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

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

@@ -1,25 +1,26 @@
 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/router/runtime/lifecycle.mjs

@@ -1,3 +1,12 @@
+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 ? [
@@ -61,12 +70,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) {
@@ -79,18 +84,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/router/runtime/plugin.mjs

@@ -4,15 +4,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);
@@ -21,14 +21,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: []
@@ -216,4 +209,4 @@ function useRouterCreation(props, options) {
         getBlockNavState
     ]);
 }
-export { beforeCreateRouter, finalRouteConfig, plugin_modifyRoutes as modifyRoutes, routerPlugin };
+export { beforeCreateRouter, finalRouteConfig, modifyRoutes, routerPlugin };

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

@@ -8,8 +8,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) {
@@ -42,12 +42,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)=>{
@@ -175,5 +170,5 @@ const routerPlugin = (userConfig = {})=>({
             });
         }
     });
-const plugin_node_modifyRoutes = ()=>{};
-export { plugin_node_modifyRoutes as modifyRoutes, routerPlugin };
+const modifyRoutes = ()=>{};
+export { modifyRoutes, routerPlugin };

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

@@ -0,0 +1,57 @@
+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/router/runtime/utils.mjs

@@ -98,7 +98,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;
 }
@@ -147,17 +150,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/boundary-debugger/index.mjs

@@ -197,9 +197,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-node/cli/index.mjs

@@ -3,7 +3,7 @@ const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/
 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";
@@ -91,5 +91,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-node/core/context/extensions.mjs

@@ -0,0 +1,29 @@
+import "node:module";
+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-node/core/context/helmetContext.mjs

@@ -0,0 +1,14 @@
+import "node:module";
+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-node/core/context/index.mjs

@@ -41,6 +41,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-node/core/react/wrapper.mjs

@@ -2,24 +2,26 @@ import "node:module";
 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-node/core/server/helmet.mjs

@@ -1,4 +1,5 @@
 import "node:module";
+import { getHelmetContext } from "../context/helmetContext.mjs";
 import { safeReplace } from "./utils.mjs";
 const EOL = '\n';
 const RE_HTML_ATTR = /<html[^>]*>/;
@@ -7,7 +8,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;

package/dist/esm-node/core/server/requestHandler.mjs

@@ -3,13 +3,14 @@ import { jsx } from "react/jsx-runtime";
 import { storage } from "@modern-js/runtime-utils/node";
 import { getPathname, parseCookie, parseHeaders, parseQuery } from "@modern-js/runtime-utils/universal/request";
 import react, { Fragment } from "react";
-import { cleanupRouterRuntimeState } from "../../router/runtime/lifecycle.mjs";
+import { getRouterServerSnapshot } from "../../router/runtime/lifecycle.mjs";
 import { handleRSCRedirect } from "../../router/runtime/rsc-router.mjs";
 import { getGlobalInternalRuntimeContext, getGlobalRSCRoot } from "../context/index.mjs";
 import { getInitialContext } from "../context/runtime.mjs";
 import { getServerPayload } from "../context/serverPayload/index.mjs";
 import { createRoot } from "../react/index.mjs";
 import { CHUNK_CSS_PLACEHOLDER } from "./constants.mjs";
+import { withRouterCleanup } from "./routerCleanup.mjs";
 import { SSRErrors } from "./tracer.mjs";
 import { getSSRConfigByEntry, getSSRMode } from "./utils.mjs";
 async function handleRSCRequest(request, Root, context, options, handleRequest) {
@@ -38,6 +39,39 @@ const processRedirect = (headers, status, ctx)=>{
         headers
     });
 };
+const applyRouterSnapshotResult = (context, onError)=>{
+    const routerServerSnapshot = getRouterServerSnapshot(context);
+    const routerStatusCode = routerServerSnapshot?.statusCode ?? context.routerContext?.statusCode;
+    if (routerStatusCode && 200 !== routerStatusCode) context.ssrContext?.response.status(routerStatusCode);
+    const errors = Object.values(routerServerSnapshot?.errors || context.routerContext?.errors || {});
+    if (errors.length > 0) onError(errors[0], SSRErrors.LOADER_ERROR);
+};
+const createLoaderRedirectResponse = (beforeRenderResult, redirectCtx)=>{
+    if (!beforeRenderResult || !isRedirectStatus(beforeRenderResult.status)) return;
+    if (beforeRenderResult.headers.has('X-Modernjs-Redirect')) return beforeRenderResult;
+    const redirectUrl = beforeRenderResult.headers.get('Location') || '/';
+    return processRedirect(new Headers({
+        Location: redirectUrl
+    }), beforeRenderResult.status, redirectCtx);
+};
+const renderRequest = async (request, Root, context, options, handleRequest, enableRsc)=>{
+    if (enableRsc) return handleRSCRequest(request, Root, context, options, handleRequest);
+    return handleRequest(request, Root, {
+        ...options,
+        runtimeContext: context
+    });
+};
+const finalizeRenderResponse = (response, responseProxy, redirectCtx, routerCleanup)=>{
+    if (-1 !== responseProxy.status && isRedirectStatus(responseProxy.status) && responseProxy.headers.Location) return processRedirect(new Headers(responseProxy.headers), responseProxy.status, redirectCtx);
+    Object.entries(responseProxy.headers).forEach(([key, value])=>{
+        response.headers.set(key, value);
+    });
+    if (-1 !== responseProxy.status) return routerCleanup.deferUntilBodyDone(new Response(response.body, {
+        status: responseProxy.status,
+        headers: response.headers
+    }));
+    return routerCleanup.deferUntilBodyDone(response);
+};
 function createSSRContext(request, options) {
     const { config, loaderContext, onError, onTiming, locals, resource, params, responseProxy, reporter } = options;
     const { nonce, useJsonScript } = config;
@@ -133,41 +167,20 @@ const createRequestHandler = async (handleRequest, createRequestOptions)=>{
                 isRSCNavigation: 'true' === request.headers.get('x-rsc-tree'),
                 basename: ssrContext.baseUrl || '/'
             };
-            try {
+            return withRouterCleanup(context, options.onError, async (routerCleanup)=>{
                 const beforeRenderResult = await runBeforeRender(context);
-                const routerServerSnapshot = context.routerServerSnapshot;
-                const routerStatusCode = routerServerSnapshot?.statusCode ?? context.routerContext?.statusCode;
-                if (routerStatusCode && 200 !== routerStatusCode) context.ssrContext?.response.status(routerStatusCode);
-                const errors = Object.values(routerServerSnapshot?.errors || context.routerContext?.errors || {});
-                if (errors.length > 0) options.onError(errors[0], SSRErrors.LOADER_ERROR);
-                if ("u" > typeof Response && beforeRenderResult instanceof Response && isRedirectStatus(beforeRenderResult.status)) {
-                    if (beforeRenderResult.headers.has('X-Modernjs-Redirect')) return beforeRenderResult;
-                    const redirectUrl = beforeRenderResult.headers.get('Location') || '/';
-                    return processRedirect(new Headers({
-                        Location: redirectUrl
-                    }), beforeRenderResult.status, redirectCtx);
+                applyRouterSnapshotResult(context, options.onError);
+                if ("u" > typeof Response) {
+                    const redirectResponse = createLoaderRedirectResponse(beforeRenderResult, redirectCtx);
+                    if (redirectResponse) return redirectResponse;
                 }
                 if (!createRequestOptions?.enableRsc) {
                     const { htmlTemplate } = options.resource;
                     options.resource.htmlTemplate = htmlTemplate.replace('</head>', `${CHUNK_CSS_PLACEHOLDER}</head>`);
                 }
-                let response;
-                response = createRequestOptions?.enableRsc ? await handleRSCRequest(request, Root, context, options, handleRequest) : await handleRequest(request, Root, {
-                    ...options,
-                    runtimeContext: context
-                });
-                if (-1 !== responseProxy.status && isRedirectStatus(responseProxy.status) && responseProxy.headers.Location) return processRedirect(new Headers(responseProxy.headers), responseProxy.status, redirectCtx);
-                Object.entries(responseProxy.headers).forEach(([key, value])=>{
-                    response.headers.set(key, value);
-                });
-                if (-1 !== responseProxy.status) return new Response(response.body, {
-                    status: responseProxy.status,
-                    headers: response.headers
-                });
-                return response;
-            } finally{
-                await cleanupRouterRuntimeState(context);
-            }
+                const response = await renderRequest(request, Root, context, options, handleRequest, !!createRequestOptions?.enableRsc);
+                return finalizeRenderResponse(response, responseProxy, redirectCtx, routerCleanup);
+            });
         });
     };
     return requestHandler;

package/dist/esm-node/core/server/routerCleanup.mjs

@@ -0,0 +1,67 @@
+import "node:module";
+import { getRouterRuntimeState } from "../../router/runtime/lifecycle.mjs";
+const ROUTER_CLEANUP_ERROR = 'An error occurs during router runtime cleanup';
+async function withRouterCleanup(runtimeContext, onError, callback) {
+    const routerCleanup = createRouterCleanup(runtimeContext, onError);
+    try {
+        return await callback(routerCleanup);
+    } finally{
+        if (!routerCleanup.deferred) await routerCleanup.run();
+    }
+}
+function createRouterCleanup(runtimeContext, onError) {
+    let deferred = false;
+    let finished = false;
+    const run = async ()=>{
+        if (finished) return;
+        finished = true;
+        try {
+            await getRouterRuntimeState(runtimeContext)?.cleanup?.();
+        } catch (error) {
+            onError(error, ROUTER_CLEANUP_ERROR);
+        }
+    };
+    const deferUntilBodyDone = (response)=>{
+        const { body } = response;
+        if (!body || body.locked) return response;
+        deferred = true;
+        const reader = body.getReader();
+        const wrappedBody = new ReadableStream({
+            async pull (controller) {
+                let result;
+                try {
+                    result = await reader.read();
+                } catch (error) {
+                    controller.error(error);
+                    await run();
+                    return;
+                }
+                if (result.done) {
+                    controller.close();
+                    await run();
+                    return;
+                }
+                controller.enqueue(result.value);
+            },
+            async cancel (reason) {
+                try {
+                    await reader.cancel(reason);
+                } catch  {}
+                await run();
+            }
+        });
+        return new Response(wrappedBody, {
+            status: response.status,
+            statusText: response.statusText,
+            headers: response.headers
+        });
+    };
+    return {
+        get deferred () {
+            return deferred;
+        },
+        run,
+        deferUntilBodyDone
+    };
+}
+export { ROUTER_CLEANUP_ERROR, createRouterCleanup, withRouterCleanup };