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

package/dist/cjs/boundary-debugger/index.js

@@ -229,9 +229,13 @@ function BoundaryDebugger({ controlMode = 'visible', enabledByDefault = false, l
             enabled ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("div", {
                 "aria-hidden": "true",
                 children: boxes.map((box)=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.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/cjs/cli/index.js

@@ -40,11 +40,14 @@ __webpack_require__.d(__webpack_exports__, {
     default: ()=>cli,
     documentPlugin: ()=>index_js_namespaceObject.documentPlugin,
     getEntrypointRoutesDir: ()=>external_router_cli_index_js_namespaceObject.getEntrypointRoutesDir,
+    getEntrypointRoutesOwner: ()=>external_router_cli_index_js_namespaceObject.getEntrypointRoutesOwner,
+    getPathWithoutExt: ()=>utils_js_namespaceObject.getPathWithoutExt,
     handleFileChange: ()=>external_router_cli_index_js_namespaceObject.handleFileChange,
     handleGeneratorEntryCode: ()=>external_router_cli_index_js_namespaceObject.handleGeneratorEntryCode,
     handleModifyEntrypoints: ()=>external_router_cli_index_js_namespaceObject.handleModifyEntrypoints,
     isRouteEntry: ()=>external_router_cli_index_js_namespaceObject.isRouteEntry,
     isRuntimeEntry: ()=>external_entry_js_namespaceObject.isRuntimeEntry,
+    makeLegalIdentifier: ()=>makeLegalIdentifier_js_namespaceObject.makeLegalIdentifier,
     routerPlugin: ()=>external_router_cli_index_js_namespaceObject.routerPlugin,
     runtimePlugin: ()=>runtimePlugin,
     ssrPlugin: ()=>external_ssr_index_js_namespaceObject.ssrPlugin
@@ -59,6 +62,8 @@ const external_code_js_namespaceObject = require("./code.js");
 const external_constants_js_namespaceObject = require("./constants.js");
 const external_entry_js_namespaceObject = require("./entry.js");
 const external_ssr_index_js_namespaceObject = require("./ssr/index.js");
+const makeLegalIdentifier_js_namespaceObject = require("../router/cli/code/makeLegalIdentifier.js");
+const utils_js_namespaceObject = require("../router/cli/code/utils.js");
 const runtimePlugin = (params)=>({
         name: '@modern-js/runtime',
         post: [
@@ -144,11 +149,14 @@ const cli = runtimePlugin;
 exports["default"] = __webpack_exports__["default"];
 exports.documentPlugin = __webpack_exports__.documentPlugin;
 exports.getEntrypointRoutesDir = __webpack_exports__.getEntrypointRoutesDir;
+exports.getEntrypointRoutesOwner = __webpack_exports__.getEntrypointRoutesOwner;
+exports.getPathWithoutExt = __webpack_exports__.getPathWithoutExt;
 exports.handleFileChange = __webpack_exports__.handleFileChange;
 exports.handleGeneratorEntryCode = __webpack_exports__.handleGeneratorEntryCode;
 exports.handleModifyEntrypoints = __webpack_exports__.handleModifyEntrypoints;
 exports.isRouteEntry = __webpack_exports__.isRouteEntry;
 exports.isRuntimeEntry = __webpack_exports__.isRuntimeEntry;
+exports.makeLegalIdentifier = __webpack_exports__.makeLegalIdentifier;
 exports.routerPlugin = __webpack_exports__.routerPlugin;
 exports.runtimePlugin = __webpack_exports__.runtimePlugin;
 exports.ssrPlugin = __webpack_exports__.ssrPlugin;
@@ -156,11 +164,14 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "default",
     "documentPlugin",
     "getEntrypointRoutesDir",
+    "getEntrypointRoutesOwner",
+    "getPathWithoutExt",
     "handleFileChange",
     "handleGeneratorEntryCode",
     "handleModifyEntrypoints",
     "isRouteEntry",
     "isRuntimeEntry",
+    "makeLegalIdentifier",
     "routerPlugin",
     "runtimePlugin",
     "ssrPlugin"

package/dist/cjs/{router/runtime/tanstack/rsc/ClientSlot.js → core/context/extensions.js}

@@ -1,5 +1,4 @@
 "use strict";
-"use client";
 var __webpack_require__ = {};
 (()=>{
     __webpack_require__.d = (exports1, getters, values)=>{
@@ -28,29 +27,42 @@ var __webpack_require__ = {};
 })();
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
+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);
+        }
+    };
+}
 __webpack_require__.d(__webpack_exports__, {
-    ClientSlot: ()=>ClientSlot
+    createRuntimeContextExtension: ()=>createRuntimeContextExtension,
+    stripRuntimeContextExtensions: ()=>stripRuntimeContextExtensions
 });
-const jsx_runtime_namespaceObject = require("react/jsx-runtime");
-const external_SlotContext_js_namespaceObject = require("./SlotContext.js");
-function ClientSlot({ args, slot }) {
-    const context = (0, external_SlotContext_js_namespaceObject.useSlotContext)();
-    if (!context) throw new Error('ClientSlot must be rendered inside CompositeComponent.');
-    const implementation = context.implementations[slot];
-    if (void 0 === implementation) {
-        if (context.strict) throw new Error(`Missing RSC slot implementation for "${slot}".`);
-        return null;
-    }
-    if ('function' == typeof implementation) return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(jsx_runtime_namespaceObject.Fragment, {
-        children: implementation(...args)
-    });
-    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(jsx_runtime_namespaceObject.Fragment, {
-        children: implementation
-    });
-}
-exports.ClientSlot = __webpack_exports__.ClientSlot;
+exports.createRuntimeContextExtension = __webpack_exports__.createRuntimeContextExtension;
+exports.stripRuntimeContextExtensions = __webpack_exports__.stripRuntimeContextExtensions;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "ClientSlot"
+    "createRuntimeContextExtension",
+    "stripRuntimeContextExtensions"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/cjs/{router/runtime/tanstack/rsc/SlotContext.js → core/context/helmetContext.js}

@@ -1,5 +1,4 @@
 "use strict";
-"use client";
 var __webpack_require__ = {};
 (()=>{
     __webpack_require__.d = (exports1, getters, values)=>{
@@ -29,29 +28,26 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    SlotProvider: ()=>SlotProvider,
-    useSlotContext: ()=>useSlotContext
+    ensureHelmetContext: ()=>ensureHelmetContext,
+    getHelmetContext: ()=>getHelmetContext
 });
-const jsx_runtime_namespaceObject = require("react/jsx-runtime");
-const external_react_namespaceObject = require("react");
-const SlotContext = /*#__PURE__*/ (0, external_react_namespaceObject.createContext)(null);
-function useSlotContext() {
-    return (0, external_react_namespaceObject.use)(SlotContext);
+const external_extensions_js_namespaceObject = require("./extensions.js");
+const helmetContextExtension = (0, external_extensions_js_namespaceObject.createRuntimeContextExtension)('@modern-js/runtime:helmet-context');
+function getHelmetContext(context) {
+    return helmetContextExtension.get(context);
 }
-function SlotProvider({ children, implementations, strict }) {
-    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(SlotContext, {
-        value: {
-            implementations,
-            strict: true === strict
-        },
-        children: children
-    });
+function ensureHelmetContext(context) {
+    const existing = helmetContextExtension.get(context);
+    if (void 0 !== existing) return existing;
+    const created = {};
+    helmetContextExtension.set(context, created);
+    return created;
 }
-exports.SlotProvider = __webpack_exports__.SlotProvider;
-exports.useSlotContext = __webpack_exports__.useSlotContext;
+exports.ensureHelmetContext = __webpack_exports__.ensureHelmetContext;
+exports.getHelmetContext = __webpack_exports__.getHelmetContext;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "SlotProvider",
-    "useSlotContext"
+    "ensureHelmetContext",
+    "getHelmetContext"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/cjs/core/context/index.js

@@ -28,8 +28,15 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
+    DefaultNotFound: ()=>DefaultNotFound_js_namespaceObject.DefaultNotFound,
     InternalRuntimeContext: ()=>external_runtime_js_namespaceObject.InternalRuntimeContext,
     RuntimeContext: ()=>external_runtime_js_namespaceObject.RuntimeContext,
+    applyRouterRuntimeState: ()=>lifecycle_js_namespaceObject.applyRouterRuntimeState,
+    applyRouterServerPrepareResult: ()=>lifecycle_js_namespaceObject.applyRouterServerPrepareResult,
+    cleanupRouterRuntimeState: ()=>lifecycle_js_namespaceObject.cleanupRouterRuntimeState,
+    createRouterRuntimeState: ()=>lifecycle_js_namespaceObject.createRouterRuntimeState,
+    createRouterServerSnapshot: ()=>lifecycle_js_namespaceObject.createRouterServerSnapshot,
+    createRuntimeContextExtension: ()=>external_extensions_js_namespaceObject.createRuntimeContextExtension,
     getCurrentEntryName: ()=>getCurrentEntryName,
     getGlobalApp: ()=>getGlobalApp,
     getGlobalBasename: ()=>getGlobalBasename,
@@ -40,11 +47,29 @@ __webpack_require__.d(__webpack_exports__, {
     getGlobalRSCRoot: ()=>getGlobalRSCRoot,
     getGlobalRoutes: ()=>getGlobalRoutes,
     getInitialContext: ()=>external_runtime_js_namespaceObject.getInitialContext,
+    getRouterHydrationScripts: ()=>lifecycle_js_namespaceObject.getRouterHydrationScripts,
+    getRouterMatchedRouteIds: ()=>lifecycle_js_namespaceObject.getRouterMatchedRouteIds,
+    getRouterRuntimeState: ()=>lifecycle_js_namespaceObject.getRouterRuntimeState,
+    getRouterServerSnapshot: ()=>lifecycle_js_namespaceObject.getRouterServerSnapshot,
     getServerPayload: ()=>index_js_namespaceObject.getServerPayload,
+    modifyRoutes: ()=>hooks_js_namespaceObject.modifyRoutes,
+    onAfterCreateRouter: ()=>hooks_js_namespaceObject.onAfterCreateRouter,
+    onAfterHydrateRouter: ()=>hooks_js_namespaceObject.onAfterHydrateRouter,
+    onBeforeCreateRouter: ()=>hooks_js_namespaceObject.onBeforeCreateRouter,
+    onBeforeCreateRoutes: ()=>hooks_js_namespaceObject.onBeforeCreateRoutes,
+    onBeforeHydrateRouter: ()=>hooks_js_namespaceObject.onBeforeHydrateRouter,
+    registerRouterProvider: ()=>provider_js_namespaceObject.registerRouterProvider,
+    resolveRouterProvider: ()=>provider_js_namespaceObject.resolveRouterProvider,
+    routerProviderRegistryHooks: ()=>provider_js_namespaceObject.routerProviderRegistryHooks,
     setGlobalContext: ()=>setGlobalContext,
     setGlobalInternalRuntimeContext: ()=>setGlobalInternalRuntimeContext,
     setServerPayload: ()=>index_js_namespaceObject.setServerPayload
 });
+const DefaultNotFound_js_namespaceObject = require("../../router/runtime/DefaultNotFound.js");
+const hooks_js_namespaceObject = require("../../router/runtime/hooks.js");
+const lifecycle_js_namespaceObject = require("../../router/runtime/lifecycle.js");
+const provider_js_namespaceObject = require("../../router/runtime/provider.js");
+const external_extensions_js_namespaceObject = require("./extensions.js");
 const external_runtime_js_namespaceObject = require("./runtime.js");
 const index_js_namespaceObject = require("./serverPayload/index.js");
 const globalContext = {};
@@ -89,8 +114,15 @@ function getGlobalLayoutApp() {
 function getGlobalBasename() {
     return globalContext.basename;
 }
+exports.DefaultNotFound = __webpack_exports__.DefaultNotFound;
 exports.InternalRuntimeContext = __webpack_exports__.InternalRuntimeContext;
 exports.RuntimeContext = __webpack_exports__.RuntimeContext;
+exports.applyRouterRuntimeState = __webpack_exports__.applyRouterRuntimeState;
+exports.applyRouterServerPrepareResult = __webpack_exports__.applyRouterServerPrepareResult;
+exports.cleanupRouterRuntimeState = __webpack_exports__.cleanupRouterRuntimeState;
+exports.createRouterRuntimeState = __webpack_exports__.createRouterRuntimeState;
+exports.createRouterServerSnapshot = __webpack_exports__.createRouterServerSnapshot;
+exports.createRuntimeContextExtension = __webpack_exports__.createRuntimeContextExtension;
 exports.getCurrentEntryName = __webpack_exports__.getCurrentEntryName;
 exports.getGlobalApp = __webpack_exports__.getGlobalApp;
 exports.getGlobalBasename = __webpack_exports__.getGlobalBasename;
@@ -101,13 +133,33 @@ exports.getGlobalLayoutApp = __webpack_exports__.getGlobalLayoutApp;
 exports.getGlobalRSCRoot = __webpack_exports__.getGlobalRSCRoot;
 exports.getGlobalRoutes = __webpack_exports__.getGlobalRoutes;
 exports.getInitialContext = __webpack_exports__.getInitialContext;
+exports.getRouterHydrationScripts = __webpack_exports__.getRouterHydrationScripts;
+exports.getRouterMatchedRouteIds = __webpack_exports__.getRouterMatchedRouteIds;
+exports.getRouterRuntimeState = __webpack_exports__.getRouterRuntimeState;
+exports.getRouterServerSnapshot = __webpack_exports__.getRouterServerSnapshot;
 exports.getServerPayload = __webpack_exports__.getServerPayload;
+exports.modifyRoutes = __webpack_exports__.modifyRoutes;
+exports.onAfterCreateRouter = __webpack_exports__.onAfterCreateRouter;
+exports.onAfterHydrateRouter = __webpack_exports__.onAfterHydrateRouter;
+exports.onBeforeCreateRouter = __webpack_exports__.onBeforeCreateRouter;
+exports.onBeforeCreateRoutes = __webpack_exports__.onBeforeCreateRoutes;
+exports.onBeforeHydrateRouter = __webpack_exports__.onBeforeHydrateRouter;
+exports.registerRouterProvider = __webpack_exports__.registerRouterProvider;
+exports.resolveRouterProvider = __webpack_exports__.resolveRouterProvider;
+exports.routerProviderRegistryHooks = __webpack_exports__.routerProviderRegistryHooks;
 exports.setGlobalContext = __webpack_exports__.setGlobalContext;
 exports.setGlobalInternalRuntimeContext = __webpack_exports__.setGlobalInternalRuntimeContext;
 exports.setServerPayload = __webpack_exports__.setServerPayload;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DefaultNotFound",
     "InternalRuntimeContext",
     "RuntimeContext",
+    "applyRouterRuntimeState",
+    "applyRouterServerPrepareResult",
+    "cleanupRouterRuntimeState",
+    "createRouterRuntimeState",
+    "createRouterServerSnapshot",
+    "createRuntimeContextExtension",
     "getCurrentEntryName",
     "getGlobalApp",
     "getGlobalBasename",
@@ -118,7 +170,20 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "getGlobalRSCRoot",
     "getGlobalRoutes",
     "getInitialContext",
+    "getRouterHydrationScripts",
+    "getRouterMatchedRouteIds",
+    "getRouterRuntimeState",
+    "getRouterServerSnapshot",
     "getServerPayload",
+    "modifyRoutes",
+    "onAfterCreateRouter",
+    "onAfterHydrateRouter",
+    "onBeforeCreateRouter",
+    "onBeforeCreateRoutes",
+    "onBeforeHydrateRouter",
+    "registerRouterProvider",
+    "resolveRouterProvider",
+    "routerProviderRegistryHooks",
     "setGlobalContext",
     "setGlobalInternalRuntimeContext",
     "setServerPayload"

package/dist/cjs/core/react/wrapper.js

@@ -33,24 +33,26 @@ __webpack_require__.d(__webpack_exports__, {
 const jsx_runtime_namespaceObject = require("react/jsx-runtime");
 const external_react_helmet_async_namespaceObject = require("react-helmet-async");
 const index_js_namespaceObject = require("../context/index.js");
+const extensions_js_namespaceObject = require("../context/extensions.js");
+const helmetContext_js_namespaceObject = require("../context/helmetContext.js");
 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 = (0, helmetContext_js_namespaceObject.ensureHelmetContext)(internalContextValue);
     const runtimeContextValue = {
         isBrowser,
         initialData,
         routes,
-        routerFramework,
         context,
         ...rest
     };
+    (0, extensions_js_namespaceObject.stripRuntimeContextExtensions)(runtimeContextValue);
     return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(index_js_namespaceObject.InternalRuntimeContext.Provider, {
         value: internalContextValue,
         children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(index_js_namespaceObject.RuntimeContext.Provider, {
             value: runtimeContextValue,
             children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_react_helmet_async_namespaceObject.HelmetProvider, {
-                context: internalContextValue._helmetContext,
+                context: helmetContext,
                 children: App
             })
         })

package/dist/cjs/core/server/helmet.js

@@ -32,6 +32,7 @@ __webpack_require__.d(__webpack_exports__, {
     getHelmetData: ()=>getHelmetData,
     helmetReplace: ()=>helmetReplace
 });
+const helmetContext_js_namespaceObject = require("../context/helmetContext.js");
 const external_utils_js_namespaceObject = require("./utils.js");
 const EOL = '\n';
 const RE_HTML_ATTR = /<html[^>]*>/;
@@ -40,7 +41,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 (0, helmetContext_js_namespaceObject.getHelmetContext)(runtimeContext)?.helmet ?? void 0;
 }
 function createReplaceHelemt(helmetData) {
     return helmetData ? (template)=>helmetReplace(template, helmetData) : (tempalte)=>tempalte;

package/dist/cjs/core/server/requestHandler.js

@@ -51,6 +51,7 @@ const runtime_js_namespaceObject = require("../context/runtime.js");
 const serverPayload_index_js_namespaceObject = require("../context/serverPayload/index.js");
 const external_react_index_js_namespaceObject = require("../react/index.js");
 const external_constants_js_namespaceObject = require("./constants.js");
+const external_routerCleanup_js_namespaceObject = require("./routerCleanup.js");
 const external_tracer_js_namespaceObject = require("./tracer.js");
 const external_utils_js_namespaceObject = require("./utils.js");
 async function handleRSCRequest(request, Root, context, options, handleRequest) {
@@ -79,6 +80,39 @@ const processRedirect = (headers, status, ctx)=>{
         headers
     });
 };
+const applyRouterSnapshotResult = (context, onError)=>{
+    const routerServerSnapshot = (0, lifecycle_js_namespaceObject.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], external_tracer_js_namespaceObject.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;
@@ -174,41 +208,20 @@ const createRequestHandler = async (handleRequest, createRequestOptions)=>{
                 isRSCNavigation: 'true' === request.headers.get('x-rsc-tree'),
                 basename: ssrContext.baseUrl || '/'
             };
-            try {
+            return (0, external_routerCleanup_js_namespaceObject.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], external_tracer_js_namespaceObject.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>', `${external_constants_js_namespaceObject.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 (0, lifecycle_js_namespaceObject.cleanupRouterRuntimeState)(context);
-            }
+                const response = await renderRequest(request, Root, context, options, handleRequest, !!createRequestOptions?.enableRsc);
+                return finalizeRenderResponse(response, responseProxy, redirectCtx, routerCleanup);
+            });
         });
     };
     return requestHandler;

package/dist/cjs/core/server/routerCleanup.js

@@ -0,0 +1,110 @@
+"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__, {
+    ROUTER_CLEANUP_ERROR: ()=>ROUTER_CLEANUP_ERROR,
+    createRouterCleanup: ()=>createRouterCleanup,
+    withRouterCleanup: ()=>withRouterCleanup
+});
+const lifecycle_js_namespaceObject = require("../../router/runtime/lifecycle.js");
+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 (0, lifecycle_js_namespaceObject.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
+    };
+}
+exports.ROUTER_CLEANUP_ERROR = __webpack_exports__.ROUTER_CLEANUP_ERROR;
+exports.createRouterCleanup = __webpack_exports__.createRouterCleanup;
+exports.withRouterCleanup = __webpack_exports__.withRouterCleanup;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ROUTER_CLEANUP_ERROR",
+    "createRouterCleanup",
+    "withRouterCleanup"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});