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

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

@@ -11,45 +11,141 @@ function composeEventHandlers(theirHandler, ourHandler) {
     };
 }
 const ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
-function usePrefetchBehavior(prefetch, theirElementProps) {
-    const [maybePrefetch, setMaybePrefetch] = react.useState(false);
+const DEFAULT_PREFETCH_BEHAVIOR = 'render';
+const INTENT_DELAY = 100;
+const VIEWPORT_ROOT_MARGIN = '200px';
+const MAX_CONCURRENT_WARMUPS = 4;
+const WARMUP_TTL = 30000;
+const SLOW_EFFECTIVE_TYPES = new Set([
+    'slow-2g',
+    '2g'
+]);
+const warmupCache = new Map();
+const warmupQueue = [];
+let activeWarmups = 0;
+const getWarmupTimestamp = ()=>performance.now();
+const getConnection = ()=>{
+    const nav = globalThis.navigator;
+    return nav?.connection || nav?.mozConnection || nav?.webkitConnection;
+};
+const shouldWarmupOnCurrentNetwork = ()=>{
+    const connection = getConnection();
+    if (connection?.saveData) return false;
+    if ('string' == typeof connection?.effectiveType && SLOW_EFFECTIVE_TYPES.has(connection.effectiveType)) return false;
+    return true;
+};
+const pruneWarmupCache = (now = getWarmupTimestamp())=>{
+    for (const [key, timestamp] of warmupCache)if (now - timestamp > WARMUP_TTL) warmupCache.delete(key);
+};
+const runNextWarmup = ()=>{
+    while(activeWarmups < MAX_CONCURRENT_WARMUPS && warmupQueue.length > 0){
+        const task = warmupQueue.shift();
+        if (task.cancelled) continue;
+        activeWarmups += 1;
+        task.run().catch((error)=>{
+            console.error(error);
+            warmupCache.delete(task.key);
+        }).finally(()=>{
+            activeWarmups -= 1;
+            runNextWarmup();
+        });
+    }
+};
+const scheduleWarmup = (key, run)=>{
+    if (!shouldWarmupOnCurrentNetwork()) return ()=>{};
+    pruneWarmupCache();
+    if (warmupCache.has(key)) return ()=>{};
+    warmupCache.set(key, getWarmupTimestamp());
+    const task = {
+        key,
+        run,
+        cancelled: false
+    };
+    warmupQueue.push(task);
+    runNextWarmup();
+    return ()=>{
+        task.cancelled = true;
+    };
+};
+const setRef = (ref, value)=>{
+    if (!ref) return;
+    if ('function' == typeof ref) return void ref(value);
+    try {
+        ref.current = value;
+    } catch  {}
+};
+const isDataWarmupEnabled = (route)=>{
+    const handle = route.handle;
+    return handle?.navigationWarmup?.data !== false;
+};
+function usePrefetchBehavior(prefetch, preload, theirElementProps) {
+    const [maybeWarmup, setMaybeWarmup] = react.useState(false);
     const [shouldPrefetch, setShouldPrefetch] = react.useState(false);
+    const [shouldPreload, setShouldPreload] = react.useState(false);
+    const [viewportElement, setViewportElement] = react.useState(null);
     const { onFocus, onBlur, onMouseEnter, onMouseLeave, onTouchStart } = theirElementProps;
     react.useEffect(()=>{
         if ('render' === prefetch) setShouldPrefetch(true);
+        if ('render' === preload) setShouldPreload(true);
     }, [
-        prefetch
+        prefetch,
+        preload
     ]);
     const setIntent = ()=>{
-        if ('intent' === prefetch) setMaybePrefetch(true);
+        if ('intent' === prefetch || 'intent' === preload) setMaybeWarmup(true);
     };
     const cancelIntent = ()=>{
-        if ('intent' === prefetch) {
-            setMaybePrefetch(false);
+        if ('intent' === prefetch || 'intent' === preload) {
+            setMaybeWarmup(false);
             setShouldPrefetch(false);
+            setShouldPreload(false);
         }
     };
     react.useEffect(()=>{
-        if (maybePrefetch) {
+        if (maybeWarmup) {
             const id = setTimeout(()=>{
-                setShouldPrefetch(true);
-            }, 100);
+                if ('intent' === prefetch) setShouldPrefetch(true);
+                if ('intent' === preload) setShouldPreload(true);
+            }, INTENT_DELAY);
             return ()=>{
                 clearTimeout(id);
             };
         }
     }, [
-        maybePrefetch
+        maybeWarmup,
+        prefetch,
+        preload
+    ]);
+    react.useEffect(()=>{
+        if (!viewportElement || 'viewport' !== prefetch && 'viewport' !== preload || "u" < typeof IntersectionObserver) return;
+        const observer = new IntersectionObserver((entries)=>{
+            if (!entries.some((entry)=>entry.isIntersecting)) return;
+            if ('viewport' === prefetch) setShouldPrefetch(true);
+            if ('viewport' === preload) setShouldPreload(true);
+            observer.disconnect();
+        }, {
+            rootMargin: VIEWPORT_ROOT_MARGIN
+        });
+        observer.observe(viewportElement);
+        return ()=>{
+            observer.disconnect();
+        };
+    }, [
+        prefetch,
+        preload,
+        viewportElement
     ]);
     return [
         shouldPrefetch,
+        shouldPreload,
         {
             onFocus: composeEventHandlers(onFocus, setIntent),
             onBlur: composeEventHandlers(onBlur, cancelIntent),
             onMouseEnter: composeEventHandlers(onMouseEnter, setIntent),
             onMouseLeave: composeEventHandlers(onMouseLeave, cancelIntent),
             onTouchStart: composeEventHandlers(onTouchStart, setIntent)
-        }
+        },
+        setViewportElement
     ];
 }
 async function loadRouteModule(route, routeAssets) {
@@ -84,14 +180,34 @@ const getDataHref = (route, pathname, basename)=>{
     const url = getRequestUrl(path, id);
     return createDataHref(url.toString());
 };
-const PrefetchPageLinks = ({ path })=>{
+const PrefetchPageLinks = ({ path, includeData })=>{
     const { pathname } = path;
     const context = useContext(InternalRuntimeContext);
     const { routeManifest, routes } = context;
     const { routeAssets } = routeManifest || {};
-    const matches = Array.isArray(routes) ? matchRoutes(routes, pathname) : [];
-    if (Array.isArray(matches) && routeAssets) matches?.forEach((match)=>loadRouteModule(match.route, routeAssets));
-    if (!window._SSR_DATA) return null;
+    const allowNetworkWarmup = shouldWarmupOnCurrentNetwork();
+    const matches = useMemo(()=>Array.isArray(routes) ? matchRoutes(routes, pathname) : [], [
+        pathname,
+        routes
+    ]);
+    react.useEffect(()=>{
+        if (!allowNetworkWarmup || !Array.isArray(matches) || !routeAssets || !__webpack_chunk_load__) return;
+        const cancellations = matches.map((match)=>{
+            const routeId = match.route.id;
+            const routeAsset = routeId ? routeAssets[routeId] : void 0;
+            const chunkIds = routeAsset?.chunkIds;
+            if (!routeId || !Array.isArray(chunkIds) || 0 === chunkIds.length) return ()=>{};
+            return scheduleWarmup(`route-module:${routeId}:${chunkIds.join(',')}`, ()=>loadRouteModule(match.route, routeAssets));
+        });
+        return ()=>{
+            cancellations.forEach((cancel)=>cancel());
+        };
+    }, [
+        allowNetworkWarmup,
+        matches,
+        routeAssets
+    ]);
+    if (!allowNetworkWarmup || !includeData || !window._SSR_DATA) return null;
     return /*#__PURE__*/ jsx(PrefetchDataLinks, {
         matches: matches,
         path: path,
@@ -103,7 +219,7 @@ const PrefetchDataLinks = ({ matches, path, routeManifest })=>{
     const currentMatches = useMatches();
     const basename = useHref('/');
     const dataHrefs = useMemo(()=>matches?.filter((match, index)=>{
-            if (!match.route.loader || 'function' != typeof match.route.loader || 0 === match.route.loader.length) return false;
+            if (!isDataWarmupEnabled(match.route) || !match.route.loader || 'function' != typeof match.route.loader || 0 === match.route.loader.length) return false;
             if (match.route.shouldRevalidate) {
                 const currentUrl = new URL(location.pathname + location.search + location.hash, window.origin);
                 const nextUrl = new URL(pathname + search + hash, window.origin);
@@ -130,20 +246,35 @@ const PrefetchDataLinks = ({ matches, path, routeManifest })=>{
         children: dataHrefs
     });
 };
-const createPrefetchLink = (Link)=>/*#__PURE__*/ react.forwardRef(({ to, prefetch = 'none', ...props }, forwardedRef)=>{
+const normalizePreloadBehavior = (preload, prefetch)=>{
+    if (false === preload || 'none' === preload) return 'none';
+    if (void 0 !== preload) return preload;
+    if ('none' === prefetch) return 'none';
+    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);
-        const [shouldPrefetch, prefetchHandlers] = usePrefetchBehavior(prefetch, props);
+        const resolvedPreload = normalizePreloadBehavior(preload, prefetch);
+        const [shouldPrefetch, shouldPreload, prefetchHandlers, setViewportElement] = usePrefetchBehavior(prefetch, resolvedPreload, props);
+        const setAnchorRef = react.useCallback((element)=>{
+            setViewportElement(element);
+            setRef(forwardedRef, element);
+        }, [
+            forwardedRef,
+            setViewportElement
+        ]);
         const resolvedPath = useResolvedPath(to);
         return /*#__PURE__*/ jsxs(Fragment, {
             children: [
                 /*#__PURE__*/ jsx(Link, {
-                    ref: forwardedRef,
+                    ref: setAnchorRef,
                     to: to,
                     ...props,
                     ...prefetchHandlers
                 }),
-                shouldPrefetch && __webpack_chunk_load__ && !isAbsolute ? /*#__PURE__*/ jsx(PrefetchPageLinks, {
-                    path: resolvedPath
+                (shouldPrefetch || shouldPreload) && !isAbsolute ? /*#__PURE__*/ jsx(PrefetchPageLinks, {
+                    path: resolvedPath,
+                    includeData: shouldPrefetch
                 }) : null
             ]
         });

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/esm-node/rsc/server.worker.mjs

@@ -0,0 +1,2 @@
+import "node:module";
+export * from "@modern-js/render/rsc-worker";

package/dist/types/boundary-debugger/index.d.ts

@@ -0,0 +1,28 @@
+import type { RuntimePlugin } from '../core';
+export type BoundaryDebugEntry = {
+    appId: string;
+    color?: string;
+    label?: string;
+    mfName: string;
+    ownerTeam?: string;
+    packageName?: string;
+    role?: 'host' | 'vertical';
+};
+export type BoundaryDebugMetadata = {
+    appId: string;
+    boundaries: BoundaryDebugEntry[];
+    schemaVersion: 1;
+};
+export type BoundaryDebuggerControlMode = 'visible' | 'hidden-when-off' | 'hidden';
+export type BoundaryDebuggerPluginOptions = {
+    controlMode?: BoundaryDebuggerControlMode;
+    enabledByDefault?: boolean;
+    labels?: Record<string, {
+        toggle: string;
+    }>;
+    legacySelector?: string;
+    metadata: BoundaryDebugMetadata;
+    storageKey?: string;
+};
+export declare const ultramodernBoundaryDebuggerPlugin: (options: BoundaryDebuggerPluginOptions) => RuntimePlugin;
+export default ultramodernBoundaryDebuggerPlugin;

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

@@ -1,2 +1,2 @@
-export declare const hasApp: (dir: string) => any;
-export declare const isRuntimeEntry: (dir: string) => any;
+export declare const hasApp: (dir: string) => string | false;
+export declare const isRuntimeEntry: (dir: string) => string | false;

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?: {

package/dist/types/core/context/extensions.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Fork-owned runtime-context extension mechanism.
+ *
+ * Plugins must not add ad-hoc fields to `TRuntimeContext` /
+ * `TInternalRuntimeContext`. Instead they store state in a single internal
+ * slot (a `Map` keyed by symbol) attached to the context object under a
+ * symbol property, so nothing leaks into string-key enumeration
+ * (`Object.keys`, `JSON.stringify`, `{ ...context }` rest patterns over
+ * named keys).
+ *
+ * `Symbol.for` is used for both the slot and the extension keys so that the
+ * mechanism stays coherent even if this module is instantiated twice
+ * (e.g. esm/cjs interop in test runners).
+ */
+export interface RuntimeContextExtension<T> {
+    /** Stable identity of this extension. */
+    readonly key: symbol;
+    get(context: object): T | undefined;
+    set(context: object, value: T): void;
+    remove(context: object): void;
+}
+/**
+ * Removes the extension slot from a context object.
+ *
+ * The slot is an enumerable symbol-keyed property, so object spreads copy it
+ * onto derived objects. Call this on *copies* that form the public
+ * `RuntimeContext` value to keep internal state (router instances, helmet
+ * state, ...) unreachable from the public context object.
+ */
+export declare function stripRuntimeContextExtensions(context: object): void;
+/**
+ * Creates a typed accessor pair over the shared extension slot.
+ *
+ * The `id` must be globally unique (it is interned via `Symbol.for`); use a
+ * package-prefixed name such as `@modern-js/plugin-tanstack:router-state`.
+ */
+export declare function createRuntimeContextExtension<T>(id: string): RuntimeContextExtension<T>;

package/dist/types/core/context/helmetContext.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Fork-owned helmet state, stored via the runtime-context extension slot
+ * instead of an ad-hoc `_helmetContext` field on `TInternalRuntimeContext`.
+ */
+import type { HelmetServerState } from 'react-helmet-async';
+export interface HelmetContextSlot {
+    helmet?: HelmetServerState | null;
+}
+export declare function getHelmetContext(context: object): HelmetContextSlot | undefined;
+export declare function ensureHelmetContext(context: object): HelmetContextSlot;

package/dist/types/core/context/index.d.ts

@@ -3,6 +3,12 @@ import type { NestedRoute, PageRoute } from '@modern-js/types';
 import type React from 'react';
 import type { RuntimeExtends } from '../plugin/types';
 import type { ServerPayload } from './serverPayload/index';
+export { DefaultNotFound } from '../../router/runtime/DefaultNotFound';
+export { modifyRoutes, onAfterCreateRouter, onAfterHydrateRouter, onBeforeCreateRouter, onBeforeCreateRoutes, onBeforeHydrateRouter, type RouterExtendsHooks, } from '../../router/runtime/hooks';
+export { applyRouterRuntimeState, applyRouterServerPrepareResult, cleanupRouterRuntimeState, createRouterRuntimeState, createRouterServerSnapshot, getRouterHydrationScripts, getRouterMatchedRouteIds, getRouterRuntimeState, getRouterServerSnapshot, type RouterLifecycleContext, type RouterLifecyclePhase, } from '../../router/runtime/lifecycle';
+export { type RouterProviderFactory, type RouterProviderPlugin, registerRouterProvider, resolveRouterProvider, routerProviderRegistryHooks, } from '../../router/runtime/provider';
+export type { BuiltInRouterFramework, InternalRouterRuntimeState, InternalRouterServerSnapshot, RouterFramework, RouterRouteMatchSnapshot, RouterServerPrepareResult, } from '../../router/runtime/types';
+export { createRuntimeContextExtension, type RuntimeContextExtension, } from './extensions';
 export { getInitialContext, InternalRuntimeContext, RuntimeContext, type TInternalRuntimeContext, type TRuntimeContext, } from './runtime';
 export type { PayloadRoute, ServerPayload } from './serverPayload/index';
 interface GlobalContext {