@modern-js/server-core 2.54.6 → 2.56.0

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

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,14 +15,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var ssrCache_exports = {};
 __export(ssrCache_exports, {
@@ -33,72 +23,42 @@ __export(ssrCache_exports, {
 });
 module.exports = __toCommonJS(ssrCache_exports);
 var import_storer = require("@modern-js/runtime-utils/storer");
+var import_constants = require("../../constants");
 var import_utils = require("../../utils");
-async function processCache(key, render, ssrContext, ttl, container, status) {
-  const renderResult = await render(ssrContext);
-  if (!renderResult) {
-    return {
-      data: ""
-    };
-  } else if (typeof renderResult === "string") {
-    const current = Date.now();
-    const cache = {
-      val: renderResult,
-      cursor: current
-    };
-    await container.set(key, JSON.stringify(cache), {
-      ttl
-    });
-    return {
-      data: renderResult,
-      status
-    };
-  } else {
-    const { Readable } = await Promise.resolve().then(() => __toESM(require("stream"))).catch((_) => ({
-      Readable: void 0
-    }));
-    const runtimeEnv = (0, import_utils.getRuntimeEnv)();
-    const streamModule = "../../adapters/node/polyfills/stream";
-    const { createReadableStreamFromReadable } = runtimeEnv === "node" ? await Promise.resolve().then(() => __toESM(require(streamModule))).catch((_) => ({
-      createReadableStreamFromReadable: void 0
-    })) : {
-      createReadableStreamFromReadable: void 0
-    };
-    const body = (
-      // TODO: remove node:stream, move it to ssr entry.
-      Readable && renderResult instanceof Readable ? createReadableStreamFromReadable === null || createReadableStreamFromReadable === void 0 ? void 0 : createReadableStreamFromReadable(renderResult) : renderResult
-    );
+async function processCache({ request, key, requestHandler, requestHandlerOptions, ttl, container, cacheStatus }) {
+  const response = await requestHandler(request, requestHandlerOptions);
+  const decoder = new TextDecoder();
+  if (response.body) {
+    const stream = (0, import_utils.createTransformStream)();
+    const reader = response.body.getReader();
+    const writer = stream.writable.getWriter();
     let html = "";
-    const stream = (0, import_utils.createTransformStream)((chunk) => {
-      html += chunk;
-      return chunk;
+    const push = () => reader.read().then(({ done, value }) => {
+      if (done) {
+        const current = Date.now();
+        const cache = {
+          val: html,
+          cursor: current
+        };
+        container.set(key, JSON.stringify(cache), {
+          ttl
+        });
+        writer.close();
+        return;
+      }
+      const content = decoder.decode(value);
+      html += content;
+      writer.write(value);
+      push();
     });
-    const reader = body.getReader();
-    const writer = stream.writable.getWriter();
-    const push = () => {
-      reader.read().then(({ done, value }) => {
-        if (done) {
-          const current = Date.now();
-          const cache = {
-            val: html,
-            cursor: current
-          };
-          container.set(key, JSON.stringify(cache), {
-            ttl
-          });
-          writer.close();
-          return;
-        }
-        writer.write(value);
-        push();
-      });
-    };
     push();
-    return {
-      data: stream.readable,
-      status
-    };
+    cacheStatus && response.headers.set(import_constants.X_RENDER_CACHE, cacheStatus);
+    return new Response(stream.readable, {
+      status: response.status,
+      headers: response.headers
+    });
   }
+  return response;
 }
 const CACHE_NAMESPACE = "__ssr__cache";
 const storage = (0, import_storer.createMemoryStorage)(CACHE_NAMESPACE);
@@ -145,7 +105,7 @@ function matchCacheControl(cacheOption, req) {
   }
 }
 async function getCacheResult(request, options) {
-  const { cacheControl, render, ssrContext, container = storage } = options;
+  const { cacheControl, container = storage, requestHandler, requestHandlerOptions } = options;
   const key = computedKey(request, cacheControl);
   const value = await container.get(key);
   const { maxAge, staleWhileRevalidate } = cacheControl;
@@ -154,21 +114,50 @@ async function getCacheResult(request, options) {
     const cache = JSON.parse(value);
     const interval = Date.now() - cache.cursor;
     if (interval <= maxAge) {
-      return {
-        data: cache.val,
-        status: "hit"
-      };
+      const cacheStatus = "hit";
+      return new Response(cache.val, {
+        headers: {
+          [import_constants.X_RENDER_CACHE]: cacheStatus
+        }
+      });
     } else if (interval <= staleWhileRevalidate + maxAge) {
-      processCache(key, render, ssrContext, ttl, container);
-      return {
-        data: cache.val,
-        status: "stale"
-      };
+      processCache({
+        key,
+        request,
+        requestHandler,
+        requestHandlerOptions,
+        ttl,
+        container
+      }).then(async (response) => {
+        await response.text();
+      });
+      const cacheStatus = "stale";
+      return new Response(cache.val, {
+        headers: {
+          [import_constants.X_RENDER_CACHE]: cacheStatus
+        }
+      });
     } else {
-      return processCache(key, render, ssrContext, ttl, container, "expired");
+      return processCache({
+        key,
+        request,
+        requestHandler,
+        requestHandlerOptions,
+        ttl,
+        container,
+        cacheStatus: "expired"
+      });
     }
   } else {
-    return processCache(key, render, ssrContext, ttl, container, "miss");
+    return processCache({
+      key,
+      request,
+      requestHandler,
+      requestHandlerOptions,
+      ttl,
+      container,
+      cacheStatus: "miss"
+    });
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

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

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,48 +15,22 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var ssrRender_exports = {};
 __export(ssrRender_exports, {
-  getPathnameFromNodeReq: () => getPathnameFromNodeReq,
   ssrRender: () => ssrRender
 });
 module.exports = __toCommonJS(ssrRender_exports);
 var import_constants = require("@modern-js/utils/universal/constants");
-var isbot = __toESM(require("isbot"));
 var import_utils = require("../../utils");
 var import_constants2 = require("../../constants");
-var import_serverTiming = require("./serverTiming");
 var import_ssrCache = require("./ssrCache");
-const defaultReporter = {
-  init() {
-  },
-  reportError() {
-  },
-  reportTiming() {
-  },
-  reportInfo() {
-  },
-  reportWarn() {
-  }
-};
-async function ssrRender(request, { routeInfo, html, staticGenerate, nonce, metaName, reporter, logger, nodeReq, serverManifest, locals, params, metrics, loaderContext, cacheConfig }) {
+const SERVER_RUNTIME_ENTRY = "requestHandler";
+async function ssrRender(request, { routeInfo, html, config: userConfig, staticGenerate, nodeReq, serverManifest, locals, params, loaderContext, reporter, cacheConfig, logger, metrics, onError, onTiming }) {
   var _serverManifest_renderBundles;
   const { entryName } = routeInfo;
   const loadableStats = serverManifest.loadableStats || {};
   const routeManifest = serverManifest.routeManifest || {};
-  const host = (0, import_utils.getHost)(request);
-  const isSpider = isbot.default(request.headers.get("user-agent"));
-  const responseProxy = new ResponseProxy();
-  const query = (0, import_utils.parseQuery)(request);
   const headers = (0, import_utils.parseHeaders)(request);
   if (nodeReq) {
     for (const key in nodeReq.headers) {
@@ -67,103 +39,46 @@ async function ssrRender(request, { routeInfo, html, staticGenerate, nonce, meta
       }
     }
   }
-  const ssrContext = {
-    request: {
-      baseUrl: routeInfo.urlPath,
-      params,
-      pathname: nodeReq ? getPathnameFromNodeReq(nodeReq) : (0, import_utils.getPathname)(request),
-      host,
-      query,
-      url: nodeReq ? getHrefFromNodeReq(nodeReq) : request.url,
-      headers
-    },
-    response: {
-      setHeader(key, value) {
-        responseProxy.headers.set(key, value);
-      },
-      status(code) {
-        responseProxy.status = code;
-      },
-      locals: locals || {}
+  const renderBundle = (_serverManifest_renderBundles = serverManifest.renderBundles) === null || _serverManifest_renderBundles === void 0 ? void 0 : _serverManifest_renderBundles[entryName || import_constants.MAIN_ENTRY_NAME];
+  if (!renderBundle) {
+    throw new Error(`Can't found renderBundle ${entryName || import_constants.MAIN_ENTRY_NAME}`);
+  }
+  const requestHandler = await renderBundle[SERVER_RUNTIME_ENTRY];
+  const config = createRequestHandlerConfig(userConfig);
+  const requestHandlerOptions = {
+    resource: {
+      route: routeInfo,
+      loadableStats,
+      routeManifest,
+      htmlTemplate: html,
+      entryName: entryName || import_constants.MAIN_ENTRY_NAME
     },
-    redirection: {},
-    template: html,
-    loadableStats,
+    params,
     loaderContext,
-    routeManifest,
-    entryName,
+    config,
+    locals,
+    reporter,
     staticGenerate,
     logger,
     metrics,
-    serverTiming: new import_serverTiming.ServerTiming(responseProxy.headers, metaName),
-    reporter: reporter || defaultReporter,
-    /** @deprecated node req */
-    req: nodeReq || request,
-    /** @deprecated node res  */
-    res: void 0,
-    isSpider,
-    nonce
+    onError,
+    onTiming
   };
-  const renderBundle = (_serverManifest_renderBundles = serverManifest.renderBundles) === null || _serverManifest_renderBundles === void 0 ? void 0 : _serverManifest_renderBundles[entryName || import_constants.MAIN_ENTRY_NAME];
-  if (!renderBundle) {
-    throw new Error(`Can't found renderBundle ${entryName || import_constants.MAIN_ENTRY_NAME}`);
-  }
-  const runtimeEnv = (0, import_utils.getRuntimeEnv)();
-  let ssrResult;
-  let cacheStatus;
-  const render = renderBundle[import_constants.SERVER_RENDER_FUNCTION_NAME];
   const cacheControl = await (0, import_ssrCache.matchCacheControl)(cacheConfig === null || cacheConfig === void 0 ? void 0 : cacheConfig.strategy, nodeReq || new IncomingMessgeProxy(request));
+  let response;
   if (cacheControl) {
-    const { data: data2, status } = await (0, import_ssrCache.getCacheResult)(request, {
+    response = await (0, import_ssrCache.getCacheResult)(request, {
       cacheControl,
       container: cacheConfig === null || cacheConfig === void 0 ? void 0 : cacheConfig.container,
-      render,
-      ssrContext
+      requestHandler,
+      requestHandlerOptions
     });
-    ssrResult = data2;
-    cacheStatus = status;
   } else {
-    ssrResult = await render(ssrContext);
-  }
-  const { redirection } = ssrContext;
-  if (cacheStatus) {
-    responseProxy.headers.set(import_constants2.X_RENDER_CACHE, cacheStatus);
-  }
-  responseProxy.headers.set(import_constants2.X_MODERNJS_RENDER, "server");
-  if (redirection.url) {
-    const { headers: headers2 } = responseProxy;
-    headers2.set("Location", redirection.url);
-    return new Response(null, {
-      status: redirection.status || 302,
-      headers: {
-        Location: redirection.url
-      }
-    });
-  }
-  const { Readable } = await Promise.resolve().then(() => __toESM(require("stream"))).catch((_) => ({
-    Readable: void 0
-  }));
-  const streamModule = "../../adapters/node/polyfills/stream";
-  const { createReadableStreamFromReadable } = runtimeEnv === "node" ? await Promise.resolve().then(() => __toESM(require(streamModule))).catch((_) => ({
-    createReadableStreamFromReadable: void 0
-  })) : {
-    createReadableStreamFromReadable: void 0
-  };
-  const data = Readable && ssrResult instanceof Readable ? (createReadableStreamFromReadable === null || createReadableStreamFromReadable === void 0 ? void 0 : createReadableStreamFromReadable(ssrResult)) || "" : ssrResult;
-  if (typeof data !== "string") {
-    responseProxy.headers.set("transfer-encoding", "chunked");
-  }
-  return new Response(data, {
-    status: responseProxy.status,
-    headers: responseProxy.headers
-  });
-}
-class ResponseProxy {
-  constructor() {
-    this.headers = new Headers();
-    this.status = 200;
-    this.headers.set("content-type", "text/html; charset=UTF-8");
+    response = await requestHandler(request, requestHandlerOptions);
   }
+  response.headers.set(import_constants2.X_MODERNJS_RENDER, "server");
+  response.headers.set("content-type", "text/html; charset=UTF-8");
+  return response;
 }
 class IncomingMessgeProxy {
   constructor(req) {
@@ -175,39 +90,19 @@ class IncomingMessgeProxy {
     this.url = (0, import_utils.getPathname)(req);
   }
 }
-function getHrefFromNodeReq(nodeReq) {
-  function getProtocal() {
-    if (nodeReq.socket.encrypted) {
-      return "https";
-    }
-    const proto = nodeReq.headers["x-forwarded-proto"];
-    return proto ? proto.split(/\s*,\s*/, 1)[0] : "http";
-  }
-  function getHost2() {
-    let host = nodeReq.headers["x-forwarded-host"];
-    if (!host) {
-      host = nodeReq.headers.host;
-    }
-    host = host.split(/\s*,\s*/, 1)[0] || "undefined";
-    return host;
-  }
-  const href = `${getProtocal()}://${getHost2()}${nodeReq.url || ""}`;
-  return href;
-}
-function getPathnameFromNodeReq(nodeReq) {
-  const { url } = nodeReq;
-  if (!url) {
-    return "/";
-  }
-  const match = url.match(/\/[^?]*/);
-  let pathname = match ? match[0] : "/";
-  if (pathname !== "/" && pathname.endsWith("/")) {
-    pathname = pathname.slice(0, -1);
-  }
-  return pathname;
+function createRequestHandlerConfig(userConfig) {
+  const { output, server, security, html } = userConfig;
+  return {
+    ssr: server === null || server === void 0 ? void 0 : server.ssr,
+    ssrByEntries: server === null || server === void 0 ? void 0 : server.ssrByEntries,
+    nonce: security === null || security === void 0 ? void 0 : security.nonce,
+    enableInlineScripts: output === null || output === void 0 ? void 0 : output.enableInlineScripts,
+    enableInlineStyles: output === null || output === void 0 ? void 0 : output.enableInlineStyles,
+    crossorigin: html === null || html === void 0 ? void 0 : html.crossorigin,
+    scriptLoading: html === null || html === void 0 ? void 0 : html.scriptLoading
+  };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  getPathnameFromNodeReq,
   ssrRender
 });

package/dist/cjs/types/requestHandler.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 requestHandler_exports = {};
+module.exports = __toCommonJS(requestHandler_exports);

package/dist/cjs/utils/error.js

@@ -68,11 +68,11 @@ var ErrorDigest;
   ErrorDigest2["EINTER"] = "Internal server error";
   ErrorDigest2["ERENDER"] = "SSR render failed";
 })(ErrorDigest || (ErrorDigest = {}));
-function onError(digest, error, logger, req) {
+function onError(digest, error, monitors, req) {
   const headerData = req && (0, import_request.parseHeaders)(req);
   headerData && delete headerData.cookie;
-  if (logger) {
-    logger.error(req ? `Server Error - ${digest}, error = %s, req.url = %s, req.headers = %o` : `Server Error - ${digest}, error = %s`, error instanceof Error ? error.stack || error.message : error, req === null || req === void 0 ? void 0 : req.url, headerData);
+  if (monitors) {
+    monitors.error(req ? `Server Error - ${digest}, error = %s, req.url = %s, req.headers = %o` : `Server Error - ${digest}, error = %s`, error instanceof Error ? error.stack || error.message : error, req === null || req === void 0 ? void 0 : req.url, headerData);
   } else if (req) {
     console.error(`Server Error - ${digest}, error = ${error instanceof Error ? error.stack || error.message : error}, req.url = ${req.url}, req.headers = ${JSON.stringify(headerData)}`);
   } else {

package/dist/cjs/utils/transformStream.js

@@ -28,7 +28,7 @@ function createTransformStream(fn) {
   return new TransformStream({
     async transform(chunk, controller) {
       const content = decoder.decode(chunk);
-      const newContent = await fn(content);
+      const newContent = fn ? await fn(content) : content;
       controller.enqueue(encoder.encode(newContent));
     }
   });

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

@@ -137,7 +137,7 @@ var loadBundle = function() {
           return [
             2,
             dynamicImport(filepath).catch(function(e) {
-              logger.error("Load ".concat(filepath, " bundle failed, error = %s"), _instanceof(e, Error) ? e.stack || e.message : e);
+              logger === null || logger === void 0 ? void 0 : logger.error("Load ".concat(filepath, " bundle failed, error = %s"), _instanceof(e, Error) ? e.stack || e.message : e);
               return void 0;
             })
           ];

package/dist/esm/constants.js

@@ -15,19 +15,21 @@ var REPLACE_REG = {
     body: "</body>"
   }
 };
-var ServerReportTimings;
-(function(ServerReportTimings2) {
-  ServerReportTimings2["SERVER_HANDLE_REQUEST"] = "server-handle-request";
-  ServerReportTimings2["SERVER_MIDDLEWARE"] = "server-middleware";
-  ServerReportTimings2["SERVER_HOOK_AFTER_RENDER"] = "server-hook-after-render";
-  ServerReportTimings2["SERVER_HOOK_AFTER_MATCH"] = "server-hook-after-match";
-})(ServerReportTimings || (ServerReportTimings = {}));
+var ServerTimings;
+(function(ServerTimings2) {
+  ServerTimings2["SERVER_HANDLE_REQUEST"] = "server-handle-request";
+  ServerTimings2["SERVER_MIDDLEWARE"] = "server-middleware";
+  ServerTimings2["SERVER_HOOK_AFTER_RENDER"] = "server-hook-after-render";
+  ServerTimings2["SERVER_HOOK_AFTER_MATCH"] = "server-hook-after-match";
+})(ServerTimings || (ServerTimings = {}));
+var SERVER_TIMING = "Server-Timing";
 var X_RENDER_CACHE = "x-render-cache";
 var X_MODERNJS_RENDER = "x-modernjs-render";
 export {
   AGGRED_DIR,
   REPLACE_REG,
-  ServerReportTimings,
+  SERVER_TIMING,
+  ServerTimings,
   X_MODERNJS_RENDER,
   X_RENDER_CACHE
 };

package/dist/esm/index.js

@@ -7,6 +7,7 @@ export * from "./types/plugin";
 export * from "./types/render";
 export * from "@modern-js/plugin";
 export * from "./types/config";
+export * from "./types/requestHandler";
 export {
   AGGRED_DIR,
   ErrorDigest,

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

@@ -3,7 +3,7 @@ import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import { time } from "@modern-js/runtime-utils/time";
 import { transformResponse } from "../../utils";
-import { ServerReportTimings } from "../../constants";
+import { ServerTimings } from "../../constants";
 import { getLoaderCtx } from "./loader";
 import { getAfterMatchCtx, getAfterRenderCtx, createCustomMiddlewaresCtx, createAfterStreamingRenderContext } from "./context";
 import { createBaseHookContext } from "./base";
@@ -37,14 +37,14 @@ var CustomServer = /* @__PURE__ */ function() {
     var _this = this;
     return function() {
       var _ref = _async_to_generator(function(c, next) {
-        var routeInfo, reporter, baseHookCtx, afterMatchCtx, getCost, cost, _afterMatchCtx_router, url, status, current, rewriteRoute, afterStreamingRenderContext, afterRenderCtx, getCost1, cost1, newBody;
+        var routeInfo, monitors, baseHookCtx, afterMatchCtx, getCost, cost, _afterMatchCtx_router, url, status, current, rewriteRoute, afterStreamingRenderContext, afterRenderCtx, getCost1, cost1, newBody;
         return _ts_generator(this, function(_state) {
           switch (_state.label) {
             case 0:
               routeInfo = routes.find(function(route) {
                 return route.entryName === entryName;
               });
-              reporter = c.get("reporter");
+              monitors = c.get("monitors");
               baseHookCtx = createBaseHookContext(c);
               afterMatchCtx = getAfterMatchCtx(entryName, baseHookCtx);
               getCost = time();
@@ -57,7 +57,7 @@ var CustomServer = /* @__PURE__ */ function() {
             case 1:
               _state.sent();
               cost = getCost();
-              cost && (reporter === null || reporter === void 0 ? void 0 : reporter.reportTiming(ServerReportTimings.SERVER_HOOK_AFTER_MATCH, cost));
+              cost && (monitors === null || monitors === void 0 ? void 0 : monitors.timing(ServerTimings.SERVER_HOOK_AFTER_MATCH, cost));
               _afterMatchCtx_router = afterMatchCtx.router, url = _afterMatchCtx_router.url, status = _afterMatchCtx_router.status;
               if (url) {
                 return [
@@ -137,7 +137,7 @@ var CustomServer = /* @__PURE__ */ function() {
             case 5:
               _state.sent();
               cost1 = getCost1();
-              cost1 && (reporter === null || reporter === void 0 ? void 0 : reporter.reportTiming(ServerReportTimings.SERVER_HOOK_AFTER_RENDER, cost1));
+              cost1 && (monitors === null || monitors === void 0 ? void 0 : monitors.timing(ServerTimings.SERVER_HOOK_AFTER_RENDER, cost1));
               if (afterRenderCtx.response.private_overrided) {
                 return [
                   2,
@@ -187,11 +187,11 @@ var CustomServer = /* @__PURE__ */ function() {
               2,
               function() {
                 var _ref = _async_to_generator(function(c, next) {
-                  var _c_env_node_res, _c_env_node, _c_env, reporter, locals, resArgs, customMiddlewareCtx, getCost, cost;
+                  var _c_env_node_res, _c_env_node, _c_env, monitors, locals, resArgs, customMiddlewareCtx, getCost, cost;
                   return _ts_generator(this, function(_state2) {
                     switch (_state2.label) {
                       case 0:
-                        reporter = c.get("reporter");
+                        monitors = c.get("monitors");
                         locals = {};
                         resArgs = {
                           headers: new Headers()
@@ -205,7 +205,7 @@ var CustomServer = /* @__PURE__ */ function() {
                       case 1:
                         _state2.sent();
                         cost = getCost();
-                        cost && (reporter === null || reporter === void 0 ? void 0 : reporter.reportTiming(ServerReportTimings.SERVER_MIDDLEWARE, cost));
+                        cost && (monitors === null || monitors === void 0 ? void 0 : monitors.timing(ServerTimings.SERVER_MIDDLEWARE, cost));
                         c.set("locals", locals);
                         if (isRedirect(resArgs.headers, resArgs.status)) {
                           return [

package/dist/esm/plugins/index.js

@@ -3,13 +3,15 @@ import { faviconPlugin } from "./favicon";
 import { processedByPlugin } from "./processedBy";
 import { getLoaderCtx } from "./customServer";
 import { logPlugin } from "./log";
-import { monitorPlugin } from "./monitor";
+import { initMonitorsPlugin, injectServerTiming, injectloggerPluigin } from "./monitors";
 export {
   faviconPlugin,
   getLoaderCtx,
   getRenderHandler,
+  initMonitorsPlugin,
+  injectServerTiming,
+  injectloggerPluigin,
   logPlugin,
-  monitorPlugin,
   processedByPlugin,
   renderPlugin
 };

package/dist/esm/plugins/log.js

@@ -41,13 +41,13 @@ function log(fn, prefix, method, path) {
 function logHandler() {
   return function() {
     var _logger = _async_to_generator(function(c, next) {
-      var method, _$logger, path, logFn, start;
+      var method, monitors, path, logFn, start;
       return _ts_generator(this, function(_state) {
         switch (_state.label) {
           case 0:
             method = c.req.method;
-            _$logger = c.get("logger");
-            if (!!_$logger)
+            monitors = c.get("monitors");
+            if (!!monitors)
               return [
                 3,
                 2
@@ -63,7 +63,7 @@ function logHandler() {
             ];
           case 2:
             path = getPathname(c.req.raw);
-            logFn = _$logger.debug;
+            logFn = monitors.debug;
             log(logFn, "<--", method, path);
             start = Date.now();
             return [