@modern-js/server-core 2.64.1 → 2.64.3

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/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);

package/dist/esm-node/adapters/node/index.js

@@ -1,6 +1,6 @@
 import { httpCallBack2HonoMid, connectMid2HonoMid } from "./hono";
 import { createNodeServer, sendResponse, createWebRequest, writeReadableStreamToWritable } from "./node";
-import { serverStaticPlugin, injectResourcePlugin, getHtmlTemplates, getServerManifest, injectNodeSeverPlugin } from "./plugins";
+import { serverStaticPlugin, injectResourcePlugin, getHtmlTemplates, getServerManifest, injectNodeSeverPlugin, injectRscManifestPlugin } from "./plugins";
 import { loadServerPlugins, loadServerEnv, loadServerRuntimeConfig, loadServerCliConfig, loadCacheConfig } from "./helper";
 export {
   connectMid2HonoMid,
@@ -11,6 +11,7 @@ export {
   httpCallBack2HonoMid,
   injectNodeSeverPlugin,
   injectResourcePlugin,
+  injectRscManifestPlugin,
   loadCacheConfig,
   loadServerCliConfig,
   loadServerEnv,

package/dist/esm-node/adapters/node/node.js

@@ -22,7 +22,7 @@ const createWebRequest = (req, res, body) => {
     signal: controller.signal
   };
   res.on("close", () => controller.abort("res closed"));
-  if (body || !(method === "GET" || method === "HEAD") && ((_req_url = req.url) === null || _req_url === void 0 ? void 0 : _req_url.includes("__loader")) || req.headers["x-mf-micro"]) {
+  if (body || !(method === "GET" || method === "HEAD") && ((_req_url = req.url) === null || _req_url === void 0 ? void 0 : _req_url.includes("__loader")) || req.headers["x-mf-micro"] || req.headers["x-rsc-action"] || req.headers["x-parse-through-body"]) {
     init.body = body !== null && body !== void 0 ? body : createReadableStreamFromReadable(req);
     init.duplex = "half";
   }

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

@@ -66,16 +66,56 @@ async function getServerManifest(pwd, routes, logger) {
     nestedRoutesJson
   };
 }
-function injectServerManifest(pwd, routes) {
+function injectServerManifest(pwd, routes, manifestPromise) {
   return async (c, next) => {
     if (routes && !c.get("serverManifest")) {
       const logger = c.get("logger");
-      const serverManifest = await getServerManifest(pwd, routes, logger);
+      const serverManifest = await (manifestPromise || getServerManifest(pwd, routes, logger));
       c.set("serverManifest", serverManifest);
     }
     await next();
   };
 }
+async function getRscServerManifest(pwd) {
+  const rscServerManifest = await compatibleRequire(path.join(pwd, "bundles", "react-server-manifest.json")).catch((_) => void 0);
+  return rscServerManifest;
+}
+async function getClientManifest(pwd) {
+  const rscClientManifest = await compatibleRequire(path.join(pwd, "react-client-manifest.json")).catch((_) => void 0);
+  return rscClientManifest;
+}
+async function getRscSSRManifest(pwd) {
+  const rscSSRManifest = await compatibleRequire(path.join(pwd, "react-ssr-manifest.json")).catch((_) => void 0);
+  return rscSSRManifest;
+}
+const injectRscManifestPlugin = () => ({
+  name: "@modern-js/plugin-inject-rsc-manifest",
+  setup(api) {
+    return {
+      async prepare() {
+        const { middlewares, distDirectory: pwd } = api.useAppContext();
+        middlewares.push({
+          name: "inject-rsc-manifest",
+          handler: async (c, next) => {
+            if (!c.get("rscServerManifest")) {
+              const rscServerManifest = await getRscServerManifest(pwd);
+              c.set("rscServerManifest", rscServerManifest);
+            }
+            if (!c.get("rscClientManifest")) {
+              const rscClientManifest = await getClientManifest(pwd);
+              c.set("rscClientManifest", rscClientManifest);
+            }
+            if (!c.get("rscSSRManifest")) {
+              const rscSSRManifest = await getRscSSRManifest(pwd);
+              c.set("rscSSRManifest", rscSSRManifest);
+            }
+            await next();
+          }
+        });
+      }
+    };
+  }
+});
 const injectResourcePlugin = () => ({
   name: "@modern-js/plugin-inject-resource",
   setup(api) {
@@ -83,13 +123,14 @@ const injectResourcePlugin = () => ({
       async prepare() {
         const { middlewares, routes, distDirectory: pwd } = api.useAppContext();
         let htmlTemplatePromise;
+        let manifestPromise;
         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",
@@ -100,9 +141,13 @@ const injectResourcePlugin = () => ({
   }
 });
 export {
+  getClientManifest,
   getHtmlTemplates,
+  getRscSSRManifest,
+  getRscServerManifest,
   getServerManifest,
   injectResourcePlugin,
+  injectRscManifestPlugin,
   injectServerManifest,
   injectTemplates
 };

package/dist/esm-node/plugins/default.js

@@ -2,13 +2,21 @@ import { logPlugin } from "./log";
 import { initMonitorsPlugin, injectServerTiming, injectloggerPluigin } from "./monitors";
 import { processedByPlugin } from "./processedBy";
 import { injectRenderHandlerPlugin } from "./render";
+function createSilenceLogger() {
+  return new Proxy({}, {
+    get: () => {
+      return () => {
+      };
+    }
+  });
+}
 function createDefaultPlugins(options = {}) {
   const plugins = [
+    logPlugin(),
     initMonitorsPlugin(),
     injectRenderHandlerPlugin(options),
-    injectloggerPluigin(options.logger),
+    injectloggerPluigin(options.logger ? options.logger : createSilenceLogger()),
     injectServerTiming(),
-    logPlugin(),
     processedByPlugin()
   ];
   return plugins;

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

@@ -65,6 +65,9 @@ function createRenderHandler(render) {
     const monitors = c.get("monitors");
     const templates = c.get("templates") || {};
     const serverManifest = c.get("serverManifest") || {};
+    const rscServerManifest = c.get("rscServerManifest");
+    const rscClientManifest = c.get("rscClientManifest");
+    const rscSSRManifest = c.get("rscSSRManifest");
     const locals = c.get("locals");
     const metrics = c.get("metrics");
     const matchPathname = c.get("matchPathname");
@@ -80,6 +83,9 @@ function createRenderHandler(render) {
       templates,
       metrics,
       serverManifest,
+      rscServerManifest,
+      rscClientManifest,
+      rscSSRManifest,
       loaderContext,
       locals,
       matchPathname,