@bleedingdev/modern-js-runtime 3.5.0-ultramodern.5 → 3.5.0-ultramodern.75

package/dist/esm/cli/code.mjs

@@ -2,8 +2,8 @@ import { formatImportPath, fs } from "@modern-js/utils";
 import path from "path";
 import { ENTRY_BOOTSTRAP_FILE_NAME, ENTRY_POINT_FILE_NAME, ENTRY_POINT_REGISTER_FILE_NAME, ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME, ENTRY_POINT_RUNTIME_REGISTER_FILE_NAME, ENTRY_SERVER_BOOTSTRAP_FILE_NAME, INDEX_FILE_NAME, SERVER_ENTRY_POINT_FILE_NAME } from "./constants.mjs";
 import { resolveSSRMode } from "./ssr/mode.mjs";
-import * as __rspack_external__template_mjs_d6ab8956 from "./template.mjs";
-import * as __rspack_external__template_server_mjs_38d6edb1 from "./template.server.mjs";
+import * as __rspack_external__template_mjs_d1604447 from "./template.mjs";
+import * as __rspack_external__template_server_mjs_f98cfe58 from "./template.server.mjs";
 const normalizePreEntry = (preEntry)=>{
     if (!preEntry) return [];
     if (Array.isArray(preEntry)) return preEntry.filter((v)=>'string' == typeof v && v.length > 0);
@@ -35,7 +35,7 @@ const generateCode = async (entrypoints, appContext, config, hooks)=>{
                 nestedRoutesEntry
             });
             let indexCode = '';
-            indexCode = ssrMode || !config.server.rsc || customEntry ? __rspack_external__template_mjs_d6ab8956.index({
+            indexCode = ssrMode || !config.server.rsc || customEntry ? __rspack_external__template_mjs_d1604447.index({
                 srcDirectory,
                 internalSrcAlias,
                 metaName,
@@ -45,7 +45,7 @@ const generateCode = async (entrypoints, appContext, config, hooks)=>{
                 mountId,
                 enableRsc: config.server.rsc,
                 isNestedRouter: !!entrypoint.nestedRoutesEntry
-            }) : __rspack_external__template_mjs_d6ab8956.entryForCSRWithRSC({
+            }) : __rspack_external__template_mjs_d1604447.entryForCSRWithRSC({
                 metaName,
                 entryName,
                 mountId,
@@ -76,7 +76,7 @@ const generateCode = async (entrypoints, appContext, config, hooks)=>{
                 if (ssrMode) await fs.outputFile(bootstrapServerFile, `export const requestHandler = import('./${SERVER_ENTRY_POINT_FILE_NAME}').then((m) => m.requestHandler)`, 'utf8');
             }
             if (ssrMode) {
-                const indexServerCode = __rspack_external__template_server_mjs_38d6edb1.serverIndex({
+                const indexServerCode = __rspack_external__template_server_mjs_f98cfe58.serverIndex({
                     entry,
                     entryName,
                     internalSrcAlias,
@@ -90,16 +90,16 @@ const generateCode = async (entrypoints, appContext, config, hooks)=>{
                 await fs.outputFile(indexServerFile, indexServerCode, 'utf8');
             } else if (config.server.rsc) {
                 const indexServerFile = path.resolve(internalDirectory, `./${entryName}/${SERVER_ENTRY_POINT_FILE_NAME}`);
-                const indexServerCode = __rspack_external__template_server_mjs_38d6edb1.entryForCSRWithRSC({
+                const indexServerCode = __rspack_external__template_server_mjs_f98cfe58.entryForCSRWithRSC({
                     entryName,
                     metaName
                 });
                 await fs.outputFile(indexServerFile, indexServerCode, 'utf8');
             }
-            const registerCode = __rspack_external__template_mjs_d6ab8956.register();
+            const registerCode = __rspack_external__template_mjs_d1604447.register();
             const registerFile = path.resolve(internalDirectory, `./${entryName}/${ENTRY_POINT_REGISTER_FILE_NAME}`);
             await fs.outputFile(registerFile, registerCode, 'utf8');
-            const registerRuntimeCode = __rspack_external__template_mjs_d6ab8956.runtimeRegister({
+            const registerRuntimeCode = __rspack_external__template_mjs_d1604447.runtimeRegister({
                 entryName,
                 srcDirectory,
                 internalSrcAlias,
@@ -113,7 +113,7 @@ const generateCode = async (entrypoints, appContext, config, hooks)=>{
             if (!config.server.rsc || entrypoint.nestedRoutesEntry) {
                 const route = serverRoutes.find((r)=>r.entryName === entryName);
                 const basename = route?.urlPath || '/';
-                contextCode = __rspack_external__template_mjs_d6ab8956.runtimeGlobalContext({
+                contextCode = __rspack_external__template_mjs_d1604447.runtimeGlobalContext({
                     entryName,
                     srcDirectory,
                     internalSrcAlias,
@@ -124,18 +124,18 @@ const generateCode = async (entrypoints, appContext, config, hooks)=>{
                 });
             } else {
                 const AppProxyPath = path.join(internalDirectory, entryName, './AppProxy.jsx');
-                const appProxyCode = __rspack_external__template_mjs_d6ab8956.AppProxyForRSC({
+                const appProxyCode = __rspack_external__template_mjs_d1604447.AppProxyForRSC({
                     srcDirectory,
                     internalSrcAlias,
                     entry,
                     customEntry
                 });
                 await fs.outputFile(AppProxyPath, appProxyCode);
-                contextCode = __rspack_external__template_mjs_d6ab8956.runtimeGlobalContextForRSCClient({
+                contextCode = __rspack_external__template_mjs_d1604447.runtimeGlobalContextForRSCClient({
                     metaName,
                     customEntry
                 });
-                const contextServerCode = __rspack_external__template_mjs_d6ab8956.runtimeGlobalContextForRSCServer({
+                const contextServerCode = __rspack_external__template_mjs_d1604447.runtimeGlobalContextForRSCServer({
                     metaName
                 });
                 const contextFile = path.resolve(internalDirectory, `./${entryName}/${ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME}.server.js`);

package/dist/esm/cli/ssr/index.mjs

@@ -84,14 +84,13 @@ const ssrBuilderPlugin = (modernAPI, outputModule, exportLoadablePath)=>({
                 const hasServerRendering = hasServerRenderingConfig(userConfig);
                 const hasModuleFederationRuntimeMarker = hasServerRendering && shouldUseModuleFederationNodeOutput(config);
                 const hasExplicitMfSsrFlag = isModuleFederationAppSSREnabled(userConfig);
-                const isCloudflareWorkerSSR = 'workerSSR' === name && userConfig.deploy?.target === 'cloudflare';
                 const requireExplicitMfSsrFlag = 'true' === process.env.MODERN_MF_APP_SSR_REQUIRE_EXPLICIT;
                 if (hasServerRendering && hasModuleFederationRuntimeMarker && !hasExplicitMfSsrFlag) {
                     const warningMessage = '[modernjs][mf-ssr] Module Federation SSR was auto-detected from runtime markers. Set server.ssr.moduleFederationAppSSR=true explicitly in host and remotes to avoid heuristic drift.';
                     if (requireExplicitMfSsrFlag) throw new Error(`${warningMessage} (enforced by MODERN_MF_APP_SSR_REQUIRE_EXPLICIT=true)`);
                     console.warn(warningMessage);
                 }
-                const isModuleFederationAppSSR = hasServerRendering && hasExplicitMfSsrFlag && !isCloudflareWorkerSSR;
+                const isModuleFederationAppSSR = hasServerRendering && hasExplicitMfSsrFlag;
                 const ssrEnv = userConfig.deploy?.worker?.ssr || userConfig.server?.rsc ? 'edge' : 'node';
                 const appContext = modernAPI.getAppContext();
                 const { appDirectory, entrypoints } = appContext;
@@ -105,6 +104,8 @@ const ssrBuilderPlugin = (modernAPI, outputModule, exportLoadablePath)=>({
                         define: {
                             'process.env.MODERN_TARGET': isServerEnvironment ? JSON.stringify('node') : JSON.stringify('browser'),
                             'process.env.MODERN_SSR_ENV': JSON.stringify(ssrEnv),
+                            'process.env.MODERN_ENABLE_HYDRATION': JSON.stringify(isUseSSRBundle(userConfig)),
+                            'process.env.MODERN_ENABLE_RSC': JSON.stringify(Boolean(userConfig.server?.rsc)),
                             'process.env.MODERN_MF_APP_SSR': JSON.stringify(isModuleFederationAppSSR)
                         }
                     },

package/dist/esm/cli/ssr/loadable-bundler-plugin.mjs

@@ -1,6 +1,7 @@
 import { fs } from "@modern-js/utils";
 import path_0 from "path";
 const normalizeChunkId = (id)=>'string' == typeof id && /^\d+$/.test(id) ? Number(id) : id;
+const DEFAULT_CHUNK_LOADING_GLOBAL = '__LOADABLE_LOADED_CHUNKS__';
 const normalizeChunkGroup = (group)=>({
         ...group,
         chunks: (group.chunks || []).map(normalizeChunkId)
@@ -8,7 +9,11 @@ const normalizeChunkGroup = (group)=>({
 class LoadablePlugin {
     apply(compiler) {
         this.compiler = compiler;
-        compiler.options.output.chunkLoadingGlobal = this.opts.chunkLoadingGlobal;
+        const chunkLoadingGlobal = this.opts.chunkLoadingGlobal ?? compiler.options.output.chunkLoadingGlobal ?? DEFAULT_CHUNK_LOADING_GLOBAL;
+        compiler.options.output.chunkLoadingGlobal = chunkLoadingGlobal;
+        new compiler.webpack.DefinePlugin({
+            'process.env.MODERN_CHUNK_LOADING_GLOBAL': JSON.stringify(chunkLoadingGlobal)
+        }).apply(compiler);
         if (this.opts.outputAsset || this.opts.writeToDisk) compiler.hooks.make.tap(LoadablePlugin.name, (compilation)=>{
             compilation.hooks.processAssets.tap({
                 name: LoadablePlugin.name,
@@ -68,10 +73,9 @@ class LoadablePlugin {
         const outputFile = path_0.resolve(outputFolder || '', this.opts.filename);
         fs.outputFileSync(outputFile, manifest);
     }
-    constructor({ filename = 'loadable-stats.json', path, writeToDisk, outputAsset = true, chunkLoadingGlobal = '__LOADABLE_LOADED_CHUNKS__' } = {
+    constructor({ filename = 'loadable-stats.json', path, writeToDisk, outputAsset = true, chunkLoadingGlobal } = {
         filename: 'loadable-stats.json',
-        outputAsset: true,
-        chunkLoadingGlobal: '__LOADABLE_LOADED_CHUNKS__'
+        outputAsset: true
     }){
         this.opts = {
             filename,

package/dist/esm/core/browser/hydrate.mjs

@@ -1,10 +1,21 @@
 import { jsx } from "react/jsx-runtime";
 import { loadableReady } from "@loadable/component";
+import { SSR_HYDRATION_ID_PREFIX } from "@modern-js/utils/universal/constants";
+import { hydrateRoot } from "react-dom/client";
 import { RenderLevel } from "../constants.mjs";
 import { wrapRuntimeContextProvider } from "../react/wrapper.mjs";
 import { WithCallback } from "./withCallback.mjs";
 const isReact18 = ()=>'true' === process.env.IS_REACT18;
-function hydrateRoot(App, context, ModernRender, ModernHydrate) {
+const runtimeProcess = Reflect.get(globalThis, 'process');
+const loadableReadyOptions = {
+    chunkLoadingGlobal: runtimeProcess?.env?.MODERN_CHUNK_LOADING_GLOBAL || '__LOADABLE_LOADED_CHUNKS__'
+};
+async function hydrateWithReact(App, rootElement) {
+    return hydrateRoot(rootElement, App, {
+        identifierPrefix: SSR_HYDRATION_ID_PREFIX
+    });
+}
+function hydrate_hydrateRoot(App, context, ModernRender, ModernHydrate) {
     const hydrateContext = {
         ...context,
         get routes () {
@@ -40,14 +51,14 @@ function hydrateRoot(App, context, ModernRender, ModernHydrate) {
                 ModernHydrate(wrapRuntimeContextProvider(/*#__PURE__*/ jsx(SSRApp, {}), hydrateContext)).then((root)=>{
                     resolve(root);
                 });
-            }) : loadableReady(()=>{
+            }, loadableReadyOptions) : loadableReady(()=>{
                 ModernHydrate(wrapRuntimeContextProvider(App, hydrateContext), callback).then((root)=>{
                     resolve(root);
                 });
-            });
+            }, loadableReadyOptions);
         });
         console.warn(`unknow render level: ${renderLevel}, execute render()`);
         return ModernRender(wrapRuntimeContextProvider(App, context));
     }
 }
-export { hydrateRoot, isReact18 };
+export { hydrateWithReact, hydrate_hydrateRoot as hydrateRoot, isReact18 };

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

@@ -3,7 +3,7 @@ import { parseCookie } from "cookie";
 import { getGlobalInternalRuntimeContext } from "../context/index.mjs";
 import { getInitialContext } from "../context/runtime.mjs";
 import { wrapRuntimeContextProvider } from "../react/wrapper.mjs";
-import { hydrateRoot } from "./hydrate.mjs";
+import { hydrateRoot, hydrateWithReact } from "./hydrate.mjs";
 const IS_REACT18 = 'true' === process.env.IS_REACT18;
 const getQuery = ()=>window.location.search.substring(1).split('&').reduce((res, item)=>{
         const [key, value] = item.split('=');
@@ -47,10 +47,9 @@ function getSSRData() {
 function isClientArgs(id) {
     return void 0 === id || 'string' == typeof id || "u" > typeof HTMLElement && id instanceof HTMLElement;
 }
-async function render(App, id) {
+async function renderApp(App, id, hydrateFromSsrData, internalRuntimeContext) {
     const context = getInitialContext();
     const runBeforeRender = async (context)=>{
-        const internalRuntimeContext = getGlobalInternalRuntimeContext();
         const api = internalRuntimeContext.pluginAPI;
         api.updateRuntimeContext(context);
         const hooks = internalRuntimeContext.hooks;
@@ -73,11 +72,18 @@ async function render(App, id) {
             const hydrateFunc = IS_REACT18 ? hydrateWithReact18 : hydrateWithReact17;
             return hydrateFunc(App, rootElement, callback);
         }
-        if (window._SSR_DATA) return hydrateRoot(App, context, ModernRender, ModernHydrate);
+        if (hydrateFromSsrData && process.env.MODERN_ENABLE_HYDRATION && window._SSR_DATA) return hydrateRoot(App, context, ModernRender, ModernHydrate);
         return ModernRender(wrapRuntimeContextProvider(App, context));
     }
     throw Error('`render` function needs id in browser environment, it needs to be string or element');
 }
+async function render(App, id) {
+    return renderApp(App, id, true, getGlobalInternalRuntimeContext());
+}
+function createNestedAppRenderer() {
+    const internalRuntimeContext = getGlobalInternalRuntimeContext();
+    return (App, id)=>renderApp(App, id, false, internalRuntimeContext);
+}
 async function renderWithReact18(App, rootElement) {
     const ReactDOM = await import("react-dom/client");
     const root = ReactDOM.createRoot(rootElement);
@@ -101,4 +107,4 @@ async function hydrateWithReact17(App, rootElement, callback) {
     const root = ReactDOM.hydrate(App, rootElement, callback);
     return root;
 }
-export { hydrateWithReact17, hydrateWithReact18, render, renderWithReact17, renderWithReact18 };
+export { createNestedAppRenderer, hydrateWithReact, hydrateWithReact17, hydrateWithReact18, render, renderWithReact17, renderWithReact18 };

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

@@ -43,7 +43,7 @@ function getGlobalBasename() {
 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 { createRouterProviderRealm, 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";

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

@@ -0,0 +1,5 @@
+import { createContext, useContext } from "react";
+const RuntimeContext = createContext({});
+const ReactRuntimeContext = RuntimeContext;
+const useRuntimeContext = ()=>useContext(RuntimeContext);
+export { ReactRuntimeContext, RuntimeContext, useRuntimeContext };

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

@@ -1,8 +1,6 @@
-import { ROUTE_MANIFEST } from "@modern-js/utils/universal/constants";
-import { createContext, useContext } from "react";
+import { createContext } from "react";
+const ROUTE_MANIFEST = '_MODERNJS_ROUTE_MANIFEST';
 const InternalRuntimeContext = createContext({});
-const RuntimeContext = createContext({});
-const ReactRuntimeContext = RuntimeContext;
 const getInitialContext = (isBrowser = true, routeManifest)=>{
     const requestContext = {
         request: {},
@@ -15,5 +13,5 @@ const getInitialContext = (isBrowser = true, routeManifest)=>{
         context: requestContext
     };
 };
-const useRuntimeContext = ()=>useContext(RuntimeContext);
-export { InternalRuntimeContext, ReactRuntimeContext, RuntimeContext, getInitialContext, useRuntimeContext };
+export { ReactRuntimeContext, RuntimeContext, useRuntimeContext } from "./public.mjs";
+export { InternalRuntimeContext, getInitialContext };

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

@@ -1,8 +1,44 @@
 import { jsx } from "react/jsx-runtime";
 import { HelmetProvider } from "react-helmet-async";
-import { InternalRuntimeContext, RuntimeContext } from "../context/index.mjs";
+import { InternalRuntimeContext, RuntimeContext, getGlobalEnableRsc } from "../context/index.mjs";
 import { stripRuntimeContextExtensions } from "../context/extensions.mjs";
 import { ensureHelmetContext } from "../context/helmetContext.mjs";
+function toRscSafeRecord(value) {
+    if (!value || 'object' != typeof value) return value;
+    return Object.fromEntries(Object.entries(value));
+}
+function createRscSafeSsrContext(ssrContext) {
+    if (!ssrContext) return ssrContext;
+    const { request } = ssrContext;
+    return {
+        nonce: ssrContext.nonce,
+        useJsonScript: ssrContext.useJsonScript,
+        htmlModifiers: [],
+        baseUrl: ssrContext.baseUrl,
+        request: request ? {
+            url: request.url,
+            userAgent: request.userAgent,
+            cookie: request.cookie,
+            pathname: request.pathname,
+            query: toRscSafeRecord(request.query),
+            params: toRscSafeRecord(request.params),
+            headers: toRscSafeRecord(request.headers),
+            host: request.host,
+            referer: request.referer
+        } : request,
+        mode: ssrContext.mode,
+        loaderFailureMode: ssrContext.loaderFailureMode
+    };
+}
+function createRscSafeRequestContext(ssrContext) {
+    const safeSsrContext = createRscSafeSsrContext(ssrContext);
+    return {
+        request: safeSsrContext?.request || {},
+        response: {
+            locals: ssrContext?.response?.locals || {}
+        }
+    };
+}
 function wrapRuntimeContextProvider(App, contextValue) {
     const { isBrowser, initialData, routes, context, routeManifest, routerContext, unstable_getBlockNavState, ssrContext, _internalContext, _internalRouterBaseName, ...rest } = contextValue;
     const internalContextValue = contextValue;
@@ -15,6 +51,27 @@ function wrapRuntimeContextProvider(App, contextValue) {
         ...rest
     };
     stripRuntimeContextExtensions(runtimeContextValue);
+    if (getGlobalEnableRsc() && !isBrowser) {
+        const rscSafeRequestContext = createRscSafeRequestContext(ssrContext);
+        const rscInternalContextValue = {
+            ...internalContextValue,
+            context: rscSafeRequestContext,
+            requestContext: rscSafeRequestContext,
+            ssrContext: createRscSafeSsrContext(ssrContext)
+        };
+        const rscRuntimeContextValue = {
+            ...runtimeContextValue,
+            context: rscSafeRequestContext,
+            requestContext: rscSafeRequestContext
+        };
+        return /*#__PURE__*/ jsx(InternalRuntimeContext.Provider, {
+            value: rscInternalContextValue,
+            children: /*#__PURE__*/ jsx(RuntimeContext.Provider, {
+                value: rscRuntimeContextValue,
+                children: App
+            })
+        });
+    }
     return /*#__PURE__*/ jsx(InternalRuntimeContext.Provider, {
         value: internalContextValue,
         children: /*#__PURE__*/ jsx(RuntimeContext.Provider, {

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

@@ -1,12 +1,16 @@
 import { attributesToString } from "./utils.mjs";
+const escapeHtmlAttribute = (value)=>value.replaceAll('&', '&amp;').replaceAll('"', '&quot;').replaceAll('<', '&lt;').replaceAll('>', '&gt;');
 const createFederatedCssLinks = (assets, options)=>{
     if (void 0 === assets || 0 === assets.length) return '';
     const seen = new Set(options.existingAssets || []);
     const attributes = attributesToString(options.attributes || {});
     const links = [];
-    for (const asset of assets)if (!('' === asset || seen.has(asset) || options.template.includes(asset))) {
-        seen.add(asset);
-        links.push(`<link${attributes} href="${asset}" rel="stylesheet" />`);
+    for (const asset of assets){
+        const href = escapeHtmlAttribute(asset);
+        if (!('' === asset || seen.has(asset) || options.template.includes(asset) || options.template.includes(href))) {
+            seen.add(asset);
+            links.push(`<link${attributes} href="${href}" rel="stylesheet" />`);
+        }
     }
     return links.join('');
 };

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

@@ -2,15 +2,13 @@ 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 { 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 { applyRouterSnapshotResult, createLoaderRedirectResponse, finalizeRenderResponse } from "./requestResponse.mjs";
+import { createRouterCleanup, finishWithRouterCleanup, runWithRouterCleanupOnError } from "./routerCleanup.mjs";
 import { getSSRConfigByEntry, getSSRMode } from "./utils.mjs";
 async function handleRSCRequest(request, Root, context, options, handleRequest) {
     const serverPayload = getServerPayload();
@@ -30,29 +28,6 @@ async function handleRSCRequest(request, Root, context, options, handleRequest)
         runtimeContext: context
     });
 }
-const isRedirectStatus = (status)=>status >= 300 && status <= 399;
-const processRedirect = (headers, status, ctx)=>{
-    if (ctx.enableRsc && ctx.isRSCNavigation) return handleRSCRedirect(headers, ctx.basename, status);
-    return new Response(null, {
-        status,
-        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, {
@@ -60,17 +35,6 @@ const renderRequest = async (request, Root, context, options, handleRequest, ena
         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;
@@ -166,20 +130,26 @@ const createRequestHandler = async (handleRequest, createRequestOptions)=>{
                 isRSCNavigation: 'true' === request.headers.get('x-rsc-tree'),
                 basename: ssrContext.baseUrl || '/'
             };
-            return withRouterCleanup(context, options.onError, async (routerCleanup)=>{
-                const beforeRenderResult = await runBeforeRender(context);
+            const routerCleanup = createRouterCleanup(context, options.onError);
+            const beforeRenderResult = await runWithRouterCleanupOnError(routerCleanup, ()=>runBeforeRender(context));
+            await runWithRouterCleanupOnError(routerCleanup, ()=>{
                 applyRouterSnapshotResult(context, options.onError);
-                if ("u" > typeof Response) {
-                    const redirectResponse = createLoaderRedirectResponse(beforeRenderResult, redirectCtx);
-                    if (redirectResponse) return redirectResponse;
+            });
+            if ("u" > typeof Response) {
+                const redirectResponse = await runWithRouterCleanupOnError(routerCleanup, ()=>createLoaderRedirectResponse(beforeRenderResult, redirectCtx));
+                if (redirectResponse) {
+                    await routerCleanup.run();
+                    return redirectResponse;
                 }
+            }
+            await runWithRouterCleanupOnError(routerCleanup, ()=>{
                 if (!createRequestOptions?.enableRsc) {
                     const { htmlTemplate } = options.resource;
                     options.resource.htmlTemplate = htmlTemplate.replace('</head>', `${CHUNK_CSS_PLACEHOLDER}</head>`);
                 }
-                const response = await renderRequest(request, Root, context, options, handleRequest, !!createRequestOptions?.enableRsc);
-                return finalizeRenderResponse(response, responseProxy, redirectCtx, routerCleanup);
             });
+            const response = await runWithRouterCleanupOnError(routerCleanup, ()=>renderRequest(request, Root, context, options, handleRequest, !!createRequestOptions?.enableRsc));
+            return finishWithRouterCleanup(routerCleanup, ()=>finalizeRenderResponse(response, responseProxy, redirectCtx, routerCleanup));
         });
     };
     return requestHandler;

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

@@ -0,0 +1,39 @@
+import { getRouterServerSnapshot } from "../../router/runtime/lifecycle.mjs";
+import { handleRSCRedirect } from "../../router/runtime/rsc-router.mjs";
+import { SSRErrors } from "./tracer.mjs";
+const isRedirectStatus = (status)=>status >= 300 && status <= 399;
+const isNullBodyStatus = (status)=>204 === status || 205 === status || 304 === status;
+const processRedirect = (headers, status, ctx)=>{
+    if (ctx.enableRsc && ctx.isRSCNavigation) return handleRSCRedirect(headers, ctx.basename, status);
+    return new Response(null, {
+        status,
+        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 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(isNullBodyStatus(responseProxy.status) ? null : response.body, {
+        status: responseProxy.status,
+        headers: response.headers
+    }));
+    return routerCleanup.deferUntilBodyDone(response);
+};
+export { applyRouterSnapshotResult, createLoaderRedirectResponse, finalizeRenderResponse };

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

@@ -1,9 +1,16 @@
 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);
+async function runWithRouterCleanupOnError(routerCleanup, callback) {
     try {
-        return await callback(routerCleanup);
+        return await callback();
+    } catch (error) {
+        await routerCleanup.run();
+        throw error;
+    }
+}
+async function finishWithRouterCleanup(routerCleanup, callback) {
+    try {
+        return await callback();
     } finally{
         if (!routerCleanup.deferred) await routerCleanup.run();
     }
@@ -63,4 +70,4 @@ function createRouterCleanup(runtimeContext, onError) {
         deferUntilBodyDone
     };
 }
-export { ROUTER_CLEANUP_ERROR, createRouterCleanup, withRouterCleanup };
+export { ROUTER_CLEANUP_ERROR, createRouterCleanup, finishWithRouterCleanup, runWithRouterCleanupOnError };

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

@@ -42,6 +42,10 @@ function getMatchedRouteAssets(runtimeContext, routeManifest) {
     const matchedRouteIds = getRouterMatchedRouteIds(runtimeContext) ?? [];
     return matchedRouteIds.flatMap((routeId)=>routeAssets[routeId]?.assets ?? []);
 }
+function getMatchedRouteChunks(runtimeContext, routeManifest, routeAssetToChunk) {
+    if (!routeManifest) return [];
+    return getMatchedRouteAssets(runtimeContext, routeManifest).map(routeAssetToChunk);
+}
 const orderHydrationScriptChunks = ({ asyncEntryChunks, collectedChunks, matchedRouteChunks, entryName })=>{
     const asyncEntryScriptChunks = [];
     const asyncEntryDependencyChunks = [];
@@ -72,13 +76,12 @@ function createRouteHydrationScriptTags(runtimeContext, entryName, options = {})
     const { nonce, template } = options;
     const routeAssets = getRouteAssets(runtimeContext);
     if (void 0 === routeAssets) return '';
-    const matchedRouteIds = getRouterMatchedRouteIds(runtimeContext) ?? [];
-    const assetEntries = [
-        ...matchedRouteIds.map((routeId)=>routeAssets[routeId]),
-        routeAssets[`async-${entryName}`]
-    ].filter((entry)=>void 0 !== entry);
-    const jsAssets = Array.from(new Set(assetEntries.flatMap((entry)=>(entry.assets ?? []).filter((asset)=>asset.endsWith('.js')))));
+    const existingScriptSrcs = void 0 === template ? new Set() : new Set(getScriptTags(template).map(({ src })=>src));
+    const jsAssets = Array.from(new Set([
+        ...getMatchedRouteAssets(runtimeContext),
+        ...routeAssets[`async-${entryName}`]?.assets ?? []
+    ].filter((asset)=>asset.endsWith('.js'))));
     const nonceAttr = void 0 === nonce || '' === nonce ? '' : ` nonce="${nonce}"`;
-    return jsAssets.filter((asset)=>template?.includes(asset) !== true).map((asset)=>`<script src=${asset}${nonceAttr}></script>`).join(' ');
+    return jsAssets.filter((asset)=>!existingScriptSrcs.has(asset)).map((asset)=>`<script src=${asset}${nonceAttr}></script>`).join(' ');
 }
-export { createRouteHydrationScriptTags, getMatchedRouteAssets, injectBeforeHydrationEntryScript, orderHydrationScriptChunks, replaceChunkJsPlaceholder };
+export { createRouteHydrationScriptTags, getMatchedRouteChunks, injectBeforeHydrationEntryScript, orderHydrationScriptChunks, replaceChunkJsPlaceholder };

package/dist/esm/core/server/stream/afterTemplate.mjs

@@ -4,19 +4,20 @@ import { SSR_DATA_JSON_ID } from "../../constants.mjs";
 import { SSR_DATA_PLACEHOLDER } from "../constants.mjs";
 import { createRouteHydrationScriptTags, replaceChunkJsPlaceholder } from "../scriptOrder.mjs";
 import { buildHtml } from "../shared.mjs";
-import { attributesToString, safeReplace } from "../utils.mjs";
+import { attributesToString } from "../utils.mjs";
 function buildShellAfterTemplate(afterAppTemplate, options) {
     const { request, config, ssrConfig, runtimeContext, renderLevel, entryName } = options;
     const callbacks = [
+        (template)=>injectJs(template, entryName, config.nonce),
         createReplaceSSRData({
             request,
             ssrConfig,
             nonce: config.nonce,
             useJsonScript: config.useJsonScript,
             runtimeContext,
-            renderLevel
-        }),
-        (template)=>injectJs(template, entryName, config.nonce)
+            renderLevel,
+            entryName
+        })
     ];
     async function injectJs(template, entryName, nonce) {
         const jsChunkStr = createRouteHydrationScriptTags(runtimeContext, entryName, {
@@ -29,7 +30,7 @@ function buildShellAfterTemplate(afterAppTemplate, options) {
     return buildHtml(afterAppTemplate, callbacks);
 }
 function createReplaceSSRData(options) {
-    const { runtimeContext, nonce, renderLevel, useJsonScript, ssrConfig } = options;
+    const { runtimeContext, nonce, renderLevel, useJsonScript, ssrConfig, entryName } = options;
     const { request, reporter } = runtimeContext.ssrContext;
     const headers = 'object' == typeof ssrConfig && ssrConfig.unsafeHeaders ? Object.fromEntries(Object.entries(request.headers).filter(([key, _])=>ssrConfig.unsafeHeaders?.map((header)=>header.toLowerCase())?.includes(key.toLowerCase()))) : void 0;
     const ssrData = {
@@ -60,6 +61,9 @@ function createReplaceSSRData(options) {
     const ssrDataScript = useJsonScript ? `<script type="application/json" id="${SSR_DATA_JSON_ID}">${serializeSSRData}</script>` : `<script${attrsStr}>window._SSR_DATA = ${serializeSSRData}</script>`;
     const hydrationScripts = getRouterHydrationScripts(runtimeContext);
     const ssrScripts = hydrationScripts.length ? `${ssrDataScript}\n${hydrationScripts.join('\n')}` : ssrDataScript;
-    return (template)=>safeReplace(template, SSR_DATA_PLACEHOLDER, ssrScripts);
+    return (template)=>{
+        if (!template.includes(SSR_DATA_PLACEHOLDER)) return template;
+        return replaceChunkJsPlaceholder(template, ssrScripts, entryName, SSR_DATA_PLACEHOLDER);
+    };
 }
 export { buildShellAfterTemplate };

package/dist/esm/core/server/stream/template.mjs

@@ -2,12 +2,12 @@ import { buildShellAfterTemplate } from "./afterTemplate.mjs";
 import { buildShellBeforeTemplate } from "./beforeTemplate.mjs";
 const HTML_SEPARATOR = '<!--<?- html ?>-->';
 const getTemplates = async (htmlTemplate, options)=>{
-    const [beforeAppTemplate = '', afterAppHtmlTemplate = ''] = htmlTemplate.split(HTML_SEPARATOR) || [];
+    const builtTemplate = await buildShellAfterTemplate(htmlTemplate, options);
+    const [beforeAppTemplate = '', afterAppHtmlTemplate = ''] = builtTemplate.split(HTML_SEPARATOR) || [];
     const builtBeforeTemplate = await buildShellBeforeTemplate(beforeAppTemplate, options);
-    const builtAfterTemplate = await buildShellAfterTemplate(afterAppHtmlTemplate, options);
     return {
         shellBefore: builtBeforeTemplate,
-        shellAfter: builtAfterTemplate
+        shellAfter: afterAppHtmlTemplate
     };
 };
 export { getTemplates };