@web-ts-toolkit/express-runtime 0.26.0 → 0.27.0

package/cli-api.js

@@ -0,0 +1,1084 @@
+"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 __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+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
+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 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
+  };
+}
+var import_node_http, import_express, import_serverless_http, defaultLogger, DEFAULT_SIGNALS, DEFAULT_SHUTDOWN_TIMEOUT;
+var init_index = __esm({
+  "src/index.ts"() {
+    "use strict";
+    import_node_http = __toESM(require("http"));
+    import_express = __toESM(require("express"));
+    import_serverless_http = __toESM(require("serverless-http"));
+    defaultLogger = {
+      log: (...args) => console.log(...args),
+      error: (...args) => console.error(...args),
+      debug: (...args) => console.debug(...args)
+    };
+    DEFAULT_SIGNALS = ["SIGINT", "SIGTERM"];
+    DEFAULT_SHUTDOWN_TIMEOUT = 5e3;
+  }
+});
+
+// src/cli-utils.ts
+function readValue(argv, index, name) {
+  const value = argv[index + 1];
+  if (value === void 0 || value.startsWith("--")) {
+    throw new Error(`Missing value for argument: ${name}`);
+  }
+  return value;
+}
+function printHelp() {
+  console.log(`wtt-express-runtime
+
+Run an Express app locally, bundle it for local or serverless runtimes, or run the bundle.
+
+Usage:
+  wtt-express-runtime <command> <app-module> [options]
+  wtt-express-runtime <app-module> [options]   (alias for dev)
+
+Commands:
+  dev                           Run the Express app as a local dev server
+  build                         Bundle the Express app as a local app module
+  start                         Run a bundled local app module
+  build-serverless              Bundle the Express app as a serverless handler
+  start-serverless              Run a bundled serverless handler locally
+
+Dev options:
+  --port <number>               Port or named pipe (default: process.env.PORT or 8080)
+  --host <hostname>             Hostname to bind (default: process.env.HOST or 0.0.0.0)
+  --no-signals                  Disable SIGINT/SIGTERM handler registration
+  --shutdown-timeout <ms>       Max ms to wait for in-flight requests (default: 5000)
+  --require <module>            Module(s) to preload before app load (repeatable)
+  --env <path>                  Env file(s) to load (repeatable; existing env vars are not overridden)
+  --watch <paths>               Comma-separated paths to watch for restart (repeatable; dev only)
+  --ext <extensions>            Comma-separated extensions to watch (default: ts,js,mjs,cjs,json)
+  --delay <ms>                  Debounce ms before restarting on change (default: 500)
+
+Build options:
+  --init <path>                 Init hook module (default export, async function)
+  --out-dir <path>              Output directory (default: dist)
+  --out-name <name>             Output filename without extension (default: app)
+  --format <cjs|esm>            Output format (default: cjs)
+  --target <target>             Compilation target (default: node22)
+  --external <pkg>              Mark package as external (repeatable; express always external)
+  --no-clean                    Don't clean the output directory before building
+
+Start options:
+  --port <number>               Port or named pipe (default: process.env.PORT or 8080)
+  --host <hostname>             Hostname to bind (default: process.env.HOST or 0.0.0.0)
+  --no-signals                  Disable SIGINT/SIGTERM handler registration
+  --shutdown-timeout <ms>       Max ms to wait for in-flight requests (default: 5000)
+  --require <module>            Module(s) to preload before app load (repeatable)
+  --env <path>                  Env file(s) to load (repeatable; existing env vars are not overridden)
+
+Build-serverless options:
+  --init <path>                 Init hook module (default export, async function)
+  --out-dir <path>              Output directory (default: dist)
+  --out-name <name>             Output filename without extension (default: handler)
+  --format <cjs|esm>            Output format (default: cjs)
+  --target <target>             Compilation target (default: node22)
+  --external <pkg>              Mark package as external (repeatable; express always external)
+  --no-clean                    Don't clean the output directory before building
+
+Start-serverless options:
+  --port <number>               Port or named pipe (default: process.env.PORT or 8080)
+  --host <hostname>             Hostname to bind (default: process.env.HOST or 0.0.0.0)
+  --no-signals                  Disable SIGINT/SIGTERM handler registration
+  --shutdown-timeout <ms>       Max ms to wait for in-flight requests (default: 5000)
+  --require <module>            Module(s) to preload before handler load (repeatable)
+  --env <path>                  Env file(s) to load (repeatable; existing env vars are not overridden)
+
+Global options:
+  -V, --version                 Show version
+  -h, --help                    Show this help message
+
+Examples:
+  wtt-express-runtime dev ./dist/app.js
+  wtt-express-runtime dev ./dist/app.js --port 3000 --host localhost
+  wtt-express-runtime dev ./src/app.ts --env .env --require tsconfig-paths/register --watch ./src,./shared
+  wtt-express-runtime build ./src/app.ts --out-dir dist
+  wtt-express-runtime start ./dist/app.js --port 3000 --env .env
+  wtt-express-runtime build-serverless ./src/app.ts --out-dir netlify/functions
+  wtt-express-runtime build-serverless ./src/app.ts --init ./src/init.ts --format esm
+  wtt-express-runtime start-serverless ./netlify/functions/handler.js --port 9000 --env .env
+  wtt-express-runtime build-serverless ./src/app.ts && wtt-express-runtime start-serverless ./dist/handler.js
+
+Notes:
+  - In dev mode, the CLI evaluates arbitrary code from <app-module> in the current process.
+  - TypeScript app modules in dev mode require a TS loader. Run via tsx:
+      npx tsx ./node_modules/@web-ts-toolkit/express-runtime/dist/cli.js dev ./src/app.ts
+    Or use --require with a TS-aware loader module.
+  - --env files are parsed as KEY=VALUE; existing process.env entries are never overridden.
+    For advanced dotenv features (multiline, expansion), --require dotenv/config instead.
+  - --watch forks a child process running the same CLI without --watch. On file change,
+    the child is killed (SIGTERM) and respawned after the debounce delay.
+  - In build/build-serverless mode, express is always external. Add more externals with --external.
+  - In start mode, the bundled app file must default-export an Express app (or export it as "app").
+    If the bundle exports "init", it runs before the server starts listening.
+  - In start-serverless mode, the bundled handler file must be a JS/CJS module whose
+    "handler" export (or default export) is a function: (event, context) => Promise<result>.
+  - Init logic for dev mode (DB connections, etc.): add at the top level of your app module.
+`);
+}
+function isVersion(arg) {
+  return arg === "-V" || arg === "--version";
+}
+function isHelp(arg) {
+  return arg === "-h" || arg === "--help";
+}
+function isSubcommand(arg) {
+  return arg === "dev" || arg === "build" || arg === "start" || arg === "build-serverless" || arg === "start-serverless";
+}
+function parseRepeatable(argv, index, arg, list) {
+  const value = readValue(argv, index, arg);
+  for (const part of value.split(",")) {
+    const trimmed = part.trim();
+    if (trimmed) list.push(trimmed);
+  }
+  return index + 1;
+}
+function parseDevArgs(argv) {
+  const options = {};
+  const requireModules = [];
+  const envFiles = [];
+  const watchPaths = [];
+  let watchExt;
+  let watchDelay;
+  let appPath;
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--") {
+      continue;
+    }
+    if (isHelp(arg) || isVersion(arg)) {
+      continue;
+    }
+    if (arg === "--port") {
+      const port = readValue(argv, index, arg);
+      const portNum = Number(port);
+      options.port = Number.isNaN(portNum) ? port : portNum;
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--port=")) {
+      const port = arg.slice("--port=".length);
+      const portNum = Number(port);
+      options.port = Number.isNaN(portNum) ? port : portNum;
+      continue;
+    }
+    if (arg === "--host") {
+      options.host = readValue(argv, index, arg);
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--host=")) {
+      options.host = arg.slice("--host=".length);
+      continue;
+    }
+    if (arg === "--no-signals") {
+      options.signals = false;
+      continue;
+    }
+    if (arg === "--shutdown-timeout") {
+      options.shutdownTimeout = Number(readValue(argv, index, arg));
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--shutdown-timeout=")) {
+      options.shutdownTimeout = Number(arg.slice("--shutdown-timeout=".length));
+      continue;
+    }
+    if (arg === "--require") {
+      index = parseRepeatable(argv, index, arg, requireModules);
+      continue;
+    }
+    if (arg.startsWith("--require=")) {
+      for (const part of arg.slice("--require=".length).split(",")) {
+        const trimmed = part.trim();
+        if (trimmed) requireModules.push(trimmed);
+      }
+      continue;
+    }
+    if (arg === "--env") {
+      index = parseRepeatable(argv, index, arg, envFiles);
+      continue;
+    }
+    if (arg.startsWith("--env=")) {
+      for (const part of arg.slice("--env=".length).split(",")) {
+        const trimmed = part.trim();
+        if (trimmed) envFiles.push(trimmed);
+      }
+      continue;
+    }
+    if (arg === "--watch") {
+      index = parseRepeatable(argv, index, arg, watchPaths);
+      continue;
+    }
+    if (arg.startsWith("--watch=")) {
+      for (const part of arg.slice("--watch=".length).split(",")) {
+        const trimmed = part.trim();
+        if (trimmed) watchPaths.push(trimmed);
+      }
+      continue;
+    }
+    if (arg === "--ext") {
+      watchExt = [];
+      index = parseRepeatable(argv, index, arg, watchExt);
+      continue;
+    }
+    if (arg.startsWith("--ext=")) {
+      watchExt = [];
+      for (const part of arg.slice("--ext=".length).split(",")) {
+        const trimmed = part.trim();
+        if (trimmed) watchExt.push(trimmed);
+      }
+      continue;
+    }
+    if (arg === "--delay") {
+      watchDelay = Number(readValue(argv, index, arg));
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--delay=")) {
+      watchDelay = Number(arg.slice("--delay=".length));
+      continue;
+    }
+    if (!arg.startsWith("--")) {
+      if (appPath) {
+        throw new Error(`Unexpected positional argument: ${arg}. App module already set to ${appPath}`);
+      }
+      appPath = arg;
+      continue;
+    }
+    throw new Error(`Unknown argument: ${arg}`);
+  }
+  if (!appPath) {
+    printHelp();
+    throw new Error("Missing required argument: <app-module>");
+  }
+  return {
+    appPath,
+    options,
+    require: requireModules,
+    env: envFiles,
+    watch: watchPaths,
+    watchExt: watchExt ?? DEFAULT_WATCH_EXTENSIONS,
+    watchDelay: watchDelay ?? DEFAULT_WATCH_DELAY
+  };
+}
+function parseStartLikeArgs(argv, subcommandName) {
+  for (const arg of argv) {
+    if (arg === "--watch" || arg.startsWith("--watch=") || arg === "--ext" || arg.startsWith("--ext=") || arg === "--delay" || arg.startsWith("--delay=")) {
+      throw new Error(`--watch/--ext/--delay are not supported with the ${subcommandName} subcommand`);
+    }
+  }
+  return parseDevArgs(argv);
+}
+function parseStartArgs(argv) {
+  const result = parseStartLikeArgs(argv, "start");
+  return {
+    appPath: result.appPath,
+    options: result.options,
+    require: result.require,
+    env: result.env
+  };
+}
+function parseStartServerlessArgs(argv) {
+  const result = parseStartLikeArgs(argv, "start-serverless");
+  return {
+    handlerPath: result.appPath,
+    options: result.options,
+    require: result.require,
+    env: result.env
+  };
+}
+function parseBuildArgs(argv, outNameDefault) {
+  let appPath;
+  const external = [];
+  const result = {
+    initPath: void 0,
+    outDir: "dist",
+    outName: outNameDefault,
+    format: "cjs",
+    target: "node22",
+    external,
+    clean: true
+  };
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--") {
+      continue;
+    }
+    if (isHelp(arg) || isVersion(arg)) {
+      continue;
+    }
+    if (arg === "--init") {
+      result.initPath = readValue(argv, index, arg);
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--init=")) {
+      result.initPath = arg.slice("--init=".length);
+      continue;
+    }
+    if (arg === "--out-dir") {
+      result.outDir = readValue(argv, index, arg);
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--out-dir=")) {
+      result.outDir = arg.slice("--out-dir=".length);
+      continue;
+    }
+    if (arg === "--out-name") {
+      result.outName = readValue(argv, index, arg);
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--out-name=")) {
+      result.outName = arg.slice("--out-name=".length);
+      continue;
+    }
+    if (arg === "--format") {
+      const fmt = readValue(argv, index, arg);
+      if (fmt !== "cjs" && fmt !== "esm") {
+        throw new Error(`Invalid --format: ${fmt}. Must be 'cjs' or 'esm'.`);
+      }
+      result.format = fmt;
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--format=")) {
+      const fmt = arg.slice("--format=".length);
+      if (fmt !== "cjs" && fmt !== "esm") {
+        throw new Error(`Invalid --format: ${fmt}. Must be 'cjs' or 'esm'.`);
+      }
+      result.format = fmt;
+      continue;
+    }
+    if (arg === "--target") {
+      result.target = readValue(argv, index, arg);
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--target=")) {
+      result.target = arg.slice("--target=".length);
+      continue;
+    }
+    if (arg === "--external") {
+      external.push(readValue(argv, index, arg));
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--external=")) {
+      external.push(arg.slice("--external=".length));
+      continue;
+    }
+    if (arg === "--no-clean") {
+      result.clean = false;
+      continue;
+    }
+    if (!arg.startsWith("--")) {
+      if (appPath) {
+        throw new Error(`Unexpected positional argument: ${arg}. App module already set to ${appPath}`);
+      }
+      appPath = arg;
+      continue;
+    }
+    throw new Error(`Unknown argument: ${arg}`);
+  }
+  if (!appPath) {
+    printHelp();
+    throw new Error("Missing required argument: <app-module>");
+  }
+  return { appPath, ...result };
+}
+function parseLocalBuildArgs(argv) {
+  return parseBuildArgs(argv, "app");
+}
+function parseBuildServerlessArgs(argv) {
+  return parseBuildArgs(argv, "handler");
+}
+function parseArgs(argv) {
+  if (argv.length === 0) {
+    printHelp();
+    return null;
+  }
+  if (argv.some((a) => isHelp(a))) {
+    printHelp();
+    return null;
+  }
+  if (argv.some((a) => isVersion(a))) {
+    console.log(CLI_VERSION);
+    return null;
+  }
+  const first = argv[0];
+  if (isSubcommand(first)) {
+    const rest = argv.slice(1);
+    if (first === "dev") {
+      return { subcommand: "dev", dev: parseDevArgs(rest) };
+    }
+    if (first === "build") {
+      return { subcommand: "build", build: parseLocalBuildArgs(rest) };
+    }
+    if (first === "start") {
+      return { subcommand: "start", start: parseStartArgs(rest) };
+    }
+    if (first === "build-serverless") {
+      return { subcommand: "build-serverless", buildServerless: parseBuildServerlessArgs(rest) };
+    }
+    return { subcommand: "start-serverless", startServerless: parseStartServerlessArgs(rest) };
+  }
+  return { subcommand: "dev", dev: parseDevArgs(argv) };
+}
+function isExpressApp(x) {
+  if (x === null || x === void 0) return false;
+  const t = typeof x;
+  if (t !== "object" && t !== "function") return false;
+  return typeof x.listen === "function" && typeof x.use === "function";
+}
+function extractExport(mod) {
+  return mod.default ?? mod.app;
+}
+async function resolveExport(exported, appPath) {
+  if (isExpressApp(exported)) {
+    return exported;
+  }
+  if (typeof exported === "function") {
+    const result = await exported();
+    if (!isExpressApp(result)) {
+      throw new Error(`Function in "${appPath}" did not return an Express app.`);
+    }
+    return result;
+  }
+  throw new Error(`Default export of "${appPath}" is not an Express app or an async function returning one.`);
+}
+async function loadApp(appPath) {
+  const fullPath = (0, import_node_path.resolve)(process.cwd(), appPath);
+  const moduleUrl = (0, import_node_url.pathToFileURL)(fullPath).href;
+  const mod = await import(moduleUrl);
+  const exported = extractExport(mod);
+  if (!exported) {
+    throw new Error(
+      `Module "${appPath}" must default-export an Express app or an async function returning one. Exports: ${Object.keys(mod).join(", ")}`
+    );
+  }
+  return resolveExport(exported, appPath);
+}
+function parseEnvFile(content) {
+  const result = {};
+  for (const line of content.split("\n")) {
+    let trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    if (trimmed.startsWith("export ")) trimmed = trimmed.slice("export ".length).trim();
+    const eqIndex = trimmed.indexOf("=");
+    if (eqIndex === -1) continue;
+    const key = trimmed.slice(0, eqIndex).trim();
+    let value = trimmed.slice(eqIndex + 1).trim();
+    if (value.length >= 2) {
+      const first = value[0];
+      const last = value[value.length - 1];
+      if (first === '"' && last === '"' || first === "'" && last === "'") {
+        value = value.slice(1, -1);
+      }
+    }
+    result[key] = value;
+  }
+  return result;
+}
+function loadEnvFiles(paths) {
+  for (const p of paths) {
+    const absPath = (0, import_node_path.resolve)(process.cwd(), p);
+    if (!(0, import_node_fs.existsSync)(absPath)) {
+      throw new Error(`Env file not found: ${p}`);
+    }
+    const content = (0, import_node_fs.readFileSync)(absPath, "utf8");
+    const parsed = parseEnvFile(content);
+    for (const [key, value] of Object.entries(parsed)) {
+      if (process.env[key] === void 0) {
+        process.env[key] = value;
+      }
+    }
+  }
+}
+async function preloadModules(modules) {
+  for (const mod of modules) {
+    moduleRequire(mod);
+  }
+}
+function buildChildArgs(args) {
+  const result = ["dev", args.appPath];
+  if (args.options.port !== void 0) result.push("--port", String(args.options.port));
+  if (args.options.host !== void 0) result.push("--host", args.options.host);
+  if (args.options.signals === false) result.push("--no-signals");
+  if (args.options.shutdownTimeout !== void 0)
+    result.push("--shutdown-timeout", String(args.options.shutdownTimeout));
+  for (const r of args.require) result.push("--require", r);
+  for (const e of args.env) result.push("--env", e);
+  return result;
+}
+function runWithWatch(args) {
+  const cliPath = process.argv[1];
+  const childArgv = buildChildArgs(args);
+  let child = null;
+  let restartTimer = null;
+  let isShuttingDown = false;
+  const restartDelay = args.watchDelay;
+  const spawnChild = () => {
+    child = (0, import_node_child_process.fork)(cliPath, childArgv, { stdio: "inherit" });
+    child.on("exit", (code) => {
+      child = null;
+      if (!isShuttingDown && code !== null && code !== 0) {
+      }
+    });
+  };
+  const killChild = () => {
+    return new Promise((resolve) => {
+      if (!child || !child.pid) {
+        resolve();
+        return;
+      }
+      child.once("exit", () => resolve());
+      child.kill("SIGTERM");
+    });
+  };
+  const restart = async () => {
+    await killChild();
+    spawnChild();
+  };
+  const debouncedRestart = () => {
+    if (restartTimer) clearTimeout(restartTimer);
+    restartTimer = setTimeout(() => {
+      restartTimer = null;
+      void restart();
+    }, restartDelay);
+  };
+  for (const watchPath of args.watch) {
+    const absPath = (0, import_node_path.resolve)(process.cwd(), watchPath);
+    if (!(0, import_node_fs.existsSync)(absPath)) {
+      throw new Error(`Watch path not found: ${watchPath}`);
+    }
+    (0, import_node_fs.watch)(absPath, { recursive: true }, (_eventType, filename) => {
+      if (!filename) return;
+      const ext = (0, import_node_path.extname)(filename).slice(1).toLowerCase();
+      if (args.watchExt.includes(ext)) {
+        debouncedRestart();
+      }
+    });
+  }
+  const shutdown = () => {
+    isShuttingDown = true;
+    if (restartTimer) clearTimeout(restartTimer);
+    if (child && child.pid) {
+      child.once("exit", () => process.exit(0));
+      child.kill("SIGTERM");
+    } else {
+      process.exit(0);
+    }
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  spawnChild();
+}
+function generateServerlessEntry(appPath, initPath) {
+  const absAppPath = (0, import_node_path.resolve)(process.cwd(), appPath);
+  const absInitPath = initPath ? (0, import_node_path.resolve)(process.cwd(), initPath) : void 0;
+  const lines = [
+    "// Auto-generated by @web-ts-toolkit/express-runtime CLI \u2014 do not edit.",
+    `import { createServerlessHandler } from '@web-ts-toolkit/express-runtime';`,
+    `import app from ${JSON.stringify(absAppPath)};`
+  ];
+  if (absInitPath) {
+    lines.push(`import init from ${JSON.stringify(absInitPath)};`);
+    lines.push(`const handler = createServerlessHandler(app, { init });`);
+  } else {
+    lines.push(`const handler = createServerlessHandler(app);`);
+  }
+  lines.push(`export { handler };`);
+  return lines.join("\n") + "\n";
+}
+function generateRuntimeEntry(appPath, initPath) {
+  const absAppPath = (0, import_node_path.resolve)(process.cwd(), appPath);
+  const absInitPath = initPath ? (0, import_node_path.resolve)(process.cwd(), initPath) : void 0;
+  const lines = [
+    "// Auto-generated by @web-ts-toolkit/express-runtime CLI \u2014 do not edit.",
+    `import app from ${JSON.stringify(absAppPath)};`,
+    "export default app;",
+    "export { app };"
+  ];
+  if (absInitPath) {
+    lines.push(`export { default as init } from ${JSON.stringify(absInitPath)};`);
+  }
+  return lines.join("\n") + "\n";
+}
+async function buildBundleFromEntryContent(args) {
+  const tsupModule = await import("tsup");
+  const { build } = tsupModule;
+  const tempEntryPath = (0, import_node_path.resolve)(process.cwd(), args.tempEntryFilename);
+  (0, import_node_fs.writeFileSync)(tempEntryPath, args.entryContent, "utf8");
+  try {
+    await build({
+      config: false,
+      entry: { [args.outName]: tempEntryPath },
+      format: [args.format],
+      target: args.target,
+      outDir: args.outDir,
+      clean: args.clean,
+      external: ["express", ...args.external],
+      sourcemap: false,
+      dts: false,
+      splitting: false
+    });
+  } finally {
+    (0, import_node_fs.rmSync)(tempEntryPath, { force: true });
+  }
+}
+async function buildRuntime(args) {
+  const { runBuildEntryCommand: runBuildEntryCommand2 } = await Promise.resolve().then(() => (init_cli_api(), cli_api_exports));
+  await runBuildEntryCommand2(args, {
+    generateEntry: generateRuntimeEntry,
+    tempEntryFilename: TEMP_BUILD_ENTRY_FILENAME
+  });
+}
+async function buildServerless(args) {
+  const { runBuildEntryCommand: runBuildEntryCommand2 } = await Promise.resolve().then(() => (init_cli_api(), cli_api_exports));
+  await runBuildEntryCommand2(args, {
+    generateEntry: generateServerlessEntry,
+    tempEntryFilename: TEMP_SERVERLESS_ENTRY_FILENAME
+  });
+}
+function collectBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => resolve(Buffer.concat(chunks)));
+    req.on("error", reject);
+  });
+}
+function toServerlessEvent(method, url, headers, body) {
+  return {
+    httpMethod: method,
+    path: url,
+    headers,
+    body: body.length > 0 ? body : void 0
+  };
+}
+function applyServerlessResult(result, res) {
+  if (result === null || result === void 0) {
+    res.status(200).end();
+    return;
+  }
+  const r = result;
+  if (typeof r.statusCode === "number") {
+    res.status(r.statusCode);
+  }
+  if (r.headers && typeof r.headers === "object") {
+    for (const [key, value] of Object.entries(r.headers)) {
+      if (value !== void 0) {
+        res.setHeader(key, Array.isArray(value) ? value.join(",") : value);
+      }
+    }
+  }
+  if (r.isBase64Encoded && typeof r.body === "string") {
+    res.end(Buffer.from(r.body, "base64"));
+  } else if (typeof r.body === "string") {
+    res.end(r.body);
+  } else {
+    res.end();
+  }
+}
+function createServerlessAdapterApp(handler) {
+  return createExpressApp({
+    json: false,
+    urlencoded: false,
+    finalize: (app) => {
+      app.use(async (req, res) => {
+        const body = await collectBody(req);
+        const event = toServerlessEvent(req.method, req.url, req.headers, body);
+        const result = await handler(event, {});
+        applyServerlessResult(result, res);
+      });
+    },
+    errorHandler: (error, _req, res, _next) => {
+      console.error("Serverless adapter error:", error);
+      res.status(500).end("Internal server error");
+    }
+  });
+}
+async function loadBuiltApp(appPath) {
+  const fullPath = (0, import_node_path.resolve)(process.cwd(), appPath);
+  const moduleUrl = (0, import_node_url.pathToFileURL)(fullPath).href;
+  const mod = await import(moduleUrl);
+  const exported = extractExport(mod);
+  if (!exported) {
+    throw new Error(
+      `Module "${appPath}" must default-export an Express app or export it as "app". Exports: ${Object.keys(mod).join(", ")}`
+    );
+  }
+  const init = mod.init;
+  if (init !== void 0 && typeof init !== "function") {
+    throw new Error(`Module "${appPath}" must export "init" as a function when present.`);
+  }
+  return {
+    app: await resolveExport(exported, appPath),
+    init
+  };
+}
+async function loadHandler(handlerPath) {
+  const fullPath = (0, import_node_path.resolve)(process.cwd(), handlerPath);
+  const moduleUrl = (0, import_node_url.pathToFileURL)(fullPath).href;
+  const mod = await import(moduleUrl);
+  const exported = mod.handler ?? mod.default;
+  if (typeof exported !== "function") {
+    throw new Error(
+      `Module "${handlerPath}" must export a "handler" function. Exports: ${Object.keys(mod).join(", ")}`
+    );
+  }
+  return exported;
+}
+var import_node_url, import_node_path, import_node_fs, import_node_module, import_node_child_process, import_meta, CLI_VERSION, DEFAULT_WATCH_EXTENSIONS, DEFAULT_WATCH_DELAY, moduleRequire, TEMP_BUILD_ENTRY_FILENAME, TEMP_SERVERLESS_ENTRY_FILENAME;
+var init_cli_utils = __esm({
+  "src/cli-utils.ts"() {
+    "use strict";
+    import_node_url = require("url");
+    import_node_path = require("path");
+    import_node_fs = require("fs");
+    import_node_module = require("module");
+    import_node_child_process = require("child_process");
+    init_index();
+    import_meta = {};
+    CLI_VERSION = "0.0.0-PLACEHOLDER";
+    DEFAULT_WATCH_EXTENSIONS = ["ts", "js", "mjs", "cjs", "json"];
+    DEFAULT_WATCH_DELAY = 500;
+    moduleRequire = (0, import_node_module.createRequire)(
+      typeof import_meta !== "undefined" && import_meta.url || (0, import_node_path.resolve)(process.cwd(), "x").replace(/x$/, "")
+    );
+    TEMP_BUILD_ENTRY_FILENAME = ".express-runtime-build-entry.ts";
+    TEMP_SERVERLESS_ENTRY_FILENAME = ".express-runtime-build-serverless-entry.ts";
+  }
+});
+
+// src/cli-api.ts
+var cli_api_exports = {};
+__export(cli_api_exports, {
+  CLI_VERSION: () => CLI_VERSION,
+  applyServerlessResult: () => applyServerlessResult,
+  buildBundleFromEntryContent: () => buildBundleFromEntryContent,
+  buildChildArgs: () => buildChildArgs,
+  buildRuntime: () => buildRuntime,
+  buildServerless: () => buildServerless,
+  createServerlessAdapterApp: () => createServerlessAdapterApp,
+  extractExport: () => extractExport,
+  generateRuntimeEntry: () => generateRuntimeEntry,
+  generateServerlessEntry: () => generateServerlessEntry,
+  isExpressApp: () => isExpressApp,
+  loadApp: () => loadApp,
+  loadBuiltApp: () => loadBuiltApp,
+  loadEnvFiles: () => loadEnvFiles,
+  loadHandler: () => loadHandler,
+  parseArgs: () => parseArgs,
+  parseEnvFile: () => parseEnvFile,
+  preloadModules: () => preloadModules,
+  printHelp: () => printHelp,
+  readValue: () => readValue,
+  resolveExport: () => resolveExport,
+  runBuildEntryCommand: () => runBuildEntryCommand,
+  runCliCommand: () => runCliCommand,
+  runDevCommand: () => runDevCommand,
+  runExpressDevCommand: () => runExpressDevCommand,
+  runWithWatch: () => runWithWatch,
+  toServerlessEvent: () => toServerlessEvent
+});
+module.exports = __toCommonJS(cli_api_exports);
+async function runDevCommand(args, runner) {
+  if (args.watch.length > 0) {
+    (runner.watch ?? runWithWatch)(args);
+    return;
+  }
+  if (args.env.length > 0) {
+    loadEnvFiles(args.env);
+  }
+  await preloadModules(args.require);
+  const loaded = await runner.load(args.appPath);
+  runner.start(loaded, { ...args.options, exitAfterShutdown: true });
+}
+async function runExpressDevCommand(args) {
+  await runDevCommand(args, {
+    load: loadApp,
+    start: (app, options) => {
+      startLocalServer(app, options);
+    }
+  });
+}
+async function runBuildEntryCommand(args, options) {
+  if (options.allowInit === false && args.initPath) {
+    throw new Error(options.initErrorMessage ?? "This build command manages init automatically. Remove --init.");
+  }
+  await buildBundleFromEntryContent({
+    entryContent: options.generateEntry(args.appPath, args.initPath),
+    tempEntryFilename: options.tempEntryFilename,
+    outDir: args.outDir,
+    outName: args.outName,
+    format: args.format,
+    target: args.target,
+    external: args.external,
+    clean: args.clean
+  });
+}
+async function runCliCommand(parsedArgs) {
+  if (parsedArgs.subcommand === "dev") {
+    await runExpressDevCommand(parsedArgs.dev);
+    return;
+  }
+  if (parsedArgs.subcommand === "start") {
+    const { start } = parsedArgs;
+    if (start.env.length > 0) {
+      loadEnvFiles(start.env);
+    }
+    await preloadModules(start.require);
+    const { app, init } = await loadBuiltApp(start.appPath);
+    startLocalServer(app, {
+      ...start.options,
+      init: init ? async () => {
+        await init();
+      } : void 0,
+      exitAfterShutdown: true
+    });
+    return;
+  }
+  if (parsedArgs.subcommand === "build") {
+    await buildRuntime(parsedArgs.build);
+    return;
+  }
+  if (parsedArgs.subcommand === "start-serverless") {
+    const { startServerless } = parsedArgs;
+    if (startServerless.env.length > 0) {
+      loadEnvFiles(startServerless.env);
+    }
+    await preloadModules(startServerless.require);
+    const handler = await loadHandler(startServerless.handlerPath);
+    const app = createServerlessAdapterApp(handler);
+    startLocalServer(app, { ...startServerless.options, exitAfterShutdown: true });
+    return;
+  }
+  await buildServerless(parsedArgs.buildServerless);
+}
+var init_cli_api = __esm({
+  "src/cli-api.ts"() {
+    init_index();
+    init_cli_utils();
+  }
+});
+init_cli_api();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CLI_VERSION,
+  applyServerlessResult,
+  buildBundleFromEntryContent,
+  buildChildArgs,
+  buildRuntime,
+  buildServerless,
+  createServerlessAdapterApp,
+  extractExport,
+  generateRuntimeEntry,
+  generateServerlessEntry,
+  isExpressApp,
+  loadApp,
+  loadBuiltApp,
+  loadEnvFiles,
+  loadHandler,
+  parseArgs,
+  parseEnvFile,
+  preloadModules,
+  printHelp,
+  readValue,
+  resolveExport,
+  runBuildEntryCommand,
+  runCliCommand,
+  runDevCommand,
+  runExpressDevCommand,
+  runWithWatch,
+  toServerlessEvent
+});