@modern-js/server-core 2.46.1 → 2.47.1-alpha.0

package/dist/cjs/base/adapters/node/polyfills/install.js

@@ -0,0 +1,57 @@
+"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 install_exports = {};
+__export(install_exports, {
+  installGlobals: () => installGlobals
+});
+module.exports = __toCommonJS(install_exports);
+var import_fetch = require("@web-std/fetch");
+var import_stream = require("@web-std/stream");
+Object.defineProperty(import_fetch.Headers.prototype, "getSetCookie", {
+  value: function getSetCookie() {
+    const cookies = [];
+    this.forEach((value, name) => {
+      if (name.toLowerCase() === "set-cookie") {
+        cookies.push(value);
+      }
+    });
+    return cookies;
+  }
+});
+const installGlobals = () => {
+  if (!global.Headers) {
+    global.Headers = import_fetch.Headers;
+  }
+  if (!global.Request) {
+    global.Request = import_fetch.Request;
+  }
+  if (!global.Response) {
+    global.Response = import_fetch.Response;
+  }
+  if (!global.TransformStream) {
+    global.TransformStream = import_stream.TransformStream;
+  }
+  if (!global.ReadableStream) {
+    global.ReadableStream = import_stream.ReadableStream;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  installGlobals
+});

package/dist/cjs/base/adapters/node/polyfills/stream.js

@@ -0,0 +1,159 @@
+"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 stream_exports = {};
+__export(stream_exports, {
+  createReadableStreamFromReadable: () => createReadableStreamFromReadable,
+  readableStreamToString: () => readableStreamToString,
+  writeAsyncIterableToWritable: () => writeAsyncIterableToWritable,
+  writeReadableStreamToWritable: () => writeReadableStreamToWritable
+});
+module.exports = __toCommonJS(stream_exports);
+var import_define_property = require("@swc/helpers/_/_define_property");
+var import_node_stream = require("node:stream");
+var import_stream = require("@web-std/stream");
+async function writeReadableStreamToWritable(stream, writable) {
+  const reader = stream.getReader();
+  const flushable = writable;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        writable.end();
+        break;
+      }
+      writable.write(value);
+      if (typeof flushable.flush === "function") {
+        flushable.flush();
+      }
+    }
+  } catch (error) {
+    writable.destroy(error);
+    throw error;
+  }
+}
+async function writeAsyncIterableToWritable(iterable, writable) {
+  try {
+    for await (const chunk of iterable) {
+      writable.write(chunk);
+    }
+    writable.end();
+  } catch (error) {
+    writable.destroy(error);
+    throw error;
+  }
+}
+async function readableStreamToString(stream, encoding) {
+  const reader = stream.getReader();
+  const chunks = [];
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) {
+      break;
+    }
+    if (value) {
+      chunks.push(value);
+    }
+  }
+  return Buffer.concat(chunks).toString(encoding);
+}
+const createReadableStreamFromReadable = (source) => {
+  const pump = new StreamPump(source);
+  const stream = new import_stream.ReadableStream(pump, pump);
+  return stream;
+};
+class StreamPump {
+  size(chunk) {
+    return (chunk === null || chunk === void 0 ? void 0 : chunk.byteLength) || 0;
+  }
+  start(controller) {
+    this.controller = controller;
+    this.stream.on("data", this.enqueue);
+    this.stream.once("error", this.error);
+    this.stream.once("end", this.close);
+    this.stream.once("close", this.close);
+  }
+  pull() {
+    this.resume();
+  }
+  cancel(reason) {
+    if (this.stream.destroy) {
+      this.stream.destroy(reason);
+    }
+    this.stream.off("data", this.enqueue);
+    this.stream.off("error", this.error);
+    this.stream.off("end", this.close);
+    this.stream.off("close", this.close);
+  }
+  enqueue(chunk) {
+    if (this.controller) {
+      try {
+        const bytes = chunk instanceof Uint8Array ? chunk : Buffer.from(chunk);
+        const available = (this.controller.desiredSize || 0) - bytes.byteLength;
+        this.controller.enqueue(bytes);
+        if (available <= 0) {
+          this.pause();
+        }
+      } catch (error) {
+        this.controller.error(new Error("Could not create Buffer, chunk must be of type string or an instance of Buffer, ArrayBuffer, or Array or an Array-like Object"));
+        this.cancel();
+      }
+    }
+  }
+  pause() {
+    if (this.stream.pause) {
+      this.stream.pause();
+    }
+  }
+  resume() {
+    if (this.stream.readable && this.stream.resume) {
+      this.stream.resume();
+    }
+  }
+  close() {
+    if (this.controller) {
+      this.controller.close();
+      delete this.controller;
+    }
+  }
+  error(error) {
+    if (this.controller) {
+      this.controller.error(error);
+      delete this.controller;
+    }
+  }
+  constructor(stream) {
+    (0, import_define_property._)(this, "highWaterMark", void 0);
+    (0, import_define_property._)(this, "accumalatedSize", void 0);
+    (0, import_define_property._)(this, "stream", void 0);
+    (0, import_define_property._)(this, "controller", void 0);
+    this.highWaterMark = stream.readableHighWaterMark || new import_node_stream.Stream.Readable().readableHighWaterMark;
+    this.accumalatedSize = 0;
+    this.stream = stream;
+    this.enqueue = this.enqueue.bind(this);
+    this.error = this.error.bind(this);
+    this.close = this.close.bind(this);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createReadableStreamFromReadable,
+  readableStreamToString,
+  writeAsyncIterableToWritable,
+  writeReadableStreamToWritable
+});

package/dist/cjs/base/constants.js

@@ -0,0 +1,55 @@
+"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 constants_exports = {};
+__export(constants_exports, {
+  AGGRED_DIR: () => AGGRED_DIR,
+  REPLACE_REG: () => REPLACE_REG,
+  ServerReportTimings: () => ServerReportTimings
+});
+module.exports = __toCommonJS(constants_exports);
+const AGGRED_DIR = {
+  mock: "config/mock",
+  server: "server",
+  api: "api",
+  shared: "shared",
+  lambda: "lambda"
+};
+const REPLACE_REG = {
+  before: {
+    head: "<head[^>]*>",
+    body: "<body[^>]*>"
+  },
+  after: {
+    head: "</head>",
+    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 = {}));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AGGRED_DIR,
+  REPLACE_REG,
+  ServerReportTimings
+});

package/dist/cjs/base/index.js

@@ -0,0 +1,73 @@
+"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 base_exports = {};
+__export(base_exports, {
+  AGGRED_DIR: () => import_constants.AGGRED_DIR,
+  bindBFFHandler: () => import_node.bindBFFHandler,
+  bindDataHandlers: () => import_middlewares.bindDataHandlers,
+  bindRenderHandler: () => import_middlewares.bindRenderHandler,
+  connectMid2HonoMid: () => import_node.connectMid2HonoMid,
+  createErrorHtml: () => import_utils.createErrorHtml,
+  createInjectHtml: () => import_node.createInjectHtml,
+  createNodeServer: () => import_node.createNodeServer,
+  createServerBase: () => createServerBase,
+  createStaticMiddleware: () => import_node.createStaticMiddleware,
+  favionFallbackMiddleware: () => import_middlewares.favionFallbackMiddleware,
+  getRenderHandler: () => import_middlewares.getRenderHandler,
+  httpCallBack2HonoMid: () => import_node.httpCallBack2HonoMid,
+  injectLogger: () => import_middlewares.injectLogger,
+  injectReporter: () => import_middlewares.injectReporter,
+  loadServerEnv: () => import_node.loadServerEnv,
+  registerMockHandlers: () => import_node.registerMockHandlers,
+  sendResponse: () => import_node.sendResponse
+});
+module.exports = __toCommonJS(base_exports);
+var import_serverBase = require("./serverBase");
+var import_utils = require("./utils");
+var import_constants = require("./constants");
+var import_node = require("./adapters/node");
+var import_middlewares = require("./middlewares");
+function createServerBase(options) {
+  if (options == null) {
+    throw new Error("can not start server without options");
+  }
+  const server = new import_serverBase.ServerBase(options);
+  return server;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AGGRED_DIR,
+  bindBFFHandler,
+  bindDataHandlers,
+  bindRenderHandler,
+  connectMid2HonoMid,
+  createErrorHtml,
+  createInjectHtml,
+  createNodeServer,
+  createServerBase,
+  createStaticMiddleware,
+  favionFallbackMiddleware,
+  getRenderHandler,
+  httpCallBack2HonoMid,
+  injectLogger,
+  injectReporter,
+  loadServerEnv,
+  registerMockHandlers,
+  sendResponse
+});

package/dist/cjs/base/middlewares/customServer/base.js

@@ -0,0 +1,115 @@
+"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 base_exports = {};
+__export(base_exports, {
+  createBaseHookContext: () => createBaseHookContext
+});
+module.exports = __toCommonJS(base_exports);
+var import_define_property = require("@swc/helpers/_/_define_property");
+var import_cookie = require("hono/cookie");
+var import_utils = require("../../utils");
+function createBaseHookContext(c, logger, metrics) {
+  return {
+    request: new BaseHookRequest(c),
+    response: new BaseHookResponse(c),
+    logger,
+    metrics
+  };
+}
+class BaseHookRequest {
+  get url() {
+    return this.req.url;
+  }
+  get host() {
+    return (0, import_utils.getHost)(this.req.raw);
+  }
+  get pathname() {
+    return this.req.path;
+  }
+  get query() {
+    return this.req.query();
+  }
+  get headers() {
+    return this.req.header();
+  }
+  get cookies() {
+    return {
+      // FIXME: ModernRequest Type Error
+      get: (key) => {
+        return (0, import_cookie.getCookie)(this.c, key);
+      }
+    };
+  }
+  get cookie() {
+    return this.req.header("cookie");
+  }
+  constructor(c) {
+    (0, import_define_property._)(this, "req", void 0);
+    (0, import_define_property._)(this, "c", void 0);
+    this.c = c;
+    this.req = c.req;
+  }
+}
+class BaseHookResponse {
+  get(key) {
+    return this.c.res.headers.get(key);
+  }
+  set(key, value) {
+    if ([
+      "set-cookie",
+      "Set-Cookie"
+    ].includes(key)) {
+      this.c.header(key, value.toString(), {
+        append: true
+      });
+    } else {
+      this.c.header(key, value.toString());
+    }
+  }
+  status(code) {
+    this.c.status(code);
+  }
+  get cookies() {
+    const setCookie = (key, value) => {
+      this.c.header("set-cookie", `${key}=${value}`, {
+        append: true
+      });
+    };
+    const clearCookie = () => {
+      this.c.header("set-cookie", void 0);
+    };
+    return {
+      set: setCookie,
+      clear: clearCookie
+    };
+  }
+  raw(body, options) {
+    this.c.res = this.c.newResponse(body, options);
+    this.private_overrided = true;
+  }
+  constructor(c) {
+    (0, import_define_property._)(this, "private_overrided", false);
+    (0, import_define_property._)(this, "c", void 0);
+    this.c = c;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createBaseHookContext
+});

package/dist/cjs/base/middlewares/customServer/context.js

@@ -0,0 +1,78 @@
+"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 context_exports = {};
+__export(context_exports, {
+  createAfterMatchCtx: () => createAfterMatchCtx,
+  createAfterRenderCtx: () => createAfterRenderCtx,
+  createAfterStreamingRenderContext: () => createAfterStreamingRenderContext,
+  createCustomMiddlewaresCtx: () => createCustomMiddlewaresCtx
+});
+module.exports = __toCommonJS(context_exports);
+var import_routerApi = require("./routerApi");
+var import_template = require("./template");
+var import_base = require("./base");
+function createAfterMatchCtx(c, entryName, logger, metrics) {
+  const baseContext = (0, import_base.createBaseHookContext)(c, logger, metrics);
+  return {
+    ...baseContext,
+    router: new import_routerApi.RouterAPI(entryName)
+  };
+}
+async function createAfterRenderCtx(c, logger, metrics) {
+  const baseContext = (0, import_base.createBaseHookContext)(c, logger, metrics);
+  const resBody = await c.res.text();
+  return {
+    ...baseContext,
+    template: new import_template.TemplateApi(resBody)
+  };
+}
+function createCustomMiddlewaresCtx(c, logger, metrics) {
+  var _c_env_node, _c_env_node1;
+  const baseContext = (0, import_base.createBaseHookContext)(c, logger, metrics);
+  const reporter = c.get("reporter");
+  return {
+    ...baseContext,
+    reporter,
+    response: {
+      ...baseContext.response,
+      locals: {}
+    },
+    source: {
+      req: (_c_env_node = c.env.node) === null || _c_env_node === void 0 ? void 0 : _c_env_node.req,
+      res: (_c_env_node1 = c.env.node) === null || _c_env_node1 === void 0 ? void 0 : _c_env_node1.res
+    }
+  };
+}
+function createAfterStreamingRenderContext(c, logger, route, metrics) {
+  const baseContext = (0, import_base.createBaseHookContext)(c, logger, metrics);
+  return (chunk) => {
+    return {
+      ...baseContext,
+      route,
+      chunk
+    };
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createAfterMatchCtx,
+  createAfterRenderCtx,
+  createAfterStreamingRenderContext,
+  createCustomMiddlewaresCtx
+});

package/dist/cjs/base/middlewares/customServer/index.js

@@ -0,0 +1,138 @@
+"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 customServer_exports = {};
+__export(customServer_exports, {
+  CustomServer: () => CustomServer
+});
+module.exports = __toCommonJS(customServer_exports);
+var import_define_property = require("@swc/helpers/_/_define_property");
+var import_time = require("@modern-js/runtime-utils/time");
+var import_utils = require("../../utils");
+var import_constants = require("../../constants");
+var import_context = require("./context");
+const noop = () => {
+};
+class CustomServer {
+  getHookMiddleware(entryName, routes) {
+    return async (c, next) => {
+      const routeInfo = routes.find((route) => route.entryName === entryName);
+      const logger = c.get("logger");
+      const reporter = c.get("reporter");
+      const metrics = c.get("metrics");
+      const afterMatchCtx = (0, import_context.createAfterMatchCtx)(c, entryName, logger, metrics);
+      const getCost = (0, import_time.time)();
+      await this.runner.afterMatch(afterMatchCtx, {
+        onLast: noop
+      });
+      const cost = getCost();
+      cost && reporter.reportTiming(import_constants.ServerReportTimings.SERVER_HOOK_AFTER_MATCH, cost);
+      const {
+        // current,
+        url,
+        status
+      } = afterMatchCtx.router;
+      if (url) {
+        return c.redirect(url, status);
+      }
+      const { current } = afterMatchCtx.router;
+      if (current !== entryName) {
+        const rewriteRoute = routes.find((route) => route.entryName === current);
+        if (rewriteRoute) {
+          return this.serverBase.request(rewriteRoute.urlPath);
+        }
+      }
+      if (c.finalized) {
+        return void 0;
+      }
+      await next();
+      if (c.finalized && !c.res.body) {
+        return void 0;
+      }
+      if (routeInfo.isStream) {
+        var _c_res_body;
+        const afterStreamingRenderContext = (0, import_context.createAfterStreamingRenderContext)(c, logger, routeInfo, metrics);
+        const injectStream = (0, import_utils.createTransformStream)((chunk) => {
+          const context = afterStreamingRenderContext(chunk);
+          return this.runner.afterStreamingRender(context, {
+            onLast: ({ chunk: chunk2 }) => chunk2
+          });
+        });
+        (_c_res_body = c.res.body) === null || _c_res_body === void 0 ? void 0 : _c_res_body.pipeThrough(injectStream);
+        const { headers, status: status2, statusText } = c.res;
+        c.res = c.body(injectStream.readable, {
+          headers,
+          status: status2,
+          statusText
+        });
+      } else {
+        const afterRenderCtx = await (0, import_context.createAfterRenderCtx)(c, logger, metrics);
+        const getCost2 = (0, import_time.time)();
+        await this.runner.afterRender(afterRenderCtx, {
+          onLast: noop
+        });
+        const cost2 = getCost2();
+        cost2 && reporter.reportTiming(import_constants.ServerReportTimings.SERVER_HOOK_AFTER_RENDER, cost2);
+        if (afterRenderCtx.response.private_overrided) {
+          return void 0;
+        }
+        const newBody = afterRenderCtx.template.get();
+        c.res = c.body(newBody);
+      }
+    };
+  }
+  getServerMiddleware() {
+    return async (c, next) => {
+      const serverMiddleware = await this.serverMiddlewarePromise;
+      if (!serverMiddleware) {
+        return next();
+      }
+      const reporter = c.get("reporter");
+      const logger = c.get("logger");
+      const metrics = c.get("metrics");
+      const customMiddlewareCtx = (0, import_context.createCustomMiddlewaresCtx)(c, logger, metrics);
+      const getCost = (0, import_time.time)();
+      await serverMiddleware(customMiddlewareCtx);
+      const cost = getCost();
+      cost && reporter.reportTiming(import_constants.ServerReportTimings.SERVER_MIDDLEWARE, cost);
+      if (!c.finalized) {
+        return next();
+      }
+    };
+  }
+  constructor(runner, serverBase, pwd) {
+    (0, import_define_property._)(this, "runner", void 0);
+    (0, import_define_property._)(this, "serverMiddlewarePromise", void 0);
+    (0, import_define_property._)(this, "serverBase", void 0);
+    this.runner = runner;
+    this.serverBase = serverBase;
+    const webExtension = [];
+    this.serverMiddlewarePromise = runner.prepareWebServer({
+      pwd,
+      config: {
+        middleware: webExtension
+      }
+    }, {
+      onLast: () => null
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CustomServer
+});