@modern-js/server-core 2.48.2 → 2.48.3-alpha.0

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,130 @@
+"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_time = require("@modern-js/runtime-utils/time");
+var import_utils = require("../../utils");
+var import_constants = require("../../constants");
+var import_context = require("./context");
+const noop = () => {
+};
+const isHtmlResponse = (response) => {
+  const contentType = response.headers.get("content-type");
+  return contentType === null || contentType === void 0 ? void 0 : contentType.includes("text/html");
+};
+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 === null || reporter === void 0 ? void 0 : 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 || !isHtmlResponse(c.res))) {
+        return void 0;
+      }
+      if (routeInfo.isStream) {
+        const afterStreamingRenderContext = (0, import_context.createAfterStreamingRenderContext)(c, logger, routeInfo, metrics);
+        c.res = (0, import_utils.transformResponse)(c.res, (chunk) => {
+          const context = afterStreamingRenderContext(chunk);
+          return this.runner.afterStreamingRender(context, {
+            onLast: ({ chunk: chunk2 }) => chunk2
+          });
+        });
+      } 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 === null || reporter === void 0 ? void 0 : 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 logger = c.get("logger");
+      const reporter = c.get("reporter");
+      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 === null || reporter === void 0 ? void 0 : reporter.reportTiming(import_constants.ServerReportTimings.SERVER_MIDDLEWARE, cost));
+      if (!c.finalized) {
+        return next();
+      }
+    };
+  }
+  constructor(runner, serverBase, pwd) {
+    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
+});

package/dist/cjs/base/middlewares/customServer/routerApi.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 routerApi_exports = {};
+__export(routerApi_exports, {
+  RouterAPI: () => RouterAPI
+});
+module.exports = __toCommonJS(routerApi_exports);
+class RouterAPI {
+  redirect(url, status = 302) {
+    this.url = url;
+    this.status = status;
+  }
+  rewrite(entryName) {
+    this.current = entryName;
+  }
+  use(entryName) {
+    this.rewrite(entryName);
+  }
+  constructor(entryName) {
+    this.current = entryName;
+    this.status = 200;
+    this.url = "";
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RouterAPI
+});

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

@@ -0,0 +1,58 @@
+"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 template_exports = {};
+__export(template_exports, {
+  TemplateApi: () => TemplateApi
+});
+module.exports = __toCommonJS(template_exports);
+var import_constants = require("../../constants");
+class TemplateApi {
+  set(content) {
+    this.body = content;
+  }
+  get() {
+    return this.body;
+  }
+  prependHead(fragment) {
+    const { head } = import_constants.REPLACE_REG.before;
+    this.replaceBody(new RegExp(head), (beforeHead) => `${beforeHead}${fragment}`);
+  }
+  appendHead(fragment) {
+    const { head } = import_constants.REPLACE_REG.after;
+    this.replaceBody(head, () => `${fragment}${head}`);
+  }
+  prependBody(fragment) {
+    const { body } = import_constants.REPLACE_REG.before;
+    this.replaceBody(new RegExp(body), (beforeBody) => `${beforeBody}${fragment}`);
+  }
+  appendBody(fragment) {
+    const { body } = import_constants.REPLACE_REG.after;
+    this.replaceBody(body, () => `${fragment}${body}`);
+  }
+  replaceBody(searchValue, replaceCb) {
+    this.body = this.body.replace(searchValue, replaceCb);
+  }
+  constructor(body) {
+    this.body = body;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TemplateApi
+});

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

@@ -0,0 +1,34 @@
+"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 faviconFallback_exports = {};
+__export(faviconFallback_exports, {
+  favionFallbackMiddleware: () => favionFallbackMiddleware
+});
+module.exports = __toCommonJS(faviconFallback_exports);
+const favionFallbackMiddleware = async (c, next) => {
+  if (c.req.path === "/favicon.ico") {
+    return c.body(null, 204);
+  } else {
+    return next();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  favionFallbackMiddleware
+});

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

@@ -0,0 +1,26 @@
+"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 __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 = {};
+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);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./faviconFallback"),
+  ...require("./monitor"),
+  ...require("./renderHandler")
+});

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

@@ -0,0 +1,90 @@
+"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 monitor_exports = {};
+__export(monitor_exports, {
+  initReporter: () => initReporter,
+  injectLogger: () => injectLogger,
+  injectMetrics: () => injectMetrics,
+  injectReporter: () => injectReporter
+});
+module.exports = __toCommonJS(monitor_exports);
+var import_time = require("@modern-js/runtime-utils/time");
+var import_constants = require("../constants");
+const defaultReporter = {
+  init() {
+  },
+  reportError() {
+  },
+  reportTiming() {
+  },
+  reportInfo() {
+  },
+  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");
+    if (!reporter) {
+      await next();
+      return;
+    }
+    await reporter.init({
+      entryName
+    });
+    const getCost = (0, import_time.time)();
+    await next();
+    const cost = getCost();
+    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();
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  initReporter,
+  injectLogger,
+  injectMetrics,
+  injectReporter
+});

package/dist/cjs/base/middlewares/renderHandler/dataHandler.js

@@ -0,0 +1,46 @@
+"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 dataHandler_exports = {};
+__export(dataHandler_exports, {
+  dataHandler: () => dataHandler
+});
+module.exports = __toCommonJS(dataHandler_exports);
+var import_constants = require("@modern-js/utils/universal/constants");
+const dataHandler = async (request, { routeInfo, serverRoutes, reporter, logger, serverManifest }) => {
+  var _serverManifest_loaderBundles;
+  const serverLoaderModule = serverManifest === null || serverManifest === void 0 ? void 0 : (_serverManifest_loaderBundles = serverManifest.loaderBundles) === null || _serverManifest_loaderBundles === void 0 ? void 0 : _serverManifest_loaderBundles[routeInfo.entryName || import_constants.MAIN_ENTRY_NAME];
+  if (!serverLoaderModule) {
+    return;
+  }
+  const { routes, handleRequest } = serverLoaderModule;
+  const response = await handleRequest({
+    request,
+    serverRoutes,
+    context: {
+      logger,
+      reporter
+    },
+    routes
+  });
+  return response;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  dataHandler
+});

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

@@ -0,0 +1,104 @@
+"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)
+    __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 __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 renderHandler_exports = {};
+__export(renderHandler_exports, {
+  bindRenderHandler: () => bindRenderHandler,
+  getRenderHandler: () => getRenderHandler
+});
+module.exports = __toCommonJS(renderHandler_exports);
+var import_utils = require("../../utils");
+var import_monitor = require("../monitor");
+var import_customServer = require("../customServer");
+var import_render = require("./render");
+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 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,
+      serverManifest
+    });
+    return res;
+  };
+}
+async function getRenderHandler(options) {
+  const { routes, pwd, config } = options;
+  if (routes && routes.length > 0) {
+    var _config_server, _options_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,
+      staticGenerate: options.staticGenerate,
+      metaName: options.metaName || "modern-js",
+      forceCSR,
+      nonce: (_options_config_security = options.config.security) === null || _options_config_security === void 0 ? void 0 : _options_config_security.nonce
+    });
+    return render;
+  }
+  return null;
+}
+async function bindRenderHandler(server, options) {
+  const { routes, pwd } = options;
+  const { runner } = server;
+  if (routes && routes.length > 0) {
+    const customServer = new import_customServer.CustomServer(runner, server, pwd);
+    if ((0, import_utils.getRuntimeEnv)() === "node") {
+      const cacheModuleName = "./ssrCache";
+      const { ssrCache } = await Promise.resolve().then(() => __toESM(require(cacheModuleName)));
+      await ssrCache.loadCacheMod((0, import_utils.checkIsProd)() ? pwd : void 0);
+    }
+    const pageRoutes = routes.filter((route) => !route.isApi).sort(import_utils.sortRoutes);
+    for (const route of pageRoutes) {
+      const { urlPath: originUrlPath, entryName } = route;
+      const urlPath = originUrlPath.endsWith("/") ? `${originUrlPath}*` : `${originUrlPath}/*`;
+      const customServerHookMiddleware = customServer.getHookMiddleware(entryName || "main", routes);
+      server.use(urlPath, (0, import_monitor.initReporter)(entryName));
+      server.use(urlPath, customServerHookMiddleware);
+      const customServerMiddleware = customServer.getServerMiddleware();
+      server.use(urlPath, customServerMiddleware);
+    }
+    const render = await getRenderHandler(options);
+    render && server.all("*", createRenderHandler(render));
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  bindRenderHandler,
+  getRenderHandler
+});