astro-intlayer 9.5.5 → 9.5.6

package/README.md

@@ -201,7 +201,6 @@ Explore our comprehensive documentation to get started with Intlayer and learn h
       <li><a href="https://intlayer.org/doc/environment/astro/vue" rel=''>Vue</a></li>
       <li><a href="https://intlayer.org/doc/environment/astro/svelte" rel=''>Svelte</a></li>
       <li><a href="https://intlayer.org/doc/environment/astro/solid" rel=''>Solid</a></li>
-      <li><a href="https://intlayer.org/doc/environment/astro/vanilla" rel=''>Vanilla JS</a></li>
       <li><a href="https://intlayer.org/doc/environment/astro/lit" rel=''>Lit</a></li>
     </ul>
   </li>

package/dist/cjs/_virtual/_rolldown/runtime.cjs

@@ -0,0 +1,28 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+exports.__toESM = __toESM;

package/dist/cjs/client/localeRedirect.cjs

@@ -0,0 +1,64 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+let _intlayer_core_localization = require("@intlayer/core/localization");
+let _intlayer_config_built = require("@intlayer/config/built");
+let _intlayer_core_utils = require("@intlayer/core/utils");
+
+//#region src/client/localeRedirect.ts
+/**
+* Locale explicitly carried by a URL — path prefix, or `?locale=` in
+* `search-params` mode. `undefined` when the URL is unlocalized, which in
+* `prefix-no-default` mode means it belongs to the default locale.
+*/
+const getExplicitUrlLocale = (url) => {
+	const candidate = _intlayer_config_built.routing.mode === "search-params" ? url.searchParams.get("locale") : url.pathname.split("/")[1];
+	return candidate && _intlayer_config_built.internationalization.locales.includes(candidate) ? candidate : void 0;
+};
+/**
+* Computes where a prerendered page should send the visitor so it matches the
+* locale they stored (cookie, localStorage or sessionStorage, per
+* `routing.storage`).
+*
+* Mirrors the redirect the Intlayer proxy performs on server-rendered requests,
+* for pages served as static files where no server can read the cookie:
+* - the URL wins over storage, so a localized URL is never redirected;
+* - `routing.enableProxy: false` and `no-prefix` routing disable it;
+* - in auto mode a dev server keeps routing URL-driven, like the proxy.
+*
+* @param url - The URL of the current page.
+* @param isDevServer - Whether `astro dev` is serving the page.
+* @returns The localized URL to navigate to, or `undefined` to stay put.
+*/
+const getStoredLocaleRedirect = (url, isDevServer) => {
+	const proxyMode = (0, _intlayer_core_localization.resolveProxyMode)(_intlayer_config_built.routing.enableProxy);
+	if (proxyMode === "disabled") return;
+	if (!(0, _intlayer_core_localization.isProxyStorageLocaleEnabled)(proxyMode, isDevServer)) return;
+	if (_intlayer_config_built.routing.mode === "no-prefix") return;
+	if (getExplicitUrlLocale(url)) return;
+	const storedLocale = (0, _intlayer_core_utils.getLocaleFromStorageClient)();
+	if (!storedLocale || storedLocale === _intlayer_config_built.internationalization.defaultLocale) return;
+	const currentPath = `${url.pathname}${url.search}${url.hash}`;
+	const localizedPath = (0, _intlayer_core_localization.getLocalizedUrl)(currentPath, storedLocale);
+	return localizedPath === currentPath ? void 0 : localizedPath;
+};
+/**
+* Whether `astro dev` is serving the page. Vite inlines `import.meta.env.DEV`
+* into the client bundle; the optional chain keeps the module loadable where
+* no bundler defines it.
+*/
+const isDevServer = {}.env?.DEV === true;
+/**
+* Sends the visitor of a prerendered page to the URL of their stored locale.
+*
+* Injected on every page by the `intlayer()` integration; a no-op once the URL
+* already names a locale, so a redirected page does not redirect again.
+*/
+const redirectToStoredLocale = () => {
+	if (typeof window === "undefined") return;
+	const target = getStoredLocaleRedirect(new URL(window.location.href), isDevServer);
+	if (target) window.location.replace(target);
+};
+
+//#endregion
+exports.getStoredLocaleRedirect = getStoredLocaleRedirect;
+exports.redirectToStoredLocale = redirectToStoredLocale;
+//# sourceMappingURL=localeRedirect.cjs.map

package/dist/cjs/client/localeRedirect.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"localeRedirect.cjs","names":["routing","internationalization","resolveProxyMode","isProxyStorageLocaleEnabled","getLocaleFromStorageClient","getLocalizedUrl"],"sources":["../../../src/client/localeRedirect.ts"],"sourcesContent":["import { internationalization, routing } from '@intlayer/config/built';\nimport {\n  getLocalizedUrl,\n  isProxyStorageLocaleEnabled,\n  resolveProxyMode,\n} from '@intlayer/core/localization';\nimport { getLocaleFromStorageClient } from '@intlayer/core/utils';\nimport type { Locale } from '@intlayer/types/allLocales';\n\n/**\n * Locale explicitly carried by a URL — path prefix, or `?locale=` in\n * `search-params` mode. `undefined` when the URL is unlocalized, which in\n * `prefix-no-default` mode means it belongs to the default locale.\n */\nconst getExplicitUrlLocale = (url: URL): Locale | undefined => {\n  const candidate =\n    routing.mode === 'search-params'\n      ? url.searchParams.get('locale')\n      : url.pathname.split('/')[1];\n\n  return candidate && internationalization.locales.includes(candidate as Locale)\n    ? (candidate as Locale)\n    : undefined;\n};\n\n/**\n * Computes where a prerendered page should send the visitor so it matches the\n * locale they stored (cookie, localStorage or sessionStorage, per\n * `routing.storage`).\n *\n * Mirrors the redirect the Intlayer proxy performs on server-rendered requests,\n * for pages served as static files where no server can read the cookie:\n * - the URL wins over storage, so a localized URL is never redirected;\n * - `routing.enableProxy: false` and `no-prefix` routing disable it;\n * - in auto mode a dev server keeps routing URL-driven, like the proxy.\n *\n * @param url - The URL of the current page.\n * @param isDevServer - Whether `astro dev` is serving the page.\n * @returns The localized URL to navigate to, or `undefined` to stay put.\n */\nexport const getStoredLocaleRedirect = (\n  url: URL,\n  isDevServer: boolean\n): string | undefined => {\n  const proxyMode = resolveProxyMode(routing.enableProxy);\n\n  if (proxyMode === 'disabled') return;\n  if (!isProxyStorageLocaleEnabled(proxyMode, isDevServer)) return;\n  if (routing.mode === 'no-prefix') return;\n  if (getExplicitUrlLocale(url)) return;\n\n  const storedLocale = getLocaleFromStorageClient();\n\n  if (!storedLocale || storedLocale === internationalization.defaultLocale) {\n    return;\n  }\n\n  const currentPath = `${url.pathname}${url.search}${url.hash}`;\n  const localizedPath = getLocalizedUrl(currentPath, storedLocale);\n\n  return localizedPath === currentPath ? undefined : localizedPath;\n};\n\n/**\n * Whether `astro dev` is serving the page. Vite inlines `import.meta.env.DEV`\n * into the client bundle; the optional chain keeps the module loadable where\n * no bundler defines it.\n */\nconst isDevServer =\n  (import.meta as { env?: { DEV?: boolean } }).env?.DEV === true;\n\n/**\n * Sends the visitor of a prerendered page to the URL of their stored locale.\n *\n * Injected on every page by the `intlayer()` integration; a no-op once the URL\n * already names a locale, so a redirected page does not redirect again.\n */\nexport const redirectToStoredLocale = (): void => {\n  if (typeof window === 'undefined') return;\n\n  const target = getStoredLocaleRedirect(\n    new URL(window.location.href),\n    isDevServer\n  );\n\n  if (target) window.location.replace(target);\n};\n"],"mappings":";;;;;;;;;;;AAcA,MAAM,wBAAwB,QAAiC;CAC7D,MAAM,YACJA,+BAAQ,SAAS,kBACb,IAAI,aAAa,IAAI,QAAQ,IAC7B,IAAI,SAAS,MAAM,GAAG,CAAC,CAAC;CAE9B,OAAO,aAAaC,4CAAqB,QAAQ,SAAS,SAAmB,IACxE,YACD;AACN;;;;;;;;;;;;;;;;AAiBA,MAAa,2BACX,KACA,gBACuB;CACvB,MAAM,gBAAYC,8CAAiBF,+BAAQ,WAAW;CAEtD,IAAI,cAAc,YAAY;CAC9B,IAAI,KAACG,yDAA4B,WAAW,WAAW,GAAG;CAC1D,IAAIH,+BAAQ,SAAS,aAAa;CAClC,IAAI,qBAAqB,GAAG,GAAG;CAE/B,MAAM,mBAAeI,iDAA2B;CAEhD,IAAI,CAAC,gBAAgB,iBAAiBH,4CAAqB,eACzD;CAGF,MAAM,cAAc,GAAG,IAAI,WAAW,IAAI,SAAS,IAAI;CACvD,MAAM,oBAAgBI,6CAAgB,aAAa,YAAY;CAE/D,OAAO,kBAAkB,cAAc,SAAY;AACrD;;;;;;AAOA,MAAM,iBACyC,KAAK,QAAQ;;;;;;;AAQ5D,MAAa,+BAAqC;CAChD,IAAI,OAAO,WAAW,aAAa;CAEnC,MAAM,SAAS,wBACb,IAAI,IAAI,OAAO,SAAS,IAAI,GAC5B,WACF;CAEA,IAAI,QAAQ,OAAO,SAAS,QAAQ,MAAM;AAC5C"}

package/dist/cjs/integration.cjs

@@ -1,6 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_emitRewrittenPages = require('./emitRewrittenPages.cjs');
 let node_path = require("node:path");
+let _intlayer_core_localization = require("@intlayer/core/localization");
+let _intlayer_config_logger = require("@intlayer/config/logger");
 let _intlayer_config_node = require("@intlayer/config/node");
 let _intlayer_config_utils = require("@intlayer/config/utils");
 let _intlayer_engine_build = require("@intlayer/engine/build");
@@ -26,20 +28,28 @@ const intlayerNoExternalEnvironments = () => ({
 *    optimizations (prune).
 * 3. Configures the Vite aliases for dictionary access.
 * 4. Registers the `astro-intlayer/middleware`, which resolves the request
-*    locale into `Astro.locals.intlayer` for the hooks.
+*    locale into `Astro.locals.intlayer` for the hooks and redirects
+*    server-rendered requests to the visitor's locale.
+* 5. Injects the client-side locale redirect, which does the same for
+*    prerendered pages: served as static files, nothing else can read the
+*    stored locale there.
 *
 * The dev-time content watcher is not started here: the bundled
 * `vite-intlayer` plugin already starts one from `configureServer`, and
 * `watch()` subscribes anew on every call, so doing both would rebuild each
 * content edit twice.
 */
-const configSetup = async ({ updateConfig, addMiddleware }) => {
+const configSetup = async ({ command, updateConfig, addMiddleware, injectScript }) => {
 	const configuration = (0, _intlayer_config_node.getConfiguration)();
 	await (0, _intlayer_engine_build.prepareIntlayer)(configuration);
 	addMiddleware({
 		entrypoint: "astro-intlayer/middleware",
 		order: "pre"
 	});
+	if ((0, _intlayer_core_localization.resolveProxyMode)(configuration.routing.enableProxy) !== "disabled") {
+		injectScript("page", `import { redirectToStoredLocale } from 'astro-intlayer/client/locale-redirect';\nredirectToStoredLocale();`);
+		if (command === "preview") (0, _intlayer_config_logger.getAppLogger)(configuration)((0, _intlayer_core_localization.formatProxyEnabledMessage)(false), { level: "info" });
+	}
 	updateConfig({ vite: {
 		plugins: [(0, vite_intlayer.intlayer)(), intlayerNoExternalEnvironments()],
 		resolve: { alias: { ...(0, _intlayer_config_utils.getAlias)({

package/dist/cjs/integration.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"integration.cjs","names":["INTLAYER_NO_EXTERNAL_PATTERN","getConfiguration","prepareIntlayer","viteIntlayerPlugin","getAlias","resolve","emitRewrittenPages"],"sources":["../../src/integration.ts"],"sourcesContent":["import { resolve } from 'node:path';\nimport { getConfiguration } from '@intlayer/config/node';\nimport { getAlias } from '@intlayer/config/utils';\nimport { prepareIntlayer } from '@intlayer/engine/build';\nimport type { AstroIntegration } from 'astro';\nimport type { PluginOption } from 'vite';\nimport {\n  INTLAYER_NO_EXTERNAL_PATTERN,\n  intlayer as viteIntlayerPlugin,\n} from 'vite-intlayer';\nimport { emitRewrittenPages } from './emitRewrittenPages';\n\n/**\n * Keeps the intlayer packages out of Node's native module loader in *every*\n * Vite environment Astro renders from.\n *\n * A static dev server renders from `ssr`, but other setups render from Astro's\n * `astro` or `prerender` environments, and a top-level `ssr.noExternal` only\n * seeds the `ssr` one. Declaring it per environment covers the rest.\n */\nconst intlayerNoExternalEnvironments = (): PluginOption => ({\n  name: 'astro-intlayer-no-external',\n  configEnvironment: () => ({\n    resolve: { noExternal: [INTLAYER_NO_EXTERNAL_PATTERN] },\n  }),\n});\n\n/**\n * Node-only half of the integration, loaded lazily by the `astro-intlayer`\n * entry when a hook runs.\n *\n * Pages import their hooks from that same entry, and Astro bundles the whole\n * package into the server build (`ssr.noExternal`), so the config loader,\n * `@intlayer/engine` and `vite-intlayer` must stay behind a dynamic import:\n * a static one would put them in the module graph of every page.\n */\n\ntype ConfigSetupOptions = Parameters<\n  NonNullable<AstroIntegration['hooks']['astro:config:setup']>\n>[0];\n\ntype BuildDoneOptions = Parameters<\n  NonNullable<AstroIntegration['hooks']['astro:build:done']>\n>[0];\n\n/**\n * `astro:config:setup`:\n * 1. Prepares the Intlayer resources (dictionaries).\n * 2. Injects the Vite plugins for aliases, locale-based routing and build\n *    optimizations (prune).\n * 3. Configures the Vite aliases for dictionary access.\n * 4. Registers the `astro-intlayer/middleware`, which resolves the request\n *    locale into `Astro.locals.intlayer` for the hooks.\n *\n * The dev-time content watcher is not started here: the bundled\n * `vite-intlayer` plugin already starts one from `configureServer`, and\n * `watch()` subscribes anew on every call, so doing both would rebuild each\n * content edit twice.\n */\nexport const configSetup = async ({\n  updateConfig,\n  addMiddleware,\n}: ConfigSetupOptions): Promise<void> => {\n  const configuration = getConfiguration();\n\n  // Prepare once per process start to ensure generated entries exist\n  await prepareIntlayer(configuration);\n\n  // Runs before the user middleware so `Astro.locals.intlayer` is set\n  // everywhere, including in a hand-written `src/middleware.ts`.\n  addMiddleware({\n    entrypoint: 'astro-intlayer/middleware',\n    order: 'pre',\n  });\n\n  updateConfig({\n    vite: {\n      plugins: [\n        viteIntlayerPlugin(),\n        intlayerNoExternalEnvironments(),\n      ] as PluginOption[],\n      resolve: {\n        alias: {\n          ...getAlias({\n            configuration,\n            formatter: (value) => resolve(value),\n          }),\n        },\n      },\n      // `astro-intlayer` is tagged with the `astro` keyword, so Astro\n      // treats it as an Astro package and crawls its dependency tree\n      // (`vitefu`), force-externalizing every dependency it finds —\n      // `@intlayer/core`, `@intlayer/config`, … — into\n      // `resolve.external`. Vite checks `external` before `noExternal`,\n      // so the `ssr.noExternal` that `vite-intlayer` returns from its\n      // Vite `config` hook loses that race and the packages are loaded\n      // natively by Node, stranding dictionary edits behind Node's\n      // require cache. Declaring it here instead runs before the crawl,\n      // which drops explicitly no-externalized packages from its result.\n      ssr: {\n        noExternal: [INTLAYER_NO_EXTERNAL_PATTERN],\n      },\n    },\n  });\n};\n\n/**\n * `astro:build:done`: Astro renders each page from its canonical file-system\n * route, so a static build has no file for the localized paths declared in\n * `routing.rewrite`. Mirror them here, otherwise the URLs produced by\n * `getLocalizedUrl` (links, hreflang, sitemap) 404 once deployed.\n */\nexport const buildDone = async ({\n  dir,\n  logger,\n}: BuildDoneOptions): Promise<void> => {\n  const configuration = getConfiguration();\n\n  const emittedPages = await emitRewrittenPages(configuration, dir);\n\n  if (emittedPages.length > 0) {\n    logger.info(\n      `Emitted ${emittedPages.length} rewritten page(s): ${emittedPages\n        .map(([from, to]) => `${from} \\u2192 ${to}`)\n        .join(', ')}`\n    );\n  }\n};\n"],"mappings":";;;;;;;;;;;;;;;;;AAoBA,MAAM,wCAAsD;CAC1D,MAAM;CACN,0BAA0B,EACxB,SAAS,EAAE,YAAY,CAACA,0CAA4B,EAAE,EACxD;AACF;;;;;;;;;;;;;;;AAkCA,MAAa,cAAc,OAAO,EAChC,cACA,oBACuC;CACvC,MAAM,oBAAgBC,wCAAiB;CAGvC,UAAMC,wCAAgB,aAAa;CAInC,cAAc;EACZ,YAAY;EACZ,OAAO;CACT,CAAC;CAED,aAAa,EACX,MAAM;EACJ,SAAS,KACPC,wBAAmB,GACnB,+BAA+B,CACjC;EACA,SAAS,EACP,OAAO,EACL,OAAGC,iCAAS;GACV;GACA,YAAY,cAAUC,mBAAQ,KAAK;EACrC,CAAC,EACH,EACF;EAWA,KAAK,EACH,YAAY,CAACL,0CAA4B,EAC3C;CACF,EACF,CAAC;AACH;;;;;;;AAQA,MAAa,YAAY,OAAO,EAC9B,KACA,aACqC;CACrC,MAAM,oBAAgBC,wCAAiB;CAEvC,MAAM,eAAe,MAAMK,8CAAmB,eAAe,GAAG;CAEhE,IAAI,aAAa,SAAS,GACxB,OAAO,KACL,WAAW,aAAa,OAAO,sBAAsB,aAClD,KAAK,CAAC,MAAM,QAAQ,GAAG,KAAK,UAAU,IAAI,CAAC,CAC3C,KAAK,IAAI,GACd;AAEJ"}
+{"version":3,"file":"integration.cjs","names":["INTLAYER_NO_EXTERNAL_PATTERN","getConfiguration","prepareIntlayer","resolveProxyMode","formatProxyEnabledMessage","viteIntlayerPlugin","getAlias","resolve","emitRewrittenPages"],"sources":["../../src/integration.ts"],"sourcesContent":["import { resolve } from 'node:path';\nimport { getAppLogger } from '@intlayer/config/logger';\nimport { getConfiguration } from '@intlayer/config/node';\nimport { getAlias } from '@intlayer/config/utils';\nimport {\n  formatProxyEnabledMessage,\n  resolveProxyMode,\n} from '@intlayer/core/localization';\nimport { prepareIntlayer } from '@intlayer/engine/build';\nimport type { AstroIntegration } from 'astro';\nimport type { PluginOption } from 'vite';\nimport {\n  INTLAYER_NO_EXTERNAL_PATTERN,\n  intlayer as viteIntlayerPlugin,\n} from 'vite-intlayer';\nimport { emitRewrittenPages } from './emitRewrittenPages';\n\n/**\n * Keeps the intlayer packages out of Node's native module loader in *every*\n * Vite environment Astro renders from.\n *\n * A static dev server renders from `ssr`, but other setups render from Astro's\n * `astro` or `prerender` environments, and a top-level `ssr.noExternal` only\n * seeds the `ssr` one. Declaring it per environment covers the rest.\n */\nconst intlayerNoExternalEnvironments = (): PluginOption => ({\n  name: 'astro-intlayer-no-external',\n  configEnvironment: () => ({\n    resolve: { noExternal: [INTLAYER_NO_EXTERNAL_PATTERN] },\n  }),\n});\n\n/**\n * Node-only half of the integration, loaded lazily by the `astro-intlayer`\n * entry when a hook runs.\n *\n * Pages import their hooks from that same entry, and Astro bundles the whole\n * package into the server build (`ssr.noExternal`), so the config loader,\n * `@intlayer/engine` and `vite-intlayer` must stay behind a dynamic import:\n * a static one would put them in the module graph of every page.\n */\n\ntype ConfigSetupOptions = Parameters<\n  NonNullable<AstroIntegration['hooks']['astro:config:setup']>\n>[0];\n\ntype BuildDoneOptions = Parameters<\n  NonNullable<AstroIntegration['hooks']['astro:build:done']>\n>[0];\n\n/**\n * `astro:config:setup`:\n * 1. Prepares the Intlayer resources (dictionaries).\n * 2. Injects the Vite plugins for aliases, locale-based routing and build\n *    optimizations (prune).\n * 3. Configures the Vite aliases for dictionary access.\n * 4. Registers the `astro-intlayer/middleware`, which resolves the request\n *    locale into `Astro.locals.intlayer` for the hooks and redirects\n *    server-rendered requests to the visitor's locale.\n * 5. Injects the client-side locale redirect, which does the same for\n *    prerendered pages: served as static files, nothing else can read the\n *    stored locale there.\n *\n * The dev-time content watcher is not started here: the bundled\n * `vite-intlayer` plugin already starts one from `configureServer`, and\n * `watch()` subscribes anew on every call, so doing both would rebuild each\n * content edit twice.\n */\nexport const configSetup = async ({\n  command,\n  updateConfig,\n  addMiddleware,\n  injectScript,\n}: ConfigSetupOptions): Promise<void> => {\n  const configuration = getConfiguration();\n\n  // Prepare once per process start to ensure generated entries exist\n  await prepareIntlayer(configuration);\n\n  // Runs before the user middleware so `Astro.locals.intlayer` is set\n  // everywhere, including in a hand-written `src/middleware.ts`.\n  addMiddleware({\n    entrypoint: 'astro-intlayer/middleware',\n    order: 'pre',\n  });\n\n  const proxyMode = resolveProxyMode(configuration.routing.enableProxy);\n\n  if (proxyMode !== 'disabled') {\n    injectScript(\n      'page',\n      `import { redirectToStoredLocale } from 'astro-intlayer/client/locale-redirect';\\nredirectToStoredLocale();`\n    );\n\n    // `dev` and `build` are announced by the bundled `vite-intlayer` plugin.\n    // `astro preview` runs no Vite plugin, so the served output is announced\n    // here: the stored locale drives redirects again once the output is\n    // served — by the middleware on server-rendered pages, by the injected\n    // script on static ones.\n    if (command === 'preview') {\n      getAppLogger(configuration)(formatProxyEnabledMessage(false), {\n        level: 'info',\n      });\n    }\n  }\n\n  updateConfig({\n    vite: {\n      plugins: [\n        viteIntlayerPlugin(),\n        intlayerNoExternalEnvironments(),\n      ] as PluginOption[],\n      resolve: {\n        alias: {\n          ...getAlias({\n            configuration,\n            formatter: (value) => resolve(value),\n          }),\n        },\n      },\n      // `astro-intlayer` is tagged with the `astro` keyword, so Astro\n      // treats it as an Astro package and crawls its dependency tree\n      // (`vitefu`), force-externalizing every dependency it finds —\n      // `@intlayer/core`, `@intlayer/config`, … — into\n      // `resolve.external`. Vite checks `external` before `noExternal`,\n      // so the `ssr.noExternal` that `vite-intlayer` returns from its\n      // Vite `config` hook loses that race and the packages are loaded\n      // natively by Node, stranding dictionary edits behind Node's\n      // require cache. Declaring it here instead runs before the crawl,\n      // which drops explicitly no-externalized packages from its result.\n      ssr: {\n        noExternal: [INTLAYER_NO_EXTERNAL_PATTERN],\n      },\n    },\n  });\n};\n\n/**\n * `astro:build:done`: Astro renders each page from its canonical file-system\n * route, so a static build has no file for the localized paths declared in\n * `routing.rewrite`. Mirror them here, otherwise the URLs produced by\n * `getLocalizedUrl` (links, hreflang, sitemap) 404 once deployed.\n */\nexport const buildDone = async ({\n  dir,\n  logger,\n}: BuildDoneOptions): Promise<void> => {\n  const configuration = getConfiguration();\n\n  const emittedPages = await emitRewrittenPages(configuration, dir);\n\n  if (emittedPages.length > 0) {\n    logger.info(\n      `Emitted ${emittedPages.length} rewritten page(s): ${emittedPages\n        .map(([from, to]) => `${from} \\u2192 ${to}`)\n        .join(', ')}`\n    );\n  }\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAyBA,MAAM,wCAAsD;CAC1D,MAAM;CACN,0BAA0B,EACxB,SAAS,EAAE,YAAY,CAACA,0CAA4B,EAAE,EACxD;AACF;;;;;;;;;;;;;;;;;;;AAsCA,MAAa,cAAc,OAAO,EAChC,SACA,cACA,eACA,mBACuC;CACvC,MAAM,oBAAgBC,wCAAiB;CAGvC,UAAMC,wCAAgB,aAAa;CAInC,cAAc;EACZ,YAAY;EACZ,OAAO;CACT,CAAC;CAID,QAFkBC,8CAAiB,cAAc,QAAQ,WAE7C,MAAM,YAAY;EAC5B,aACE,QACA,4GACF;EAOA,IAAI,YAAY,WACd,0CAAa,aAAa,CAAC,KAACC,uDAA0B,KAAK,GAAG,EAC5D,OAAO,OACT,CAAC;CAEL;CAEA,aAAa,EACX,MAAM;EACJ,SAAS,KACPC,wBAAmB,GACnB,+BAA+B,CACjC;EACA,SAAS,EACP,OAAO,EACL,OAAGC,iCAAS;GACV;GACA,YAAY,cAAUC,mBAAQ,KAAK;EACrC,CAAC,EACH,EACF;EAWA,KAAK,EACH,YAAY,CAACP,0CAA4B,EAC3C;CACF,EACF,CAAC;AACH;;;;;;;AAQA,MAAa,YAAY,OAAO,EAC9B,KACA,aACqC;CACrC,MAAM,oBAAgBC,wCAAiB;CAEvC,MAAM,eAAe,MAAMO,8CAAmB,eAAe,GAAG;CAEhE,IAAI,aAAa,SAAS,GACxB,OAAO,KACL,WAAW,aAAa,OAAO,sBAAsB,aAClD,KAAK,CAAC,MAAM,QAAQ,GAAG,KAAK,UAAU,IAAI,CAAC,CAC3C,KAAK,IAAI,GACd;AAEJ"}

package/dist/cjs/middleware.cjs

@@ -1,16 +1,66 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
 const require_requestStorage = require('./requestStorage.cjs');
 let _intlayer_core_localization = require("@intlayer/core/localization");
 let _intlayer_config_built = require("@intlayer/config/built");
+_intlayer_config_built = require_runtime.__toESM(_intlayer_config_built);
+let vite_intlayer_web_proxy_handler = require("vite-intlayer/web-proxy-handler");
 
 //#region src/middleware.ts
 /**
+* Whether `astro dev` is serving the app. Vite inlines `import.meta.env.DEV`
+* into the server bundle; the optional chain keeps the module loadable where
+* no bundler defines it (`process.env.NODE_ENV` cannot be used instead: the
+* package build inlines it).
+*/
+const isDevServer = {}.env?.DEV === true;
+const configuration = _intlayer_config_built;
+const { internationalization, routing } = configuration;
+/**
+* Locale-routing proxy shared with the Vite dev server and the Nitro handler.
+*
+* `undefined` when `routing.enableProxy` is `false`. In auto mode (option
+* unset) `astro dev` keeps routing URL-driven: the stored locale is not a
+* redirect source, exactly like the Vite proxy mounted on the same dev server,
+* so the two never disagree.
+*/
+const proxy = (0, _intlayer_core_localization.resolveProxyMode)(routing.enableProxy) === "disabled" ? void 0 : (0, vite_intlayer_web_proxy_handler.createIntlayerWebProxyHandler)({
+	configuration,
+	isDevServer
+});
+/**
+* Appends the headers the proxy produced (the persisted locale cookie) to the
+* rendered response. Some responses ship immutable headers, in which case the
+* body is re-wrapped in a fresh `Response`.
+*/
+const withProxyHeaders = (response, headers) => {
+	const entries = [...headers];
+	if (entries.length === 0) return response;
+	const applyHeaders = (target) => {
+		for (const [name, value] of entries) target.headers.append(name, value);
+		return target;
+	};
+	try {
+		return applyHeaders(response);
+	} catch {
+		return applyHeaders(new Response(response.body, response));
+	}
+};
+/**
 * Astro middleware resolving the request locale into `Astro.locals.intlayer`.
 *
 * Priority: the URL (path prefix or `?locale=` search param, in every routing
 * mode but `no-prefix`), then the locale persisted by the client (cookie or
 * custom header), then `Accept-Language` negotiation.
 *
+* On server-rendered requests it also runs the Intlayer locale-routing proxy,
+* so a visitor whose stored locale is `fr` is redirected from `/` to `/fr`
+* (per `routing.mode`) and the resolved locale is persisted on the response.
+* Only redirects are honoured: the proxy's internal rewrites target
+* prefix-based routers, while Astro pages already resolve the locale from the
+* URL they are rendered for. Prerendered pages are served as static files, so
+* nothing can redirect them at request time and the proxy is skipped.
+*
 * The `intlayer()` integration registers it automatically, before the user
 * middleware, so `Astro.locals.intlayer` is available in every page, endpoint
 * and middleware. The rest of the request renders inside an
@@ -27,15 +77,25 @@ let _intlayer_config_built = require("@intlayer/config/built");
 * ```
 */
 const onRequest = async (context, next) => {
+	let proxyOutcome;
+	if (proxy && !context.isPrerendered) {
+		const outcome = proxy({
+			url: context.url,
+			headers: context.request.headers
+		});
+		if (outcome.kind === "response") return outcome.response;
+		proxyOutcome = outcome;
+	}
 	context.locals.intlayer = {
 		locale: await (0, _intlayer_core_localization.getLocaleFromRequest)({
 			url: context.url,
 			headers: context.isPrerendered ? new Headers() : context.request.headers
 		}),
-		defaultLocale: _intlayer_config_built.internationalization.defaultLocale,
-		availableLocales: _intlayer_config_built.internationalization.locales
+		defaultLocale: internationalization.defaultLocale,
+		availableLocales: internationalization.locales
 	};
-	return require_requestStorage.requestStorage.run(context.locals, next);
+	const response = await require_requestStorage.requestStorage.run(context.locals, next);
+	return proxyOutcome ? withProxyHeaders(response, proxyOutcome.headers) : response;
 };
 
 //#endregion

package/dist/cjs/middleware.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"middleware.cjs","names":["getLocaleFromRequest","internationalization","requestStorage"],"sources":["../../src/middleware.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport { getLocaleFromRequest } from '@intlayer/core/localization';\nimport type { DeclaredLocales } from '@intlayer/types/module_augmentation';\nimport type { MiddlewareHandler } from 'astro';\nimport { requestStorage } from './requestStorage';\n\n/**\n * Intlayer state stored in `Astro.locals.intlayer` by the {@link onRequest} middleware.\n */\nexport type IntlayerLocals = {\n  /** Locale resolved for the current request. */\n  locale: DeclaredLocales;\n  /** Locale configured as fallback in `intlayer.config.ts`. */\n  defaultLocale: DeclaredLocales;\n  /** Every locale declared in `intlayer.config.ts`. */\n  availableLocales: DeclaredLocales[];\n};\n\ndeclare global {\n  namespace App {\n    interface Locals {\n      intlayer: IntlayerLocals;\n    }\n  }\n}\n\n/**\n * Astro middleware resolving the request locale into `Astro.locals.intlayer`.\n *\n * Priority: the URL (path prefix or `?locale=` search param, in every routing\n * mode but `no-prefix`), then the locale persisted by the client (cookie or\n * custom header), then `Accept-Language` negotiation.\n *\n * The `intlayer()` integration registers it automatically, before the user\n * middleware, so `Astro.locals.intlayer` is available in every page, endpoint\n * and middleware. The rest of the request renders inside an\n * `AsyncLocalStorage` scope bound to those locals, which is how the hooks of\n * `astro-intlayer/server` read the locale with no argument.\n *\n * @example\n * ```ts\n * // src/middleware.ts — only needed when composing it by hand\n * import { onRequest as intlayer } from 'astro-intlayer/middleware';\n * import { sequence } from 'astro:middleware';\n *\n * export const onRequest = sequence(intlayer, myMiddleware);\n * ```\n */\nexport const onRequest: MiddlewareHandler = async (context, next) => {\n  context.locals.intlayer = {\n    locale: await getLocaleFromRequest({\n      url: context.url,\n      // A prerendered page is rendered once and served to every visitor, so\n      // its locale can only come from the URL. Reading the request headers\n      // there would also make Astro warn on every page of the build.\n      headers: context.isPrerendered ? new Headers() : context.request.headers,\n    }),\n    defaultLocale: internationalization.defaultLocale as DeclaredLocales,\n    availableLocales: internationalization.locales as DeclaredLocales[],\n  };\n\n  return requestStorage.run(context.locals, next);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDA,MAAa,YAA+B,OAAO,SAAS,SAAS;CACnE,QAAQ,OAAO,WAAW;EACxB,QAAQ,UAAMA,kDAAqB;GACjC,KAAK,QAAQ;GAIb,SAAS,QAAQ,gBAAgB,IAAI,QAAQ,IAAI,QAAQ,QAAQ;EACnE,CAAC;EACD,eAAeC,4CAAqB;EACpC,kBAAkBA,4CAAqB;CACzC;CAEA,OAAOC,sCAAe,IAAI,QAAQ,QAAQ,IAAI;AAChD"}
+{"version":3,"file":"middleware.cjs","names":["builtConfiguration","resolveProxyMode","createIntlayerWebProxyHandler","getLocaleFromRequest","requestStorage"],"sources":["../../src/middleware.ts"],"sourcesContent":["import * as builtConfiguration from '@intlayer/config/built';\nimport {\n  getLocaleFromRequest,\n  resolveProxyMode,\n} from '@intlayer/core/localization';\nimport type { IntlayerConfig } from '@intlayer/types/config';\nimport type { DeclaredLocales } from '@intlayer/types/module_augmentation';\nimport type { MiddlewareHandler } from 'astro';\nimport {\n  createIntlayerWebProxyHandler,\n  type WebProxyOutcome,\n} from 'vite-intlayer/web-proxy-handler';\nimport { requestStorage } from './requestStorage';\n\n/** Proxy outcome letting the request continue to the page. */\ntype WebProxyNextOutcome = Extract<WebProxyOutcome, { kind: 'next' }>;\n\n/**\n * Whether `astro dev` is serving the app. Vite inlines `import.meta.env.DEV`\n * into the server bundle; the optional chain keeps the module loadable where\n * no bundler defines it (`process.env.NODE_ENV` cannot be used instead: the\n * package build inlines it).\n */\nconst isDevServer =\n  (import.meta as { env?: { DEV?: boolean } }).env?.DEV === true;\n\nconst configuration = builtConfiguration as unknown as IntlayerConfig;\nconst { internationalization, routing } = configuration;\n\n/**\n * Locale-routing proxy shared with the Vite dev server and the Nitro handler.\n *\n * `undefined` when `routing.enableProxy` is `false`. In auto mode (option\n * unset) `astro dev` keeps routing URL-driven: the stored locale is not a\n * redirect source, exactly like the Vite proxy mounted on the same dev server,\n * so the two never disagree.\n */\nconst proxy =\n  resolveProxyMode(routing.enableProxy) === 'disabled'\n    ? undefined\n    : createIntlayerWebProxyHandler({\n        configuration,\n        isDevServer,\n      });\n\n/**\n * Appends the headers the proxy produced (the persisted locale cookie) to the\n * rendered response. Some responses ship immutable headers, in which case the\n * body is re-wrapped in a fresh `Response`.\n */\nconst withProxyHeaders = (response: Response, headers: Headers): Response => {\n  const entries = [...headers];\n  if (entries.length === 0) return response;\n\n  const applyHeaders = (target: Response) => {\n    for (const [name, value] of entries) {\n      target.headers.append(name, value);\n    }\n    return target;\n  };\n\n  try {\n    return applyHeaders(response);\n  } catch {\n    return applyHeaders(new Response(response.body, response));\n  }\n};\n\n/**\n * Intlayer state stored in `Astro.locals.intlayer` by the {@link onRequest} middleware.\n */\nexport type IntlayerLocals = {\n  /** Locale resolved for the current request. */\n  locale: DeclaredLocales;\n  /** Locale configured as fallback in `intlayer.config.ts`. */\n  defaultLocale: DeclaredLocales;\n  /** Every locale declared in `intlayer.config.ts`. */\n  availableLocales: DeclaredLocales[];\n};\n\ndeclare global {\n  namespace App {\n    interface Locals {\n      intlayer: IntlayerLocals;\n    }\n  }\n}\n\n/**\n * Astro middleware resolving the request locale into `Astro.locals.intlayer`.\n *\n * Priority: the URL (path prefix or `?locale=` search param, in every routing\n * mode but `no-prefix`), then the locale persisted by the client (cookie or\n * custom header), then `Accept-Language` negotiation.\n *\n * On server-rendered requests it also runs the Intlayer locale-routing proxy,\n * so a visitor whose stored locale is `fr` is redirected from `/` to `/fr`\n * (per `routing.mode`) and the resolved locale is persisted on the response.\n * Only redirects are honoured: the proxy's internal rewrites target\n * prefix-based routers, while Astro pages already resolve the locale from the\n * URL they are rendered for. Prerendered pages are served as static files, so\n * nothing can redirect them at request time and the proxy is skipped.\n *\n * The `intlayer()` integration registers it automatically, before the user\n * middleware, so `Astro.locals.intlayer` is available in every page, endpoint\n * and middleware. The rest of the request renders inside an\n * `AsyncLocalStorage` scope bound to those locals, which is how the hooks of\n * `astro-intlayer/server` read the locale with no argument.\n *\n * @example\n * ```ts\n * // src/middleware.ts — only needed when composing it by hand\n * import { onRequest as intlayer } from 'astro-intlayer/middleware';\n * import { sequence } from 'astro:middleware';\n *\n * export const onRequest = sequence(intlayer, myMiddleware);\n * ```\n */\nexport const onRequest: MiddlewareHandler = async (context, next) => {\n  let proxyOutcome: WebProxyNextOutcome | undefined;\n\n  if (proxy && !context.isPrerendered) {\n    const outcome = proxy({\n      url: context.url,\n      headers: context.request.headers,\n    });\n\n    if (outcome.kind === 'response') return outcome.response;\n    proxyOutcome = outcome;\n  }\n\n  context.locals.intlayer = {\n    locale: await getLocaleFromRequest({\n      url: context.url,\n      // A prerendered page is rendered once and served to every visitor, so\n      // its locale can only come from the URL. Reading the request headers\n      // there would also make Astro warn on every page of the build.\n      headers: context.isPrerendered ? new Headers() : context.request.headers,\n    }),\n    defaultLocale: internationalization.defaultLocale as DeclaredLocales,\n    availableLocales: internationalization.locales as DeclaredLocales[],\n  };\n\n  const response = await requestStorage.run(context.locals, next);\n\n  return proxyOutcome\n    ? withProxyHeaders(response, proxyOutcome.headers)\n    : response;\n};\n"],"mappings":";;;;;;;;;;;;;;;AAuBA,MAAM,iBACyC,KAAK,QAAQ;AAE5D,MAAM,gBAAgBA;AACtB,MAAM,EAAE,sBAAsB,YAAY;;;;;;;;;AAU1C,MAAM,YACJC,8CAAiB,QAAQ,WAAW,MAAM,aACtC,aACAC,+DAA8B;CAC5B;CACA;AACF,CAAC;;;;;;AAOP,MAAM,oBAAoB,UAAoB,YAA+B;CAC3E,MAAM,UAAU,CAAC,GAAG,OAAO;CAC3B,IAAI,QAAQ,WAAW,GAAG,OAAO;CAEjC,MAAM,gBAAgB,WAAqB;EACzC,KAAK,MAAM,CAAC,MAAM,UAAU,SAC1B,OAAO,QAAQ,OAAO,MAAM,KAAK;EAEnC,OAAO;CACT;CAEA,IAAI;EACF,OAAO,aAAa,QAAQ;CAC9B,QAAQ;EACN,OAAO,aAAa,IAAI,SAAS,SAAS,MAAM,QAAQ,CAAC;CAC3D;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoDA,MAAa,YAA+B,OAAO,SAAS,SAAS;CACnE,IAAI;CAEJ,IAAI,SAAS,CAAC,QAAQ,eAAe;EACnC,MAAM,UAAU,MAAM;GACpB,KAAK,QAAQ;GACb,SAAS,QAAQ,QAAQ;EAC3B,CAAC;EAED,IAAI,QAAQ,SAAS,YAAY,OAAO,QAAQ;EAChD,eAAe;CACjB;CAEA,QAAQ,OAAO,WAAW;EACxB,QAAQ,UAAMC,kDAAqB;GACjC,KAAK,QAAQ;GAIb,SAAS,QAAQ,gBAAgB,IAAI,QAAQ,IAAI,QAAQ,QAAQ;EACnE,CAAC;EACD,eAAe,qBAAqB;EACpC,kBAAkB,qBAAqB;CACzC;CAEA,MAAM,WAAW,MAAMC,sCAAe,IAAI,QAAQ,QAAQ,IAAI;CAE9D,OAAO,eACH,iBAAiB,UAAU,aAAa,OAAO,IAC/C;AACN"}

package/dist/esm/client/localeRedirect.mjs

@@ -0,0 +1,62 @@
+import { getLocalizedUrl, isProxyStorageLocaleEnabled, resolveProxyMode } from "@intlayer/core/localization";
+import { internationalization, routing } from "@intlayer/config/built";
+import { getLocaleFromStorageClient } from "@intlayer/core/utils";
+
+//#region src/client/localeRedirect.ts
+/**
+* Locale explicitly carried by a URL — path prefix, or `?locale=` in
+* `search-params` mode. `undefined` when the URL is unlocalized, which in
+* `prefix-no-default` mode means it belongs to the default locale.
+*/
+const getExplicitUrlLocale = (url) => {
+	const candidate = routing.mode === "search-params" ? url.searchParams.get("locale") : url.pathname.split("/")[1];
+	return candidate && internationalization.locales.includes(candidate) ? candidate : void 0;
+};
+/**
+* Computes where a prerendered page should send the visitor so it matches the
+* locale they stored (cookie, localStorage or sessionStorage, per
+* `routing.storage`).
+*
+* Mirrors the redirect the Intlayer proxy performs on server-rendered requests,
+* for pages served as static files where no server can read the cookie:
+* - the URL wins over storage, so a localized URL is never redirected;
+* - `routing.enableProxy: false` and `no-prefix` routing disable it;
+* - in auto mode a dev server keeps routing URL-driven, like the proxy.
+*
+* @param url - The URL of the current page.
+* @param isDevServer - Whether `astro dev` is serving the page.
+* @returns The localized URL to navigate to, or `undefined` to stay put.
+*/
+const getStoredLocaleRedirect = (url, isDevServer) => {
+	const proxyMode = resolveProxyMode(routing.enableProxy);
+	if (proxyMode === "disabled") return;
+	if (!isProxyStorageLocaleEnabled(proxyMode, isDevServer)) return;
+	if (routing.mode === "no-prefix") return;
+	if (getExplicitUrlLocale(url)) return;
+	const storedLocale = getLocaleFromStorageClient();
+	if (!storedLocale || storedLocale === internationalization.defaultLocale) return;
+	const currentPath = `${url.pathname}${url.search}${url.hash}`;
+	const localizedPath = getLocalizedUrl(currentPath, storedLocale);
+	return localizedPath === currentPath ? void 0 : localizedPath;
+};
+/**
+* Whether `astro dev` is serving the page. Vite inlines `import.meta.env.DEV`
+* into the client bundle; the optional chain keeps the module loadable where
+* no bundler defines it.
+*/
+const isDevServer = import.meta.env?.DEV === true;
+/**
+* Sends the visitor of a prerendered page to the URL of their stored locale.
+*
+* Injected on every page by the `intlayer()` integration; a no-op once the URL
+* already names a locale, so a redirected page does not redirect again.
+*/
+const redirectToStoredLocale = () => {
+	if (typeof window === "undefined") return;
+	const target = getStoredLocaleRedirect(new URL(window.location.href), isDevServer);
+	if (target) window.location.replace(target);
+};
+
+//#endregion
+export { getStoredLocaleRedirect, redirectToStoredLocale };
+//# sourceMappingURL=localeRedirect.mjs.map

package/dist/esm/client/localeRedirect.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"localeRedirect.mjs","names":[],"sources":["../../../src/client/localeRedirect.ts"],"sourcesContent":["import { internationalization, routing } from '@intlayer/config/built';\nimport {\n  getLocalizedUrl,\n  isProxyStorageLocaleEnabled,\n  resolveProxyMode,\n} from '@intlayer/core/localization';\nimport { getLocaleFromStorageClient } from '@intlayer/core/utils';\nimport type { Locale } from '@intlayer/types/allLocales';\n\n/**\n * Locale explicitly carried by a URL — path prefix, or `?locale=` in\n * `search-params` mode. `undefined` when the URL is unlocalized, which in\n * `prefix-no-default` mode means it belongs to the default locale.\n */\nconst getExplicitUrlLocale = (url: URL): Locale | undefined => {\n  const candidate =\n    routing.mode === 'search-params'\n      ? url.searchParams.get('locale')\n      : url.pathname.split('/')[1];\n\n  return candidate && internationalization.locales.includes(candidate as Locale)\n    ? (candidate as Locale)\n    : undefined;\n};\n\n/**\n * Computes where a prerendered page should send the visitor so it matches the\n * locale they stored (cookie, localStorage or sessionStorage, per\n * `routing.storage`).\n *\n * Mirrors the redirect the Intlayer proxy performs on server-rendered requests,\n * for pages served as static files where no server can read the cookie:\n * - the URL wins over storage, so a localized URL is never redirected;\n * - `routing.enableProxy: false` and `no-prefix` routing disable it;\n * - in auto mode a dev server keeps routing URL-driven, like the proxy.\n *\n * @param url - The URL of the current page.\n * @param isDevServer - Whether `astro dev` is serving the page.\n * @returns The localized URL to navigate to, or `undefined` to stay put.\n */\nexport const getStoredLocaleRedirect = (\n  url: URL,\n  isDevServer: boolean\n): string | undefined => {\n  const proxyMode = resolveProxyMode(routing.enableProxy);\n\n  if (proxyMode === 'disabled') return;\n  if (!isProxyStorageLocaleEnabled(proxyMode, isDevServer)) return;\n  if (routing.mode === 'no-prefix') return;\n  if (getExplicitUrlLocale(url)) return;\n\n  const storedLocale = getLocaleFromStorageClient();\n\n  if (!storedLocale || storedLocale === internationalization.defaultLocale) {\n    return;\n  }\n\n  const currentPath = `${url.pathname}${url.search}${url.hash}`;\n  const localizedPath = getLocalizedUrl(currentPath, storedLocale);\n\n  return localizedPath === currentPath ? undefined : localizedPath;\n};\n\n/**\n * Whether `astro dev` is serving the page. Vite inlines `import.meta.env.DEV`\n * into the client bundle; the optional chain keeps the module loadable where\n * no bundler defines it.\n */\nconst isDevServer =\n  (import.meta as { env?: { DEV?: boolean } }).env?.DEV === true;\n\n/**\n * Sends the visitor of a prerendered page to the URL of their stored locale.\n *\n * Injected on every page by the `intlayer()` integration; a no-op once the URL\n * already names a locale, so a redirected page does not redirect again.\n */\nexport const redirectToStoredLocale = (): void => {\n  if (typeof window === 'undefined') return;\n\n  const target = getStoredLocaleRedirect(\n    new URL(window.location.href),\n    isDevServer\n  );\n\n  if (target) window.location.replace(target);\n};\n"],"mappings":";;;;;;;;;;AAcA,MAAM,wBAAwB,QAAiC;CAC7D,MAAM,YACJ,QAAQ,SAAS,kBACb,IAAI,aAAa,IAAI,QAAQ,IAC7B,IAAI,SAAS,MAAM,GAAG,CAAC,CAAC;CAE9B,OAAO,aAAa,qBAAqB,QAAQ,SAAS,SAAmB,IACxE,YACD;AACN;;;;;;;;;;;;;;;;AAiBA,MAAa,2BACX,KACA,gBACuB;CACvB,MAAM,YAAY,iBAAiB,QAAQ,WAAW;CAEtD,IAAI,cAAc,YAAY;CAC9B,IAAI,CAAC,4BAA4B,WAAW,WAAW,GAAG;CAC1D,IAAI,QAAQ,SAAS,aAAa;CAClC,IAAI,qBAAqB,GAAG,GAAG;CAE/B,MAAM,eAAe,2BAA2B;CAEhD,IAAI,CAAC,gBAAgB,iBAAiB,qBAAqB,eACzD;CAGF,MAAM,cAAc,GAAG,IAAI,WAAW,IAAI,SAAS,IAAI;CACvD,MAAM,gBAAgB,gBAAgB,aAAa,YAAY;CAE/D,OAAO,kBAAkB,cAAc,SAAY;AACrD;;;;;;AAOA,MAAM,cACH,YAA4C,KAAK,QAAQ;;;;;;;AAQ5D,MAAa,+BAAqC;CAChD,IAAI,OAAO,WAAW,aAAa;CAEnC,MAAM,SAAS,wBACb,IAAI,IAAI,OAAO,SAAS,IAAI,GAC5B,WACF;CAEA,IAAI,QAAQ,OAAO,SAAS,QAAQ,MAAM;AAC5C"}

package/dist/esm/integration.mjs

@@ -1,5 +1,7 @@
 import { emitRewrittenPages } from "./emitRewrittenPages.mjs";
 import { resolve } from "node:path";
+import { formatProxyEnabledMessage, resolveProxyMode } from "@intlayer/core/localization";
+import { getAppLogger } from "@intlayer/config/logger";
 import { getConfiguration } from "@intlayer/config/node";
 import { getAlias } from "@intlayer/config/utils";
 import { prepareIntlayer } from "@intlayer/engine/build";
@@ -25,20 +27,28 @@ const intlayerNoExternalEnvironments = () => ({
 *    optimizations (prune).
 * 3. Configures the Vite aliases for dictionary access.
 * 4. Registers the `astro-intlayer/middleware`, which resolves the request
-*    locale into `Astro.locals.intlayer` for the hooks.
+*    locale into `Astro.locals.intlayer` for the hooks and redirects
+*    server-rendered requests to the visitor's locale.
+* 5. Injects the client-side locale redirect, which does the same for
+*    prerendered pages: served as static files, nothing else can read the
+*    stored locale there.
 *
 * The dev-time content watcher is not started here: the bundled
 * `vite-intlayer` plugin already starts one from `configureServer`, and
 * `watch()` subscribes anew on every call, so doing both would rebuild each
 * content edit twice.
 */
-const configSetup = async ({ updateConfig, addMiddleware }) => {
+const configSetup = async ({ command, updateConfig, addMiddleware, injectScript }) => {
 	const configuration = getConfiguration();
 	await prepareIntlayer(configuration);
 	addMiddleware({
 		entrypoint: "astro-intlayer/middleware",
 		order: "pre"
 	});
+	if (resolveProxyMode(configuration.routing.enableProxy) !== "disabled") {
+		injectScript("page", `import { redirectToStoredLocale } from 'astro-intlayer/client/locale-redirect';\nredirectToStoredLocale();`);
+		if (command === "preview") getAppLogger(configuration)(formatProxyEnabledMessage(false), { level: "info" });
+	}
 	updateConfig({ vite: {
 		plugins: [intlayer(), intlayerNoExternalEnvironments()],
 		resolve: { alias: { ...getAlias({

package/dist/esm/integration.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"integration.mjs","names":["viteIntlayerPlugin"],"sources":["../../src/integration.ts"],"sourcesContent":["import { resolve } from 'node:path';\nimport { getConfiguration } from '@intlayer/config/node';\nimport { getAlias } from '@intlayer/config/utils';\nimport { prepareIntlayer } from '@intlayer/engine/build';\nimport type { AstroIntegration } from 'astro';\nimport type { PluginOption } from 'vite';\nimport {\n  INTLAYER_NO_EXTERNAL_PATTERN,\n  intlayer as viteIntlayerPlugin,\n} from 'vite-intlayer';\nimport { emitRewrittenPages } from './emitRewrittenPages';\n\n/**\n * Keeps the intlayer packages out of Node's native module loader in *every*\n * Vite environment Astro renders from.\n *\n * A static dev server renders from `ssr`, but other setups render from Astro's\n * `astro` or `prerender` environments, and a top-level `ssr.noExternal` only\n * seeds the `ssr` one. Declaring it per environment covers the rest.\n */\nconst intlayerNoExternalEnvironments = (): PluginOption => ({\n  name: 'astro-intlayer-no-external',\n  configEnvironment: () => ({\n    resolve: { noExternal: [INTLAYER_NO_EXTERNAL_PATTERN] },\n  }),\n});\n\n/**\n * Node-only half of the integration, loaded lazily by the `astro-intlayer`\n * entry when a hook runs.\n *\n * Pages import their hooks from that same entry, and Astro bundles the whole\n * package into the server build (`ssr.noExternal`), so the config loader,\n * `@intlayer/engine` and `vite-intlayer` must stay behind a dynamic import:\n * a static one would put them in the module graph of every page.\n */\n\ntype ConfigSetupOptions = Parameters<\n  NonNullable<AstroIntegration['hooks']['astro:config:setup']>\n>[0];\n\ntype BuildDoneOptions = Parameters<\n  NonNullable<AstroIntegration['hooks']['astro:build:done']>\n>[0];\n\n/**\n * `astro:config:setup`:\n * 1. Prepares the Intlayer resources (dictionaries).\n * 2. Injects the Vite plugins for aliases, locale-based routing and build\n *    optimizations (prune).\n * 3. Configures the Vite aliases for dictionary access.\n * 4. Registers the `astro-intlayer/middleware`, which resolves the request\n *    locale into `Astro.locals.intlayer` for the hooks.\n *\n * The dev-time content watcher is not started here: the bundled\n * `vite-intlayer` plugin already starts one from `configureServer`, and\n * `watch()` subscribes anew on every call, so doing both would rebuild each\n * content edit twice.\n */\nexport const configSetup = async ({\n  updateConfig,\n  addMiddleware,\n}: ConfigSetupOptions): Promise<void> => {\n  const configuration = getConfiguration();\n\n  // Prepare once per process start to ensure generated entries exist\n  await prepareIntlayer(configuration);\n\n  // Runs before the user middleware so `Astro.locals.intlayer` is set\n  // everywhere, including in a hand-written `src/middleware.ts`.\n  addMiddleware({\n    entrypoint: 'astro-intlayer/middleware',\n    order: 'pre',\n  });\n\n  updateConfig({\n    vite: {\n      plugins: [\n        viteIntlayerPlugin(),\n        intlayerNoExternalEnvironments(),\n      ] as PluginOption[],\n      resolve: {\n        alias: {\n          ...getAlias({\n            configuration,\n            formatter: (value) => resolve(value),\n          }),\n        },\n      },\n      // `astro-intlayer` is tagged with the `astro` keyword, so Astro\n      // treats it as an Astro package and crawls its dependency tree\n      // (`vitefu`), force-externalizing every dependency it finds —\n      // `@intlayer/core`, `@intlayer/config`, … — into\n      // `resolve.external`. Vite checks `external` before `noExternal`,\n      // so the `ssr.noExternal` that `vite-intlayer` returns from its\n      // Vite `config` hook loses that race and the packages are loaded\n      // natively by Node, stranding dictionary edits behind Node's\n      // require cache. Declaring it here instead runs before the crawl,\n      // which drops explicitly no-externalized packages from its result.\n      ssr: {\n        noExternal: [INTLAYER_NO_EXTERNAL_PATTERN],\n      },\n    },\n  });\n};\n\n/**\n * `astro:build:done`: Astro renders each page from its canonical file-system\n * route, so a static build has no file for the localized paths declared in\n * `routing.rewrite`. Mirror them here, otherwise the URLs produced by\n * `getLocalizedUrl` (links, hreflang, sitemap) 404 once deployed.\n */\nexport const buildDone = async ({\n  dir,\n  logger,\n}: BuildDoneOptions): Promise<void> => {\n  const configuration = getConfiguration();\n\n  const emittedPages = await emitRewrittenPages(configuration, dir);\n\n  if (emittedPages.length > 0) {\n    logger.info(\n      `Emitted ${emittedPages.length} rewritten page(s): ${emittedPages\n        .map(([from, to]) => `${from} \\u2192 ${to}`)\n        .join(', ')}`\n    );\n  }\n};\n"],"mappings":";;;;;;;;;;;;;;;;AAoBA,MAAM,wCAAsD;CAC1D,MAAM;CACN,0BAA0B,EACxB,SAAS,EAAE,YAAY,CAAC,4BAA4B,EAAE,EACxD;AACF;;;;;;;;;;;;;;;AAkCA,MAAa,cAAc,OAAO,EAChC,cACA,oBACuC;CACvC,MAAM,gBAAgB,iBAAiB;CAGvC,MAAM,gBAAgB,aAAa;CAInC,cAAc;EACZ,YAAY;EACZ,OAAO;CACT,CAAC;CAED,aAAa,EACX,MAAM;EACJ,SAAS,CACPA,SAAmB,GACnB,+BAA+B,CACjC;EACA,SAAS,EACP,OAAO,EACL,GAAG,SAAS;GACV;GACA,YAAY,UAAU,QAAQ,KAAK;EACrC,CAAC,EACH,EACF;EAWA,KAAK,EACH,YAAY,CAAC,4BAA4B,EAC3C;CACF,EACF,CAAC;AACH;;;;;;;AAQA,MAAa,YAAY,OAAO,EAC9B,KACA,aACqC;CACrC,MAAM,gBAAgB,iBAAiB;CAEvC,MAAM,eAAe,MAAM,mBAAmB,eAAe,GAAG;CAEhE,IAAI,aAAa,SAAS,GACxB,OAAO,KACL,WAAW,aAAa,OAAO,sBAAsB,aAClD,KAAK,CAAC,MAAM,QAAQ,GAAG,KAAK,UAAU,IAAI,CAAC,CAC3C,KAAK,IAAI,GACd;AAEJ"}
+{"version":3,"file":"integration.mjs","names":["viteIntlayerPlugin"],"sources":["../../src/integration.ts"],"sourcesContent":["import { resolve } from 'node:path';\nimport { getAppLogger } from '@intlayer/config/logger';\nimport { getConfiguration } from '@intlayer/config/node';\nimport { getAlias } from '@intlayer/config/utils';\nimport {\n  formatProxyEnabledMessage,\n  resolveProxyMode,\n} from '@intlayer/core/localization';\nimport { prepareIntlayer } from '@intlayer/engine/build';\nimport type { AstroIntegration } from 'astro';\nimport type { PluginOption } from 'vite';\nimport {\n  INTLAYER_NO_EXTERNAL_PATTERN,\n  intlayer as viteIntlayerPlugin,\n} from 'vite-intlayer';\nimport { emitRewrittenPages } from './emitRewrittenPages';\n\n/**\n * Keeps the intlayer packages out of Node's native module loader in *every*\n * Vite environment Astro renders from.\n *\n * A static dev server renders from `ssr`, but other setups render from Astro's\n * `astro` or `prerender` environments, and a top-level `ssr.noExternal` only\n * seeds the `ssr` one. Declaring it per environment covers the rest.\n */\nconst intlayerNoExternalEnvironments = (): PluginOption => ({\n  name: 'astro-intlayer-no-external',\n  configEnvironment: () => ({\n    resolve: { noExternal: [INTLAYER_NO_EXTERNAL_PATTERN] },\n  }),\n});\n\n/**\n * Node-only half of the integration, loaded lazily by the `astro-intlayer`\n * entry when a hook runs.\n *\n * Pages import their hooks from that same entry, and Astro bundles the whole\n * package into the server build (`ssr.noExternal`), so the config loader,\n * `@intlayer/engine` and `vite-intlayer` must stay behind a dynamic import:\n * a static one would put them in the module graph of every page.\n */\n\ntype ConfigSetupOptions = Parameters<\n  NonNullable<AstroIntegration['hooks']['astro:config:setup']>\n>[0];\n\ntype BuildDoneOptions = Parameters<\n  NonNullable<AstroIntegration['hooks']['astro:build:done']>\n>[0];\n\n/**\n * `astro:config:setup`:\n * 1. Prepares the Intlayer resources (dictionaries).\n * 2. Injects the Vite plugins for aliases, locale-based routing and build\n *    optimizations (prune).\n * 3. Configures the Vite aliases for dictionary access.\n * 4. Registers the `astro-intlayer/middleware`, which resolves the request\n *    locale into `Astro.locals.intlayer` for the hooks and redirects\n *    server-rendered requests to the visitor's locale.\n * 5. Injects the client-side locale redirect, which does the same for\n *    prerendered pages: served as static files, nothing else can read the\n *    stored locale there.\n *\n * The dev-time content watcher is not started here: the bundled\n * `vite-intlayer` plugin already starts one from `configureServer`, and\n * `watch()` subscribes anew on every call, so doing both would rebuild each\n * content edit twice.\n */\nexport const configSetup = async ({\n  command,\n  updateConfig,\n  addMiddleware,\n  injectScript,\n}: ConfigSetupOptions): Promise<void> => {\n  const configuration = getConfiguration();\n\n  // Prepare once per process start to ensure generated entries exist\n  await prepareIntlayer(configuration);\n\n  // Runs before the user middleware so `Astro.locals.intlayer` is set\n  // everywhere, including in a hand-written `src/middleware.ts`.\n  addMiddleware({\n    entrypoint: 'astro-intlayer/middleware',\n    order: 'pre',\n  });\n\n  const proxyMode = resolveProxyMode(configuration.routing.enableProxy);\n\n  if (proxyMode !== 'disabled') {\n    injectScript(\n      'page',\n      `import { redirectToStoredLocale } from 'astro-intlayer/client/locale-redirect';\\nredirectToStoredLocale();`\n    );\n\n    // `dev` and `build` are announced by the bundled `vite-intlayer` plugin.\n    // `astro preview` runs no Vite plugin, so the served output is announced\n    // here: the stored locale drives redirects again once the output is\n    // served — by the middleware on server-rendered pages, by the injected\n    // script on static ones.\n    if (command === 'preview') {\n      getAppLogger(configuration)(formatProxyEnabledMessage(false), {\n        level: 'info',\n      });\n    }\n  }\n\n  updateConfig({\n    vite: {\n      plugins: [\n        viteIntlayerPlugin(),\n        intlayerNoExternalEnvironments(),\n      ] as PluginOption[],\n      resolve: {\n        alias: {\n          ...getAlias({\n            configuration,\n            formatter: (value) => resolve(value),\n          }),\n        },\n      },\n      // `astro-intlayer` is tagged with the `astro` keyword, so Astro\n      // treats it as an Astro package and crawls its dependency tree\n      // (`vitefu`), force-externalizing every dependency it finds —\n      // `@intlayer/core`, `@intlayer/config`, … — into\n      // `resolve.external`. Vite checks `external` before `noExternal`,\n      // so the `ssr.noExternal` that `vite-intlayer` returns from its\n      // Vite `config` hook loses that race and the packages are loaded\n      // natively by Node, stranding dictionary edits behind Node's\n      // require cache. Declaring it here instead runs before the crawl,\n      // which drops explicitly no-externalized packages from its result.\n      ssr: {\n        noExternal: [INTLAYER_NO_EXTERNAL_PATTERN],\n      },\n    },\n  });\n};\n\n/**\n * `astro:build:done`: Astro renders each page from its canonical file-system\n * route, so a static build has no file for the localized paths declared in\n * `routing.rewrite`. Mirror them here, otherwise the URLs produced by\n * `getLocalizedUrl` (links, hreflang, sitemap) 404 once deployed.\n */\nexport const buildDone = async ({\n  dir,\n  logger,\n}: BuildDoneOptions): Promise<void> => {\n  const configuration = getConfiguration();\n\n  const emittedPages = await emitRewrittenPages(configuration, dir);\n\n  if (emittedPages.length > 0) {\n    logger.info(\n      `Emitted ${emittedPages.length} rewritten page(s): ${emittedPages\n        .map(([from, to]) => `${from} \\u2192 ${to}`)\n        .join(', ')}`\n    );\n  }\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAyBA,MAAM,wCAAsD;CAC1D,MAAM;CACN,0BAA0B,EACxB,SAAS,EAAE,YAAY,CAAC,4BAA4B,EAAE,EACxD;AACF;;;;;;;;;;;;;;;;;;;AAsCA,MAAa,cAAc,OAAO,EAChC,SACA,cACA,eACA,mBACuC;CACvC,MAAM,gBAAgB,iBAAiB;CAGvC,MAAM,gBAAgB,aAAa;CAInC,cAAc;EACZ,YAAY;EACZ,OAAO;CACT,CAAC;CAID,IAFkB,iBAAiB,cAAc,QAAQ,WAE7C,MAAM,YAAY;EAC5B,aACE,QACA,4GACF;EAOA,IAAI,YAAY,WACd,aAAa,aAAa,CAAC,CAAC,0BAA0B,KAAK,GAAG,EAC5D,OAAO,OACT,CAAC;CAEL;CAEA,aAAa,EACX,MAAM;EACJ,SAAS,CACPA,SAAmB,GACnB,+BAA+B,CACjC;EACA,SAAS,EACP,OAAO,EACL,GAAG,SAAS;GACV;GACA,YAAY,UAAU,QAAQ,KAAK;EACrC,CAAC,EACH,EACF;EAWA,KAAK,EACH,YAAY,CAAC,4BAA4B,EAC3C;CACF,EACF,CAAC;AACH;;;;;;;AAQA,MAAa,YAAY,OAAO,EAC9B,KACA,aACqC;CACrC,MAAM,gBAAgB,iBAAiB;CAEvC,MAAM,eAAe,MAAM,mBAAmB,eAAe,GAAG;CAEhE,IAAI,aAAa,SAAS,GACxB,OAAO,KACL,WAAW,aAAa,OAAO,sBAAsB,aAClD,KAAK,CAAC,MAAM,QAAQ,GAAG,KAAK,UAAU,IAAI,CAAC,CAC3C,KAAK,IAAI,GACd;AAEJ"}

package/dist/esm/middleware.mjs

@@ -1,15 +1,63 @@
 import { requestStorage } from "./requestStorage.mjs";
-import { getLocaleFromRequest } from "@intlayer/core/localization";
-import { internationalization } from "@intlayer/config/built";
+import { getLocaleFromRequest, resolveProxyMode } from "@intlayer/core/localization";
+import * as builtConfiguration from "@intlayer/config/built";
+import { createIntlayerWebProxyHandler } from "vite-intlayer/web-proxy-handler";
 
 //#region src/middleware.ts
 /**
+* Whether `astro dev` is serving the app. Vite inlines `import.meta.env.DEV`
+* into the server bundle; the optional chain keeps the module loadable where
+* no bundler defines it (`process.env.NODE_ENV` cannot be used instead: the
+* package build inlines it).
+*/
+const isDevServer = import.meta.env?.DEV === true;
+const configuration = builtConfiguration;
+const { internationalization: internationalization$1, routing: routing$1 } = configuration;
+/**
+* Locale-routing proxy shared with the Vite dev server and the Nitro handler.
+*
+* `undefined` when `routing.enableProxy` is `false`. In auto mode (option
+* unset) `astro dev` keeps routing URL-driven: the stored locale is not a
+* redirect source, exactly like the Vite proxy mounted on the same dev server,
+* so the two never disagree.
+*/
+const proxy = resolveProxyMode(routing$1.enableProxy) === "disabled" ? void 0 : createIntlayerWebProxyHandler({
+	configuration,
+	isDevServer
+});
+/**
+* Appends the headers the proxy produced (the persisted locale cookie) to the
+* rendered response. Some responses ship immutable headers, in which case the
+* body is re-wrapped in a fresh `Response`.
+*/
+const withProxyHeaders = (response, headers) => {
+	const entries = [...headers];
+	if (entries.length === 0) return response;
+	const applyHeaders = (target) => {
+		for (const [name, value] of entries) target.headers.append(name, value);
+		return target;
+	};
+	try {
+		return applyHeaders(response);
+	} catch {
+		return applyHeaders(new Response(response.body, response));
+	}
+};
+/**
 * Astro middleware resolving the request locale into `Astro.locals.intlayer`.
 *
 * Priority: the URL (path prefix or `?locale=` search param, in every routing
 * mode but `no-prefix`), then the locale persisted by the client (cookie or
 * custom header), then `Accept-Language` negotiation.
 *
+* On server-rendered requests it also runs the Intlayer locale-routing proxy,
+* so a visitor whose stored locale is `fr` is redirected from `/` to `/fr`
+* (per `routing.mode`) and the resolved locale is persisted on the response.
+* Only redirects are honoured: the proxy's internal rewrites target
+* prefix-based routers, while Astro pages already resolve the locale from the
+* URL they are rendered for. Prerendered pages are served as static files, so
+* nothing can redirect them at request time and the proxy is skipped.
+*
 * The `intlayer()` integration registers it automatically, before the user
 * middleware, so `Astro.locals.intlayer` is available in every page, endpoint
 * and middleware. The rest of the request renders inside an
@@ -26,15 +74,25 @@ import { internationalization } from "@intlayer/config/built";
 * ```
 */
 const onRequest = async (context, next) => {
+	let proxyOutcome;
+	if (proxy && !context.isPrerendered) {
+		const outcome = proxy({
+			url: context.url,
+			headers: context.request.headers
+		});
+		if (outcome.kind === "response") return outcome.response;
+		proxyOutcome = outcome;
+	}
 	context.locals.intlayer = {
 		locale: await getLocaleFromRequest({
 			url: context.url,
 			headers: context.isPrerendered ? new Headers() : context.request.headers
 		}),
-		defaultLocale: internationalization.defaultLocale,
-		availableLocales: internationalization.locales
+		defaultLocale: internationalization$1.defaultLocale,
+		availableLocales: internationalization$1.locales
 	};
-	return requestStorage.run(context.locals, next);
+	const response = await requestStorage.run(context.locals, next);
+	return proxyOutcome ? withProxyHeaders(response, proxyOutcome.headers) : response;
 };
 
 //#endregion

package/dist/esm/middleware.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"middleware.mjs","names":[],"sources":["../../src/middleware.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport { getLocaleFromRequest } from '@intlayer/core/localization';\nimport type { DeclaredLocales } from '@intlayer/types/module_augmentation';\nimport type { MiddlewareHandler } from 'astro';\nimport { requestStorage } from './requestStorage';\n\n/**\n * Intlayer state stored in `Astro.locals.intlayer` by the {@link onRequest} middleware.\n */\nexport type IntlayerLocals = {\n  /** Locale resolved for the current request. */\n  locale: DeclaredLocales;\n  /** Locale configured as fallback in `intlayer.config.ts`. */\n  defaultLocale: DeclaredLocales;\n  /** Every locale declared in `intlayer.config.ts`. */\n  availableLocales: DeclaredLocales[];\n};\n\ndeclare global {\n  namespace App {\n    interface Locals {\n      intlayer: IntlayerLocals;\n    }\n  }\n}\n\n/**\n * Astro middleware resolving the request locale into `Astro.locals.intlayer`.\n *\n * Priority: the URL (path prefix or `?locale=` search param, in every routing\n * mode but `no-prefix`), then the locale persisted by the client (cookie or\n * custom header), then `Accept-Language` negotiation.\n *\n * The `intlayer()` integration registers it automatically, before the user\n * middleware, so `Astro.locals.intlayer` is available in every page, endpoint\n * and middleware. The rest of the request renders inside an\n * `AsyncLocalStorage` scope bound to those locals, which is how the hooks of\n * `astro-intlayer/server` read the locale with no argument.\n *\n * @example\n * ```ts\n * // src/middleware.ts — only needed when composing it by hand\n * import { onRequest as intlayer } from 'astro-intlayer/middleware';\n * import { sequence } from 'astro:middleware';\n *\n * export const onRequest = sequence(intlayer, myMiddleware);\n * ```\n */\nexport const onRequest: MiddlewareHandler = async (context, next) => {\n  context.locals.intlayer = {\n    locale: await getLocaleFromRequest({\n      url: context.url,\n      // A prerendered page is rendered once and served to every visitor, so\n      // its locale can only come from the URL. Reading the request headers\n      // there would also make Astro warn on every page of the build.\n      headers: context.isPrerendered ? new Headers() : context.request.headers,\n    }),\n    defaultLocale: internationalization.defaultLocale as DeclaredLocales,\n    availableLocales: internationalization.locales as DeclaredLocales[],\n  };\n\n  return requestStorage.run(context.locals, next);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDA,MAAa,YAA+B,OAAO,SAAS,SAAS;CACnE,QAAQ,OAAO,WAAW;EACxB,QAAQ,MAAM,qBAAqB;GACjC,KAAK,QAAQ;GAIb,SAAS,QAAQ,gBAAgB,IAAI,QAAQ,IAAI,QAAQ,QAAQ;EACnE,CAAC;EACD,eAAe,qBAAqB;EACpC,kBAAkB,qBAAqB;CACzC;CAEA,OAAO,eAAe,IAAI,QAAQ,QAAQ,IAAI;AAChD"}
+{"version":3,"file":"middleware.mjs","names":["routing","internationalization"],"sources":["../../src/middleware.ts"],"sourcesContent":["import * as builtConfiguration from '@intlayer/config/built';\nimport {\n  getLocaleFromRequest,\n  resolveProxyMode,\n} from '@intlayer/core/localization';\nimport type { IntlayerConfig } from '@intlayer/types/config';\nimport type { DeclaredLocales } from '@intlayer/types/module_augmentation';\nimport type { MiddlewareHandler } from 'astro';\nimport {\n  createIntlayerWebProxyHandler,\n  type WebProxyOutcome,\n} from 'vite-intlayer/web-proxy-handler';\nimport { requestStorage } from './requestStorage';\n\n/** Proxy outcome letting the request continue to the page. */\ntype WebProxyNextOutcome = Extract<WebProxyOutcome, { kind: 'next' }>;\n\n/**\n * Whether `astro dev` is serving the app. Vite inlines `import.meta.env.DEV`\n * into the server bundle; the optional chain keeps the module loadable where\n * no bundler defines it (`process.env.NODE_ENV` cannot be used instead: the\n * package build inlines it).\n */\nconst isDevServer =\n  (import.meta as { env?: { DEV?: boolean } }).env?.DEV === true;\n\nconst configuration = builtConfiguration as unknown as IntlayerConfig;\nconst { internationalization, routing } = configuration;\n\n/**\n * Locale-routing proxy shared with the Vite dev server and the Nitro handler.\n *\n * `undefined` when `routing.enableProxy` is `false`. In auto mode (option\n * unset) `astro dev` keeps routing URL-driven: the stored locale is not a\n * redirect source, exactly like the Vite proxy mounted on the same dev server,\n * so the two never disagree.\n */\nconst proxy =\n  resolveProxyMode(routing.enableProxy) === 'disabled'\n    ? undefined\n    : createIntlayerWebProxyHandler({\n        configuration,\n        isDevServer,\n      });\n\n/**\n * Appends the headers the proxy produced (the persisted locale cookie) to the\n * rendered response. Some responses ship immutable headers, in which case the\n * body is re-wrapped in a fresh `Response`.\n */\nconst withProxyHeaders = (response: Response, headers: Headers): Response => {\n  const entries = [...headers];\n  if (entries.length === 0) return response;\n\n  const applyHeaders = (target: Response) => {\n    for (const [name, value] of entries) {\n      target.headers.append(name, value);\n    }\n    return target;\n  };\n\n  try {\n    return applyHeaders(response);\n  } catch {\n    return applyHeaders(new Response(response.body, response));\n  }\n};\n\n/**\n * Intlayer state stored in `Astro.locals.intlayer` by the {@link onRequest} middleware.\n */\nexport type IntlayerLocals = {\n  /** Locale resolved for the current request. */\n  locale: DeclaredLocales;\n  /** Locale configured as fallback in `intlayer.config.ts`. */\n  defaultLocale: DeclaredLocales;\n  /** Every locale declared in `intlayer.config.ts`. */\n  availableLocales: DeclaredLocales[];\n};\n\ndeclare global {\n  namespace App {\n    interface Locals {\n      intlayer: IntlayerLocals;\n    }\n  }\n}\n\n/**\n * Astro middleware resolving the request locale into `Astro.locals.intlayer`.\n *\n * Priority: the URL (path prefix or `?locale=` search param, in every routing\n * mode but `no-prefix`), then the locale persisted by the client (cookie or\n * custom header), then `Accept-Language` negotiation.\n *\n * On server-rendered requests it also runs the Intlayer locale-routing proxy,\n * so a visitor whose stored locale is `fr` is redirected from `/` to `/fr`\n * (per `routing.mode`) and the resolved locale is persisted on the response.\n * Only redirects are honoured: the proxy's internal rewrites target\n * prefix-based routers, while Astro pages already resolve the locale from the\n * URL they are rendered for. Prerendered pages are served as static files, so\n * nothing can redirect them at request time and the proxy is skipped.\n *\n * The `intlayer()` integration registers it automatically, before the user\n * middleware, so `Astro.locals.intlayer` is available in every page, endpoint\n * and middleware. The rest of the request renders inside an\n * `AsyncLocalStorage` scope bound to those locals, which is how the hooks of\n * `astro-intlayer/server` read the locale with no argument.\n *\n * @example\n * ```ts\n * // src/middleware.ts — only needed when composing it by hand\n * import { onRequest as intlayer } from 'astro-intlayer/middleware';\n * import { sequence } from 'astro:middleware';\n *\n * export const onRequest = sequence(intlayer, myMiddleware);\n * ```\n */\nexport const onRequest: MiddlewareHandler = async (context, next) => {\n  let proxyOutcome: WebProxyNextOutcome | undefined;\n\n  if (proxy && !context.isPrerendered) {\n    const outcome = proxy({\n      url: context.url,\n      headers: context.request.headers,\n    });\n\n    if (outcome.kind === 'response') return outcome.response;\n    proxyOutcome = outcome;\n  }\n\n  context.locals.intlayer = {\n    locale: await getLocaleFromRequest({\n      url: context.url,\n      // A prerendered page is rendered once and served to every visitor, so\n      // its locale can only come from the URL. Reading the request headers\n      // there would also make Astro warn on every page of the build.\n      headers: context.isPrerendered ? new Headers() : context.request.headers,\n    }),\n    defaultLocale: internationalization.defaultLocale as DeclaredLocales,\n    availableLocales: internationalization.locales as DeclaredLocales[],\n  };\n\n  const response = await requestStorage.run(context.locals, next);\n\n  return proxyOutcome\n    ? withProxyHeaders(response, proxyOutcome.headers)\n    : response;\n};\n"],"mappings":";;;;;;;;;;;;AAuBA,MAAM,cACH,YAA4C,KAAK,QAAQ;AAE5D,MAAM,gBAAgB;AACtB,MAAM,EAAE,8CAAsB,uBAAY;;;;;;;;;AAU1C,MAAM,QACJ,iBAAiBA,UAAQ,WAAW,MAAM,aACtC,SACA,8BAA8B;CAC5B;CACA;AACF,CAAC;;;;;;AAOP,MAAM,oBAAoB,UAAoB,YAA+B;CAC3E,MAAM,UAAU,CAAC,GAAG,OAAO;CAC3B,IAAI,QAAQ,WAAW,GAAG,OAAO;CAEjC,MAAM,gBAAgB,WAAqB;EACzC,KAAK,MAAM,CAAC,MAAM,UAAU,SAC1B,OAAO,QAAQ,OAAO,MAAM,KAAK;EAEnC,OAAO;CACT;CAEA,IAAI;EACF,OAAO,aAAa,QAAQ;CAC9B,QAAQ;EACN,OAAO,aAAa,IAAI,SAAS,SAAS,MAAM,QAAQ,CAAC;CAC3D;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoDA,MAAa,YAA+B,OAAO,SAAS,SAAS;CACnE,IAAI;CAEJ,IAAI,SAAS,CAAC,QAAQ,eAAe;EACnC,MAAM,UAAU,MAAM;GACpB,KAAK,QAAQ;GACb,SAAS,QAAQ,QAAQ;EAC3B,CAAC;EAED,IAAI,QAAQ,SAAS,YAAY,OAAO,QAAQ;EAChD,eAAe;CACjB;CAEA,QAAQ,OAAO,WAAW;EACxB,QAAQ,MAAM,qBAAqB;GACjC,KAAK,QAAQ;GAIb,SAAS,QAAQ,gBAAgB,IAAI,QAAQ,IAAI,QAAQ,QAAQ;EACnE,CAAC;EACD,eAAeC,uBAAqB;EACpC,kBAAkBA,uBAAqB;CACzC;CAEA,MAAM,WAAW,MAAM,eAAe,IAAI,QAAQ,QAAQ,IAAI;CAE9D,OAAO,eACH,iBAAiB,UAAU,aAAa,OAAO,IAC/C;AACN"}

package/dist/types/client/localeRedirect.d.ts

@@ -0,0 +1,26 @@
+//#region src/client/localeRedirect.d.ts
+/**
+ * Computes where a prerendered page should send the visitor so it matches the
+ * locale they stored (cookie, localStorage or sessionStorage, per
+ * `routing.storage`).
+ *
+ * Mirrors the redirect the Intlayer proxy performs on server-rendered requests,
+ * for pages served as static files where no server can read the cookie:
+ * - the URL wins over storage, so a localized URL is never redirected;
+ * - `routing.enableProxy: false` and `no-prefix` routing disable it;
+ * - in auto mode a dev server keeps routing URL-driven, like the proxy.
+ *
+ * @param url - The URL of the current page.
+ * @param isDevServer - Whether `astro dev` is serving the page.
+ * @returns The localized URL to navigate to, or `undefined` to stay put.
+ */
+export declare const getStoredLocaleRedirect: (url: URL, isDevServer: boolean) => string | undefined;
+/**
+ * Sends the visitor of a prerendered page to the URL of their stored locale.
+ *
+ * Injected on every page by the `intlayer()` integration; a no-op once the URL
+ * already names a locale, so a redirected page does not redirect again.
+ */
+export declare const redirectToStoredLocale: () => void;
+//#endregion
+//# sourceMappingURL=localeRedirect.d.ts.map

package/dist/types/client/localeRedirect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"localeRedirect.d.ts","names":[],"sources":["../../../src/client/localeRedirect.ts"],"mappings":";;;;;;;;;;;;;;;;qBAwCa,0BAAuB,KAC7B,KAAG;;;;;;;qBAoCG"}

package/dist/types/integration.d.ts

@@ -18,14 +18,18 @@ type BuildDoneOptions = Parameters<NonNullable<AstroIntegration['hooks']['astro:
  *    optimizations (prune).
  * 3. Configures the Vite aliases for dictionary access.
  * 4. Registers the `astro-intlayer/middleware`, which resolves the request
- *    locale into `Astro.locals.intlayer` for the hooks.
+ *    locale into `Astro.locals.intlayer` for the hooks and redirects
+ *    server-rendered requests to the visitor's locale.
+ * 5. Injects the client-side locale redirect, which does the same for
+ *    prerendered pages: served as static files, nothing else can read the
+ *    stored locale there.
  *
  * The dev-time content watcher is not started here: the bundled
  * `vite-intlayer` plugin already starts one from `configureServer`, and
  * `watch()` subscribes anew on every call, so doing both would rebuild each
  * content edit twice.
  */
-export declare const configSetup: ({ updateConfig, addMiddleware }: ConfigSetupOptions) => Promise<void>;
+export declare const configSetup: ({ command, updateConfig, addMiddleware, injectScript }: ConfigSetupOptions) => Promise<void>;
 /**
  * `astro:build:done`: Astro renders each page from its canonical file-system
  * route, so a static build has no file for the localized paths declared in

package/dist/types/integration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"integration.d.ts","names":[],"sources":["../../src/integration.ts"],"mappings":";;;;;;;;;;;KAqCK,qBAAqB,WACxB,YAAY;KAGT,mBAAmB,WACtB,YAAY;;;;;;;;;;;;;;;qBAiBD,gBAAW,cAAA,iBAGrB,uBAAqB;;;;;;;qBAkDX,cAAS,KAAA,UAGnB,qBAAmB"}
+{"version":3,"file":"integration.d.ts","names":[],"sources":["../../src/integration.ts"],"mappings":";;;;;;;;;;;KA0CK,qBAAqB,WACxB,YAAY;KAGT,mBAAmB,WACtB,YAAY;;;;;;;;;;;;;;;;;;;qBAqBD,gBAAW,SAAA,cAAA,eAAA,gBAKrB,uBAAqB;;;;;;;qBAsEX,cAAS,KAAA,UAGnB,qBAAmB"}

package/dist/types/middleware.d.ts

@@ -26,6 +26,14 @@ declare global {
  * mode but `no-prefix`), then the locale persisted by the client (cookie or
  * custom header), then `Accept-Language` negotiation.
  *
+ * On server-rendered requests it also runs the Intlayer locale-routing proxy,
+ * so a visitor whose stored locale is `fr` is redirected from `/` to `/fr`
+ * (per `routing.mode`) and the resolved locale is persisted on the response.
+ * Only redirects are honoured: the proxy's internal rewrites target
+ * prefix-based routers, while Astro pages already resolve the locale from the
+ * URL they are rendered for. Prerendered pages are served as static files, so
+ * nothing can redirect them at request time and the proxy is skipped.
+ *
  * The `intlayer()` integration registers it automatically, before the user
  * middleware, so `Astro.locals.intlayer` is available in every page, endpoint
  * and middleware. The rest of the request renders inside an

package/dist/types/middleware.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"middleware.d.ts","names":[],"sources":["../../src/middleware.ts"],"mappings":";;;;;;YASY;;EAEV,QAAQ;;EAER,eAAe;;EAEf,kBAAkB;;QAGZ;YACI;cACE;MACR,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;qBA2BH,WAAW"}
+{"version":3,"file":"middleware.d.ts","names":[],"sources":["../../src/middleware.ts"],"mappings":";;;;;;YAuEY;;EAEV,QAAQ;;EAER,eAAe;;EAEf,kBAAkB;;QAGZ;YACI;cACE;MACR,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAmCH,WAAW"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro-intlayer",
-  "version": "9.5.5",
+  "version": "9.5.6",
   "private": false,
   "description": "Easily internationalize i18n your Astro applications with type-safe multilingual content management.",
   "keywords": [
@@ -77,6 +77,11 @@
       "require": "./dist/cjs/client/index.cjs",
       "import": "./dist/esm/client/index.mjs"
     },
+    "./client/locale-redirect": {
+      "types": "./dist/types/client/localeRedirect.d.ts",
+      "require": "./dist/cjs/client/localeRedirect.cjs",
+      "import": "./dist/esm/client/localeRedirect.mjs"
+    },
     "./integration": {
       "types": "./dist/types/integration.d.ts",
       "require": "./dist/cjs/integration.cjs",
@@ -116,6 +121,9 @@
       "client": [
         "./dist/types/client/index.d.ts"
       ],
+      "client/locale-redirect": [
+        "./dist/types/client/localeRedirect.d.ts"
+      ],
       "format": [
         "./dist/types/format/index.d.ts"
       ],
@@ -159,15 +167,15 @@
     "typecheck": "tsc --noEmit --project tsconfig.types.json"
   },
   "dependencies": {
-    "@intlayer/config": "9.5.5",
-    "@intlayer/core": "9.5.5",
-    "@intlayer/engine": "9.5.5",
-    "@intlayer/types": "9.5.5",
-    "vanilla-intlayer": "9.5.5",
-    "vite-intlayer": "9.5.5"
+    "@intlayer/config": "9.5.6",
+    "@intlayer/core": "9.5.6",
+    "@intlayer/engine": "9.5.6",
+    "@intlayer/types": "9.5.6",
+    "vanilla-intlayer": "9.5.6",
+    "vite-intlayer": "9.5.6"
   },
   "devDependencies": {
-    "@intlayer/dictionaries-entry": "9.5.5",
+    "@intlayer/dictionaries-entry": "9.5.6",
     "@types/node": "^22",
     "@utils/ts-config": "1.0.4",
     "@utils/ts-config-types": "1.0.4",