@bleedingdev/modern-js-runtime 3.5.0-ultramodern.30 → 3.5.0-ultramodern.31

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

@@ -35,6 +35,42 @@ 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 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;
@@ -47,6 +83,27 @@ function wrapRuntimeContextProvider(App, contextValue) {
         ...rest
     };
     (0, extensions_js_namespaceObject.stripRuntimeContextExtensions)(runtimeContextValue);
+    if ((0, index_js_namespaceObject.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__*/ (0, jsx_runtime_namespaceObject.jsx)(index_js_namespaceObject.InternalRuntimeContext.Provider, {
+            value: rscInternalContextValue,
+            children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(index_js_namespaceObject.RuntimeContext.Provider, {
+                value: rscRuntimeContextValue,
+                children: App
+            })
+        });
+    }
     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, {

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

@@ -31,14 +31,18 @@ __webpack_require__.d(__webpack_exports__, {
     createFederatedCssLinks: ()=>createFederatedCssLinks
 });
 const external_utils_js_namespaceObject = require("./utils.js");
+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 = (0, external_utils_js_namespaceObject.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/cjs/core/server/requestHandler.js

@@ -44,15 +44,13 @@ const node_namespaceObject = require("@modern-js/runtime-utils/node");
 const request_namespaceObject = require("@modern-js/runtime-utils/universal/request");
 const external_react_namespaceObject = require("react");
 var external_react_default = /*#__PURE__*/ __webpack_require__.n(external_react_namespaceObject);
-const lifecycle_js_namespaceObject = require("../../router/runtime/lifecycle.js");
-const rsc_router_js_namespaceObject = require("../../router/runtime/rsc-router.js");
 const index_js_namespaceObject = require("../context/index.js");
 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_requestResponse_js_namespaceObject = require("./requestResponse.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) {
     const serverPayload = (0, serverPayload_index_js_namespaceObject.getServerPayload)();
@@ -72,29 +70,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 (0, rsc_router_js_namespaceObject.handleRSCRedirect)(headers, ctx.basename, status);
-    return new Response(null, {
-        status,
-        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, {
@@ -102,17 +77,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;
@@ -208,20 +172,26 @@ const createRequestHandler = async (handleRequest, createRequestOptions)=>{
                 isRSCNavigation: 'true' === request.headers.get('x-rsc-tree'),
                 basename: ssrContext.baseUrl || '/'
             };
-            return (0, external_routerCleanup_js_namespaceObject.withRouterCleanup)(context, options.onError, async (routerCleanup)=>{
-                const beforeRenderResult = await runBeforeRender(context);
-                applyRouterSnapshotResult(context, options.onError);
-                if ("u" > typeof Response) {
-                    const redirectResponse = createLoaderRedirectResponse(beforeRenderResult, redirectCtx);
-                    if (redirectResponse) return redirectResponse;
+            const routerCleanup = (0, external_routerCleanup_js_namespaceObject.createRouterCleanup)(context, options.onError);
+            const beforeRenderResult = await (0, external_routerCleanup_js_namespaceObject.runWithRouterCleanupOnError)(routerCleanup, ()=>runBeforeRender(context));
+            await (0, external_routerCleanup_js_namespaceObject.runWithRouterCleanupOnError)(routerCleanup, ()=>{
+                (0, external_requestResponse_js_namespaceObject.applyRouterSnapshotResult)(context, options.onError);
+            });
+            if ("u" > typeof Response) {
+                const redirectResponse = await (0, external_routerCleanup_js_namespaceObject.runWithRouterCleanupOnError)(routerCleanup, ()=>(0, external_requestResponse_js_namespaceObject.createLoaderRedirectResponse)(beforeRenderResult, redirectCtx));
+                if (redirectResponse) {
+                    await routerCleanup.run();
+                    return redirectResponse;
                 }
+            }
+            await (0, external_routerCleanup_js_namespaceObject.runWithRouterCleanupOnError)(routerCleanup, ()=>{
                 if (!createRequestOptions?.enableRsc) {
                     const { htmlTemplate } = options.resource;
                     options.resource.htmlTemplate = htmlTemplate.replace('</head>', `${external_constants_js_namespaceObject.CHUNK_CSS_PLACEHOLDER}</head>`);
                 }
-                const response = await renderRequest(request, Root, context, options, handleRequest, !!createRequestOptions?.enableRsc);
-                return finalizeRenderResponse(response, responseProxy, redirectCtx, routerCleanup);
             });
+            const response = await (0, external_routerCleanup_js_namespaceObject.runWithRouterCleanupOnError)(routerCleanup, ()=>renderRequest(request, Root, context, options, handleRequest, !!createRequestOptions?.enableRsc));
+            return (0, external_routerCleanup_js_namespaceObject.finishWithRouterCleanup)(routerCleanup, ()=>(0, external_requestResponse_js_namespaceObject.finalizeRenderResponse)(response, responseProxy, redirectCtx, routerCleanup));
         });
     };
     return requestHandler;

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

@@ -0,0 +1,83 @@
+"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__, {
+    applyRouterSnapshotResult: ()=>applyRouterSnapshotResult,
+    createLoaderRedirectResponse: ()=>createLoaderRedirectResponse,
+    finalizeRenderResponse: ()=>finalizeRenderResponse
+});
+const lifecycle_js_namespaceObject = require("../../router/runtime/lifecycle.js");
+const rsc_router_js_namespaceObject = require("../../router/runtime/rsc-router.js");
+const external_tracer_js_namespaceObject = require("./tracer.js");
+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 (0, rsc_router_js_namespaceObject.handleRSCRedirect)(headers, ctx.basename, status);
+    return new Response(null, {
+        status,
+        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 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);
+};
+exports.applyRouterSnapshotResult = __webpack_exports__.applyRouterSnapshotResult;
+exports.createLoaderRedirectResponse = __webpack_exports__.createLoaderRedirectResponse;
+exports.finalizeRenderResponse = __webpack_exports__.finalizeRenderResponse;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "applyRouterSnapshotResult",
+    "createLoaderRedirectResponse",
+    "finalizeRenderResponse"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -30,6 +30,8 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     ROUTER_CLEANUP_ERROR: ()=>ROUTER_CLEANUP_ERROR,
     createRouterCleanup: ()=>createRouterCleanup,
+    finishWithRouterCleanup: ()=>finishWithRouterCleanup,
+    runWithRouterCleanupOnError: ()=>runWithRouterCleanupOnError,
     withRouterCleanup: ()=>withRouterCleanup
 });
 const lifecycle_js_namespaceObject = require("../../router/runtime/lifecycle.js");
@@ -42,6 +44,21 @@ async function withRouterCleanup(runtimeContext, onError, callback) {
         if (!routerCleanup.deferred) await routerCleanup.run();
     }
 }
+async function runWithRouterCleanupOnError(routerCleanup, callback) {
+    try {
+        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();
+    }
+}
 function createRouterCleanup(runtimeContext, onError) {
     let deferred = false;
     let finished = false;
@@ -99,10 +116,14 @@ function createRouterCleanup(runtimeContext, onError) {
 }
 exports.ROUTER_CLEANUP_ERROR = __webpack_exports__.ROUTER_CLEANUP_ERROR;
 exports.createRouterCleanup = __webpack_exports__.createRouterCleanup;
+exports.finishWithRouterCleanup = __webpack_exports__.finishWithRouterCleanup;
+exports.runWithRouterCleanupOnError = __webpack_exports__.runWithRouterCleanupOnError;
 exports.withRouterCleanup = __webpack_exports__.withRouterCleanup;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "ROUTER_CLEANUP_ERROR",
     "createRouterCleanup",
+    "finishWithRouterCleanup",
+    "runWithRouterCleanupOnError",
     "withRouterCleanup"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

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

@@ -30,6 +30,7 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     createRouteHydrationScriptTags: ()=>createRouteHydrationScriptTags,
     getMatchedRouteAssets: ()=>getMatchedRouteAssets,
+    getMatchedRouteChunks: ()=>getMatchedRouteChunks,
     injectBeforeHydrationEntryScript: ()=>injectBeforeHydrationEntryScript,
     orderHydrationScriptChunks: ()=>orderHydrationScriptChunks,
     replaceChunkJsPlaceholder: ()=>replaceChunkJsPlaceholder
@@ -78,6 +79,10 @@ function getMatchedRouteAssets(runtimeContext, routeManifest) {
     const matchedRouteIds = (0, lifecycle_js_namespaceObject.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 = [];
@@ -108,23 +113,24 @@ function createRouteHydrationScriptTags(runtimeContext, entryName, options = {})
     const { nonce, template } = options;
     const routeAssets = getRouteAssets(runtimeContext);
     if (void 0 === routeAssets) return '';
-    const matchedRouteIds = (0, lifecycle_js_namespaceObject.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(' ');
 }
 exports.createRouteHydrationScriptTags = __webpack_exports__.createRouteHydrationScriptTags;
 exports.getMatchedRouteAssets = __webpack_exports__.getMatchedRouteAssets;
+exports.getMatchedRouteChunks = __webpack_exports__.getMatchedRouteChunks;
 exports.injectBeforeHydrationEntryScript = __webpack_exports__.injectBeforeHydrationEntryScript;
 exports.orderHydrationScriptChunks = __webpack_exports__.orderHydrationScriptChunks;
 exports.replaceChunkJsPlaceholder = __webpack_exports__.replaceChunkJsPlaceholder;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "createRouteHydrationScriptTags",
     "getMatchedRouteAssets",
+    "getMatchedRouteChunks",
     "injectBeforeHydrationEntryScript",
     "orderHydrationScriptChunks",
     "replaceChunkJsPlaceholder"

package/dist/cjs/core/server/string/loadable.js

@@ -28,8 +28,7 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    LoadableCollector: ()=>LoadableCollector,
-    orderHydrationScriptChunks: ()=>external_scriptOrder_js_namespaceObject.orderHydrationScriptChunks
+    LoadableCollector: ()=>LoadableCollector
 });
 const server_namespaceObject = require("@loadable/server");
 const external_federatedCss_js_namespaceObject = require("../federatedCss.js");
@@ -61,11 +60,6 @@ const readAsset = async (chunk)=>{
     return fs.readFile(filepath, 'utf-8');
 };
 class LoadableCollector {
-    getMatchedRouteChunks() {
-        const { routeManifest, runtimeContext } = this.options;
-        if (!routeManifest) return [];
-        return (0, external_scriptOrder_js_namespaceObject.getMatchedRouteAssets)(runtimeContext, routeManifest).map(routeAssetToChunk);
-    }
     collect(comopnent) {
         const { stats, entryName } = this.options;
         if (!stats) return comopnent;
@@ -87,7 +81,7 @@ class LoadableCollector {
             ]));
         } catch (e) {}
         const collectedChunks = extractor ? extractor.getChunkAssets(extractor.chunks) : [];
-        const matchedRouteChunks = this.getMatchedRouteChunks();
+        const matchedRouteChunks = (0, external_scriptOrder_js_namespaceObject.getMatchedRouteChunks)(options.runtimeContext, options.routeManifest, routeAssetToChunk);
         const orderedScriptChunks = (0, external_scriptOrder_js_namespaceObject.orderHydrationScriptChunks)({
             asyncEntryChunks: asyncChunks,
             collectedChunks,
@@ -166,10 +160,8 @@ class LoadableCollector {
     }
 }
 exports.LoadableCollector = __webpack_exports__.LoadableCollector;
-exports.orderHydrationScriptChunks = __webpack_exports__.orderHydrationScriptChunks;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "LoadableCollector",
-    "orderHydrationScriptChunks"
+    "LoadableCollector"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/cjs/router/cli/code/templates.js

@@ -227,7 +227,8 @@ const fileSystemRoutes = async ({ metaName, routes, ssrMode, nestedRoutesEntry,
             component = `component_${components.length - 1}`;
         }
         const isClientComponent = 'nested' === route.type && Boolean(route._component) && Boolean(srcDirectory) && Boolean(internalSrcAlias) && await hasUseClientDirective(route._component, srcDirectory, internalSrcAlias);
-        const shouldIncludeClientBundle = !isRscClientBundle || isClientComponent;
+        const shouldHydrateRscRoute = isRscClientBundle && !isClientComponent && !route.loader && !route.data;
+        const shouldIncludeClientBundle = !isRscClientBundle || isClientComponent || shouldHydrateRscRoute;
         const finalRoute = {
             ...route,
             loading,
@@ -330,7 +331,7 @@ const fileSystemRoutes = async ({ metaName, routes, ssrMode, nestedRoutesEntry,
     ${importLazyCode}
     ${!isRscClientBundle ? importComponentsCode : ''}
     ${importRuntimeRouterCode}
-    ${!isRscClientBundle ? rootLayoutCode : ''}
+    ${rootLayoutCode}
     ${importLoadingCode}
     ${importErrorComponentsCode}
     ${importLoadersCode}

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

@@ -76,7 +76,7 @@ function registerRouterProvider(name, factory, options = {}) {
 }
 function resolveRouterProvider(framework, options = {}) {
     const registry = getRegistry();
-    const name = framework || registry.defaultProvider || options.localDefault?.name;
+    const name = framework || options.localDefault?.name || registry.defaultProvider;
     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);

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;