@bleedingdev/modern-js-runtime-extensions 3.9.0-ultramodern.11 → 3.9.0-ultramodern.13

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

@@ -0,0 +1,177 @@
+import "node:module";
+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-node/localisedUrls/types.mjs

@@ -0,0 +1 @@
+import "node:module";

package/dist/esm-node/routerState.mjs

@@ -8,66 +8,52 @@ 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)
+        } : {},
+        ...snapshot.errors ? {
+            errors: Object.freeze({
+                ...snapshot.errors
+            })
         } : {},
-        ...serverSnapshot ? {
-            serverSnapshot
+        ...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) {
@@ -103,38 +89,26 @@ function notifyRouterRuntimeState(runtimeContext) {
 }
 function applyRouterRuntimeState(runtimeContext, state) {
     const previous = routerRuntimeStateExtension.get(runtimeContext);
-    const normalized = createRouterRuntimeState(state);
-    routerRuntimeStateExtension.set(runtimeContext, normalized);
-    if (normalized.serverSnapshot) routerServerSnapshotExtension.set(runtimeContext, normalized.serverSnapshot);
-    if (previous?.instance !== normalized.instance || previous?.framework !== normalized.framework) notifyRouterRuntimeState(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, subscribeRouterRuntimeState };
+export { applyRouterRuntimeState, applyRouterServerPrepareResult, cleanupRouterRuntimeState, createRouterServerSnapshot, getRouterHydrationScripts, getRouterMatchedRouteIds, getRouterRuntimeState, getRouterServerSnapshot, subscribeRouterRuntimeState };

package/dist/esm-node/routerStatePlugin.mjs

@@ -1,6 +1,25 @@
 import "node:module";
 import { createRouterPrefetchPolicy } from "./routerPrefetchPolicy.mjs";
-import { applyRouterRuntimeState, createRouterServerSnapshot } from "./routerState.mjs";
+import { applyRouterRuntimeState, applyRouterServerPrepareResult } from "./routerState.mjs";
+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',
@@ -15,7 +34,7 @@ function createRouterStatePlugin({ registryHooks }) {
                 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,
@@ -29,19 +48,27 @@ 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
-                });
+                }
             });
         }
     };

package/dist/types/localisedUrls/config.d.ts

@@ -0,0 +1,9 @@
+import type { LocalisedUrlsOption, ResolvedLocalisedUrlsConfig } from './types.js';
+/**
+ * Localised URLs are strictly opt-in: only an explicit, non-empty map enables
+ * route expansion and validation. `true`, `false`, an empty map and absence
+ * all resolve to disabled, so upstream-style configs (`localePathRedirect` +
+ * `languages` without a map) keep plain locale-prefix behavior instead of
+ * failing the build for every route missing from a map they never wrote.
+ */
+export declare const resolveLocalisedUrlsConfig: (option: LocalisedUrlsOption | undefined) => ResolvedLocalisedUrlsConfig;

package/dist/types/localisedUrls/index.d.ts

@@ -0,0 +1,10 @@
+export { resolveLocalisedUrlsConfig } from './config.js';
+export { normalisePathname, normalisePathPattern } from './normalise.js';
+export { canonicalTargetPathname, localiseTargetPathname, stripLanguagePrefix, } from './pathname.js';
+export { buildPathFromPattern, matchPathPattern } from './patterns.js';
+export type { LocaleRedirectSkipRule } from './redirect.js';
+export { DEFAULT_LOCALE_REDIRECT_SKIP_RULES, isDefaultLocaleRedirectSkipPath, matchesPathPrefix, shouldSkipLocaleRedirect, } from './redirect.js';
+export { resolveCanonicalLocalisedPath, resolveLocalisedPath } from './resolve.js';
+export { createLocalisedRouteRewrite } from './routeIdentity.js';
+export { applyLocalisedUrlsToRoutes, validateLocalisedUrls } from './routes.js';
+export type { LocalisedRoute, LocalisedUrlPathMap, LocalisedUrlsMap, LocalisedUrlsOption, ResolvedLocalisedUrlsConfig, } from './types.js';

package/dist/types/localisedUrls/normalise.d.ts

@@ -0,0 +1,10 @@
+export declare const normalisePathPattern: (path: string) => string;
+/**
+ * Normalise a concrete request pathname: slash cleanup only. Unlike
+ * {@link normalisePathPattern} it must not rewrite literal `[x]` segments to
+ * `:x` params — pathnames are values, not patterns.
+ */
+export declare const normalisePathname: (pathname: string) => string;
+export declare const normaliseRoutePath: (path: string) => string;
+export declare const stripLeadingLocaleParam: (path?: string) => string | undefined;
+export declare const getLeadingLocaleParam: (path?: string) => string | null;

package/dist/types/localisedUrls/pathname.d.ts

@@ -0,0 +1,4 @@
+import type { LocalisedUrlsOption } from './types.js';
+export declare const stripLanguagePrefix: (pathname: string, languages: string[]) => string;
+export declare const localiseTargetPathname: (pathname: string, language: string, languages: string[], localisedUrls?: LocalisedUrlsOption) => string;
+export declare const canonicalTargetPathname: (pathname: string, languages: string[], localisedUrls?: LocalisedUrlsOption) => string;

package/dist/types/localisedUrls/patterns.d.ts

@@ -0,0 +1,11 @@
+export declare const getOrderedPathParamSignature: (pattern: string) => string[];
+export declare const getPathParamSignature: (pattern: string) => string[];
+export declare const getPathPatternValidationIssue: (pattern: string) => string | undefined;
+export declare const getPhysicalPathPattern: (pattern: string) => string;
+export declare const haveEqualPatternSpecificity: (left: string, right: string) => boolean;
+export declare const doPathPatternsOverlap: (left: string, right: string) => boolean;
+export declare const sortPatternsBySpecificity: <T extends {
+    pattern: string;
+}>(patterns: T[]) => T[];
+export declare const matchPathPattern: (pathname: string, pattern: string) => Record<string, string> | null;
+export declare const buildPathFromPattern: (pattern: string, params: Record<string, string>) => string;

package/dist/types/localisedUrls/redirect.d.ts

@@ -0,0 +1,19 @@
+export type LocaleRedirectSkipRule = {
+    type: 'exact';
+    path: string;
+} | {
+    type: 'prefix';
+    path: string;
+} | {
+    type: 'pattern';
+    path: RegExp;
+};
+/**
+ * Federation artifacts are never pages. The remote entries match the same
+ * shapes the federation layer itself recognises and serves (`mfCache.ts`):
+ * a manifest may name a root entry such as `remoteEntry.catalog.js`.
+ */
+export declare const DEFAULT_LOCALE_REDIRECT_SKIP_RULES: readonly LocaleRedirectSkipRule[];
+export declare const matchesPathPrefix: (pathname: string, prefix: string) => boolean;
+export declare const isDefaultLocaleRedirectSkipPath: (pathname: string, languages?: string[]) => boolean;
+export declare const shouldSkipLocaleRedirect: (pathname: string, languages?: string[], ignoreRedirectRoutes?: string[] | ((pathname: string) => boolean)) => boolean;

package/dist/types/localisedUrls/resolve.d.ts

@@ -0,0 +1,7 @@
+import type { LocalisedUrlsMap } from './types.js';
+export declare const resolveLocalisedPath: (pathname: string, targetLanguage: string, languages: string[], localisedUrls: LocalisedUrlsMap) => string;
+/**
+ * Reverse-map language-specific pathnames back to language-agnostic
+ * LocalisedUrlsMap keys.
+ */
+export declare const resolveCanonicalLocalisedPath: (pathname: string, languages: string[], localisedUrls: LocalisedUrlsMap) => string;

package/dist/types/localisedUrls/routeIdentity.d.ts

@@ -0,0 +1,22 @@
+interface RouteIdentity {
+    id?: string;
+    path?: string;
+    canonicalPath: string;
+    paths?: Record<string, string>;
+}
+interface RouteNode {
+    id?: string;
+    path?: string;
+    children?: RouteNode[];
+    modernLocalisedRoute?: RouteIdentity;
+}
+/** Use the router's URL rewrite seam; browser URLs retain their locale spelling. */
+export declare function createLocalisedRouteRewrite(routes: RouteNode[]): {
+    input: ({ url }: {
+        url: URL;
+    }) => URL;
+    output: ({ url }: {
+        url: URL;
+    }) => URL;
+} | undefined;
+export {};

package/dist/types/localisedUrls/routes.d.ts

@@ -0,0 +1,3 @@
+import type { LocalisedRoute, LocalisedUrlsMap } from './types.js';
+export declare const validateLocalisedUrls: (routes: LocalisedRoute[], languages: string[], localisedUrls: LocalisedUrlsMap) => void;
+export declare const applyLocalisedUrlsToRoutes: (routes: LocalisedRoute[], languages: string[], localisedUrls: LocalisedUrlsMap, projection?: 'physical' | 'canonical') => LocalisedRoute[];

package/dist/types/localisedUrls/types.d.ts

@@ -0,0 +1,14 @@
+export type LocalisedRoute = {
+    type: 'nested' | 'page';
+    path?: string;
+    id?: string;
+    children?: LocalisedRoute[];
+    [key: string]: any;
+};
+export type LocalisedUrlPathMap = Record<string, string>;
+export type LocalisedUrlsMap = Record<string, LocalisedUrlPathMap>;
+export type LocalisedUrlsOption = boolean | LocalisedUrlsMap;
+export interface ResolvedLocalisedUrlsConfig {
+    enabled: boolean;
+    map: LocalisedUrlsMap;
+}

package/dist/types/request-policy/types.d.ts

@@ -106,7 +106,7 @@ export type OperationContractOptions = {
     requireOperationVersion?: boolean;
     onViolation?: (violation: OperationContractViolation) => void;
 };
-export type OperationContextSource = 'client' | 'server' | 'generated-client' | 'effect-adapter' | 'data-platform' | 'unknown';
+export type OperationContextSource = 'client' | 'server' | 'generated-client' | 'effect-server' | 'data-platform' | 'unknown';
 export type OperationContext = {
     requestId?: string;
     operationId?: string;

package/dist/types/routeHydration.d.ts

@@ -8,7 +8,7 @@ export type ScriptChunkLike = {
     filename?: string;
     url?: string;
 };
-export declare function getMatchedRouteChunks<T>(routeManifest: RouteManifestLike | undefined, matchedRouteIds: string[], routeAssetToChunk: (asset: string) => T): T[];
+export declare function getMatchedRouteChunks<T>(routeManifest: RouteManifestLike | undefined, matchedRouteIds: readonly string[], routeAssetToChunk: (asset: string) => T): T[];
 export declare const orderHydrationScriptChunks: <T extends ScriptChunkLike>({ asyncEntryChunks, collectedChunks, matchedRouteChunks, entryName, }: {
     asyncEntryChunks: T[];
     collectedChunks: T[];
@@ -17,7 +17,7 @@ export declare const orderHydrationScriptChunks: <T extends ScriptChunkLike>({ a
 }) => T[];
 export declare function injectBeforeHydrationEntryScript(template: string, scripts: string, entryName?: string): string;
 export declare function replaceChunkJsPlaceholder(template: string, scripts: string, entryName: string | undefined, placeholder: string): string;
-export declare function createRouteHydrationScriptTags(routeManifest: RouteManifestLike | undefined, matchedRouteIds: string[], entryName: string, options?: {
+export declare function createRouteHydrationScriptTags(routeManifest: RouteManifestLike | undefined, matchedRouteIds: readonly string[], entryName: string, options?: {
     nonce?: string;
     template?: string;
 }): string;

package/dist/types/routerState.d.ts

@@ -1,10 +1,9 @@
 import type { InternalRouterRuntimeState, InternalRouterServerSnapshot, RouterServerPrepareResult } from './routerStateTypes.js';
-export type { BuiltInRouterFramework, InternalRouterRuntimeState, InternalRouterServerSnapshot, RouterFramework, RouterLifecyclePhase, RouterRouteMatchSnapshot, RouterServerPrepareResult, } from './routerStateTypes.js';
+export type { BuiltInRouterFramework, InternalRouterRuntimeState, InternalRouterServerSnapshot, RouterFramework, RouterLifecyclePhase, RouterLinkTarget, RouterNavigationCapability, RouterNavigationSnapshot, RouterRouteMatchSnapshot, RouterServerPrepareResult, } from './routerStateTypes.js';
 export declare function getRouterRuntimeState(runtimeContext: object): InternalRouterRuntimeState | undefined;
 export declare function getRouterServerSnapshot(runtimeContext: object): InternalRouterServerSnapshot | undefined;
-type RouterSnapshotLike = Partial<InternalRouterServerSnapshot>;
-export declare function createRouterServerSnapshot(state: RouterSnapshotLike): InternalRouterServerSnapshot;
-export declare function createRouterRuntimeState(state: InternalRouterRuntimeState): InternalRouterRuntimeState;
+/** Capture prepared metadata once; live router updates cannot rewrite it. */
+export declare function createRouterServerSnapshot(snapshot: InternalRouterServerSnapshot): InternalRouterServerSnapshot;
 /**
  * Observe the router runtime-state slot for the given runtime context.
  * Returns an unsubscribe function; safe to call for a context that never
@@ -13,6 +12,6 @@ export declare function createRouterRuntimeState(state: InternalRouterRuntimeSta
 export declare function subscribeRouterRuntimeState(runtimeContext: object, listener: () => void): () => void;
 export declare function applyRouterRuntimeState<Context extends object>(runtimeContext: Context, state: InternalRouterRuntimeState): Context;
 export declare function applyRouterServerPrepareResult<Context extends object>(runtimeContext: Context, result: RouterServerPrepareResult): Context;
-export declare function getRouterHydrationScripts(runtimeContext: object): string[];
-export declare function getRouterMatchedRouteIds(runtimeContext: object): string[] | undefined;
+export declare function getRouterHydrationScripts(runtimeContext: object): readonly string[];
+export declare function getRouterMatchedRouteIds(runtimeContext: object): readonly string[] | undefined;
 export declare function cleanupRouterRuntimeState(runtimeContext: object): Promise<void>;