@bleedingdev/modern-js-plugin-i18n 3.5.0-ultramodern.99 → 3.8.1-ultramodern.2

package/dist/cjs/runtime/providerComposition.js

@@ -77,21 +77,20 @@ const createI18nRootWrapper = (options)=>(App)=>(props)=>{
                 forceUpdate,
                 synchronizeLanguage
             ]);
+            const I18nextProvider = getI18nextProvider();
+            const i18nextInstanceForProvider = (0, external_react_namespaceObject.useMemo)(()=>i18nInstance ? (0, instance_js_namespaceObject.getI18nextInstanceForProvider)(i18nInstance, lang) : void 0, [
+                i18nInstance,
+                lang
+            ]);
             const children = props.children;
             let appContent = App ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(App, {
                 ...props,
                 children: children
             }) : children;
-            if (i18nInstance) {
-                const I18nextProvider = getI18nextProvider();
-                if (I18nextProvider) {
-                    const i18nextInstanceForProvider = (0, instance_js_namespaceObject.getI18nextInstanceForProvider)(i18nInstance, lang);
-                    appContent = /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(I18nextProvider, {
-                        i18n: i18nextInstanceForProvider,
-                        children: appContent
-                    });
-                }
-            }
+            if (I18nextProvider && i18nextInstanceForProvider) appContent = /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(I18nextProvider, {
+                i18n: i18nextInstanceForProvider,
+                children: appContent
+            });
             return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(jsx_runtime_namespaceObject.Fragment, {
                 children: [
                     Boolean(htmlLangAttr) && /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(head_namespaceObject.Helmet, {

package/dist/cjs/runtime/routerAdapter.js

@@ -32,7 +32,6 @@ __webpack_require__.d(__webpack_exports__, {
 });
 const runtime_namespaceObject = require("@modern-js/runtime");
 const context_namespaceObject = require("@modern-js/runtime/context");
-const router_namespaceObject = require("@modern-js/runtime/router");
 const external_react_namespaceObject = require("react");
 const normalizeUrlPart = (value, prefix)=>{
     if ('string' != typeof value || !value) return '';
@@ -82,24 +81,33 @@ const getRouterParams = (internalContext, contextRouter)=>{
         return params;
     }, {});
 };
+const getRouterSnapshot = (internalContext, contextRouter)=>{
+    const location = getRouterStateLocation(internalContext, contextRouter);
+    const params = getRouterParams(internalContext, contextRouter);
+    return JSON.stringify([
+        location?.pathname ?? '',
+        location?.search ?? '',
+        location?.hash ?? '',
+        Object.entries(params).sort(([left], [right])=>left.localeCompare(right))
+    ]);
+};
 const useI18nRouterAdapter = ()=>{
     const runtimeContext = (0, external_react_namespaceObject.useContext)(runtime_namespaceObject.RuntimeContext);
     const internalContext = (0, external_react_namespaceObject.useContext)(context_namespaceObject.InternalRuntimeContext);
-    const inReactRouter = (0, router_namespaceObject.useInRouterContext)();
-    const reactRouterNavigate = inReactRouter ? (0, router_namespaceObject.useNavigate)() : null;
-    const reactRouterLocation = inReactRouter ? (0, router_namespaceObject.useLocation)() : null;
-    const reactRouterParams = inReactRouter ? (0, router_namespaceObject.useParams)() : {};
+    const routerApi = internalContext.router || runtimeContext.router;
+    const inReactRouter = routerApi?.useInRouterContext?.() ?? false;
+    const reactRouterNavigate = inReactRouter ? routerApi?.useNavigate?.() ?? null : null;
+    const reactRouterLocation = inReactRouter ? routerApi?.useLocation?.() ?? null : null;
+    const reactRouterParams = inReactRouter ? routerApi?.useParams?.() ?? {} : {};
     const framework = getRouterFramework(runtimeContext, internalContext, inReactRouter);
     const contextUseRouter = inReactRouter || 'tanstack' !== framework ? void 0 : internalContext.router?.useRouter || runtimeContext.router?.useRouter;
     const contextRouter = contextUseRouter ? contextUseRouter({
         warn: false
     }) : null;
-    const [, setRouterVersion] = (0, external_react_namespaceObject.useState)(0);
     const hasRouter = 'tanstack' === framework || 'react-router' === framework || Boolean(reactRouterNavigate);
-    (0, external_react_namespaceObject.useEffect)(()=>{
+    const subscribeToRouter = (0, external_react_namespaceObject.useCallback)((update)=>{
         const router = getRouterInstance(internalContext, contextRouter);
-        if (!router) return;
-        const update = ()=>setRouterVersion((version)=>version + 1);
+        if (!router) return ()=>void 0;
         const unsubscribers = [];
         if ('react-router' === framework && !inReactRouter && 'function' == typeof router.subscribe) {
             const subscribe = router.subscribe;
@@ -129,6 +137,11 @@ const useI18nRouterAdapter = ()=>{
         inReactRouter,
         internalContext
     ]);
+    const getSnapshot = (0, external_react_namespaceObject.useCallback)(()=>getRouterSnapshot(internalContext, contextRouter), [
+        contextRouter,
+        internalContext
+    ]);
+    (0, external_react_namespaceObject.useSyncExternalStore)(subscribeToRouter, getSnapshot, getSnapshot);
     const navigate = (0, external_react_namespaceObject.useCallback)((href, options)=>{
         const router = getRouterInstance(internalContext, contextRouter);
         const activeFramework = getRouterFramework(runtimeContext, internalContext, inReactRouter);
@@ -156,7 +169,7 @@ const useI18nRouterAdapter = ()=>{
     ]);
     const location = (reactRouterLocation ? normalizeLocation(reactRouterLocation) : getRouterStateLocation(internalContext, contextRouter)) || getWindowLocation();
     const params = inReactRouter ? reactRouterParams : getRouterParams(internalContext, contextRouter);
-    const Link = 'tanstack' === framework ? internalContext.router?.Link || runtimeContext.router?.Link || null : 'react-router' === framework || inReactRouter ? router_namespaceObject.Link : null;
+    const Link = 'tanstack' === framework ? internalContext.router?.Link || runtimeContext.router?.Link || null : 'react-router' === framework || inReactRouter ? routerApi?.Link ?? null : null;
     return {
         framework,
         hasRouter,

package/dist/esm/runtime/providerComposition.mjs

@@ -45,21 +45,20 @@ const createI18nRootWrapper = (options)=>(App)=>(props)=>{
                 forceUpdate,
                 synchronizeLanguage
             ]);
+            const I18nextProvider = getI18nextProvider();
+            const i18nextInstanceForProvider = useMemo(()=>i18nInstance ? getI18nextInstanceForProvider(i18nInstance, lang) : void 0, [
+                i18nInstance,
+                lang
+            ]);
             const children = props.children;
             let appContent = App ? /*#__PURE__*/ jsx(App, {
                 ...props,
                 children: children
             }) : children;
-            if (i18nInstance) {
-                const I18nextProvider = getI18nextProvider();
-                if (I18nextProvider) {
-                    const i18nextInstanceForProvider = getI18nextInstanceForProvider(i18nInstance, lang);
-                    appContent = /*#__PURE__*/ jsx(I18nextProvider, {
-                        i18n: i18nextInstanceForProvider,
-                        children: appContent
-                    });
-                }
-            }
+            if (I18nextProvider && i18nextInstanceForProvider) appContent = /*#__PURE__*/ jsx(I18nextProvider, {
+                i18n: i18nextInstanceForProvider,
+                children: appContent
+            });
             return /*#__PURE__*/ jsxs(Fragment, {
                 children: [
                     Boolean(htmlLangAttr) && /*#__PURE__*/ jsx(Helmet, {

package/dist/esm/runtime/routerAdapter.mjs

@@ -1,7 +1,6 @@
 import { RuntimeContext, isBrowser } from "@modern-js/runtime";
 import { InternalRuntimeContext, getRouterRuntimeState } from "@modern-js/runtime/context";
-import { Link as router_Link, useInRouterContext, useLocation, useNavigate, useParams } from "@modern-js/runtime/router";
-import { useCallback, useContext, useEffect, useState } from "react";
+import { useCallback, useContext, useSyncExternalStore } from "react";
 const normalizeUrlPart = (value, prefix)=>{
     if ('string' != typeof value || !value) return '';
     return value.startsWith(prefix) ? value : `${prefix}${value}`;
@@ -50,24 +49,33 @@ const getRouterParams = (internalContext, contextRouter)=>{
         return params;
     }, {});
 };
+const getRouterSnapshot = (internalContext, contextRouter)=>{
+    const location = getRouterStateLocation(internalContext, contextRouter);
+    const params = getRouterParams(internalContext, contextRouter);
+    return JSON.stringify([
+        location?.pathname ?? '',
+        location?.search ?? '',
+        location?.hash ?? '',
+        Object.entries(params).sort(([left], [right])=>left.localeCompare(right))
+    ]);
+};
 const useI18nRouterAdapter = ()=>{
     const runtimeContext = useContext(RuntimeContext);
     const internalContext = useContext(InternalRuntimeContext);
-    const inReactRouter = useInRouterContext();
-    const reactRouterNavigate = inReactRouter ? useNavigate() : null;
-    const reactRouterLocation = inReactRouter ? useLocation() : null;
-    const reactRouterParams = inReactRouter ? useParams() : {};
+    const routerApi = internalContext.router || runtimeContext.router;
+    const inReactRouter = routerApi?.useInRouterContext?.() ?? false;
+    const reactRouterNavigate = inReactRouter ? routerApi?.useNavigate?.() ?? null : null;
+    const reactRouterLocation = inReactRouter ? routerApi?.useLocation?.() ?? null : null;
+    const reactRouterParams = inReactRouter ? routerApi?.useParams?.() ?? {} : {};
     const framework = getRouterFramework(runtimeContext, internalContext, inReactRouter);
     const contextUseRouter = inReactRouter || 'tanstack' !== framework ? void 0 : internalContext.router?.useRouter || runtimeContext.router?.useRouter;
     const contextRouter = contextUseRouter ? contextUseRouter({
         warn: false
     }) : null;
-    const [, setRouterVersion] = useState(0);
     const hasRouter = 'tanstack' === framework || 'react-router' === framework || Boolean(reactRouterNavigate);
-    useEffect(()=>{
+    const subscribeToRouter = useCallback((update)=>{
         const router = getRouterInstance(internalContext, contextRouter);
-        if (!router) return;
-        const update = ()=>setRouterVersion((version)=>version + 1);
+        if (!router) return ()=>void 0;
         const unsubscribers = [];
         if ('react-router' === framework && !inReactRouter && 'function' == typeof router.subscribe) {
             const subscribe = router.subscribe;
@@ -97,6 +105,11 @@ const useI18nRouterAdapter = ()=>{
         inReactRouter,
         internalContext
     ]);
+    const getSnapshot = useCallback(()=>getRouterSnapshot(internalContext, contextRouter), [
+        contextRouter,
+        internalContext
+    ]);
+    useSyncExternalStore(subscribeToRouter, getSnapshot, getSnapshot);
     const navigate = useCallback((href, options)=>{
         const router = getRouterInstance(internalContext, contextRouter);
         const activeFramework = getRouterFramework(runtimeContext, internalContext, inReactRouter);
@@ -124,7 +137,7 @@ const useI18nRouterAdapter = ()=>{
     ]);
     const location = (reactRouterLocation ? normalizeLocation(reactRouterLocation) : getRouterStateLocation(internalContext, contextRouter)) || getWindowLocation();
     const params = inReactRouter ? reactRouterParams : getRouterParams(internalContext, contextRouter);
-    const Link = 'tanstack' === framework ? internalContext.router?.Link || runtimeContext.router?.Link || null : 'react-router' === framework || inReactRouter ? router_Link : null;
+    const Link = 'tanstack' === framework ? internalContext.router?.Link || runtimeContext.router?.Link || null : 'react-router' === framework || inReactRouter ? routerApi?.Link ?? null : null;
     return {
         framework,
         hasRouter,

package/dist/esm-node/runtime/providerComposition.mjs

@@ -46,21 +46,20 @@ const createI18nRootWrapper = (options)=>(App)=>(props)=>{
                 forceUpdate,
                 synchronizeLanguage
             ]);
+            const I18nextProvider = getI18nextProvider();
+            const i18nextInstanceForProvider = useMemo(()=>i18nInstance ? getI18nextInstanceForProvider(i18nInstance, lang) : void 0, [
+                i18nInstance,
+                lang
+            ]);
             const children = props.children;
             let appContent = App ? /*#__PURE__*/ jsx(App, {
                 ...props,
                 children: children
             }) : children;
-            if (i18nInstance) {
-                const I18nextProvider = getI18nextProvider();
-                if (I18nextProvider) {
-                    const i18nextInstanceForProvider = getI18nextInstanceForProvider(i18nInstance, lang);
-                    appContent = /*#__PURE__*/ jsx(I18nextProvider, {
-                        i18n: i18nextInstanceForProvider,
-                        children: appContent
-                    });
-                }
-            }
+            if (I18nextProvider && i18nextInstanceForProvider) appContent = /*#__PURE__*/ jsx(I18nextProvider, {
+                i18n: i18nextInstanceForProvider,
+                children: appContent
+            });
             return /*#__PURE__*/ jsxs(Fragment, {
                 children: [
                     Boolean(htmlLangAttr) && /*#__PURE__*/ jsx(Helmet, {

package/dist/esm-node/runtime/routerAdapter.mjs

@@ -1,8 +1,7 @@
 import "node:module";
 import { RuntimeContext, isBrowser } from "@modern-js/runtime";
 import { InternalRuntimeContext, getRouterRuntimeState } from "@modern-js/runtime/context";
-import { Link as router_Link, useInRouterContext, useLocation, useNavigate, useParams } from "@modern-js/runtime/router";
-import { useCallback, useContext, useEffect, useState } from "react";
+import { useCallback, useContext, useSyncExternalStore } from "react";
 const normalizeUrlPart = (value, prefix)=>{
     if ('string' != typeof value || !value) return '';
     return value.startsWith(prefix) ? value : `${prefix}${value}`;
@@ -51,24 +50,33 @@ const getRouterParams = (internalContext, contextRouter)=>{
         return params;
     }, {});
 };
+const getRouterSnapshot = (internalContext, contextRouter)=>{
+    const location = getRouterStateLocation(internalContext, contextRouter);
+    const params = getRouterParams(internalContext, contextRouter);
+    return JSON.stringify([
+        location?.pathname ?? '',
+        location?.search ?? '',
+        location?.hash ?? '',
+        Object.entries(params).sort(([left], [right])=>left.localeCompare(right))
+    ]);
+};
 const useI18nRouterAdapter = ()=>{
     const runtimeContext = useContext(RuntimeContext);
     const internalContext = useContext(InternalRuntimeContext);
-    const inReactRouter = useInRouterContext();
-    const reactRouterNavigate = inReactRouter ? useNavigate() : null;
-    const reactRouterLocation = inReactRouter ? useLocation() : null;
-    const reactRouterParams = inReactRouter ? useParams() : {};
+    const routerApi = internalContext.router || runtimeContext.router;
+    const inReactRouter = routerApi?.useInRouterContext?.() ?? false;
+    const reactRouterNavigate = inReactRouter ? routerApi?.useNavigate?.() ?? null : null;
+    const reactRouterLocation = inReactRouter ? routerApi?.useLocation?.() ?? null : null;
+    const reactRouterParams = inReactRouter ? routerApi?.useParams?.() ?? {} : {};
     const framework = getRouterFramework(runtimeContext, internalContext, inReactRouter);
     const contextUseRouter = inReactRouter || 'tanstack' !== framework ? void 0 : internalContext.router?.useRouter || runtimeContext.router?.useRouter;
     const contextRouter = contextUseRouter ? contextUseRouter({
         warn: false
     }) : null;
-    const [, setRouterVersion] = useState(0);
     const hasRouter = 'tanstack' === framework || 'react-router' === framework || Boolean(reactRouterNavigate);
-    useEffect(()=>{
+    const subscribeToRouter = useCallback((update)=>{
         const router = getRouterInstance(internalContext, contextRouter);
-        if (!router) return;
-        const update = ()=>setRouterVersion((version)=>version + 1);
+        if (!router) return ()=>void 0;
         const unsubscribers = [];
         if ('react-router' === framework && !inReactRouter && 'function' == typeof router.subscribe) {
             const subscribe = router.subscribe;
@@ -98,6 +106,11 @@ const useI18nRouterAdapter = ()=>{
         inReactRouter,
         internalContext
     ]);
+    const getSnapshot = useCallback(()=>getRouterSnapshot(internalContext, contextRouter), [
+        contextRouter,
+        internalContext
+    ]);
+    useSyncExternalStore(subscribeToRouter, getSnapshot, getSnapshot);
     const navigate = useCallback((href, options)=>{
         const router = getRouterInstance(internalContext, contextRouter);
         const activeFramework = getRouterFramework(runtimeContext, internalContext, inReactRouter);
@@ -125,7 +138,7 @@ const useI18nRouterAdapter = ()=>{
     ]);
     const location = (reactRouterLocation ? normalizeLocation(reactRouterLocation) : getRouterStateLocation(internalContext, contextRouter)) || getWindowLocation();
     const params = inReactRouter ? reactRouterParams : getRouterParams(internalContext, contextRouter);
-    const Link = 'tanstack' === framework ? internalContext.router?.Link || runtimeContext.router?.Link || null : 'react-router' === framework || inReactRouter ? router_Link : null;
+    const Link = 'tanstack' === framework ? internalContext.router?.Link || runtimeContext.router?.Link || null : 'react-router' === framework || inReactRouter ? routerApi?.Link ?? null : null;
     return {
         framework,
         hasRouter,

package/package.json

@@ -17,7 +17,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "3.5.0-ultramodern.99",
+  "version": "3.8.1-ultramodern.2",
   "engines": {
     "node": ">=20"
   },
@@ -91,12 +91,12 @@
     }
   },
   "dependencies": {
-    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.5.0-ultramodern.99",
-    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.5.0-ultramodern.99",
-    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.5.0-ultramodern.99",
-    "@modern-js/server-runtime": "npm:@bleedingdev/modern-js-server-runtime@3.5.0-ultramodern.99",
-    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.5.0-ultramodern.99",
-    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.5.0-ultramodern.99",
+    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.8.1-ultramodern.2",
+    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.8.1-ultramodern.2",
+    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.8.1-ultramodern.2",
+    "@modern-js/server-runtime": "npm:@bleedingdev/modern-js-server-runtime@3.8.1-ultramodern.2",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.8.1-ultramodern.2",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.8.1-ultramodern.2",
     "@swc/helpers": "^0.5.23",
     "i18next-browser-languagedetector": "^8.2.1",
     "i18next-chained-backend": "^5.0.5",
@@ -105,11 +105,11 @@
     "i18next-http-middleware": "^3.9.7"
   },
   "peerDependencies": {
-    "@modern-js/runtime": "3.5.0-ultramodern.99",
-    "i18next": ">=26.3.1",
-    "react": "^19.2.7",
-    "react-dom": "^19.2.7",
-    "react-i18next": "^17.0.9"
+    "@modern-js/runtime": "3.8.1-ultramodern.2",
+    "i18next": ">=25.7.4",
+    "react": ">=18",
+    "react-dom": ">=18",
+    "react-i18next": ">=15.7.4"
   },
   "peerDependenciesMeta": {
     "i18next": {
@@ -120,14 +120,15 @@
     }
   },
   "devDependencies": {
-    "@modern-js/app-tools": "npm:@bleedingdev/modern-js-app-tools@3.5.0-ultramodern.99",
-    "@modern-js/runtime": "npm:@bleedingdev/modern-js-runtime@3.5.0-ultramodern.99",
+    "@modern-js/app-tools": "npm:@bleedingdev/modern-js-app-tools@3.8.1-ultramodern.2",
+    "@modern-js/runtime": "npm:@bleedingdev/modern-js-runtime@3.8.1-ultramodern.2",
     "@rslib/core": "0.23.2",
-    "@types/node": "^26.1.1",
+    "@types/node": "^26.2.0",
     "@typescript/native-preview": "7.0.0-dev.20260707.2",
+    "esbuild": "^0.28.1",
     "i18next": "26.3.6",
-    "react": "^19.2.7",
-    "react-dom": "^19.2.7",
+    "react": "^19.2.8",
+    "react-dom": "^19.2.8",
     "react-i18next": "17.0.9",
     "ts-node": "^10.9.2",
     "typescript": "^7.0.2"

package/src/runtime/providerComposition.tsx

@@ -113,6 +113,14 @@ export const createI18nRootWrapper =
           synchronizeLanguage,
         ],
       );
+      const I18nextProvider = getI18nextProvider();
+      const i18nextInstanceForProvider = useMemo(
+        () =>
+          i18nInstance
+            ? getI18nextInstanceForProvider(i18nInstance, lang)
+            : undefined,
+        [i18nInstance, lang],
+      );
 
       const children = (props as React.PropsWithChildren).children;
       let appContent: React.ReactNode = App ? (
@@ -121,19 +129,12 @@ export const createI18nRootWrapper =
         children
       );
 
-      if (i18nInstance) {
-        const I18nextProvider = getI18nextProvider();
-        if (I18nextProvider) {
-          const i18nextInstanceForProvider = getI18nextInstanceForProvider(
-            i18nInstance,
-            lang,
-          );
-          appContent = (
-            <I18nextProvider i18n={i18nextInstanceForProvider}>
-              {appContent}
-            </I18nextProvider>
-          );
-        }
+      if (I18nextProvider && i18nextInstanceForProvider) {
+        appContent = (
+          <I18nextProvider i18n={i18nextInstanceForProvider}>
+            {appContent}
+          </I18nextProvider>
+        );
       }
 
       return (

package/src/runtime/routerAdapter.tsx

@@ -5,15 +5,8 @@ import {
   type TInternalRuntimeContext,
   type TRuntimeContext,
 } from '@modern-js/runtime/context';
-import {
-  Link as ReactRouterLink,
-  useInRouterContext,
-  useLocation as useReactRouterLocation,
-  useNavigate as useReactRouterNavigate,
-  useParams as useReactRouterParams,
-} from '@modern-js/runtime/router';
 import type React from 'react';
-import { useCallback, useContext, useEffect, useState } from 'react';
+import { useCallback, useContext, useSyncExternalStore } from 'react';
 
 type I18nRouterFramework = 'react-router' | 'tanstack' | string;
 
@@ -50,8 +43,11 @@ interface I18nRouterAdapter {
 
 type RuntimeContextWithRouter = TRuntimeContext & {
   router?: {
+    useInRouterContext?: () => boolean;
     useRouter?: (options?: { warn?: boolean }) => unknown;
     useLocation?: () => unknown;
+    useNavigate?: () => I18nRouterNavigate;
+    useParams?: () => Record<string, string>;
     useHref?: () => unknown;
     Link?: I18nRouterLink;
   };
@@ -205,15 +201,36 @@ const getRouterParams = (
   }, {});
 };
 
+const getRouterSnapshot = (
+  internalContext: InternalRuntimeContextWithRouter,
+  contextRouter?: RouterInstance | null,
+) => {
+  const location = getRouterStateLocation(internalContext, contextRouter);
+  const params = getRouterParams(internalContext, contextRouter);
+  return JSON.stringify([
+    location?.pathname ?? '',
+    location?.search ?? '',
+    location?.hash ?? '',
+    Object.entries(params).sort(([left], [right]) => left.localeCompare(right)),
+  ]);
+};
+
 export const useI18nRouterAdapter = (): I18nRouterAdapter => {
   const runtimeContext = useContext(RuntimeContext) as RuntimeContextWithRouter;
   const internalContext = useContext(
     InternalRuntimeContext,
   ) as InternalRuntimeContextWithRouter;
-  const inReactRouter = useInRouterContext();
-  const reactRouterNavigate = inReactRouter ? useReactRouterNavigate() : null;
-  const reactRouterLocation = inReactRouter ? useReactRouterLocation() : null;
-  const reactRouterParams = inReactRouter ? useReactRouterParams() : {};
+  const routerApi = internalContext.router || runtimeContext.router;
+  const inReactRouter = routerApi?.useInRouterContext?.() ?? false;
+  const reactRouterNavigate = inReactRouter
+    ? (routerApi?.useNavigate?.() ?? null)
+    : null;
+  const reactRouterLocation = inReactRouter
+    ? (routerApi?.useLocation?.() ?? null)
+    : null;
+  const reactRouterParams = inReactRouter
+    ? (routerApi?.useParams?.() ?? {})
+    : {};
   const framework = getRouterFramework(
     runtimeContext,
     internalContext,
@@ -226,66 +243,72 @@ export const useI18nRouterAdapter = (): I18nRouterAdapter => {
   const contextRouter = contextUseRouter
     ? (contextUseRouter({ warn: false }) as RouterInstance | null)
     : null;
-  const [, setRouterVersion] = useState(0);
   const hasRouter =
     framework === 'tanstack' ||
     framework === 'react-router' ||
     Boolean(reactRouterNavigate);
 
-  useEffect(() => {
-    const router = getRouterInstance(internalContext, contextRouter);
-    if (!router) {
-      return;
-    }
-
-    const update = () => setRouterVersion(version => version + 1);
-    const unsubscribers: Array<() => void> = [];
-
-    if (
-      framework === 'react-router' &&
-      !inReactRouter &&
-      typeof router.subscribe === 'function'
-    ) {
-      const subscribe = router.subscribe as (
-        this: RouterInstance,
-        listener: () => void,
-      ) => () => void;
-      const unsubscribe = subscribe.call(router, update);
-      if (typeof unsubscribe === 'function') {
-        unsubscribers.push(unsubscribe);
+  const subscribeToRouter = useCallback(
+    (update: () => void) => {
+      const router = getRouterInstance(internalContext, contextRouter);
+      if (!router) {
+        return () => undefined;
       }
-    }
 
-    if (
-      framework === 'tanstack' &&
-      typeof router.stores?.location?.subscribe === 'function'
-    ) {
-      const unsubscribe = router.stores.location.subscribe(update);
-      if (typeof unsubscribe === 'function') {
-        unsubscribers.push(unsubscribe);
+      const unsubscribers: Array<() => void> = [];
+
+      if (
+        framework === 'react-router' &&
+        !inReactRouter &&
+        typeof router.subscribe === 'function'
+      ) {
+        const subscribe = router.subscribe as (
+          this: RouterInstance,
+          listener: () => void,
+        ) => () => void;
+        const unsubscribe = subscribe.call(router, update);
+        if (typeof unsubscribe === 'function') {
+          unsubscribers.push(unsubscribe);
+        }
       }
-    }
 
-    if (framework === 'tanstack' && typeof router.subscribe === 'function') {
-      const subscribe = router.subscribe as (
-        this: RouterInstance,
-        eventType: string,
-        listener: () => void,
-      ) => () => void;
-      for (const eventType of ['onBeforeNavigate', 'onBeforeLoad']) {
-        const unsubscribe = subscribe.call(router, eventType, update);
+      if (
+        framework === 'tanstack' &&
+        typeof router.stores?.location?.subscribe === 'function'
+      ) {
+        const unsubscribe = router.stores.location.subscribe(update);
         if (typeof unsubscribe === 'function') {
           unsubscribers.push(unsubscribe);
         }
       }
-    }
 
-    return () => {
-      for (const unsubscribe of unsubscribers) {
-        unsubscribe();
+      if (framework === 'tanstack' && typeof router.subscribe === 'function') {
+        const subscribe = router.subscribe as (
+          this: RouterInstance,
+          eventType: string,
+          listener: () => void,
+        ) => () => void;
+        for (const eventType of ['onBeforeNavigate', 'onBeforeLoad']) {
+          const unsubscribe = subscribe.call(router, eventType, update);
+          if (typeof unsubscribe === 'function') {
+            unsubscribers.push(unsubscribe);
+          }
+        }
       }
-    };
-  }, [contextRouter, framework, inReactRouter, internalContext]);
+
+      return () => {
+        for (const unsubscribe of unsubscribers) {
+          unsubscribe();
+        }
+      };
+    },
+    [contextRouter, framework, inReactRouter, internalContext],
+  );
+  const getSnapshot = useCallback(
+    () => getRouterSnapshot(internalContext, contextRouter),
+    [contextRouter, internalContext],
+  );
+  useSyncExternalStore(subscribeToRouter, getSnapshot, getSnapshot);
 
   const navigate = useCallback<I18nRouterNavigate>(
     (href, options) => {
@@ -339,7 +362,7 @@ export const useI18nRouterAdapter = (): I18nRouterAdapter => {
     framework === 'tanstack'
       ? internalContext.router?.Link || runtimeContext.router?.Link || null
       : framework === 'react-router' || inReactRouter
-        ? (ReactRouterLink as I18nRouterLink)
+        ? (routerApi?.Link ?? null)
         : null;
 
   return {

package/tests/localisedUrls.test.ts

@@ -1,5 +1,3 @@
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import path from 'node:path';
 import type { NestedRouteForCli } from '@modern-js/types';
 import { describe, expect, test } from '@rstest/core';
 import { i18nPlugin as i18nCliPlugin } from '../src/cli';
@@ -19,12 +17,6 @@ import {
   validateLocalisedUrls,
 } from '../src/shared/localisedUrls';
 
-const localisedRoutesGoldenPath = path.join(
-  __dirname,
-  'fixtures',
-  'localised-routes.golden.json',
-);
-
 const createRoute = (
   path: string,
   children?: NestedRouteForCli[],
@@ -45,9 +37,6 @@ const createRequestContext = (pathname: string) =>
     },
   }) as any;
 
-const serializeRoutesForGolden = (routes: unknown): string =>
-  `${JSON.stringify(routes, null, 2)}\n`;
-
 describe('resolveLocalisedUrlsConfig', () => {
   test('is opt-in: only a non-empty map enables the feature', () => {
     const map = { '/about': { en: '/about', cs: '/o-nas' } };
@@ -119,7 +108,7 @@ describe('cli modifyFileSystemRoutes', () => {
     return modifyRoutes!;
   };
 
-  const generateLocalisedRoutesGolden = (): string => {
+  const generateLocalisedRoutes = () => {
     const modifyRoutes = setupModifyRoutes({
       localePathRedirect: true,
       languages: ['en', 'cs', 'de'],
@@ -164,23 +153,53 @@ describe('cli modifyFileSystemRoutes', () => {
       routes,
     });
 
-    return serializeRoutesForGolden(result.routes);
+    return result.routes;
   };
 
-  test('matches checked-in localised routes golden output', async () => {
-    const localisedRoutes = generateLocalisedRoutesGolden();
-    const repeatedLocalisedRoutes = generateLocalisedRoutesGolden();
+  test('creates deterministic localized aliases with canonical route identity', () => {
+    const localisedRoutes = generateLocalisedRoutes();
+    expect(generateLocalisedRoutes()).toEqual(localisedRoutes);
 
-    expect(repeatedLocalisedRoutes).toBe(localisedRoutes);
-
-    if (process.env.UPDATE_I18N_LOCALISED_ROUTES_GOLDEN === '1') {
-      await mkdir(path.dirname(localisedRoutesGoldenPath), { recursive: true });
-      await writeFile(localisedRoutesGoldenPath, localisedRoutes);
+    const [localeLayout] = localisedRoutes;
+    expect(localeLayout.children?.map(route => route.path)).toEqual([
+      'about',
+      'o-nas',
+      'ueber-uns',
+      'products',
+      'produkty',
+      'produkte',
+      'docs',
+      'dokumenty',
+      'dokumente',
+    ]);
+    expect(localeLayout.children?.slice(0, 3)).toMatchObject([
+      {
+        _component: 'about.tsx',
+        modernCanonicalPath: '/about',
+        path: 'about',
+      },
+      {
+        _component: 'about.tsx',
+        modernCanonicalPath: '/about',
+        path: 'o-nas',
+      },
+      {
+        _component: 'about.tsx',
+        modernCanonicalPath: '/about',
+        path: 'ueber-uns',
+      },
+    ]);
+    for (const productRoute of localeLayout.children?.slice(3, 6) ?? []) {
+      expect(productRoute).toMatchObject({
+        _component: 'products.tsx',
+        modernCanonicalPath: '/products',
+      });
+      expect(productRoute.children?.[0]).toMatchObject({
+        _component: ':slug.tsx',
+        modernCanonicalPath: '/products/:slug',
+        path: ':slug',
+      });
     }
-
-    await expect(readFile(localisedRoutesGoldenPath, 'utf8')).resolves.toBe(
-      localisedRoutes,
-    );
   });
 
   test('upstream-style configs without a map keep routes untouched', () => {

package/tests/reactI18nextRuntimeBoundary.test.ts

@@ -1,48 +1,198 @@
-import { readFileSync } from 'node:fs';
-import { dirname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { basename, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
 import { describe, expect, test } from '@rstest/core';
+import { build } from 'esbuild';
+import i18next from 'i18next';
+import { createElement } from 'react';
+import { renderToStaticMarkup } from 'react-dom/server';
+import { i18nPlugin as noReactI18nextPlugin } from '../src/runtime/no-react-i18next';
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
 const runtimeRoot = resolve(__dirname, '../src/runtime');
 
-const readRuntimeSource = (file: string) =>
-  readFileSync(resolve(runtimeRoot, file), 'utf8').replace(/\r\n/gu, '\n');
-
 describe('react-i18next runtime boundary', () => {
-  test('keeps the disabled runtime entry free of the optional adapter edge', () => {
-    const noReactEntry = readRuntimeSource('no-react-i18next.tsx');
-    const core = readRuntimeSource('core.tsx');
-
-    expect(noReactEntry).not.toContain('./i18n/react-i18next');
-    expect(core).not.toContain('./i18n/react-i18next');
-    expect(core).not.toContain("import('react-i18next')");
+  test('bundles the disabled runtime entry when react-i18next is unavailable', async () => {
+    await expect(
+      build({
+        bundle: true,
+        entryPoints: [resolve(runtimeRoot, 'no-react-i18next.tsx')],
+        format: 'esm',
+        packages: 'external',
+        platform: 'node',
+        plugins: [
+          {
+            name: 'reject-react-i18next',
+            setup(buildApi) {
+              buildApi.onResolve({ filter: /^react-i18next$/ }, () => {
+                throw new Error(
+                  'disabled runtime entry reached optional react-i18next',
+                );
+              });
+            },
+          },
+        ],
+        write: false,
+      }),
+    ).resolves.toBeDefined();
   });
 
-  test('keeps the runtime plugin factory entry synchronous for federation', () => {
-    const core = readRuntimeSource('core.tsx');
-    const pluginSetup = readRuntimeSource('pluginSetup.ts');
+  test('bundles the default runtime entry with the react-i18next adapter', async () => {
+    let adapterResolutions = 0;
+    await build({
+      bundle: true,
+      entryPoints: [resolve(runtimeRoot, 'index.tsx')],
+      format: 'esm',
+      packages: 'external',
+      platform: 'node',
+      plugins: [
+        {
+          name: 'observe-react-i18next',
+          setup(buildApi) {
+            buildApi.onResolve({ filter: /^react-i18next$/ }, args => {
+              adapterResolutions += 1;
+              return { external: true, path: args.path };
+            });
+          },
+        },
+      ],
+      write: false,
+    });
+
+    expect(adapterResolutions).toBeGreaterThan(0);
+  });
 
-    expect(core).not.toContain("from './i18n/backend/middleware'");
-    expect(core).not.toContain("from './i18n/utils'");
-    expect(pluginSetup).not.toContain("from './i18n/backend/middleware'");
-    expect(pluginSetup).not.toContain("from './i18n/utils'");
-    expect(pluginSetup).toContain("import('./i18n/backend/middleware')");
-    expect(pluginSetup).toContain("import('./i18n/utils')");
+  test('gets router capabilities from the selected runtime provider', async () => {
+    await expect(
+      build({
+        bundle: true,
+        entryPoints: [resolve(runtimeRoot, 'routerAdapter.tsx')],
+        format: 'esm',
+        packages: 'external',
+        platform: 'neutral',
+        plugins: [
+          {
+            name: 'reject-direct-router-provider',
+            setup(buildApi) {
+              buildApi.onResolve(
+                { filter: /^@modern-js\/runtime\/router$/ },
+                () => {
+                  throw new Error(
+                    'The i18n adapter loaded the React Router provider directly.',
+                  );
+                },
+              );
+            },
+          },
+        ],
+        write: false,
+      }),
+    ).resolves.toBeDefined();
   });
 
-  test('keeps the Modern i18n context stable across federated runtime copies', () => {
-    const context = readRuntimeSource('context.tsx');
+  test('keeps expensive lifecycle helpers behind asynchronous bundle edges', async () => {
+    const result = await build({
+      bundle: true,
+      entryPoints: [resolve(runtimeRoot, 'pluginSetup.ts')],
+      format: 'esm',
+      metafile: true,
+      outdir: 'out',
+      packages: 'external',
+      platform: 'node',
+      splitting: true,
+      write: false,
+    });
+
+    const entryOutput = Object.values(result.metafile.outputs).find(output =>
+      output.entryPoint?.endsWith('/pluginSetup.ts'),
+    );
+    if (!entryOutput) {
+      throw new Error('pluginSetup entry output was not generated');
+    }
+    const dynamicOutputNames = entryOutput.imports
+      .filter(moduleImport => moduleImport.kind === 'dynamic-import')
+      .map(moduleImport => basename(moduleImport.path));
+    const dynamicOutputs = Object.entries(result.metafile.outputs)
+      .filter(([outputPath]) =>
+        dynamicOutputNames.includes(basename(outputPath)),
+      )
+      .map(([, output]) => output);
+    const dynamicEntries = dynamicOutputs.map(output =>
+      basename(output.entryPoint ?? ''),
+    );
 
-    expect(context).toContain(
-      "Symbol.for(\n  '@modern-js/plugin-i18n/runtime/ModernI18nContext'",
+    expect(dynamicEntries).toEqual(
+      expect.arrayContaining(['middleware.ts', 'utils.ts']),
     );
-    expect(context).toContain('globalStore[modernI18nContextKey] ??=');
   });
 
-  test('keeps the default runtime entry wired to react-i18next integration', () => {
-    const defaultEntry = readRuntimeSource('index.tsx');
+  test('registers plugin lifecycle hooks synchronously', () => {
+    let beforeRender: unknown;
+    let rootWrapper: unknown;
+    const plugin = noReactI18nextPlugin({ reactI18next: false });
+    const setupResult = plugin.setup?.({
+      getRuntimeConfig: () => ({}),
+      onBeforeRender: hook => {
+        beforeRender = hook;
+      },
+      wrapRoot: wrapper => {
+        rootWrapper = wrapper;
+      },
+    } as any);
+
+    expect(setupResult).toBeUndefined();
+    expect(typeof beforeRender).toBe('function');
+    expect(typeof rootWrapper).toBe('function');
+  });
+
+  test('shares Modern i18n context across independently bundled runtime copies', async () => {
+    const tempDir = await mkdtemp(
+      resolve(__dirname, '.modern-i18n-runtime-boundary-'),
+    );
+    try {
+      const contextEntry = resolve(runtimeRoot, 'context.tsx');
+      const copies = await Promise.all(
+        ['copy-a.mjs', 'copy-b.mjs'].map(async filename => {
+          const outfile = resolve(tempDir, filename);
+          await build({
+            bundle: true,
+            entryPoints: [contextEntry],
+            format: 'esm',
+            jsx: 'automatic',
+            outfile,
+            packages: 'external',
+            platform: 'node',
+          });
+          return import(pathToFileURL(outfile).href);
+        }),
+      );
+      const [copyA, copyB] = copies;
+      const instance = i18next.createInstance();
+      await instance.init({
+        initImmediate: false,
+        lng: 'cs',
+        resources: { cs: { translation: { language: 'Jazyk' } } },
+      });
+      const Consumer = () =>
+        createElement('span', null, copyB.useModernI18n().language);
+
+      const html = renderToStaticMarkup(
+        createElement(
+          copyA.ModernI18nProvider,
+          {
+            value: {
+              i18nInstance: instance,
+              language: 'cs',
+              languages: ['en', 'cs'],
+            },
+          },
+          createElement(Consumer),
+        ),
+      );
 
-    expect(defaultEntry).toContain('./i18n/react-i18next');
+      expect(html).toBe('<span>cs</span>');
+    } finally {
+      await rm(tempDir, { force: true, recursive: true });
+    }
   });
 });

package/tests/routerAdapter.test.tsx

@@ -20,6 +20,7 @@ import { I18nLink } from '../src/runtime/I18nLink';
 import type { I18nInstance } from '../src/runtime/i18n';
 import { getReactI18nextIntegration } from '../src/runtime/i18n/react-i18next';
 import { createI18nRootWrapper } from '../src/runtime/providerComposition';
+import { useI18nRouterAdapter } from '../src/runtime/routerAdapter';
 
 (
   globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }
@@ -244,9 +245,68 @@ function createMutableTanstackRouter(pathname = '/en') {
         listener();
       }
     },
+    publishStateUpdate() {
+      for (const listener of listeners) {
+        listener();
+      }
+    },
   };
 }
 
+function createMutableReactRouter(
+  pathname = '/en',
+  params: Record<string, string> = { lang: pathname.slice(1) },
+) {
+  const listeners = new Set<() => void>();
+  const router = {
+    state: {
+      location: {
+        pathname,
+        search: '',
+        hash: '',
+      },
+      matches: [{ params }],
+      fetchers: new Map<string, unknown>(),
+    },
+    subscribe(listener: () => void) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    publishFetcherUpdate() {
+      router.state = {
+        ...router.state,
+        fetchers: new Map([['fetcher', { state: 'idle' }]]),
+      };
+      for (const listener of listeners) {
+        listener();
+      }
+    },
+    publishPathname(nextPathname: string) {
+      router.state = {
+        ...router.state,
+        location: {
+          ...router.state.location,
+          pathname: nextPathname,
+        },
+      };
+      for (const listener of listeners) {
+        listener();
+      }
+    },
+    publishParams(nextParams: Record<string, string>) {
+      router.state = {
+        ...router.state,
+        matches: [{ params: nextParams }],
+      };
+      for (const listener of listeners) {
+        listener();
+      }
+    },
+  };
+
+  return router;
+}
+
 function createDeferredI18nInstance() {
   const resources = {
     en: { languageSwitcher: 'Language' },
@@ -459,6 +519,53 @@ describe('i18n runtime wrapRoot', () => {
     expect(rendered.container.textContent).toContain('router content');
   });
 
+  test('keeps the i18next provider instance stable across unrelated parent renders', async () => {
+    const i18nInstance = createI18nInstance('cs');
+    const providerInstances: I18nInstance[] = [];
+    const I18nextProvider = ({
+      children,
+      i18n,
+    }: PropsWithChildren<{ i18n: I18nInstance }>) => {
+      providerInstances.push(i18n);
+      return <>{children}</>;
+    };
+    const App = () => <main>router content</main>;
+    const I18nRoot = createI18nRootWrapper({
+      htmlLangAttr: false,
+      localePathRedirect: false,
+      languages: ['en', 'cs'],
+      fallbackLanguage: 'en',
+      getLatestI18nInstance: () => i18nInstance,
+      getI18nextProvider: () => I18nextProvider,
+    })(App);
+    const Parent = () => {
+      const [renderVersion, setRenderVersion] = useState(0);
+      return (
+        <>
+          <button
+            type="button"
+            onClick={() => setRenderVersion(version => version + 1)}
+          >
+            Render {renderVersion}
+          </button>
+          <I18nRoot renderVersion={renderVersion} />
+        </>
+      );
+    };
+
+    rendered = await renderI18nRoot(<Parent />);
+    const initialProviderInstance = providerInstances.at(-1);
+
+    await act(async () => {
+      rendered?.container
+        .querySelector('button')
+        ?.dispatchEvent(new MouseEvent('click', { bubbles: true }));
+    });
+
+    expect(providerInstances.length).toBeGreaterThan(1);
+    expect(providerInstances.at(-1)).toBe(initialProviderInstance);
+  });
+
   test('commits route language and translated copy after the instance changes', async () => {
     window.history.replaceState(null, '', '/en');
     const router = createMutableTanstackRouter();
@@ -762,6 +869,83 @@ describe('i18n router adapter', () => {
     expect(link?.getAttribute('data-router-link')).toBe('tanstack');
   });
 
+  test('ignores router state updates that do not change location or params', async () => {
+    const router = createMutableTanstackRouter('/en');
+    let renders = 0;
+    const LocationProbe = () => {
+      renders += 1;
+      const { location } = useI18nRouterAdapter();
+      return <output>{location?.pathname}</output>;
+    };
+
+    rendered = await renderWithRuntime(
+      <LocationProbe />,
+      createTanstackRuntimeContext(router),
+    );
+    const initialRenders = renders;
+
+    await act(async () => {
+      router.publishStateUpdate();
+    });
+    expect(renders).toBe(initialRenders);
+    expect(rendered.container.textContent).toBe('/en');
+
+    await act(async () => {
+      router.publishPathname('/cs');
+    });
+    expect(renders).toBe(initialRenders + 1);
+    expect(rendered.container.textContent).toBe('/cs');
+  });
+
+  test('ignores React Router fetcher updates while observing location changes', async () => {
+    const router = createMutableReactRouter('/en');
+    let renders = 0;
+    const LocationProbe = () => {
+      renders += 1;
+      const { location } = useI18nRouterAdapter();
+      return <output>{location?.pathname}</output>;
+    };
+
+    rendered = await renderWithRuntime(
+      <LocationProbe />,
+      createReactRouterRuntimeContext(router),
+    );
+    const initialRenders = renders;
+
+    await act(async () => {
+      router.publishFetcherUpdate();
+    });
+    expect(renders).toBe(initialRenders);
+    expect(rendered.container.textContent).toBe('/en');
+
+    await act(async () => {
+      router.publishPathname('/cs');
+    });
+    expect(renders).toBe(initialRenders + 1);
+    expect(rendered.container.textContent).toBe('/cs');
+  });
+
+  test('observes distinct route params without serialized snapshot collisions', async () => {
+    const router = createMutableReactRouter('/products', {
+      a: '1&b=2',
+    });
+    const ParamsProbe = () => {
+      const { params } = useI18nRouterAdapter();
+      return <output>{JSON.stringify(params)}</output>;
+    };
+
+    rendered = await renderWithRuntime(
+      <ParamsProbe />,
+      createReactRouterRuntimeContext(router),
+    );
+    expect(rendered.container.textContent).toBe('{"a":"1&b=2"}');
+
+    await act(async () => {
+      router.publishParams({ a: '1', b: '2' });
+    });
+    expect(rendered.container.textContent).toBe('{"a":"1","b":"2"}');
+  });
+
   test('forwards warmup props through I18nLink with a localized string target', async () => {
     const router = createTanstackRouter('/cs/podminky-pouzivani', 'cs');
     rendered = await renderWithRuntime(

package/tests/fixtures/localised-routes.golden.json

@@ -1,156 +0,0 @@
-[
-  {
-    "id": ":lang",
-    "path": ":lang",
-    "type": "nested",
-    "origin": "file-system",
-    "routeType": "layout",
-    "_component": ":lang.tsx",
-    "children": [
-      {
-        "id": "about",
-        "path": "about",
-        "type": "nested",
-        "origin": "file-system",
-        "routeType": "page",
-        "_component": "about.tsx",
-        "modernCanonicalPath": "/about"
-      },
-      {
-        "id": "about__localised_o-nas",
-        "path": "o-nas",
-        "type": "nested",
-        "origin": "file-system",
-        "routeType": "page",
-        "_component": "about.tsx",
-        "modernCanonicalPath": "/about"
-      },
-      {
-        "id": "about__localised_ueber-uns",
-        "path": "ueber-uns",
-        "type": "nested",
-        "origin": "file-system",
-        "routeType": "page",
-        "_component": "about.tsx",
-        "modernCanonicalPath": "/about"
-      },
-      {
-        "id": "products",
-        "path": "products",
-        "type": "nested",
-        "origin": "file-system",
-        "routeType": "layout",
-        "_component": "products.tsx",
-        "children": [
-          {
-            "id": ":slug",
-            "path": ":slug",
-            "type": "nested",
-            "origin": "file-system",
-            "routeType": "page",
-            "_component": ":slug.tsx",
-            "modernCanonicalPath": "/products/:slug"
-          }
-        ],
-        "modernCanonicalPath": "/products"
-      },
-      {
-        "id": "products__localised_produkty",
-        "path": "produkty",
-        "type": "nested",
-        "origin": "file-system",
-        "routeType": "layout",
-        "_component": "products.tsx",
-        "children": [
-          {
-            "id": ":slug__localised_produkty",
-            "path": ":slug",
-            "type": "nested",
-            "origin": "file-system",
-            "routeType": "page",
-            "_component": ":slug.tsx",
-            "modernCanonicalPath": "/products/:slug"
-          }
-        ],
-        "modernCanonicalPath": "/products"
-      },
-      {
-        "id": "products__localised_produkte",
-        "path": "produkte",
-        "type": "nested",
-        "origin": "file-system",
-        "routeType": "layout",
-        "_component": "products.tsx",
-        "children": [
-          {
-            "id": ":slug__localised_produkte",
-            "path": ":slug",
-            "type": "nested",
-            "origin": "file-system",
-            "routeType": "page",
-            "_component": ":slug.tsx",
-            "modernCanonicalPath": "/products/:slug"
-          }
-        ],
-        "modernCanonicalPath": "/products"
-      },
-      {
-        "id": "docs",
-        "path": "docs",
-        "type": "nested",
-        "origin": "file-system",
-        "routeType": "layout",
-        "_component": "docs.tsx",
-        "children": [
-          {
-            "id": "*",
-            "path": "*",
-            "type": "nested",
-            "origin": "file-system",
-            "routeType": "page",
-            "_component": "*.tsx"
-          }
-        ],
-        "modernCanonicalPath": "/docs"
-      },
-      {
-        "id": "docs__localised_dokumenty",
-        "path": "dokumenty",
-        "type": "nested",
-        "origin": "file-system",
-        "routeType": "layout",
-        "_component": "docs.tsx",
-        "children": [
-          {
-            "id": "*__localised_dokumenty",
-            "path": "*",
-            "type": "nested",
-            "origin": "file-system",
-            "routeType": "page",
-            "_component": "*.tsx"
-          }
-        ],
-        "modernCanonicalPath": "/docs"
-      },
-      {
-        "id": "docs__localised_dokumente",
-        "path": "dokumente",
-        "type": "nested",
-        "origin": "file-system",
-        "routeType": "layout",
-        "_component": "docs.tsx",
-        "children": [
-          {
-            "id": "*__localised_dokumente",
-            "path": "*",
-            "type": "nested",
-            "origin": "file-system",
-            "routeType": "page",
-            "_component": "*.tsx"
-          }
-        ],
-        "modernCanonicalPath": "/docs"
-      }
-    ]
-  }
-]