@bleedingdev/modern-js-runtime 3.2.0-ultramodern.120 → 3.2.0-ultramodern.121

package/dist/esm-node/module-federation/index.mjs

@@ -0,0 +1,110 @@
+import "node:module";
+const MODULE_FEDERATION_FALLBACK_SIGNAL_EVENT = 'modernjs:mf-runtime-fallback';
+const MODULE_FEDERATION_RECOVERY_SIGNAL_EVENT = 'modernjs:mf-runtime-recovery';
+const DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT = '/_modern/contract-gates/runtime-fallback';
+const DEFAULT_RUNTIME_FALLBACK_SIGNAL_AUTH_HEADER = 'x-modernjs-runtime-signal-token';
+class ModuleFederationRemoteLoadTimeoutError extends Error {
+    constructor(remote, timeoutMs){
+        super(`Loading remote "${remote}" timed out after ${timeoutMs}ms`);
+        this.name = 'ModuleFederationRemoteLoadTimeoutError';
+    }
+}
+class ModuleFederationRemoteLoadError extends Error {
+    constructor(remote, attempts, causeError){
+        super(`Unable to load remote "${remote}" after ${attempts} attempt${attempts > 1 ? 's' : ''}: ${causeError.message}`);
+        this.name = 'ModuleFederationRemoteLoadError';
+        this.remote = remote;
+        this.attempts = attempts;
+        this.causeError = causeError;
+    }
+}
+class ModuleFederationRemoteComponentContractError extends Error {
+    constructor(remote, exportName){
+        super(`Remote "${remote}" export "${exportName}" is not a valid React component`);
+        this.name = 'ModuleFederationRemoteComponentContractError';
+    }
+}
+function toError(error) {
+    if (error instanceof Error) return error;
+    return new Error('string' == typeof error ? error : 'Unknown remote load error');
+}
+function classifyModuleFederationFallback(error) {
+    const normalizedError = toError(error);
+    if (normalizedError instanceof ModuleFederationRemoteLoadError) return classifyModuleFederationFallback(normalizedError.causeError);
+    if (normalizedError instanceof ModuleFederationRemoteLoadTimeoutError) return 'timeout';
+    if (normalizedError instanceof ModuleFederationRemoteComponentContractError) return 'contract';
+    const message = normalizedError.message;
+    if (/version|requiredVersion|singleton|share scope|shared module/i.test(message)) return 'version-skew';
+    if (/network|fetch|script|timeout|chunk|loading/i.test(message)) return 'network';
+    return 'remote-unavailable';
+}
+function createModuleFederationFallbackTelemetry(input) {
+    const error = void 0 !== input.error ? toError(input.error) : void 0;
+    const status = input.status ?? 'degraded';
+    const eventName = input.eventName ?? ('recovered' === status ? MODULE_FEDERATION_RECOVERY_SIGNAL_EVENT : MODULE_FEDERATION_FALLBACK_SIGNAL_EVENT);
+    const metadata = {
+        ...input.metadata ?? {},
+        classification: input.classification,
+        remote: input.remote,
+        status
+    };
+    if (void 0 !== input.exportName) metadata.exportName = input.exportName;
+    if (void 0 !== input.runtimeDigest) metadata.runtimeDigest = input.runtimeDigest;
+    if (void 0 !== error) {
+        metadata.errorName = error.name;
+        metadata.errorMessage = error.message;
+    }
+    const payload = {
+        appName: input.appName,
+        eventName,
+        metadata,
+        phase: input.phase,
+        reason: input.classification,
+        schemaVersion: 1
+    };
+    if (void 0 !== input.entry) payload.entry = input.entry;
+    if (void 0 !== input.runtimeDigest) payload.runtimeDigest = input.runtimeDigest;
+    return payload;
+}
+function toModuleFederationFallbackAttributes(payload) {
+    return {
+        'data-mf-fallback-app': payload.appName,
+        'data-mf-fallback-classification': payload.reason,
+        'data-mf-fallback-phase': payload.phase,
+        'data-mf-fallback-remote': String(payload.metadata.remote),
+        'data-mf-fallback-status': String(payload.metadata.status),
+        'data-mf-telemetry-event': payload.eventName
+    };
+}
+async function emitModuleFederationFallbackTelemetry(input, options = {}) {
+    const payload = createModuleFederationFallbackTelemetry(input);
+    if ("u" > typeof window && 'function' == typeof window.dispatchEvent && "u" > typeof CustomEvent) window.dispatchEvent(new CustomEvent(payload.eventName, {
+        detail: payload
+    }));
+    const shouldPost = true === options.postSignal || Boolean(options.endpoint);
+    if (!shouldPost) return {
+        dispatched: true,
+        posted: false
+    };
+    const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+    if ('function' != typeof fetchImpl) return {
+        dispatched: true,
+        posted: false
+    };
+    const headers = new Headers({
+        'content-type': 'application/json'
+    });
+    if (void 0 !== options.authToken && options.authToken.length > 0) headers.set(options.authHeaderName ?? DEFAULT_RUNTIME_FALLBACK_SIGNAL_AUTH_HEADER, options.authToken);
+    const response = await fetchImpl(options.endpoint ?? DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT, {
+        body: JSON.stringify(payload),
+        headers,
+        method: 'POST',
+        keepalive: true
+    });
+    return {
+        dispatched: true,
+        posted: true,
+        postStatus: response.status
+    };
+}
+export { DEFAULT_RUNTIME_FALLBACK_SIGNAL_AUTH_HEADER, DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT, MODULE_FEDERATION_FALLBACK_SIGNAL_EVENT, MODULE_FEDERATION_RECOVERY_SIGNAL_EVENT, ModuleFederationRemoteComponentContractError, ModuleFederationRemoteLoadError, ModuleFederationRemoteLoadTimeoutError, classifyModuleFederationFallback, createModuleFederationFallbackTelemetry, emitModuleFederationFallbackTelemetry, toModuleFederationFallbackAttributes };

package/dist/esm-node/router/cli/code/index.mjs

@@ -6,7 +6,6 @@ import { ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME } from "../../../cli/const
 import { resolveSSRMode } from "../../../cli/ssr/mode.mjs";
 import { FILE_SYSTEM_ROUTES_FILE_NAME } from "../constants.mjs";
 import { walk } from "./nestedRoutes.mjs";
-import { generateTanstackRouterTypesSourceForEntry, isTanstackRouterFrameworkEnabled } from "./tanstackTypes.mjs";
 import { getServerCombinedModuleFile, getServerLoadersFile } from "./utils.mjs";
 import * as __rspack_external__templates_mjs_4da4c6c8 from "./templates.mjs";
 async function generateRoutesForEntry(entrypoint, appContext) {
@@ -41,42 +40,11 @@ async function generateRoutesForEntry(entrypoint, appContext) {
     }
     return routes;
 }
-const generateCode = async (appContext, config, entrypoints, api, options)=>{
+const generateCode = async (appContext, config, entrypoints, api)=>{
     const { internalDirectory, srcDirectory, internalSrcAlias, packageName } = appContext;
     const hooks = api.getHooks();
-    const enableTanstackTypes = options?.enableTanstackTypes ?? await isTanstackRouterFrameworkEnabled(appContext);
     const generatedRoutesByEntry = {};
     await Promise.all(entrypoints.map(generateEntryCode));
-    if (enableTanstackTypes) {
-        const allEntries = Array.from(new Set(entrypoints.map((e)=>e.entryName).filter(Boolean)));
-        const mainEntry = entrypoints.find((e)=>e.isMainEntry)?.entryName;
-        const registerEntries = allEntries.sort((a, b)=>{
-            if (mainEntry && a === mainEntry) return -1;
-            if (mainEntry && b === mainEntry) return 1;
-            return a.localeCompare(b);
-        });
-        if (registerEntries.length > 0) {
-            const registerDtsPath = path.join(srcDirectory, 'modern-tanstack', 'register.gen.d.ts');
-            const importStatements = registerEntries.map((entryName, index)=>`import type { router as router${index} } from './${entryName}/router.gen';`).join('\n');
-            const routerUnionType = registerEntries.map((_, index)=>`typeof router${index}`).join(' | ');
-            const registerContent = `// This file is auto-generated by Modern.js. Do not edit manually.
-
-${importStatements}
-
-declare module '@modern-js/runtime/tanstack-router' {
-  interface Register {
-    router: ${routerUnionType};
-  }
-}
-`;
-            try {
-                const prev = await fs.pathExists(registerDtsPath) ? await fs.readFile(registerDtsPath, 'utf-8') : null;
-                if (prev !== registerContent) await fs.outputFile(registerDtsPath, registerContent, 'utf-8');
-            } catch  {
-                await fs.outputFile(registerDtsPath, registerContent, 'utf-8');
-            }
-        }
-    }
     async function generateEntryCode(entrypoint) {
         const { entryName, isMainEntry, isAutoMount, pageRoutesEntry, nestedRoutesEntry } = entrypoint;
         const { metaName } = api.getAppContext();
@@ -158,20 +126,6 @@ declare module '@modern-js/runtime/tanstack-router' {
                     await fs.outputFile(serverLoaderFile, serverLoaderCombined);
                 }
                 await fs.outputFile(path.resolve(internalDirectory, `./${entryName}/${FILE_SYSTEM_ROUTES_FILE_NAME}`), code, 'utf8');
-                if (enableTanstackTypes) {
-                    const { routerGenTs } = await generateTanstackRouterTypesSourceForEntry({
-                        appContext,
-                        entryName,
-                        routes: routes
-                    });
-                    const outPath = path.join(srcDirectory, 'modern-tanstack', entryName, 'router.gen.ts');
-                    try {
-                        const prev = await fs.pathExists(outPath) ? await fs.readFile(outPath, 'utf-8') : null;
-                        if (prev !== routerGenTs) await fs.outputFile(outPath, routerGenTs, 'utf-8');
-                    } catch  {
-                        await fs.outputFile(outPath, routerGenTs, 'utf-8');
-                    }
-                }
             }
         }
     }

package/dist/esm-node/router/cli/code/templates.mjs

@@ -102,20 +102,7 @@ const fileSystemRoutes = async ({ metaName, routes, ssrMode, nestedRoutesEntry,
     const loadersMapFile = path.join(internalDirectory, entryName, TEMP_LOADERS_DIR, 'map.json');
     const importLazyCode = `
     import { lazy } from "react";
-    import * as loadableModule from "@${metaName}/runtime/loadable"
-
-    const resolveLoadableExport = module => {
-      const candidates = [module, module.default, module.default?.default];
-      const loadable = candidates.find(candidate => typeof candidate === 'function');
-
-      if (!loadable) {
-        throw new TypeError('Modern.js runtime loadable export must resolve to a function');
-      }
-
-      return loadable;
-    };
-    const loadable = resolveLoadableExport(loadableModule);
-    const loadableLazy = loadableModule.lazy || loadableModule.default?.lazy || loadable.lazy;
+    import loadable, { lazy as loadableLazy } from "@${metaName}/runtime/loadable"
   `;
     let rootLayoutCode = "";
     const getDataLoaderPath = ({ loaderId, clientData, action, inline, routeId, inValidSSRRoute })=>{

package/dist/esm-node/router/cli/handler.mjs

@@ -21,7 +21,7 @@ async function handleGeneratorEntryCode(api, entrypoints, options = {}) {
     const { generatorRegisterCode, generateCode, generatorServerRegisterCode } = await import("./code/index.mjs");
     originEntrypointsByKey.set(entrypointsKey, cloneDeep(entrypoints));
     const enableRsc = resolvedConfig?.server?.rsc;
-    const routesByEntry = await generateCode(appContext, resolvedConfig, entrypoints, api, normalizedOptions.generateCodeOptions);
+    const routesByEntry = await generateCode(appContext, resolvedConfig, entrypoints, api);
     await Promise.all(entrypoints.map(async (entrypoint)=>{
         if (entrypoint.nestedRoutesEntry || entrypoint.pageRoutesEntry) {
             const route = appContext.serverRoutes.find((r)=>r.entryName === entrypoint.entryName);

package/dist/esm-node/router/cli/index.mjs

@@ -1,32 +1,12 @@
 import "node:module";
 import node_path from "node:path";
-import { NESTED_ROUTE_SPEC_FILE, filterRoutesForServer, findExists, fs } from "@modern-js/utils";
+import { NESTED_ROUTE_SPEC_FILE, filterRoutesForServer, fs } from "@modern-js/utils";
 import { NESTED_ROUTES_DIR } from "./constants.mjs";
 import { BUILT_IN_ROUTES_OWNER, getEntrypointRoutesDir, getEntrypointRoutesOwner, isRouteEntry } from "./entry.mjs";
 import { handleFileChange, handleGeneratorEntryCode, handleModifyEntrypoints } from "./handler.mjs";
 import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
 import { dirname as __rspack_dirname } from "node:path";
 var cli_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
-const JS_OR_TS_EXTS = [
-    '.js',
-    '.jsx',
-    '.ts',
-    '.tsx',
-    '.mjs',
-    '.mts',
-    '.cjs',
-    '.cts'
-];
-function hasRouterConfigInRuntimeFile(runtimeConfigBase) {
-    const runtimeConfigFile = findExists(JS_OR_TS_EXTS.map((ext)=>`${runtimeConfigBase}${ext}`));
-    if (!runtimeConfigFile) return false;
-    try {
-        const content = fs.readFileSync(runtimeConfigFile, 'utf-8');
-        return /router\s*:/.test(content);
-    } catch  {
-        return false;
-    }
-}
 function isBuiltInRouteEntrypoint(entrypoint) {
     const entrypointRoutesOwner = getEntrypointRoutesOwner(entrypoint);
     if (entrypointRoutesOwner) return entrypointRoutesOwner === BUILT_IN_ROUTES_OWNER;
@@ -56,12 +36,11 @@ const routerPlugin = ()=>({
                 });
             });
             api._internalRuntimePlugins(({ entrypoint, plugins })=>{
-                const { serverRoutes, metaName, srcDirectory, runtimeConfigFile } = api.getAppContext();
+                const { serverRoutes, metaName } = api.getAppContext();
                 const normalizedConfig = api.getNormalizedConfig();
                 const hasUserRouterConfig = normalizedConfig.router && Object.keys(normalizedConfig.router).length > 0;
-                const hasRuntimeRouterConfig = hasRouterConfigInRuntimeFile(node_path.join(srcDirectory, runtimeConfigFile));
                 const serverBase = serverRoutes.filter((route)=>route.entryName === entrypoint.entryName).map((route)=>route.urlPath).sort((a, b)=>a.length - b.length > 0 ? -1 : 1);
-                const shouldInstallBuiltInRouter = isBuiltInRouteEntrypoint(entrypoint) || !isPluginOwnedRouteEntrypoint(entrypoint) && (hasUserRouterConfig || hasRuntimeRouterConfig);
+                const shouldInstallBuiltInRouter = isBuiltInRouteEntrypoint(entrypoint) || !isPluginOwnedRouteEntrypoint(entrypoint) && hasUserRouterConfig;
                 if (shouldInstallBuiltInRouter) plugins.push({
                     name: 'router',
                     path: `@${metaName}/runtime/router/internal`,

package/dist/esm-node/router/runtime/DeferredDataScripts.node.mjs

@@ -5,6 +5,21 @@ import { useEffect, useMemo, useRef } from "react";
 import { ROUTER_DATA_JSON_ID } from "../../core/constants.mjs";
 import { modernInline, runWindowFnStr } from "./constants.mjs";
 import { serializeErrors } from "./utils.mjs";
+function toDeferredErrorInfo(error) {
+    if ('production' === process.env.NODE_ENV) return {
+        message: 'Unexpected Server Error'
+    };
+    if (error && 'object' == typeof error) {
+        const maybeMessage = error.message;
+        return {
+            message: 'string' == typeof maybeMessage ? maybeMessage : String(maybeMessage ?? error),
+            stack: error.stack
+        };
+    }
+    return {
+        message: String(error)
+    };
+}
 const DeferredDataScripts = (props)=>{
     const staticContext = props?.context;
     const useJsonScript = props?.useJsonScript;
@@ -40,10 +55,7 @@ const DeferredDataScripts = (props)=>{
                 {
                     const trackedPromise = deferredData.data[key];
                     if (void 0 !== trackedPromise._error) {
-                        const error = {
-                            message: trackedPromise._error.message,
-                            stack: 'production' !== process.env.NODE_ENV ? trackedPromise._error.stack : void 0
-                        };
+                        const error = toDeferredErrorInfo(trackedPromise._error);
                         return {
                             key,
                             routerDataFnName: 'p',

package/dist/esm-node/router/runtime/PrefetchLink.mjs

@@ -12,7 +12,6 @@ function composeEventHandlers(theirHandler, ourHandler) {
 }
 const ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
 const DEFAULT_PREFETCH_BEHAVIOR = 'render';
-const DEFAULT_PRELOAD_BEHAVIOR = 'viewport';
 const INTENT_DELAY = 100;
 const VIEWPORT_ROOT_MARGIN = '200px';
 const MAX_CONCURRENT_WARMUPS = 4;
@@ -77,7 +76,7 @@ const setRef = (ref, value)=>{
 };
 const isDataWarmupEnabled = (route)=>{
     const handle = route.handle;
-    return handle?.navigationWarmup?.data === true;
+    return handle?.navigationWarmup?.data !== false;
 };
 function usePrefetchBehavior(prefetch, preload, theirElementProps) {
     const [maybeWarmup, setMaybeWarmup] = react.useState(false);
@@ -251,7 +250,7 @@ const normalizePreloadBehavior = (preload, prefetch)=>{
     if (false === preload || 'none' === preload) return 'none';
     if (void 0 !== preload) return preload;
     if ('none' === prefetch) return 'none';
-    return DEFAULT_PRELOAD_BEHAVIOR;
+    return prefetch;
 };
 const createPrefetchLink = (Link)=>/*#__PURE__*/ react.forwardRef(({ to, prefetch = DEFAULT_PREFETCH_BEHAVIOR, preload, ...props }, forwardedRef)=>{
         const isAbsolute = 'string' == typeof to && ABSOLUTE_URL_REGEX.test(to);

package/dist/esm-node/router/runtime/internal.mjs

@@ -1,26 +1,27 @@
 import "node:module";
 import { merge } from "@modern-js/runtime-utils/merge";
-import { modifyRoutes, onAfterCreateRouter, onAfterHydrateRouter, onBeforeCreateRouter, onBeforeCreateRoutes, onBeforeHydrateRouter } from "./hooks.mjs";
-import { modifyRoutes as external_plugin_mjs_modifyRoutes, routerPlugin } from "./plugin.mjs";
-import { tanstackRouterPlugin } from "./tanstack/plugin.mjs";
+import { modifyRoutes, routerPlugin } from "./plugin.mjs";
+import { registerRouterProvider, reportUnsupportedProviderRegistryHooks, resolveRouterProvider, routerProviderRegistryHooks } from "./provider.mjs";
+registerRouterProvider('react-router', routerPlugin, {
+    isDefault: true
+});
 const internal_routerPlugin = (userConfig = {})=>({
         name: '@modern-js/plugin-router',
-        registryHooks: {
-            onAfterCreateRouter: onAfterCreateRouter,
-            onAfterHydrateRouter: onAfterHydrateRouter,
-            onBeforeCreateRouter: onBeforeCreateRouter,
-            modifyRoutes: modifyRoutes,
-            onBeforeCreateRoutes: onBeforeCreateRoutes,
-            onBeforeHydrateRouter: onBeforeHydrateRouter
-        },
+        registryHooks: routerProviderRegistryHooks,
         setup: (api)=>{
             const mergedConfig = merge(api.getRuntimeConfig().router || {}, userConfig);
-            const framework = mergedConfig.framework || 'react-router';
-            const pluginFactory = 'tanstack' === framework ? tanstackRouterPlugin : routerPlugin;
-            pluginFactory(userConfig).setup?.(api);
+            const pluginFactory = resolveRouterProvider(mergedConfig.framework, {
+                localDefault: {
+                    name: 'react-router',
+                    factory: routerPlugin
+                }
+            });
+            const providerPlugin = pluginFactory(userConfig);
+            reportUnsupportedProviderRegistryHooks(providerPlugin);
+            providerPlugin.setup?.(api);
         }
     });
 const internal = internal_routerPlugin;
 export { renderRoutes } from "./utils.mjs";
 export default internal;
-export { external_plugin_mjs_modifyRoutes as modifyRoutes, internal_routerPlugin as routerPlugin };
+export { internal_routerPlugin as routerPlugin, modifyRoutes, registerRouterProvider, resolveRouterProvider };

package/dist/esm-node/router/runtime/lifecycle.mjs

@@ -1,4 +1,13 @@
 import "node:module";
+import { createRuntimeContextExtension } from "../../core/context/extensions.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 ? [
@@ -62,12 +71,8 @@ function createRouterRuntimeState(state) {
 }
 function applyRouterRuntimeState(runtimeContext, state) {
     const normalized = createRouterRuntimeState(state);
-    runtimeContext.routerFramework = normalized.framework;
-    runtimeContext.routerInstance = normalized.instance;
-    runtimeContext.routerHydrationScript = normalized.hydrationScript;
-    runtimeContext.routerMatchedRouteIds = normalized.matchedRouteIds;
-    runtimeContext.routerRuntime = normalized;
-    if (normalized.serverSnapshot) runtimeContext.routerServerSnapshot = normalized.serverSnapshot;
+    routerRuntimeStateExtension.set(runtimeContext, normalized);
+    if (normalized.serverSnapshot) routerServerSnapshotExtension.set(runtimeContext, normalized.serverSnapshot);
     return runtimeContext;
 }
 function applyRouterServerPrepareResult(runtimeContext, result) {
@@ -80,18 +85,22 @@ function applyRouterServerPrepareResult(runtimeContext, result) {
     return runtimeContext;
 }
 function getRouterHydrationScripts(runtimeContext) {
-    return runtimeContext.routerServerSnapshot?.hydrationScripts ?? toHydrationScripts({
-        hydrationScript: runtimeContext.routerServerSnapshot?.hydrationScript
-    }) ?? runtimeContext.routerRuntime?.hydrationScripts ?? toHydrationScripts({
-        hydrationScript: runtimeContext.routerRuntime?.hydrationScript ?? runtimeContext.routerHydrationScript
+    const serverSnapshot = getRouterServerSnapshot(runtimeContext);
+    const runtimeState = getRouterRuntimeState(runtimeContext);
+    return serverSnapshot?.hydrationScripts ?? toHydrationScripts({
+        hydrationScript: serverSnapshot?.hydrationScript
+    }) ?? runtimeState?.hydrationScripts ?? toHydrationScripts({
+        hydrationScript: runtimeState?.hydrationScript
     }) ?? [];
 }
 function getRouterMatchedRouteIds(runtimeContext) {
-    return runtimeContext.routerServerSnapshot?.matchedRouteIds ?? getMatchedRouteIdsFromMatches(runtimeContext.routerServerSnapshot?.matches) ?? runtimeContext.routerRuntime?.matchedRouteIds ?? getMatchedRouteIdsFromMatches(runtimeContext.routerRuntime?.matches) ?? runtimeContext.routerMatchedRouteIds;
+    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 runtimeContext.routerRuntime?.cleanup?.();
+        await getRouterRuntimeState(runtimeContext)?.cleanup?.();
     } catch  {}
 }
-export { applyRouterRuntimeState, applyRouterServerPrepareResult, cleanupRouterRuntimeState, createRouterRuntimeState, createRouterServerSnapshot, getRouterHydrationScripts, getRouterMatchedRouteIds };
+export { applyRouterRuntimeState, applyRouterServerPrepareResult, cleanupRouterRuntimeState, createRouterRuntimeState, createRouterServerSnapshot, getRouterHydrationScripts, getRouterMatchedRouteIds, getRouterRuntimeState, getRouterServerSnapshot };

package/dist/esm-node/router/runtime/plugin.mjs

@@ -5,15 +5,15 @@ import { RouterProvider, createBrowserRouter, createHashRouter, createRoutesFrom
 import { normalizePathname } from "@modern-js/runtime-utils/url";
 import * as __rspack_external_react from "react";
 import { InternalRuntimeContext, getGlobalIsRscClient, getGlobalLayoutApp, getGlobalRoutes } from "../../core/context/index.mjs";
-import { modifyRoutes, onAfterCreateRouter, onAfterHydrateRouter, onBeforeCreateRouter, onBeforeCreateRoutes, onBeforeHydrateRouter } from "./hooks.mjs";
 import { applyRouterRuntimeState } from "./lifecycle.mjs";
+import { routerProviderRegistryHooks } from "./provider.mjs";
 import { createClientRouterFromPayload } from "./rsc-router.mjs";
 import { createRouteObjectsFromConfig, deserializeErrors, renderRoutes, urlJoin } from "./utils.mjs";
 let finalRouteConfig = {
     routes: []
 };
 let beforeCreateRouter = true;
-function plugin_modifyRoutes(modifyFunction) {
+function modifyRoutes(modifyFunction) {
     if (beforeCreateRouter) {
         const { routes: originRoutes } = finalRouteConfig;
         const newRoutes = modifyFunction(originRoutes);
@@ -22,14 +22,7 @@ function plugin_modifyRoutes(modifyFunction) {
 }
 const routerPlugin = (userConfig = {})=>({
         name: '@modern-js/plugin-router',
-        registryHooks: {
-            onAfterCreateRouter: onAfterCreateRouter,
-            onAfterHydrateRouter: onAfterHydrateRouter,
-            onBeforeCreateRouter: onBeforeCreateRouter,
-            modifyRoutes: modifyRoutes,
-            onBeforeCreateRoutes: onBeforeCreateRoutes,
-            onBeforeHydrateRouter: onBeforeHydrateRouter
-        },
+        registryHooks: routerProviderRegistryHooks,
         setup: (api)=>{
             const routesContainer = {
                 current: []
@@ -217,4 +210,4 @@ function useRouterCreation(props, options) {
         getBlockNavState
     ]);
 }
-export { beforeCreateRouter, finalRouteConfig, plugin_modifyRoutes as modifyRoutes, routerPlugin };
+export { beforeCreateRouter, finalRouteConfig, modifyRoutes, routerPlugin };

package/dist/esm-node/router/runtime/plugin.node.mjs

@@ -9,8 +9,8 @@ import { useContext } from "react";
 import { InternalRuntimeContext, getGlobalEnableRsc, getGlobalLayoutApp, getGlobalRoutes } from "../../core/context/index.mjs";
 import { setServerPayload } from "../../core/context/serverPayload/index.server.mjs";
 import DeferredDataScripts_node from "./DeferredDataScripts.node.mjs";
-import { modifyRoutes, onAfterCreateRouter, onBeforeCreateRouter, onBeforeCreateRoutes } from "./hooks.mjs";
 import { applyRouterRuntimeState, createRouterServerSnapshot } from "./lifecycle.mjs";
+import { routerProviderRegistryHooks } from "./provider.mjs";
 import { RSCStaticRouter, createServerPayload, handleRSCRedirect, prepareRSCRoutes } from "./rsc-router.mjs";
 import { createRouteObjectsFromConfig, renderRoutes, urlJoin } from "./utils.mjs";
 function createRemixRequest(request) {
@@ -43,12 +43,7 @@ function createReactRouterServerSnapshot(routerContext, basename) {
 }
 const routerPlugin = (userConfig = {})=>({
         name: '@modern-js/plugin-router',
-        registryHooks: {
-            onAfterCreateRouter: onAfterCreateRouter,
-            onBeforeCreateRouter: onBeforeCreateRouter,
-            modifyRoutes: modifyRoutes,
-            onBeforeCreateRoutes: onBeforeCreateRoutes
-        },
+        registryHooks: routerProviderRegistryHooks,
         setup: (api)=>{
             let finalRouteConfig = {};
             api.onBeforeRender(async (context, interrupt)=>{
@@ -176,5 +171,5 @@ const routerPlugin = (userConfig = {})=>({
             });
         }
     });
-const plugin_node_modifyRoutes = ()=>{};
-export { plugin_node_modifyRoutes as modifyRoutes, routerPlugin };
+const modifyRoutes = ()=>{};
+export { modifyRoutes, routerPlugin };

package/dist/esm-node/router/runtime/provider.mjs

@@ -0,0 +1,58 @@
+import "node:module";
+import { modifyRoutes, onAfterCreateRouter, onAfterHydrateRouter, onBeforeCreateRouter, onBeforeCreateRoutes, onBeforeHydrateRouter } from "./hooks.mjs";
+const routerProviderRegistryHooks = {
+    modifyRoutes: modifyRoutes,
+    onBeforeCreateRoutes: onBeforeCreateRoutes,
+    onBeforeCreateRouter: onBeforeCreateRouter,
+    onAfterCreateRouter: onAfterCreateRouter,
+    onBeforeHydrateRouter: onBeforeHydrateRouter,
+    onAfterHydrateRouter: onAfterHydrateRouter
+};
+function reportUnsupportedProviderRegistryHooks(providerPlugin) {
+    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;
+}
+const REGISTRY_SLOT = Symbol.for('@modern-js/runtime:router-providers:v2');
+function getRegistry() {
+    const host = globalThis;
+    host[REGISTRY_SLOT] ??= {
+        providers: new Map(),
+        warnedDuplicates: new Set()
+    };
+    host[REGISTRY_SLOT].warnedDuplicates ??= new Set();
+    return host[REGISTRY_SLOT];
+}
+function registerRouterProvider(name, factory, options = {}) {
+    const registry = getRegistry();
+    const existing = registry.providers.get(name);
+    if (void 0 !== existing) {
+        if (existing !== factory && !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; keeping the first registration. This usually means two copies of the providing plugin were bundled — for Module Federation, add the provider runtime (e.g. '@modern-js/plugin-tanstack/runtime') to the shared modules of both the host and the remote to deduplicate it.`);
+        }
+        return;
+    }
+    if (true !== options.isDefault) {
+        if (void 0 !== registry.nonDefaultProvider && registry.nonDefaultProvider !== name) throw new Error(`[@modern-js/runtime] Cannot register router provider "${name}": the competing router provider "${registry.nonDefaultProvider}" is already registered. Only one non-default router provider may be installed at a time — remove one of the router plugins.`);
+        registry.nonDefaultProvider = name;
+    } else registry.defaultProvider = name;
+    registry.providers.set(name, factory);
+}
+function resolveRouterProvider(framework, options = {}) {
+    const registry = getRegistry();
+    const name = framework || registry.defaultProvider || options.localDefault?.name;
+    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) return factory;
+    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: ${[
+        ...registry.providers.keys()
+    ].join(', ') || '(none)'}. Install and register the plugin that provides this router framework.`);
+}
+function unsafe_resetRouterProvidersForTesting() {
+    const host = globalThis;
+    delete host[REGISTRY_SLOT];
+}
+export { registerRouterProvider, reportUnsupportedProviderRegistryHooks, resolveRouterProvider, routerProviderRegistryHooks, unsafe_resetRouterProvidersForTesting };

package/dist/esm-node/router/runtime/utils.mjs

@@ -99,7 +99,10 @@ function getRouteObjects(routes, { globalApp, ssrMode, props }) {
     }
     routeObjects.push({
         path: '*',
-        element: /*#__PURE__*/ jsx(DefaultNotFound, {})
+        element: /*#__PURE__*/ jsx(DefaultNotFound, {}),
+        loader: ()=>new Response('404', {
+                status: 404
+            })
     });
     return routeObjects;
 }
@@ -148,17 +151,40 @@ function serializeErrors(errors) {
     if (!errors) return null;
     const entries = Object.entries(errors);
     const serialized = {};
-    for (const [key, val] of entries)if (isRouteErrorResponse(val)) serialized[key] = {
-        ...val,
-        __type: 'RouteErrorResponse'
+    for (const [key, val] of entries)if (isRouteErrorResponse(val)) serialized[key] = serializeRouteErrorResponse(val);
+    else if (val instanceof Error) serialized[key] = serializeError(val);
+    else serialized[key] = val;
+    return serialized;
+}
+function shouldRedactServerError() {
+    return 'development' !== process.env.NODE_ENV && 'test' !== process.env.NODE_ENV;
+}
+function serializeError(error) {
+    if (shouldRedactServerError()) return {
+        message: 'Unexpected Server Error',
+        stack: void 0,
+        __type: 'Error'
     };
-    else if (val instanceof Error) serialized[key] = {
-        message: val.message,
-        stack: val.stack,
+    return {
+        message: error.message,
+        stack: error.stack,
         __type: 'Error'
     };
-    else serialized[key] = val;
-    return serialized;
+}
+function serializeRouteErrorResponse(error) {
+    if (!isRouteErrorResponse(error)) return error;
+    if (error.status >= 500 && shouldRedactServerError()) return {
+        status: error.status,
+        statusText: 'Internal Server Error',
+        data: 'Unexpected Server Error',
+        __type: 'RouteErrorResponse'
+    };
+    return {
+        status: error.status,
+        statusText: error.statusText,
+        data: error.data,
+        __type: 'RouteErrorResponse'
+    };
 }
 function deserializeErrors(errors) {
     if (!errors) return null;

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

@@ -2,7 +2,9 @@ import type { AppTools, CliPlugin } from '@modern-js/app-tools';
 import { documentPlugin } from '../document/cli';
 import { routerPlugin } from '../router/cli';
 import { ssrPlugin } from './ssr';
-export { getEntrypointRoutesDir, handleFileChange, handleGeneratorEntryCode, handleModifyEntrypoints, isRouteEntry, } from '../router/cli';
+export { getEntrypointRoutesDir, getEntrypointRoutesOwner, handleFileChange, handleGeneratorEntryCode, handleModifyEntrypoints, isRouteEntry, } from '../router/cli';
+export { makeLegalIdentifier } from '../router/cli/code/makeLegalIdentifier';
+export { getPathWithoutExt } from '../router/cli/code/utils';
 export { isRuntimeEntry } from './entry';
 export { documentPlugin, routerPlugin, ssrPlugin };
 export declare const runtimePlugin: (params?: {