@modern-js/runtime 2.68.0 → 2.68.2

package/dist/cjs/cli/code.js

@@ -71,7 +71,8 @@ const generateCode = async (entrypoints, appContext, config, hooks) => {
           metaName,
           entryName,
           mountId,
-          urlPath: (_serverRoutes_find = serverRoutes.find((route) => route.entryName === entryName)) === null || _serverRoutes_find === void 0 ? void 0 : _serverRoutes_find.urlPath
+          urlPath: (_serverRoutes_find = serverRoutes.find((route) => route.entryName === entryName)) === null || _serverRoutes_find === void 0 ? void 0 : _serverRoutes_find.urlPath,
+          isNestedRouter: entrypoint.nestedRoutesEntry
         });
       } else {
         indexCode = template.index({
@@ -83,7 +84,8 @@ const generateCode = async (entrypoints, appContext, config, hooks) => {
           customEntry,
           customBootstrap,
           mountId,
-          enableRsc: config.server.rsc
+          enableRsc: config.server.rsc,
+          isNestedRouter: !!entrypoint.nestedRoutesEntry
         });
       }
       const indexFile = import_path.default.resolve(internalDirectory, `./${entryName}/${import_constants.ENTRY_POINT_FILE_NAME}`);
@@ -112,6 +114,7 @@ const generateCode = async (entrypoints, appContext, config, hooks) => {
       } else if (config.server.rsc) {
         const indexServerFile = import_path.default.resolve(internalDirectory, `./${entryName}/${import_constants.SERVER_ENTRY_POINT_FILE_NAME}`);
         const indexServerCode = serverTemplate.entryForCSRWithRSC({
+          entryName,
           metaName
         });
         await import_utils.fs.outputFile(indexServerFile, indexServerCode, "utf8");
@@ -130,7 +133,7 @@ const generateCode = async (entrypoints, appContext, config, hooks) => {
       const registerRuntimeFile = import_path.default.resolve(internalDirectory, `./${entryName}/${import_constants.ENTRY_POINT_RUNTIME_REGISTER_FILE_NAME}`);
       await import_utils.fs.outputFile(registerRuntimeFile, registerRuntimeCode, "utf8");
       let contextCode = "";
-      if (!config.server.rsc) {
+      if (!config.server.rsc || entrypoint.nestedRoutesEntry) {
         contextCode = template.runtimeGlobalContext({
           entryName,
           srcDirectory,

package/dist/cjs/cli/template.js

@@ -41,7 +41,21 @@ module.exports = __toCommonJS(template_exports);
 var import_path = __toESM(require("path"));
 var import_utils = require("@modern-js/utils");
 var import_constants = require("./constants");
-const genRenderCode = ({ srcDirectory, internalSrcAlias, metaName, entry, customEntry, customBootstrap, mountId, enableRsc }) => {
+const genRenderStatement = ({ customBootstrap, enableRsc, mountId, isNestedRouter }) => {
+  if (customBootstrap) {
+    return `customBootstrap(ModernRoot, () => render(<ModernRoot />, '${mountId || "root"}'));`;
+  }
+  if (enableRsc) {
+    if (!isNestedRouter) {
+      return `render(<ModernRoot>
+                  <RscClientRoot rscPayload={data} />
+                </ModernRoot>, '${mountId || "root"}');`;
+    }
+    return `render(<ModernRoot rscPayload={data} />, '${mountId || "root"}');`;
+  }
+  return `render(<ModernRoot />, '${mountId || "root"}');`;
+};
+const genRenderCode = ({ srcDirectory, internalSrcAlias, metaName, entry, customEntry, customBootstrap, mountId, enableRsc, isNestedRouter }) => {
   if (customEntry) {
     return `import '${(0, import_utils.formatImportPath)(entry.replace(srcDirectory, internalSrcAlias))}'`;
   }
@@ -60,11 +74,14 @@ ${customBootstrap ? `import customBootstrap from '${(0, import_utils.formatImpor
 
 const ModernRoot = createRoot();
 
-${customBootstrap ? `customBootstrap(ModernRoot, () => render(<ModernRoot />, '${mountId || "root"}'));` : enableRsc ? `render(<ModernRoot>
-                  <RscClientRoot data={data} />
-                </ModernRoot>, '${mountId || "root"}');` : `render(<ModernRoot />, '${mountId || "root"}');`}`;
+${genRenderStatement({
+    customBootstrap,
+    enableRsc,
+    mountId,
+    isNestedRouter
+  })}`;
 };
-const entryForCSRWithRSC = ({ metaName, entryName, urlPath = "/", mountId = "root" }) => {
+const entryForCSRWithRSC = ({ metaName, entryName, urlPath = "/", mountId = "root", isNestedRouter }) => {
   return `
   import '@${metaName}/runtime/registry/${entryName}';
   import { render } from '@${metaName}/runtime/browser';
@@ -72,28 +89,61 @@ const entryForCSRWithRSC = ({ metaName, entryName, urlPath = "/", mountId = "roo
 
   import {
     RscClientRoot,
-    createFromFetch
+    createFromFetch,
+    isRedirectResponse,
+    rscStream,
+    callServer,
+    createFromReadableStream
   } from '@${metaName}/runtime/rsc/client';
 
-  const content = createFromFetch(
-    fetch('${urlPath}', {
-      headers: {
-        'x-rsc-tree': 'true',
-      },
-    }),
-  );
+  const handleRedirectResponse = (res: Response) => {
+    const { headers } = res;
+    const location = headers.get('X-Modernjs-Redirect');
+    const baseUrl = headers.get('X-Modernjs-BaseUrl');
+    if (location) {
+      if (baseUrl !== '/') {
+        window.location.replace(baseUrl + location);
+      } else {
+        window.location.replace(location);
+      }
+      return;
+    }
+    return res;
+  };
+
+  ${process.env.MODERN_DISABLE_INJECT_RSC_DATA ? `
+      const data = createFromFetch(
+        fetch(location.pathname, {
+          headers: {
+            'x-rsc-tree': 'true',
+          },
+        }).then(handleRedirectResponse),
+      )
+      ` : `
+      const data = createFromReadableStream(rscStream, {
+        callServer: callServer,
+      });
+      `}
 
   const ModernRoot = createRoot();
 
-  render(
-    <ModernRoot>
-      <RscClientRoot data={content} />
-    </ModernRoot>,
-    '${mountId}',
-  );
+  ${isNestedRouter ? `
+      render(
+        <ModernRoot rscPayload={data}>
+        </ModernRoot>,
+        '${mountId}',
+      );
+      ` : `
+      render(
+        <ModernRoot>
+          <RscClientRoot rscPayload={data} />
+        </ModernRoot>,
+        '${mountId}',
+      );
+      `}
   `;
 };
-const index = ({ srcDirectory, internalSrcAlias, metaName, entry, entryName, customEntry, customBootstrap, mountId, enableRsc }) => `import '@${metaName}/runtime/registry/${entryName}';
+const index = ({ srcDirectory, internalSrcAlias, metaName, entry, entryName, customEntry, customBootstrap, mountId, enableRsc, isNestedRouter }) => `import '@${metaName}/runtime/registry/${entryName}';
 ${genRenderCode({
   srcDirectory,
   internalSrcAlias,
@@ -102,7 +152,8 @@ ${genRenderCode({
   customEntry,
   customBootstrap,
   mountId,
-  enableRsc
+  enableRsc,
+  isNestedRouter
 })}
 `;
 const register = () => `import './${import_constants.ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME}';

package/dist/cjs/cli/template.server.js

@@ -48,6 +48,7 @@ import {
   createRequestHandler,
 } from '@#metaName/runtime/ssr/server';
 import { RSCServerSlot } from '@#metaName/runtime/rsc/client';
+import { renderRsc } from '@#metaName/runtime/rsc/server';
 export { handleAction } from '@#metaName/runtime/rsc/server';
 
 const handleRequest = async (request, ServerRoot, options) => {
@@ -58,7 +59,7 @@ const handleRequest = async (request, ServerRoot, options) => {
     </ServerRoot>,
     {
       ...options,
-      rscRoot: <options.RSCRoot />,
+      rscRoot: options.rscRoot,
     },
   );
 
@@ -70,7 +71,22 @@ const handleRequest = async (request, ServerRoot, options) => {
 };
 
 export const requestHandler = createRequestHandler(handleRequest, {
-  enableRsc: true,
+  enableRsc: true
+});
+
+const handleRSCRequest = async (request, ServerRoot, options) => {
+  const { serverPayload } = options;
+  const stream = renderRsc({
+    element: options.rscRoot,
+    clientManifest: options.rscClientManifest!,
+  });
+
+  return new Response(stream);
+}
+
+
+export const rscPayloadHandler = createRequestHandler(handleRSCRequest, {
+  enableRsc: true
 });
 `;
 const serverIndex = (options) => {
@@ -80,24 +96,57 @@ const serverIndex = (options) => {
     ${genHandlerCode(options)}
   `;
 };
-const entryForCSRWithRSC = ({ metaName }) => {
+const entryForCSRWithRSC = ({ metaName, entryName }) => {
   return `
-  import App from './AppProxy';
-  import { renderRsc } from '@${metaName}/runtime/rsc/server'
+  import '@${metaName}/runtime/registry/${entryName}';
+  import {
+    createRequestHandler,
+  } from '@${metaName}/runtime/ssr/server';
+  import { renderRsc, processRSCStream } from '@${metaName}/runtime/rsc/server'
   export { handleAction } from '@${metaName}/runtime/rsc/server';
 
+  const handleCSRRender = async (request, ServerRoot, options) => {
+    const rscPayloadStream = renderRsc({
+      element: options.rscRoot,
+      clientManifest: options.rscClientManifest!,
+    });
+    const stream = new ReadableStream({
+      start(controller) {
+        const encoder = new TextEncoder();
+
+        controller.enqueue(encoder.encode(options.html));
 
-  export const rscRequestHandler = ({
-    clientManifest
-  }) => {
+      processRSCStream(rscPayloadStream, controller, encoder)
+        .catch(err => {
+          controller.error(err);
+        });
+      }
+    });
+
+    return new Response(stream, {
+      status: 200,
+      headers: new Headers({
+        'content-type': 'text/html; charset=UTF-8',
+      }),
+    });
+  }
+
+  export const renderRscStreamHandler = createRequestHandler(handleCSRRender, {
+    enableRsc: true
+  });
+
+  const handleRequest = async (request, ServerRoot, options) => {
     const stream = renderRsc({
-      element: <App/>,
-      clientManifest,
-    })
+            element: options.rscRoot,
+      clientManifest: options.rscClientManifest!,
+    });
 
-    const response = new Response(stream);
-    return response
+    return new Response(stream);
   }
+
+  export const rscPayloadHandler = createRequestHandler(handleRequest, {
+    enableRsc: true
+  });
 `;
 };
 function genHandlerCode({ mode, metaName, customServerEntry, srcDirectory, internalSrcAlias, enableRsc }) {

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

@@ -23,17 +23,28 @@ __export(context_exports, {
   getGlobalApp: () => getGlobalApp,
   getGlobalAppConfig: () => getGlobalAppConfig,
   getGlobalAppInit: () => getGlobalAppInit,
+  getGlobalEnableRsc: () => getGlobalEnableRsc,
   getGlobalInternalRuntimeContext: () => getGlobalInternalRuntimeContext,
+  getGlobalIsRscClient: () => getGlobalIsRscClient,
   getGlobalLayoutApp: () => getGlobalLayoutApp,
   getGlobalRSCRoot: () => getGlobalRSCRoot,
   getGlobalRoutes: () => getGlobalRoutes,
   getInitialContext: () => import_runtime.getInitialContext,
+  getServerPayload: () => import_serverPayload.getServerPayload,
   setGlobalContext: () => setGlobalContext,
-  setGlobalInternalRuntimeContext: () => setGlobalInternalRuntimeContext
+  setGlobalInternalRuntimeContext: () => setGlobalInternalRuntimeContext,
+  setServerPayload: () => import_serverPayload.setServerPayload
 });
 module.exports = __toCommonJS(context_exports);
 var import_runtime = require("./runtime");
+var import_serverPayload = require("./serverPayload.server");
 const globalContext = {};
+function getGlobalIsRscClient() {
+  return globalContext.isRscClient;
+}
+function getGlobalEnableRsc() {
+  return globalContext.enableRsc;
+}
 function setGlobalContext(context) {
   globalContext.entryName = context.entryName;
   globalContext.App = context.App;
@@ -42,6 +53,8 @@ function setGlobalContext(context) {
   globalContext.appConfig = typeof context.appConfig === "function" ? context.appConfig() : context.appConfig;
   globalContext.layoutApp = context.layoutApp;
   globalContext.RSCRoot = context.RSCRoot;
+  globalContext.isRscClient = context.isRscClient;
+  globalContext.enableRsc = context.enableRsc;
 }
 function getCurrentEntryName() {
   return globalContext.entryName;
@@ -79,11 +92,15 @@ function getGlobalLayoutApp() {
   getGlobalApp,
   getGlobalAppConfig,
   getGlobalAppInit,
+  getGlobalEnableRsc,
   getGlobalInternalRuntimeContext,
+  getGlobalIsRscClient,
   getGlobalLayoutApp,
   getGlobalRSCRoot,
   getGlobalRoutes,
   getInitialContext,
+  getServerPayload,
   setGlobalContext,
-  setGlobalInternalRuntimeContext
+  setGlobalInternalRuntimeContext,
+  setServerPayload
 });

package/dist/cjs/core/context/serverPayload.server.js

@@ -0,0 +1,40 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var serverPayload_server_exports = {};
+__export(serverPayload_server_exports, {
+  getServerPayload: () => getServerPayload,
+  setServerPayload: () => setServerPayload
+});
+module.exports = __toCommonJS(serverPayload_server_exports);
+var import_node = require("@modern-js/runtime-utils/node");
+const getServerPayload = () => {
+  const context = import_node.storage.useContext();
+  return context === null || context === void 0 ? void 0 : context.serverPayload;
+};
+const setServerPayload = (payload) => {
+  const context = import_node.storage.useContext();
+  if (context) {
+    context.serverPayload = payload;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getServerPayload,
+  setServerPayload
+});

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

@@ -21,15 +21,40 @@ __export(requestHandler_exports, {
   createRequestHandler: () => createRequestHandler
 });
 module.exports = __toCommonJS(requestHandler_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
 var import_node = require("@modern-js/runtime-utils/node");
 var import_request = require("@modern-js/runtime-utils/universal/request");
+var import_react = require("react");
 var import_context = require("../context");
 var import_runtime = require("../context/runtime");
+var import_serverPayload = require("../context/serverPayload.server");
 var import_loaderManager = require("../loader/loaderManager");
-var import_react = require("../react");
+var import_react2 = require("../react");
 var import_constants = require("./constants");
 var import_tracer = require("./tracer");
 var import_utils = require("./utils");
+async function handleRSCRequest(request, Root, context, options, handleRequest) {
+  const serverPayload = (0, import_serverPayload.getServerPayload)();
+  if (typeof serverPayload !== "undefined") {
+    return await handleRequest(request, Root, {
+      ...options,
+      runtimeContext: context,
+      rscRoot: serverPayload
+    });
+  }
+  const App = (0, import_context.getGlobalRSCRoot)();
+  if (App) {
+    return await handleRequest(request, import_react.Fragment, {
+      ...options,
+      runtimeContext: context,
+      rscRoot: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(App, {})
+    });
+  }
+  return await handleRequest(request, Root, {
+    ...options,
+    runtimeContext: context
+  });
+}
 function createSSRContext(request, options) {
   const { config, loaderContext, onError, onTiming, locals, resource, params, responseProxy, logger, metrics, reporter } = options;
   const { nonce, useJsonScript } = config;
@@ -100,10 +125,11 @@ const createRequestHandler = async (handleRequest, createRequestOptions) => {
       request,
       monitors: options.monitors,
       responseProxy,
-      activeDeferreds
+      activeDeferreds,
+      serverPayload: void 0
     }, async () => {
       var _context_routerContext, _context_routerContext1, _context_routerContext2;
-      const Root = (0, import_react.createRoot)();
+      const Root = (0, import_react2.createRoot)();
       const internalRuntimeContext = (0, import_context.getGlobalInternalRuntimeContext)();
       const hooks = internalRuntimeContext.hooks;
       const { routeManifest } = options.resource;
@@ -158,15 +184,25 @@ const createRequestHandler = async (handleRequest, createRequestOptions) => {
       context.initialData = initialData;
       const redirectResponse = getRedirectResponse(initialData);
       if (redirectResponse) {
-        return redirectResponse;
+        if (createRequestOptions === null || createRequestOptions === void 0 ? void 0 : createRequestOptions.enableRsc) {
+          return initialData;
+        } else {
+          return redirectResponse;
+        }
+      }
+      if (!(createRequestOptions === null || createRequestOptions === void 0 ? void 0 : createRequestOptions.enableRsc)) {
+        const { htmlTemplate } = options.resource;
+        options.resource.htmlTemplate = htmlTemplate.replace("</head>", `${import_constants.CHUNK_CSS_PLACEHOLDER}</head>`);
+      }
+      let response;
+      if (createRequestOptions === null || createRequestOptions === void 0 ? void 0 : createRequestOptions.enableRsc) {
+        response = await handleRSCRequest(request, Root, context, options, handleRequest);
+      } else {
+        response = await handleRequest(request, Root, {
+          ...options,
+          runtimeContext: context
+        });
       }
-      const { htmlTemplate } = options.resource;
-      options.resource.htmlTemplate = htmlTemplate.replace("</head>", `${import_constants.CHUNK_CSS_PLACEHOLDER}</head>`);
-      const response = await handleRequest(request, Root, {
-        ...options,
-        runtimeContext: context,
-        RSCRoot: (createRequestOptions === null || createRequestOptions === void 0 ? void 0 : createRequestOptions.enableRsc) && (0, import_context.getGlobalRSCRoot)()
-      });
       Object.entries(responseProxy.headers).forEach(([key, value]) => {
         response.headers.set(key, value);
       });

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

@@ -29,7 +29,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var code_exports = {};
 __export(code_exports, {
   generateCode: () => generateCode,
-  generatorRegisterCode: () => generatorRegisterCode
+  generatorRegisterCode: () => generatorRegisterCode,
+  generatorServerRegisterCode: () => generatorServerRegisterCode
 });
 module.exports = __toCommonJS(code_exports);
 var import_path = __toESM(require("path"));
@@ -107,14 +108,15 @@ const generateCode = async (appContext, config, entrypoints, api, isRouterV5) =>
           code: await templates.fileSystemRoutes({
             metaName,
             routes,
-            ssrMode: useSSG ? "string" : mode,
+            ssrMode: useSSG ? "string" : (0, import_utils.isUseRsc)(config2) ? "stream" : mode,
             nestedRoutesEntry: entrypoint.nestedRoutesEntry,
             entryName: entrypoint.entryName,
             internalDirectory,
-            splitRouteChunks: config2 === null || config2 === void 0 ? void 0 : (_config_output = config2.output) === null || _config_output === void 0 ? void 0 : _config_output.splitRouteChunks
+            splitRouteChunks: config2 === null || config2 === void 0 ? void 0 : (_config_output = config2.output) === null || _config_output === void 0 ? void 0 : _config_output.splitRouteChunks,
+            isRscClient: (0, import_utils.isUseRsc)(config2)
           })
         });
-        if (entrypoint.nestedRoutesEntry && (0, import_utils.isUseSSRBundle)(config2)) {
+        if (entrypoint.nestedRoutesEntry && ((0, import_utils.isUseSSRBundle)(config2) || (0, import_utils.isUseRsc)(config2))) {
           var _config_output1;
           const routesServerFile = (0, import_utils3.getServerLoadersFile)(internalDirectory, entryName);
           const filtedRoutesForServer = (0, import_utils2.filterRoutesForServer)(routes);
@@ -131,7 +133,8 @@ const generateCode = async (appContext, config, entrypoints, api, isRouterV5) =>
             nestedRoutesEntry: entrypoint.nestedRoutesEntry,
             entryName: entrypoint.entryName,
             internalDirectory,
-            splitRouteChunks: config2 === null || config2 === void 0 ? void 0 : (_config_output1 = config2.output) === null || _config_output1 === void 0 ? void 0 : _config_output1.splitRouteChunks
+            splitRouteChunks: config2 === null || config2 === void 0 ? void 0 : (_config_output1 = config2.output) === null || _config_output1 === void 0 ? void 0 : _config_output1.splitRouteChunks,
+            isRscClient: false
           });
           await import_utils.fs.outputFile(import_path.default.resolve(internalDirectory, `./${entryName}/routes.server.js`), serverRoutesCode, "utf8");
         }
@@ -148,8 +151,12 @@ const generateCode = async (appContext, config, entrypoints, api, isRouterV5) =>
 function generatorRegisterCode(internalDirectory, entryName, code) {
   import_utils.fs.outputFileSync(import_path.default.resolve(internalDirectory, `./${entryName}/${import_constants.ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME}.js`), code, "utf8");
 }
+function generatorServerRegisterCode(internalDirectory, entryName, code) {
+  import_utils.fs.outputFileSync(import_path.default.resolve(internalDirectory, `./${entryName}/${import_constants.ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME}.server.js`), code, "utf8");
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   generateCode,
-  generatorRegisterCode
+  generatorRegisterCode,
+  generatorServerRegisterCode
 });

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

@@ -121,7 +121,7 @@ const routesForServer = ({ routesForServerLoaderMatches }) => {
 };
 const createMatchReg = (keyword) => new RegExp(`("${keyword}":\\s)"([^
 ]+)"`, "g");
-const fileSystemRoutes = async ({ metaName, routes, ssrMode, nestedRoutesEntry, entryName, internalDirectory, splitRouteChunks = true }) => {
+const fileSystemRoutes = async ({ metaName, routes, ssrMode, nestedRoutesEntry, entryName, internalDirectory, splitRouteChunks = true, isRscClient = false }) => {
   const components = [];
   const loadings = [];
   const errors = [];
@@ -147,14 +147,14 @@ const fileSystemRoutes = async ({ metaName, routes, ssrMode, nestedRoutesEntry,
     return "";
   };
   const createLazyImport = ({ componentPath, routeId, webpackChunkName, eager }) => {
-    const importOptions = webpackChunkName ? `/* webpackChunkName: "${routeId}" */ ` : eager ? `/* webpackMode: "eager" */ ` : "";
+    const importOptions = webpackChunkName ? `/* webpackChunkName: "${routeId}" */  ` : eager ? `/* webpackMode: "eager" */  ` : "";
     return `() => import(${importOptions}'${componentPath}').then(routeModule => handleRouteModule(routeModule, "${routeId}")).catch(handleRouteModuleError)`;
   };
-  const traverseRouteTree = (route) => {
+  const traverseRouteTree = (route, isRscClient2) => {
     let children;
     if ("children" in route && route.children) {
       var _route_children;
-      children = route === null || route === void 0 ? void 0 : (_route_children = route.children) === null || _route_children === void 0 ? void 0 : _route_children.map(traverseRouteTree);
+      children = route === null || route === void 0 ? void 0 : (_route_children = route.children) === null || _route_children === void 0 ? void 0 : _route_children.map((child) => traverseRouteTree(child, isRscClient2));
     }
     let loading;
     let error;
@@ -237,7 +237,6 @@ const fileSystemRoutes = async ({ metaName, routes, ssrMode, nestedRoutesEntry,
     }
     const finalRoute = {
       ...route,
-      lazyImport,
       loading,
       loader,
       action,
@@ -245,7 +244,10 @@ const fileSystemRoutes = async ({ metaName, routes, ssrMode, nestedRoutesEntry,
       error,
       children
     };
-    if (route._component) {
+    if (!isRscClient2) {
+      finalRoute.lazyImport = lazyImport;
+    }
+    if (route._component && !isRscClient2) {
       finalRoute.component = component;
     }
     if (route.type === "nested" && route._component && (route.loader || route.data)) {
@@ -258,7 +260,7 @@ const fileSystemRoutes = async ({ metaName, routes, ssrMode, nestedRoutesEntry,
   `;
   for (const route of routes) {
     if ("type" in route) {
-      const newRoute = traverseRouteTree(route);
+      const newRoute = traverseRouteTree(route, isRscClient);
       const routeStr = JSON.stringify(newRoute, null, 2);
       const keywords = [
         "component",
@@ -357,9 +359,9 @@ const fileSystemRoutes = async ({ metaName, routes, ssrMode, nestedRoutesEntry,
   `;
   return `
     ${importLazyCode}
-    ${importComponentsCode}
+    ${!isRscClient ? importComponentsCode : ""}
     ${importRuntimeRouterCode}
-    ${rootLayoutCode}
+    ${!isRscClient ? rootLayoutCode : ""}
     ${importLoadingCode}
     ${importErrorComponentsCode}
     ${importLoadersCode}
@@ -398,7 +400,7 @@ function ssrLoaderCombinedModule(entrypoints, entrypoint, config, appContext) {
   }
   return null;
 }
-const runtimeGlobalContext = async ({ entryName, metaName, srcDirectory, nestedRoutesEntry, internalSrcAlias, globalApp }) => {
+const runtimeGlobalContext = async ({ entryName, metaName, srcDirectory, nestedRoutesEntry, internalSrcAlias, globalApp, rscType = false }) => {
   const imports = [
     `import { setGlobalContext } from '@${metaName}/runtime/context';`
   ];
@@ -443,18 +445,40 @@ const runtimeGlobalContext = async ({ entryName, metaName, srcDirectory, nestedR
   } else {
     imports.push(`let layoutApp;`);
   }
-  return `${imports.join("\n")}
+  const isClient = rscType === "client";
+  const enableRsc = Boolean(rscType);
+  if (isClient) {
+    return `${imports.join("\n")}
+
+    import { routes } from './routes';
+
+    const entryName = '${entryName}';
+      setGlobalContext({
+        entryName,
+        layoutApp,
+        routes,
+        appInit,
+        appConfig,
+        isRscClient: true,
+        enableRsc: true,
+      });
+    `;
+  } else {
+    return `${imports.join("\n")}
 
-import { routes } from './routes';
+    import { routes } from './routes';
 
-const entryName = '${entryName}';
-setGlobalContext({
-  entryName,
-  layoutApp,
-  routes,
-  appInit,
-  appConfig,
-});`;
+    const entryName = '${entryName}';
+      setGlobalContext({
+        entryName,
+        layoutApp,
+        routes,
+        appInit,
+        appConfig,
+        enableRsc: ${enableRsc},
+      });
+    `;
+  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {