@bleedingdev/modern-js-i18n-runtime-extensions 3.9.0-ultramodern.4 → 3.9.0-ultramodern.5

package/dist/cjs/index.js

@@ -6,6 +6,9 @@ var __webpack_modules__ = {
     "./language-sync/react" (module) {
         module.exports = require("./language-sync/react.js");
     },
+    "./localeRedirectPolicy" (module) {
+        module.exports = require("./localeRedirectPolicy.js");
+    },
     "./localisedUrls/index" (module) {
         module.exports = require("./localisedUrls/index.js");
     }
@@ -65,9 +68,13 @@ var __webpack_exports__ = {};
     var __rspack_reexport = {};
     for(const __rspack_import_key in _language_sync_react__rspack_import_1)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_language_sync_react__rspack_import_1[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-    var _localisedUrls_index__rspack_import_2 = __webpack_require__("./localisedUrls/index");
+    var _localeRedirectPolicy__rspack_import_2 = __webpack_require__("./localeRedirectPolicy");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _localeRedirectPolicy__rspack_import_2)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_localeRedirectPolicy__rspack_import_2[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _localisedUrls_index__rspack_import_3 = __webpack_require__("./localisedUrls/index");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in _localisedUrls_index__rspack_import_2)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_localisedUrls_index__rspack_import_2[__rspack_import_key];
+    for(const __rspack_import_key in _localisedUrls_index__rspack_import_3)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_localisedUrls_index__rspack_import_3[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
 })();
 for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];

package/dist/cjs/localeRedirectPolicy.js

@@ -0,0 +1,96 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    buildLocalizedUrl: ()=>buildLocalizedUrl,
+    createLocaleRedirectResponse: ()=>createLocaleRedirectResponse,
+    getLanguageFromPath: ()=>getLanguageFromPath,
+    isStaticResourceRequest: ()=>isStaticResourceRequest,
+    shouldIgnoreRedirect: ()=>shouldIgnoreRedirect
+});
+const index_js_namespaceObject = require("./localisedUrls/index.js");
+const stripUrlPathPrefix = (pathname, urlPath)=>{
+    const basePath = urlPath.replace('/*', '');
+    if (!basePath || '/' === basePath) return pathname;
+    const remainingPath = pathname.startsWith(basePath) ? pathname.slice(basePath.length) : pathname;
+    return remainingPath || '/';
+};
+const shouldIgnoreRedirect = (pathname, urlPath, ignoreRedirectRoutes)=>{
+    const remainingPath = stripUrlPathPrefix(pathname, urlPath);
+    return (0, index_js_namespaceObject.shouldSkipLocaleRedirect)(remainingPath, [], ignoreRedirectRoutes);
+};
+const isStaticResourceRequest = (pathname, staticRoutePrefixes, languages = [])=>{
+    if ((0, index_js_namespaceObject.isDefaultLocaleRedirectSkipPath)(pathname, languages)) return true;
+    const matchesStaticRoutePrefix = (targetPathname)=>staticRoutePrefixes.some((prefix)=>(0, index_js_namespaceObject.matchesPathPrefix)(targetPathname, prefix));
+    if (matchesStaticRoutePrefix(pathname)) return true;
+    const pathWithoutLanguage = (0, index_js_namespaceObject.stripLanguagePrefix)(pathname, languages);
+    return pathWithoutLanguage !== pathname && matchesStaticRoutePrefix(pathWithoutLanguage);
+};
+const getLanguageFromPath = (req, urlPath, languages)=>{
+    const url = new URL(req.url, `http://${req.header().host}`);
+    const pathname = url.pathname;
+    const remainingPath = stripUrlPathPrefix(pathname, urlPath);
+    const segments = remainingPath.split('/').filter(Boolean);
+    const firstSegment = segments[0];
+    if (languages.includes(firstSegment)) return firstSegment;
+    return null;
+};
+const buildLocalizedUrl = (req, urlPath, language, languages, localisedUrls)=>{
+    const url = new URL(req.url);
+    const pathname = url.pathname;
+    const basePath = urlPath.replace('/*', '');
+    const remainingPath = stripUrlPathPrefix(pathname, urlPath);
+    const newPathname = (0, index_js_namespaceObject.localiseTargetPathname)(remainingPath, language, languages, localisedUrls);
+    const suffix = `${url.search}${url.hash}`;
+    const localizedUrl = '/' === basePath ? newPathname + suffix : basePath + newPathname + suffix;
+    return localizedUrl;
+};
+const createLocaleRedirectResponse = (location)=>new Response(null, {
+        status: 302,
+        headers: {
+            'Cache-Control': 'private, no-store',
+            Location: location,
+            Vary: 'Accept-Language, Cookie'
+        }
+    });
+exports.buildLocalizedUrl = __webpack_exports__.buildLocalizedUrl;
+exports.createLocaleRedirectResponse = __webpack_exports__.createLocaleRedirectResponse;
+exports.getLanguageFromPath = __webpack_exports__.getLanguageFromPath;
+exports.isStaticResourceRequest = __webpack_exports__.isStaticResourceRequest;
+exports.shouldIgnoreRedirect = __webpack_exports__.shouldIgnoreRedirect;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "buildLocalizedUrl",
+    "createLocaleRedirectResponse",
+    "getLanguageFromPath",
+    "isStaticResourceRequest",
+    "shouldIgnoreRedirect"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/paths.js

@@ -0,0 +1,56 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    buildLocalizedUrl: ()=>buildLocalizedUrl,
+    canonicalPath: ()=>canonicalPath,
+    localizePath: ()=>localizePath
+});
+const url_namespaceObject = require("@modern-js/runtime-utils/url");
+const index_js_namespaceObject = require("./localisedUrls/index.js");
+const buildLocalizedUrl = (target, language, languages, localisedUrls)=>{
+    const { pathname, search, hash } = (0, url_namespaceObject.splitUrlTarget)(target);
+    return `${(0, index_js_namespaceObject.localiseTargetPathname)(pathname, language, languages, localisedUrls)}${search}${hash}`;
+};
+const localizePath = (target, language, config)=>buildLocalizedUrl(target, language, config.languages, config.localisedUrls);
+const canonicalPath = (target, config)=>{
+    const { pathname, search, hash } = (0, url_namespaceObject.splitUrlTarget)(target);
+    return `${(0, index_js_namespaceObject.canonicalTargetPathname)(pathname, config.languages, config.localisedUrls)}${search}${hash}`;
+};
+exports.buildLocalizedUrl = __webpack_exports__.buildLocalizedUrl;
+exports.canonicalPath = __webpack_exports__.canonicalPath;
+exports.localizePath = __webpack_exports__.localizePath;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "buildLocalizedUrl",
+    "canonicalPath",
+    "localizePath"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/esm/index.mjs

@@ -1,3 +1,4 @@
 export * from "./language-sync/controller.mjs";
 export * from "./language-sync/react.mjs";
+export * from "./localeRedirectPolicy.mjs";
 export * from "./localisedUrls/index.mjs";

package/dist/esm/localeRedirectPolicy.mjs

@@ -0,0 +1,46 @@
+import { isDefaultLocaleRedirectSkipPath, localiseTargetPathname, matchesPathPrefix, shouldSkipLocaleRedirect, stripLanguagePrefix } from "./localisedUrls/index.mjs";
+const stripUrlPathPrefix = (pathname, urlPath)=>{
+    const basePath = urlPath.replace('/*', '');
+    if (!basePath || '/' === basePath) return pathname;
+    const remainingPath = pathname.startsWith(basePath) ? pathname.slice(basePath.length) : pathname;
+    return remainingPath || '/';
+};
+const shouldIgnoreRedirect = (pathname, urlPath, ignoreRedirectRoutes)=>{
+    const remainingPath = stripUrlPathPrefix(pathname, urlPath);
+    return shouldSkipLocaleRedirect(remainingPath, [], ignoreRedirectRoutes);
+};
+const isStaticResourceRequest = (pathname, staticRoutePrefixes, languages = [])=>{
+    if (isDefaultLocaleRedirectSkipPath(pathname, languages)) return true;
+    const matchesStaticRoutePrefix = (targetPathname)=>staticRoutePrefixes.some((prefix)=>matchesPathPrefix(targetPathname, prefix));
+    if (matchesStaticRoutePrefix(pathname)) return true;
+    const pathWithoutLanguage = stripLanguagePrefix(pathname, languages);
+    return pathWithoutLanguage !== pathname && matchesStaticRoutePrefix(pathWithoutLanguage);
+};
+const getLanguageFromPath = (req, urlPath, languages)=>{
+    const url = new URL(req.url, `http://${req.header().host}`);
+    const pathname = url.pathname;
+    const remainingPath = stripUrlPathPrefix(pathname, urlPath);
+    const segments = remainingPath.split('/').filter(Boolean);
+    const firstSegment = segments[0];
+    if (languages.includes(firstSegment)) return firstSegment;
+    return null;
+};
+const buildLocalizedUrl = (req, urlPath, language, languages, localisedUrls)=>{
+    const url = new URL(req.url);
+    const pathname = url.pathname;
+    const basePath = urlPath.replace('/*', '');
+    const remainingPath = stripUrlPathPrefix(pathname, urlPath);
+    const newPathname = localiseTargetPathname(remainingPath, language, languages, localisedUrls);
+    const suffix = `${url.search}${url.hash}`;
+    const localizedUrl = '/' === basePath ? newPathname + suffix : basePath + newPathname + suffix;
+    return localizedUrl;
+};
+const createLocaleRedirectResponse = (location)=>new Response(null, {
+        status: 302,
+        headers: {
+            'Cache-Control': 'private, no-store',
+            Location: location,
+            Vary: 'Accept-Language, Cookie'
+        }
+    });
+export { buildLocalizedUrl, createLocaleRedirectResponse, getLanguageFromPath, isStaticResourceRequest, shouldIgnoreRedirect };

package/dist/esm/paths.mjs

@@ -0,0 +1,12 @@
+import { splitUrlTarget } from "@modern-js/runtime-utils/url";
+import { canonicalTargetPathname, localiseTargetPathname } from "./localisedUrls/index.mjs";
+const buildLocalizedUrl = (target, language, languages, localisedUrls)=>{
+    const { pathname, search, hash } = splitUrlTarget(target);
+    return `${localiseTargetPathname(pathname, language, languages, localisedUrls)}${search}${hash}`;
+};
+const localizePath = (target, language, config)=>buildLocalizedUrl(target, language, config.languages, config.localisedUrls);
+const canonicalPath = (target, config)=>{
+    const { pathname, search, hash } = splitUrlTarget(target);
+    return `${canonicalTargetPathname(pathname, config.languages, config.localisedUrls)}${search}${hash}`;
+};
+export { buildLocalizedUrl, canonicalPath, localizePath };

package/dist/esm-node/index.mjs

@@ -1,4 +1,5 @@
 import "node:module";
 export * from "./language-sync/controller.mjs";
 export * from "./language-sync/react.mjs";
+export * from "./localeRedirectPolicy.mjs";
 export * from "./localisedUrls/index.mjs";

package/dist/esm-node/localeRedirectPolicy.mjs

@@ -0,0 +1,47 @@
+import "node:module";
+import { isDefaultLocaleRedirectSkipPath, localiseTargetPathname, matchesPathPrefix, shouldSkipLocaleRedirect, stripLanguagePrefix } from "./localisedUrls/index.mjs";
+const stripUrlPathPrefix = (pathname, urlPath)=>{
+    const basePath = urlPath.replace('/*', '');
+    if (!basePath || '/' === basePath) return pathname;
+    const remainingPath = pathname.startsWith(basePath) ? pathname.slice(basePath.length) : pathname;
+    return remainingPath || '/';
+};
+const shouldIgnoreRedirect = (pathname, urlPath, ignoreRedirectRoutes)=>{
+    const remainingPath = stripUrlPathPrefix(pathname, urlPath);
+    return shouldSkipLocaleRedirect(remainingPath, [], ignoreRedirectRoutes);
+};
+const isStaticResourceRequest = (pathname, staticRoutePrefixes, languages = [])=>{
+    if (isDefaultLocaleRedirectSkipPath(pathname, languages)) return true;
+    const matchesStaticRoutePrefix = (targetPathname)=>staticRoutePrefixes.some((prefix)=>matchesPathPrefix(targetPathname, prefix));
+    if (matchesStaticRoutePrefix(pathname)) return true;
+    const pathWithoutLanguage = stripLanguagePrefix(pathname, languages);
+    return pathWithoutLanguage !== pathname && matchesStaticRoutePrefix(pathWithoutLanguage);
+};
+const getLanguageFromPath = (req, urlPath, languages)=>{
+    const url = new URL(req.url, `http://${req.header().host}`);
+    const pathname = url.pathname;
+    const remainingPath = stripUrlPathPrefix(pathname, urlPath);
+    const segments = remainingPath.split('/').filter(Boolean);
+    const firstSegment = segments[0];
+    if (languages.includes(firstSegment)) return firstSegment;
+    return null;
+};
+const buildLocalizedUrl = (req, urlPath, language, languages, localisedUrls)=>{
+    const url = new URL(req.url);
+    const pathname = url.pathname;
+    const basePath = urlPath.replace('/*', '');
+    const remainingPath = stripUrlPathPrefix(pathname, urlPath);
+    const newPathname = localiseTargetPathname(remainingPath, language, languages, localisedUrls);
+    const suffix = `${url.search}${url.hash}`;
+    const localizedUrl = '/' === basePath ? newPathname + suffix : basePath + newPathname + suffix;
+    return localizedUrl;
+};
+const createLocaleRedirectResponse = (location)=>new Response(null, {
+        status: 302,
+        headers: {
+            'Cache-Control': 'private, no-store',
+            Location: location,
+            Vary: 'Accept-Language, Cookie'
+        }
+    });
+export { buildLocalizedUrl, createLocaleRedirectResponse, getLanguageFromPath, isStaticResourceRequest, shouldIgnoreRedirect };

package/dist/esm-node/paths.mjs

@@ -0,0 +1,13 @@
+import "node:module";
+import { splitUrlTarget } from "@modern-js/runtime-utils/url";
+import { canonicalTargetPathname, localiseTargetPathname } from "./localisedUrls/index.mjs";
+const buildLocalizedUrl = (target, language, languages, localisedUrls)=>{
+    const { pathname, search, hash } = splitUrlTarget(target);
+    return `${localiseTargetPathname(pathname, language, languages, localisedUrls)}${search}${hash}`;
+};
+const localizePath = (target, language, config)=>buildLocalizedUrl(target, language, config.languages, config.localisedUrls);
+const canonicalPath = (target, config)=>{
+    const { pathname, search, hash } = splitUrlTarget(target);
+    return `${canonicalTargetPathname(pathname, config.languages, config.localisedUrls)}${search}${hash}`;
+};
+export { buildLocalizedUrl, canonicalPath, localizePath };

package/dist/types/index.d.ts

@@ -1,3 +1,4 @@
 export * from './language-sync/controller.js';
 export * from './language-sync/react.js';
+export * from './localeRedirectPolicy.js';
 export * from './localisedUrls/index.js';

package/dist/types/localeRedirectPolicy.d.ts

@@ -0,0 +1,22 @@
+import type { LocalisedUrlsOption } from './localisedUrls/index.js';
+interface LocaleRedirectRequest {
+    url: string;
+    header: () => {
+        host?: string;
+    };
+}
+/**
+ * Check if pathname should ignore automatic locale redirect.
+ */
+export declare const shouldIgnoreRedirect: (pathname: string, urlPath: string, ignoreRedirectRoutes?: string[] | ((pathname: string) => boolean)) => boolean;
+/**
+ * Check if pathname is a static or federation resource request.
+ *
+ * This includes configured staticRoutePrefixes, the shared default skip policy
+ * from ADR-0002, and language-prefixed variants such as /en/static/app.js.
+ */
+export declare const isStaticResourceRequest: (pathname: string, staticRoutePrefixes: string[], languages?: string[]) => boolean;
+export declare const getLanguageFromPath: (req: LocaleRedirectRequest, urlPath: string, languages: string[]) => string | null;
+export declare const buildLocalizedUrl: (req: LocaleRedirectRequest, urlPath: string, language: string, languages: string[], localisedUrls?: LocalisedUrlsOption) => string;
+export declare const createLocaleRedirectResponse: (location: string) => Response;
+export {};

package/dist/types/paths.d.ts

@@ -0,0 +1,9 @@
+import { type LocalisedUrlsOption } from './localisedUrls/index.js';
+export interface LocalizedPathsConfig {
+    languages: string[];
+    localisedUrls?: LocalisedUrlsOption;
+}
+/** Synchronous mapped URL construction, independent of React/plugin setup. */
+export declare const buildLocalizedUrl: (target: string, language: string, languages: string[], localisedUrls?: LocalisedUrlsOption) => string;
+export declare const localizePath: (target: string, language: string, config: LocalizedPathsConfig) => string;
+export declare const canonicalPath: (target: string, config: LocalizedPathsConfig) => string;

package/package.json

@@ -17,7 +17,7 @@
     "modern.js",
     "i18n"
   ],
-  "version": "3.9.0-ultramodern.4",
+  "version": "3.9.0-ultramodern.5",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.mjs",
@@ -30,13 +30,24 @@
       },
       "default": "./dist/esm/index.mjs"
     },
-    "./package.json": "./package.json"
+    "./package.json": "./package.json",
+    "./paths": {
+      "types": "./dist/types/paths.d.ts",
+      "node": {
+        "import": "./dist/esm-node/paths.mjs",
+        "require": "./dist/cjs/paths.js"
+      },
+      "default": "./dist/esm/paths.mjs"
+    }
   },
   "typesVersions": {
     "*": {
       ".": [
         "./dist/types/index.d.ts",
         "./src/index.ts"
+      ],
+      "paths": [
+        "./dist/types/paths.d.ts"
       ]
     }
   },
@@ -44,14 +55,15 @@
     "node": ">=26.7.0"
   },
   "dependencies": {
+    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.9.0-ultramodern.5",
     "i18next-browser-languagedetector": "^8.2.1"
   },
   "peerDependencies": {
-    "@modern-js/runtime": "3.9.0-ultramodern.4",
+    "@modern-js/runtime": "3.9.0-ultramodern.5",
     "react": "^19.2.8"
   },
   "devDependencies": {
-    "@modern-js/runtime": "npm:@bleedingdev/modern-js-runtime@3.9.0-ultramodern.4",
+    "@modern-js/runtime": "npm:@bleedingdev/modern-js-runtime@3.9.0-ultramodern.5",
     "@rslib/core": "1.0.0",
     "@scripts/rstest-config": "2.66.0",
     "@types/node": "^26.4.1",

package/src/index.ts

@@ -1,3 +1,4 @@
 export * from './language-sync/controller';
 export * from './language-sync/react';
+export * from './localeRedirectPolicy';
 export * from './localisedUrls/index';

package/src/localeRedirectPolicy.ts

@@ -0,0 +1,127 @@
+import type { LocalisedUrlsOption } from './localisedUrls/index';
+import {
+  isDefaultLocaleRedirectSkipPath,
+  localiseTargetPathname,
+  matchesPathPrefix,
+  shouldSkipLocaleRedirect,
+  stripLanguagePrefix,
+} from './localisedUrls/index';
+
+interface LocaleRedirectRequest {
+  url: string;
+  header: () => {
+    host?: string;
+  };
+}
+
+const stripUrlPathPrefix = (pathname: string, urlPath: string): string => {
+  const basePath = urlPath.replace('/*', '');
+
+  if (!basePath || basePath === '/') {
+    return pathname;
+  }
+
+  const remainingPath = pathname.startsWith(basePath)
+    ? pathname.slice(basePath.length)
+    : pathname;
+
+  return remainingPath || '/';
+};
+
+/**
+ * Check if pathname should ignore automatic locale redirect.
+ */
+export const shouldIgnoreRedirect = (
+  pathname: string,
+  urlPath: string,
+  ignoreRedirectRoutes?: string[] | ((pathname: string) => boolean),
+): boolean => {
+  const remainingPath = stripUrlPathPrefix(pathname, urlPath);
+
+  return shouldSkipLocaleRedirect(remainingPath, [], ignoreRedirectRoutes);
+};
+
+/**
+ * Check if pathname is a static or federation resource request.
+ *
+ * This includes configured staticRoutePrefixes, the shared default skip policy
+ * from ADR-0002, and language-prefixed variants such as /en/static/app.js.
+ */
+export const isStaticResourceRequest = (
+  pathname: string,
+  staticRoutePrefixes: string[],
+  languages: string[] = [],
+): boolean => {
+  if (isDefaultLocaleRedirectSkipPath(pathname, languages)) {
+    return true;
+  }
+
+  const matchesStaticRoutePrefix = (targetPathname: string): boolean =>
+    staticRoutePrefixes.some(prefix =>
+      matchesPathPrefix(targetPathname, prefix),
+    );
+
+  if (matchesStaticRoutePrefix(pathname)) {
+    return true;
+  }
+
+  const pathWithoutLanguage = stripLanguagePrefix(pathname, languages);
+
+  return (
+    pathWithoutLanguage !== pathname &&
+    matchesStaticRoutePrefix(pathWithoutLanguage)
+  );
+};
+
+export const getLanguageFromPath = (
+  req: LocaleRedirectRequest,
+  urlPath: string,
+  languages: string[],
+): string | null => {
+  const url = new URL(req.url, `http://${req.header().host}`);
+  const pathname = url.pathname;
+  const remainingPath = stripUrlPathPrefix(pathname, urlPath);
+  const segments = remainingPath.split('/').filter(Boolean);
+  const firstSegment = segments[0];
+
+  if (languages.includes(firstSegment)) {
+    return firstSegment;
+  }
+
+  return null;
+};
+
+export const buildLocalizedUrl = (
+  req: LocaleRedirectRequest,
+  urlPath: string,
+  language: string,
+  languages: string[],
+  localisedUrls?: LocalisedUrlsOption,
+): string => {
+  const url = new URL(req.url);
+  const pathname = url.pathname;
+  const basePath = urlPath.replace('/*', '');
+  const remainingPath = stripUrlPathPrefix(pathname, urlPath);
+
+  const newPathname = localiseTargetPathname(
+    remainingPath,
+    language,
+    languages,
+    localisedUrls,
+  );
+  const suffix = `${url.search}${url.hash}`;
+  const localizedUrl =
+    basePath === '/' ? newPathname + suffix : basePath + newPathname + suffix;
+
+  return localizedUrl;
+};
+
+export const createLocaleRedirectResponse = (location: string): Response =>
+  new Response(null, {
+    status: 302,
+    headers: {
+      'Cache-Control': 'private, no-store',
+      Location: location,
+      Vary: 'Accept-Language, Cookie',
+    },
+  });

package/src/paths.ts

@@ -0,0 +1,37 @@
+import { splitUrlTarget } from '@modern-js/runtime-utils/url';
+import {
+  canonicalTargetPathname,
+  type LocalisedUrlsOption,
+  localiseTargetPathname,
+} from './localisedUrls';
+
+export interface LocalizedPathsConfig {
+  languages: string[];
+  localisedUrls?: LocalisedUrlsOption;
+}
+
+/** Synchronous mapped URL construction, independent of React/plugin setup. */
+export const buildLocalizedUrl = (
+  target: string,
+  language: string,
+  languages: string[],
+  localisedUrls?: LocalisedUrlsOption,
+): string => {
+  const { pathname, search, hash } = splitUrlTarget(target);
+  return `${localiseTargetPathname(pathname, language, languages, localisedUrls)}${search}${hash}`;
+};
+
+export const localizePath = (
+  target: string,
+  language: string,
+  config: LocalizedPathsConfig,
+): string =>
+  buildLocalizedUrl(target, language, config.languages, config.localisedUrls);
+
+export const canonicalPath = (
+  target: string,
+  config: LocalizedPathsConfig,
+): string => {
+  const { pathname, search, hash } = splitUrlTarget(target);
+  return `${canonicalTargetPathname(pathname, config.languages, config.localisedUrls)}${search}${hash}`;
+};

package/tests/localeRedirectPolicy.test.ts

@@ -0,0 +1,205 @@
+import { describe, expect, test } from '@rstest/core';
+import {
+  buildLocalizedUrl,
+  createLocaleRedirectResponse,
+  getLanguageFromPath,
+  isStaticResourceRequest,
+  shouldIgnoreRedirect,
+} from '../src/localeRedirectPolicy';
+
+const languages = ['en', 'cs'];
+const request = (url: string) => ({
+  url,
+  header: () => ({ host: 'example.com' }),
+});
+
+describe('locale redirect resource policy', () => {
+  test('exempts default static and federation routes, including locale prefixes', () => {
+    const paths = [
+      '/backend-mf-manifest.json',
+      '/backendRemoteEntry.cjs',
+      '/mf-manifest.json',
+      '/mf-stats.json',
+      '/remoteEntry.js',
+      '/static/app.js',
+      '/upload/avatar.png',
+    ];
+
+    for (const pathname of paths) {
+      expect(isStaticResourceRequest(pathname, [], languages)).toBe(true);
+      expect(isStaticResourceRequest(`/cs${pathname}`, [], languages)).toBe(
+        true,
+      );
+      expect(shouldIgnoreRedirect(`/store${pathname}`, '/store/*')).toBe(true);
+    }
+  });
+
+  test('configured static prefixes match complete path segments with or without a locale', () => {
+    for (const pathname of ['/assets', '/assets/app.js', '/en/assets/app.js']) {
+      expect(isStaticResourceRequest(pathname, ['/assets/'], languages)).toBe(
+        true,
+      );
+    }
+    for (const pathname of [
+      '/assets-extra/app.js',
+      '/cs/assets-extra/app.js',
+    ]) {
+      expect(isStaticResourceRequest(pathname, ['/assets'], languages)).toBe(
+        false,
+      );
+    }
+    expect(
+      isStaticResourceRequest('/fr/assets/app.js', ['/assets'], languages),
+    ).toBe(false);
+    expect(
+      isStaticResourceRequest('/remoteEntry.js/product', [], languages),
+    ).toBe(false);
+    expect(isStaticResourceRequest('/static-product', [])).toBe(false);
+  });
+
+  test('custom ignore lists operate after stripping the mount path', () => {
+    expect(
+      shouldIgnoreRedirect('/store/health/live', '/store/*', ['/health']),
+    ).toBe(true);
+    expect(
+      shouldIgnoreRedirect('/store/healthy', '/store/*', ['/health']),
+    ).toBe(false);
+    expect(shouldIgnoreRedirect('/store/products', '/store/*')).toBe(false);
+  });
+
+  test('custom callbacks receive the remaining pathname and default exemptions take priority', () => {
+    const seen: string[] = [];
+    const ignore = (pathname: string) => {
+      seen.push(pathname);
+      return pathname === '/health';
+    };
+
+    expect(shouldIgnoreRedirect('/store/health', '/store/*', ignore)).toBe(
+      true,
+    );
+    expect(shouldIgnoreRedirect('/store/products', '/store/*', ignore)).toBe(
+      false,
+    );
+    expect(
+      shouldIgnoreRedirect('/store/static/app.js', '/store/*', ignore),
+    ).toBe(true);
+    expect(seen).toEqual(['/health', '/products']);
+  });
+
+  test('preserves startsWith mount removal and empty remaining path behavior', () => {
+    expect(shouldIgnoreRedirect('/storefront', '/store/*', ['/front'])).toBe(
+      true,
+    );
+    expect(shouldIgnoreRedirect('/store', '/store/*', ['/'])).toBe(true);
+    expect(shouldIgnoreRedirect('/health', '', ['/health'])).toBe(true);
+    expect(shouldIgnoreRedirect('/health', '/', ['/health'])).toBe(true);
+    expect(shouldIgnoreRedirect('/health', '/other/*', ['/health'])).toBe(true);
+  });
+});
+
+describe('locale redirect URL policy', () => {
+  test('detects a configured first language segment for relative or absolute URLs', () => {
+    expect(
+      getLanguageFromPath(
+        request('/store/cs/products?x=1'),
+        '/store/*',
+        languages,
+      ),
+    ).toBe('cs');
+    expect(
+      getLanguageFromPath(
+        request('https://example.com/en/products'),
+        '/',
+        languages,
+      ),
+    ).toBe('en');
+    expect(getLanguageFromPath(request('/cs/products'), '', languages)).toBe(
+      'cs',
+    );
+    expect(
+      getLanguageFromPath(request('/storecs/products'), '/store/*', languages),
+    ).toBe('cs');
+  });
+
+  test('retains case-sensitive language detection and does not search later segments', () => {
+    for (const pathname of [
+      '/store',
+      '/store/CS/products',
+      '/store/fr/products',
+      '/store/products/cs',
+    ]) {
+      expect(
+        getLanguageFromPath(request(pathname), '/store/*', languages),
+      ).toBeNull();
+    }
+  });
+
+  test('switches localized dynamic paths while preserving mount, query and hash', () => {
+    expect(
+      buildLocalizedUrl(
+        request(
+          'https://example.com/store/en/products/red%20tractor?q=a%2Fb&sort=price#details',
+        ),
+        '/store/*',
+        'cs',
+        languages,
+        { '/products/:slug': { en: '/products/:slug', cs: '/produkty/:slug' } },
+      ),
+    ).toBe('/store/cs/produkty/red%20tractor?q=a%2Fb&sort=price#details');
+  });
+
+  test('supports root and empty mounts and missing locale mapping', () => {
+    for (const mount of ['/', '', '/*']) {
+      expect(
+        buildLocalizedUrl(
+          request('https://example.com/products?x=1#top'),
+          mount,
+          'cs',
+          languages,
+        ),
+      ).toBe('/cs/products?x=1#top');
+    }
+    expect(
+      buildLocalizedUrl(
+        request('https://example.com/store'),
+        '/store/*',
+        'cs',
+        languages,
+        false,
+      ),
+    ).toBe('/store/cs');
+  });
+
+  test('preserves the existing nonmatching and partial mount behavior', () => {
+    expect(
+      buildLocalizedUrl(
+        request('https://example.com/products'),
+        '/store/*',
+        'cs',
+        languages,
+      ),
+    ).toBe('/store/cs/products');
+    expect(
+      buildLocalizedUrl(
+        request('https://example.com/storefront'),
+        '/store/*',
+        'cs',
+        languages,
+      ),
+    ).toBe('/store/cs/front');
+  });
+
+  test('returns a non-cacheable temporary redirect with language negotiation headers', async () => {
+    const response = createLocaleRedirectResponse(
+      '/cs/produkty?sort=price#details',
+    );
+
+    expect(response.status).toBe(302);
+    expect(response.headers.get('Location')).toBe(
+      '/cs/produkty?sort=price#details',
+    );
+    expect(response.headers.get('Cache-Control')).toBe('private, no-store');
+    expect(response.headers.get('Vary')).toBe('Accept-Language, Cookie');
+    expect(await response.text()).toBe('');
+  });
+});

package/tests/localisedUrls.test.ts

@@ -25,13 +25,11 @@ const createRoute = (
 });
 
 describe('resolveLocalisedUrlsConfig', () => {
-  test('is opt-in: only a non-empty map enables the feature', () => {
+  test('enables the feature only for a non-empty map', () => {
     const map = { '/about': { en: '/about', cs: '/o-nas' } };
-    expect(resolveLocalisedUrlsConfig(map)).toEqual({ enabled: true, map });
-  });
-
-  test('absent, boolean and empty-map options resolve to disabled', () => {
     const disabled = { enabled: false, map: {} };
+
+    expect(resolveLocalisedUrlsConfig(map)).toEqual({ enabled: true, map });
     expect(resolveLocalisedUrlsConfig(undefined)).toEqual(disabled);
     expect(resolveLocalisedUrlsConfig(false)).toEqual(disabled);
     expect(resolveLocalisedUrlsConfig(true)).toEqual(disabled);
@@ -207,9 +205,6 @@ describe('localisedUrls', () => {
       localisedUrls,
     );
 
-    expect(
-      applyLocalisedUrlsToRoutes(routes, ['en', 'cs', 'de'], localisedUrls),
-    ).toEqual(localisedRoutes);
     expect(localisedRoutes.map(route => route.path)).toEqual([
       ':lang/about',
       ':lang/o.nas',
@@ -304,62 +299,6 @@ describe('localisedUrls', () => {
     ]);
   });
 
-  test('expands flat locale-prefixed route paths with canonical keys', () => {
-    const routes = [
-      createRoute('/:lang/about'),
-      createRoute('/:lang/products/:slug'),
-    ];
-
-    const localisedRoutes = applyLocalisedUrlsToRoutes(routes, ['en', 'cs'], {
-      '/about': {
-        en: '/about',
-        cs: '/o-nas',
-      },
-      '/products/:slug': {
-        en: '/products/:slug',
-        cs: '/produkty/:slug',
-      },
-    });
-
-    expect(localisedRoutes.map(route => route.path)).toEqual([
-      ':lang/about',
-      ':lang/o-nas',
-      ':lang/products/:slug',
-      ':lang/produkty/:slug',
-    ]);
-  });
-
-  test('resolves current localized path to the target language', () => {
-    const localisedUrls = {
-      '/terms-of-service': {
-        en: '/terms-of-service',
-        cs: '/podminky-pouzivani',
-      },
-      '/products/:slug': {
-        en: '/products/:slug',
-        cs: '/produkty/:slug',
-      },
-    };
-
-    expect(
-      resolveLocalisedPath(
-        '/terms-of-service',
-        'cs',
-        ['en', 'cs'],
-        localisedUrls,
-      ),
-    ).toBe('/podminky-pouzivani');
-    expect(
-      resolveLocalisedPath('/produkty/cervena-bota', 'en', ['en', 'cs'], {
-        ...localisedUrls,
-        '/products/:slug': {
-          en: '/products/:slug',
-          cs: '/produkty/:slug',
-        },
-      }),
-    ).toBe('/products/cervena-bota');
-  });
-
   test('resolves optional route params', () => {
     const localisedUrls = {
       '/products/:slug?': {
@@ -455,30 +394,6 @@ describe('localisedUrls', () => {
     ).toBe('/products/new');
   });
 
-  test('reverse resolution is deterministic for equally specific matches', () => {
-    const firstOrder = {
-      '/z/:slug': {
-        en: '/x/:slug',
-        cs: '/z/:slug',
-      },
-      '/a/:section': {
-        en: '/:section/y',
-        cs: '/a/:section',
-      },
-    };
-    const reverseOrder = {
-      '/a/:section': firstOrder['/a/:section'],
-      '/z/:slug': firstOrder['/z/:slug'],
-    };
-
-    expect(
-      resolveCanonicalLocalisedPath('/x/y', ['en', 'cs'], firstOrder),
-    ).toBe('/a/x');
-    expect(
-      resolveCanonicalLocalisedPath('/x/y', ['en', 'cs'], reverseOrder),
-    ).toBe('/a/x');
-  });
-
   test('reverse resolution prefers the most specific localised source pattern', () => {
     const localisedUrls = {
       '/catalog/:section/:item/:detail': {
@@ -537,31 +452,6 @@ describe('localisedUrls', () => {
     ).toThrow('Missing required path parameter "toString"');
   });
 
-  test('localises and canonicalises full target pathnames through one helper', () => {
-    const localisedUrls = {
-      '/products/:slug': {
-        en: '/products/:slug',
-        cs: '/produkty/:slug',
-      },
-    };
-
-    expect(
-      localiseTargetPathname(
-        '/en/products/cervena-bota',
-        'cs',
-        ['en', 'cs'],
-        localisedUrls,
-      ),
-    ).toBe('/cs/produkty/cervena-bota');
-    expect(
-      canonicalTargetPathname(
-        '/cs/produkty/cervena-bota',
-        ['en', 'cs'],
-        localisedUrls,
-      ),
-    ).toBe('/products/cervena-bota');
-  });
-
   test('strips case-insensitive locale prefixes before relocalising full pathnames', () => {
     const localisedUrls = {
       '/products/:slug': {

package/tests/paths.test.ts

@@ -0,0 +1,189 @@
+import { describe, expect, test } from '@rstest/core';
+import type { LocalisedUrlsMap } from '../src/localisedUrls';
+import { buildLocalizedUrl, canonicalPath, localizePath } from '../src/paths';
+
+const languages = ['en', 'cs'];
+
+const localisedUrls = {
+  '/products/:slug': {
+    en: '/products/:slug',
+    cs: '/produkty/:slug',
+  },
+  '/files/*': {
+    en: '/files/*',
+    cs: '/soubory/*',
+  },
+  '/app/products/:slug': {
+    en: '/app/products/:slug',
+    cs: '/app/produkty/:slug',
+  },
+} satisfies LocalisedUrlsMap;
+
+const pathsConfig = {
+  languages,
+  localisedUrls,
+};
+
+describe('fork-owned localised URL rewrite matrix', () => {
+  const rewriteScenarios = [
+    {
+      name: 'adds the target locale prefix and localises canonical segments',
+      target: '/products/red-shoe',
+      language: 'cs',
+      expected: '/cs/produkty/red-shoe',
+    },
+    {
+      name: 'strips a case-insensitive source locale before relocalising',
+      target: '/CS/produkty/red%20shoe?tag=boots#details',
+      language: 'en',
+      expected: '/en/products/red%20shoe?tag=boots#details',
+    },
+    {
+      name: 'preserves repeated query keys and the fragment',
+      target: '/products/red-shoe?tag=boots&tag=sale#details',
+      language: 'cs',
+      expected: '/cs/produkty/red-shoe?tag=boots&tag=sale#details',
+    },
+    {
+      name: 'keeps a base-path segment inside the localised route map',
+      target: '/app/products/red-shoe?ref=nav#details',
+      language: 'cs',
+      expected: '/cs/app/produkty/red-shoe?ref=nav#details',
+    },
+    {
+      name: 'keeps the default locale explicitly prefixed',
+      target: '/products/red-shoe',
+      language: 'en',
+      expected: '/en/products/red-shoe',
+    },
+    {
+      name: 'does not double-prefix an already-localised URL',
+      target: '/cs/produkty/red-shoe?tag=boots#details',
+      language: 'cs',
+      expected: '/cs/produkty/red-shoe?tag=boots#details',
+    },
+  ];
+
+  for (const scenario of rewriteScenarios) {
+    test(scenario.name, () => {
+      expect(
+        buildLocalizedUrl(
+          scenario.target,
+          scenario.language,
+          languages,
+          localisedUrls,
+        ),
+      ).toBe(scenario.expected);
+    });
+  }
+
+  test('canonical and localized path helpers strip and add prefixes exactly', () => {
+    expect(
+      canonicalPath('/CS/produkty/red-shoe?tag=boots#details', pathsConfig),
+    ).toBe('/products/red-shoe?tag=boots#details');
+    expect(
+      localizePath('/products/red-shoe?tag=boots#details', 'cs', pathsConfig),
+    ).toBe('/cs/produkty/red-shoe?tag=boots#details');
+  });
+
+  test('splat params preserve separators and percent-encode each segment', () => {
+    expect(
+      buildLocalizedUrl(
+        '/files/resume%20drafts/Q1%20deck.pdf',
+        'cs',
+        languages,
+        localisedUrls,
+      ),
+    ).toBe('/cs/soubory/resume%20drafts/Q1%20deck.pdf');
+  });
+  test('explicit maps work without plugin registration and keep suffixes verbatim', () => {
+    const config = {
+      languages,
+      localisedUrls: {
+        '/docs/:slug?': { en: '/docs/:slug?', cs: '/dokumenty/:slug?' },
+      },
+    };
+    expect(localizePath('/docs?x=%2f&x=2#literal?query', 'cs', config)).toBe(
+      '/cs/dokumenty?x=%2f&x=2#literal?query',
+    );
+    expect(canonicalPath('/cs/dokumenty/%E0%A4%A', config)).toBe(
+      '/dokumenty/%E0%A4%A',
+    );
+    expect(localizePath('/[literal]?x=1#x', 'cs', { languages })).toBe(
+      '/cs/[literal]?x=1#x',
+    );
+  });
+});
+
+describe('migrated public mapped helper contract', () => {
+  const localisedUrls = {
+    '/terms-of-service': {
+      en: '/terms-of-service',
+      cs: '/podminky-pouzivani',
+    },
+    '/products': {
+      en: '/products',
+      cs: '/produkty',
+    },
+    '/products/:slug': {
+      en: '/products/:slug',
+      cs: '/produkty/:slug',
+    },
+    // Canonical key that matches no language pattern.
+    '/talks/:slug': {
+      en: '/lectures/:slug',
+      cs: '/prednasky/:slug',
+    },
+  };
+
+  const languages = ['en', 'cs'];
+  const pathsConfig = { languages, localisedUrls };
+
+  test('query and hash survive localized slug mapping', () => {
+    expect(
+      buildLocalizedUrl(
+        '/products/bota?tag=x#detail',
+        'cs',
+        languages,
+        localisedUrls,
+      ),
+    ).toBe('/cs/produkty/bota?tag=x#detail');
+  });
+
+  test('localizes canonical keys that match no language pattern', () => {
+    expect(
+      buildLocalizedUrl(
+        '/talks/ai-slop#abstract',
+        'cs',
+        languages,
+        localisedUrls,
+      ),
+    ).toBe('/cs/prednasky/ai-slop#abstract');
+    expect(
+      buildLocalizedUrl('/talks/ai-slop', 'en', languages, localisedUrls),
+    ).toBe('/en/lectures/ai-slop');
+  });
+
+  test('re-localizes already-localized paths', () => {
+    expect(
+      buildLocalizedUrl('/cs/produkty/bota#x', 'en', languages, localisedUrls),
+    ).toBe('/en/products/bota#x');
+  });
+  test('localizePath maps canonical paths per language', () => {
+    expect(localizePath('/products/bota', 'cs', pathsConfig)).toBe(
+      '/cs/produkty/bota',
+    );
+    expect(localizePath('/talks/x', 'en', pathsConfig)).toBe('/en/lectures/x');
+  });
+
+  test('canonicalPath strips language and reverse-maps localized slugs', () => {
+    expect(canonicalPath('/cs/produkty/bota', pathsConfig)).toBe(
+      '/products/bota',
+    );
+    expect(canonicalPath('/en/lectures/x?q=1#h', pathsConfig)).toBe(
+      '/talks/x?q=1#h',
+    );
+    expect(canonicalPath('/cs', pathsConfig)).toBe('/');
+    expect(canonicalPath('/en/products', pathsConfig)).toBe('/products');
+  });
+});

package/tests/reactLanguageSync.test.tsx

@@ -7,6 +7,14 @@ interface Target {
   language: string;
 }
 
+beforeEach(() => {
+  rstest.stubGlobal('IS_REACT_ACT_ENVIRONMENT', true);
+});
+
+afterEach(() => {
+  rstest.unstubAllGlobals();
+});
+
 test('an abandoned suspended render cannot publish an uncommitted target', async () => {
   let resolveFirst!: () => void;
   const firstChange = new Promise<void>(resolve => {
@@ -14,6 +22,7 @@ test('an abandoned suspended render cannot publish an uncommitted target', async
   });
   const changes: string[] = [];
   const commits: string[] = [];
+  let suspended = false;
   const neverSettles = new Promise<never>(() => undefined);
   const first = { id: 'first', language: 'en' };
   const speculative = { id: 'speculative', language: 'en' };
@@ -41,6 +50,7 @@ test('an abandoned suspended render cannot publish an uncommitted target', async
       },
     });
     if (suspend) {
+      suspended = true;
       throw neverSettles;
     }
     return <main>{target.id}</main>;
@@ -68,6 +78,11 @@ test('an abandoned suspended render cannot publish an uncommitted target', async
     await Promise.resolve();
   });
 
+  expect(suspended).toBe(true);
+  expect(container.textContent).toBe('first');
+  expect(changes).toEqual(['first']);
+  expect(commits).toEqual([]);
+
   await act(async () => {
     resolveFirst();
     await firstChange;

package/tests/clientRedirectIntegration.test.tsx

@@ -1,74 +0,0 @@
-import React, { act } from 'react';
-import { createRoot } from 'react-dom/client';
-import { useClientSideRedirect } from '../../plugin-i18n/src/runtime/hooks';
-
-const navigate = rstest.fn(async () => undefined);
-let location = {
-  pathname: '/cs/about',
-  search: '?from=test',
-  hash: '#section',
-};
-
-rstest.mock('../../plugin-i18n/src/runtime/routerAdapter', () => ({
-  useI18nRouterAdapter: () => ({
-    hasRouter: true,
-    location,
-    navigate,
-  }),
-}));
-
-test('canonicalizes successive prefixed routes in one mounted provider', async () => {
-  const previousTarget = process.env.MODERN_TARGET;
-  process.env.MODERN_TARGET = 'browser';
-  const instance = {
-    language: 'cs',
-    isInitialized: true,
-  } as Parameters<typeof useClientSideRedirect>[0];
-  const localisedUrls = {
-    '/about': { en: '/about', cs: '/o-nas' },
-    '/terms-of-service': {
-      en: '/terms-of-service',
-      cs: '/podminky-pouzivani',
-    },
-  };
-  const Harness = () => {
-    useClientSideRedirect(
-      instance,
-      true,
-      ['en', 'cs'],
-      'en',
-      undefined,
-      localisedUrls,
-    );
-    return null;
-  };
-  const container = document.createElement('div');
-  const root = createRoot(container);
-
-  try {
-    window.history.replaceState(null, '', '/cs/about?from=test#section');
-    await act(async () => root.render(<Harness />));
-    expect(navigate).toHaveBeenLastCalledWith('/cs/o-nas?from=test#section', {
-      replace: true,
-    });
-
-    location = {
-      pathname: '/cs/terms-of-service',
-      search: '',
-      hash: '',
-    };
-    window.history.replaceState(null, '', '/cs/terms-of-service');
-    await act(async () => root.render(<Harness />));
-    expect(navigate).toHaveBeenLastCalledWith('/cs/podminky-pouzivani', {
-      replace: true,
-    });
-    expect(navigate).toHaveBeenCalledTimes(2);
-  } finally {
-    await act(async () => root.unmount());
-    if (previousTarget === undefined) {
-      delete process.env.MODERN_TARGET;
-    } else {
-      process.env.MODERN_TARGET = previousTarget;
-    }
-  }
-});