@bleedingdev/modern-js-runtime-extensions 3.9.0-ultramodern.8 → 3.9.3-ultramodern.1

package/dist/esm-node/routerState.mjs

@@ -8,99 +8,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-node/routerStatePlugin.mjs

@@ -1,21 +1,64 @@
 import "node:module";
 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,
@@ -29,21 +72,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/types/helmetCompat.d.ts

@@ -63,7 +63,7 @@ export type HelmetCompatState<Element> = {
     style: HeadDatum<Element>;
     title: HeadDatum<Element>;
 };
-export declare const renderHeadMarker: <Element>(react: ElementFactory<Element>, marker: MarkerProps | null | undefined) => Element | null;
+export declare const renderHeadMarker: <Element>(react: ElementFactory<Element>, marker: MarkerProps | undefined) => Element | null;
 export declare const markPriorityHeadRecord: (record: object, prioritize: boolean | undefined) => void;
 export declare const isPriorityHeadTag: (tag: object) => boolean;
 export declare const headTagsToComponents: <Element>(react: ElementFactory<Element>, tagName: string, tags: HeadTag[]) => Element[];

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/rendererHead.d.ts

@@ -1,11 +1,13 @@
 declare const MARKER_ATTRIBUTE = "data-modern-helmet";
 export type RendererHeadMarkerProps = Record<typeof MARKER_ATTRIBUTE, string>;
 export * from './helmetCompat.js';
-export declare const beginHeadRender: (context: object) => void;
-export declare const collectHeadRecord: <RecordType>(context: object, createRecord: () => RecordType, publish: (records: RecordType[]) => void) => RendererHeadMarkerProps | null | undefined;
+export type ReportLateHead = (message: string) => void;
+export declare 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'.";
+export declare const beginHeadRender: (context: object, reportLateHead: ReportLateHead) => void;
+export declare const collectHeadRecord: <RecordType>(context: object, createRecord: () => RecordType, publish: (records: RecordType[]) => void) => RendererHeadMarkerProps | undefined;
 export declare const collectHeadState: <RecordType, StateType>(context: object, createRecord: () => RecordType, derive: (records: RecordType[]) => StateType, target: {
     helmet?: StateType;
-}) => RendererHeadMarkerProps | null | undefined;
+}) => RendererHeadMarkerProps | undefined;
 export declare const publishHeadRender: (context: object) => void;
 export declare const finishHeadRender: (context: object) => void;
 export declare const completeHeadRender: (context: object, html: string) => string;

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/routerProvider.d.ts

@@ -47,9 +47,7 @@ export declare function createRouterPlugin<Hooks extends Record<string, unknown>
     name: string;
     registryHooks: Hooks;
     setup(api: {
-        getRuntimeConfig: () => {
-            router?: Record<string, unknown>;
-        };
+        getRuntimeConfig: () => Record<string, unknown>;
         [key: string]: any;
     }): void;
 };

package/dist/types/routerState.d.ts

@@ -1,12 +1,17 @@
 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
+ * receives a router.
+ */
+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>;

package/dist/types/routerStatePlugin.d.ts

@@ -5,6 +5,14 @@ type RouterLifecycleEvent = {
     basename?: string;
     router?: unknown;
 };
+type PreparedRequest<RuntimeContext extends object = object> = {
+    runtimeContext: RuntimeContext;
+    routerResult?: {
+        statusCode?: number;
+        errors?: Record<string, unknown> | null;
+    };
+};
+export declare const ROUTER_CLEANUP_ERROR = "An error occurs during router runtime cleanup";
 /** Install fork policy through lifecycle hooks supplied by the native owner. */
 export declare function createRouterStatePlugin<Hooks extends Record<string, unknown>>({ registryHooks, }: {
     registryHooks: Hooks;
@@ -13,6 +21,10 @@ export declare function createRouterStatePlugin<Hooks extends Record<string, unk
     registryHooks: Hooks;
     setup(api: {
         onBeforeRender: (callback: (context: object) => void) => unknown;
+        onRenderPrepared: (callback: <RuntimeContext extends object>(info: PreparedRequest<RuntimeContext>) => PreparedRequest<RuntimeContext>) => unknown;
+        onRequestEnd: (callback: (info: {
+            runtimeContext: object;
+        }) => Promise<void>) => unknown;
         onAfterCreateRouter: (callback: (event: RouterLifecycleEvent) => void) => unknown;
     }): void;
 };

package/dist/types/routerStateTypes.d.ts

@@ -1,3 +1,4 @@
+import type React from 'react';
 export type BuiltInRouterFramework = 'react-router' | 'tanstack';
 export type RouterFramework = BuiltInRouterFramework | (string & {});
 export interface RouterRouteMatchSnapshot {
@@ -7,34 +8,63 @@ export interface RouterRouteMatchSnapshot {
     params?: Record<string, string>;
 }
 export interface InternalRouterServerSnapshot {
-    framework?: RouterFramework;
-    basename?: string;
-    statusCode?: number;
-    errors?: Record<string, unknown>;
-    routerData?: {
-        loaderData?: Record<string, unknown>;
-        errors?: Record<string, unknown>;
+    readonly framework?: RouterFramework;
+    readonly basename?: string;
+    readonly statusCode?: number;
+    readonly errors?: Record<string, unknown>;
+    readonly routerData?: {
+        readonly loaderData?: Record<string, unknown>;
+        readonly errors?: Record<string, unknown>;
     };
-    hydrationScript?: string;
-    hydrationScripts?: string[];
-    matchedRouteIds?: string[];
-    matches?: RouterRouteMatchSnapshot[];
+    readonly hydrationScripts?: readonly string[];
+    readonly matchedRouteIds?: readonly string[];
+    readonly matches?: readonly RouterRouteMatchSnapshot[];
 }
 export interface InternalRouterRuntimeState {
     framework: RouterFramework;
     basename?: string;
     instance?: unknown;
-    hydrationScript?: string;
-    hydrationScripts?: string[];
-    matchedRouteIds?: string[];
-    matches?: RouterRouteMatchSnapshot[];
-    serverSnapshot?: InternalRouterServerSnapshot;
+    navigation?: RouterNavigationCapability;
     cleanup?: () => void | Promise<void>;
 }
 export interface RouterServerPrepareResult {
     state: InternalRouterRuntimeState;
     snapshot?: InternalRouterServerSnapshot;
-    redirect?: Response;
     cleanup?: () => void | Promise<void>;
 }
 export type RouterLifecyclePhase = 'ssr-prepare' | 'client-create' | 'hydrate';
+/** Provider-owned browser navigation. Consumers never inspect router internals. */
+export interface RouterNavigationSnapshot {
+    location: {
+        pathname: string;
+        search: string;
+        hash: string;
+    };
+    params: Record<string, string>;
+}
+export interface RouterLinkTarget {
+    pathname: string;
+    href: string;
+    search?: Record<string, unknown>;
+    hash?: string;
+    hashScrollIntoView?: boolean | ScrollIntoViewOptions;
+    prefetch?: 'intent' | 'render' | 'viewport' | 'none';
+    preload?: unknown;
+}
+export interface RouterNavigationCapability {
+    getSnapshot: () => RouterNavigationSnapshot;
+    subscribe: (listener: () => void) => () => void;
+    navigate: (href: string, options?: {
+        replace?: boolean;
+        state?: unknown;
+    }) => void | Promise<void>;
+    Link: React.ComponentType<{
+        to: string;
+        children?: React.ReactNode;
+        [key: string]: unknown;
+    }>;
+    createLinkProps?: (target: RouterLinkTarget) => {
+        to: string;
+        [key: string]: unknown;
+    };
+}