@bleedingdev/modern-js-runtime-extensions 3.9.0-ultramodern.9 → 3.9.3-ultramodern.2

package/dist/esm/localisedUrls/resolve.mjs

@@ -0,0 +1,37 @@
+import { normalisePathname } from "./normalise.mjs";
+import { buildPathFromPattern, matchPathPattern, sortPatternsBySpecificity } from "./patterns.mjs";
+const getCanonicalCandidates = (localisedUrls)=>sortPatternsBySpecificity(Object.entries(localisedUrls).map(([canonicalPattern, localisedUrlEntry])=>({
+            pattern: canonicalPattern,
+            canonicalPattern,
+            localisedUrlEntry
+        })));
+const resolveLocalisedUrlPath = (pathname, languages, localisedUrls, options)=>{
+    const normalizedPathname = normalisePathname(pathname);
+    const canonicalCandidates = getCanonicalCandidates(localisedUrls);
+    const candidates = sortPatternsBySpecificity(canonicalCandidates.flatMap(({ canonicalPattern, localisedUrlEntry })=>{
+        const targetPattern = 'localised' === options.mode ? localisedUrlEntry[options.targetLanguage] : canonicalPattern;
+        if (!targetPattern) return [];
+        const sourcePatterns = new Set([
+            canonicalPattern,
+            ...languages.map((language)=>localisedUrlEntry[language]).filter((sourcePattern)=>Boolean(sourcePattern))
+        ]);
+        return Array.from(sourcePatterns, (sourcePattern)=>({
+                pattern: sourcePattern,
+                sourcePattern,
+                targetPattern
+            }));
+    }));
+    for (const { sourcePattern, targetPattern } of candidates){
+        const params = matchPathPattern(normalizedPathname, sourcePattern);
+        if (params) return buildPathFromPattern(targetPattern, params);
+    }
+    return normalizedPathname;
+};
+const resolveLocalisedPath = (pathname, targetLanguage, languages, localisedUrls)=>resolveLocalisedUrlPath(pathname, languages, localisedUrls, {
+        mode: 'localised',
+        targetLanguage
+    });
+const resolveCanonicalLocalisedPath = (pathname, languages, localisedUrls)=>resolveLocalisedUrlPath(pathname, languages, localisedUrls, {
+        mode: 'canonical'
+    });
+export { resolveCanonicalLocalisedPath, resolveLocalisedPath };

package/dist/esm/localisedUrls/routeIdentity.mjs

@@ -0,0 +1,54 @@
+import { normalisePathPattern } from "./normalise.mjs";
+import { buildPathFromPattern, matchPathPattern } from "./patterns.mjs";
+function rewritePath(url, mappings) {
+    for (const { from, to } of mappings){
+        const params = matchPathPattern(url.pathname, from);
+        if (params) {
+            url.pathname = buildPathFromPattern(to, params);
+            break;
+        }
+    }
+    return url;
+}
+function createLocalisedRouteRewrite(routes) {
+    const input = [];
+    const output = [];
+    const visit = (nodes, parent)=>{
+        for (const route of nodes){
+            const fullPath = normalisePathPattern(`${parent}/${route.path ?? ''}`);
+            const identity = route.modernLocalisedRoute;
+            if (identity?.paths && fullPath.endsWith(identity.canonicalPath)) {
+                const prefix = fullPath.slice(0, -identity.canonicalPath.length);
+                const hasLocale = prefix.split('/').some((segment)=>/^:(?:lang|locale|language)\??$/.test(segment));
+                for (const [language, localisedPath] of Object.entries(identity.paths)){
+                    const localePrefix = prefix.split('/').map((segment)=>/^:(?:lang|locale|language)\??$/.test(segment) ? language : segment).join('/');
+                    const canonical = normalisePathPattern(`${localePrefix}/${identity.canonicalPath}`);
+                    const localised = normalisePathPattern(`${localePrefix}/${localisedPath}`);
+                    if (canonical !== localised) {
+                        input.push({
+                            from: localised,
+                            to: canonical
+                        });
+                        if (hasLocale) output.push({
+                            from: canonical,
+                            to: localised
+                        });
+                    }
+                }
+            }
+            if (route.children) visit(route.children, fullPath);
+        }
+    };
+    visit(routes, '');
+    if (0 === input.length) return;
+    const specificity = (pattern)=>pattern.split('/').filter((segment)=>segment && !segment.startsWith(':') && '*' !== segment).length;
+    for (const mappings of [
+        input,
+        output
+    ])mappings.sort((a, b)=>specificity(b.from) - specificity(a.from));
+    return {
+        input: ({ url })=>rewritePath(url, input),
+        output: ({ url })=>rewritePath(url, output)
+    };
+}
+export { createLocalisedRouteRewrite };

package/dist/esm/localisedUrls/routes.mjs

@@ -0,0 +1,176 @@
+import { getLeadingLocaleParam, normalisePathPattern, normaliseRoutePath, stripLeadingLocaleParam } from "./normalise.mjs";
+import { doPathPatternsOverlap, getOrderedPathParamSignature, getPathParamSignature, getPathPatternValidationIssue, getPhysicalPathPattern, haveEqualPatternSpecificity } from "./patterns.mjs";
+const isLocalisableRoutePath = (path)=>{
+    const pathWithoutLocale = stripLeadingLocaleParam(path);
+    if (!pathWithoutLocale || '/' === pathWithoutLocale || '*' === pathWithoutLocale) return false;
+    return true;
+};
+const joinPath = (parentPath, routePath)=>{
+    if (!isLocalisableRoutePath(routePath)) return parentPath;
+    const segment = normaliseRoutePath(stripLeadingLocaleParam(routePath) || '');
+    return normalisePathPattern(`${parentPath}/${segment}`);
+};
+const isFrameworkInternalRoutePath = (canonicalPath)=>'/_mf' === canonicalPath || canonicalPath.startsWith('/_mf/');
+const legalRouteIdPart = (value)=>value.replace(/[^a-zA-Z0-9_$-]+/g, '_').replace(/^_+|_+$/g, '') || 'index';
+const formatParamSignature = (signature)=>signature.length > 0 ? signature.join(', ') : '(none)';
+const validateLocalisedUrlPatterns = (languages, localisedUrls)=>{
+    const physicalPatterns = new Map();
+    const claimedPatterns = [];
+    const claimPhysicalPattern = (sourcePattern, canonicalPath, source)=>{
+        const physicalPattern = getPhysicalPathPattern(sourcePattern);
+        const existing = physicalPatterns.get(physicalPattern);
+        if (existing && existing.canonicalPath !== canonicalPath) throw new Error(`localisedUrls["${existing.canonicalPath}"] ${existing.source} and localisedUrls["${canonicalPath}"] ${source} generate the same physical route pattern "${physicalPattern}". Localised route patterns must identify exactly one canonical route.`);
+        const overlapping = claimedPatterns.find((claimed)=>claimed.canonicalPath !== canonicalPath && haveEqualPatternSpecificity(claimed.pattern, sourcePattern) && doPathPatternsOverlap(claimed.pattern, sourcePattern));
+        if (overlapping) throw new Error(`localisedUrls["${overlapping.canonicalPath}"] ${overlapping.source} pattern "${overlapping.pattern}" and localisedUrls["${canonicalPath}"] ${source} pattern "${sourcePattern}" are equal-specificity overlapping route patterns. Localised route patterns must identify exactly one canonical route.`);
+        physicalPatterns.set(physicalPattern, {
+            canonicalPath,
+            source
+        });
+        claimedPatterns.push({
+            canonicalPath,
+            pattern: sourcePattern,
+            source
+        });
+    };
+    for (const [canonicalPath, entry] of Object.entries(localisedUrls).sort(([left], [right])=>left < right ? -1 : left > right ? 1 : 0)){
+        const canonicalIssue = getPathPatternValidationIssue(canonicalPath);
+        if (canonicalIssue) throw new Error(`localisedUrls["${canonicalPath}"] canonical pattern has ${canonicalIssue}.`);
+        const expectedSignature = getPathParamSignature(canonicalPath);
+        const expectedOrderedSignature = getOrderedPathParamSignature(canonicalPath);
+        claimPhysicalPattern(canonicalPath, canonicalPath, 'canonical pattern');
+        for (const language of languages){
+            const localisedPattern = entry[language];
+            if (!localisedPattern) continue;
+            const localisedIssue = getPathPatternValidationIssue(localisedPattern);
+            if (localisedIssue) throw new Error(`localisedUrls["${canonicalPath}"].${language} has ${localisedIssue}.`);
+            const actualSignature = getPathParamSignature(localisedPattern);
+            if (actualSignature.length !== expectedSignature.length || actualSignature.some((parameter, index)=>parameter !== expectedSignature[index])) throw new Error(`localisedUrls["${canonicalPath}"].${language} must use the same parameter signature as "${canonicalPath}": expected ${formatParamSignature(expectedSignature)}; received ${formatParamSignature(actualSignature)}.`);
+            const actualOrderedSignature = getOrderedPathParamSignature(localisedPattern);
+            if (expectedOrderedSignature.some((parameter)=>'*' === parameter || parameter.endsWith('?')) && actualOrderedSignature.some((parameter, index)=>parameter !== expectedOrderedSignature[index])) throw new Error(`localisedUrls["${canonicalPath}"].${language} must keep optional and splat parameters in canonical order: expected ${formatParamSignature(expectedOrderedSignature)}; received ${formatParamSignature(actualOrderedSignature)}.`);
+            claimPhysicalPattern(localisedPattern, canonicalPath, `.${language}`);
+        }
+    }
+};
+const ensureLocalisedUrlsForPath = (canonicalPath, languages, localisedUrls)=>{
+    const entry = localisedUrls[canonicalPath];
+    if (!entry) throw new Error(`localisedUrls is enabled, but route "${canonicalPath}" does not define localised URLs for languages: ${languages.join(', ')}. Add localisedUrls["${canonicalPath}"] or set localeDetection.localisedUrls to false.`);
+    const missingLanguages = languages.filter((language)=>!entry[language]);
+    if (missingLanguages.length > 0) throw new Error(`localisedUrls["${canonicalPath}"] is missing languages: ${missingLanguages.join(', ')}. Every configured language must have a localised URL.`);
+    return entry;
+};
+const validateLocalisedUrls = (routes, languages, localisedUrls)=>{
+    validateLocalisedUrlPatterns(languages, localisedUrls);
+    const visit = (route, parentPath)=>{
+        const canonicalPath = joinPath(parentPath, route.path);
+        if (isLocalisableRoutePath(route.path) && !isFrameworkInternalRoutePath(canonicalPath)) ensureLocalisedUrlsForPath(canonicalPath, languages, localisedUrls);
+        if ('children' in route && route.children) route.children.forEach((child)=>visit(child, canonicalPath));
+    };
+    routes.forEach((route)=>visit(route, ''));
+};
+const getLocalisedRouteIdSuffixes = (paths)=>{
+    const usedSuffixes = new Set();
+    return paths.map((path, index)=>{
+        if (0 === index) return;
+        const baseSuffix = legalRouteIdPart(path);
+        let suffix = baseSuffix;
+        let disambiguator = 2;
+        while(usedSuffixes.has(suffix))suffix = `${baseSuffix}_${disambiguator++}`;
+        usedSuffixes.add(suffix);
+        return suffix;
+    });
+};
+const getLocalisedRoutePaths = (canonicalPath, parentLocalisedPaths, languages, entry)=>{
+    const paths = languages.map((language)=>{
+        const fullPath = normalisePathPattern(entry[language]);
+        const parentPath = normalisePathPattern(parentLocalisedPaths[language] || '/');
+        if ('/' === parentPath) return normaliseRoutePath(fullPath) || void 0;
+        const parentPrefix = `${parentPath}/`;
+        if (!fullPath.startsWith(parentPrefix)) throw new Error(`localisedUrls["${canonicalPath}"].${language} must be nested under "${parentPath}" because its parent route is localised there.`);
+        return normaliseRoutePath(fullPath.slice(parentPath.length));
+    });
+    const uniquePaths = Array.from(new Set(paths.filter(Boolean)));
+    return uniquePaths;
+};
+const transformLocalisedRoute = (route, parentCanonicalPath, parentLocalisedPaths, languages, localisedUrls, projection)=>{
+    const isSplat = '*' === stripLeadingLocaleParam(route.path);
+    const canonicalPath = isSplat ? normalisePathPattern(`${parentCanonicalPath}/*`) : joinPath(parentCanonicalPath, route.path);
+    const localisedUrlEntry = isLocalisableRoutePath(route.path) && !isFrameworkInternalRoutePath(canonicalPath) ? ensureLocalisedUrlsForPath(canonicalPath, languages, localisedUrls) : void 0;
+    const routeLocalisedPaths = localisedUrlEntry ? languages.reduce((acc, language)=>{
+        acc[language] = normalisePathPattern(localisedUrlEntry[language]);
+        return acc;
+    }, {}) : isSplat ? Object.fromEntries(Object.entries(parentLocalisedPaths).map(([language, path])=>[
+            language,
+            normalisePathPattern(`${path}/*`)
+        ])) : parentLocalisedPaths;
+    const children = 'children' in route && route.children ? route.children.flatMap((child)=>transformLocalisedRoute(child, canonicalPath, routeLocalisedPaths, languages, localisedUrls, projection)) : void 0;
+    const baseRoute = {
+        ...route,
+        ...!isFrameworkInternalRoutePath(canonicalPath) ? {
+            modernLocalisedRoute: {
+                id: route.id,
+                path: route.path,
+                canonicalPath,
+                paths: localisedUrlEntry ?? (isSplat ? routeLocalisedPaths : void 0)
+            }
+        } : {},
+        ...children ? {
+            children
+        } : {}
+    };
+    if (!localisedUrlEntry) return [
+        baseRoute
+    ];
+    const localisedPaths = getLocalisedRoutePaths(canonicalPath, parentLocalisedPaths, languages, localisedUrlEntry);
+    if ('canonical' === projection) return [
+        baseRoute
+    ];
+    const leadingLocaleParam = getLeadingLocaleParam(route.path);
+    const routeIdPaths = leadingLocaleParam ? localisedPaths.map((path)=>normaliseRoutePath(`${leadingLocaleParam}/${path}`)) : localisedPaths;
+    const routeIdSuffixes = getLocalisedRouteIdSuffixes(routeIdPaths);
+    return localisedPaths.map((localisedPath, index)=>cloneRouteWithLocalisedPath(baseRoute, localisedPath, routeIdSuffixes[index], canonicalPath));
+};
+const suffixRouteIds = (route, suffix)=>{
+    const children = 'children' in route && route.children ? route.children.map((child)=>suffixRouteIds(child, suffix)) : void 0;
+    return {
+        ...route,
+        ...route.id ? {
+            id: `${route.id}__localised_${suffix}`
+        } : {},
+        ...children ? {
+            children
+        } : {}
+    };
+};
+const collectRouteIdCounts = (routes, counts = new Map())=>{
+    for (const route of routes){
+        if (route.id) counts.set(route.id, (counts.get(route.id) ?? 0) + 1);
+        if ('children' in route && route.children) collectRouteIdCounts(route.children, counts);
+    }
+    return counts;
+};
+const validateNoNewRouteIdCollisions = (sourceRoutes, localisedRoutes)=>{
+    const sourceCounts = collectRouteIdCounts(sourceRoutes);
+    const localisedCounts = collectRouteIdCounts(localisedRoutes);
+    for (const [routeId, count] of localisedCounts)if (count > 1 && count > (sourceCounts.get(routeId) ?? 0)) throw new Error(`Localised route expansion generated duplicate route ID "${routeId}". Change the source route ID or localised path so every generated route remains identifiable.`);
+};
+const cloneRouteWithLocalisedPath = (route, path, routeIdSuffix, canonicalPath)=>{
+    const leadingLocaleParam = getLeadingLocaleParam(route.path);
+    const localisedPath = leadingLocaleParam ? normaliseRoutePath(`${leadingLocaleParam}/${path}`) : path;
+    const routeWithPath = {
+        ...route,
+        path: localisedPath
+    };
+    routeWithPath.modernCanonicalPath = canonicalPath;
+    return routeIdSuffix ? suffixRouteIds(routeWithPath, routeIdSuffix) : routeWithPath;
+};
+const applyLocalisedUrlsToRoutes = (routes, languages, localisedUrls, projection = 'physical')=>{
+    const rootLocalisedPaths = languages.reduce((acc, language)=>{
+        acc[language] = '/';
+        return acc;
+    }, {});
+    validateLocalisedUrls(routes, languages, localisedUrls);
+    const localisedRoutes = routes.flatMap((route)=>transformLocalisedRoute(route, '', rootLocalisedPaths, languages, localisedUrls, projection));
+    validateNoNewRouteIdCollisions(routes, localisedRoutes);
+    return localisedRoutes;
+};
+export { applyLocalisedUrlsToRoutes, validateLocalisedUrls };

package/dist/esm/rendererHead.mjs

@@ -4,6 +4,7 @@ const MARKER_PREFIX = `<template ${MARKER_ATTRIBUTE}="`;
 const MARKER_SUFFIX = '"></template>';
 const RECORD_ID_WIDTH = 12;
 const MARKER_LENGTH = MARKER_PREFIX.length + 1 + 36 + RECORD_ID_WIDTH + MARKER_SUFFIX.length;
+const LATE_HEAD_MESSAGE = "<Helmet> rendered in a boundary that completed after the shell; head tags dropped. Move it above the Suspense boundary or set server.ssrByEntries[entry].mode to 'string'.";
 const HEAD_STATE = Symbol('modern.rendererHead');
 const getState = (context)=>{
     const headContext = context;
@@ -24,7 +25,12 @@ const createToken = (transaction)=>{
     transaction.nextRecordId += 1;
     return token;
 };
-const beginHeadRender = (context)=>{
+const dropLateHead = (transaction)=>{
+    if (transaction.lateHeadReported) return;
+    transaction.lateHeadReported = true;
+    transaction.reportLateHead(LATE_HEAD_MESSAGE);
+};
+const beginHeadRender = (context, reportLateHead)=>{
     const state = getState(context);
     state.transaction = {
         recordsByToken: new Map(),
@@ -33,7 +39,9 @@ const beginHeadRender = (context)=>{
         nextRecordId: 0,
         nonce: globalThis.crypto.randomUUID(),
         previousRecords: state.publishedRecords,
-        sealed: false
+        sealed: false,
+        reportLateHead,
+        lateHeadReported: false
     };
     state.publish?.([]);
 };
@@ -44,7 +52,6 @@ const collectHeadRecord = (context, createRecord, publish)=>{
     const hadPublisher = void 0 !== state.publish;
     state.publish = (records)=>publish(records);
     if (!hadPublisher) state.publish([]);
-    if (transaction.sealed) return null;
     const token = createToken(transaction);
     transaction.recordsByToken.set(token, createRecord());
     return {
@@ -74,7 +81,9 @@ const consumeMarkers = (context, html)=>{
         const token = html.slice(tokenStart, end);
         if (transaction.recordsByToken.has(token)) {
             stripped += html.slice(cursor, start);
-            if (!transaction.sealed && !transaction.committedTokens.has(token)) {
+            if (transaction.sealed) {
+                if (!transaction.committedTokens.has(token)) dropLateHead(transaction);
+            } else if (!transaction.committedTokens.has(token)) {
                 transaction.committedTokens.add(token);
                 transaction.committedRecords.push(transaction.recordsByToken.get(token));
             }
@@ -159,4 +168,4 @@ const createWebHeadMarkerStripper = (context)=>{
         }
     });
 };
-export { abortHeadRender, beginHeadRender, collectHeadRecord, collectHeadState, completeHeadRender, createHeadChunkProcessor, createWebHeadMarkerStripper, finishHeadRender, publishHeadRender };
+export { LATE_HEAD_MESSAGE, abortHeadRender, beginHeadRender, collectHeadRecord, collectHeadState, completeHeadRender, createHeadChunkProcessor, createWebHeadMarkerStripper, finishHeadRender, publishHeadRender };

package/dist/esm/request-policy/policyCore.mjs

@@ -30,7 +30,7 @@ const toOrigin = (value)=>{
     if (!value) return;
     try {
         return new URL(value).origin;
-    } catch (error) {
+    } catch  {
         return;
     }
 };

package/dist/esm/request-policy/transport.mjs

@@ -58,7 +58,7 @@ const shouldRetryWithDefaults = (method, statusCode, error, retryableStatusCodes
 const shouldRetry = (retryOptions, context, retryableStatusCodes)=>{
     if ('function' == typeof retryOptions?.shouldRetry) try {
         return retryOptions.shouldRetry(context);
-    } catch (error) {
+    } catch  {
         return false;
     }
     return shouldRetryWithDefaults(context.method, context.statusCode, context.error, retryableStatusCodes);
@@ -75,7 +75,7 @@ const emitDegradedEvent = (transport, event)=>{
     if ('function' != typeof transport?.onDegraded) return;
     try {
         transport.onDegraded(event);
-    } catch (error) {}
+    } catch  {}
 };
 const withTimeout = async (promise, timeoutMs, signalBuilder)=>{
     if (!timeoutMs || timeoutMs <= 0) {

package/dist/esm/routerState.mjs

@@ -7,99 +7,107 @@ function getRouterRuntimeState(runtimeContext) {
 function getRouterServerSnapshot(runtimeContext) {
     return routerServerSnapshotExtension.get(runtimeContext);
 }
-function toHydrationScripts(state) {
-    if (state.hydrationScripts?.length) return state.hydrationScripts;
-    return state.hydrationScript ? [
-        state.hydrationScript
-    ] : void 0;
-}
-function getMatchedRouteIdsFromMatches(matches) {
-    const routeIds = matches?.map((match)=>match.assetRouteId ?? match.routeId).filter((routeId)=>'string' == typeof routeId);
-    return routeIds?.length ? routeIds : void 0;
-}
-function createRouterServerSnapshot(state) {
-    const hydrationScripts = toHydrationScripts(state);
-    const matchedRouteIds = state.matchedRouteIds ?? getMatchedRouteIdsFromMatches(state.matches);
-    return {
-        ...state,
-        ...hydrationScripts?.length ? {
-            hydrationScript: state.hydrationScript ?? hydrationScripts[0],
-            hydrationScripts
+function createRouterServerSnapshot(snapshot) {
+    const matches = snapshot.matches?.map((match)=>Object.freeze({
+            ...match,
+            ...match.params ? {
+                params: Object.freeze({
+                    ...match.params
+                })
+            } : {}
+        }));
+    const matchedRouteIds = snapshot.matchedRouteIds ?? matches?.map((match)=>match.assetRouteId ?? match.routeId);
+    return Object.freeze({
+        ...snapshot,
+        ...snapshot.hydrationScripts ? {
+            hydrationScripts: Object.freeze([
+                ...snapshot.hydrationScripts
+            ])
         } : {},
         ...matchedRouteIds ? {
-            matchedRouteIds
-        } : {}
-    };
-}
-function createRouterRuntimeState(state) {
-    const hasSnapshotState = Boolean(state.serverSnapshot) || Boolean(state.hydrationScript) || Boolean(state.hydrationScripts?.length) || Boolean(state.matchedRouteIds?.length) || Boolean(state.matches?.length);
-    const serverSnapshot = state.serverSnapshot ? createRouterServerSnapshot({
-        ...state.serverSnapshot,
-        framework: state.serverSnapshot.framework ?? state.framework,
-        basename: state.serverSnapshot.basename ?? state.basename,
-        hydrationScript: state.serverSnapshot.hydrationScript ?? state.hydrationScript,
-        hydrationScripts: state.serverSnapshot.hydrationScripts ?? state.hydrationScripts,
-        matchedRouteIds: state.serverSnapshot.matchedRouteIds ?? state.matchedRouteIds,
-        matches: state.serverSnapshot.matches ?? state.matches
-    }) : hasSnapshotState ? createRouterServerSnapshot({
-        framework: state.framework,
-        basename: state.basename,
-        hydrationScript: state.hydrationScript,
-        hydrationScripts: state.hydrationScripts,
-        matchedRouteIds: state.matchedRouteIds,
-        matches: state.matches
-    }) : void 0;
-    const hydrationScripts = toHydrationScripts({
-        hydrationScript: state.hydrationScript ?? serverSnapshot?.hydrationScript,
-        hydrationScripts: state.hydrationScripts ?? serverSnapshot?.hydrationScripts
-    });
-    const matchedRouteIds = state.matchedRouteIds ?? serverSnapshot?.matchedRouteIds ?? getMatchedRouteIdsFromMatches(state.matches);
-    return {
-        ...state,
-        ...hydrationScripts?.length ? {
-            hydrationScript: state.hydrationScript ?? hydrationScripts[0],
-            hydrationScripts
+            matchedRouteIds: Object.freeze([
+                ...matchedRouteIds
+            ])
         } : {},
-        ...matchedRouteIds ? {
-            matchedRouteIds
+        ...matches ? {
+            matches: Object.freeze(matches)
         } : {},
-        ...serverSnapshot ? {
-            serverSnapshot
+        ...snapshot.errors ? {
+            errors: Object.freeze({
+                ...snapshot.errors
+            })
+        } : {},
+        ...snapshot.routerData ? {
+            routerData: Object.freeze({
+                ...snapshot.routerData,
+                ...snapshot.routerData.loaderData ? {
+                    loaderData: Object.freeze({
+                        ...snapshot.routerData.loaderData
+                    })
+                } : {},
+                ...snapshot.routerData.errors ? {
+                    errors: Object.freeze({
+                        ...snapshot.routerData.errors
+                    })
+                } : {}
+            })
         } : {}
+    });
+}
+const routerRuntimeStateListeners = new WeakMap();
+function subscribeRouterRuntimeState(runtimeContext, listener) {
+    if (!runtimeContext || 'object' != typeof runtimeContext) return ()=>void 0;
+    let listeners = routerRuntimeStateListeners.get(runtimeContext);
+    if (!listeners) {
+        listeners = new Set();
+        routerRuntimeStateListeners.set(runtimeContext, listeners);
+    }
+    listeners.add(listener);
+    return ()=>{
+        listeners?.delete(listener);
     };
 }
+const pendingRouterRuntimeStateNotifications = new WeakSet();
+function notifyRouterRuntimeState(runtimeContext) {
+    const listeners = routerRuntimeStateListeners.get(runtimeContext);
+    if (!listeners?.size) return;
+    if (pendingRouterRuntimeStateNotifications.has(runtimeContext)) return;
+    pendingRouterRuntimeStateNotifications.add(runtimeContext);
+    const deliver = ()=>{
+        pendingRouterRuntimeStateNotifications.delete(runtimeContext);
+        const current = routerRuntimeStateListeners.get(runtimeContext);
+        if (!current?.size) return;
+        for (const listener of [
+            ...current
+        ])try {
+            listener();
+        } catch  {}
+    };
+    if ('function' == typeof queueMicrotask) queueMicrotask(deliver);
+    else setTimeout(deliver, 0);
+}
 function applyRouterRuntimeState(runtimeContext, state) {
-    const normalized = createRouterRuntimeState(state);
-    routerRuntimeStateExtension.set(runtimeContext, normalized);
-    if (normalized.serverSnapshot) routerServerSnapshotExtension.set(runtimeContext, normalized.serverSnapshot);
+    const previous = routerRuntimeStateExtension.get(runtimeContext);
+    routerRuntimeStateExtension.set(runtimeContext, state);
+    if (previous?.instance !== state.instance || previous?.framework !== state.framework || previous?.navigation !== state.navigation) notifyRouterRuntimeState(runtimeContext);
     return runtimeContext;
 }
 function applyRouterServerPrepareResult(runtimeContext, result) {
-    const state = createRouterRuntimeState({
+    if (result.snapshot) routerServerSnapshotExtension.set(runtimeContext, createRouterServerSnapshot(result.snapshot));
+    return applyRouterRuntimeState(runtimeContext, {
         ...result.state,
-        cleanup: result.cleanup ?? result.state.cleanup,
-        serverSnapshot: result.snapshot ?? result.state.serverSnapshot
+        cleanup: result.cleanup ?? result.state.cleanup
     });
-    applyRouterRuntimeState(runtimeContext, state);
-    return runtimeContext;
 }
 function getRouterHydrationScripts(runtimeContext) {
-    const serverSnapshot = getRouterServerSnapshot(runtimeContext);
-    const runtimeState = getRouterRuntimeState(runtimeContext);
-    return serverSnapshot?.hydrationScripts ?? toHydrationScripts({
-        hydrationScript: serverSnapshot?.hydrationScript
-    }) ?? runtimeState?.hydrationScripts ?? toHydrationScripts({
-        hydrationScript: runtimeState?.hydrationScript
-    }) ?? [];
+    return getRouterServerSnapshot(runtimeContext)?.hydrationScripts ?? [];
 }
 function getRouterMatchedRouteIds(runtimeContext) {
-    const serverSnapshot = getRouterServerSnapshot(runtimeContext);
-    const runtimeState = getRouterRuntimeState(runtimeContext);
-    return serverSnapshot?.matchedRouteIds ?? getMatchedRouteIdsFromMatches(serverSnapshot?.matches) ?? runtimeState?.matchedRouteIds ?? getMatchedRouteIdsFromMatches(runtimeState?.matches);
+    return getRouterServerSnapshot(runtimeContext)?.matchedRouteIds;
 }
 async function cleanupRouterRuntimeState(runtimeContext) {
     try {
         await getRouterRuntimeState(runtimeContext)?.cleanup?.();
     } catch  {}
 }
-export { applyRouterRuntimeState, applyRouterServerPrepareResult, cleanupRouterRuntimeState, createRouterRuntimeState, createRouterServerSnapshot, getRouterHydrationScripts, getRouterMatchedRouteIds, getRouterRuntimeState, getRouterServerSnapshot };
+export { applyRouterRuntimeState, applyRouterServerPrepareResult, cleanupRouterRuntimeState, createRouterServerSnapshot, getRouterHydrationScripts, getRouterMatchedRouteIds, getRouterRuntimeState, getRouterServerSnapshot, subscribeRouterRuntimeState };

package/dist/esm/routerStatePlugin.mjs

@@ -1,20 +1,63 @@
 import { createRouterPrefetchPolicy } from "./routerPrefetchPolicy.mjs";
-import { applyRouterRuntimeState, createRouterServerSnapshot } from "./routerState.mjs";
+import { applyRouterRuntimeState, applyRouterServerPrepareResult, getRouterRuntimeState, getRouterServerSnapshot } from "./routerState.mjs";
+const ROUTER_CLEANUP_ERROR = 'An error occurs during router runtime cleanup';
+const installedRouterPolicies = new WeakSet();
+function createReactRouterNavigation(router, Link) {
+    let state;
+    let snapshot;
+    return {
+        Link,
+        getSnapshot () {
+            if (state !== router.state) {
+                state = router.state;
+                snapshot = {
+                    location: state.location,
+                    params: Object.assign({}, ...state.matches.map((match)=>match.params))
+                };
+            }
+            return snapshot;
+        },
+        subscribe: (listener)=>router.subscribe(listener),
+        navigate: (href, options)=>router.navigate(href, options)
+    };
+}
 function createRouterStatePlugin({ registryHooks }) {
     return {
         name: '@modern-js/router-runtime-policy',
         registryHooks,
         setup (api) {
+            if (installedRouterPolicies.has(api)) return;
+            installedRouterPolicies.add(api);
             api.onBeforeRender((context)=>{
                 const runtimeContext = context;
                 runtimeContext.linkPrefetchPolicy ??= createRouterPrefetchPolicy();
             });
+            api.onRenderPrepared((info)=>{
+                const snapshot = getRouterServerSnapshot(info.runtimeContext);
+                if (!snapshot) return info;
+                return {
+                    ...info,
+                    routerResult: {
+                        statusCode: snapshot.statusCode ?? info.routerResult?.statusCode,
+                        errors: snapshot.errors ?? info.routerResult?.errors
+                    }
+                };
+            });
+            api.onRequestEnd(async ({ runtimeContext })=>{
+                try {
+                    await getRouterRuntimeState(runtimeContext)?.cleanup?.();
+                } catch (error) {
+                    const { ssrContext } = runtimeContext;
+                    if (!ssrContext) throw error;
+                    ssrContext.onError(error, ROUTER_CLEANUP_ERROR);
+                }
+            });
             api.onAfterCreateRouter((event)=>{
                 if ('react-router' !== event.framework) return;
                 if ('ssr-prepare' === event.phase) {
                     const { routerContext } = event.runtimeContext;
                     if (!routerContext) return;
-                    const serverSnapshot = createRouterServerSnapshot({
+                    const snapshot = {
                         framework: event.framework,
                         basename: event.basename,
                         statusCode: routerContext.statusCode,
@@ -28,21 +71,29 @@ function createRouterStatePlugin({ registryHooks }) {
                                     routeId: match.route.id
                                 }
                             ] : [])
+                    };
+                    applyRouterServerPrepareResult(event.runtimeContext, {
+                        snapshot,
+                        state: {
+                            framework: event.framework,
+                            basename: event.basename,
+                            instance: event.router
+                        }
                     });
+                } else if ('client-create' === event.phase) {
+                    const router = event.router;
+                    const { router: api } = event.runtimeContext;
                     applyRouterRuntimeState(event.runtimeContext, {
                         framework: event.framework,
                         basename: event.basename,
-                        instance: event.router,
-                        matchedRouteIds: serverSnapshot.matchedRouteIds,
-                        serverSnapshot
+                        instance: router,
+                        ...api?.Link ? {
+                            navigation: createReactRouterNavigation(router, api.Link)
+                        } : {}
                     });
-                } else if ('client-create' === event.phase) applyRouterRuntimeState(event.runtimeContext, {
-                    framework: event.framework,
-                    basename: event.basename,
-                    instance: event.router
-                });
+                }
             });
         }
     };
 }
-export { createRouterStatePlugin };
+export { ROUTER_CLEANUP_ERROR, createRouterStatePlugin };

package/dist/esm-node/localisedUrls/config.mjs

@@ -0,0 +1,12 @@
+import "node:module";
+const resolveLocalisedUrlsConfig = (option)=>{
+    if (option && 'object' == typeof option && Object.keys(option).length > 0) return {
+        enabled: true,
+        map: option
+    };
+    return {
+        enabled: false,
+        map: {}
+    };
+};
+export { resolveLocalisedUrlsConfig };