@bleedingdev/modern-js-runtime 3.5.0-ultramodern.102 → 3.5.0-ultramodern.103

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

@@ -151,6 +151,7 @@ const ssrBuilderPlugin = (modernAPI, outputModule, exportLoadablePath)=>({
                             '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)),
+                            __MODERN_ENABLE_RSC__: JSON.stringify(Boolean(userConfig.server?.rsc)),
                             'process.env.MODERN_MF_APP_SSR': JSON.stringify(isModuleFederationAppSSR)
                         }
                     },

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

@@ -29,8 +29,7 @@ var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     hydrateRoot: ()=>hydrateRoot,
-    hydrateWithReact: ()=>hydrateWithReact,
-    isReact18: ()=>isReact18
+    hydrateWithReact: ()=>hydrateWithReact
 });
 const jsx_runtime_namespaceObject = require("react/jsx-runtime");
 const component_namespaceObject = require("@loadable/component");
@@ -39,15 +38,23 @@ 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 runtimeEnvironment = null !== runtimeProcess && 'object' == typeof runtimeProcess ? Reflect.get(runtimeProcess, 'env') : void 0;
+const readRuntimeEnvironment = (name)=>{
+    if (null === runtimeEnvironment || 'object' != typeof runtimeEnvironment) return;
+    const value = Reflect.get(runtimeEnvironment, name);
+    return 'string' == typeof value ? value : void 0;
+};
 const loadableReadyOptions = {
-    chunkLoadingGlobal: runtimeProcess?.env?.MODERN_CHUNK_LOADING_GLOBAL || '__LOADABLE_LOADED_CHUNKS__'
+    chunkLoadingGlobal: (()=>{
+        const configured = readRuntimeEnvironment('MODERN_CHUNK_LOADING_GLOBAL');
+        return void 0 === configured || '' === configured ? '__LOADABLE_LOADED_CHUNKS__' : configured;
+    })()
 };
-async function hydrateWithReact(App, rootElement) {
-    return (0, client_namespaceObject.hydrateRoot)(rootElement, App, {
+function hydrateWithReact(App, rootElement) {
+    return Promise.resolve((0, client_namespaceObject.hydrateRoot)(rootElement, App, {
         identifierPrefix: constants_namespaceObject.SSR_HYDRATION_ID_PREFIX
-    });
+    }));
 }
 function hydrateRoot(App, context, ModernRender, ModernHydrate) {
     const hydrateContext = {
@@ -60,9 +67,9 @@ function hydrateRoot(App, context, ModernRender, ModernHydrate) {
     const callback = ()=>{
         delete hydrateContext._hydration;
     };
-    const renderLevel = window?._SSR_DATA?.renderLevel || external_constants_js_namespaceObject.RenderLevel.CLIENT_RENDER;
-    const renderMode = window?._SSR_DATA?.mode || 'string';
-    if (isReact18() && 'stream' === renderMode) return streamSSRHydrate();
+    const renderLevel = window?._SSR_DATA?.renderLevel ?? external_constants_js_namespaceObject.RenderLevel.CLIENT_RENDER;
+    const renderMode = window?._SSR_DATA?.mode ?? 'string';
+    if ('stream' === renderMode) return streamSSRHydrate();
     function streamSSRHydrate() {
         if (renderLevel !== external_constants_js_namespaceObject.RenderLevel.SERVER_RENDER) return ModernRender((0, wrapper_js_namespaceObject.wrapRuntimeContextProvider)(App, context));
         {
@@ -76,33 +83,30 @@ function hydrateRoot(App, context, ModernRender, ModernHydrate) {
     return stringSSRHydrate();
     function stringSSRHydrate() {
         if (renderLevel === external_constants_js_namespaceObject.RenderLevel.CLIENT_RENDER) return ModernRender((0, wrapper_js_namespaceObject.wrapRuntimeContextProvider)(App, context));
-        if (renderLevel === external_constants_js_namespaceObject.RenderLevel.SERVER_RENDER) return new Promise((resolve)=>{
-            if (isReact18()) (0, component_namespaceObject.loadableReady)(()=>{
+        {
+            if (renderLevel === external_constants_js_namespaceObject.RenderLevel.SERVER_RENDER) return (0, component_namespaceObject.loadableReady)(()=>void 0, loadableReadyOptions).then(()=>{
                 const SSRApp = ()=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_withCallback_js_namespaceObject.WithCallback, {
                         callback: callback,
                         children: App
                     });
-                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));
+                return ModernHydrate((0, wrapper_js_namespaceObject.wrapRuntimeContextProvider)(/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(SSRApp, {}), hydrateContext));
+            });
+            const runtimeConsole = Reflect.get(globalThis, 'console');
+            if (null !== runtimeConsole && 'object' == typeof runtimeConsole) {
+                const warn = Reflect.get(runtimeConsole, 'warn');
+                if ('function' == typeof warn) Reflect.apply(warn, runtimeConsole, [
+                    `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"
+    "hydrateWithReact"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

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

@@ -35,39 +35,34 @@ 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;
+function createRscSafeRequestContext(ssrContext) {
+    if (void 0 === ssrContext) return {
+        request: {},
+        response: {
+            locals: {}
+        }
+    };
+    const { request, response } = ssrContext;
     return {
-        nonce: ssrContext.nonce,
-        useJsonScript: ssrContext.useJsonScript,
-        htmlModifiers: [],
-        baseUrl: ssrContext.baseUrl,
-        request: 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),
+            query: {
+                ...request.query
+            },
+            params: {
+                ...request.params
+            },
+            headers: {
+                ...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 || {}
+            locals: response.locals ?? {}
         }
     };
 }
@@ -83,14 +78,14 @@ function wrapRuntimeContextProvider(App, contextValue) {
         ...rest
     };
     (0, extensions_js_namespaceObject.stripRuntimeContextExtensions)(runtimeContextValue);
-    if ((0, index_js_namespaceObject.getGlobalEnableRsc)() && !isBrowser) {
+    if (true === (0, index_js_namespaceObject.getGlobalEnableRsc)() && false === isBrowser) {
         const rscSafeRequestContext = createRscSafeRequestContext(ssrContext);
         const rscInternalContextValue = {
             ...internalContextValue,
             context: rscSafeRequestContext,
-            requestContext: rscSafeRequestContext,
-            ssrContext: createRscSafeSsrContext(ssrContext)
+            requestContext: rscSafeRequestContext
         };
+        delete rscInternalContextValue.ssrContext;
         const rscRuntimeContextValue = {
             ...runtimeContextValue,
             context: rscSafeRequestContext,

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

@@ -33,12 +33,12 @@ __webpack_require__.d(__webpack_exports__, {
     finalizeRenderResponse: ()=>finalizeRenderResponse
 });
 const lifecycle_js_namespaceObject = require("../../router/runtime/lifecycle.js");
-const rsc_router_js_namespaceObject = require("../../router/runtime/rsc-router.js");
+const redirect_js_namespaceObject = require("../../router/runtime/redirect.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);
+    if (ctx.enableRsc && ctx.isRSCNavigation) return (0, redirect_js_namespaceObject.handleRSCRedirect)(headers, ctx.basename, status);
     return new Response(null, {
         status,
         headers
@@ -47,12 +47,12 @@ const processRedirect = (headers, status, ctx)=>{
 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);
+    if (void 0 !== routerStatusCode && 0 !== routerStatusCode && !Number.isNaN(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 (void 0 === beforeRenderResult || !isRedirectStatus(beforeRenderResult.status)) return;
     if (beforeRenderResult.headers.has('X-Modernjs-Redirect')) return beforeRenderResult;
     const redirectUrl = beforeRenderResult.headers.get('Location') || '/';
     return processRedirect(new Headers({
@@ -60,7 +60,7 @@ const createLoaderRedirectResponse = (beforeRenderResult, redirectCtx)=>{
     }), 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);
+    if (-1 !== responseProxy.status && isRedirectStatus(responseProxy.status) && void 0 !== responseProxy.headers.Location && '' !== responseProxy.headers.Location) return processRedirect(new Headers(responseProxy.headers), responseProxy.status, redirectCtx);
     Object.entries(responseProxy.headers).forEach(([key, value])=>{
         response.headers.set(key, value);
     });

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

@@ -79,7 +79,7 @@ function getMatchedRouteAssets(runtimeContext, routeManifest) {
     return matchedRouteIds.flatMap((routeId)=>routeAssets[routeId]?.assets ?? []);
 }
 function getMatchedRouteChunks(runtimeContext, routeManifest, routeAssetToChunk) {
-    if (!routeManifest) return [];
+    if (void 0 === routeManifest) return [];
     return getMatchedRouteAssets(runtimeContext, routeManifest).map(routeAssetToChunk);
 }
 const orderHydrationScriptChunks = ({ asyncEntryChunks, collectedChunks, matchedRouteChunks, entryName })=>{

package/dist/cjs/core/server/stream/beforeTemplate.worker.js

@@ -30,7 +30,6 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     buildShellBeforeTemplate: ()=>buildShellBeforeTemplate
 });
-const router_namespaceObject = require("@modern-js/runtime-utils/router");
 const lifecycle_js_namespaceObject = require("../../../router/runtime/lifecycle.js");
 const external_constants_js_namespaceObject = require("../constants.js");
 const external_federatedCss_js_namespaceObject = require("../federatedCss.js");
@@ -59,20 +58,12 @@ async function buildShellBeforeTemplate(beforeAppTemplate, options) {
         });
         return (0, external_utils_js_namespaceObject.safeReplace)(template, external_constants_js_namespaceObject.CHUNK_CSS_PLACEHOLDER, css);
         async function getCssChunks() {
-            const { routeManifest, routerContext, routes } = runtimeContext;
+            const { routeManifest } = runtimeContext;
             const routeAssets = routeManifest?.routeAssets;
             if (!routeAssets) return '';
             let matchedRouteManifests = [];
             const matchedRouteIds = (0, lifecycle_js_namespaceObject.getRouterMatchedRouteIds)(runtimeContext);
             if (matchedRouteIds?.length) matchedRouteManifests = matchedRouteIds.map((routeId)=>routeAssets[routeId]).filter(Boolean);
-            else if (routerContext && routes) {
-                const matches = (0, router_namespaceObject.matchRoutes)(routes, routerContext.location, routerContext.basename);
-                matchedRouteManifests = matches?.map((match, index)=>{
-                    if (!index) return;
-                    const routeId = match.route.id;
-                    if (routeId) return routeAssets[routeId];
-                }).filter((routeManifest)=>void 0 !== routeManifest) ?? [];
-            }
             const asyncEntry = routeAssets[`async-${entryName}`];
             if (asyncEntry) matchedRouteManifests.push(asyncEntry);
             const cssChunks = matchedRouteManifests.reduce((chunks, routeManifest)=>{

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

@@ -36,7 +36,7 @@ __webpack_require__.d(__webpack_exports__, {
     safeReplace: ()=>safeReplace,
     serializeErrors: ()=>serializeErrors
 });
-const router_namespaceObject = require("@modern-js/runtime-utils/router");
+const routerHelper_js_namespaceObject = require("../../router/runtime/routerHelper.js");
 function attributesToString(attributes) {
     return Object.entries(attributes).reduce((str, [key, value])=>void 0 === value ? str : `${str} ${key}="${value}"`, '');
 }
@@ -50,7 +50,7 @@ function serializeErrors(errors) {
     if (!errors) return null;
     const entries = Object.entries(errors);
     const serialized = {};
-    for (const [key, val] of entries)if ((0, router_namespaceObject.isRouteErrorResponse)(val)) serialized[key] = serializeRouteErrorResponse(val);
+    for (const [key, val] of entries)if ((0, routerHelper_js_namespaceObject.isRouteErrorResponse)(val)) serialized[key] = serializeRouteErrorResponse(val);
     else if (val instanceof Error) serialized[key] = serializeError(val);
     else serialized[key] = val;
     return serialized;
@@ -71,7 +71,7 @@ function serializeError(error) {
     };
 }
 function serializeRouteErrorResponse(error) {
-    if (!(0, router_namespaceObject.isRouteErrorResponse)(error)) return error;
+    if (!(0, routerHelper_js_namespaceObject.isRouteErrorResponse)(error)) return error;
     if (error.status >= 500 && shouldRedactServerError()) return {
         status: error.status,
         statusText: 'Internal Server Error',

package/dist/cjs/module-federation/distributed-ssr.js

@@ -44,24 +44,24 @@ function distributedSsrFragmentKey(remote, expose) {
 }
 function getDistributedSsrFragmentContext(response) {
     const locals = response?.locals;
-    if (!locals || 'object' != typeof locals) return;
-    const context = locals[DISTRIBUTED_SSR_FRAGMENTS_LOCALS_KEY];
-    if (!context || 'object' != typeof context) return;
+    if ('object' != typeof locals || null === locals) return;
+    const context = DISTRIBUTED_SSR_FRAGMENTS_LOCALS_KEY in locals ? locals[DISTRIBUTED_SSR_FRAGMENTS_LOCALS_KEY] : void 0;
+    if ('object' != typeof context || null === context) return;
     return context;
 }
 function useDistributedSsrFragmentProps({ boundaryId, expose }) {
     const runtimeContext = (0, runtime_js_namespaceObject.useRuntimeContext)();
     const locals = runtimeContext.requestContext?.response?.locals;
-    const request = locals && 'object' == typeof locals ? locals[DISTRIBUTED_SSR_FRAGMENT_REQUEST_LOCALS_KEY] : void 0;
-    if (!request || 'object' != typeof request || request.boundaryId !== boundaryId || request.expose !== expose) throw new Error(`Distributed SSR fragment request contract mismatch for ${boundaryId} ${expose}.`);
-    const props = request.props;
-    if (!props || 'object' != typeof props || Array.isArray(props)) throw new Error(`Distributed SSR fragment request props must be an object for ${boundaryId} ${expose}.`);
+    const request = 'object' == typeof locals && null !== locals && DISTRIBUTED_SSR_FRAGMENT_REQUEST_LOCALS_KEY in locals ? locals[DISTRIBUTED_SSR_FRAGMENT_REQUEST_LOCALS_KEY] : void 0;
+    if ('object' != typeof request || null === request || !('boundaryId' in request) || request.boundaryId !== boundaryId || !('expose' in request) || request.expose !== expose) throw new Error(`Distributed SSR fragment request contract mismatch for ${boundaryId} ${expose}.`);
+    const props = 'props' in request ? request.props : void 0;
+    if ('object' != typeof props || null === props || Array.isArray(props)) throw new Error(`Distributed SSR fragment request props must be an object for ${boundaryId} ${expose}.`);
     return props;
 }
 function isThenable(value) {
-    return 'function' == typeof value.then;
+    return void 0 !== value && 'then' in value && 'function' == typeof value.then;
 }
-function DistributedSsrBoundary({ children, expose, fallback, fragmentProps = {}, remote }) {
+function DistributedSsrBoundary({ children, expose, fallback, fragmentProps, remote }) {
     const runtimeContext = (0, runtime_js_namespaceObject.useRuntimeContext)();
     const key = distributedSsrFragmentKey(remote, expose);
     const attributes = {
@@ -72,12 +72,13 @@ function DistributedSsrBoundary({ children, expose, fallback, fragmentProps = {}
         children: children
     });
     const fragmentContext = getDistributedSsrFragmentContext(runtimeContext.requestContext?.response);
-    if (!fragmentContext) return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("div", {
+    if (void 0 === fragmentContext) return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("div", {
         ...attributes,
         children: children
     });
-    const fragmentOrPromise = fragmentContext.resolve?.(remote, expose, fragmentProps) ?? fragmentContext.fragments?.[key];
-    if (fragmentOrPromise && isThenable(fragmentOrPromise)) throw fragmentOrPromise;
+    const resolverFragmentProps = void 0 === fragmentProps ? {} : Object.fromEntries(Object.entries(fragmentProps));
+    const fragmentOrPromise = fragmentContext.resolve?.(remote, expose, resolverFragmentProps) ?? fragmentContext.fragments?.[key];
+    if (isThenable(fragmentOrPromise)) throw fragmentOrPromise;
     const fragment = fragmentOrPromise;
     if (fragment?.status === 'ready') return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("div", {
         ...attributes,

package/dist/cjs/module-federation/last-known-good.js

@@ -67,7 +67,7 @@ function staleRecordResult(ref, env, ageMs, maxStaleMs) {
 }
 function createLastKnownGoodProvider(options) {
     const storage = options.storage ?? createInMemoryLkgStorage();
-    const now = options.now ?? (()=>Date.now());
+    const now = options.now ?? (()=>Math.floor(performance.timeOrigin + performance.now()));
     const maxStaleMs = options.freshness?.maxStaleMs;
     async function serveFromCache(ref, env, fallback) {
         const key = (0, external_surface_resolution_types_js_namespaceObject.deliveryUnitResolutionKey)(ref.unitId, env);

package/dist/cjs/module-federation/manifest-recovery-runtime-plugin.js

@@ -27,6 +27,11 @@ var __webpack_require__ = {};
 })();
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createModuleFederationManifestRecoveryPlugin: ()=>createModuleFederationManifestRecoveryPlugin,
+    default: ()=>manifest_recovery_runtime_plugin
+});
+const universal_namespaceObject = require("@modern-js/utils/universal");
 const DEFAULT_ATTEMPTS = 3;
 const DEFAULT_RETRY_DELAY_MS = 100;
 const DEFAULT_TIMEOUT_MS = 1000;
@@ -72,7 +77,7 @@ const isRetryableError = (error)=>{
     return error instanceof TypeError || /(?:fetch failed|network|ECONNREFUSED|ECONNRESET|ETIMEDOUT|EAI_AGAIN)/i.test(message);
 };
 const isHttpManifestUrl = (id)=>{
-    if (!id) return false;
+    if (void 0 === id || 0 === id.length) return false;
     try {
         const url = new URL(id);
         return ('http:' === url.protocol || 'https:' === url.protocol) && url.pathname.endsWith('.json');
@@ -80,55 +85,39 @@ const isHttpManifestUrl = (id)=>{
         return false;
     }
 };
-const defaultWait = (milliseconds)=>new Promise((resolve)=>{
-        setTimeout(resolve, milliseconds);
+const defaultWait = (milliseconds)=>(0, universal_namespaceObject.wait)(milliseconds).then(()=>void 0);
+const fetchWithTimeout = (fetchImpl, url, timeoutMs)=>fetchImpl(url, {
+        signal: AbortSignal.timeout(timeoutMs)
     });
-const fetchWithTimeout = async (fetchImpl, url, timeoutMs)=>{
-    const controller = new AbortController();
-    const timeout = setTimeout(()=>controller.abort(), timeoutMs);
-    try {
-        return await fetchImpl(url, {
-            signal: controller.signal
-        });
-    } finally{
-        clearTimeout(timeout);
-    }
-};
 const createModuleFederationManifestRecoveryPlugin = (options = {})=>{
     const attempts = clampInteger(options.attempts, DEFAULT_ATTEMPTS, 1, MAX_ATTEMPTS);
     const retryDelayMs = clampInteger(options.retryDelayMs, DEFAULT_RETRY_DELAY_MS, 0, MAX_RETRY_DELAY_MS);
     const timeoutMs = clampInteger(options.timeoutMs, DEFAULT_TIMEOUT_MS, 1, MAX_TIMEOUT_MS);
     const fetchImpl = options.fetchImpl ?? globalThis.fetch;
     const waitImpl = options.waitImpl ?? defaultWait;
+    const recoverManifest = (url, attempt)=>{
+        const fetchManifest = ()=>Promise.resolve().then(()=>fetchWithTimeout(fetchImpl, url, timeoutMs)).then((response)=>{
+                if (!response.ok) {
+                    if (!RETRYABLE_HTTP_STATUSES.has(response.status) || attempt === attempts - 1) return;
+                    return recoverManifest(url, attempt + 1);
+                }
+                return Promise.resolve().then(()=>response.json()).then((manifest)=>manifest, ()=>void 0);
+            }, (error)=>{
+                if (!isRetryableError(error) || attempt === attempts - 1) return;
+                return recoverManifest(url, attempt + 1);
+            });
+        if (attempt > 0 && retryDelayMs > 0) return waitImpl(retryDelayMs).then(fetchManifest);
+        return fetchManifest();
+    };
     return {
         name: 'modern-js-manifest-recovery-plugin',
-        async errorLoadRemote (args) {
-            if ('afterResolve' !== args.lifecycle || !isHttpManifestUrl(args.id) || !isRetryableError(args.error) || 'function' != typeof fetchImpl) return;
-            for(let attempt = 0; attempt < attempts; attempt++){
-                if (attempt > 0 && retryDelayMs > 0) await waitImpl(retryDelayMs);
-                try {
-                    const response = await fetchWithTimeout(fetchImpl, args.id, timeoutMs);
-                    if (!response.ok) {
-                        if (!RETRYABLE_HTTP_STATUSES.has(response.status) || attempt === attempts - 1) return;
-                        continue;
-                    }
-                    try {
-                        return await response.json();
-                    } catch  {
-                        break;
-                    }
-                } catch (error) {
-                    if (!isRetryableError(error) || attempt === attempts - 1) break;
-                }
-            }
+        errorLoadRemote (args) {
+            if ('afterResolve' !== args.lifecycle || !isHttpManifestUrl(args.id) || !isRetryableError(args.error) || 'function' != typeof fetchImpl) return Promise.resolve(void 0);
+            return recoverManifest(args.id, 0);
         }
     };
 };
-const __rspack_default_export = createModuleFederationManifestRecoveryPlugin;
-__webpack_require__.d(__webpack_exports__, {}, {
-    createModuleFederationManifestRecoveryPlugin: createModuleFederationManifestRecoveryPlugin,
-    default: __rspack_default_export
-});
+const manifest_recovery_runtime_plugin = createModuleFederationManifestRecoveryPlugin;
 exports.createModuleFederationManifestRecoveryPlugin = __webpack_exports__.createModuleFederationManifestRecoveryPlugin;
 exports["default"] = __webpack_exports__["default"];
 for(var __rspack_i in __webpack_exports__)if (-1 === [

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

@@ -86,6 +86,7 @@ async function generateRoutesForEntry(entrypoint, appContext) {
 }
 const generateCode = async (appContext, config, entrypoints, api, options = {})=>{
     const { internalDirectory, srcDirectory, internalSrcAlias, packageName } = appContext;
+    const includeRouteServerLoadersInSsrEntry = false !== options.includeRouteServerLoadersInSsrEntry || !(0, utils_namespaceObject.isUseRsc)(config);
     const hooks = api.getHooks();
     const generatedRoutesByEntry = {};
     const eagerRouteComponentFilesByEntry = new Map();
@@ -151,12 +152,14 @@ const generateCode = async (appContext, config, entrypoints, api, options = {})=
                 if (entrypoint.nestedRoutesEntry && ((0, utils_namespaceObject.isUseSSRBundle)(config) || (0, utils_namespaceObject.isUseRsc)(config))) {
                     const routesServerFile = (0, external_utils_js_namespaceObject.getServerLoadersFile)(internalDirectory, entryName);
                     const filtedRoutesForServer = (0, utils_namespaceObject.filterRoutesForServer)(routes);
-                    const routesForServerLoaderMatches = (0, utils_namespaceObject.filterRoutesLoader)(routes);
-                    const code = external_templates_js_namespaceObject.routesForServer({
-                        routesForServerLoaderMatches
-                    });
-                    await utils_namespaceObject.fs.ensureFile(routesServerFile);
-                    await utils_namespaceObject.fs.writeFile(routesServerFile, code);
+                    if (includeRouteServerLoadersInSsrEntry) {
+                        const routesForServerLoaderMatches = (0, utils_namespaceObject.filterRoutesLoader)(routes);
+                        const code = external_templates_js_namespaceObject.routesForServer({
+                            routesForServerLoaderMatches
+                        });
+                        await utils_namespaceObject.fs.ensureFile(routesServerFile);
+                        await utils_namespaceObject.fs.writeFile(routesServerFile, code);
+                    } else await utils_namespaceObject.fs.remove(routesServerFile);
                     const serverRoutesCode = await external_templates_js_namespaceObject.fileSystemRoutes({
                         metaName,
                         routes: filtedRoutesForServer,
@@ -166,12 +169,15 @@ const generateCode = async (appContext, config, entrypoints, api, options = {})=
                         internalDirectory,
                         splitRouteChunks: config?.output?.splitRouteChunks,
                         isRscClientBundle: false,
+                        isolateRouteDataInRscLayer: (0, utils_namespaceObject.isUseRsc)(config) && options.isolateRouteDataInRscLayer,
                         srcDirectory,
                         internalSrcAlias: appContext.internalSrcAlias
                     });
                     await utils_namespaceObject.fs.outputFile(external_path_default().resolve(internalDirectory, `./${entryName}/${options.serverRoutesFileName || 'routes.server.js'}`), serverRoutesCode, 'utf8');
                 }
-                const serverLoaderCombined = external_templates_js_namespaceObject.ssrLoaderCombinedModule(entrypoints, entrypoint, config, appContext);
+                const serverLoaderCombined = external_templates_js_namespaceObject.ssrLoaderCombinedModule(entrypoints, entrypoint, config, appContext, {
+                    includeRouteServerLoaders: includeRouteServerLoadersInSsrEntry
+                });
                 if (serverLoaderCombined) {
                     const serverLoaderFile = (0, external_utils_js_namespaceObject.getServerCombinedModuleFile)(internalDirectory, entryName);
                     await utils_namespaceObject.fs.outputFile(serverLoaderFile, serverLoaderCombined);

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

@@ -134,7 +134,7 @@ async function hasUseClientDirective(componentPath, srcDirectory, internalSrcAli
         await fh?.close();
     }
 }
-const fileSystemRoutes = async ({ metaName, routes, ssrMode, nestedRoutesEntry, entryName, internalDirectory, splitRouteChunks = true, isRscClientBundle = false, hydrateRscClientRoutes = false, srcDirectory, internalSrcAlias })=>{
+const fileSystemRoutes = async ({ metaName, routes, ssrMode, nestedRoutesEntry, entryName, internalDirectory, splitRouteChunks = true, isRscClientBundle = false, hydrateRscClientRoutes = false, isolateRouteDataInRscLayer = false, srcDirectory, internalSrcAlias })=>{
     const components = [];
     const loadings = [];
     const errors = [];
@@ -226,9 +226,9 @@ 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 shouldHydrateRscRoute = hydrateRscClientRoutes && isRscClientBundle && !isClientComponent && !route.loader && !route.data;
+        const shouldHydrateRscRoute = hydrateRscClientRoutes && isRscClientBundle && !isClientComponent && ('nested' !== route.type || !route.loader && !route.data);
         const shouldIncludeClientBundle = !isRscClientBundle || isClientComponent || shouldHydrateRscRoute;
-        if (route.isRoot && route._component && shouldIncludeClientBundle) rootLayoutCode = `import RootLayout from '${route._component}'`;
+        if ('nested' === route.type && route.isRoot && route._component && shouldIncludeClientBundle) rootLayoutCode = `import RootLayout from '${route._component}'`;
         const finalRoute = {
             ...route,
             loading,
@@ -289,32 +289,30 @@ const fileSystemRoutes = async ({ metaName, routes, ssrMode, nestedRoutesEntry,
     const importComponentsCode = components.map((component, index)=>`import component_${index} from '${component}';\n`).join('');
     const importErrorComponentsCode = errors.map((error, index)=>`import error_${index} from '${error}';\n`).join('');
     let importLoadersCode = '';
-    for (const [key, loaderInfo] of Object.entries(loadersMap))if (loaderInfo.inline) {
+    const isolatedRouteDataDirectory = external_path_default().join(internalDirectory, entryName, '__rsc_route_data__');
+    await utils_namespaceObject.fs.remove(isolatedRouteDataDirectory);
+    if (isolateRouteDataInRscLayer) await utils_namespaceObject.fs.ensureDir(isolatedRouteDataDirectory);
+    for (const [key, loaderInfo] of Object.entries(loadersMap)){
         const { route } = loaderInfo;
-        if (route.action) importLoadersCode += `import { loader as ${key}, action as action_${loaderInfo.loaderId} } from "${(0, utils_namespaceObject.slash)(loaderInfo.filePath)}${getDataLoaderPath({
+        const loaderRequest = `${(0, utils_namespaceObject.slash)(loaderInfo.filePath)}${getDataLoaderPath({
             loaderId: key,
             clientData: loaderInfo.clientData,
-            action: route.action,
+            action: route.action || false,
             inline: loaderInfo.inline,
             routeId: loaderInfo.routeId,
             inValidSSRRoute: loaderInfo.inValidSSRRoute
-        })}";\n`;
-        else importLoadersCode += `import { loader as ${key} } from "${(0, utils_namespaceObject.slash)(loaderInfo.filePath)}${getDataLoaderPath({
-            loaderId: key,
-            clientData: loaderInfo.clientData,
-            action: false,
-            inline: loaderInfo.inline,
-            routeId: route.id,
-            inValidSSRRoute: loaderInfo.inValidSSRRoute
-        })}";\n`;
-    } else importLoadersCode += `import ${key} from "${(0, utils_namespaceObject.slash)(loaderInfo.filePath)}${getDataLoaderPath({
-        loaderId: key,
-        clientData: loaderInfo.clientData,
-        action: false,
-        inline: loaderInfo.inline,
-        routeId: loaderInfo.routeId,
-        inValidSSRRoute: loaderInfo.inValidSSRRoute
-    })}";\n`;
+        })}`;
+        let loaderImport = loaderRequest;
+        if (isolateRouteDataInRscLayer) {
+            const isolatedLoaderFile = external_path_default().join(isolatedRouteDataDirectory, `${key}.js`);
+            const isolatedLoaderCode = loaderInfo.inline ? route.action ? `export { loader, action } from ${JSON.stringify(loaderRequest)};` : `export { loader } from ${JSON.stringify(loaderRequest)};` : `export { default } from ${JSON.stringify(loaderRequest)};`;
+            await utils_namespaceObject.fs.outputFile(isolatedLoaderFile, isolatedLoaderCode, 'utf8');
+            loaderImport = `./__rsc_route_data__/${key}.js`;
+        }
+        if (loaderInfo.inline) if (route.action) importLoadersCode += `import { loader as ${key}, action as action_${loaderInfo.loaderId} } from "${loaderImport}";\n`;
+        else importLoadersCode += `import { loader as ${key} } from "${loaderImport}";\n`;
+        else importLoadersCode += `import ${key} from "${loaderImport}";\n`;
+    }
     let importConfigsCode = '';
     for (const [key, configPath] of Object.entries(configsMap))importConfigsCode += `import * as ${key} from "${(0, utils_namespaceObject.slash)(configPath)}";\n`;
     await utils_namespaceObject.fs.ensureFile(loadersMapFile);
@@ -340,7 +338,7 @@ const fileSystemRoutes = async ({ metaName, routes, ssrMode, nestedRoutesEntry,
     ${routeComponentsCode}
   `;
 };
-function ssrLoaderCombinedModule(entrypoints, entrypoint, config, appContext) {
+function ssrLoaderCombinedModule(entrypoints, entrypoint, config, appContext, options = {}) {
     const { entryName, isMainEntry } = entrypoint;
     const { packageName } = appContext;
     const ssr = (0, utils_namespaceObject.getEntryOptions)(entryName, isMainEntry, config.server.ssr, config.server.ssrByEntries, packageName);
@@ -348,6 +346,17 @@ function ssrLoaderCombinedModule(entrypoints, entrypoint, config, appContext) {
     if (entrypoint.nestedRoutesEntry && (ssr || ssg)) {
         const serverLoaderRuntime = require.resolve('@modern-js/plugin-data-loader/runtime');
         const serverLoadersFile = './route-server-loaders.js';
+        const includeRouteServerLoaders = false !== options.includeRouteServerLoaders;
+        if (!includeRouteServerLoaders) {
+            if (!config.source.enableAsyncEntry) return `export * from "${(0, utils_namespaceObject.slash)(serverLoaderRuntime)}"`;
+            return `
+      async function loadModules() {
+        return import("${(0, utils_namespaceObject.slash)(serverLoaderRuntime)}");
+      }
+
+      export { loadModules };
+      `;
+        }
         const combinedModule = `export * from "${(0, utils_namespaceObject.slash)(serverLoaderRuntime)}"; export * from "${serverLoadersFile}"`;
         if (!config.source.enableAsyncEntry) return combinedModule;
         return `

package/dist/cjs/router/cli/handler.js

@@ -66,6 +66,8 @@ async function handleGeneratorEntryCode(api, entrypoints, options = {}) {
     const enableRsc = resolvedConfig?.server?.rsc;
     const routesByEntry = await generateCode(appContext, resolvedConfig, entrypoints, api, {
         hydrateRscClientRoutes: normalizedOptions.hydrateRscClientRoutes,
+        includeRouteServerLoadersInSsrEntry: normalizedOptions.includeRouteServerLoadersInSsrEntry,
+        isolateRouteDataInRscLayer: normalizedOptions.isolateRouteDataInRscLayer,
         serverRoutesFileName: normalizedOptions.serverRoutesFileName
     });
     await Promise.all(entrypoints.map(async (entrypoint)=>{