@modern-js/server-core 2.53.0 → 2.54.1

package/dist/cjs/pluginManager.js

@@ -0,0 +1,106 @@
+"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 pluginManager_exports = {};
+__export(pluginManager_exports, {
+  PluginManager: () => PluginManager
+});
+module.exports = __toCommonJS(pluginManager_exports);
+var import_class_private_field_get = require("@swc/helpers/_/_class_private_field_get");
+var import_class_private_field_init = require("@swc/helpers/_/_class_private_field_init");
+var import_class_private_field_set = require("@swc/helpers/_/_class_private_field_set");
+var import_class_private_method_get = require("@swc/helpers/_/_class_private_method_get");
+var import_class_private_method_init = require("@swc/helpers/_/_class_private_method_init");
+var import_plugin = require("@modern-js/plugin");
+var import_utils = require("./utils");
+var _appContext = /* @__PURE__ */ new WeakMap(), _plugins = /* @__PURE__ */ new WeakMap(), _options = /* @__PURE__ */ new WeakMap(), _configContext = /* @__PURE__ */ new WeakMap(), _createCoreManager = /* @__PURE__ */ new WeakSet(), _initConfigContext = /* @__PURE__ */ new WeakSet();
+class PluginManager {
+  async init() {
+    const coreManager = (0, import_class_private_method_get._)(this, _createCoreManager, createCoreManager).call(this);
+    const runner = await coreManager.init();
+    await (0, import_class_private_method_get._)(this, _initConfigContext, initConfigContext).call(this, runner);
+    return runner;
+  }
+  addPlugins(plugins) {
+    (0, import_class_private_field_get._)(this, _plugins).push(...plugins);
+  }
+  constructor(options) {
+    (0, import_class_private_method_init._)(this, _createCoreManager);
+    (0, import_class_private_method_init._)(this, _initConfigContext);
+    (0, import_class_private_field_init._)(this, _appContext, {
+      writable: true,
+      value: void 0
+    });
+    (0, import_class_private_field_init._)(this, _plugins, {
+      writable: true,
+      value: void 0
+    });
+    (0, import_class_private_field_init._)(this, _options, {
+      writable: true,
+      value: void 0
+    });
+    (0, import_class_private_field_init._)(this, _configContext, {
+      writable: true,
+      value: void 0
+    });
+    (0, import_class_private_field_set._)(this, _plugins, []);
+    (0, import_class_private_field_set._)(this, _configContext, (0, import_plugin.createContext)({}));
+    (0, import_class_private_field_set._)(this, _appContext, options.appContext);
+    (0, import_class_private_field_set._)(this, _configContext, (0, import_plugin.createContext)(options.serverConfig || {}));
+    (0, import_class_private_field_set._)(this, _options, options);
+  }
+}
+function createCoreManager() {
+  var _class_private_field_get_serverConfig;
+  const hooks = {
+    config: (0, import_plugin.createAsyncWaterfall)(),
+    prepare: (0, import_plugin.createAsyncWaterfall)(),
+    reset: (0, import_plugin.createParallelWorkflow)(),
+    prepareWebServer: (0, import_plugin.createAsyncPipeline)(),
+    fallback: (0, import_plugin.createParallelWorkflow)(),
+    prepareApiServer: (0, import_plugin.createAsyncPipeline)(),
+    afterMatch: (0, import_plugin.createAsyncPipeline)(),
+    afterRender: (0, import_plugin.createAsyncPipeline)(),
+    afterStreamingRender: (0, import_plugin.createAsyncPipeline)()
+  };
+  const pluginApi = {
+    useConfigContext: () => (0, import_class_private_field_get._)(this, _configContext).use().value,
+    useAppContext: () => (0, import_class_private_field_get._)(this, _appContext).use().value,
+    setAppContext: (c) => (0, import_class_private_field_get._)(this, _appContext).set(c)
+  };
+  const coreManager = (0, import_plugin.createAsyncManager)(hooks, pluginApi);
+  this.addPlugins(((_class_private_field_get_serverConfig = (0, import_class_private_field_get._)(this, _options).serverConfig) === null || _class_private_field_get_serverConfig === void 0 ? void 0 : _class_private_field_get_serverConfig.plugins) || []);
+  (0, import_class_private_field_get._)(this, _plugins).forEach((p) => {
+    const plugin = coreManager.createPlugin(p.setup, p);
+    coreManager.usePlugin(plugin);
+  });
+  return coreManager;
+}
+async function initConfigContext(runner) {
+  const { serverConfig, cliConfig } = (0, import_class_private_field_get._)(this, _options);
+  const mergedConfig = (0, import_utils.loadConfig)({
+    cliConfig,
+    serverConfig: serverConfig || {}
+  });
+  const finalServerConfig = await runner.config(mergedConfig);
+  (0, import_class_private_field_get._)(this, _configContext).set(finalServerConfig);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PluginManager
+});

package/dist/cjs/{base/middlewares → plugins}/customServer/index.js

@@ -19,7 +19,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var customServer_exports = {};
 __export(customServer_exports, {
   CustomServer: () => CustomServer,
-  getLoaderCtx: () => import_loader2.getLoaderCtx
+  getLoaderCtx: () => import_loader2.getLoaderCtx,
+  getServerMidFromUnstableMid: () => getServerMidFromUnstableMid
 });
 module.exports = __toCommonJS(customServer_exports);
 var import_time = require("@modern-js/runtime-utils/time");
@@ -102,7 +103,7 @@ class CustomServer {
       return;
     }
     if (Array.isArray(serverMiddleware)) {
-      return getUnstableMiddlewares(serverMiddleware);
+      return getServerMidFromUnstableMid(serverMiddleware);
     }
     return async (c, next) => {
       var _c_env_node_res, _c_env_node, _c_env;
@@ -142,6 +143,14 @@ class CustomServer {
     });
   }
 }
+function getServerMidFromUnstableMid(serverMiddleware) {
+  return serverMiddleware.map((middleware) => {
+    return async (c, next) => {
+      const context = createMiddlewareContextFromHono(c);
+      return middleware(context, next);
+    };
+  });
+}
 function isRedirect(headers, code) {
   return [
     301,
@@ -150,14 +159,6 @@ function isRedirect(headers, code) {
     308
   ].includes(code || 0) || headers.get("Location");
 }
-function getUnstableMiddlewares(serverMiddleware) {
-  return serverMiddleware.map((middleware) => {
-    return async (c, next) => {
-      const context = createMiddlewareContextFromHono(c);
-      return middleware(context, next);
-    };
-  });
-}
 function createMiddlewareContextFromHono(c) {
   const loaderContext = (0, import_loader.getLoaderCtx)(c);
   return {
@@ -186,5 +187,6 @@ function createMiddlewareContextFromHono(c) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CustomServer,
-  getLoaderCtx
+  getLoaderCtx,
+  getServerMidFromUnstableMid
 });

package/dist/cjs/plugins/favicon.js

@@ -0,0 +1,44 @@
+"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 favicon_exports = {};
+__export(favicon_exports, {
+  faviconPlugin: () => faviconPlugin
+});
+module.exports = __toCommonJS(favicon_exports);
+const faviconPlugin = () => ({
+  name: "@modern-js/plugin-favicon",
+  setup(api) {
+    return {
+      prepare() {
+        const { middlewares } = api.useAppContext();
+        middlewares.push({
+          name: "favicon-fallback",
+          path: "/favicon.ico",
+          handler: async (c, _next) => {
+            return c.body(null, 204);
+          }
+        });
+      }
+    };
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  faviconPlugin
+});

package/dist/cjs/{base/middlewares → plugins}/index.js

@@ -15,25 +15,31 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var middlewares_exports = {};
-__export(middlewares_exports, {
-  getLoaderCtx: () => import_customServer.getLoaderCtx
+var plugins_exports = {};
+__export(plugins_exports, {
+  faviconPlugin: () => import_favicon.faviconPlugin,
+  getLoaderCtx: () => import_customServer.getLoaderCtx,
+  getRenderHandler: () => import_render.getRenderHandler,
+  logPlugin: () => import_log.logPlugin,
+  monitorPlugin: () => import_monitor.monitorPlugin,
+  processedByPlugin: () => import_processedBy.processedByPlugin,
+  renderPlugin: () => import_render.renderPlugin
 });
-module.exports = __toCommonJS(middlewares_exports);
-__reExport(middlewares_exports, require("./faviconFallback"), module.exports);
-__reExport(middlewares_exports, require("./monitor"), module.exports);
-__reExport(middlewares_exports, require("./renderHandler"), module.exports);
-__reExport(middlewares_exports, require("./logger"), module.exports);
-__reExport(middlewares_exports, require("./frameworkHeader"), module.exports);
+module.exports = __toCommonJS(plugins_exports);
+var import_render = require("./render");
+var import_favicon = require("./favicon");
+var import_processedBy = require("./processedBy");
 var import_customServer = require("./customServer");
+var import_log = require("./log");
+var import_monitor = require("./monitor");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  faviconPlugin,
   getLoaderCtx,
-  ...require("./faviconFallback"),
-  ...require("./monitor"),
-  ...require("./renderHandler"),
-  ...require("./logger"),
-  ...require("./frameworkHeader")
+  getRenderHandler,
+  logPlugin,
+  monitorPlugin,
+  processedByPlugin,
+  renderPlugin
 });

package/dist/cjs/{base/middlewares/logger.js → plugins/log.js}

@@ -16,11 +16,11 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var logger_exports = {};
-__export(logger_exports, {
-  logHandler: () => logHandler
+var log_exports = {};
+__export(log_exports, {
+  logPlugin: () => logPlugin
 });
-module.exports = __toCommonJS(logger_exports);
+module.exports = __toCommonJS(log_exports);
 var import_utils = require("../utils");
 var LogPrefix;
 (function(LogPrefix2) {
@@ -63,6 +63,10 @@ function logHandler() {
   return async function logger(c, next) {
     const { method } = c.req;
     const logger2 = c.get("logger");
+    if (!logger2) {
+      await next();
+      return;
+    }
     const path = (0, import_utils.getPathname)(c.req.raw);
     const logFn = logger2.debug;
     log(logFn, "<--", method, path);
@@ -71,7 +75,21 @@ function logHandler() {
     log(logFn, "-->", method, path, c.res.status, time(start));
   };
 }
+const logPlugin = () => ({
+  name: "@modern-js/plugin-log",
+  setup(api) {
+    return {
+      prepare() {
+        const { middlewares } = api.useAppContext();
+        middlewares.push({
+          name: "print_log",
+          handler: logHandler()
+        });
+      }
+    };
+  }
+});
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  logHandler
+  logPlugin
 });

package/dist/cjs/{base/middlewares → plugins}/monitor.js

@@ -19,9 +19,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var monitor_exports = {};
 __export(monitor_exports, {
   initReporter: () => initReporter,
-  injectLogger: () => injectLogger,
-  injectMetrics: () => injectMetrics,
-  injectReporter: () => injectReporter
+  monitorPlugin: () => monitorPlugin
 });
 module.exports = __toCommonJS(monitor_exports);
 var import_time = require("@modern-js/runtime-utils/time");
@@ -38,15 +36,6 @@ const defaultReporter = {
   reportWarn() {
   }
 };
-function injectReporter() {
-  return async (c, next) => {
-    const reporter = c.get("reporter");
-    if (!reporter) {
-      c.set("reporter", defaultReporter);
-    }
-    await next();
-  };
-}
 function initReporter(entryName) {
   return async (c, next) => {
     const reporter = c.get("reporter");
@@ -63,28 +52,36 @@ function initReporter(entryName) {
     reporter.reportTiming(import_constants.ServerReportTimings.SERVER_HANDLE_REQUEST, cost);
   };
 }
-function injectLogger(inputLogger) {
-  return async (c, next) => {
-    const logger = c.get("logger");
-    if (!logger && inputLogger) {
-      c.set("logger", inputLogger);
-    }
-    await next();
-  };
-}
-function injectMetrics(inputMetrics) {
-  return async (c, next) => {
-    const metrics = c.get("metrics");
-    if (!metrics) {
-      c.set("metrics", inputMetrics);
-    }
-    await next();
-  };
-}
+const monitorPlugin = (options) => ({
+  name: "@modern-js/plugin-monitor",
+  setup(api) {
+    return {
+      prepare() {
+        const { middlewares } = api.useAppContext();
+        middlewares.push({
+          name: "monitor",
+          handler: async (c, next) => {
+            const logger = c.get("logger");
+            if (!logger && options.logger) {
+              c.set("logger", options.logger);
+            }
+            const metrics = c.get("metrics");
+            if (!metrics && options.metrics) {
+              c.set("metrics", metrics);
+            }
+            const reporter = c.get("reporter");
+            if (!reporter) {
+              c.set("reporter", reporter || defaultReporter);
+            }
+            await next();
+          }
+        });
+      }
+    };
+  }
+});
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   initReporter,
-  injectLogger,
-  injectMetrics,
-  injectReporter
+  monitorPlugin
 });

package/dist/cjs/plugins/processedBy.js

@@ -0,0 +1,44 @@
+"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 processedBy_exports = {};
+__export(processedBy_exports, {
+  processedByPlugin: () => processedByPlugin
+});
+module.exports = __toCommonJS(processedBy_exports);
+const processedByPlugin = () => ({
+  name: "@modern-js/plugin-processed",
+  setup(api) {
+    return {
+      prepare() {
+        const { middlewares } = api.useAppContext();
+        middlewares.push({
+          name: "processed-by",
+          handler: async (c, next) => {
+            await next();
+            c.header("X-Processed-By", "Modern.js");
+          }
+        });
+      }
+    };
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  processedByPlugin
+});

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

@@ -0,0 +1,136 @@
+"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 render_exports = {};
+__export(render_exports, {
+  getRenderHandler: () => getRenderHandler,
+  renderPlugin: () => renderPlugin
+});
+module.exports = __toCommonJS(render_exports);
+var import_constants = require("@modern-js/utils/universal/constants");
+var import_monitor = require("../monitor");
+var import_utils = require("../../utils");
+var import_customServer = require("../customServer");
+var import_render = require("./render");
+const renderPlugin = (options = {}) => ({
+  name: "@modern-js/plugin-render",
+  setup(api) {
+    const { staticGenerate, cacheConfig } = options;
+    return {
+      async prepare() {
+        var _config_render, _config_render1;
+        const { middlewares, routes, metaName, distDirectory: pwd, serverBase } = api.useAppContext();
+        const runner = api.useHookRunners();
+        const config = api.useConfigContext();
+        if (!routes) {
+          return;
+        }
+        const customServer = new import_customServer.CustomServer(runner, serverBase, pwd);
+        const serverMiddleware = ((_config_render = config.render) === null || _config_render === void 0 ? void 0 : _config_render.middleware) && (0, import_customServer.getServerMidFromUnstableMid)(config.render.middleware);
+        const pageRoutes = getPageRoutes(routes);
+        const render = await getRenderHandler({
+          pwd,
+          routes,
+          config,
+          metaName,
+          cacheConfig: ((_config_render1 = config.render) === null || _config_render1 === void 0 ? void 0 : _config_render1.cache) || cacheConfig,
+          staticGenerate
+        });
+        for (const route of pageRoutes) {
+          const { urlPath: originUrlPath, entryName } = route;
+          const urlPath = originUrlPath.endsWith("/") ? `${originUrlPath}*` : `${originUrlPath}/*`;
+          middlewares.push({
+            name: "init-reporter",
+            handler: (0, import_monitor.initReporter)(entryName || import_constants.MAIN_ENTRY_NAME)
+          });
+          const customServerHookMiddleware = customServer.getHookMiddleware(entryName || "main", routes);
+          middlewares.push({
+            name: "custom-server-hook",
+            path: urlPath,
+            handler: customServerHookMiddleware
+          });
+          const customServerMiddleware = serverMiddleware || await customServer.getServerMiddleware();
+          customServerMiddleware && middlewares.push({
+            name: "custom-server-middleware",
+            path: urlPath,
+            handler: customServerMiddleware
+          });
+          middlewares.push({
+            name: `render`,
+            path: urlPath,
+            handler: createRenderHandler(render)
+          });
+        }
+      }
+    };
+  }
+});
+function getPageRoutes(routes) {
+  return routes.filter((route) => !route.isApi).sort(import_utils.sortRoutes);
+}
+function createRenderHandler(render) {
+  return async (c, _) => {
+    var _c_env_node;
+    const logger = c.get("logger");
+    const reporter = c.get("reporter");
+    const templates = c.get("templates") || {};
+    const serverManifest = c.get("serverManifest") || {};
+    const locals = c.get("locals");
+    const metrics = c.get("metrics");
+    const loaderContext = (0, import_customServer.getLoaderCtx)(c);
+    const request = c.req.raw;
+    const nodeReq = (_c_env_node = c.env.node) === null || _c_env_node === void 0 ? void 0 : _c_env_node.req;
+    const res = await render(request, {
+      logger,
+      nodeReq,
+      reporter,
+      templates,
+      metrics,
+      serverManifest,
+      loaderContext,
+      locals
+    });
+    const { body, status, headers } = res;
+    const headersData = {};
+    headers.forEach((v, k) => {
+      headersData[k] = v;
+    });
+    return c.body(body, status, headersData);
+  };
+}
+async function getRenderHandler({ pwd, routes, config, cacheConfig, metaName, staticGenerate }) {
+  var _config_server, _config_security;
+  const ssrConfig = (_config_server = config.server) === null || _config_server === void 0 ? void 0 : _config_server.ssr;
+  const forceCSR = typeof ssrConfig === "object" ? ssrConfig.forceCSR : false;
+  const render = (0, import_render.createRender)({
+    routes,
+    pwd,
+    // TODO: need static Genrate
+    staticGenerate,
+    cacheConfig,
+    forceCSR,
+    nonce: (_config_security = config.security) === null || _config_security === void 0 ? void 0 : _config_security.nonce,
+    metaName: metaName || "modern-js"
+  });
+  return render;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getRenderHandler,
+  renderPlugin
+});

package/dist/cjs/{base/middlewares/renderHandler → plugins/render}/render.js

@@ -24,13 +24,26 @@ module.exports = __toCommonJS(render_exports);
 var import_universal = require("@modern-js/utils/universal");
 var import_trie_router = require("hono/router/trie-router");
 var import_utils = require("../../utils");
-var import_constants = require("../../../base/constants");
+var import_constants = require("../../constants");
 var import_dataHandler = require("./dataHandler");
 var import_ssrRender = require("./ssrRender");
+const DYNAMIC_ROUTE_REG = /\/:./;
 function getRouter(routes) {
-  const sorted = routes.sort(import_utils.sortRoutes);
+  const dynamicRoutes = [];
+  const normalRoutes = [];
+  routes.forEach((route) => {
+    if (DYNAMIC_ROUTE_REG.test(route.urlPath)) {
+      dynamicRoutes.push(route);
+    } else {
+      normalRoutes.push(route);
+    }
+  });
+  const finalRoutes = [
+    ...normalRoutes.sort(import_utils.sortRoutes),
+    ...dynamicRoutes.sort(import_utils.sortRoutes)
+  ];
   const router = new import_trie_router.TrieRouter();
-  for (const route of sorted) {
+  for (const route of finalRoutes) {
     const { urlPath: originUrlPath } = route;
     const urlPath = originUrlPath.endsWith("/") ? `${originUrlPath}*` : `${originUrlPath}/*`;
     router.add("*", urlPath, route);
@@ -43,7 +56,7 @@ function matchRoute(router, request) {
   const result = matched[0][0];
   return result || [];
 }
-async function createRender({ routes, pwd, metaName, staticGenerate, forceCSR, nonce, onFallback: onFallbackFn }) {
+async function createRender({ routes, pwd, metaName, staticGenerate, cacheConfig, forceCSR, nonce, onFallback: onFallbackFn }) {
   const router = getRouter(routes);
   return async (req, { logger, nodeReq, reporter, templates, serverManifest, locals, metrics, loaderContext }) => {
     const [routeInfo, params] = matchRoute(router, req);
@@ -85,6 +98,7 @@ async function createRender({ routes, pwd, metaName, staticGenerate, forceCSR, n
       nonce,
       logger,
       nodeReq,
+      cacheConfig,
       reporter,
       serverRoutes: routes,
       params,
@@ -160,7 +174,8 @@ function csrRender(html) {
   return new Response(html, {
     status: 200,
     headers: new Headers({
-      "content-type": "text/html; charset=UTF-8"
+      "content-type": "text/html; charset=UTF-8",
+      [import_constants.X_MODERNJS_RENDER]: "client"
     })
   });
 }