@bleedingdev/modern-js-runtime 3.5.0-ultramodern.99 → 3.8.1-ultramodern.1

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

@@ -1,5 +1,5 @@
 import { getRouterServerSnapshot } from "../../router/runtime/lifecycle.mjs";
-import { handleRSCRedirect } from "../../router/runtime/rsc-router.mjs";
+import { handleRSCRedirect } from "../../router/runtime/redirect.mjs";
 import { SSRErrors } from "./tracer.mjs";
 const isRedirectStatus = (status)=>status >= 300 && status <= 399;
 const isNullBodyStatus = (status)=>204 === status || 205 === status || 304 === status;
@@ -13,12 +13,12 @@ const processRedirect = (headers, status, ctx)=>{
 const applyRouterSnapshotResult = (context, onError)=>{
     const routerServerSnapshot = 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], 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({
@@ -26,7 +26,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/esm/core/server/scriptOrder.mjs

@@ -43,7 +43,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/esm/core/server/stream/beforeTemplate.worker.mjs

@@ -1,4 +1,3 @@
-import { matchRoutes } from "@modern-js/runtime-utils/router";
 import { getRouterMatchedRouteIds } from "../../../router/runtime/lifecycle.mjs";
 import { CHUNK_CSS_PLACEHOLDER } from "../constants.mjs";
 import { createFederatedCssLinks } from "../federatedCss.mjs";
@@ -27,20 +26,12 @@ async function buildShellBeforeTemplate(beforeAppTemplate, options) {
         });
         return safeReplace(template, 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 = getRouterMatchedRouteIds(runtimeContext);
             if (matchedRouteIds?.length) matchedRouteManifests = matchedRouteIds.map((routeId)=>routeAssets[routeId]).filter(Boolean);
-            else if (routerContext && routes) {
-                const matches = 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/esm/core/server/utils.mjs

@@ -1,4 +1,4 @@
-import { isRouteErrorResponse } from "@modern-js/runtime-utils/router";
+import { isRouteErrorResponse } from "../../router/runtime/routerHelper.mjs";
 function attributesToString(attributes) {
     return Object.entries(attributes).reduce((str, [key, value])=>void 0 === value ? str : `${str} ${key}="${value}"`, '');
 }

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

@@ -347,4 +347,4 @@ const documentPlugin = ()=>({
     });
 const cli = documentPlugin;
 export default cli;
-export { documentPlugin, getDocumentByEntryName };
+export { documentPlugin, getDocumentByEntryName, processScriptPlaceholders };

package/dist/esm/module-federation/distributed-ssr.mjs

@@ -7,24 +7,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 = 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 = useRuntimeContext();
     const key = distributedSsrFragmentKey(remote, expose);
     const attributes = {
@@ -35,12 +35,13 @@ function DistributedSsrBoundary({ children, expose, fallback, fragmentProps = {}
         children: children
     });
     const fragmentContext = getDistributedSsrFragmentContext(runtimeContext.requestContext?.response);
-    if (!fragmentContext) return /*#__PURE__*/ jsx("div", {
+    if (void 0 === fragmentContext) return /*#__PURE__*/ 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__*/ jsx("div", {
         ...attributes,

package/dist/esm/module-federation/last-known-good.mjs

@@ -33,7 +33,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 = deliveryUnitResolutionKey(ref.unitId, env);

package/dist/esm/module-federation/manifest-recovery-runtime-plugin.mjs

@@ -1,3 +1,4 @@
+import { wait } from "@modern-js/utils/universal";
 const DEFAULT_ATTEMPTS = 3;
 const DEFAULT_RETRY_DELAY_MS = 100;
 const DEFAULT_TIMEOUT_MS = 1000;
@@ -43,7 +44,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');
@@ -51,47 +52,35 @@ const isHttpManifestUrl = (id)=>{
         return false;
     }
 };
-const defaultWait = (milliseconds)=>new Promise((resolve)=>{
-        setTimeout(resolve, milliseconds);
+const defaultWait = (milliseconds)=>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);
         }
     };
 };

package/dist/esm/router/cli/code/index.mjs

@@ -39,8 +39,9 @@ async function generateRoutesForEntry(entrypoint, appContext) {
     }
     return routes;
 }
-const generateCode = async (appContext, config, entrypoints, api)=>{
+const generateCode = async (appContext, config, entrypoints, api, options = {})=>{
     const { internalDirectory, srcDirectory, internalSrcAlias, packageName } = appContext;
+    const includeRouteServerLoadersInSsrEntry = false !== options.includeRouteServerLoadersInSsrEntry || !isUseRsc(config);
     const hooks = api.getHooks();
     const generatedRoutesByEntry = {};
     const eagerRouteComponentFilesByEntry = new Map();
@@ -98,6 +99,7 @@ const generateCode = async (appContext, config, entrypoints, api)=>{
                         internalDirectory,
                         splitRouteChunks: config?.output?.splitRouteChunks,
                         isRscClientBundle: isUseRsc(config),
+                        hydrateRscClientRoutes: options.hydrateRscClientRoutes,
                         srcDirectory,
                         internalSrcAlias: appContext.internalSrcAlias
                     })
@@ -105,12 +107,14 @@ const generateCode = async (appContext, config, entrypoints, api)=>{
                 if (entrypoint.nestedRoutesEntry && (isUseSSRBundle(config) || isUseRsc(config))) {
                     const routesServerFile = getServerLoadersFile(internalDirectory, entryName);
                     const filtedRoutesForServer = filterRoutesForServer(routes);
-                    const routesForServerLoaderMatches = filterRoutesLoader(routes);
-                    const code = __rspack_external__templates_mjs_ab577925.routesForServer({
-                        routesForServerLoaderMatches
-                    });
-                    await fs.ensureFile(routesServerFile);
-                    await fs.writeFile(routesServerFile, code);
+                    if (includeRouteServerLoadersInSsrEntry) {
+                        const routesForServerLoaderMatches = filterRoutesLoader(routes);
+                        const code = __rspack_external__templates_mjs_ab577925.routesForServer({
+                            routesForServerLoaderMatches
+                        });
+                        await fs.ensureFile(routesServerFile);
+                        await fs.writeFile(routesServerFile, code);
+                    } else await fs.remove(routesServerFile);
                     const serverRoutesCode = await __rspack_external__templates_mjs_ab577925.fileSystemRoutes({
                         metaName,
                         routes: filtedRoutesForServer,
@@ -120,12 +124,15 @@ const generateCode = async (appContext, config, entrypoints, api)=>{
                         internalDirectory,
                         splitRouteChunks: config?.output?.splitRouteChunks,
                         isRscClientBundle: false,
+                        isolateRouteDataInRscLayer: isUseRsc(config) && options.isolateRouteDataInRscLayer,
                         srcDirectory,
                         internalSrcAlias: appContext.internalSrcAlias
                     });
-                    await fs.outputFile(path.resolve(internalDirectory, `./${entryName}/routes.server.js`), serverRoutesCode, 'utf8');
+                    await fs.outputFile(path.resolve(internalDirectory, `./${entryName}/${options.serverRoutesFileName || 'routes.server.js'}`), serverRoutesCode, 'utf8');
                 }
-                const serverLoaderCombined = __rspack_external__templates_mjs_ab577925.ssrLoaderCombinedModule(entrypoints, entrypoint, config, appContext);
+                const serverLoaderCombined = __rspack_external__templates_mjs_ab577925.ssrLoaderCombinedModule(entrypoints, entrypoint, config, appContext, {
+                    includeRouteServerLoaders: includeRouteServerLoadersInSsrEntry
+                });
                 if (serverLoaderCombined) {
                     const serverLoaderFile = getServerCombinedModuleFile(internalDirectory, entryName);
                     await fs.outputFile(serverLoaderFile, serverLoaderCombined);

package/dist/esm/router/cli/code/templates.mjs

@@ -89,7 +89,7 @@ async function hasUseClientDirective(componentPath, srcDirectory, internalSrcAli
         await fh?.close();
     }
 }
-const fileSystemRoutes = async ({ metaName, routes, ssrMode, nestedRoutesEntry, entryName, internalDirectory, splitRouteChunks = true, isRscClientBundle = 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 = [];
@@ -161,7 +161,6 @@ const fileSystemRoutes = async ({ metaName, routes, ssrMode, nestedRoutesEntry,
                     componentPath: route._component,
                     routeId: route.id
                 });
-                rootLayoutCode = `import RootLayout from '${route._component}'`;
                 component = 'RootLayout';
             } else if (splitRouteChunks) {
                 lazyImport = createLazyImport({
@@ -182,8 +181,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 = isRscClientBundle && !isClientComponent && !route.loader && !route.data;
+        const shouldHydrateRscRoute = hydrateRscClientRoutes && isRscClientBundle && !isClientComponent && ('nested' !== route.type || !route.loader && !route.data);
         const shouldIncludeClientBundle = !isRscClientBundle || isClientComponent || shouldHydrateRscRoute;
+        if ('nested' === route.type && route.isRoot && route._component && shouldIncludeClientBundle) rootLayoutCode = `import RootLayout from '${route._component}'`;
         const finalRoute = {
             ...route,
             loading,
@@ -244,32 +244,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 = path.join(internalDirectory, entryName, '__rsc_route_data__');
+    await fs.remove(isolatedRouteDataDirectory);
+    if (isolateRouteDataInRscLayer) await 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 "${slash(loaderInfo.filePath)}${getDataLoaderPath({
+        const loaderRequest = `${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 "${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 "${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 = path.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 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 "${slash(configPath)}";\n`;
     await fs.ensureFile(loadersMapFile);
@@ -295,7 +293,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 = getEntryOptions(entryName, isMainEntry, config.server.ssr, config.server.ssrByEntries, packageName);
@@ -303,6 +301,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 "${slash(serverLoaderRuntime)}"`;
+            return `
+      async function loadModules() {
+        return import("${slash(serverLoaderRuntime)}");
+      }
+
+      export { loadModules };
+      `;
+        }
         const combinedModule = `export * from "${slash(serverLoaderRuntime)}"; export * from "${serverLoadersFile}"`;
         if (!config.source.enableAsyncEntry) return combinedModule;
         return `
@@ -323,7 +332,7 @@ function ssrLoaderCombinedModule(entrypoints, entrypoint, config, appContext) {
     }
     return null;
 }
-const runtimeGlobalContext = async ({ entryName, metaName, srcDirectory, nestedRoutesEntry, internalSrcAlias, globalApp, rscType = false, basename })=>{
+const runtimeGlobalContext = async ({ entryName, metaName, srcDirectory, nestedRoutesEntry, internalSrcAlias, globalApp, rscType = false, routesImportPath = './routes', basename })=>{
     const imports = [
         `import { setGlobalContext } from '@${metaName}/runtime/context';`
     ];
@@ -354,7 +363,7 @@ const runtimeGlobalContext = async ({ entryName, metaName, srcDirectory, nestedR
     const enableRsc = Boolean(rscType);
     if (isClient) return `${imports.join('\n')}
 
-    import { routes } from './routes';
+    import { routes } from '${routesImportPath}';
 
     const entryName = '${entryName}';
     const basename = '${basename || '/'}';
@@ -370,7 +379,7 @@ const runtimeGlobalContext = async ({ entryName, metaName, srcDirectory, nestedR
     `;
     return `${imports.join('\n')}
 
-    import { routes } from './routes';
+    import { routes } from '${routesImportPath}';
 
     const entryName = '${entryName}';
     const basename = '${basename || '/'}';

package/dist/esm/router/cli/handler.mjs

@@ -20,7 +20,12 @@ async function handleGeneratorEntryCode(api, entrypoints, options = {}) {
     const { generatorRegisterCode, generateCode, generatorServerRegisterCode } = await import("./code/index.mjs");
     originEntrypointsByKey.set(entrypointsKey, cloneDeep(entrypoints));
     const enableRsc = resolvedConfig?.server?.rsc;
-    const routesByEntry = await generateCode(appContext, resolvedConfig, entrypoints, api);
+    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)=>{
         if (entrypoint.nestedRoutesEntry || entrypoint.pageRoutesEntry) {
             const route = appContext.serverRoutes.find((r)=>r.entryName === entrypoint.entryName);
@@ -43,6 +48,7 @@ async function handleGeneratorEntryCode(api, entrypoints, options = {}) {
                 internalSrcAlias: appContext.internalSrcAlias,
                 globalApp: entrypoint.fileSystemRoutes?.globalApp,
                 rscType: 'server',
+                routesImportPath: normalizedOptions.serverRoutesFileName ? `./${normalizedOptions.serverRoutesFileName.replace(/\.js$/, '')}` : void 0,
                 basename
             }));
         }

package/dist/esm/router/runtime/plugin.mjs

@@ -1,10 +1,11 @@
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import { merge } from "@modern-js/runtime-utils/merge";
-import { RouterProvider, createBrowserRouter, createHashRouter, createRoutesFromElements, useHref, useLocation, useMatches } from "@modern-js/runtime-utils/router";
+import { RouterProvider, createBrowserRouter, createHashRouter, createRoutesFromElements, useHref, useInRouterContext, useLocation, useMatches, useNavigate, useParams } from "@modern-js/runtime-utils/router";
 import { normalizePathname } from "@modern-js/runtime-utils/url";
 import * as __rspack_external_react from "react";
-import { InternalRuntimeContext, getGlobalIsRscClient, getGlobalLayoutApp, getGlobalRoutes } from "../../core/context/index.mjs";
+import { InternalRuntimeContext, getGlobalEnableRsc, getGlobalIsRscClient, getGlobalLayoutApp, getGlobalRoutes } from "../../core/context/index.mjs";
 import { applyRouterRuntimeState } from "./lifecycle.mjs";
+import { Link } from "./PrefetchLink.mjs";
 import { routerProviderRegistryHooks } from "./provider.mjs";
 import { createClientRouterFromPayload } from "./rsc-router.mjs";
 import { createRouteObjectsFromConfig, deserializeErrors, renderRoutes, urlJoin } from "./utils.mjs";
@@ -38,9 +39,13 @@ const routerPlugin = (userConfig = {})=>({
                     }
                 }
                 context.router = {
+                    Link: Link,
                     useMatches: useMatches,
                     useLocation: useLocation,
-                    useHref: useHref
+                    useHref: useHref,
+                    useInRouterContext: useInRouterContext,
+                    useNavigate: useNavigate,
+                    useParams: useParams
                 };
                 Object.defineProperty(context, 'routes', {
                     get () {
@@ -64,7 +69,7 @@ const routerPlugin = (userConfig = {})=>({
                 };
                 let cachedRouter = null;
                 const RouterWrapper = (props)=>{
-                    const routerResult = useRouterCreation(process.env.MODERN_ENABLE_RSC ? {
+                    const routerResult = useRouterCreation(("u" > typeof __MODERN_ENABLE_RSC__ ? __MODERN_ENABLE_RSC__ : true === getGlobalEnableRsc()) ? {
                         ...props,
                         rscPayload: props?.rscPayload
                     } : props, {
@@ -82,18 +87,18 @@ const routerPlugin = (userConfig = {})=>({
                     const { routes } = routerResult;
                     routesContainer.current = routes;
                     beforeCreateRouter = false;
-                    const RouterContent = ()=>/*#__PURE__*/ jsxs(Fragment, {
-                            children: [
-                                /*#__PURE__*/ jsx(RouterProvider, {
-                                    router: router
-                                }),
-                                /*#__PURE__*/ jsx(EmptyComponent, {}),
-                                /*#__PURE__*/ jsx(EmptyComponent, {})
-                            ]
-                        });
+                    const routerContent = /*#__PURE__*/ jsxs(Fragment, {
+                        children: [
+                            /*#__PURE__*/ jsx(RouterProvider, {
+                                router: router
+                            }),
+                            /*#__PURE__*/ jsx(EmptyComponent, {}),
+                            /*#__PURE__*/ jsx(EmptyComponent, {})
+                        ]
+                    });
                     return App ? /*#__PURE__*/ jsx(App, {
-                        children: /*#__PURE__*/ jsx(RouterContent, {})
-                    }) : /*#__PURE__*/ jsx(RouterContent, {});
+                        children: routerContent
+                    }) : routerContent;
                 };
                 return RouterWrapper;
             });
@@ -121,15 +126,15 @@ function useRouterCreation(props, options) {
     const baseUrl = selectBasePath(location.pathname).replace(/^\/*/, '/');
     const _basename = '/' === baseUrl ? urlJoin(baseUrl, runtimeContext._internalRouterBaseName || basename || '') : baseUrl;
     const { unstable_getBlockNavState: getBlockNavState } = runtimeContext;
-    const rscPayload = process.env.MODERN_ENABLE_RSC && props?.rscPayload ? safeUse(props.rscPayload) : null;
-    let hydrationData = process.env.MODERN_ENABLE_RSC ? window._ROUTER_DATA || rscPayload : window._ROUTER_DATA;
+    const rscPayload = ("u" > typeof __MODERN_ENABLE_RSC__ ? __MODERN_ENABLE_RSC__ : true === getGlobalEnableRsc()) && props?.rscPayload ? safeUse(props.rscPayload) : null;
+    let hydrationData = "u" > typeof __MODERN_ENABLE_RSC__ ? __MODERN_ENABLE_RSC__ ? window._ROUTER_DATA || rscPayload : window._ROUTER_DATA : true === getGlobalEnableRsc() ? window._ROUTER_DATA || rscPayload : window._ROUTER_DATA;
     return (0, __rspack_external_react.useMemo)(()=>{
         if (hydrationData?.errors) hydrationData = {
             ...hydrationData,
             errors: deserializeErrors(hydrationData.errors)
         };
         let routes = null;
-        routes = process.env.MODERN_ENABLE_RSC && getGlobalIsRscClient() ? createRoutes ? createRoutes() : createRouteObjectsFromConfig({
+        routes = ("u" > typeof __MODERN_ENABLE_RSC__ ? __MODERN_ENABLE_RSC__ : true === getGlobalEnableRsc()) && getGlobalIsRscClient() ? createRoutes ? createRoutes() : createRouteObjectsFromConfig({
             routesConfig: finalRouteConfig
         }) : createRoutes ? createRoutes() : createRoutesFromElements(renderRoutes({
             routesConfig: finalRouteConfig,
@@ -137,7 +142,7 @@ function useRouterCreation(props, options) {
         }));
         if (!routes) routes = [];
         const hooks = api.getHooks();
-        if (process.env.MODERN_ENABLE_RSC && rscPayload) try {
+        if (("u" > typeof __MODERN_ENABLE_RSC__ ? __MODERN_ENABLE_RSC__ : true === getGlobalEnableRsc()) && rscPayload) try {
             const router = createClientRouterFromPayload(rscPayload, routes, _basename);
             return {
                 router,

package/dist/esm/router/runtime/plugin.node.mjs

@@ -1,7 +1,7 @@
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import { merge } from "@modern-js/runtime-utils/merge";
 import { createRequestContext } from "@modern-js/runtime-utils/node";
-import { StaticRouterProvider, createRoutesFromElements, createStaticHandler, createStaticRouter } from "@modern-js/runtime-utils/router";
+import { StaticRouterProvider, createRoutesFromElements, createStaticHandler, createStaticRouter, useInRouterContext, useLocation, useNavigate, useParams } from "@modern-js/runtime-utils/router";
 import { time } from "@modern-js/runtime-utils/time";
 import { LOADER_REPORTER_NAME } from "@modern-js/utils/universal/constants";
 import { useContext } from "react";
@@ -9,6 +9,7 @@ import { InternalRuntimeContext, getGlobalEnableRsc, getGlobalLayoutApp, getGlob
 import { setServerPayload } from "../../core/context/serverPayload/index.server.mjs";
 import DeferredDataScripts_node from "./DeferredDataScripts.node.mjs";
 import { applyRouterRuntimeState, createRouterServerSnapshot } from "./lifecycle.mjs";
+import { Link } from "./PrefetchLink.mjs";
 import { routerProviderRegistryHooks } from "./provider.mjs";
 import { RSCStaticRouter, createServerPayload, handleRSCRedirect, prepareRSCRoutes } from "./rsc-router.mjs";
 import { createRouteObjectsFromConfig, renderRoutes, urlJoin } from "./utils.mjs";
@@ -46,6 +47,13 @@ const routerPlugin = (userConfig = {})=>({
         setup: (api)=>{
             let finalRouteConfig = {};
             api.onBeforeRender(async (context, interrupt)=>{
+                context.router = {
+                    Link: Link,
+                    useInRouterContext: useInRouterContext,
+                    useLocation: useLocation,
+                    useNavigate: useNavigate,
+                    useParams: useParams
+                };
                 const pluginConfig = api.getRuntimeConfig();
                 const { basename = '', routesConfig, createRoutes } = merge(pluginConfig.router || {}, userConfig);
                 finalRouteConfig = {
@@ -134,10 +142,8 @@ const routerPlugin = (userConfig = {})=>({
                     const enableRsc = getGlobalEnableRsc();
                     return (props)=>{
                         const context = useContext(InternalRuntimeContext);
-                        const { routerContext, ssrContext, routes } = context;
-                        const { nonce, mode, useJsonScript } = ssrContext;
+                        const { routerContext, routes } = context;
                         const { basename } = routerContext;
-                        const remixRouter = createStaticRouter(routes, routerContext);
                         if (enableRsc) return App ? /*#__PURE__*/ jsx(App, {
                             children: /*#__PURE__*/ jsx(RSCStaticRouter, {
                                 basename: basename
@@ -146,6 +152,8 @@ const routerPlugin = (userConfig = {})=>({
                             basename: basename
                         });
                         {
+                            const { nonce, mode, useJsonScript } = context.ssrContext;
+                            const remixRouter = createStaticRouter(routes, routerContext);
                             const routerWrapper = /*#__PURE__*/ jsxs(Fragment, {
                                 children: [
                                     /*#__PURE__*/ jsx(StaticRouterProvider, {

package/dist/esm/router/runtime/provider.mjs

@@ -16,7 +16,7 @@ function createRouterProviderRealm(registrations) {
     const providers = new Map();
     let defaultProvider;
     for (const registration of registrations){
-        if (!registration.name) throw new Error('[@modern-js/runtime] A router provider realm cannot contain an unnamed provider.');
+        if (0 === registration.name.length) throw new Error('[@modern-js/runtime] A router provider realm cannot contain an unnamed provider.');
         if (providers.has(registration.name)) throw new Error(`[@modern-js/runtime] Router provider "${registration.name}" is declared more than once in the same runtime realm.`);
         if (true === registration.isDefault && void 0 !== defaultProvider && defaultProvider !== registration.name) throw new Error(`[@modern-js/runtime] Router provider realm declares both "${defaultProvider}" and "${registration.name}" as defaults.`);
         providers.set(registration.name, registration.factory);
@@ -26,7 +26,7 @@ function createRouterProviderRealm(registrations) {
         ...providers.keys()
     ]);
     return Object.freeze({
-        ...defaultProvider ? {
+        ...void 0 !== defaultProvider ? {
             defaultProvider
         } : {},
         get: (name)=>providers.get(name),

package/dist/esm/router/runtime/redirect.mjs

@@ -0,0 +1,13 @@
+const handleRSCRedirect = (headers, basename, status)=>{
+    const newHeaders = new Headers(headers);
+    let redirectUrl = headers.get('Location');
+    if ('/' !== basename) redirectUrl = redirectUrl.replace(basename, '');
+    newHeaders.set('X-Modernjs-Redirect', redirectUrl);
+    newHeaders.set('X-Modernjs-BaseUrl', basename);
+    newHeaders.delete('Location');
+    return new Response(null, {
+        status,
+        headers: newHeaders
+    });
+};
+export { handleRSCRedirect };