@bleedingdev/modern-js-runtime 3.5.0-ultramodern.10 → 3.5.0-ultramodern.101

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

@@ -142,9 +142,20 @@ function BoundaryDebugger({ controlMode = 'visible', enabledByDefault = false, l
     ]);
     (0, external_react_namespaceObject.useEffect)(()=>{
         if (!enabled) return void setBoxes([]);
+        let resizeObserver;
+        const observedElements = new Set();
+        const observeBoundaryElements = (elements)=>{
+            if (void 0 === resizeObserver) return;
+            for (const element of elements)if (!observedElements.has(element)) {
+                observedElements.add(element);
+                resizeObserver.observe(element);
+            }
+        };
         const readBoxes = ()=>{
+            const elements = collectBoundaryElements(legacySelector);
+            observeBoundaryElements(elements);
             const seenBoxes = new Set();
-            const nextBoxes = collectBoundaryElements(legacySelector).map((element)=>{
+            const nextBoxes = elements.map((element)=>{
                 const boundaryId = getBoundaryId(element);
                 if (void 0 === boundaryId || '' === boundaryId) return;
                 const rect = element.getBoundingClientRect();
@@ -172,9 +183,8 @@ function BoundaryDebugger({ controlMode = 'visible', enabledByDefault = false, l
             }).filter((box)=>void 0 !== box);
             setBoxes(nextBoxes);
         };
+        resizeObserver = "u" < typeof ResizeObserver ? void 0 : new ResizeObserver(readBoxes);
         readBoxes();
-        const resizeObserver = "u" < typeof ResizeObserver ? void 0 : new ResizeObserver(readBoxes);
-        for (const element of collectBoundaryElements(legacySelector))resizeObserver?.observe(element);
         const mutationObserver = new MutationObserver(readBoxes);
         mutationObserver.observe(document.body, {
             childList: true,

package/dist/cjs/cli/index.js

@@ -112,12 +112,10 @@ const runtimePlugin = (params)=>({
             });
             api.config(()=>{
                 const { appDirectory, metaName } = api.getAppContext();
-                const isReact18 = (0, utils_namespaceObject.isReact18)(appDirectory);
-                process.env.IS_REACT18 = isReact18.toString();
                 return {
                     source: {
                         globalVars: {
-                            'process.env.IS_REACT18': process.env.IS_REACT18
+                            'process.env.IS_REACT18': 'true'
                         },
                         include: [
                             new RegExp(`[\\\\/]node_modules[\\\\/]@${metaName}[\\\\/]runtime[\\\\/].*[\\\\/]head\\.`)
@@ -126,14 +124,6 @@ const runtimePlugin = (params)=>({
                     tools: {
                         bundlerChain: (chain)=>{
                             chain.module.rule('modern-entry').test(/\.jsx?$/).include.add(external_path_default().resolve(appDirectory, 'node_modules', `.${metaName}`)).end().sideEffects(true);
-                        },
-                        rspack: (_config, { appendPlugins, rspack })=>{
-                            if (!isReact18) appendPlugins([
-                                new rspack.IgnorePlugin({
-                                    resourceRegExp: /^react-dom\/client$/,
-                                    contextRegExp: /@modern-js\/runtime/
-                                })
-                            ]);
                         }
                     }
                 };

package/dist/cjs/cli/registry.js

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/cli/ssr/index.js

@@ -129,14 +129,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;
@@ -150,6 +149,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((0, utils_namespaceObject.isUseSSRBundle)(userConfig)),
+                            'process.env.MODERN_ENABLE_RSC': JSON.stringify(Boolean(userConfig.server?.rsc)),
                             'process.env.MODERN_MF_APP_SSR': JSON.stringify(isModuleFederationAppSSR)
                         }
                     },

package/dist/cjs/cli/ssr/loadable-bundler-plugin.js

@@ -43,6 +43,7 @@ const utils_namespaceObject = require("@modern-js/utils");
 const external_path_namespaceObject = require("path");
 var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
 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)
@@ -50,7 +51,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,
@@ -110,10 +115,9 @@ class LoadablePlugin {
         const outputFile = external_path_default().resolve(outputFolder || '', this.opts.filename);
         utils_namespaceObject.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/cjs/core/browser/hydrate.js

@@ -29,14 +29,26 @@ var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     hydrateRoot: ()=>hydrateRoot,
+    hydrateWithReact: ()=>hydrateWithReact,
     isReact18: ()=>isReact18
 });
 const jsx_runtime_namespaceObject = require("react/jsx-runtime");
 const component_namespaceObject = require("@loadable/component");
+const constants_namespaceObject = require("@modern-js/utils/universal/constants");
+const client_namespaceObject = require("react-dom/client");
 const external_constants_js_namespaceObject = require("../constants.js");
 const wrapper_js_namespaceObject = require("../react/wrapper.js");
 const external_withCallback_js_namespaceObject = require("./withCallback.js");
 const isReact18 = ()=>'true' === process.env.IS_REACT18;
+const runtimeProcess = Reflect.get(globalThis, 'process');
+const loadableReadyOptions = {
+    chunkLoadingGlobal: runtimeProcess?.env?.MODERN_CHUNK_LOADING_GLOBAL || '__LOADABLE_LOADED_CHUNKS__'
+};
+async function hydrateWithReact(App, rootElement) {
+    return (0, client_namespaceObject.hydrateRoot)(rootElement, App, {
+        identifierPrefix: constants_namespaceObject.SSR_HYDRATION_ID_PREFIX
+    });
+}
 function hydrateRoot(App, context, ModernRender, ModernHydrate) {
     const hydrateContext = {
         ...context,
@@ -73,21 +85,23 @@ function hydrateRoot(App, context, ModernRender, ModernHydrate) {
                 ModernHydrate((0, wrapper_js_namespaceObject.wrapRuntimeContextProvider)(/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(SSRApp, {}), hydrateContext)).then((root)=>{
                     resolve(root);
                 });
-            });
+            }, loadableReadyOptions);
             else (0, component_namespaceObject.loadableReady)(()=>{
                 ModernHydrate((0, wrapper_js_namespaceObject.wrapRuntimeContextProvider)(App, hydrateContext), callback).then((root)=>{
                     resolve(root);
                 });
-            });
+            }, loadableReadyOptions);
         });
         console.warn(`unknow render level: ${renderLevel}, execute render()`);
         return ModernRender((0, wrapper_js_namespaceObject.wrapRuntimeContextProvider)(App, context));
     }
 }
 exports.hydrateRoot = __webpack_exports__.hydrateRoot;
+exports.hydrateWithReact = __webpack_exports__.hydrateWithReact;
 exports.isReact18 = __webpack_exports__.isReact18;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "hydrateRoot",
+    "hydrateWithReact",
     "isReact18"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

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

@@ -28,14 +28,15 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
+    createNestedAppRenderer: ()=>createNestedAppRenderer,
+    hydrateWithReact: ()=>external_hydrate_js_namespaceObject.hydrateWithReact,
     hydrateWithReact17: ()=>hydrateWithReact17,
-    hydrateWithReact18: ()=>hydrateWithReact18,
     render: ()=>render,
     renderWithReact17: ()=>renderWithReact17,
     renderWithReact18: ()=>renderWithReact18
 });
-const constants_namespaceObject = require("@modern-js/utils/universal/constants");
 const external_cookie_namespaceObject = require("cookie");
+const client_namespaceObject = require("react-dom/client");
 const index_js_namespaceObject = require("../context/index.js");
 const runtime_js_namespaceObject = require("../context/runtime.js");
 const wrapper_js_namespaceObject = require("../react/wrapper.js");
@@ -83,10 +84,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 = (0, runtime_js_namespaceObject.getInitialContext)();
     const runBeforeRender = async (context)=>{
-        const internalRuntimeContext = (0, index_js_namespaceObject.getGlobalInternalRuntimeContext)();
         const api = internalRuntimeContext.pluginAPI;
         api.updateRuntimeContext(context);
         const hooks = internalRuntimeContext.hooks;
@@ -106,17 +106,23 @@ async function render(App, id) {
             return renderFunc(App, rootElement);
         }
         async function ModernHydrate(App, callback) {
-            const hydrateFunc = IS_REACT18 ? hydrateWithReact18 : hydrateWithReact17;
-            return hydrateFunc(App, rootElement, callback);
+            if (IS_REACT18) return (0, external_hydrate_js_namespaceObject.hydrateWithReact)(App, rootElement);
+            return hydrateWithReact17(App, rootElement, callback);
         }
-        if (window._SSR_DATA) return (0, external_hydrate_js_namespaceObject.hydrateRoot)(App, context, ModernRender, ModernHydrate);
+        if (hydrateFromSsrData && process.env.MODERN_ENABLE_HYDRATION && window._SSR_DATA) return (0, external_hydrate_js_namespaceObject.hydrateRoot)(App, context, ModernRender, ModernHydrate);
         return ModernRender((0, wrapper_js_namespaceObject.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, (0, index_js_namespaceObject.getGlobalInternalRuntimeContext)());
+}
+function createNestedAppRenderer() {
+    const internalRuntimeContext = (0, index_js_namespaceObject.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);
+    const root = (0, client_namespaceObject.createRoot)(rootElement);
     root.render(App);
     return root;
 }
@@ -125,26 +131,21 @@ async function renderWithReact17(App, rootElement) {
     ReactDOM.render(App, rootElement);
     return rootElement;
 }
-async function hydrateWithReact18(App, rootElement) {
-    const ReactDOM = await import("react-dom/client");
-    const root = ReactDOM.hydrateRoot(rootElement, App, {
-        identifierPrefix: constants_namespaceObject.SSR_HYDRATION_ID_PREFIX
-    });
-    return root;
-}
 async function hydrateWithReact17(App, rootElement, callback) {
     const ReactDOM = await import("react-dom");
     const root = ReactDOM.hydrate(App, rootElement, callback);
     return root;
 }
+exports.createNestedAppRenderer = __webpack_exports__.createNestedAppRenderer;
+exports.hydrateWithReact = __webpack_exports__.hydrateWithReact;
 exports.hydrateWithReact17 = __webpack_exports__.hydrateWithReact17;
-exports.hydrateWithReact18 = __webpack_exports__.hydrateWithReact18;
 exports.render = __webpack_exports__.render;
 exports.renderWithReact17 = __webpack_exports__.renderWithReact17;
 exports.renderWithReact18 = __webpack_exports__.renderWithReact18;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createNestedAppRenderer",
+    "hydrateWithReact",
     "hydrateWithReact17",
-    "hydrateWithReact18",
     "render",
     "renderWithReact17",
     "renderWithReact18"

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

@@ -34,6 +34,7 @@ __webpack_require__.d(__webpack_exports__, {
     applyRouterRuntimeState: ()=>lifecycle_js_namespaceObject.applyRouterRuntimeState,
     applyRouterServerPrepareResult: ()=>lifecycle_js_namespaceObject.applyRouterServerPrepareResult,
     cleanupRouterRuntimeState: ()=>lifecycle_js_namespaceObject.cleanupRouterRuntimeState,
+    createRouterProviderRealm: ()=>provider_js_namespaceObject.createRouterProviderRealm,
     createRouterRuntimeState: ()=>lifecycle_js_namespaceObject.createRouterRuntimeState,
     createRouterServerSnapshot: ()=>lifecycle_js_namespaceObject.createRouterServerSnapshot,
     createRuntimeContextExtension: ()=>external_extensions_js_namespaceObject.createRuntimeContextExtension,
@@ -120,6 +121,7 @@ exports.RuntimeContext = __webpack_exports__.RuntimeContext;
 exports.applyRouterRuntimeState = __webpack_exports__.applyRouterRuntimeState;
 exports.applyRouterServerPrepareResult = __webpack_exports__.applyRouterServerPrepareResult;
 exports.cleanupRouterRuntimeState = __webpack_exports__.cleanupRouterRuntimeState;
+exports.createRouterProviderRealm = __webpack_exports__.createRouterProviderRealm;
 exports.createRouterRuntimeState = __webpack_exports__.createRouterRuntimeState;
 exports.createRouterServerSnapshot = __webpack_exports__.createRouterServerSnapshot;
 exports.createRuntimeContextExtension = __webpack_exports__.createRuntimeContextExtension;
@@ -157,6 +159,7 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "applyRouterRuntimeState",
     "applyRouterServerPrepareResult",
     "cleanupRouterRuntimeState",
+    "createRouterProviderRealm",
     "createRouterRuntimeState",
     "createRouterServerSnapshot",
     "createRuntimeContextExtension",

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

@@ -0,0 +1,49 @@
+"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__, {
+    ReactRuntimeContext: ()=>ReactRuntimeContext,
+    RuntimeContext: ()=>RuntimeContext,
+    useRuntimeContext: ()=>useRuntimeContext
+});
+const external_react_namespaceObject = require("react");
+const RuntimeContext = (0, external_react_namespaceObject.createContext)({});
+const ReactRuntimeContext = RuntimeContext;
+const useRuntimeContext = ()=>(0, external_react_namespaceObject.useContext)(RuntimeContext);
+exports.ReactRuntimeContext = __webpack_exports__.ReactRuntimeContext;
+exports.RuntimeContext = __webpack_exports__.RuntimeContext;
+exports.useRuntimeContext = __webpack_exports__.useRuntimeContext;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ReactRuntimeContext",
+    "RuntimeContext",
+    "useRuntimeContext"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -29,16 +29,15 @@ var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     InternalRuntimeContext: ()=>InternalRuntimeContext,
-    ReactRuntimeContext: ()=>ReactRuntimeContext,
-    RuntimeContext: ()=>RuntimeContext,
+    ReactRuntimeContext: ()=>external_public_js_namespaceObject.ReactRuntimeContext,
+    RuntimeContext: ()=>external_public_js_namespaceObject.RuntimeContext,
     getInitialContext: ()=>getInitialContext,
-    useRuntimeContext: ()=>useRuntimeContext
+    useRuntimeContext: ()=>external_public_js_namespaceObject.useRuntimeContext
 });
-const constants_namespaceObject = require("@modern-js/utils/universal/constants");
 const external_react_namespaceObject = require("react");
+const external_public_js_namespaceObject = require("./public.js");
+const ROUTE_MANIFEST = '_MODERNJS_ROUTE_MANIFEST';
 const InternalRuntimeContext = (0, external_react_namespaceObject.createContext)({});
-const RuntimeContext = (0, external_react_namespaceObject.createContext)({});
-const ReactRuntimeContext = RuntimeContext;
 const getInitialContext = (isBrowser = true, routeManifest)=>{
     const requestContext = {
         request: {},
@@ -46,12 +45,11 @@ const getInitialContext = (isBrowser = true, routeManifest)=>{
     };
     return {
         isBrowser,
-        routeManifest: routeManifest || "u" > typeof window && window[constants_namespaceObject.ROUTE_MANIFEST],
+        routeManifest: routeManifest || "u" > typeof window && window[ROUTE_MANIFEST],
         requestContext,
         context: requestContext
     };
 };
-const useRuntimeContext = ()=>(0, external_react_namespaceObject.useContext)(RuntimeContext);
 exports.InternalRuntimeContext = __webpack_exports__.InternalRuntimeContext;
 exports.ReactRuntimeContext = __webpack_exports__.ReactRuntimeContext;
 exports.RuntimeContext = __webpack_exports__.RuntimeContext;

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;