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

package/dist/cjs/router/cli/index.js

@@ -53,26 +53,6 @@ const utils_namespaceObject = require("@modern-js/utils");
 const external_constants_js_namespaceObject = require("./constants.js");
 const external_entry_js_namespaceObject = require("./entry.js");
 const external_handler_js_namespaceObject = require("./handler.js");
-const JS_OR_TS_EXTS = [
-    '.js',
-    '.jsx',
-    '.ts',
-    '.tsx',
-    '.mjs',
-    '.mts',
-    '.cjs',
-    '.cts'
-];
-function hasRouterConfigInRuntimeFile(runtimeConfigBase) {
-    const runtimeConfigFile = (0, utils_namespaceObject.findExists)(JS_OR_TS_EXTS.map((ext)=>`${runtimeConfigBase}${ext}`));
-    if (!runtimeConfigFile) return false;
-    try {
-        const content = utils_namespaceObject.fs.readFileSync(runtimeConfigFile, 'utf-8');
-        return /router\s*:/.test(content);
-    } catch  {
-        return false;
-    }
-}
 function isBuiltInRouteEntrypoint(entrypoint) {
     const entrypointRoutesOwner = (0, external_entry_js_namespaceObject.getEntrypointRoutesOwner)(entrypoint);
     if (entrypointRoutesOwner) return entrypointRoutesOwner === external_entry_js_namespaceObject.BUILT_IN_ROUTES_OWNER;
@@ -102,12 +82,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(external_node_path_default().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/cjs/router/runtime/DeferredDataScripts.node.js

@@ -36,6 +36,21 @@ const external_react_namespaceObject = require("react");
 const constants_js_namespaceObject = require("../../core/constants.js");
 const external_constants_js_namespaceObject = require("./constants.js");
 const external_utils_js_namespaceObject = require("./utils.js");
+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;
@@ -71,10 +86,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/cjs/router/runtime/PrefetchLink.js

@@ -54,7 +54,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;
@@ -119,7 +118,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] = external_react_default().useState(false);
@@ -293,7 +292,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__*/ external_react_default().forwardRef(({ to, prefetch = DEFAULT_PREFETCH_BEHAVIOR, preload, ...props }, forwardedRef)=>{
         const isAbsolute = 'string' == typeof to && ABSOLUTE_URL_REGEX.test(to);

package/dist/cjs/router/runtime/internal.js

@@ -30,40 +30,47 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     default: ()=>internal,
     modifyRoutes: ()=>external_plugin_js_namespaceObject.modifyRoutes,
+    registerRouterProvider: ()=>external_provider_js_namespaceObject.registerRouterProvider,
     renderRoutes: ()=>external_utils_js_namespaceObject.renderRoutes,
+    resolveRouterProvider: ()=>external_provider_js_namespaceObject.resolveRouterProvider,
     routerPlugin: ()=>routerPlugin
 });
 const merge_namespaceObject = require("@modern-js/runtime-utils/merge");
-const external_hooks_js_namespaceObject = require("./hooks.js");
 const external_plugin_js_namespaceObject = require("./plugin.js");
-const plugin_js_namespaceObject = require("./tanstack/plugin.js");
+const external_provider_js_namespaceObject = require("./provider.js");
 const external_utils_js_namespaceObject = require("./utils.js");
+(0, external_provider_js_namespaceObject.registerRouterProvider)('react-router', external_plugin_js_namespaceObject.routerPlugin, {
+    isDefault: true
+});
 const routerPlugin = (userConfig = {})=>({
         name: '@modern-js/plugin-router',
-        registryHooks: {
-            onAfterCreateRouter: external_hooks_js_namespaceObject.onAfterCreateRouter,
-            onAfterHydrateRouter: external_hooks_js_namespaceObject.onAfterHydrateRouter,
-            onBeforeCreateRouter: external_hooks_js_namespaceObject.onBeforeCreateRouter,
-            modifyRoutes: external_hooks_js_namespaceObject.modifyRoutes,
-            onBeforeCreateRoutes: external_hooks_js_namespaceObject.onBeforeCreateRoutes,
-            onBeforeHydrateRouter: external_hooks_js_namespaceObject.onBeforeHydrateRouter
-        },
+        registryHooks: external_provider_js_namespaceObject.routerProviderRegistryHooks,
         setup: (api)=>{
             const mergedConfig = (0, merge_namespaceObject.merge)(api.getRuntimeConfig().router || {}, userConfig);
-            const framework = mergedConfig.framework || 'react-router';
-            const pluginFactory = 'tanstack' === framework ? plugin_js_namespaceObject.tanstackRouterPlugin : external_plugin_js_namespaceObject.routerPlugin;
-            pluginFactory(userConfig).setup?.(api);
+            const pluginFactory = (0, external_provider_js_namespaceObject.resolveRouterProvider)(mergedConfig.framework, {
+                localDefault: {
+                    name: 'react-router',
+                    factory: external_plugin_js_namespaceObject.routerPlugin
+                }
+            });
+            const providerPlugin = pluginFactory(userConfig);
+            (0, external_provider_js_namespaceObject.reportUnsupportedProviderRegistryHooks)(providerPlugin);
+            providerPlugin.setup?.(api);
         }
     });
 const internal = routerPlugin;
 exports["default"] = __webpack_exports__["default"];
 exports.modifyRoutes = __webpack_exports__.modifyRoutes;
+exports.registerRouterProvider = __webpack_exports__.registerRouterProvider;
 exports.renderRoutes = __webpack_exports__.renderRoutes;
+exports.resolveRouterProvider = __webpack_exports__.resolveRouterProvider;
 exports.routerPlugin = __webpack_exports__.routerPlugin;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "default",
     "modifyRoutes",
+    "registerRouterProvider",
     "renderRoutes",
+    "resolveRouterProvider",
     "routerPlugin"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

package/dist/cjs/router/runtime/lifecycle.js

@@ -27,6 +27,26 @@ var __webpack_require__ = {};
 })();
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    applyRouterRuntimeState: ()=>applyRouterRuntimeState,
+    applyRouterServerPrepareResult: ()=>applyRouterServerPrepareResult,
+    cleanupRouterRuntimeState: ()=>cleanupRouterRuntimeState,
+    createRouterRuntimeState: ()=>createRouterRuntimeState,
+    createRouterServerSnapshot: ()=>createRouterServerSnapshot,
+    getRouterHydrationScripts: ()=>getRouterHydrationScripts,
+    getRouterMatchedRouteIds: ()=>getRouterMatchedRouteIds,
+    getRouterRuntimeState: ()=>getRouterRuntimeState,
+    getRouterServerSnapshot: ()=>getRouterServerSnapshot
+});
+const extensions_js_namespaceObject = require("../../core/context/extensions.js");
+const routerRuntimeStateExtension = (0, extensions_js_namespaceObject.createRuntimeContextExtension)('@modern-js/runtime:router-runtime-state');
+const routerServerSnapshotExtension = (0, extensions_js_namespaceObject.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 ? [
@@ -90,12 +110,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) {
@@ -108,29 +124,24 @@ 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  {}
 }
-__webpack_require__.d(__webpack_exports__, {
-    applyRouterRuntimeState: ()=>applyRouterRuntimeState,
-    applyRouterServerPrepareResult: ()=>applyRouterServerPrepareResult,
-    cleanupRouterRuntimeState: ()=>cleanupRouterRuntimeState,
-    createRouterRuntimeState: ()=>createRouterRuntimeState,
-    createRouterServerSnapshot: ()=>createRouterServerSnapshot,
-    getRouterHydrationScripts: ()=>getRouterHydrationScripts,
-    getRouterMatchedRouteIds: ()=>getRouterMatchedRouteIds
-});
 exports.applyRouterRuntimeState = __webpack_exports__.applyRouterRuntimeState;
 exports.applyRouterServerPrepareResult = __webpack_exports__.applyRouterServerPrepareResult;
 exports.cleanupRouterRuntimeState = __webpack_exports__.cleanupRouterRuntimeState;
@@ -138,6 +149,8 @@ exports.createRouterRuntimeState = __webpack_exports__.createRouterRuntimeState;
 exports.createRouterServerSnapshot = __webpack_exports__.createRouterServerSnapshot;
 exports.getRouterHydrationScripts = __webpack_exports__.getRouterHydrationScripts;
 exports.getRouterMatchedRouteIds = __webpack_exports__.getRouterMatchedRouteIds;
+exports.getRouterRuntimeState = __webpack_exports__.getRouterRuntimeState;
+exports.getRouterServerSnapshot = __webpack_exports__.getRouterServerSnapshot;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "applyRouterRuntimeState",
     "applyRouterServerPrepareResult",
@@ -145,7 +158,9 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "createRouterRuntimeState",
     "createRouterServerSnapshot",
     "getRouterHydrationScripts",
-    "getRouterMatchedRouteIds"
+    "getRouterMatchedRouteIds",
+    "getRouterRuntimeState",
+    "getRouterServerSnapshot"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/cjs/router/runtime/plugin.js

@@ -39,8 +39,8 @@ const router_namespaceObject = require("@modern-js/runtime-utils/router");
 const url_namespaceObject = require("@modern-js/runtime-utils/url");
 const external_react_namespaceObject = require("react");
 const index_js_namespaceObject = require("../../core/context/index.js");
-const external_hooks_js_namespaceObject = require("./hooks.js");
 const external_lifecycle_js_namespaceObject = require("./lifecycle.js");
+const external_provider_js_namespaceObject = require("./provider.js");
 const external_rsc_router_js_namespaceObject = require("./rsc-router.js");
 const external_utils_js_namespaceObject = require("./utils.js");
 let finalRouteConfig = {
@@ -56,14 +56,7 @@ function modifyRoutes(modifyFunction) {
 }
 const routerPlugin = (userConfig = {})=>({
         name: '@modern-js/plugin-router',
-        registryHooks: {
-            onAfterCreateRouter: external_hooks_js_namespaceObject.onAfterCreateRouter,
-            onAfterHydrateRouter: external_hooks_js_namespaceObject.onAfterHydrateRouter,
-            onBeforeCreateRouter: external_hooks_js_namespaceObject.onBeforeCreateRouter,
-            modifyRoutes: external_hooks_js_namespaceObject.modifyRoutes,
-            onBeforeCreateRoutes: external_hooks_js_namespaceObject.onBeforeCreateRoutes,
-            onBeforeHydrateRouter: external_hooks_js_namespaceObject.onBeforeHydrateRouter
-        },
+        registryHooks: external_provider_js_namespaceObject.routerProviderRegistryHooks,
         setup: (api)=>{
             const routesContainer = {
                 current: []

package/dist/cjs/router/runtime/plugin.node.js

@@ -51,8 +51,8 @@ const index_js_namespaceObject = require("../../core/context/index.js");
 const index_server_js_namespaceObject = require("../../core/context/serverPayload/index.server.js");
 const external_DeferredDataScripts_node_js_namespaceObject = require("./DeferredDataScripts.node.js");
 var external_DeferredDataScripts_node_js_default = /*#__PURE__*/ __webpack_require__.n(external_DeferredDataScripts_node_js_namespaceObject);
-const external_hooks_js_namespaceObject = require("./hooks.js");
 const external_lifecycle_js_namespaceObject = require("./lifecycle.js");
+const external_provider_js_namespaceObject = require("./provider.js");
 const external_rsc_router_js_namespaceObject = require("./rsc-router.js");
 const external_utils_js_namespaceObject = require("./utils.js");
 function createRemixRequest(request) {
@@ -85,12 +85,7 @@ function createReactRouterServerSnapshot(routerContext, basename) {
 }
 const routerPlugin = (userConfig = {})=>({
         name: '@modern-js/plugin-router',
-        registryHooks: {
-            onAfterCreateRouter: external_hooks_js_namespaceObject.onAfterCreateRouter,
-            onBeforeCreateRouter: external_hooks_js_namespaceObject.onBeforeCreateRouter,
-            modifyRoutes: external_hooks_js_namespaceObject.modifyRoutes,
-            onBeforeCreateRoutes: external_hooks_js_namespaceObject.onBeforeCreateRoutes
-        },
+        registryHooks: external_provider_js_namespaceObject.routerProviderRegistryHooks,
         setup: (api)=>{
             let finalRouteConfig = {};
             api.onBeforeRender(async (context, interrupt)=>{

package/dist/cjs/router/runtime/provider.js

@@ -0,0 +1,107 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    registerRouterProvider: ()=>registerRouterProvider,
+    reportUnsupportedProviderRegistryHooks: ()=>reportUnsupportedProviderRegistryHooks,
+    resolveRouterProvider: ()=>resolveRouterProvider,
+    routerProviderRegistryHooks: ()=>routerProviderRegistryHooks,
+    unsafe_resetRouterProvidersForTesting: ()=>unsafe_resetRouterProvidersForTesting
+});
+const external_hooks_js_namespaceObject = require("./hooks.js");
+const routerProviderRegistryHooks = {
+    modifyRoutes: external_hooks_js_namespaceObject.modifyRoutes,
+    onBeforeCreateRoutes: external_hooks_js_namespaceObject.onBeforeCreateRoutes,
+    onBeforeCreateRouter: external_hooks_js_namespaceObject.onBeforeCreateRouter,
+    onAfterCreateRouter: external_hooks_js_namespaceObject.onAfterCreateRouter,
+    onBeforeHydrateRouter: external_hooks_js_namespaceObject.onBeforeHydrateRouter,
+    onAfterHydrateRouter: external_hooks_js_namespaceObject.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];
+}
+exports.registerRouterProvider = __webpack_exports__.registerRouterProvider;
+exports.reportUnsupportedProviderRegistryHooks = __webpack_exports__.reportUnsupportedProviderRegistryHooks;
+exports.resolveRouterProvider = __webpack_exports__.resolveRouterProvider;
+exports.routerProviderRegistryHooks = __webpack_exports__.routerProviderRegistryHooks;
+exports.unsafe_resetRouterProvidersForTesting = __webpack_exports__.unsafe_resetRouterProvidersForTesting;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "registerRouterProvider",
+    "reportUnsupportedProviderRegistryHooks",
+    "resolveRouterProvider",
+    "routerProviderRegistryHooks",
+    "unsafe_resetRouterProvidersForTesting"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/router/runtime/utils.js

@@ -149,7 +149,10 @@ function getRouteObjects(routes, { globalApp, ssrMode, props }) {
     }
     routeObjects.push({
         path: '*',
-        element: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_DefaultNotFound_js_namespaceObject.DefaultNotFound, {})
+        element: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_DefaultNotFound_js_namespaceObject.DefaultNotFound, {}),
+        loader: ()=>new Response('404', {
+                status: 404
+            })
     });
     return routeObjects;
 }
@@ -198,17 +201,40 @@ function serializeErrors(errors) {
     if (!errors) return null;
     const entries = Object.entries(errors);
     const serialized = {};
-    for (const [key, val] of entries)if ((0, router_namespaceObject.isRouteErrorResponse)(val)) serialized[key] = {
-        ...val,
-        __type: 'RouteErrorResponse'
+    for (const [key, val] of entries)if ((0, router_namespaceObject.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 (!(0, router_namespaceObject.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/esm/boundary-debugger/index.mjs

@@ -196,9 +196,13 @@ function BoundaryDebugger({ controlMode = 'visible', enabledByDefault = false, l
             enabled ? /*#__PURE__*/ jsx("div", {
                 "aria-hidden": "true",
                 children: boxes.map((box)=>/*#__PURE__*/ jsx("div", {
+                        "data-modern-boundary-overlay": "",
+                        "data-modern-boundary-overlay-id": box.id,
+                        "data-modern-boundary-overlay-label": box.label,
                         style: {
                             border: `2px solid ${box.color}`,
                             borderRadius: 8,
+                            boxSizing: 'border-box',
                             boxShadow: `0 0 0 1px rgba(255,255,255,.72), 0 6px 20px color-mix(in srgb, ${box.color} 20%, transparent)`,
                             height: box.height,
                             left: box.left,

package/dist/esm/cli/index.mjs

@@ -1,7 +1,7 @@
 import { cleanRequireCache, isReact18 as utils_isReact18 } from "@modern-js/utils";
 import path_0 from "path";
 import { documentPlugin } from "../document/cli/index.mjs";
-import { getEntrypointRoutesDir, handleFileChange, handleGeneratorEntryCode, handleModifyEntrypoints, isRouteEntry, routerPlugin } from "../router/cli/index.mjs";
+import { getEntrypointRoutesDir, getEntrypointRoutesOwner, handleFileChange, handleGeneratorEntryCode, handleModifyEntrypoints, isRouteEntry, routerPlugin } from "../router/cli/index.mjs";
 import { builderPluginAlias } from "./alias.mjs";
 import { generateCode } from "./code.mjs";
 import { ENTRY_BOOTSTRAP_FILE_NAME, ENTRY_POINT_FILE_NAME } from "./constants.mjs";
@@ -89,5 +89,7 @@ const runtimePlugin = (params)=>({
         }
     });
 const cli = runtimePlugin;
+export { makeLegalIdentifier } from "../router/cli/code/makeLegalIdentifier.mjs";
+export { getPathWithoutExt } from "../router/cli/code/utils.mjs";
 export default cli;
-export { documentPlugin, getEntrypointRoutesDir, handleFileChange, handleGeneratorEntryCode, handleModifyEntrypoints, isRouteEntry, isRuntimeEntry, routerPlugin, runtimePlugin, ssrPlugin };
+export { documentPlugin, getEntrypointRoutesDir, getEntrypointRoutesOwner, handleFileChange, handleGeneratorEntryCode, handleModifyEntrypoints, isRouteEntry, isRuntimeEntry, routerPlugin, runtimePlugin, ssrPlugin };

package/dist/esm/core/context/extensions.mjs

@@ -0,0 +1,28 @@
+const EXTENSIONS_SLOT = Symbol.for('@modern-js/runtime:context-extensions');
+function getStore(context) {
+    return context[EXTENSIONS_SLOT];
+}
+function ensureStore(context) {
+    const target = context;
+    target[EXTENSIONS_SLOT] ??= new Map();
+    return target[EXTENSIONS_SLOT];
+}
+function stripRuntimeContextExtensions(context) {
+    delete context[EXTENSIONS_SLOT];
+}
+function createRuntimeContextExtension(id) {
+    const key = Symbol.for(`@modern-js/runtime:context-extension:${id}`);
+    return {
+        key,
+        get (context) {
+            return getStore(context)?.get(key);
+        },
+        set (context, value) {
+            ensureStore(context).set(key, value);
+        },
+        remove (context) {
+            getStore(context)?.delete(key);
+        }
+    };
+}
+export { createRuntimeContextExtension, stripRuntimeContextExtensions };

package/dist/esm/core/context/helmetContext.mjs

@@ -0,0 +1,13 @@
+import { createRuntimeContextExtension } from "./extensions.mjs";
+const helmetContextExtension = createRuntimeContextExtension('@modern-js/runtime:helmet-context');
+function getHelmetContext(context) {
+    return helmetContextExtension.get(context);
+}
+function ensureHelmetContext(context) {
+    const existing = helmetContextExtension.get(context);
+    if (void 0 !== existing) return existing;
+    const created = {};
+    helmetContextExtension.set(context, created);
+    return created;
+}
+export { ensureHelmetContext, getHelmetContext };

package/dist/esm/core/context/index.mjs

@@ -40,6 +40,11 @@ function getGlobalLayoutApp() {
 function getGlobalBasename() {
     return globalContext.basename;
 }
+export { DefaultNotFound } from "../../router/runtime/DefaultNotFound.mjs";
+export { modifyRoutes, onAfterCreateRouter, onAfterHydrateRouter, onBeforeCreateRouter, onBeforeCreateRoutes, onBeforeHydrateRouter } from "../../router/runtime/hooks.mjs";
+export { applyRouterRuntimeState, applyRouterServerPrepareResult, cleanupRouterRuntimeState, createRouterRuntimeState, createRouterServerSnapshot, getRouterHydrationScripts, getRouterMatchedRouteIds, getRouterRuntimeState, getRouterServerSnapshot } from "../../router/runtime/lifecycle.mjs";
+export { registerRouterProvider, resolveRouterProvider, routerProviderRegistryHooks } from "../../router/runtime/provider.mjs";
+export { createRuntimeContextExtension } from "./extensions.mjs";
 export { InternalRuntimeContext, RuntimeContext, getInitialContext } from "./runtime.mjs";
 export { getServerPayload, setServerPayload } from "./serverPayload/index.mjs";
 export { getCurrentEntryName, getGlobalApp, getGlobalBasename, getGlobalEnableRsc, getGlobalInternalRuntimeContext, getGlobalIsRscClient, getGlobalLayoutApp, getGlobalRSCRoot, getGlobalRoutes, setGlobalContext, setGlobalInternalRuntimeContext };

package/dist/esm/core/react/wrapper.mjs

@@ -1,24 +1,26 @@
 import { jsx } from "react/jsx-runtime";
 import { HelmetProvider } from "react-helmet-async";
 import { InternalRuntimeContext, RuntimeContext } from "../context/index.mjs";
+import { stripRuntimeContextExtensions } from "../context/extensions.mjs";
+import { ensureHelmetContext } from "../context/helmetContext.mjs";
 function wrapRuntimeContextProvider(App, contextValue) {
-    const { isBrowser, initialData, routes, routerFramework, context, routeManifest, routerRuntime, routerInstance, routerHydrationScript, routerMatchedRouteIds, routerServerSnapshot, routerContext, unstable_getBlockNavState, ssrContext, _internalContext, _internalRouterBaseName, _helmetContext, ...rest } = contextValue;
+    const { isBrowser, initialData, routes, context, routeManifest, routerContext, unstable_getBlockNavState, ssrContext, _internalContext, _internalRouterBaseName, ...rest } = contextValue;
     const internalContextValue = contextValue;
-    internalContextValue._helmetContext ??= {};
+    const helmetContext = ensureHelmetContext(internalContextValue);
     const runtimeContextValue = {
         isBrowser,
         initialData,
         routes,
-        routerFramework,
         context,
         ...rest
     };
+    stripRuntimeContextExtensions(runtimeContextValue);
     return /*#__PURE__*/ jsx(InternalRuntimeContext.Provider, {
         value: internalContextValue,
         children: /*#__PURE__*/ jsx(RuntimeContext.Provider, {
             value: runtimeContextValue,
             children: /*#__PURE__*/ jsx(HelmetProvider, {
-                context: internalContextValue._helmetContext,
+                context: helmetContext,
                 children: App
             })
         })

package/dist/esm/core/server/helmet.mjs

@@ -1,3 +1,4 @@
+import { getHelmetContext } from "../context/helmetContext.mjs";
 import { safeReplace } from "./utils.mjs";
 const EOL = '\n';
 const RE_HTML_ATTR = /<html[^>]*>/;
@@ -6,7 +7,7 @@ const RE_LAST_IN_HEAD = /<\/head>/;
 const RE_TITLE = /<title[^>]*>([\s\S\n\r]*?)<\/title>/;
 const TEST_TITLE_CONTENT = /(?<=<title[^>]*>)([\s\S\n\r]*?)([.|\S])([\s\S\n\r]*?)(?=<\/title>)/;
 function getHelmetData(runtimeContext) {
-    return runtimeContext._helmetContext?.helmet ?? void 0;
+    return getHelmetContext(runtimeContext)?.helmet ?? void 0;
 }
 function createReplaceHelemt(helmetData) {
     return helmetData ? (template)=>helmetReplace(template, helmetData) : (tempalte)=>tempalte;