@web-ts-toolkit/express-runtime 0.40.1 → 0.41.0

package/chunk-UPFG3S34.mjs

@@ -0,0 +1,1494 @@
+import {
+  MAX_INTEGER_OPTION_VALUE,
+  createExpressApp,
+  parsePortValue,
+  validateFiniteInteger
+} from "./chunk-VPFBKM2K.mjs";
+
+// src/cli-utils.ts
+import { pathToFileURL } from "url";
+import {
+  dirname,
+  resolve as pathResolve,
+  extname,
+  join as pathJoin,
+  normalize as pathNormalize,
+  parse as pathParse,
+  sep as pathSep
+} from "path";
+import {
+  writeFileSync,
+  rmSync,
+  readFileSync,
+  existsSync,
+  realpathSync,
+  watch,
+  mkdtempSync,
+  lstatSync,
+  chmodSync
+} from "fs";
+import { createRequire } from "module";
+import { fork } from "child_process";
+import { validateHeaderName, validateHeaderValue } from "http";
+function readPackageVersion(candidatePath) {
+  try {
+    const manifest = JSON.parse(readFileSync(candidatePath, "utf8"));
+    return typeof manifest.version === "string" && manifest.version.length > 0 ? manifest.version : void 0;
+  } catch (_error) {
+    void _error;
+    return void 0;
+  }
+}
+function resolveCliVersion(executablePath = process.argv[1]) {
+  let resolvedExecutable;
+  try {
+    resolvedExecutable = executablePath ? realpathSync(executablePath) : void 0;
+  } catch (_error) {
+    void _error;
+  }
+  const executableDir = resolvedExecutable ? dirname(resolvedExecutable) : void 0;
+  const candidates = executableDir ? [pathJoin(executableDir, "package.json"), pathJoin(executableDir, "..", "package.json")] : [];
+  for (const candidate of candidates) {
+    const version = readPackageVersion(candidate);
+    if (version) return version;
+  }
+  return "0.0.0-dev";
+}
+var CLI_VERSION = resolveCliVersion();
+function readValue(argv, index, name) {
+  const value = argv[index + 1];
+  if (value === void 0 || value === "" || value.startsWith("--")) {
+    throw new Error(`Missing value for argument: ${name}`);
+  }
+  return value;
+}
+function readInlineValue(arg, prefix, name) {
+  const value = arg.slice(prefix.length);
+  if (value === "") {
+    throw new Error(`Missing value for argument: ${name}`);
+  }
+  return value;
+}
+function parseIntegerFlag(raw, name, min = 0, max = MAX_INTEGER_OPTION_VALUE) {
+  if (!/^(0|[1-9]\d*)$/.test(raw)) {
+    throw new Error(`Invalid ${name}: ${raw}. Must be a finite integer in ${min}..${max}.`);
+  }
+  return validateFiniteInteger(Number(raw), { name, min, max });
+}
+function parsePortFlag(raw, name = "--port") {
+  try {
+    return parsePortValue(raw, name);
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith(`Invalid ${name}:`)) {
+      throw error;
+    }
+    throw new Error(`Invalid ${name}: ${raw}. Must be a port number in 0..65535 or a named pipe path.`, {
+      cause: error
+    });
+  }
+}
+function parseCsvFlagValue(raw, name) {
+  const values = raw.split(",").map((part) => part.trim()).filter(Boolean);
+  if (values.length === 0) {
+    throw new Error(`Missing value for argument: ${name}`);
+  }
+  return values;
+}
+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)
+  --tsconfig <path>             Tsconfig used by config-aware consumers for TS path resolution
+  --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)
+  --tsconfig <path>             Use a custom tsconfig for bundling
+  --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)
+  --tsconfig <path>             Use a custom tsconfig for bundling
+  --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)
+  --max-body-bytes <bytes>      Max request body bytes for adapter (default: 1048576; 0 disallows bodies)
+  --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/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 one child process running the same CLI without --watch. File changes
+    are serialized into one restart at a time: SIGTERM, SIGKILL after 5000 ms if needed,
+    then respawn after the debounce delay. Shutdown closes owned watchers and signal handlers.
+  - 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>.
+  - The start-serverless adapter buffers at most --max-body-bytes per request (default 1 MiB, 0 = empty bodies only);
+    larger declared Content-Length or chunked bodies receive 413 without invoking the handler.
+  - Use -- before a positional path that starts with a dash, e.g. dev -- --app.js.
+  - Numeric flag values are validated before env/preload/app loading, watching, or binding.
+  - 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";
+}
+var DEFAULT_WATCH_EXTENSIONS = ["ts", "js", "mjs", "cjs", "json"];
+var DEFAULT_WATCH_DELAY = 500;
+function parseRepeatable(argv, index, arg, list) {
+  list.push(...parseCsvFlagValue(readValue(argv, index, arg), arg));
+  return index + 1;
+}
+function addPositional(arg, current, label) {
+  if (current) {
+    throw new Error(`Unexpected positional argument: ${arg}. ${label} already set to ${current}`);
+  }
+  return arg;
+}
+function setTsconfigPath(current, next) {
+  if (current !== void 0 && current !== next) {
+    throw new Error(`Conflicting --tsconfig values: ${current} and ${next}`);
+  }
+  return next;
+}
+function optionArgs(argv) {
+  const terminator = argv.indexOf("--");
+  return terminator === -1 ? argv : argv.slice(0, terminator);
+}
+function parseDevArgs(argv) {
+  const options = {};
+  const requireModules = [];
+  const envFiles = [];
+  const watchPaths = [];
+  let watchExt;
+  let watchDelay;
+  let tsconfigPath;
+  let appPath;
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--") {
+      for (const positional of argv.slice(index + 1)) {
+        appPath = addPositional(positional, appPath, "App module");
+      }
+      break;
+    }
+    if (isHelp(arg) || isVersion(arg)) {
+      continue;
+    }
+    if (arg === "--port") {
+      options.port = parsePortFlag(readValue(argv, index, arg));
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--port=")) {
+      options.port = parsePortFlag(readInlineValue(arg, "--port=", "--port"));
+      continue;
+    }
+    if (arg === "--host") {
+      options.host = readValue(argv, index, arg);
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--host=")) {
+      options.host = readInlineValue(arg, "--host=", "--host");
+      continue;
+    }
+    if (arg === "--no-signals") {
+      options.signals = false;
+      continue;
+    }
+    if (arg === "--shutdown-timeout") {
+      options.shutdownTimeout = parseIntegerFlag(readValue(argv, index, arg), "--shutdown-timeout");
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--shutdown-timeout=")) {
+      options.shutdownTimeout = parseIntegerFlag(
+        readInlineValue(arg, "--shutdown-timeout=", "--shutdown-timeout"),
+        "--shutdown-timeout"
+      );
+      continue;
+    }
+    if (arg === "--require") {
+      index = parseRepeatable(argv, index, arg, requireModules);
+      continue;
+    }
+    if (arg.startsWith("--require=")) {
+      requireModules.push(...parseCsvFlagValue(readInlineValue(arg, "--require=", "--require"), "--require"));
+      continue;
+    }
+    if (arg === "--env") {
+      index = parseRepeatable(argv, index, arg, envFiles);
+      continue;
+    }
+    if (arg.startsWith("--env=")) {
+      envFiles.push(...parseCsvFlagValue(readInlineValue(arg, "--env=", "--env"), "--env"));
+      continue;
+    }
+    if (arg === "--tsconfig") {
+      tsconfigPath = setTsconfigPath(tsconfigPath, readValue(argv, index, arg));
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--tsconfig=")) {
+      tsconfigPath = setTsconfigPath(tsconfigPath, readInlineValue(arg, "--tsconfig=", "--tsconfig"));
+      continue;
+    }
+    if (arg === "--watch") {
+      index = parseRepeatable(argv, index, arg, watchPaths);
+      continue;
+    }
+    if (arg.startsWith("--watch=")) {
+      watchPaths.push(...parseCsvFlagValue(readInlineValue(arg, "--watch=", "--watch"), "--watch"));
+      continue;
+    }
+    if (arg === "--ext") {
+      watchExt = [];
+      index = parseRepeatable(argv, index, arg, watchExt);
+      continue;
+    }
+    if (arg.startsWith("--ext=")) {
+      watchExt = [];
+      watchExt.push(...parseCsvFlagValue(readInlineValue(arg, "--ext=", "--ext"), "--ext"));
+      continue;
+    }
+    if (arg === "--delay") {
+      watchDelay = parseIntegerFlag(readValue(argv, index, arg), "--delay");
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--delay=")) {
+      watchDelay = parseIntegerFlag(readInlineValue(arg, "--delay=", "--delay"), "--delay");
+      continue;
+    }
+    if (!arg.startsWith("--")) {
+      appPath = addPositional(arg, appPath, "App module");
+      continue;
+    }
+    throw new Error(`Unknown argument: ${arg}`);
+  }
+  if (!appPath) {
+    printHelp();
+    throw new Error("Missing required argument: <app-module>");
+  }
+  return {
+    appPath,
+    options,
+    tsconfigPath,
+    require: requireModules,
+    env: envFiles,
+    watch: watchPaths,
+    watchExt: watchExt ?? DEFAULT_WATCH_EXTENSIONS,
+    watchDelay: watchDelay ?? DEFAULT_WATCH_DELAY
+  };
+}
+function parseStartLikeArgs(argv, subcommandName) {
+  for (const arg of optionArgs(argv)) {
+    if (arg === "--watch" || arg.startsWith("--watch=") || arg === "--tsconfig" || arg.startsWith("--tsconfig=") || arg === "--ext" || arg.startsWith("--ext=") || arg === "--delay" || arg.startsWith("--delay=")) {
+      throw new Error(`--watch/--tsconfig/--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) {
+  let maxBodyBytes;
+  const filtered = [];
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === "--") {
+      filtered.push(...argv.slice(i));
+      break;
+    }
+    if (arg === "--max-body-bytes") {
+      maxBodyBytes = parseIntegerFlag(readValue(argv, i, arg), "--max-body-bytes");
+      validateMaxBodyBytes(maxBodyBytes);
+      i += 1;
+      continue;
+    }
+    if (arg.startsWith("--max-body-bytes=")) {
+      maxBodyBytes = parseIntegerFlag(
+        readInlineValue(arg, "--max-body-bytes=", "--max-body-bytes"),
+        "--max-body-bytes"
+      );
+      validateMaxBodyBytes(maxBodyBytes);
+      continue;
+    }
+    filtered.push(arg);
+  }
+  const result = parseStartLikeArgs(filtered, "start-serverless");
+  return {
+    handlerPath: result.appPath,
+    options: result.options,
+    maxBodyBytes,
+    require: result.require,
+    env: result.env
+  };
+}
+function parseBuildArgs(argv, outNameDefault) {
+  let appPath;
+  const external = [];
+  const result = {
+    initPath: void 0,
+    tsconfigPath: 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 === "--") {
+      for (const positional of argv.slice(index + 1)) {
+        appPath = addPositional(positional, appPath, "App module");
+      }
+      break;
+    }
+    if (isHelp(arg) || isVersion(arg)) {
+      continue;
+    }
+    if (arg === "--init") {
+      result.initPath = readValue(argv, index, arg);
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--init=")) {
+      result.initPath = readInlineValue(arg, "--init=", "--init");
+      continue;
+    }
+    if (arg === "--tsconfig") {
+      result.tsconfigPath = setTsconfigPath(result.tsconfigPath, readValue(argv, index, arg));
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--tsconfig=")) {
+      result.tsconfigPath = setTsconfigPath(result.tsconfigPath, readInlineValue(arg, "--tsconfig=", "--tsconfig"));
+      continue;
+    }
+    if (arg === "--out-dir") {
+      result.outDir = readValue(argv, index, arg);
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--out-dir=")) {
+      result.outDir = readInlineValue(arg, "--out-dir=", "--out-dir");
+      continue;
+    }
+    if (arg === "--out-name") {
+      result.outName = readValue(argv, index, arg);
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--out-name=")) {
+      result.outName = readInlineValue(arg, "--out-name=", "--out-name");
+      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 = readInlineValue(arg, "--format=", "--format");
+      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 = readInlineValue(arg, "--target=", "--target");
+      continue;
+    }
+    if (arg === "--external") {
+      external.push(readValue(argv, index, arg));
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--external=")) {
+      external.push(readInlineValue(arg, "--external=", "--external"));
+      continue;
+    }
+    if (arg === "--no-clean") {
+      result.clean = false;
+      continue;
+    }
+    if (!arg.startsWith("--")) {
+      appPath = addPositional(arg, appPath, "App module");
+      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;
+  }
+  const globalArgs = optionArgs(argv);
+  if (globalArgs.some((a) => isHelp(a))) {
+    printHelp();
+    return null;
+  }
+  if (globalArgs.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 = pathResolve(process.cwd(), appPath);
+  const moduleUrl = 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 = pathResolve(process.cwd(), p);
+    if (!existsSync(absPath)) {
+      throw new Error(`Env file not found: ${p}`);
+    }
+    const content = 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;
+      }
+    }
+  }
+}
+var moduleRequire = createRequire(
+  pathToFileURL(pathResolve(process.cwd(), "__wtt_runtime_preload__.js"))
+);
+async function preloadModules(modules) {
+  for (const mod of modules) {
+    moduleRequire(mod);
+  }
+}
+var DEFAULT_WATCH_KILL_TIMEOUT_MS = 5e3;
+function toDiagnosticMessage(prefix, error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return `${prefix}: ${message}`;
+}
+function createWatchSupervisor(args, deps = {}) {
+  const forkImpl = deps.fork ?? fork;
+  const watchImpl = deps.watch ?? watch;
+  const existsSyncImpl = deps.existsSync ?? existsSync;
+  const logger = deps.logger ?? console;
+  const setTimeoutImpl = deps.setTimeout ?? setTimeout;
+  const clearTimeoutImpl = deps.clearTimeout ?? clearTimeout;
+  const killTimeoutMs = deps.killTimeoutMs ?? DEFAULT_WATCH_KILL_TIMEOUT_MS;
+  const cliPath = process.argv[1];
+  const childArgv = buildChildArgs(args);
+  let child = null;
+  let restartTimer = null;
+  let killTimer = null;
+  let isShuttingDown = false;
+  let shutdownPromise = null;
+  let restartInFlight = null;
+  let terminatingChild = null;
+  let failureHandled = false;
+  const restartDelay = args.watchDelay;
+  const watchers = [];
+  const clearRestartTimer = () => {
+    if (restartTimer) {
+      clearTimeoutImpl(restartTimer);
+      restartTimer = null;
+    }
+  };
+  const clearKillTimer = () => {
+    if (killTimer) {
+      clearTimeoutImpl(killTimer);
+      killTimer = null;
+    }
+  };
+  const closeWatchers = () => {
+    for (const watcher of watchers.splice(0)) {
+      try {
+        watcher.close();
+      } catch (_error) {
+        void _error;
+      }
+    }
+  };
+  const completeWithExit = async (code) => {
+    await shutdown();
+    deps.exit?.(code);
+  };
+  const fail = (message, code = 1) => {
+    if (failureHandled) return;
+    failureHandled = true;
+    logger.error(message);
+    void completeWithExit(code).catch(() => {
+      deps.exit?.(code);
+    });
+  };
+  const spawnChild = () => {
+    if (isShuttingDown) return;
+    let nextChild;
+    try {
+      nextChild = forkImpl(cliPath, childArgv, { stdio: "inherit" });
+    } catch (error) {
+      fail(toDiagnosticMessage("Watch child failed to spawn", error));
+      return;
+    }
+    child = nextChild;
+    nextChild.once("error", (error) => {
+      if (child === nextChild) {
+        child = null;
+      }
+      fail(toDiagnosticMessage("Watch child process error", error));
+    });
+    nextChild.once("exit", (code, signal) => {
+      if (child === nextChild) {
+        child = null;
+      }
+      if (terminatingChild === nextChild || isShuttingDown || failureHandled) {
+        return;
+      }
+      const exitCode = typeof code === "number" && code > 0 ? code : 1;
+      fail(`Watch child exited unexpectedly${signal ? ` from ${signal}` : ` with code ${String(code)}`}`, exitCode);
+    });
+  };
+  const killChild = async (target = child) => {
+    if (!target || !target.pid) {
+      if (target && child === target) child = null;
+      return;
+    }
+    terminatingChild = target;
+    await new Promise((resolve, reject) => {
+      let settled = false;
+      const settle = (error) => {
+        if (settled) return;
+        settled = true;
+        clearKillTimer();
+        target.removeListener("exit", onExit);
+        target.removeListener("error", onError);
+        if (child === target) child = null;
+        if (terminatingChild === target) terminatingChild = null;
+        if (error) reject(error);
+        else resolve();
+      };
+      const onExit = () => settle();
+      const onError = (error) => settle(error);
+      target.once("exit", onExit);
+      target.once("error", onError);
+      try {
+        const signaled = target.kill("SIGTERM");
+        if (!signaled) {
+          throw new Error('child.kill("SIGTERM") returned false');
+        }
+      } catch (error) {
+        settle(error instanceof Error ? error : new Error(String(error)));
+        return;
+      }
+      if (!settled) {
+        killTimer = setTimeoutImpl(() => {
+          try {
+            const signaled = target.kill("SIGKILL");
+            if (!signaled) {
+              settle(new Error('child.kill("SIGKILL") returned false'));
+            }
+          } catch (error) {
+            settle(error instanceof Error ? error : new Error(String(error)));
+          }
+        }, killTimeoutMs);
+      }
+    });
+  };
+  const restart = async () => {
+    if (isShuttingDown) return;
+    if (restartInFlight) {
+      await restartInFlight;
+      return;
+    }
+    restartInFlight = (async () => {
+      if (isShuttingDown) return;
+      await killChild();
+      if (isShuttingDown) return;
+      spawnChild();
+    })();
+    try {
+      await restartInFlight;
+    } finally {
+      restartInFlight = null;
+    }
+  };
+  const debouncedRestart = () => {
+    if (isShuttingDown) return;
+    clearRestartTimer();
+    restartTimer = setTimeoutImpl(() => {
+      restartTimer = null;
+      void restart().catch((error) => {
+        fail(toDiagnosticMessage("Watch restart failed", error));
+      });
+    }, restartDelay);
+  };
+  for (const watchPath of args.watch) {
+    const absPath = pathResolve(process.cwd(), watchPath);
+    if (!existsSyncImpl(absPath)) {
+      throw new Error(`Watch path not found: ${watchPath}`);
+    }
+  }
+  const shutdown = async () => {
+    if (shutdownPromise) return shutdownPromise;
+    isShuttingDown = true;
+    clearRestartTimer();
+    closeWatchers();
+    shutdownPromise = (async () => {
+      const activeRestart = restartInFlight;
+      if (activeRestart) {
+        await activeRestart.catch(() => void 0);
+      }
+      const activeChild = child;
+      if (activeChild) {
+        await killChild(activeChild).catch((error) => {
+          if (!failureHandled) {
+            fail(toDiagnosticMessage("Watch child termination failed", error));
+          }
+        });
+      }
+    })();
+    return shutdownPromise;
+  };
+  try {
+    for (const watchPath of args.watch) {
+      const absPath = pathResolve(process.cwd(), watchPath);
+      const watchListener = (_eventType, filename) => {
+        if (isShuttingDown) return;
+        if (!filename) return;
+        const ext = extname(filename).slice(1).toLowerCase();
+        if (args.watchExt.includes(ext)) {
+          debouncedRestart();
+        }
+      };
+      let watcher;
+      try {
+        watcher = watchImpl(absPath, { recursive: true }, watchListener);
+      } catch (error) {
+        if (error.code !== "ERR_FEATURE_UNAVAILABLE_ON_PLATFORM") {
+          throw error;
+        }
+        watcher = watchImpl(absPath, watchListener);
+      }
+      watcher.on?.(
+        "error",
+        (error) => {
+          fail(toDiagnosticMessage("Watch path runtime error", error));
+        }
+      );
+      watchers.push(watcher);
+    }
+    spawnChild();
+  } catch (error) {
+    clearRestartTimer();
+    closeWatchers();
+    if (child) {
+      void killChild(child).catch(() => void 0);
+    }
+    throw error;
+  }
+  return {
+    shutdown,
+    getChild: () => child,
+    getWatchers: () => [...watchers],
+    isShuttingDown: () => isShuttingDown
+  };
+}
+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));
+  if (args.tsconfigPath !== void 0) result.push("--tsconfig", args.tsconfigPath);
+  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, deps = {}) {
+  const usingInjectedDeps = Object.keys(deps).length > 0;
+  const installSignalHandlers = deps.installSignalHandlers ?? !usingInjectedDeps;
+  const exitImpl = deps.exit ?? (usingInjectedDeps ? void 0 : (code) => process.exit(code));
+  const controller = createWatchSupervisor(args, {
+    ...deps,
+    exit: exitImpl
+  });
+  let shutdownStarted = false;
+  const ownedHandlers = [];
+  const removeOwnedHandlers = () => {
+    for (const [signal, handler] of ownedHandlers.splice(0)) {
+      process.removeListener(signal, handler);
+    }
+  };
+  const shutdown = async () => {
+    removeOwnedHandlers();
+    await controller.shutdown();
+  };
+  const wrappedController = {
+    shutdown,
+    getChild: controller.getChild,
+    getWatchers: controller.getWatchers,
+    isShuttingDown: controller.isShuttingDown
+  };
+  if (installSignalHandlers) {
+    const shutdownAndExit = () => {
+      if (shutdownStarted) return;
+      shutdownStarted = true;
+      void shutdown().then(() => exitImpl?.(0));
+    };
+    ownedHandlers.push(["SIGINT", shutdownAndExit], ["SIGTERM", shutdownAndExit]);
+    process.on("SIGINT", shutdownAndExit);
+    process.on("SIGTERM", shutdownAndExit);
+  }
+  return wrappedController;
+}
+var TEMP_BUILD_ENTRY_FILENAME = ".express-runtime-build-entry.ts";
+var TEMP_SERVERLESS_ENTRY_FILENAME = ".express-runtime-build-serverless-entry.ts";
+var STAGING_DIR_PREFIX = ".wtt-build-";
+function generateServerlessEntry(appPath, initPath) {
+  const absAppPath = pathResolve(process.cwd(), appPath);
+  const absInitPath = initPath ? pathResolve(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 = pathResolve(process.cwd(), appPath);
+  const absInitPath = initPath ? pathResolve(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";
+}
+function validateOutDirForClean(outDir, clean, appPath, initPath) {
+  if (!clean) return;
+  const cwd = process.cwd();
+  const outAbs = pathResolve(cwd, outDir);
+  const normalized = pathNormalize(outAbs);
+  const root = pathParse(normalized).root;
+  if (normalized === root) {
+    throw new Error(`Refusing to clean filesystem root: ${outDir} resolves to ${normalized}`);
+  }
+  if (normalized === pathNormalize(cwd)) {
+    throw new Error(`Refusing to clean project directory: ${outDir} resolves to cwd ${cwd}`);
+  }
+  if (cwd !== root && (cwd === normalized || cwd.startsWith(normalized + pathSep))) {
+    throw new Error(
+      `Refusing to clean ancestor of project directory: ${outDir} resolves to ${normalized} which contains cwd ${cwd}`
+    );
+  }
+  try {
+    if (existsSync(outAbs)) {
+      const st = lstatSync(outAbs);
+      if (st.isSymbolicLink()) {
+        throw new Error(`Refusing to clean symlinked outDir: ${outDir} resolves to symlink ${outAbs}`);
+      }
+    }
+  } catch (e) {
+    if (e.message.startsWith("Refusing to clean")) throw e;
+  }
+  const checkOverlap = (inputPath, label) => {
+    if (!inputPath) return;
+    const inputAbs = pathResolve(cwd, inputPath);
+    const inputNorm = pathNormalize(inputAbs);
+    if (inputNorm === normalized) {
+      throw new Error(`Refusing to clean outDir that is the same as ${label}: ${outDir} == ${inputPath}`);
+    }
+    if (inputNorm.startsWith(normalized + pathSep)) {
+      throw new Error(`Refusing to clean outDir that contains ${label}: ${outDir} contains ${inputPath}`);
+    }
+  };
+  checkOverlap(appPath, "appPath");
+  checkOverlap(initPath, "initPath");
+}
+function createUniqueStagingDir() {
+  const cwd = process.cwd();
+  const prefix = pathJoin(cwd, STAGING_DIR_PREFIX);
+  const dir = mkdtempSync(prefix);
+  try {
+    const st = lstatSync(dir);
+    if (st.isSymbolicLink()) {
+      rmSync(dir, { recursive: true, force: true });
+      throw new Error(`Staging directory is a symlink: ${dir}`);
+    }
+  } catch (e) {
+    if (e.message.includes("Staging directory is a symlink")) throw e;
+    throw e;
+  }
+  try {
+    chmodSync(dir, 448);
+  } catch {
+  }
+  return dir;
+}
+function writeStagingEntry(dir, content) {
+  const entryPath = pathJoin(dir, "entry.ts");
+  try {
+    if (existsSync(entryPath)) {
+      const st = lstatSync(entryPath);
+      if (st.isSymbolicLink()) {
+        throw new Error(`Refusing to overwrite symlink at staging path: ${entryPath}`);
+      }
+      throw new Error(`Staging file already exists: ${entryPath}`);
+    }
+  } catch (e) {
+    if (e.message.startsWith("Refusing to") || e.message.startsWith("Staging file already exists"))
+      throw e;
+  }
+  writeFileSync(entryPath, content, { encoding: "utf8", flag: "wx", mode: 384 });
+  try {
+    const st = lstatSync(entryPath);
+    if (st.isSymbolicLink()) {
+      rmSync(entryPath, { force: true });
+      throw new Error(`Staging file is a symlink after write: ${entryPath}`);
+    }
+  } catch (e) {
+    if (e.message.includes("Staging file is a symlink")) throw e;
+  }
+  return entryPath;
+}
+async function buildBundleFromEntryContent(args) {
+  validateOutDirForClean(args.outDir, args.clean);
+  const tsupModule = await import("tsup");
+  const { build } = tsupModule;
+  const stagingDir = createUniqueStagingDir();
+  const tempEntryPath = writeStagingEntry(stagingDir, args.entryContent);
+  const absOutDir = pathResolve(process.cwd(), args.outDir);
+  try {
+    await build({
+      config: false,
+      entry: { [args.outName]: tempEntryPath },
+      tsconfig: args.tsconfigPath,
+      format: [args.format],
+      target: args.target,
+      outDir: absOutDir,
+      clean: args.clean,
+      external: ["express", "@web-ts-toolkit/express-runtime", ...args.external],
+      sourcemap: false,
+      dts: false,
+      splitting: false
+    });
+  } finally {
+    rmSync(stagingDir, { recursive: true, force: true });
+  }
+}
+async function buildRuntime(args) {
+  const { runBuildEntryCommand } = await import("./cli-api.mjs");
+  await runBuildEntryCommand(args, {
+    generateEntry: generateRuntimeEntry
+  });
+}
+async function buildServerless(args) {
+  const { runBuildEntryCommand } = await import("./cli-api.mjs");
+  await runBuildEntryCommand(args, {
+    generateEntry: generateServerlessEntry
+  });
+}
+var DEFAULT_ADAPTER_MAX_BODY_BYTES = 1024 * 1024;
+function validateMaxBodyBytes(value) {
+  try {
+    return validateFiniteInteger(value, { name: "--max-body-bytes", min: 0, max: MAX_INTEGER_OPTION_VALUE });
+  } catch (_error) {
+    void _error;
+    throw new Error(
+      `Invalid --max-body-bytes: ${String(value)}. Must be a finite integer in 0..${MAX_INTEGER_OPTION_VALUE}. Use 0 to disallow bodies (empty bodies only).`,
+      { cause: _error }
+    );
+  }
+}
+function collectBody(req, maxBytes) {
+  validateMaxBodyBytes(maxBytes);
+  return new Promise((resolve, reject) => {
+    const rawLength = req.headers["content-length"];
+    if (rawLength !== void 0) {
+      const raw = Array.isArray(rawLength) ? rawLength[0] : rawLength;
+      const parsed = Number(raw);
+      if (Number.isFinite(parsed) && Number.isInteger(parsed) && parsed >= 0) {
+        if (parsed > maxBytes) {
+          try {
+            req.resume?.();
+          } catch (_e) {
+            void _e;
+          }
+          const err = new Error(
+            `Request body too large: Content-Length ${parsed} exceeds limit ${maxBytes}`
+          );
+          err.code = "LIMIT_EXCEEDED";
+          err.statusCode = 413;
+          reject(err);
+          return;
+        }
+      }
+    }
+    const chunks = [];
+    let total = 0;
+    let finished = false;
+    const cleanup = () => {
+      req.removeListener("data", onData);
+      req.removeListener("end", onEnd);
+      req.removeListener("error", onError);
+      req.removeListener("close", onClose);
+      try {
+        req.removeListener?.(
+          "aborted",
+          onClose
+        );
+      } catch (_e) {
+        void _e;
+      }
+    };
+    const fail = (err) => {
+      if (finished) return;
+      finished = true;
+      cleanup();
+      if (err.code === "LIMIT_EXCEEDED") {
+        try {
+          req.resume?.();
+        } catch (_e) {
+          void _e;
+        }
+      }
+      reject(err);
+    };
+    const onData = (chunk) => {
+      if (finished) return;
+      const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      total += buf.length;
+      if (total > maxBytes) {
+        const err = new Error(
+          `Request body too large: received ${total} bytes exceeds limit ${maxBytes}`
+        );
+        err.code = "LIMIT_EXCEEDED";
+        err.statusCode = 413;
+        fail(err);
+        return;
+      }
+      chunks.push(buf);
+    };
+    const onEnd = () => {
+      if (finished) return;
+      finished = true;
+      cleanup();
+      try {
+        resolve(Buffer.concat(chunks, total));
+      } catch (e) {
+        fail(e);
+      }
+    };
+    const onError = (err) => {
+      const e = err;
+      if (!e.code) e.code = "STREAM_ERROR";
+      fail(e);
+    };
+    const onClose = () => {
+      if (finished) return;
+      const e = new Error("Request aborted by client");
+      e.code = "CLIENT_ABORT";
+      fail(e);
+    };
+    req.on("data", onData);
+    req.on("end", onEnd);
+    req.on("error", onError);
+    req.on("close", onClose);
+    try {
+      req.on?.("aborted", onClose);
+    } catch (_e) {
+      void _e;
+    }
+  });
+}
+function toServerlessEvent(method, url, headers, body) {
+  const parsedUrl = new URL(url, "http://localhost");
+  const { queryStringParameters, multiValueQueryStringParameters } = parseAwsRestQuery(parsedUrl.search);
+  const { singleValueHeaders, multiValueHeaders } = normalizeAwsRestHeaders(headers);
+  return {
+    httpMethod: method,
+    path: parsedUrl.pathname,
+    headers: singleValueHeaders,
+    multiValueHeaders,
+    queryStringParameters,
+    multiValueQueryStringParameters,
+    body: body.length > 0 ? body.toString("base64") : "",
+    isBase64Encoded: body.length > 0,
+    requestContext: {
+      identity: {
+        // Minimal field required by serverless-http's AWS v1 request adapter.
+        sourceIp: ""
+      }
+    }
+  };
+}
+function parseAwsRestQuery(search) {
+  if (search === "" || search === "?") {
+    return { queryStringParameters: null, multiValueQueryStringParameters: null };
+  }
+  const single = {};
+  const multi = {};
+  const query = search.startsWith("?") ? search.slice(1) : search;
+  for (const pair of query.split("&")) {
+    if (pair === "") continue;
+    const separator = pair.indexOf("=");
+    const rawKey = separator === -1 ? pair : pair.slice(0, separator);
+    const rawValue = separator === -1 ? "" : pair.slice(separator + 1);
+    const key = decodeQueryComponent(rawKey);
+    const value = decodeQueryComponent(rawValue);
+    single[key] = value;
+    (multi[key] ??= []).push(value);
+  }
+  return {
+    queryStringParameters: Object.keys(single).length > 0 ? single : null,
+    multiValueQueryStringParameters: Object.keys(multi).length > 0 ? multi : null
+  };
+}
+function decodeQueryComponent(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch (_error) {
+    void _error;
+    return value;
+  }
+}
+function normalizeAwsRestHeaders(headers) {
+  const singleValueHeaders = {};
+  const multiValueHeaders = {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (value === void 0) continue;
+    const values = Array.isArray(value) ? value.map(String) : [String(value)];
+    multiValueHeaders[key] = values;
+    singleValueHeaders[key] = values.join(", ");
+  }
+  return { singleValueHeaders, multiValueHeaders };
+}
+function applyServerlessResult(result, res) {
+  const response = validateServerlessResult(result);
+  res.status(response.statusCode);
+  for (const [key, value] of Object.entries(response.headers)) {
+    res.setHeader(key, value);
+  }
+  for (const [key, values] of Object.entries(response.multiValueHeaders)) {
+    if (key.toLowerCase() === "set-cookie") {
+      res.setHeader(key, values);
+    } else {
+      res.setHeader(key, values.join(","));
+    }
+  }
+  if (response.isBase64Encoded) {
+    res.end(response.decodedBody);
+  } else {
+    res.end(response.body);
+  }
+}
+function validateServerlessResult(result) {
+  if (!isPlainRecord(result)) {
+    throw new Error(
+      "Invalid serverless result: expected an object with an optional statusCode, headers, multiValueHeaders, body, and isBase64Encoded."
+    );
+  }
+  const rawStatus = result.statusCode;
+  if (rawStatus !== void 0 && (typeof rawStatus !== "number" || !Number.isInteger(rawStatus) || rawStatus < 100 || rawStatus > 599)) {
+    throw new Error(`Invalid serverless result statusCode: ${String(rawStatus)}. Expected an integer in 100..599.`);
+  }
+  const rawIsBase64Encoded = result.isBase64Encoded;
+  if (rawIsBase64Encoded !== void 0 && typeof rawIsBase64Encoded !== "boolean") {
+    throw new Error("Invalid serverless result isBase64Encoded: expected a boolean when provided.");
+  }
+  const rawBody = result.body;
+  if (rawBody !== void 0 && typeof rawBody !== "string") {
+    throw new Error(`Invalid serverless result body: expected a string when provided, received ${typeof rawBody}.`);
+  }
+  const headers = validateSingleValueHeaders(result.headers, "headers");
+  const multiValueHeaders = validateMultiValueHeaders(result.multiValueHeaders, "multiValueHeaders");
+  const multiHeaderKeys = new Set(Object.keys(multiValueHeaders).map((key) => key.toLowerCase()));
+  for (const key of Object.keys(headers)) {
+    if (multiHeaderKeys.has(key.toLowerCase())) {
+      delete headers[key];
+    }
+  }
+  const isBase64Encoded = rawIsBase64Encoded ?? false;
+  const body = rawBody ?? "";
+  let decodedBody;
+  if (isBase64Encoded) {
+    if (!isValidBase64(body)) {
+      throw new Error("Invalid serverless result body: isBase64Encoded is true but body is not valid standard base64.");
+    }
+    decodedBody = Buffer.from(body, "base64");
+  }
+  return {
+    statusCode: rawStatus ?? 200,
+    headers,
+    multiValueHeaders,
+    body,
+    decodedBody,
+    isBase64Encoded
+  };
+}
+function validateSingleValueHeaders(value, name) {
+  if (value === void 0) return {};
+  if (!isPlainRecord(value)) {
+    throw new Error(`Invalid serverless result ${name}: expected an object of string header values.`);
+  }
+  const headers = {};
+  for (const [key, headerValue] of Object.entries(value)) {
+    if (headerValue === void 0) continue;
+    if (typeof headerValue !== "string") {
+      throw new Error(`Invalid serverless result ${name}.${key}: expected a string header value.`);
+    }
+    validateServerlessHeader(key, headerValue, `${name}.${key}`);
+    headers[key] = headerValue;
+  }
+  return headers;
+}
+function validateMultiValueHeaders(value, name) {
+  if (value === void 0) return {};
+  if (!isPlainRecord(value)) {
+    throw new Error(`Invalid serverless result ${name}: expected an object of string-array header values.`);
+  }
+  const headers = {};
+  for (const [key, headerValue] of Object.entries(value)) {
+    if (headerValue === void 0) continue;
+    if (!Array.isArray(headerValue) || headerValue.some((entry) => typeof entry !== "string")) {
+      throw new Error(`Invalid serverless result ${name}.${key}: expected an array of string header values.`);
+    }
+    for (const entry of headerValue) {
+      validateServerlessHeader(key, entry, `${name}.${key}`);
+    }
+    headers[key] = headerValue;
+  }
+  return headers;
+}
+function validateServerlessHeader(key, value, label) {
+  try {
+    validateHeaderName(key);
+    validateHeaderValue(key, value);
+  } catch (error) {
+    throw new Error(`Invalid serverless result header ${label}: ${error.message}`, { cause: error });
+  }
+}
+function isValidBase64(value) {
+  if (value === "") return true;
+  if (value.length % 4 !== 0) return false;
+  return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value);
+}
+function isPlainRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function createServerlessAdapterApp(handler, options = {}) {
+  const maxBytes = options.maxBodyBytes ?? DEFAULT_ADAPTER_MAX_BODY_BYTES;
+  validateMaxBodyBytes(maxBytes);
+  return createExpressApp({
+    json: false,
+    urlencoded: false,
+    finalize: (app) => {
+      app.use(async (req, res) => {
+        let body;
+        try {
+          body = await collectBody(req, maxBytes);
+        } catch (err) {
+          const e = err;
+          if (e?.code === "LIMIT_EXCEEDED" || e?.statusCode === 413) {
+            if (!res.headersSent && !res.writableEnded) {
+              res.status(413).end("Payload Too Large");
+            } else {
+              try {
+                res.end();
+              } catch (_e) {
+                void _e;
+              }
+            }
+            return;
+          }
+          if (e?.code === "CLIENT_ABORT") {
+            return;
+          }
+          console.error("Serverless adapter error:", e);
+          if (!res.headersSent && !res.writableEnded) {
+            res.status(500).end("Internal server error");
+          } else {
+            try {
+              res.end();
+            } catch (_e) {
+              void _e;
+            }
+          }
+          return;
+        }
+        let result;
+        try {
+          const event = toServerlessEvent(req.method, req.url, req.headers, body);
+          result = await handler(event, {});
+        } catch (e) {
+          console.error("Serverless adapter error:", e);
+          if (!res.headersSent && !res.writableEnded) res.status(500).end("Internal server error");
+          return;
+        }
+        try {
+          applyServerlessResult(result, res);
+        } catch (e) {
+          console.error("Invalid serverless handler result:", e);
+          if (!res.headersSent && !res.writableEnded) res.status(500).end("Internal server error");
+        }
+      });
+    },
+    errorHandler: (error, _req, res, _next) => {
+      console.error("Serverless adapter error:", error);
+      res.status(500).end("Internal server error");
+    }
+  });
+}
+async function loadBuiltApp(appPath) {
+  const fullPath = pathResolve(process.cwd(), appPath);
+  const moduleUrl = pathToFileURL(fullPath).href;
+  const mod = await import(moduleUrl);
+  const exported = mod.app ?? mod.default;
+  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.`);
+  }
+  const shutdown = mod.shutdown;
+  if (shutdown !== void 0 && typeof shutdown !== "function") {
+    throw new Error(`Module "${appPath}" must export "shutdown" as a function when present.`);
+  }
+  return {
+    app: await resolveExport(exported, appPath),
+    init,
+    shutdown
+  };
+}
+async function loadHandler(handlerPath) {
+  const fullPath = pathResolve(process.cwd(), handlerPath);
+  const moduleUrl = 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;
+}
+
+export {
+  resolveCliVersion,
+  CLI_VERSION,
+  readValue,
+  printHelp,
+  parseArgs,
+  isExpressApp,
+  extractExport,
+  resolveExport,
+  loadApp,
+  parseEnvFile,
+  loadEnvFiles,
+  preloadModules,
+  DEFAULT_WATCH_KILL_TIMEOUT_MS,
+  createWatchSupervisor,
+  buildChildArgs,
+  runWithWatch,
+  TEMP_BUILD_ENTRY_FILENAME,
+  TEMP_SERVERLESS_ENTRY_FILENAME,
+  generateServerlessEntry,
+  generateRuntimeEntry,
+  validateOutDirForClean,
+  buildBundleFromEntryContent,
+  buildRuntime,
+  buildServerless,
+  DEFAULT_ADAPTER_MAX_BODY_BYTES,
+  validateMaxBodyBytes,
+  collectBody,
+  toServerlessEvent,
+  applyServerlessResult,
+  createServerlessAdapterApp,
+  loadBuiltApp,
+  loadHandler
+};