@web-ts-toolkit/express-runtime 0.7.0

package/index.d.mts

@@ -0,0 +1,189 @@
+import http from 'node:http';
+import express, { RequestHandler, ErrorRequestHandler, Express } from 'express';
+export { ErrorRequestHandler, Express, RequestHandler } from 'express';
+import serverless from 'serverless-http';
+export { Options as RawServerlessHttpOptions } from 'serverless-http';
+
+interface Logger {
+    log: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+    debug?: (...args: unknown[]) => void;
+}
+interface RouterMount {
+    /**
+     * Mount path. May be a string or a function returning a string at runtime
+     * (e.g. derive from `NODE_ENV` so the same app serves serverless and local
+     * URLs without re-wiring).
+     */
+    path: string | (() => string);
+    handler: RequestHandler;
+}
+interface ExpressAppOptions {
+    /**
+     * Middleware registered before the built-in body parsers. Use this for
+     * logging, helmet, request-id, etc.
+     */
+    preMiddleware?: ReadonlyArray<RequestHandler | ErrorRequestHandler>;
+    /**
+     * Middleware registered after body parsers, before routers. Default location
+     * for cookies, sessions, auth, CORS, etc.
+     */
+    middleware?: ReadonlyArray<RequestHandler | ErrorRequestHandler>;
+    /**
+     * Middleware registered after all routers (e.g. a 404 catch-all).
+     */
+    postMiddleware?: ReadonlyArray<RequestHandler | ErrorRequestHandler>;
+    /**
+     * `express.json()` options. Pass `false` to disable. Default: `{ limit: '1mb' }`.
+     */
+    json?: Parameters<typeof express.json>[0] | false;
+    /**
+     * `express.urlencoded()` options. Pass `false` to disable.
+     * Default: `{ extended: false, limit: '1mb' }`.
+     */
+    urlencoded?: Parameters<typeof express.urlencoded>[0] | false;
+    /** Single router convenience. Same as `routers: [router]`. */
+    router?: RouterMount;
+    /**
+     * Multiple routers mounted in order. If `router` is also provided, it is
+     * mounted first.
+     */
+    routers?: ReadonlyArray<RouterMount>;
+    /**
+     * Express `trust proxy` setting. **Default: `false`** (opt-in). Setting this
+     * to a number/loop without a trusted upstream proxy is a security
+     * risk (`X-Forwarded-*` spoofing).
+     */
+    trustProxy?: boolean | number | string | ReadonlyArray<string>;
+    /** Disable the `x-powered-by` header. Default: `true`. */
+    disablePoweredBy?: boolean;
+    /** Express `etag` setting. Default: `false` (disable cache validation). */
+    etag?: boolean | string;
+    /**
+     * Hook called after routers and `postMiddleware`, before `errorHandler`. Use
+     * this to register routes that the error handler should catch — routes added
+     * after `createExpressApp` returns will not be wrapped by `errorHandler`.
+     */
+    finalize?(app: Express): void;
+    /** Error handler registered last (4-arg middleware). */
+    errorHandler?: ErrorRequestHandler;
+    /** Logger used internally. Default: `console`. */
+    logger?: Logger;
+}
+declare function createExpressApp(options?: ExpressAppOptions): Express;
+/**
+ * A platform-agnostic serverless handler. Works with Netlify, Vercel, AWS
+ * Lambda, and any platform that calls `(event, context)` and expects a
+ * response.
+ */
+type ServerlessHandler = ((event: unknown, context: unknown) => Promise<unknown>) & {
+    /**
+     * Reset the memoized init promise. Call to retry a failed cold-start
+     * (`init()` rejection is memoized; without `reset()` every subsequent
+     * invocation re-throws).
+     */
+    reset: () => void;
+};
+/** Type of the options object accepted by `serverless-http`. */
+type ServerlessHttpOptions = NonNullable<Parameters<typeof serverless>[1]>;
+interface ServerlessRequest {
+    body?: unknown;
+    headers?: Record<string, string>;
+}
+interface ServerlessHandlerOptions {
+    /**
+     * Called once per cold start before delegating to the handler. The resulting
+     * promise is memoized so subsequent warm invocations skip re-initialization.
+     * A rejected promise is **also** memoized — call `handler.reset()` to retry.
+     * Use this for DB connections, cache warmup, etc.
+     */
+    init?: () => Promise<void>;
+    /**
+     * Hook called for each request before Express processes it. The default
+     * implementation works around serverless-http issue #305 by parsing Buffer
+     * bodies into JSON or strings. Pass a function to override this behavior.
+     */
+    request?: (req: ServerlessRequest) => void | Promise<void>;
+    /** Hook called after Express finishes processing. */
+    response?: (res: unknown) => void | Promise<void>;
+    /**
+     * Additional options forwarded to `serverless-http` (e.g. `provider`,
+     * `binary`, `basePath`). `request` and `response` are controlled by the
+     * dedicated hooks above.
+     */
+    serverlessOptions?: Omit<ServerlessHttpOptions, 'request' | 'response'>;
+    /**
+     * Skip parsing bodies larger than this in the default request hook.
+     * Default: `1mb`. Platform events bypass Express body-parser limits, so the
+     * default hook applies its own size guard.
+     */
+    maxBodyBytes?: number;
+    logger?: Logger;
+}
+/**
+ * The default serverless request hook. Parses Buffer bodies into JSON (when
+ * `content-type` starts with `application/json`, allowing charset variations)
+ * or UTF-8 strings — a workaround for serverless-http issue #305.
+ *
+ * Exported for direct unit testing.
+ */
+declare function defaultRequestHook(req: ServerlessRequest, maxBodyBytes?: number, logger?: Logger): void;
+declare function createServerlessHandler(app: Express, options?: ServerlessHandlerOptions): ServerlessHandler;
+interface LocalServerOptions {
+    /**
+     * Port number or named pipe. Defaults to `process.env.PORT` or `8080`.
+     * Strings that don't parse as numbers are treated as named pipe paths.
+     */
+    port?: number | string;
+    /** Hostname to bind. Defaults to `process.env.HOST` or `0.0.0.0`. */
+    host?: string;
+    /** Called once before the server starts listening. */
+    init?: () => Promise<void>;
+    /**
+     * Called on graceful shutdown (via signal handler or `shutdown()`). The
+     * server closes and (if `exitAfterShutdown`) the process exits after this
+     * resolves.
+     */
+    onShutdown?: () => Promise<void> | void;
+    /** Called when the server starts listening. */
+    onListening?: () => void;
+    /** Called when the server encounters an error. Default logs and exits. */
+    onError?: (error: NodeJS.ErrnoException) => void;
+    /**
+     * Register signal handlers for graceful shutdown. Default: `true`
+     * (`SIGINT` + `SIGTERM`). Set `false` to manage the lifecycle manually via
+     * `shutdown()`. Pass an explicit array to choose different signals.
+     */
+    signals?: boolean | ReadonlyArray<NodeJS.Signals>;
+    /** Max ms to wait for in-flight requests on shutdown. Default: `5000`. */
+    shutdownTimeout?: number;
+    /**
+     * Call `process.exit(0)` after graceful shutdown completes. Default: `false`
+     * (programmatic callers manage the process themselves). The CLI sets this to
+     * `true`.
+     */
+    exitAfterShutdown?: boolean;
+    logger?: Logger;
+}
+interface LocalServer {
+    /** The underlying `http.Server`. */
+    server: http.Server;
+    /**
+     * Trigger graceful shutdown. Resolves after `onShutdown` and `server.close`
+     * complete (or after `shutdownTimeout` ms, force-closing idle connections).
+     * If `exitAfterShutdown` is `true`, the process exits before the promise
+     * resolves.
+     */
+    shutdown: () => Promise<void>;
+}
+/**
+ * Normalize a port value to a number or a named-pipe string. Throws on invalid
+ * values (negative, out of 16-bit range). Empty/undefined falls back to
+ * `process.env.PORT` then `8080`.
+ *
+ * Exported for direct unit testing.
+ */
+declare function normalizePort(val: number | string | undefined): number | string;
+declare function startLocalServer(app: Express, options?: LocalServerOptions): LocalServer;
+
+export { type ExpressAppOptions, type LocalServer, type LocalServerOptions, type Logger, type RouterMount, type ServerlessHandler, type ServerlessHandlerOptions, type ServerlessHttpOptions, type ServerlessRequest, createExpressApp, createServerlessHandler, defaultRequestHook, normalizePort, startLocalServer };

package/index.d.ts

@@ -0,0 +1,189 @@
+import http from 'node:http';
+import express, { RequestHandler, ErrorRequestHandler, Express } from 'express';
+export { ErrorRequestHandler, Express, RequestHandler } from 'express';
+import serverless from 'serverless-http';
+export { Options as RawServerlessHttpOptions } from 'serverless-http';
+
+interface Logger {
+    log: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+    debug?: (...args: unknown[]) => void;
+}
+interface RouterMount {
+    /**
+     * Mount path. May be a string or a function returning a string at runtime
+     * (e.g. derive from `NODE_ENV` so the same app serves serverless and local
+     * URLs without re-wiring).
+     */
+    path: string | (() => string);
+    handler: RequestHandler;
+}
+interface ExpressAppOptions {
+    /**
+     * Middleware registered before the built-in body parsers. Use this for
+     * logging, helmet, request-id, etc.
+     */
+    preMiddleware?: ReadonlyArray<RequestHandler | ErrorRequestHandler>;
+    /**
+     * Middleware registered after body parsers, before routers. Default location
+     * for cookies, sessions, auth, CORS, etc.
+     */
+    middleware?: ReadonlyArray<RequestHandler | ErrorRequestHandler>;
+    /**
+     * Middleware registered after all routers (e.g. a 404 catch-all).
+     */
+    postMiddleware?: ReadonlyArray<RequestHandler | ErrorRequestHandler>;
+    /**
+     * `express.json()` options. Pass `false` to disable. Default: `{ limit: '1mb' }`.
+     */
+    json?: Parameters<typeof express.json>[0] | false;
+    /**
+     * `express.urlencoded()` options. Pass `false` to disable.
+     * Default: `{ extended: false, limit: '1mb' }`.
+     */
+    urlencoded?: Parameters<typeof express.urlencoded>[0] | false;
+    /** Single router convenience. Same as `routers: [router]`. */
+    router?: RouterMount;
+    /**
+     * Multiple routers mounted in order. If `router` is also provided, it is
+     * mounted first.
+     */
+    routers?: ReadonlyArray<RouterMount>;
+    /**
+     * Express `trust proxy` setting. **Default: `false`** (opt-in). Setting this
+     * to a number/loop without a trusted upstream proxy is a security
+     * risk (`X-Forwarded-*` spoofing).
+     */
+    trustProxy?: boolean | number | string | ReadonlyArray<string>;
+    /** Disable the `x-powered-by` header. Default: `true`. */
+    disablePoweredBy?: boolean;
+    /** Express `etag` setting. Default: `false` (disable cache validation). */
+    etag?: boolean | string;
+    /**
+     * Hook called after routers and `postMiddleware`, before `errorHandler`. Use
+     * this to register routes that the error handler should catch — routes added
+     * after `createExpressApp` returns will not be wrapped by `errorHandler`.
+     */
+    finalize?(app: Express): void;
+    /** Error handler registered last (4-arg middleware). */
+    errorHandler?: ErrorRequestHandler;
+    /** Logger used internally. Default: `console`. */
+    logger?: Logger;
+}
+declare function createExpressApp(options?: ExpressAppOptions): Express;
+/**
+ * A platform-agnostic serverless handler. Works with Netlify, Vercel, AWS
+ * Lambda, and any platform that calls `(event, context)` and expects a
+ * response.
+ */
+type ServerlessHandler = ((event: unknown, context: unknown) => Promise<unknown>) & {
+    /**
+     * Reset the memoized init promise. Call to retry a failed cold-start
+     * (`init()` rejection is memoized; without `reset()` every subsequent
+     * invocation re-throws).
+     */
+    reset: () => void;
+};
+/** Type of the options object accepted by `serverless-http`. */
+type ServerlessHttpOptions = NonNullable<Parameters<typeof serverless>[1]>;
+interface ServerlessRequest {
+    body?: unknown;
+    headers?: Record<string, string>;
+}
+interface ServerlessHandlerOptions {
+    /**
+     * Called once per cold start before delegating to the handler. The resulting
+     * promise is memoized so subsequent warm invocations skip re-initialization.
+     * A rejected promise is **also** memoized — call `handler.reset()` to retry.
+     * Use this for DB connections, cache warmup, etc.
+     */
+    init?: () => Promise<void>;
+    /**
+     * Hook called for each request before Express processes it. The default
+     * implementation works around serverless-http issue #305 by parsing Buffer
+     * bodies into JSON or strings. Pass a function to override this behavior.
+     */
+    request?: (req: ServerlessRequest) => void | Promise<void>;
+    /** Hook called after Express finishes processing. */
+    response?: (res: unknown) => void | Promise<void>;
+    /**
+     * Additional options forwarded to `serverless-http` (e.g. `provider`,
+     * `binary`, `basePath`). `request` and `response` are controlled by the
+     * dedicated hooks above.
+     */
+    serverlessOptions?: Omit<ServerlessHttpOptions, 'request' | 'response'>;
+    /**
+     * Skip parsing bodies larger than this in the default request hook.
+     * Default: `1mb`. Platform events bypass Express body-parser limits, so the
+     * default hook applies its own size guard.
+     */
+    maxBodyBytes?: number;
+    logger?: Logger;
+}
+/**
+ * The default serverless request hook. Parses Buffer bodies into JSON (when
+ * `content-type` starts with `application/json`, allowing charset variations)
+ * or UTF-8 strings — a workaround for serverless-http issue #305.
+ *
+ * Exported for direct unit testing.
+ */
+declare function defaultRequestHook(req: ServerlessRequest, maxBodyBytes?: number, logger?: Logger): void;
+declare function createServerlessHandler(app: Express, options?: ServerlessHandlerOptions): ServerlessHandler;
+interface LocalServerOptions {
+    /**
+     * Port number or named pipe. Defaults to `process.env.PORT` or `8080`.
+     * Strings that don't parse as numbers are treated as named pipe paths.
+     */
+    port?: number | string;
+    /** Hostname to bind. Defaults to `process.env.HOST` or `0.0.0.0`. */
+    host?: string;
+    /** Called once before the server starts listening. */
+    init?: () => Promise<void>;
+    /**
+     * Called on graceful shutdown (via signal handler or `shutdown()`). The
+     * server closes and (if `exitAfterShutdown`) the process exits after this
+     * resolves.
+     */
+    onShutdown?: () => Promise<void> | void;
+    /** Called when the server starts listening. */
+    onListening?: () => void;
+    /** Called when the server encounters an error. Default logs and exits. */
+    onError?: (error: NodeJS.ErrnoException) => void;
+    /**
+     * Register signal handlers for graceful shutdown. Default: `true`
+     * (`SIGINT` + `SIGTERM`). Set `false` to manage the lifecycle manually via
+     * `shutdown()`. Pass an explicit array to choose different signals.
+     */
+    signals?: boolean | ReadonlyArray<NodeJS.Signals>;
+    /** Max ms to wait for in-flight requests on shutdown. Default: `5000`. */
+    shutdownTimeout?: number;
+    /**
+     * Call `process.exit(0)` after graceful shutdown completes. Default: `false`
+     * (programmatic callers manage the process themselves). The CLI sets this to
+     * `true`.
+     */
+    exitAfterShutdown?: boolean;
+    logger?: Logger;
+}
+interface LocalServer {
+    /** The underlying `http.Server`. */
+    server: http.Server;
+    /**
+     * Trigger graceful shutdown. Resolves after `onShutdown` and `server.close`
+     * complete (or after `shutdownTimeout` ms, force-closing idle connections).
+     * If `exitAfterShutdown` is `true`, the process exits before the promise
+     * resolves.
+     */
+    shutdown: () => Promise<void>;
+}
+/**
+ * Normalize a port value to a number or a named-pipe string. Throws on invalid
+ * values (negative, out of 16-bit range). Empty/undefined falls back to
+ * `process.env.PORT` then `8080`.
+ *
+ * Exported for direct unit testing.
+ */
+declare function normalizePort(val: number | string | undefined): number | string;
+declare function startLocalServer(app: Express, options?: LocalServerOptions): LocalServer;
+
+export { type ExpressAppOptions, type LocalServer, type LocalServerOptions, type Logger, type RouterMount, type ServerlessHandler, type ServerlessHandlerOptions, type ServerlessHttpOptions, type ServerlessRequest, createExpressApp, createServerlessHandler, defaultRequestHook, normalizePort, startLocalServer };

package/index.js

@@ -0,0 +1,259 @@
+"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);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createExpressApp: () => createExpressApp,
+  createServerlessHandler: () => createServerlessHandler,
+  defaultRequestHook: () => defaultRequestHook,
+  normalizePort: () => normalizePort,
+  startLocalServer: () => startLocalServer
+});
+module.exports = __toCommonJS(index_exports);
+var import_node_http = __toESM(require("http"));
+var import_express = __toESM(require("express"));
+var import_serverless_http = __toESM(require("serverless-http"));
+var defaultLogger = {
+  log: (...args) => console.log(...args),
+  error: (...args) => console.error(...args),
+  debug: (...args) => console.debug(...args)
+};
+function applySettings(app, options) {
+  if (options.disablePoweredBy !== false) {
+    app.disable("x-powered-by");
+  }
+  app.set("etag", options.etag ?? false);
+  app.set("trust proxy", options.trustProxy ?? false);
+}
+function applyMiddlewareList(app, list) {
+  if (list) {
+    for (const mw of list) {
+      app.use(mw);
+    }
+  }
+}
+function applyRouters(app, options) {
+  const mounts = [];
+  if (options.router) mounts.push(options.router);
+  if (options.routers) mounts.push(...options.routers);
+  for (const mount of mounts) {
+    const path = typeof mount.path === "function" ? mount.path() : mount.path;
+    app.use(path, mount.handler);
+  }
+}
+function createExpressApp(options = {}) {
+  const app = (0, import_express.default)();
+  applySettings(app, options);
+  applyMiddlewareList(app, options.preMiddleware);
+  if (options.json !== false) {
+    app.use(import_express.default.json(options.json ?? { limit: "1mb" }));
+  }
+  if (options.urlencoded !== false) {
+    app.use(import_express.default.urlencoded(options.urlencoded ?? { extended: false, limit: "1mb" }));
+  }
+  applyMiddlewareList(app, options.middleware);
+  applyRouters(app, options);
+  applyMiddlewareList(app, options.postMiddleware);
+  if (options.finalize) {
+    options.finalize(app);
+  }
+  if (options.errorHandler) {
+    app.use(options.errorHandler);
+  }
+  return app;
+}
+function defaultRequestHook(req, maxBodyBytes = 1024 * 1024, logger = defaultLogger) {
+  if (!req.body || !Buffer.isBuffer(req.body)) {
+    return;
+  }
+  if (req.body.length > maxBodyBytes) {
+    logger.debug?.(" Skipping oversized serverless body for content-type parsing");
+    return;
+  }
+  try {
+    const bodyStr = req.body.toString("utf8");
+    const contentType = (req.headers?.["content-type"] ?? "").toLowerCase();
+    if (contentType.startsWith("application/json")) {
+      req.body = JSON.parse(bodyStr);
+    } else {
+      req.body = bodyStr;
+    }
+  } catch (error) {
+    logger.error("Failed to parse serverless request body:", error);
+  }
+}
+function createServerlessHandler(app, options = {}) {
+  const logger = options.logger ?? defaultLogger;
+  const maxBodyBytes = options.maxBodyBytes ?? 1024 * 1024;
+  const requestHook = options.request ?? ((req) => defaultRequestHook(req, maxBodyBytes, logger));
+  const baseOptions = {
+    ...options.serverlessOptions ?? {},
+    request: requestHook
+  };
+  if (options.response) {
+    baseOptions.response = options.response;
+  }
+  const apiHandler = (0, import_serverless_http.default)(app, baseOptions);
+  let initialized = null;
+  const ensureInit = () => {
+    if (!initialized) {
+      logger.debug?.("Serverless cold start: running init");
+      initialized = options.init ? options.init() : Promise.resolve();
+    }
+    return initialized;
+  };
+  const handler = async (event, context) => {
+    await ensureInit();
+    return apiHandler(event, context);
+  };
+  handler.reset = () => {
+    initialized = null;
+  };
+  return handler;
+}
+var DEFAULT_SIGNALS = ["SIGINT", "SIGTERM"];
+var DEFAULT_SHUTDOWN_TIMEOUT = 5e3;
+function normalizePort(val) {
+  if (val === void 0 || val === "") {
+    const envPort = process.env.PORT;
+    if (envPort === void 0 || envPort === "") {
+      return 8080;
+    }
+    val = envPort;
+  }
+  if (typeof val === "string") {
+    const parsed = Number(val);
+    if (Number.isNaN(parsed)) {
+      return val;
+    }
+    val = parsed;
+  }
+  if (!Number.isFinite(val) || val < 0 || val > 65535) {
+    throw new Error(`Invalid port: ${String(val)}`);
+  }
+  return val;
+}
+function defaultOnError(error, port, logger) {
+  if (error.syscall !== "listen") {
+    throw error;
+  }
+  const bind = typeof port === "string" ? `Pipe ${port}` : `Port ${port}`;
+  if (error.code === "EACCES") {
+    logger.error(`${bind} requires elevated privileges`);
+    process.exit(1);
+  } else if (error.code === "EADDRINUSE") {
+    logger.error(`${bind} is already in use`);
+    process.exit(1);
+  } else {
+    throw error;
+  }
+}
+function startLocalServer(app, options = {}) {
+  const logger = options.logger ?? defaultLogger;
+  const port = normalizePort(options.port);
+  const host = options.host ?? process.env.HOST ?? "0.0.0.0";
+  const shutdownTimeout = options.shutdownTimeout ?? DEFAULT_SHUTDOWN_TIMEOUT;
+  const server = import_node_http.default.createServer(app);
+  app.set("port", port);
+  const onError = (error) => {
+    if (options.onError) {
+      options.onError(error);
+    } else {
+      defaultOnError(error, port, logger);
+    }
+  };
+  const onListening = () => {
+    const addr = server.address();
+    const bind = typeof addr === "string" ? `pipe ${addr}` : `port ${addr?.port}`;
+    logger.log(`Server running at http://${host}:${port}/ (${bind})`);
+    options.onListening?.();
+  };
+  server.on("error", onError);
+  server.on("listening", onListening);
+  const shutdown = async () => {
+    logger.log("Shutting down...");
+    try {
+      if (options.onShutdown) {
+        await options.onShutdown();
+      }
+    } catch (err) {
+      logger.error("onShutdown hook failed:", err);
+    }
+    await new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        server.closeAllConnections?.();
+        resolve();
+      }, shutdownTimeout);
+      server.close((err) => {
+        clearTimeout(timer);
+        if (err) {
+          logger.error("Server close error:", err);
+        }
+        resolve();
+      });
+    });
+    if (options.exitAfterShutdown) {
+      process.exit(0);
+    }
+  };
+  if (options.signals !== false) {
+    const list = options.signals === void 0 || options.signals === true ? DEFAULT_SIGNALS : options.signals;
+    for (const sig of list) {
+      process.once(sig, () => void shutdown());
+    }
+  }
+  const start = async () => {
+    try {
+      if (options.init) {
+        await options.init();
+      }
+      if (typeof port === "number") {
+        server.listen(port, host);
+      } else {
+        server.listen(port);
+      }
+    } catch (err) {
+      server.emit("error", err);
+    }
+  };
+  void start();
+  return {
+    server,
+    shutdown
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createExpressApp,
+  createServerlessHandler,
+  defaultRequestHook,
+  normalizePort,
+  startLocalServer
+});