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

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

@@ -0,0 +1,197 @@
+import "node:module";
+const DEFAULT_RETRYABLE_STATUS_CODES = [
+    408,
+    425,
+    429,
+    500,
+    502,
+    503,
+    504
+];
+const DEFAULT_BASE_DELAY_MS = 100;
+const DEFAULT_MAX_DELAY_MS = 1000;
+const DEFAULT_JITTER_RATIO = 0.1;
+const DEFAULT_RETRYABLE_METHODS = new Set([
+    'DELETE',
+    'GET',
+    'HEAD',
+    'OPTIONS',
+    'PUT',
+    'TRACE'
+]);
+const createTimeoutError = (timeoutMs)=>{
+    const error = new Error(`Request timed out after ${timeoutMs}ms`);
+    error.name = 'TimeoutError';
+    return error;
+};
+const unrefTimer = (timer)=>{
+    if ('object' == typeof timer && null !== timer && 'unref' in timer && 'function' == typeof timer.unref) timer.unref();
+};
+const wait = (ms)=>new Promise((resolve)=>{
+        const timer = setTimeout(()=>resolve(), ms);
+        unrefTimer(timer);
+    });
+const toStatusCode = (error)=>{
+    if (!error || 'object' != typeof error) return;
+    const status = error.status;
+    if ('number' == typeof status) return status;
+    const responseStatus = error.response?.status;
+    if ('number' == typeof responseStatus) return responseStatus;
+};
+const isRetryableNetworkError = (error)=>{
+    if (!error || 'object' != typeof error) return false;
+    const name = error.name;
+    if ('FetchError' === name || 'TimeoutError' === name || 'TypeError' === name) return true;
+    const code = error.code;
+    return 'ECONNRESET' === code || 'ETIMEDOUT' === code || 'ECONNREFUSED' === code || 'EPIPE' === code;
+};
+const normalizePositiveNumber = (value, fallback)=>'number' == typeof value && Number.isFinite(value) && value > 0 ? value : fallback;
+const normalizeNonNegativeInt = (value, fallback)=>'number' == typeof value && Number.isFinite(value) && value >= 0 ? Math.floor(value) : fallback;
+const normalizeJitterRatio = (value)=>{
+    if ('number' != typeof value || !Number.isFinite(value)) return DEFAULT_JITTER_RATIO;
+    return Math.max(0, Math.min(1, value));
+};
+const shouldRetryWithDefaults = (method, statusCode, error, retryableStatusCodes)=>{
+    if (!DEFAULT_RETRYABLE_METHODS.has(method.toUpperCase())) return false;
+    if ('number' == typeof statusCode) return retryableStatusCodes.includes(statusCode);
+    return isRetryableNetworkError(error);
+};
+const shouldRetry = (retryOptions, context, retryableStatusCodes)=>{
+    if ('function' == typeof retryOptions?.shouldRetry) try {
+        return retryOptions.shouldRetry(context);
+    } catch (error) {
+        return false;
+    }
+    return shouldRetryWithDefaults(context.method, context.statusCode, context.error, retryableStatusCodes);
+};
+const getBackoffMs = (retryOptions, attempt)=>{
+    const baseDelayMs = normalizePositiveNumber(retryOptions?.baseDelayMs, DEFAULT_BASE_DELAY_MS);
+    const maxDelayMs = normalizePositiveNumber(retryOptions?.maxDelayMs, DEFAULT_MAX_DELAY_MS);
+    const jitterRatio = normalizeJitterRatio(retryOptions?.jitterRatio);
+    const exponentialDelay = Math.min(maxDelayMs, baseDelayMs * 2 ** Math.max(0, attempt - 1));
+    const jitterFactor = 0 === jitterRatio ? 1 : 1 + (2 * Math.random() - 1) * jitterRatio;
+    return Math.max(0, Math.floor(exponentialDelay * jitterFactor));
+};
+const emitDegradedEvent = (transport, event)=>{
+    if ('function' != typeof transport?.onDegraded) return;
+    try {
+        transport.onDegraded(event);
+    } catch (error) {}
+};
+const withTimeout = async (promise, timeoutMs, signalBuilder)=>{
+    if (!timeoutMs || timeoutMs <= 0) {
+        const result = await promise;
+        return {
+            result
+        };
+    }
+    const controller = signalBuilder?.();
+    let timeoutTriggered = false;
+    let rejectTimeout;
+    const timeoutPromise = new Promise((_, reject)=>{
+        rejectTimeout = reject;
+    });
+    const timer = setTimeout(()=>{
+        timeoutTriggered = true;
+        if (controller) controller.abort();
+        rejectTimeout?.(createTimeoutError(timeoutMs));
+    }, timeoutMs);
+    unrefTimer(timer);
+    try {
+        const result = await Promise.race([
+            promise,
+            timeoutPromise
+        ]);
+        return {
+            result,
+            timeoutTriggered
+        };
+    } catch (error) {
+        if (timeoutTriggered && error?.name === 'AbortError') throw createTimeoutError(timeoutMs);
+        throw error;
+    } finally{
+        clearTimeout(timer);
+    }
+};
+const executeWithResilience = async ({ requestId, target, method, url, init, fetcher, transport })=>{
+    const retries = normalizeNonNegativeInt(transport?.retry?.retries, 0);
+    const timeoutMs = 'number' == typeof transport?.timeoutMs && transport.timeoutMs > 0 ? transport.timeoutMs : void 0;
+    const maxAttempts = retries + 1;
+    const retryableStatusCodes = transport?.retry?.retryableStatusCodes && transport.retry.retryableStatusCodes.length > 0 ? transport.retry.retryableStatusCodes : DEFAULT_RETRYABLE_STATUS_CODES;
+    let attempt = 0;
+    while(attempt < maxAttempts){
+        attempt += 1;
+        const canUseAbortController = "u" > typeof AbortController;
+        let controller;
+        if (timeoutMs && canUseAbortController) controller = new AbortController();
+        const callerSignal = init.signal;
+        const requestSignal = controller ? callerSignal && !callerSignal.aborted ? AbortSignal.any([
+            callerSignal,
+            controller.signal
+        ]) : callerSignal || controller.signal : callerSignal;
+        const nextInit = requestSignal ? {
+            ...init,
+            signal: requestSignal
+        } : init;
+        try {
+            const { result } = await withTimeout(fetcher(url, nextInit), timeoutMs, ()=>controller);
+            return result;
+        } catch (error) {
+            const statusCode = toStatusCode(error);
+            const decisionContext = {
+                requestId,
+                target,
+                method,
+                url,
+                attempt,
+                maxAttempts,
+                error,
+                statusCode
+            };
+            if (error?.name === 'TimeoutError') emitDegradedEvent(transport, {
+                requestId,
+                target,
+                method,
+                url,
+                reason: 'timeout',
+                attempt,
+                maxAttempts,
+                timeoutMs,
+                statusCode,
+                error
+            });
+            const canRetry = attempt < maxAttempts && shouldRetry(transport?.retry, decisionContext, retryableStatusCodes);
+            if (!canRetry) {
+                if (retries > 0 || error?.name === 'TimeoutError') emitDegradedEvent(transport, {
+                    requestId,
+                    target,
+                    method,
+                    url,
+                    reason: 'retry_exhausted',
+                    attempt,
+                    maxAttempts,
+                    timeoutMs,
+                    statusCode,
+                    error
+                });
+                throw error;
+            }
+            const backoffMs = getBackoffMs(transport?.retry, attempt);
+            emitDegradedEvent(transport, {
+                requestId,
+                target,
+                method,
+                url,
+                reason: 'retry',
+                attempt,
+                maxAttempts,
+                timeoutMs,
+                backoffMs,
+                statusCode,
+                error
+            });
+            if (backoffMs > 0) await wait(backoffMs);
+        }
+    }
+};
+export { executeWithResilience };

package/dist/esm-node/request-policy/types.mjs

@@ -0,0 +1,11 @@
+import "node:module";
+const BFF_ENVELOPE_HEADER = 'x-modernjs-bff-envelope';
+const BFF_OPERATION_CONTEXT_HEADER = 'x-operation-id';
+const BFF_OPERATION_CONTEXT_DETAIL_HEADER = 'x-modernjs-bff-operation-context';
+const BFF_DEFAULT_PROTECTED_IDENTITY_HEADERS = [
+    'x-tenant-id',
+    'x-subject-id',
+    'x-user-id',
+    BFF_OPERATION_CONTEXT_HEADER
+];
+export { BFF_DEFAULT_PROTECTED_IDENTITY_HEADERS, BFF_ENVELOPE_HEADER, BFF_OPERATION_CONTEXT_DETAIL_HEADER, BFF_OPERATION_CONTEXT_HEADER };

package/dist/esm-node/routeHydration.mjs

@@ -0,0 +1,78 @@
+import "node:module";
+import { escapeHtmlAttribute } from "./html.mjs";
+function getScriptTags(template) {
+    const scriptRegExp = /<script\b[^>]*\bsrc=(["'])(.*?)\1[^>]*><\/script>/g;
+    return Array.from(template.matchAll(scriptRegExp)).map((match)=>({
+            index: match.index ?? 0,
+            tag: match[0],
+            src: match[2]
+        }));
+}
+function getAssetBasename(src) {
+    const withoutQuery = src.split(/[?#]/)[0];
+    return withoutQuery.split('/').pop() || withoutQuery;
+}
+function isEntryScript(src, entryName, asyncEntry) {
+    const basename = getAssetBasename(src);
+    const prefix = asyncEntry ? `async-${entryName}` : entryName;
+    return basename === `${prefix}.js` || basename.startsWith(`${prefix}.`) || basename.startsWith(`${prefix}-`);
+}
+const dedupeByUrl = (chunks)=>{
+    const seen = new Set();
+    return chunks.filter((chunk)=>{
+        if (void 0 === chunk.url || '' === chunk.url || seen.has(chunk.url)) return false;
+        seen.add(chunk.url);
+        return true;
+    });
+};
+const isAsyncEntryScriptChunk = (chunk, entryName)=>{
+    if (void 0 === chunk.url || !chunk.url.endsWith('.js')) return false;
+    const asyncEntryName = `async-${entryName}`;
+    const filename = chunk.filename ?? chunk.url;
+    const basename = filename.split('/').pop() ?? filename;
+    return basename === `${asyncEntryName}.js` || basename.startsWith(`${asyncEntryName}.`) || basename.startsWith(`${asyncEntryName}-`);
+};
+function getMatchedRouteChunks(routeManifest, matchedRouteIds, routeAssetToChunk) {
+    const routeAssets = routeManifest?.routeAssets;
+    if (void 0 === routeAssets) return [];
+    return matchedRouteIds.flatMap((routeId)=>routeAssets[routeId]?.assets ?? []).map(routeAssetToChunk);
+}
+const orderHydrationScriptChunks = ({ asyncEntryChunks, collectedChunks, matchedRouteChunks, entryName })=>{
+    const asyncEntryScriptChunks = [];
+    const asyncEntryDependencyChunks = [];
+    for (const chunk of asyncEntryChunks)if (isAsyncEntryScriptChunk(chunk, entryName)) asyncEntryScriptChunks.push(chunk);
+    else asyncEntryDependencyChunks.push(chunk);
+    return dedupeByUrl([
+        ...asyncEntryDependencyChunks,
+        ...collectedChunks,
+        ...matchedRouteChunks,
+        ...asyncEntryScriptChunks
+    ]);
+};
+function injectBeforeHydrationEntryScript(template, scripts, entryName = 'index') {
+    if ('' === scripts) return template;
+    const scriptTags = getScriptTags(template);
+    const target = scriptTags.find((match)=>isEntryScript(match.src, entryName, false)) ?? scriptTags.find((match)=>isEntryScript(match.src, entryName, true));
+    if (void 0 === target) return template;
+    return `${template.slice(0, target.index)}${scripts}${template.slice(target.index)}`;
+}
+function replaceChunkJsPlaceholder(template, scripts, entryName, placeholder) {
+    if (!template.includes(placeholder)) return template;
+    if ('' === scripts) return template.replace(placeholder, ()=>'');
+    const withoutPlaceholder = template.replace(placeholder, ()=>'');
+    const withEarlyScripts = injectBeforeHydrationEntryScript(withoutPlaceholder, scripts, entryName);
+    if (withEarlyScripts !== withoutPlaceholder) return withEarlyScripts;
+    return template.replace(placeholder, ()=>scripts);
+}
+function createRouteHydrationScriptTags(routeManifest, matchedRouteIds, entryName, options = {}) {
+    const { nonce, template } = options;
+    const routeAssets = routeManifest?.routeAssets;
+    if (void 0 === routeAssets) return '';
+    const existingScriptSrcs = void 0 === template ? new Set() : new Set(getScriptTags(template).map(({ src })=>src));
+    const jsAssets = Array.from(new Set([
+        ...getMatchedRouteChunks(routeManifest, matchedRouteIds, (asset)=>asset),
+        ...routeAssets[`async-${entryName}`]?.assets ?? []
+    ].filter((asset)=>asset.endsWith('.js'))));
+    return jsAssets.filter((asset)=>!existingScriptSrcs.has(asset)).map((asset)=>`<script src="${escapeHtmlAttribute(asset)}"${nonce ? ` nonce="${escapeHtmlAttribute(nonce)}"` : ''}></script>`).join(' ');
+}
+export { createRouteHydrationScriptTags, getMatchedRouteChunks, injectBeforeHydrationEntryScript, orderHydrationScriptChunks, replaceChunkJsPlaceholder };

package/dist/esm-node/routerPrefetchPolicy.mjs

@@ -0,0 +1,116 @@
+import "node:module";
+import { getNavigationWarmupCacheKey } from "./navigationWarmup.mjs";
+import { normalizePreloadBehavior } from "./prefetchPolicy.mjs";
+const INTENT_DELAY = 100;
+const VIEWPORT_ROOT_MARGIN = '200px';
+const MAX_CONCURRENT_WARMUPS = 4;
+const WARMUP_TTL = 30000;
+function createRouterPrefetchPolicy() {
+    const cache = new Map();
+    const queue = [];
+    let activeWarmups = 0;
+    const canWarmup = ()=>{
+        const navigator = globalThis.navigator;
+        const connection = navigator?.connection || navigator?.mozConnection || navigator?.webkitConnection;
+        return !connection?.saveData && connection?.effectiveType !== 'slow-2g' && connection?.effectiveType !== '2g';
+    };
+    const runNext = ()=>{
+        while(activeWarmups < MAX_CONCURRENT_WARMUPS && queue.length > 0){
+            const task = queue.shift();
+            if (task.cancelled) continue;
+            activeWarmups += 1;
+            task.run().catch(()=>{
+                cache.delete(task.key);
+            }).finally(()=>{
+                activeWarmups -= 1;
+                runNext();
+            });
+        }
+    };
+    return {
+        canWarmup,
+        allowData (route) {
+            return route?.handle?.navigationWarmup?.data !== false;
+        },
+        observe ({ element, prefetch: inputPrefetch, preload: inputPreload, notify }) {
+            const prefetch = inputPrefetch ?? 'render';
+            const preload = normalizePreloadBehavior(inputPreload, prefetch);
+            let state = {
+                code: 'render' === prefetch || 'render' === preload,
+                data: 'render' === prefetch
+            };
+            let timer;
+            let observer;
+            const update = (next)=>{
+                state = next;
+                notify(state);
+            };
+            const cancelTimer = ()=>{
+                if (void 0 !== timer) {
+                    clearTimeout(timer);
+                    timer = void 0;
+                }
+            };
+            notify(state);
+            if (element && ('viewport' === prefetch || 'viewport' === preload) && "u" > typeof IntersectionObserver) {
+                observer = new IntersectionObserver((entries)=>{
+                    if (!entries.some((entry)=>entry.isIntersecting)) return;
+                    update({
+                        code: true,
+                        data: state.data || 'viewport' === prefetch
+                    });
+                    observer?.disconnect();
+                }, {
+                    rootMargin: VIEWPORT_ROOT_MARGIN
+                });
+                observer.observe(element);
+            }
+            return {
+                onIntent () {
+                    if ('intent' !== prefetch && 'intent' !== preload) return;
+                    if (void 0 !== timer) return;
+                    timer = setTimeout(()=>{
+                        timer = void 0;
+                        update({
+                            code: true,
+                            data: state.data || 'intent' === prefetch
+                        });
+                    }, INTENT_DELAY);
+                },
+                onCancel () {
+                    if ('intent' === prefetch || 'intent' === preload) {
+                        cancelTimer();
+                        update({
+                            code: false,
+                            data: false
+                        });
+                    }
+                },
+                dispose () {
+                    cancelTimer();
+                    observer?.disconnect();
+                }
+            };
+        },
+        schedule ({ runtimeContext, chunkLoader, publicPath, key: operationKey, run }) {
+            if (!canWarmup()) return ()=>{};
+            const now = performance.now();
+            for (const [key, timestamp] of cache)if (now - timestamp > WARMUP_TTL) cache.delete(key);
+            const key = getNavigationWarmupCacheKey(runtimeContext, chunkLoader, publicPath, operationKey);
+            if (cache.has(key)) return ()=>{};
+            cache.set(key, now);
+            const task = {
+                key,
+                run,
+                cancelled: false
+            };
+            queue.push(task);
+            runNext();
+            return ()=>{
+                task.cancelled = true;
+                if (queue.includes(task)) cache.delete(key);
+            };
+        }
+    };
+}
+export { createRouterPrefetchPolicy };

package/dist/esm-node/routerProvider.mjs

@@ -0,0 +1,118 @@
+import "node:module";
+import { merge } from "@modern-js/runtime-utils/merge";
+function reportUnsupportedProviderRegistryHooks(providerPlugin, routerProviderRegistryHooks) {
+    const unsupportedHookNames = Object.keys(providerPlugin.registryHooks ?? {}).filter((hookName)=>!(hookName in routerProviderRegistryHooks));
+    if (unsupportedHookNames.length > 0) console.warn(`[@modern-js/runtime] The router provider "${providerPlugin.name}" declares registry hooks outside the router hook contract: ${unsupportedHookNames.join(', ')}. These hooks are not registered when the provider is resolved through \`runtime.router.framework\` — declare them on a separate runtime plugin instead.`);
+    return unsupportedHookNames;
+}
+function createRouterProviderRealm(registrations) {
+    const providers = new Map();
+    let defaultProvider;
+    for (const registration of registrations){
+        if (0 === registration.name.length) throw new Error('[@modern-js/runtime] A router provider realm cannot contain an unnamed provider.');
+        if (providers.has(registration.name)) throw new Error(`[@modern-js/runtime] Router provider "${registration.name}" is declared more than once in the same runtime realm.`);
+        if (true === registration.isDefault && void 0 !== defaultProvider && defaultProvider !== registration.name) throw new Error(`[@modern-js/runtime] Router provider realm declares both "${defaultProvider}" and "${registration.name}" as defaults.`);
+        providers.set(registration.name, registration.factory);
+        if (true === registration.isDefault) defaultProvider = registration.name;
+    }
+    const providerNames = Object.freeze([
+        ...providers.keys()
+    ]);
+    return Object.freeze({
+        ...void 0 !== defaultProvider ? {
+            defaultProvider
+        } : {},
+        get: (name)=>providers.get(name),
+        names: ()=>providerNames
+    });
+}
+const REGISTRY_SLOT = Symbol.for('@modern-js/runtime:router-providers:v3');
+const LEGACY_V2_REGISTRY_SLOT = Symbol.for('@modern-js/runtime:router-providers:v2');
+function getRegistry() {
+    const host = globalThis;
+    host[REGISTRY_SLOT] ??= {
+        providers: new Map(),
+        duplicateProviders: new Set(),
+        warnedDuplicates: new Set()
+    };
+    host[REGISTRY_SLOT].duplicateProviders ??= new Set();
+    host[REGISTRY_SLOT].warnedDuplicates ??= new Set();
+    return host[REGISTRY_SLOT];
+}
+function getLegacyV2Registry() {
+    const host = globalThis;
+    return host[LEGACY_V2_REGISTRY_SLOT];
+}
+function registerRouterProvider(name, factory, options = {}) {
+    const registry = getRegistry();
+    const existing = registry.providers.get(name);
+    if (void 0 !== existing) {
+        if (existing !== factory) registry.duplicateProviders.add(name);
+        return;
+    }
+    if (true === options.isDefault) registry.defaultProvider = name;
+    registry.providers.set(name, factory);
+}
+function resolveRouterProvider(framework, options = {}) {
+    if (void 0 !== options.realm) {
+        const name = framework || options.realm.defaultProvider;
+        const realmProviderNames = options.realm.names();
+        if (void 0 === name) throw new Error(`[@modern-js/runtime] The app-owned router provider realm does not declare a default provider. Available realm providers: ${realmProviderNames.join(', ') || '(none)'}.`);
+        const factory = options.realm.get(name);
+        if (void 0 === factory) throw new Error(`[@modern-js/runtime] Router provider "${name}" is not registered in the app-owned router provider realm. Available realm providers: ${realmProviderNames.join(', ') || '(none)'}. Compatibility registry fallback is disabled for app-owned realms.`);
+        return factory;
+    }
+    const registry = getRegistry();
+    const legacyV2Registry = getLegacyV2Registry();
+    const name = framework || options.localDefault?.name || registry.defaultProvider || legacyV2Registry?.defaultProvider;
+    if (void 0 === name) throw new Error('[@modern-js/runtime] No default router provider is registered. This is a bug in the runtime setup.');
+    if (void 0 !== options.localDefault && name === options.localDefault.name) return options.localDefault.factory;
+    const factory = registry.providers.get(name);
+    if (void 0 !== factory) {
+        if (registry.duplicateProviders.has(name) && !registry.warnedDuplicates.has(name)) {
+            registry.warnedDuplicates.add(name);
+            console.warn(`[@modern-js/runtime] The router provider "${name}" was registered more than once with different module instances, and a router wrapper without an app-owned provider realm is resolving the mixed-version compatibility fallback. The fallback is keeping the first registration. Modern router wrappers isolate app-owned realms automatically. For an older wrapper, share the provider runtime between Module Federation host and remotes or upgrade every app to a realm-aware runtime.`);
+        }
+        return factory;
+    }
+    const legacyV2Factory = legacyV2Registry?.providers.get(name);
+    if (void 0 !== legacyV2Factory) return legacyV2Factory;
+    if ('tanstack' === name) throw new Error("[@modern-js/runtime] `runtime.router.framework` is set to \"tanstack\", but no TanStack router provider is registered. Install @modern-js/plugin-tanstack, add `tanstackRouterPlugin()` to the `plugins` array in modern.config.ts, and make sure '@modern-js/plugin-tanstack/runtime' is imported (e.g. in modern.runtime.ts).");
+    throw new Error(`[@modern-js/runtime] Unknown router framework "${name}". Registered providers: ${[
+        ...new Set([
+            ...registry.providers.keys(),
+            ...legacyV2Registry?.providers.keys() ?? []
+        ])
+    ].join(', ') || '(none)'}. Install and register the plugin that provides this router framework.`);
+}
+function unsafe_resetRouterProvidersForTesting() {
+    const host = globalThis;
+    delete host[REGISTRY_SLOT];
+    delete host[LEGACY_V2_REGISTRY_SLOT];
+}
+function createRouterPlugin({ defaultProvider, registryHooks, localProviders = [] }) {
+    registerRouterProvider(defaultProvider.name, defaultProvider.factory, {
+        isDefault: true
+    });
+    const realm = createRouterProviderRealm([
+        {
+            ...defaultProvider,
+            isDefault: true
+        },
+        ...localProviders
+    ]);
+    return (userConfig = {})=>({
+            name: '@modern-js/plugin-router',
+            registryHooks,
+            setup (api) {
+                const mergedConfig = merge(api.getRuntimeConfig().router || {}, userConfig);
+                const factory = resolveRouterProvider(mergedConfig.framework, {
+                    realm
+                });
+                const provider = factory(userConfig);
+                reportUnsupportedProviderRegistryHooks(provider, registryHooks);
+                provider.setup?.(api);
+            }
+        });
+}
+export { createRouterPlugin, createRouterProviderRealm, registerRouterProvider, reportUnsupportedProviderRegistryHooks, resolveRouterProvider, unsafe_resetRouterProvidersForTesting };

package/dist/esm-node/routerState.mjs

@@ -0,0 +1,106 @@
+import "node:module";
+import { createRuntimeContextExtension } from "./contextExtensions.mjs";
+const routerRuntimeStateExtension = createRuntimeContextExtension('@modern-js/runtime:router-runtime-state');
+const routerServerSnapshotExtension = createRuntimeContextExtension('@modern-js/runtime:router-server-snapshot');
+function getRouterRuntimeState(runtimeContext) {
+    return routerRuntimeStateExtension.get(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
+        } : {},
+        ...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 ? {
+            matchedRouteIds
+        } : {},
+        ...serverSnapshot ? {
+            serverSnapshot
+        } : {}
+    };
+}
+function applyRouterRuntimeState(runtimeContext, state) {
+    const normalized = createRouterRuntimeState(state);
+    routerRuntimeStateExtension.set(runtimeContext, normalized);
+    if (normalized.serverSnapshot) routerServerSnapshotExtension.set(runtimeContext, normalized.serverSnapshot);
+    return runtimeContext;
+}
+function applyRouterServerPrepareResult(runtimeContext, result) {
+    const state = createRouterRuntimeState({
+        ...result.state,
+        cleanup: result.cleanup ?? result.state.cleanup,
+        serverSnapshot: result.snapshot ?? result.state.serverSnapshot
+    });
+    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
+    }) ?? [];
+}
+function getRouterMatchedRouteIds(runtimeContext) {
+    const serverSnapshot = getRouterServerSnapshot(runtimeContext);
+    const runtimeState = getRouterRuntimeState(runtimeContext);
+    return serverSnapshot?.matchedRouteIds ?? getMatchedRouteIdsFromMatches(serverSnapshot?.matches) ?? runtimeState?.matchedRouteIds ?? getMatchedRouteIdsFromMatches(runtimeState?.matches);
+}
+async function cleanupRouterRuntimeState(runtimeContext) {
+    try {
+        await getRouterRuntimeState(runtimeContext)?.cleanup?.();
+    } catch  {}
+}
+export { applyRouterRuntimeState, applyRouterServerPrepareResult, cleanupRouterRuntimeState, createRouterRuntimeState, createRouterServerSnapshot, getRouterHydrationScripts, getRouterMatchedRouteIds, getRouterRuntimeState, getRouterServerSnapshot };

package/dist/esm-node/routerStatePlugin.mjs

@@ -0,0 +1,49 @@
+import "node:module";
+import { createRouterPrefetchPolicy } from "./routerPrefetchPolicy.mjs";
+import { applyRouterRuntimeState, createRouterServerSnapshot } from "./routerState.mjs";
+function createRouterStatePlugin({ registryHooks }) {
+    return {
+        name: '@modern-js/router-runtime-policy',
+        registryHooks,
+        setup (api) {
+            api.onBeforeRender((context)=>{
+                const runtimeContext = context;
+                runtimeContext.linkPrefetchPolicy ??= createRouterPrefetchPolicy();
+            });
+            api.onAfterCreateRouter((event)=>{
+                if ('react-router' !== event.framework) return;
+                if ('ssr-prepare' === event.phase) {
+                    const { routerContext } = event.runtimeContext;
+                    if (!routerContext) return;
+                    const serverSnapshot = createRouterServerSnapshot({
+                        framework: event.framework,
+                        basename: event.basename,
+                        statusCode: routerContext.statusCode,
+                        errors: routerContext.errors ?? void 0,
+                        routerData: {
+                            loaderData: routerContext.loaderData,
+                            errors: routerContext.errors ?? void 0
+                        },
+                        matches: routerContext.matches.flatMap((match)=>'string' == typeof match.route.id ? [
+                                {
+                                    routeId: match.route.id
+                                }
+                            ] : [])
+                    });
+                    applyRouterRuntimeState(event.runtimeContext, {
+                        framework: event.framework,
+                        basename: event.basename,
+                        instance: event.router,
+                        matchedRouteIds: serverSnapshot.matchedRouteIds,
+                        serverSnapshot
+                    });
+                } else if ('client-create' === event.phase) applyRouterRuntimeState(event.runtimeContext, {
+                    framework: event.framework,
+                    basename: event.basename,
+                    instance: event.router
+                });
+            });
+        }
+    };
+}
+export { createRouterStatePlugin };