@modern-js/prod-server 2.28.0 → 2.29.0

package/dist/esm/server/modernServer.js

@@ -8,10 +8,11 @@ import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import { createServer } from "http";
 import path from "path";
 import { fs, isPromise, isWebOnly, mime, ROUTE_SPEC_FILE } from "@modern-js/utils";
+import { time } from "@modern-js/utils/universal/time";
 import { RouteMatchManager } from "../libs/route";
 import { createRenderHandler } from "../libs/render";
 import { createStaticFileHandler, faviconFallbackHandler } from "../libs/serveFile";
-import { createErrorDocument, createMiddlewareCollecter, getStaticReg, mergeExtension, noop, debug, isRedirect } from "../utils";
+import { createErrorDocument, createMiddlewareCollecter, getStaticReg, mergeExtension, noop, debug, isRedirect, bodyParser } from "../utils";
 import * as reader from "../libs/render/reader";
 import { createProxyHandler } from "../libs/proxy";
 import { createContext } from "../libs/context";
@@ -164,7 +165,9 @@ export var ModernServer = /* @__PURE__ */ function() {
               case 0:
                 req.logger = req.logger || _this.logger;
                 req.metrics = req.metrics || _this.metrics;
-                context = createContext(req, res);
+                context = createContext(req, res, {
+                  metaName: _this.metaName
+                });
                 matched = _this.router.match(url || context.path);
                 if (!matched) {
                   return [
@@ -666,11 +669,11 @@ export var ModernServer = /* @__PURE__ */ function() {
         function routeHandler(context) {
           var _this = this;
           return _async_to_generator(function() {
-            var res, matched, route, afterMatchContext, _afterMatchContext_router, current, url, status, matched1, middlewareContext, renderResult, responseStream, response, afterRenderContext;
+            var res, req, reporter, matched, end, route, afterMatchContext, end1, cost, _afterMatchContext_router, current, url, status, matched1, middlewareContext, end2, cost1, renderResult, responseStream, response, afterRenderContext, end3, cost2;
             return _ts_generator(this, function(_state) {
               switch (_state.label) {
                 case 0:
-                  res = context.res;
+                  res = context.res, req = context.req, reporter = context.reporter;
                   matched = _this.router.match(context.path);
                   if (!matched) {
                     _this.render404(context);
@@ -678,43 +681,65 @@ export var ModernServer = /* @__PURE__ */ function() {
                       2
                     ];
                   }
+                  return [
+                    4,
+                    reporter.init({
+                      match: matched
+                    })
+                  ];
+                case 1:
+                  _state.sent();
+                  end = time();
+                  res.on("finish", function() {
+                    var cost3 = end();
+                    reporter.reportTiming("server_handle_request", cost3);
+                  });
                   route = matched.generate(context.url);
                   if (!route.isApi)
                     return [
                       3,
-                      2
+                      3
                     ];
                   return [
                     4,
                     _this.handleAPI(context)
                   ];
-                case 1:
+                case 2:
                   _state.sent();
                   return [
                     2
                   ];
-                case 2:
+                case 3:
+                  return [
+                    4,
+                    bodyParser(req)
+                  ];
+                case 4:
+                  _state.sent();
                   if (!route.entryName)
                     return [
                       3,
-                      5
+                      7
                     ];
                   afterMatchContext = createAfterMatchContext(context, route.entryName);
                   if (!(_this.runMode === RUN_MODE.FULL))
                     return [
                       3,
-                      4
+                      6
                     ];
+                  end1 = time();
                   return [
                     4,
                     _this.runner.afterMatch(afterMatchContext, {
                       onLast: noop
                     })
                   ];
-                case 3:
+                case 5:
                   _state.sent();
-                  _state.label = 4;
-                case 4:
+                  cost = end1();
+                  reporter.reportTiming("server_hook_after_render", cost);
+                  _state.label = 6;
+                case 6:
                   if (_this.isSend(res)) {
                     return [
                       2
@@ -737,34 +762,37 @@ export var ModernServer = /* @__PURE__ */ function() {
                     }
                     route = matched1.generate(context.url);
                   }
-                  _state.label = 5;
-                case 5:
+                  _state.label = 7;
+                case 7:
                   if (!_this.frameWebHandler)
                     return [
                       3,
-                      7
+                      9
                     ];
                   res.locals = res.locals || {};
                   middlewareContext = createMiddlewareContext(context);
+                  end2 = time();
                   return [
                     4,
                     _this.frameWebHandler(middlewareContext)
                   ];
-                case 6:
+                case 8:
                   _state.sent();
+                  cost1 = end2();
+                  reporter.reportTiming("server_middleware", cost1);
                   res.locals = _object_spread({}, res.locals, middlewareContext.response.locals);
                   if (_this.isSend(res)) {
                     return [
                       2
                     ];
                   }
-                  _state.label = 7;
-                case 7:
+                  _state.label = 9;
+                case 9:
                   return [
                     4,
                     _this.handleWeb(context, route)
                   ];
-                case 8:
+                case 10:
                   renderResult = _state.sent();
                   if (!renderResult) {
                     return [
@@ -782,32 +810,35 @@ export var ModernServer = /* @__PURE__ */ function() {
                   if (!route.entryName)
                     return [
                       3,
-                      11
+                      13
                     ];
                   afterRenderContext = createAfterRenderContext(context, response.toString());
                   if (!(_this.runMode === RUN_MODE.FULL))
                     return [
                       3,
-                      10
+                      12
                     ];
+                  end3 = time();
                   return [
                     4,
                     _this.runner.afterRender(afterRenderContext, {
                       onLast: noop
                     })
                   ];
-                case 9:
+                case 11:
                   _state.sent();
-                  _state.label = 10;
-                case 10:
+                  cost2 = end3();
+                  reporter.reportTiming("server_hook_after_render", cost2);
+                  _state.label = 12;
+                case 12:
                   if (_this.isSend(res)) {
                     return [
                       2
                     ];
                   }
                   response = afterRenderContext.template.get();
-                  _state.label = 11;
-                case 11:
+                  _state.label = 13;
+                case 13:
                   res.end(response);
                   return [
                     2

package/dist/esm/utils.js

@@ -1,5 +1,7 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
 import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
 import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import { createDebugger } from "@modern-js/utils";
 export var debug = createDebugger("prod-server");
 export var mergeExtension = function(users) {
@@ -90,3 +92,58 @@ export var isRedirect = function(code) {
     308
   ].includes(code);
 };
+function parseBodyTypes(headers, body) {
+  switch (headers["content-type"]) {
+    case "application/json":
+      return JSON.parse(body);
+    default:
+      return body;
+  }
+}
+var getRequestBody = function(req) {
+  return new Promise(function(resolve, reject) {
+    var _req;
+    if (((_req = req) === null || _req === void 0 ? void 0 : _req.method) && req.method.toLowerCase() !== "get") {
+      var body = "";
+      req.on("data", function(chunk) {
+        body += chunk.toString();
+      });
+      req.on("end", function() {
+        resolve(parseBodyTypes(req.headers, body));
+      });
+      req.on("error", function(err) {
+        reject(err);
+      });
+    } else {
+      resolve(void 0);
+    }
+  });
+};
+export var bodyParser = function() {
+  var _ref = _async_to_generator(function(req) {
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          if (!!req.body)
+            return [
+              3,
+              2
+            ];
+          return [
+            4,
+            getRequestBody(req)
+          ];
+        case 1:
+          req.body = _state.sent();
+          _state.label = 2;
+        case 2:
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return function bodyParser2(req) {
+    return _ref.apply(this, arguments);
+  };
+}();

package/dist/esm/workerServer.js

@@ -9,6 +9,7 @@ import { createAfterMatchContext, createAfterRenderContext, createMiddlewareCont
 import { Logger } from "./libs/logger";
 import { RouteMatchManager } from "./libs/route";
 import { metrics as defaultMetrics } from "./libs/metrics";
+import { defaultReporter } from "./libs/reporter";
 export var ReturnResponse = /* @__PURE__ */ function() {
   "use strict";
   function ReturnResponse2(body, status) {
@@ -91,7 +92,7 @@ export var createHandler = function(manifest) {
   routeMgr.reset(routes);
   return function() {
     var _ref = _async_to_generator(function(options) {
-      var _page_serverHooks_afterMatch, _page_serverHooks, _page, request, loadableStats, routeManifest, url, pageMatch, entryName, page, logger, metrics, hookContext, afterMatchHookContext, _page_serverHooks1, _page_serverHooks_afterRender, _page_serverHooks2, middlewarsHookContext, responseLike, params, baseUrl, serverRenderContext, body, afterRenderHookContext, e;
+      var _page_serverHooks_afterMatch, _page_serverHooks, _page, request, loadableStats, routeManifest, url, pageMatch, entryName, page, logger, metrics, reporter, hookContext, afterMatchHookContext, _page_serverHooks1, _page_serverHooks_afterRender, _page_serverHooks2, middlewarsHookContext, responseLike, params, baseUrl, serverRenderContext, body, afterRenderHookContext, e;
       function createServerRequest(url2, baseUrl2, request2, params2) {
         var pathname = url2.pathname, host = url2.host, searchParams = url2.searchParams;
         var rawHeaders = request2.headers;
@@ -128,7 +129,8 @@ export var createHandler = function(manifest) {
               level: "warn"
             });
             metrics = defaultMetrics;
-            hookContext = createWorkerHookContext(request.url, logger, metrics);
+            reporter = defaultReporter;
+            hookContext = createWorkerHookContext(request.url, logger, metrics, reporter);
             afterMatchHookContext = createAfterMatchContext(hookContext, entryName);
             (_page = page) === null || _page === void 0 ? void 0 : (_page_serverHooks = _page.serverHooks) === null || _page_serverHooks === void 0 ? void 0 : (_page_serverHooks_afterMatch = _page_serverHooks.afterMatch) === null || _page_serverHooks_afterMatch === void 0 ? void 0 : _page_serverHooks_afterMatch.call(_page_serverHooks, afterMatchHookContext, function() {
               return void 0;
@@ -182,9 +184,15 @@ export var createHandler = function(manifest) {
               template: page.template,
               entryName: page.entryName,
               logger: logger,
+              reporter: defaultReporter,
               metrics: metrics,
               // FIXME: pass correctly req & res
               req: request,
+              serverTiming: {
+                addServeTiming: function addServeTiming() {
+                  return this;
+                }
+              },
               res: responseLike
             };
             return [
@@ -236,7 +244,7 @@ function createResponse(template) {
     return RESPONSE_NOTFOUND;
   }
 }
-function createWorkerHookContext(url, logger, metrics) {
+function createWorkerHookContext(url, logger, metrics, reporter) {
   var _ref = [
     {
       headers: new Headers(),
@@ -250,7 +258,8 @@ function createWorkerHookContext(url, logger, metrics) {
     res: res,
     req: req,
     logger: logger,
-    metrics: metrics
+    metrics: metrics,
+    reporter: reporter
   };
 }
 function applyMiddlewares(ctx, middleware) {

package/dist/esm-node/libs/context/context.js

@@ -4,6 +4,9 @@ import qs from "querystring";
 import { Buffer } from "buffer";
 import createEtag from "etag";
 import fresh from "fresh";
+import { cutNameByHyphen } from "@modern-js/utils";
+import { ServerTiming } from "../serverTiming";
+import { defaultReporter } from "../reporter";
 import { headersWithoutCookie } from "../../utils";
 const MOCK_URL_BASE = "https://modernjs.dev/";
 export class ModernServerContext {
@@ -149,15 +152,18 @@ export class ModernServerContext {
     this.logger.error(`Web Server Error - ${dig}, error = %s, req.url = %s, req.headers = %o`, e instanceof Error ? e.stack || e.message : e, this.path, headersWithoutCookie(this.headers));
   }
   constructor(req, res, options) {
+    var _options;
     _define_property(this, "req", void 0);
     _define_property(this, "res", void 0);
     _define_property(this, "params", {});
-    _define_property(this, "serverData", void 0);
+    _define_property(this, "reporter", defaultReporter);
+    _define_property(this, "serverTiming", void 0);
+    _define_property(this, "serverData", {});
     _define_property(this, "options", {});
     this.req = req;
     this.res = res;
     this.options = options || {};
-    this.serverData = {};
+    this.serverTiming = new ServerTiming(res, cutNameByHyphen(((_options = options) === null || _options === void 0 ? void 0 : _options.metaName) || "modern-js"));
     this.bind();
   }
 }

package/dist/esm-node/libs/hook-api/index.js

@@ -2,10 +2,11 @@ import { RouteAPI } from "./route";
 import { TemplateAPI } from "./template";
 import { BaseRequest, BaseResponse } from "./base";
 export const base = (context) => {
-  const { res } = context;
+  const { res, reporter } = context;
   return {
     response: new BaseResponse(res),
     request: new BaseRequest(context),
+    reporter,
     logger: context.logger,
     metrics: context.metrics
   };

package/dist/esm-node/libs/hook-api/index.worker.js

@@ -31,7 +31,7 @@ class ServerResponse {
   }
 }
 export const base = (context) => {
-  const { req, res, logger, metrics } = context;
+  const { req, res, logger, metrics, reporter } = context;
   const serverResponse = new ServerResponse(res);
   const { host, pathname, searchParams } = new URL(req.url);
   const headers = {};
@@ -40,6 +40,7 @@ export const base = (context) => {
   });
   return {
     response: new BaseResponse(serverResponse),
+    reporter,
     request: new BaseRequest({
       url: req.url,
       host,

package/dist/esm-node/libs/render/ssr.js

@@ -11,7 +11,6 @@ export const render = async (ctx, renderOptions, runner) => {
   const loadableStats = fs.existsSync(loadableUri) ? require(loadableUri) : "";
   const routesManifestUri = path.join(distDir, ROUTE_MANIFEST_FILE);
   const routeManifest = fs.existsSync(routesManifestUri) ? require(routesManifestUri) : void 0;
-  const body = await getRequestBody(ctx.req);
   const context = {
     request: {
       baseUrl: urlPath,
@@ -21,7 +20,7 @@ export const render = async (ctx, renderOptions, runner) => {
       query: ctx.query,
       url: ctx.href,
       headers: ctx.headers,
-      body
+      body: ctx.req.body
     },
     response: {
       setHeader: (key, value) => {
@@ -40,6 +39,8 @@ export const render = async (ctx, renderOptions, runner) => {
     staticGenerate,
     logger: void 0,
     metrics: void 0,
+    reporter: ctx.reporter,
+    serverTiming: ctx.serverTiming,
     req: ctx.req,
     res: ctx.res,
     enableUnsafeCtx,
@@ -73,20 +74,3 @@ export const render = async (ctx, renderOptions, runner) => {
     };
   }
 };
-const getRequestBody = (req) => new Promise((resolve, reject) => {
-  var _req;
-  if (((_req = req) === null || _req === void 0 ? void 0 : _req.method) && req.method.toLowerCase() !== "get") {
-    let body = "";
-    req.on("data", (chunk) => {
-      body += chunk.toString();
-    });
-    req.on("end", () => {
-      resolve(body);
-    });
-    req.on("error", (err) => {
-      reject(err);
-    });
-  } else {
-    resolve(void 0);
-  }
-});

package/dist/esm-node/libs/reporter.js

@@ -0,0 +1,12 @@
+export const defaultReporter = {
+  init() {
+  },
+  reportError() {
+  },
+  reportTiming() {
+  },
+  reportInfo() {
+  },
+  reportWarn() {
+  }
+};

package/dist/esm-node/libs/serverTiming.js

@@ -0,0 +1,17 @@
+import { _ as _define_property } from "@swc/helpers/_/_define_property";
+const SERVER_TIMING = "Server-Timing";
+export class ServerTiming {
+  addServeTiming(name, dur, desc) {
+    const _name = `bd-${this.meta}-${name}`;
+    const serverTiming = this.res.getHeader(SERVER_TIMING) || this.res.getHeader(SERVER_TIMING.toLocaleLowerCase());
+    const value = `${_name};${desc ? `decs="${desc}";` : ""} dur=${dur}`;
+    this.res.setHeader(SERVER_TIMING, serverTiming ? `${serverTiming}, ${value}` : value);
+    return this;
+  }
+  constructor(res, meta) {
+    _define_property(this, "meta", void 0);
+    _define_property(this, "res", void 0);
+    this.meta = meta;
+    this.res = res;
+  }
+}

package/dist/esm-node/server/modernServer.js

@@ -2,10 +2,11 @@ import { _ as _define_property } from "@swc/helpers/_/_define_property";
 import { createServer } from "http";
 import path from "path";
 import { fs, isPromise, isWebOnly, mime, ROUTE_SPEC_FILE } from "@modern-js/utils";
+import { time } from "@modern-js/utils/universal/time";
 import { RouteMatchManager } from "../libs/route";
 import { createRenderHandler } from "../libs/render";
 import { createStaticFileHandler, faviconFallbackHandler } from "../libs/serveFile";
-import { createErrorDocument, createMiddlewareCollecter, getStaticReg, mergeExtension, noop, debug, isRedirect } from "../utils";
+import { createErrorDocument, createMiddlewareCollecter, getStaticReg, mergeExtension, noop, debug, isRedirect, bodyParser } from "../utils";
 import * as reader from "../libs/render/reader";
 import { createProxyHandler } from "../libs/proxy";
 import { createContext } from "../libs/context";
@@ -64,7 +65,9 @@ export class ModernServer {
   async render(req, res, url) {
     req.logger = req.logger || this.logger;
     req.metrics = req.metrics || this.metrics;
-    const context = createContext(req, res);
+    const context = createContext(req, res, {
+      metaName: this.metaName
+    });
     const matched = this.router.match(url || context.path);
     if (!matched) {
       return null;
@@ -265,23 +268,35 @@ export class ModernServer {
   /* —————————————————————— private function —————————————————————— */
   // handler route.json, include api / csr / ssr
   async routeHandler(context) {
-    const { res } = context;
+    const { res, req, reporter } = context;
     const matched = this.router.match(context.path);
     if (!matched) {
       this.render404(context);
       return;
     }
+    await reporter.init({
+      match: matched
+    });
+    const end = time();
+    res.on("finish", () => {
+      const cost = end();
+      reporter.reportTiming("server_handle_request", cost);
+    });
     let route = matched.generate(context.url);
     if (route.isApi) {
       await this.handleAPI(context);
       return;
     }
+    await bodyParser(req);
     if (route.entryName) {
       const afterMatchContext = createAfterMatchContext(context, route.entryName);
       if (this.runMode === RUN_MODE.FULL) {
+        const end2 = time();
         await this.runner.afterMatch(afterMatchContext, {
           onLast: noop
         });
+        const cost = end2();
+        reporter.reportTiming("server_hook_after_render", cost);
       }
       if (this.isSend(res)) {
         return;
@@ -303,7 +318,10 @@ export class ModernServer {
     if (this.frameWebHandler) {
       res.locals = res.locals || {};
       const middlewareContext = createMiddlewareContext(context);
+      const end2 = time();
       await this.frameWebHandler(middlewareContext);
+      const cost = end2();
+      reporter.reportTiming("server_middleware", cost);
       res.locals = {
         ...res.locals,
         ...middlewareContext.response.locals
@@ -325,9 +343,12 @@ export class ModernServer {
     if (route.entryName) {
       const afterRenderContext = createAfterRenderContext(context, response.toString());
       if (this.runMode === RUN_MODE.FULL) {
+        const end2 = time();
         await this.runner.afterRender(afterRenderContext, {
           onLast: noop
         });
+        const cost = end2();
+        reporter.reportTiming("server_hook_after_render", cost);
       }
       if (this.isSend(res)) {
         return;

package/dist/esm-node/utils.js

@@ -119,3 +119,33 @@ export const isRedirect = (code) => {
     308
   ].includes(code);
 };
+function parseBodyTypes(headers, body) {
+  switch (headers["content-type"]) {
+    case "application/json":
+      return JSON.parse(body);
+    default:
+      return body;
+  }
+}
+const getRequestBody = (req) => new Promise((resolve, reject) => {
+  var _req;
+  if (((_req = req) === null || _req === void 0 ? void 0 : _req.method) && req.method.toLowerCase() !== "get") {
+    let body = "";
+    req.on("data", (chunk) => {
+      body += chunk.toString();
+    });
+    req.on("end", () => {
+      resolve(parseBodyTypes(req.headers, body));
+    });
+    req.on("error", (err) => {
+      reject(err);
+    });
+  } else {
+    resolve(void 0);
+  }
+});
+export const bodyParser = async (req) => {
+  if (!req.body) {
+    req.body = await getRequestBody(req);
+  }
+};

package/dist/esm-node/workerServer.js

@@ -4,6 +4,7 @@ import { createAfterMatchContext, createAfterRenderContext, createMiddlewareCont
 import { Logger } from "./libs/logger";
 import { RouteMatchManager } from "./libs/route";
 import { metrics as defaultMetrics } from "./libs/metrics";
+import { defaultReporter } from "./libs/reporter";
 export class ReturnResponse {
   /**
   * Iterate a Object
@@ -82,7 +83,8 @@ export const createHandler = (manifest) => {
       level: "warn"
     });
     const metrics = defaultMetrics;
-    const hookContext = createWorkerHookContext(request.url, logger, metrics);
+    const reporter = defaultReporter;
+    const hookContext = createWorkerHookContext(request.url, logger, metrics, reporter);
     const afterMatchHookContext = createAfterMatchContext(hookContext, entryName);
     (_page = page) === null || _page === void 0 ? void 0 : (_page_serverHooks = _page.serverHooks) === null || _page_serverHooks === void 0 ? void 0 : (_page_serverHooks_afterMatch = _page_serverHooks.afterMatch) === null || _page_serverHooks_afterMatch === void 0 ? void 0 : _page_serverHooks_afterMatch.call(_page_serverHooks, afterMatchHookContext, () => void 0);
     if (checkIsSent(hookContext)) {
@@ -118,9 +120,15 @@ export const createHandler = (manifest) => {
           template: page.template,
           entryName: page.entryName,
           logger,
+          reporter: defaultReporter,
           metrics,
           // FIXME: pass correctly req & res
           req: request,
+          serverTiming: {
+            addServeTiming() {
+              return this;
+            }
+          },
           res: responseLike
         };
         const body = await page.serverRender(serverRenderContext);
@@ -165,7 +173,7 @@ function createResponse(template) {
     return RESPONSE_NOTFOUND;
   }
 }
-function createWorkerHookContext(url, logger, metrics) {
+function createWorkerHookContext(url, logger, metrics, reporter) {
   const [res, req] = [
     {
       headers: new Headers(),
@@ -179,7 +187,8 @@ function createWorkerHookContext(url, logger, metrics) {
     res,
     req,
     logger,
-    metrics
+    metrics,
+    reporter
   };
 }
 function applyMiddlewares(ctx, middleware) {

package/dist/types/libs/context/context.d.ts

@@ -2,11 +2,12 @@
 /// <reference types="node" />
 /// <reference types="node" />
 /// <reference types="node/http" />
-/// <reference types=".dts-temp/3ag51RGwEKkAOCZCey_Qe/src/type" />
+/// <reference types=".dts-temp/rFczrZA4GO714tUiIeLuz/src/type" />
 import { IncomingMessage, ServerResponse } from 'http';
 import qs from 'querystring';
-import type { ModernServerContext as ModernServerContextInterface } from '@modern-js/types';
+import type { ModernServerContext as ModernServerContextInterface, Reporter as ModernServerReporter, ServerTiming as ModernServerTiming } from '@modern-js/types';
 export type ContextOptions = {
+  metaName?: string;
   etag?: boolean;
 };
 type ResponseBody = string | Buffer;
@@ -23,6 +24,8 @@ export declare class ModernServerContext implements ModernServerContextInterface
    * url params
    */
   params: Record<string, string>;
+  reporter: ModernServerReporter;
+  serverTiming: ModernServerTiming;
   get logger(): import("@modern-js/types").Logger;
   get metrics(): import("@modern-js/types").Metrics;
   serverData: Record<string, any>;

package/dist/types/libs/hook-api/index.worker.d.ts

@@ -1,4 +1,4 @@
-import { AfterMatchContext, AfterRenderContext, HookContext, Logger, Metrics, MiddlewareContext } from '@modern-js/types/server';
+import { AfterMatchContext, AfterRenderContext, HookContext, Logger, Metrics, MiddlewareContext, Reporter } from '@modern-js/types/server';
 export interface WorkerResponse {
   headers: Headers;
   status: number;
@@ -10,6 +10,7 @@ export interface WorkerServerContext {
   res: WorkerResponse;
   req: Request;
   logger: Logger;
+  reporter: Reporter;
   metrics: Metrics;
 }
 export declare const base: (context: WorkerServerContext) => HookContext;