@modern-js/server-core 2.64.0 → 2.64.2

package/dist/esm/adapters/node/plugins/resource.js

@@ -285,7 +285,7 @@ function _getServerManifest() {
   });
   return _getServerManifest.apply(this, arguments);
 }
-function injectServerManifest(pwd, routes) {
+function injectServerManifest(pwd, routes, manifestPromise) {
   return function() {
     var _ref = _async_to_generator(function(c, next) {
       var logger, serverManifest;
@@ -300,7 +300,7 @@ function injectServerManifest(pwd, routes) {
             logger = c.get("logger");
             return [
               4,
-              getServerManifest(pwd, routes, logger)
+              manifestPromise || getServerManifest(pwd, routes, logger)
             ];
           case 1:
             serverManifest = _state.sent();
@@ -324,6 +324,171 @@ function injectServerManifest(pwd, routes) {
     };
   }();
 }
+function getRscServerManifest(pwd) {
+  return _getRscServerManifest.apply(this, arguments);
+}
+function _getRscServerManifest() {
+  _getRscServerManifest = _async_to_generator(function(pwd) {
+    var rscServerManifest;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          return [
+            4,
+            compatibleRequire(path.join(pwd, "bundles", "react-server-manifest.json")).catch(function(_) {
+              return void 0;
+            })
+          ];
+        case 1:
+          rscServerManifest = _state.sent();
+          return [
+            2,
+            rscServerManifest
+          ];
+      }
+    });
+  });
+  return _getRscServerManifest.apply(this, arguments);
+}
+function getClientManifest(pwd) {
+  return _getClientManifest.apply(this, arguments);
+}
+function _getClientManifest() {
+  _getClientManifest = _async_to_generator(function(pwd) {
+    var rscClientManifest;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          return [
+            4,
+            compatibleRequire(path.join(pwd, "react-client-manifest.json")).catch(function(_) {
+              return void 0;
+            })
+          ];
+        case 1:
+          rscClientManifest = _state.sent();
+          return [
+            2,
+            rscClientManifest
+          ];
+      }
+    });
+  });
+  return _getClientManifest.apply(this, arguments);
+}
+function getRscSSRManifest(pwd) {
+  return _getRscSSRManifest.apply(this, arguments);
+}
+function _getRscSSRManifest() {
+  _getRscSSRManifest = _async_to_generator(function(pwd) {
+    var rscSSRManifest;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          return [
+            4,
+            compatibleRequire(path.join(pwd, "react-ssr-manifest.json")).catch(function(_) {
+              return void 0;
+            })
+          ];
+        case 1:
+          rscSSRManifest = _state.sent();
+          return [
+            2,
+            rscSSRManifest
+          ];
+      }
+    });
+  });
+  return _getRscSSRManifest.apply(this, arguments);
+}
+var injectRscManifestPlugin = function() {
+  return {
+    name: "@modern-js/plugin-inject-rsc-manifest",
+    setup: function setup(api) {
+      return {
+        prepare: function prepare() {
+          return _async_to_generator(function() {
+            var _api_useAppContext, middlewares, pwd;
+            return _ts_generator(this, function(_state) {
+              _api_useAppContext = api.useAppContext(), middlewares = _api_useAppContext.middlewares, pwd = _api_useAppContext.distDirectory;
+              middlewares.push({
+                name: "inject-rsc-manifest",
+                handler: function() {
+                  var _ref = _async_to_generator(function(c, next) {
+                    var rscServerManifest, rscClientManifest, rscSSRManifest;
+                    return _ts_generator(this, function(_state2) {
+                      switch (_state2.label) {
+                        case 0:
+                          if (!!c.get("rscServerManifest"))
+                            return [
+                              3,
+                              2
+                            ];
+                          return [
+                            4,
+                            getRscServerManifest(pwd)
+                          ];
+                        case 1:
+                          rscServerManifest = _state2.sent();
+                          c.set("rscServerManifest", rscServerManifest);
+                          _state2.label = 2;
+                        case 2:
+                          if (!!c.get("rscClientManifest"))
+                            return [
+                              3,
+                              4
+                            ];
+                          return [
+                            4,
+                            getClientManifest(pwd)
+                          ];
+                        case 3:
+                          rscClientManifest = _state2.sent();
+                          c.set("rscClientManifest", rscClientManifest);
+                          _state2.label = 4;
+                        case 4:
+                          if (!!c.get("rscSSRManifest"))
+                            return [
+                              3,
+                              6
+                            ];
+                          return [
+                            4,
+                            getRscSSRManifest(pwd)
+                          ];
+                        case 5:
+                          rscSSRManifest = _state2.sent();
+                          c.set("rscSSRManifest", rscSSRManifest);
+                          _state2.label = 6;
+                        case 6:
+                          return [
+                            4,
+                            next()
+                          ];
+                        case 7:
+                          _state2.sent();
+                          return [
+                            2
+                          ];
+                      }
+                    });
+                  });
+                  return function(c, next) {
+                    return _ref.apply(this, arguments);
+                  };
+                }()
+              });
+              return [
+                2
+              ];
+            });
+          })();
+        }
+      };
+    }
+  };
+};
 var injectResourcePlugin = function() {
   return {
     name: "@modern-js/plugin-inject-resource",
@@ -331,16 +496,16 @@ var injectResourcePlugin = function() {
       return {
         prepare: function prepare() {
           return _async_to_generator(function() {
-            var _api_useAppContext, middlewares, routes, pwd, htmlTemplatePromise;
+            var _api_useAppContext, middlewares, routes, pwd, htmlTemplatePromise, manifestPromise;
             return _ts_generator(this, function(_state) {
               _api_useAppContext = api.useAppContext(), middlewares = _api_useAppContext.middlewares, routes = _api_useAppContext.routes, pwd = _api_useAppContext.distDirectory;
               if (isProd()) {
-                getServerManifest(pwd, routes || [], console);
+                manifestPromise = getServerManifest(pwd, routes || [], console);
                 htmlTemplatePromise = getHtmlTemplates(pwd, routes || []);
               }
               middlewares.push({
                 name: "inject-server-manifest",
-                handler: injectServerManifest(pwd, routes)
+                handler: injectServerManifest(pwd, routes, manifestPromise)
               });
               middlewares.push({
                 name: "inject-html",
@@ -357,9 +522,13 @@ var injectResourcePlugin = function() {
   };
 };
 export {
+  getClientManifest,
   getHtmlTemplates,
+  getRscSSRManifest,
+  getRscServerManifest,
   getServerManifest,
   injectResourcePlugin,
+  injectRscManifestPlugin,
   injectServerManifest,
   injectTemplates
 };

package/dist/esm/plugins/default.js

@@ -2,14 +2,22 @@ import { logPlugin } from "./log";
 import { initMonitorsPlugin, injectServerTiming, injectloggerPluigin } from "./monitors";
 import { processedByPlugin } from "./processedBy";
 import { injectRenderHandlerPlugin } from "./render";
+function createSilenceLogger() {
+  return new Proxy({}, {
+    get: function() {
+      return function() {
+      };
+    }
+  });
+}
 function createDefaultPlugins() {
   var options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
   var plugins = [
+    logPlugin(),
     initMonitorsPlugin(),
     injectRenderHandlerPlugin(options),
-    injectloggerPluigin(options.logger),
+    injectloggerPluigin(options.logger ? options.logger : createSilenceLogger()),
     injectServerTiming(),
-    logPlugin(),
     processedByPlugin()
   ];
   return plugins;

package/dist/esm/plugins/log.js

@@ -41,7 +41,7 @@ function log(fn, prefix, method, path) {
 function logHandler() {
   return function() {
     var _logger = _async_to_generator(function(c, next) {
-      var method, monitors, path, logFn, start;
+      var _c_env_node_res, _c_env_node, _c_env, method, monitors, path, logFn, start, _c_env_node_res_statusCode;
       return _ts_generator(this, function(_state) {
         switch (_state.label) {
           case 0:
@@ -72,7 +72,7 @@ function logHandler() {
             ];
           case 3:
             _state.sent();
-            log(logFn, "-->", method, path, c.res.status, time(start));
+            log(logFn, "-->", method, path, (_c_env_node_res_statusCode = c === null || c === void 0 ? void 0 : (_c_env = c.env) === null || _c_env === void 0 ? void 0 : (_c_env_node = _c_env.node) === null || _c_env_node === void 0 ? void 0 : (_c_env_node_res = _c_env_node.res) === null || _c_env_node_res === void 0 ? void 0 : _c_env_node_res.statusCode) !== null && _c_env_node_res_statusCode !== void 0 ? _c_env_node_res_statusCode : c.res.status, time(start));
             return [
               2
             ];

package/dist/esm/plugins/render/index.js

@@ -133,7 +133,7 @@ function getPageRoutes(routes) {
 function createRenderHandler(render) {
   return function() {
     var _ref = _async_to_generator(function(c, _) {
-      var _c_env_node, logger, reporter, monitors, templates, serverManifest, locals, metrics, matchPathname, matchEntryName, loaderContext, request, nodeReq, res, body, status, headers, headersData;
+      var _c_env_node, logger, reporter, monitors, templates, serverManifest, rscServerManifest, rscClientManifest, rscSSRManifest, locals, metrics, matchPathname, matchEntryName, loaderContext, request, nodeReq, res, body, status, headers, headersData;
       return _ts_generator(this, function(_state) {
         switch (_state.label) {
           case 0:
@@ -142,6 +142,9 @@ function createRenderHandler(render) {
             monitors = c.get("monitors");
             templates = c.get("templates") || {};
             serverManifest = c.get("serverManifest") || {};
+            rscServerManifest = c.get("rscServerManifest");
+            rscClientManifest = c.get("rscClientManifest");
+            rscSSRManifest = c.get("rscSSRManifest");
             locals = c.get("locals");
             metrics = c.get("metrics");
             matchPathname = c.get("matchPathname");
@@ -159,6 +162,9 @@ function createRenderHandler(render) {
                 templates,
                 metrics,
                 serverManifest,
+                rscServerManifest,
+                rscClientManifest,
+                rscSSRManifest,
                 loaderContext,
                 locals,
                 matchPathname,

package/dist/esm/plugins/render/render.js

@@ -10,8 +10,10 @@ import { cutNameByHyphen } from "@modern-js/utils/universal";
 import { TrieRouter } from "hono/router/trie-router";
 import { X_MODERNJS_RENDER } from "../../constants";
 import { uniqueKeyByRoute } from "../../utils";
-import { ErrorDigest, createErrorHtml, getPathname, getRuntimeEnv, onError as onErrorFn, parseHeaders, parseQuery, sortRoutes } from "../../utils";
+import { ErrorDigest, createErrorHtml, getPathname, getRuntimeEnv, parseHeaders, parseQuery, sortRoutes } from "../../utils";
 import { dataHandler } from "./dataHandler";
+import { renderRscHandler } from "./renderRscHandler";
+import { serverActionHandler } from "./serverActionHandler";
 import { ssrRender } from "./ssrRender";
 var DYNAMIC_ROUTE_REG = /\/:./;
 function getRouter(routes) {
@@ -76,31 +78,31 @@ function createRender(_) {
 }
 function _createRender() {
   _createRender = _async_to_generator(function(param) {
-    var routes, pwd, metaName, staticGenerate, cacheConfig, forceCSR, config, onFallbackFn, router;
+    var routes, pwd, metaName, staticGenerate, cacheConfig, forceCSR, config, onFallback, router;
     return _ts_generator(this, function(_state) {
-      routes = param.routes, pwd = param.pwd, metaName = param.metaName, staticGenerate = param.staticGenerate, cacheConfig = param.cacheConfig, forceCSR = param.forceCSR, config = param.config, onFallbackFn = param.onFallback;
+      routes = param.routes, pwd = param.pwd, metaName = param.metaName, staticGenerate = param.staticGenerate, cacheConfig = param.cacheConfig, forceCSR = param.forceCSR, config = param.config, onFallback = param.onFallback;
       router = getRouter(routes);
       return [
         2,
         function() {
           var _ref = _async_to_generator(function(req, param2) {
-            var logger, reporter, metrics, monitors, nodeReq, templates, serverManifest, locals, matchEntryName, matchPathname, loaderContext, forMatchpathname, _matchRoute, routeInfo, params, framework, fallbackHeader, fallbackReason, onFallback, html, renderMode, headerData, onError, onTiming, onBoundError, renderOptions, response, _tmp;
+            var logger, reporter, metrics, monitors, nodeReq, templates, serverManifest, rscClientManifest, rscSSRManifest, rscServerManifest, locals, matchEntryName, matchPathname, loaderContext, forMatchpathname, _matchRoute, routeInfo, params, framework, fallbackHeader, fallbackReason, fallbackWrapper, html, renderMode, headerData, onError, onTiming, renderOptions, response, _tmp;
             return _ts_generator(this, function(_state2) {
               switch (_state2.label) {
                 case 0:
-                  logger = param2.logger, reporter = param2.reporter, metrics = param2.metrics, monitors = param2.monitors, nodeReq = param2.nodeReq, templates = param2.templates, serverManifest = param2.serverManifest, locals = param2.locals, matchEntryName = param2.matchEntryName, matchPathname = param2.matchPathname, loaderContext = param2.loaderContext;
+                  logger = param2.logger, reporter = param2.reporter, metrics = param2.metrics, monitors = param2.monitors, nodeReq = param2.nodeReq, templates = param2.templates, serverManifest = param2.serverManifest, rscClientManifest = param2.rscClientManifest, rscSSRManifest = param2.rscSSRManifest, rscServerManifest = param2.rscServerManifest, locals = param2.locals, matchEntryName = param2.matchEntryName, matchPathname = param2.matchPathname, loaderContext = param2.loaderContext;
                   forMatchpathname = matchPathname !== null && matchPathname !== void 0 ? matchPathname : getPathname(req);
                   _matchRoute = _sliced_to_array(matchRoute(router, forMatchpathname, matchEntryName), 2), routeInfo = _matchRoute[0], params = _matchRoute[1];
                   framework = metaName || "modern-js";
                   fallbackHeader = "x-".concat(cutNameByHyphen(framework), "-ssr-fallback");
                   fallbackReason = null;
-                  onFallback = function() {
+                  fallbackWrapper = function() {
                     var _ref2 = _async_to_generator(function(reason, error) {
                       return _ts_generator(this, function(_state3) {
                         fallbackReason = reason;
                         return [
                           2,
-                          onFallbackFn === null || onFallbackFn === void 0 ? void 0 : onFallbackFn(reason, {
+                          onFallback === null || onFallback === void 0 ? void 0 : onFallback(reason, {
                             logger,
                             reporter,
                             metrics
@@ -108,7 +110,7 @@ function _createRender() {
                         ];
                       });
                     });
-                    return function onFallback2(reason, error) {
+                    return function fallbackWrapper2(reason, error) {
                       return _ref2.apply(this, arguments);
                     };
                   }();
@@ -137,39 +139,17 @@ function _createRender() {
                   }
                   return [
                     4,
-                    getRenderMode(req, fallbackHeader, routeInfo.isSSR, forceCSR, nodeReq, onFallback)
+                    getRenderMode(req, fallbackHeader, routeInfo.isSSR, forceCSR, nodeReq, fallbackWrapper)
                   ];
                 case 1:
                   renderMode = _state2.sent();
                   headerData = parseHeaders(req);
-                  onError = function(e) {
-                    monitors === null || monitors === void 0 ? void 0 : monitors.error("SSR Error - ".concat(_instanceof(e, Error) ? e.name : e, ", error = %s, req.url = %s, req.headers = %o"), _instanceof(e, Error) ? e.stack || e.message : e, forMatchpathname, getHeadersWithoutCookie(headerData));
+                  onError = function(e, key) {
+                    monitors === null || monitors === void 0 ? void 0 : monitors.error("SSR Error - ".concat(key || (_instanceof(e, Error) ? e.name : e), ", error = %s, req.url = %s, req.headers = %o"), _instanceof(e, Error) ? e.stack || e.message : e, forMatchpathname, getHeadersWithoutCookie(headerData));
                   };
                   onTiming = function(name, dur) {
                     monitors === null || monitors === void 0 ? void 0 : monitors.timing(name, dur, "SSR");
                   };
-                  onBoundError = function() {
-                    var _ref2 = _async_to_generator(function(e) {
-                      return _ts_generator(this, function(_state3) {
-                        switch (_state3.label) {
-                          case 0:
-                            onErrorFn(ErrorDigest.ERENDER, e, monitors, req);
-                            return [
-                              4,
-                              onFallback === null || onFallback === void 0 ? void 0 : onFallback("error", e)
-                            ];
-                          case 1:
-                            _state3.sent();
-                            return [
-                              2
-                            ];
-                        }
-                      });
-                    });
-                    return function onBoundError2(e) {
-                      return _ref2.apply(this, arguments);
-                    };
-                  }();
                   renderOptions = {
                     pwd,
                     html,
@@ -184,6 +164,9 @@ function _createRender() {
                     logger,
                     metrics,
                     locals,
+                    rscClientManifest,
+                    rscSSRManifest,
+                    rscServerManifest,
                     serverManifest,
                     loaderContext: loaderContext || /* @__PURE__ */ new Map(),
                     onError,
@@ -195,20 +178,30 @@ function _createRender() {
                         3,
                         2
                       ];
-                    case "ssr":
+                    case "rsc-tree":
                       return [
                         3,
                         6
                       ];
+                    case "rsc-action":
+                      return [
+                        3,
+                        8
+                      ];
+                    case "ssr":
+                      return [
+                        3,
+                        10
+                      ];
                     case "csr":
                       return [
                         3,
-                        6
+                        10
                       ];
                   }
                   return [
                     3,
-                    8
+                    12
                   ];
                 case 2:
                   return [
@@ -224,7 +217,7 @@ function _createRender() {
                     ];
                   return [
                     4,
-                    renderHandler(req, renderOptions, "ssr", onBoundError)
+                    renderHandler(req, renderOptions, "ssr", fallbackWrapper)
                   ];
                 case 4:
                   _tmp = _state2.sent();
@@ -233,22 +226,44 @@ function _createRender() {
                   response = _tmp;
                   return [
                     3,
-                    9
+                    13
                   ];
                 case 6:
                   return [
                     4,
-                    renderHandler(req, renderOptions, renderMode, onBoundError)
+                    renderRscHandler(req, renderOptions)
                   ];
                 case 7:
                   response = _state2.sent();
                   return [
                     3,
-                    9
+                    13
                   ];
                 case 8:
-                  throw new Error("Unknown render mode: ".concat(renderMode));
+                  return [
+                    4,
+                    serverActionHandler(req, renderOptions)
+                  ];
                 case 9:
+                  response = _state2.sent();
+                  return [
+                    3,
+                    13
+                  ];
+                case 10:
+                  return [
+                    4,
+                    renderHandler(req, renderOptions, renderMode, fallbackWrapper)
+                  ];
+                case 11:
+                  response = _state2.sent();
+                  return [
+                    3,
+                    13
+                  ];
+                case 12:
+                  throw new Error("Unknown render mode: ".concat(renderMode));
+                case 13:
                   if (fallbackReason) {
                     response.headers.set(fallbackHeader, "1;reason=".concat(fallbackReason));
                   }
@@ -268,11 +283,11 @@ function _createRender() {
   });
   return _createRender.apply(this, arguments);
 }
-function renderHandler(request, options, mode, onError) {
+function renderHandler(request, options, mode, fallbackWrapper) {
   return _renderHandler.apply(this, arguments);
 }
 function _renderHandler() {
-  _renderHandler = _async_to_generator(function(request, options, mode, onError) {
+  _renderHandler = _async_to_generator(function(request, options, mode, fallbackWrapper) {
     var _options_config_server, response, serverManifest, ssrByRouteIds, runtimeEnv, nestedRoutesJson, routes, urlPath, pathToFileURL, matchRoutes, url, matchedRoutes, _lastMatch_route, lastMatch, e, routeInfo;
     function applyExtendHeaders(r, route) {
       Object.entries(route.responseHeaders || {}).forEach(function(param) {
@@ -350,9 +365,10 @@ function _renderHandler() {
           ];
         case 6:
           e = _state.sent();
+          options.onError(e, ErrorDigest.ERENDER);
           return [
             4,
-            onError(e)
+            fallbackWrapper("error", e)
           ];
         case 7:
           _state.sent();
@@ -391,6 +407,18 @@ function _getRenderMode() {
       switch (_state.label) {
         case 0:
           query = parseQuery(req);
+          if (req.headers.get("x-rsc-action")) {
+            return [
+              2,
+              "rsc-action"
+            ];
+          }
+          if (req.headers.get("x-rsc-tree")) {
+            return [
+              2,
+              "rsc-tree"
+            ];
+          }
           if (!isSSR)
             return [
               3,

package/dist/esm/plugins/render/renderRscHandler.js

@@ -0,0 +1,49 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { MAIN_ENTRY_NAME } from "@modern-js/utils/universal/constants";
+var renderRscHandler = function() {
+  var _ref = _async_to_generator(function(req, param) {
+    var serverManifest, routeInfo, rscClientManifest, _serverManifest_renderBundles, serverBundle, rscRequestHandler;
+    return _ts_generator(this, function(_state) {
+      serverManifest = param.serverManifest, routeInfo = param.routeInfo, rscClientManifest = param.rscClientManifest;
+      serverBundle = serverManifest === null || serverManifest === void 0 ? void 0 : (_serverManifest_renderBundles = serverManifest.renderBundles) === null || _serverManifest_renderBundles === void 0 ? void 0 : _serverManifest_renderBundles[routeInfo.entryName || MAIN_ENTRY_NAME];
+      if (!serverBundle) {
+        return [
+          2,
+          new Response("Cannot find server bundle for RSC", {
+            status: 500
+          })
+        ];
+      }
+      rscRequestHandler = serverBundle.rscRequestHandler;
+      if (!rscRequestHandler) {
+        return [
+          2,
+          new Response("Cannot find request handler for RSC", {
+            status: 500
+          })
+        ];
+      }
+      if (!rscClientManifest) {
+        return [
+          2,
+          new Response("Cannot find rsc client manifest", {
+            status: 500
+          })
+        ];
+      }
+      return [
+        2,
+        rscRequestHandler({
+          clientManifest: rscClientManifest
+        })
+      ];
+    });
+  });
+  return function renderRscHandler2(req, _) {
+    return _ref.apply(this, arguments);
+  };
+}();
+export {
+  renderRscHandler
+};

package/dist/esm/plugins/render/serverActionHandler.js

@@ -0,0 +1,49 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { MAIN_ENTRY_NAME } from "@modern-js/utils/universal/constants";
+var serverActionHandler = function() {
+  var _ref = _async_to_generator(function(req, param) {
+    var serverManifest, routeInfo, rscClientManifest, _serverManifest_renderBundles, serverBundle, handleAction;
+    return _ts_generator(this, function(_state) {
+      serverManifest = param.serverManifest, routeInfo = param.routeInfo, rscClientManifest = param.rscClientManifest;
+      serverBundle = serverManifest === null || serverManifest === void 0 ? void 0 : (_serverManifest_renderBundles = serverManifest.renderBundles) === null || _serverManifest_renderBundles === void 0 ? void 0 : _serverManifest_renderBundles[routeInfo.entryName || MAIN_ENTRY_NAME];
+      if (!serverBundle) {
+        return [
+          2,
+          new Response("Cannot find server bundle for server action", {
+            status: 500
+          })
+        ];
+      }
+      handleAction = serverBundle.handleAction;
+      if (!handleAction) {
+        return [
+          2,
+          new Response("Cannot find server action handler", {
+            status: 500
+          })
+        ];
+      }
+      if (!rscClientManifest) {
+        return [
+          2,
+          new Response("Cannot find rsc client manifest", {
+            status: 500
+          })
+        ];
+      }
+      return [
+        2,
+        handleAction(req, {
+          clientManifest: rscClientManifest
+        })
+      ];
+    });
+  });
+  return function serverActionHandler2(req, _) {
+    return _ref.apply(this, arguments);
+  };
+}();
+export {
+  serverActionHandler
+};

package/dist/esm/plugins/render/ssrRender.js

@@ -11,11 +11,11 @@ function ssrRender(request, _) {
 }
 function _ssrRender() {
   _ssrRender = _async_to_generator(function(request, param) {
-    var routeInfo, html, userConfig, staticGenerate, nodeReq, serverManifest, locals, params, loaderContext, reporter, cacheConfig, logger, metrics, onError, onTiming, _serverManifest_renderBundles, entryName, loadableStats, routeManifest, headers, key, renderBundle, requestHandler, config, requestHandlerOptions, cacheControl, response;
+    var routeInfo, html, userConfig, staticGenerate, nodeReq, serverManifest, rscSSRManifest, rscClientManifest, rscServerManifest, locals, params, loaderContext, reporter, cacheConfig, logger, metrics, onError, onTiming, _serverManifest_renderBundles, entryName, loadableStats, routeManifest, headers, key, renderBundle, requestHandler, config, requestHandlerOptions, cacheControl, response;
     return _ts_generator(this, function(_state) {
       switch (_state.label) {
         case 0:
-          routeInfo = param.routeInfo, html = param.html, userConfig = param.config, staticGenerate = param.staticGenerate, nodeReq = param.nodeReq, serverManifest = param.serverManifest, locals = param.locals, params = param.params, loaderContext = param.loaderContext, reporter = param.reporter, cacheConfig = param.cacheConfig, logger = param.logger, metrics = param.metrics, onError = param.onError, onTiming = param.onTiming;
+          routeInfo = param.routeInfo, html = param.html, userConfig = param.config, staticGenerate = param.staticGenerate, nodeReq = param.nodeReq, serverManifest = param.serverManifest, rscSSRManifest = param.rscSSRManifest, rscClientManifest = param.rscClientManifest, rscServerManifest = param.rscServerManifest, locals = param.locals, params = param.params, loaderContext = param.loaderContext, reporter = param.reporter, cacheConfig = param.cacheConfig, logger = param.logger, metrics = param.metrics, onError = param.onError, onTiming = param.onTiming;
           entryName = routeInfo.entryName;
           loadableStats = serverManifest.loadableStats || {};
           routeManifest = serverManifest.routeManifest || {};
@@ -49,6 +49,9 @@ function _ssrRender() {
             params,
             loaderContext,
             config,
+            rscSSRManifest,
+            rscClientManifest,
+            rscServerManifest,
             locals,
             reporter,
             staticGenerate,

package/dist/esm/utils/error.js

@@ -13,7 +13,7 @@ var ErrorDigest;
 (function(ErrorDigest2) {
   ErrorDigest2["ENOTF"] = "Page could not be found";
   ErrorDigest2["EINTER"] = "Internal server error";
-  ErrorDigest2["ERENDER"] = "SSR render failed";
+  ErrorDigest2["ERENDER"] = "SSR render fallback";
 })(ErrorDigest || (ErrorDigest = {}));
 function onError(digest, error, monitors, req) {
   var headerData = req && parseHeaders(req);