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

package/cli-api.mjs

@@ -1,768 +1,37 @@
 import {
-  createExpressApp,
+  CLI_VERSION,
+  DEFAULT_ADAPTER_MAX_BODY_BYTES,
+  TEMP_BUILD_ENTRY_FILENAME,
+  TEMP_SERVERLESS_ENTRY_FILENAME,
+  applyServerlessResult,
+  buildBundleFromEntryContent,
+  buildChildArgs,
+  buildRuntime,
+  buildServerless,
+  collectBody,
+  createServerlessAdapterApp,
+  extractExport,
+  generateRuntimeEntry,
+  generateServerlessEntry,
+  isExpressApp,
+  loadApp,
+  loadBuiltApp,
+  loadEnvFiles,
+  loadHandler,
+  parseArgs,
+  parseEnvFile,
+  preloadModules,
+  printHelp,
+  readValue,
+  resolveExport,
+  runWithWatch,
+  toServerlessEvent,
+  validateMaxBodyBytes,
+  validateOutDirForClean
+} from "./chunk-UPFG3S34.mjs";
+import {
   startLocalServer
-} from "./chunk-SOW7OLVN.mjs";
-
-// src/cli-utils.ts
-import { pathToFileURL } from "url";
-import { resolve as pathResolve, extname } from "path";
-import { writeFileSync, rmSync, readFileSync, existsSync, watch } from "fs";
-import { createRequire } from "module";
-import { fork } from "child_process";
-var CLI_VERSION = "0.0.0-PLACEHOLDER";
-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)
-  --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)
-  --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";
-}
-var DEFAULT_WATCH_EXTENSIONS = ["ts", "js", "mjs", "cjs", "json"];
-var DEFAULT_WATCH_DELAY = 500;
-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 tsconfigPath;
-  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 === "--tsconfig") {
-      tsconfigPath = readValue(argv, index, arg);
-      index += 1;
-      continue;
-    }
-    if (arg.startsWith("--tsconfig=")) {
-      tsconfigPath = arg.slice("--tsconfig=".length);
-      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,
-    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 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) {
-  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,
-    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 === "--") {
-      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 === "--tsconfig") {
-      result.tsconfigPath = readValue(argv, index, arg);
-      index += 1;
-      continue;
-    }
-    if (arg.startsWith("--tsconfig=")) {
-      result.tsconfigPath = arg.slice("--tsconfig=".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 = 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);
-  }
-}
-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) {
-  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 = 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 = pathResolve(process.cwd(), watchPath);
-    if (!existsSync(absPath)) {
-      throw new Error(`Watch path not found: ${watchPath}`);
-    }
-    watch(absPath, { recursive: true }, (_eventType, filename) => {
-      if (!filename) return;
-      const ext = 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();
-}
-var TEMP_BUILD_ENTRY_FILENAME = ".express-runtime-build-entry.ts";
-var TEMP_SERVERLESS_ENTRY_FILENAME = ".express-runtime-build-serverless-entry.ts";
-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";
-}
-async function buildBundleFromEntryContent(args) {
-  const tsupModule = await import("tsup");
-  const { build } = tsupModule;
-  const tempEntryPath = pathResolve(process.cwd(), args.tempEntryFilename);
-  writeFileSync(tempEntryPath, args.entryContent, "utf8");
-  try {
-    await build({
-      config: false,
-      entry: { [args.outName]: tempEntryPath },
-      tsconfig: args.tsconfigPath,
-      format: [args.format],
-      target: args.target,
-      outDir: args.outDir,
-      clean: args.clean,
-      external: ["express", ...args.external],
-      sourcemap: false,
-      dts: false,
-      splitting: false
-    });
-  } finally {
-    rmSync(tempEntryPath, { force: true });
-  }
-}
-async function buildRuntime(args) {
-  const { runBuildEntryCommand: runBuildEntryCommand2 } = await import("./cli-api.mjs");
-  await runBuildEntryCommand2(args, {
-    generateEntry: generateRuntimeEntry,
-    tempEntryFilename: TEMP_BUILD_ENTRY_FILENAME
-  });
-}
-async function buildServerless(args) {
-  const { runBuildEntryCommand: runBuildEntryCommand2 } = await import("./cli-api.mjs");
-  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) {
-        if (Array.isArray(value) && key.toLowerCase() === "set-cookie") {
-          res.setHeader(key, value);
-        } else {
-          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 = 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 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 = 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;
-}
+} from "./chunk-VPFBKM2K.mjs";
 
 // src/cli-api.ts
 async function runDevCommand(args, runner) {
@@ -775,7 +44,8 @@ async function runDevCommand(args, runner) {
   }
   await preloadModules(args.require);
   const loaded = await runner.load(args.appPath);
-  runner.start(loaded, { ...args.options, exitAfterShutdown: true });
+  const server = runner.start(loaded, { ...args.options, exitAfterShutdown: true });
+  await server?.ready;
 }
 async function runExpressDevCommand(args) {
   await runDevCommand(args, {
@@ -789,9 +59,10 @@ async function runBuildEntryCommand(args, options) {
   if (options.allowInit === false && args.initPath) {
     throw new Error(options.initErrorMessage ?? "This build command manages init automatically. Remove --init.");
   }
+  const { validateOutDirForClean: validateOutDirForClean2 } = await import("./cli-utils-4POUMJN7.mjs");
+  validateOutDirForClean2(args.outDir, args.clean, args.appPath, args.initPath);
   await buildBundleFromEntryContent({
     entryContent: options.generateEntry(args.appPath, args.initPath),
-    tempEntryFilename: options.tempEntryFilename,
     tsconfigPath: args.tsconfigPath,
     outDir: args.outDir,
     outName: args.outName,
@@ -812,14 +83,17 @@ async function runCliCommand(parsedArgs) {
       loadEnvFiles(start.env);
     }
     await preloadModules(start.require);
-    const { app, init } = await loadBuiltApp(start.appPath);
-    startLocalServer(app, {
+    const { app, init, shutdown } = await loadBuiltApp(start.appPath);
+    await startLocalServer(app, {
       ...start.options,
       init: init ? async () => {
         await init();
       } : void 0,
+      onShutdown: shutdown ? async () => {
+        await shutdown();
+      } : void 0,
       exitAfterShutdown: true
-    });
+    }).ready;
     return;
   }
   if (parsedArgs.subcommand === "build") {
@@ -833,19 +107,23 @@ async function runCliCommand(parsedArgs) {
     }
     await preloadModules(startServerless.require);
     const handler = await loadHandler(startServerless.handlerPath);
-    const app = createServerlessAdapterApp(handler);
-    startLocalServer(app, { ...startServerless.options, exitAfterShutdown: true });
+    const app = createServerlessAdapterApp(handler, { maxBodyBytes: startServerless.maxBodyBytes });
+    await startLocalServer(app, { ...startServerless.options, exitAfterShutdown: true }).ready;
     return;
   }
   await buildServerless(parsedArgs.buildServerless);
 }
 export {
   CLI_VERSION,
+  DEFAULT_ADAPTER_MAX_BODY_BYTES,
+  TEMP_BUILD_ENTRY_FILENAME,
+  TEMP_SERVERLESS_ENTRY_FILENAME,
   applyServerlessResult,
   buildBundleFromEntryContent,
   buildChildArgs,
   buildRuntime,
   buildServerless,
+  collectBody,
   createServerlessAdapterApp,
   extractExport,
   generateRuntimeEntry,
@@ -866,5 +144,7 @@ export {
   runDevCommand,
   runExpressDevCommand,
   runWithWatch,
-  toServerlessEvent
+  toServerlessEvent,
+  validateMaxBodyBytes,
+  validateOutDirForClean
 };