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

package/cli-api.js

@@ -30,6 +30,45 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/numeric-validation.ts
+function validateFiniteInteger(value, options) {
+  const min = options.min ?? Number.MIN_SAFE_INTEGER;
+  const max = options.max ?? MAX_INTEGER_OPTION_VALUE;
+  if (typeof value !== "number" || !Number.isFinite(value) || !Number.isInteger(value) || value < min || value > max) {
+    throw new Error(`Invalid ${options.name}: ${String(value)}. Must be a finite integer in ${min}..${max}.`);
+  }
+  return value;
+}
+function parsePortValue(value, name) {
+  if (typeof value === "number") {
+    return validateFiniteInteger(value, { name, min: 0, max: 65535 });
+  }
+  if (value.trim() === "") {
+    throw new Error(
+      `Invalid ${name}: ${JSON.stringify(value)}. Must be a port number in 0..65535 or a named pipe path.`
+    );
+  }
+  if (value.trim() !== value) {
+    throw new Error(
+      `Invalid ${name}: ${JSON.stringify(value)}. Numeric ports must not contain surrounding whitespace.`
+    );
+  }
+  if (/^(0|[1-9]\d*)$/.test(value)) {
+    return validateFiniteInteger(Number(value), { name, min: 0, max: 65535 });
+  }
+  if (/^[+-]?(?:\d+|\d*\.\d+)(?:e[+-]?\d+)?$/i.test(value) || /^[+-]?(?:infinity|nan)$/i.test(value)) {
+    throw new Error(`Invalid ${name}: ${value}. Numeric ports must be canonical decimal integers in 0..65535.`);
+  }
+  return value;
+}
+var MAX_INTEGER_OPTION_VALUE;
+var init_numeric_validation = __esm({
+  "src/numeric-validation.ts"() {
+    "use strict";
+    MAX_INTEGER_OPTION_VALUE = Number.MAX_SAFE_INTEGER;
+  }
+});
+
 // src/index.ts
 function applySettings(app, options) {
   if (options.disablePoweredBy !== false) {
@@ -54,8 +93,15 @@ function applyRouters(app, options) {
     app.use(path, mount.handler);
   }
 }
+function createDefaultErrorHandler(logger) {
+  return (error, _req, _res, next) => {
+    logger.error("Unhandled Express error:", error);
+    next(error);
+  };
+}
 function createExpressApp(options = {}) {
   const app = (0, import_express.default)();
+  const logger = options.logger ?? defaultLogger;
   applySettings(app, options);
   applyMiddlewareList(app, options.preMiddleware);
   if (options.json !== false) {
@@ -72,10 +118,12 @@ function createExpressApp(options = {}) {
   }
   if (options.errorHandler) {
     app.use(options.errorHandler);
+  } else {
+    app.use(createDefaultErrorHandler(logger));
   }
   return app;
 }
-function normalizePort(val) {
+function normalizePort(val, name = "port") {
   if (val === void 0 || val === "") {
     const envPort = process.env.PORT;
     if (envPort === void 0 || envPort === "") {
@@ -83,17 +131,7 @@ function normalizePort(val) {
     }
     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;
+  return parsePortValue(val, name);
 }
 function defaultOnError(error, port, logger) {
   if (error.syscall !== "listen") {
@@ -114,54 +152,217 @@ 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 shutdownTimeout = validateFiniteInteger(options.shutdownTimeout ?? DEFAULT_SHUTDOWN_TIMEOUT, {
+    name: "shutdownTimeout",
+    min: 0,
+    max: MAX_INTEGER_OPTION_VALUE
+  });
   const server = import_node_http.default.createServer(app);
   app.set("port", port);
-  const onError = (error) => {
+  let state = "initializing";
+  let shutdownPromise = null;
+  let readySettled = false;
+  let readyResolve;
+  let readyReject;
+  const ready = new Promise((resolve, reject) => {
+    readyResolve = () => {
+      if (!readySettled) {
+        readySettled = true;
+        resolve();
+      }
+    };
+    readyReject = (err) => {
+      if (!readySettled) {
+        readySettled = true;
+        reject(err);
+      }
+    };
+  });
+  ready.catch(() => {
+  });
+  const ownedSignalHandlers = /* @__PURE__ */ new Map();
+  const cleanupSignalHandlers = () => {
+    for (const [sig, handler] of ownedSignalHandlers.entries()) {
+      process.removeListener(sig, handler);
+    }
+    ownedSignalHandlers.clear();
+  };
+  const handleListenError = (error) => {
+    if (state === "stopping" || state === "stopped" || state === "failed") {
+      logger.error("Server error after terminal state:", error);
+      return;
+    }
+    if (state === "initializing") {
+      state = "failed";
+      cleanupSignalHandlers();
+      readyReject(error);
+      if (options.onError) {
+        try {
+          options.onError(error);
+        } catch (e) {
+          logger.error(e);
+        }
+      } else {
+        try {
+          defaultOnError(error, port, logger);
+        } catch (e) {
+          logger.error(e);
+        }
+      }
+      try {
+        server.close();
+      } catch (_err) {
+        void _err;
+      }
+      return;
+    }
     if (options.onError) {
-      options.onError(error);
+      try {
+        options.onError(error);
+      } catch (e) {
+        logger.error(e);
+      }
     } else {
-      defaultOnError(error, port, logger);
+      try {
+        defaultOnError(error, port, logger);
+      } catch (e) {
+        logger.error(e);
+      }
     }
   };
   const onListening = () => {
+    if (state === "stopping" || state === "stopped" || state === "failed") {
+      try {
+        server.close();
+      } catch (_err) {
+        void _err;
+      }
+      return;
+    }
+    state = "listening";
     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?.();
+    const actualPort = typeof addr === "object" && addr !== null ? addr.port : port;
+    if (typeof addr === "object" && addr !== null) {
+      logger.log(`Server running at http://${host}:${actualPort}/ (${bind})`);
+    } else if (typeof addr === "string") {
+      logger.log(`Server running at pipe ${addr} (${bind})`);
+    } else {
+      logger.log(`Server running at http://${host}:${port}/ (${bind})`);
+    }
+    try {
+      options.onListening?.();
+    } catch (e) {
+      logger.error("onListening hook failed:", e);
+    }
+    readyResolve();
   };
-  server.on("error", onError);
+  const handleClose = () => {
+    if (state === "stopping") {
+      return;
+    }
+    if (state === "listening") {
+      state = "stopped";
+      cleanupSignalHandlers();
+      return;
+    }
+    if (state === "initializing" && !readySettled) {
+      state = "stopped";
+      cleanupSignalHandlers();
+      readyReject(new Error("Server closed before listening"));
+      return;
+    }
+    if (state === "initializing") {
+      state = "stopped";
+      cleanupSignalHandlers();
+    }
+  };
+  server.on("error", handleListenError);
   server.on("listening", onListening);
-  const shutdown = async () => {
+  server.on("close", handleClose);
+  const doShutdown = async () => {
+    if (state === "stopping" || state === "stopped") {
+      return;
+    }
+    if (state === "failed") {
+      state = "stopped";
+      cleanupSignalHandlers();
+      return;
+    }
+    state = "stopping";
+    if (!readySettled) {
+      readyReject(new Error("Server shutdown before listening"));
+    }
+    cleanupSignalHandlers();
     logger.log("Shutting down...");
+    await new Promise((resolve) => {
+      if (!server.listening) {
+        resolve();
+        return;
+      }
+      let settled = false;
+      const done = () => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        resolve();
+      };
+      const timer = setTimeout(() => {
+        try {
+          server.closeAllConnections?.();
+        } catch (_err) {
+          void _err;
+        }
+        done();
+      }, shutdownTimeout);
+      timer.unref?.();
+      try {
+        server.close((err) => {
+          if (err) {
+            logger.error("Server close error:", err);
+          }
+          done();
+        });
+      } catch (err) {
+        logger.error("Server close error:", err);
+        done();
+      }
+    });
+    let shutdownError;
     try {
       if (options.onShutdown) {
         await options.onShutdown();
       }
     } catch (err) {
       logger.error("onShutdown hook failed:", err);
+      shutdownError = 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 (shutdownError) {
+      state = "failed";
+      if (options.exitAfterShutdown) {
+        process.exit(1);
+      }
+      throw shutdownError;
+    }
+    state = "stopped";
     if (options.exitAfterShutdown) {
       process.exit(0);
     }
   };
+  const shutdown = () => {
+    if (shutdownPromise) return shutdownPromise;
+    shutdownPromise = doShutdown();
+    return shutdownPromise;
+  };
   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 handler = () => {
+        void shutdown().catch(() => {
+        });
+      };
+      ownedSignalHandlers.set(sig, handler);
+      process.once(sig, handler);
     }
   }
   const start = async () => {
@@ -169,19 +370,44 @@ function startLocalServer(app, options = {}) {
       if (options.init) {
         await options.init();
       }
+      if (state === "stopping" || state === "stopped" || state === "failed") {
+        return;
+      }
       if (typeof port === "number") {
         server.listen(port, host);
       } else {
         server.listen(port);
       }
     } catch (err) {
-      server.emit("error", err);
+      if (state === "stopping" || state === "stopped") {
+        logger.error("Init failed after shutdown started:", err);
+        return;
+      }
+      state = "failed";
+      cleanupSignalHandlers();
+      const error = err;
+      readyReject(error);
+      if (options.onError) {
+        try {
+          options.onError(error);
+        } catch (e) {
+          logger.error(e);
+        }
+      } else {
+        logger.error("Init failed:", error);
+      }
+      try {
+        server.close();
+      } catch (_err) {
+        void _err;
+      }
     }
   };
   void start();
   return {
     server,
-    shutdown
+    shutdown,
+    ready
   };
 }
 var import_node_http, import_express, import_serverless_http, defaultLogger, DEFAULT_SIGNALS, DEFAULT_SHUTDOWN_TIMEOUT;
@@ -191,6 +417,7 @@ var init_index = __esm({
     import_node_http = __toESM(require("http"));
     import_express = __toESM(require("express"));
     import_serverless_http = __toESM(require("serverless-http"));
+    init_numeric_validation();
     defaultLogger = {
       log: (...args) => console.log(...args),
       error: (...args) => console.error(...args),
@@ -202,13 +429,104 @@ var init_index = __esm({
 });
 
 // src/cli-utils.ts
+var cli_utils_exports = {};
+__export(cli_utils_exports, {
+  CLI_VERSION: () => CLI_VERSION,
+  DEFAULT_ADAPTER_MAX_BODY_BYTES: () => DEFAULT_ADAPTER_MAX_BODY_BYTES,
+  DEFAULT_WATCH_KILL_TIMEOUT_MS: () => DEFAULT_WATCH_KILL_TIMEOUT_MS,
+  TEMP_BUILD_ENTRY_FILENAME: () => TEMP_BUILD_ENTRY_FILENAME,
+  TEMP_SERVERLESS_ENTRY_FILENAME: () => TEMP_SERVERLESS_ENTRY_FILENAME,
+  applyServerlessResult: () => applyServerlessResult,
+  buildBundleFromEntryContent: () => buildBundleFromEntryContent,
+  buildChildArgs: () => buildChildArgs,
+  buildRuntime: () => buildRuntime,
+  buildServerless: () => buildServerless,
+  collectBody: () => collectBody,
+  createServerlessAdapterApp: () => createServerlessAdapterApp,
+  createWatchSupervisor: () => createWatchSupervisor,
+  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,
+  resolveCliVersion: () => resolveCliVersion,
+  resolveExport: () => resolveExport,
+  runWithWatch: () => runWithWatch,
+  toServerlessEvent: () => toServerlessEvent,
+  validateMaxBodyBytes: () => validateMaxBodyBytes,
+  validateOutDirForClean: () => validateOutDirForClean
+});
+function readPackageVersion(candidatePath) {
+  try {
+    const manifest = JSON.parse((0, import_node_fs.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 ? (0, import_node_fs.realpathSync)(executablePath) : void 0;
+  } catch (_error) {
+    void _error;
+  }
+  const executableDir = resolvedExecutable ? (0, import_node_path.dirname)(resolvedExecutable) : void 0;
+  const candidates = executableDir ? [(0, import_node_path.join)(executableDir, "package.json"), (0, import_node_path.join)(executableDir, "..", "package.json")] : [];
+  for (const candidate of candidates) {
+    const version = readPackageVersion(candidate);
+    if (version) return version;
+  }
+  return "0.0.0-dev";
+}
 function readValue(argv, index, name) {
   const value = argv[index + 1];
-  if (value === void 0 || value.startsWith("--")) {
+  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
 
@@ -270,6 +588,7 @@ Start-serverless options:
   --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)
 
@@ -291,17 +610,22 @@ Examples:
 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
+      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 a child process running the same CLI without --watch. On file change,
-    the child is killed (SIGTERM) and respawned after the debounce delay.
+  - --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.
 `);
 }
@@ -315,13 +639,25 @@ 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);
-  }
+  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 = [];
@@ -334,22 +670,21 @@ function parseDevArgs(argv) {
   for (let index = 0; index < argv.length; index += 1) {
     const arg = argv[index];
     if (arg === "--") {
-      continue;
+      for (const positional of argv.slice(index + 1)) {
+        appPath = addPositional(positional, appPath, "App module");
+      }
+      break;
     }
     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;
+      options.port = parsePortFlag(readValue(argv, index, arg));
       index += 1;
       continue;
     }
     if (arg.startsWith("--port=")) {
-      const port = arg.slice("--port=".length);
-      const portNum = Number(port);
-      options.port = Number.isNaN(portNum) ? port : portNum;
+      options.port = parsePortFlag(readInlineValue(arg, "--port=", "--port"));
       continue;
     }
     if (arg === "--host") {
@@ -358,7 +693,7 @@ function parseDevArgs(argv) {
       continue;
     }
     if (arg.startsWith("--host=")) {
-      options.host = arg.slice("--host=".length);
+      options.host = readInlineValue(arg, "--host=", "--host");
       continue;
     }
     if (arg === "--no-signals") {
@@ -366,12 +701,15 @@ function parseDevArgs(argv) {
       continue;
     }
     if (arg === "--shutdown-timeout") {
-      options.shutdownTimeout = Number(readValue(argv, index, arg));
+      options.shutdownTimeout = parseIntegerFlag(readValue(argv, index, arg), "--shutdown-timeout");
       index += 1;
       continue;
     }
     if (arg.startsWith("--shutdown-timeout=")) {
-      options.shutdownTimeout = Number(arg.slice("--shutdown-timeout=".length));
+      options.shutdownTimeout = parseIntegerFlag(
+        readInlineValue(arg, "--shutdown-timeout=", "--shutdown-timeout"),
+        "--shutdown-timeout"
+      );
       continue;
     }
     if (arg === "--require") {
@@ -379,10 +717,7 @@ function parseDevArgs(argv) {
       continue;
     }
     if (arg.startsWith("--require=")) {
-      for (const part of arg.slice("--require=".length).split(",")) {
-        const trimmed = part.trim();
-        if (trimmed) requireModules.push(trimmed);
-      }
+      requireModules.push(...parseCsvFlagValue(readInlineValue(arg, "--require=", "--require"), "--require"));
       continue;
     }
     if (arg === "--env") {
@@ -390,19 +725,16 @@ function parseDevArgs(argv) {
       continue;
     }
     if (arg.startsWith("--env=")) {
-      for (const part of arg.slice("--env=".length).split(",")) {
-        const trimmed = part.trim();
-        if (trimmed) envFiles.push(trimmed);
-      }
+      envFiles.push(...parseCsvFlagValue(readInlineValue(arg, "--env=", "--env"), "--env"));
       continue;
     }
     if (arg === "--tsconfig") {
-      tsconfigPath = readValue(argv, index, arg);
+      tsconfigPath = setTsconfigPath(tsconfigPath, readValue(argv, index, arg));
       index += 1;
       continue;
     }
     if (arg.startsWith("--tsconfig=")) {
-      tsconfigPath = arg.slice("--tsconfig=".length);
+      tsconfigPath = setTsconfigPath(tsconfigPath, readInlineValue(arg, "--tsconfig=", "--tsconfig"));
       continue;
     }
     if (arg === "--watch") {
@@ -410,10 +742,7 @@ function parseDevArgs(argv) {
       continue;
     }
     if (arg.startsWith("--watch=")) {
-      for (const part of arg.slice("--watch=".length).split(",")) {
-        const trimmed = part.trim();
-        if (trimmed) watchPaths.push(trimmed);
-      }
+      watchPaths.push(...parseCsvFlagValue(readInlineValue(arg, "--watch=", "--watch"), "--watch"));
       continue;
     }
     if (arg === "--ext") {
@@ -423,26 +752,20 @@ function parseDevArgs(argv) {
     }
     if (arg.startsWith("--ext=")) {
       watchExt = [];
-      for (const part of arg.slice("--ext=".length).split(",")) {
-        const trimmed = part.trim();
-        if (trimmed) watchExt.push(trimmed);
-      }
+      watchExt.push(...parseCsvFlagValue(readInlineValue(arg, "--ext=", "--ext"), "--ext"));
       continue;
     }
     if (arg === "--delay") {
-      watchDelay = Number(readValue(argv, index, arg));
+      watchDelay = parseIntegerFlag(readValue(argv, index, arg), "--delay");
       index += 1;
       continue;
     }
     if (arg.startsWith("--delay=")) {
-      watchDelay = Number(arg.slice("--delay=".length));
+      watchDelay = parseIntegerFlag(readInlineValue(arg, "--delay=", "--delay"), "--delay");
       continue;
     }
     if (!arg.startsWith("--")) {
-      if (appPath) {
-        throw new Error(`Unexpected positional argument: ${arg}. App module already set to ${appPath}`);
-      }
-      appPath = arg;
+      appPath = addPositional(arg, appPath, "App module");
       continue;
     }
     throw new Error(`Unknown argument: ${arg}`);
@@ -463,7 +786,7 @@ function parseDevArgs(argv) {
   };
 }
 function parseStartLikeArgs(argv, subcommandName) {
-  for (const arg of argv) {
+  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`);
     }
@@ -480,10 +803,35 @@ function parseStartArgs(argv) {
   };
 }
 function parseStartServerlessArgs(argv) {
-  const result = parseStartLikeArgs(argv, "start-serverless");
+  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
   };
@@ -504,7 +852,10 @@ function parseBuildArgs(argv, outNameDefault) {
   for (let index = 0; index < argv.length; index += 1) {
     const arg = argv[index];
     if (arg === "--") {
-      continue;
+      for (const positional of argv.slice(index + 1)) {
+        appPath = addPositional(positional, appPath, "App module");
+      }
+      break;
     }
     if (isHelp(arg) || isVersion(arg)) {
       continue;
@@ -515,16 +866,16 @@ function parseBuildArgs(argv, outNameDefault) {
       continue;
     }
     if (arg.startsWith("--init=")) {
-      result.initPath = arg.slice("--init=".length);
+      result.initPath = readInlineValue(arg, "--init=", "--init");
       continue;
     }
     if (arg === "--tsconfig") {
-      result.tsconfigPath = readValue(argv, index, arg);
+      result.tsconfigPath = setTsconfigPath(result.tsconfigPath, readValue(argv, index, arg));
       index += 1;
       continue;
     }
     if (arg.startsWith("--tsconfig=")) {
-      result.tsconfigPath = arg.slice("--tsconfig=".length);
+      result.tsconfigPath = setTsconfigPath(result.tsconfigPath, readInlineValue(arg, "--tsconfig=", "--tsconfig"));
       continue;
     }
     if (arg === "--out-dir") {
@@ -533,7 +884,7 @@ function parseBuildArgs(argv, outNameDefault) {
       continue;
     }
     if (arg.startsWith("--out-dir=")) {
-      result.outDir = arg.slice("--out-dir=".length);
+      result.outDir = readInlineValue(arg, "--out-dir=", "--out-dir");
       continue;
     }
     if (arg === "--out-name") {
@@ -542,7 +893,7 @@ function parseBuildArgs(argv, outNameDefault) {
       continue;
     }
     if (arg.startsWith("--out-name=")) {
-      result.outName = arg.slice("--out-name=".length);
+      result.outName = readInlineValue(arg, "--out-name=", "--out-name");
       continue;
     }
     if (arg === "--format") {
@@ -555,7 +906,7 @@ function parseBuildArgs(argv, outNameDefault) {
       continue;
     }
     if (arg.startsWith("--format=")) {
-      const fmt = arg.slice("--format=".length);
+      const fmt = readInlineValue(arg, "--format=", "--format");
       if (fmt !== "cjs" && fmt !== "esm") {
         throw new Error(`Invalid --format: ${fmt}. Must be 'cjs' or 'esm'.`);
       }
@@ -568,7 +919,7 @@ function parseBuildArgs(argv, outNameDefault) {
       continue;
     }
     if (arg.startsWith("--target=")) {
-      result.target = arg.slice("--target=".length);
+      result.target = readInlineValue(arg, "--target=", "--target");
       continue;
     }
     if (arg === "--external") {
@@ -577,7 +928,7 @@ function parseBuildArgs(argv, outNameDefault) {
       continue;
     }
     if (arg.startsWith("--external=")) {
-      external.push(arg.slice("--external=".length));
+      external.push(readInlineValue(arg, "--external=", "--external"));
       continue;
     }
     if (arg === "--no-clean") {
@@ -585,10 +936,7 @@ function parseBuildArgs(argv, outNameDefault) {
       continue;
     }
     if (!arg.startsWith("--")) {
-      if (appPath) {
-        throw new Error(`Unexpected positional argument: ${arg}. App module already set to ${appPath}`);
-      }
-      appPath = arg;
+      appPath = addPositional(arg, appPath, "App module");
       continue;
     }
     throw new Error(`Unknown argument: ${arg}`);
@@ -610,11 +958,12 @@ function parseArgs(argv) {
     printHelp();
     return null;
   }
-  if (argv.some((a) => isHelp(a))) {
+  const globalArgs = optionArgs(argv);
+  if (globalArgs.some((a) => isHelp(a))) {
     printHelp();
     return null;
   }
-  if (argv.some((a) => isVersion(a))) {
+  if (globalArgs.some((a) => isVersion(a))) {
     console.log(CLI_VERSION);
     return null;
   }
@@ -712,80 +1061,283 @@ async function preloadModules(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 toDiagnosticMessage(prefix, error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return `${prefix}: ${message}`;
 }
-function runWithWatch(args) {
+function createWatchSupervisor(args, deps = {}) {
+  const forkImpl = deps.fork ?? import_node_child_process.fork;
+  const watchImpl = deps.watch ?? import_node_fs.watch;
+  const existsSyncImpl = deps.existsSync ?? import_node_fs.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 = () => {
-    child = (0, import_node_child_process.fork)(cliPath, childArgv, { stdio: "inherit" });
-    child.on("exit", (code) => {
-      child = null;
-      if (!isShuttingDown && code !== null && code !== 0) {
+    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 = () => {
-    return new Promise((resolve) => {
-      if (!child || !child.pid) {
-        resolve();
+  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;
       }
-      child.once("exit", () => resolve());
-      child.kill("SIGTERM");
+      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 () => {
-    await killChild();
-    spawnChild();
+    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 (restartTimer) clearTimeout(restartTimer);
-    restartTimer = setTimeout(() => {
+    if (isShuttingDown) return;
+    clearRestartTimer();
+    restartTimer = setTimeoutImpl(() => {
       restartTimer = null;
-      void restart();
+      void restart().catch((error) => {
+        fail(toDiagnosticMessage("Watch restart failed", error));
+      });
     }, restartDelay);
   };
   for (const watchPath of args.watch) {
     const absPath = (0, import_node_path.resolve)(process.cwd(), watchPath);
-    if (!(0, import_node_fs.existsSync)(absPath)) {
+    if (!existsSyncImpl(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 = () => {
+  const shutdown = async () => {
+    if (shutdownPromise) return shutdownPromise;
     isShuttingDown = true;
-    if (restartTimer) clearTimeout(restartTimer);
-    if (child && child.pid) {
-      child.once("exit", () => process.exit(0));
-      child.kill("SIGTERM");
-    } else {
-      process.exit(0);
+    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 = (0, import_node_path.resolve)(process.cwd(), watchPath);
+      const watchListener = (_eventType, filename) => {
+        if (isShuttingDown) return;
+        if (!filename) return;
+        const ext = (0, import_node_path.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
   };
-  process.on("SIGINT", shutdown);
-  process.on("SIGTERM", shutdown);
-  spawnChild();
+}
+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;
 }
 function generateServerlessEntry(appPath, initPath) {
   const absAppPath = (0, import_node_path.resolve)(process.cwd(), appPath);
@@ -818,11 +1370,100 @@ function generateRuntimeEntry(appPath, initPath) {
   }
   return lines.join("\n") + "\n";
 }
+function validateOutDirForClean(outDir, clean, appPath, initPath) {
+  if (!clean) return;
+  const cwd = process.cwd();
+  const outAbs = (0, import_node_path.resolve)(cwd, outDir);
+  const normalized = (0, import_node_path.normalize)(outAbs);
+  const root = (0, import_node_path.parse)(normalized).root;
+  if (normalized === root) {
+    throw new Error(`Refusing to clean filesystem root: ${outDir} resolves to ${normalized}`);
+  }
+  if (normalized === (0, import_node_path.normalize)(cwd)) {
+    throw new Error(`Refusing to clean project directory: ${outDir} resolves to cwd ${cwd}`);
+  }
+  if (cwd !== root && (cwd === normalized || cwd.startsWith(normalized + import_node_path.sep))) {
+    throw new Error(
+      `Refusing to clean ancestor of project directory: ${outDir} resolves to ${normalized} which contains cwd ${cwd}`
+    );
+  }
+  try {
+    if ((0, import_node_fs.existsSync)(outAbs)) {
+      const st = (0, import_node_fs.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 = (0, import_node_path.resolve)(cwd, inputPath);
+    const inputNorm = (0, import_node_path.normalize)(inputAbs);
+    if (inputNorm === normalized) {
+      throw new Error(`Refusing to clean outDir that is the same as ${label}: ${outDir} == ${inputPath}`);
+    }
+    if (inputNorm.startsWith(normalized + import_node_path.sep)) {
+      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 = (0, import_node_path.join)(cwd, STAGING_DIR_PREFIX);
+  const dir = (0, import_node_fs.mkdtempSync)(prefix);
+  try {
+    const st = (0, import_node_fs.lstatSync)(dir);
+    if (st.isSymbolicLink()) {
+      (0, import_node_fs.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 {
+    (0, import_node_fs.chmodSync)(dir, 448);
+  } catch {
+  }
+  return dir;
+}
+function writeStagingEntry(dir, content) {
+  const entryPath = (0, import_node_path.join)(dir, "entry.ts");
+  try {
+    if ((0, import_node_fs.existsSync)(entryPath)) {
+      const st = (0, import_node_fs.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;
+  }
+  (0, import_node_fs.writeFileSync)(entryPath, content, { encoding: "utf8", flag: "wx", mode: 384 });
+  try {
+    const st = (0, import_node_fs.lstatSync)(entryPath);
+    if (st.isSymbolicLink()) {
+      (0, import_node_fs.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 tempEntryPath = (0, import_node_path.resolve)(process.cwd(), args.tempEntryFilename);
-  (0, import_node_fs.writeFileSync)(tempEntryPath, args.entryContent, "utf8");
+  const stagingDir = createUniqueStagingDir();
+  const tempEntryPath = writeStagingEntry(stagingDir, args.entryContent);
+  const absOutDir = (0, import_node_path.resolve)(process.cwd(), args.outDir);
   try {
     await build({
       config: false,
@@ -830,85 +1471,371 @@ async function buildBundleFromEntryContent(args) {
       tsconfig: args.tsconfigPath,
       format: [args.format],
       target: args.target,
-      outDir: args.outDir,
+      outDir: absOutDir,
       clean: args.clean,
-      external: ["express", ...args.external],
+      external: ["express", "@web-ts-toolkit/express-runtime", ...args.external],
       sourcemap: false,
       dts: false,
       splitting: false
     });
   } finally {
-    (0, import_node_fs.rmSync)(tempEntryPath, { force: true });
+    (0, import_node_fs.rmSync)(stagingDir, { recursive: true, 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
+    generateEntry: generateRuntimeEntry
   });
 }
 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
+    generateEntry: generateServerlessEntry
   });
 }
-function collectBody(req) {
+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 = [];
-    req.on("data", (chunk) => chunks.push(chunk));
-    req.on("end", () => resolve(Buffer.concat(chunks)));
-    req.on("error", reject);
+    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: url,
-    headers,
-    body: body.length > 0 ? body : void 0
+    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) {
-  if (result === null || result === void 0) {
-    res.status(200).end();
-    return;
+  const response = validateServerlessResult(result);
+  res.status(response.statusCode);
+  for (const [key, value] of Object.entries(response.headers)) {
+    res.setHeader(key, value);
   }
-  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);
-        }
-      }
+  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 (r.isBase64Encoded && typeof r.body === "string") {
-    res.end(Buffer.from(r.body, "base64"));
-  } else if (typeof r.body === "string") {
-    res.end(r.body);
+  if (response.isBase64Encoded) {
+    res.end(response.decodedBody);
   } else {
-    res.end();
+    res.end(response.body);
   }
 }
-function createServerlessAdapterApp(handler) {
+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 {
+    (0, import_node_http2.validateHeaderName)(key);
+    (0, import_node_http2.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) => {
-        const body = await collectBody(req);
-        const event = toServerlessEvent(req.method, req.url, req.headers, body);
-        const result = await handler(event, {});
-        applyServerlessResult(result, 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) => {
@@ -921,7 +1848,7 @@ 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);
+  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(", ")}`
@@ -931,9 +1858,14 @@ async function loadBuiltApp(appPath) {
   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
+    init,
+    shutdown
   };
 }
 async function loadHandler(handlerPath) {
@@ -948,7 +1880,7 @@ async function loadHandler(handlerPath) {
   }
   return exported;
 }
-var import_node_url, import_node_path, import_node_fs, import_node_module, import_node_child_process, CLI_VERSION, DEFAULT_WATCH_EXTENSIONS, DEFAULT_WATCH_DELAY, moduleRequire, TEMP_BUILD_ENTRY_FILENAME, TEMP_SERVERLESS_ENTRY_FILENAME;
+var import_node_url, import_node_path, import_node_fs, import_node_module, import_node_child_process, import_node_http2, CLI_VERSION, DEFAULT_WATCH_EXTENSIONS, DEFAULT_WATCH_DELAY, moduleRequire, DEFAULT_WATCH_KILL_TIMEOUT_MS, TEMP_BUILD_ENTRY_FILENAME, TEMP_SERVERLESS_ENTRY_FILENAME, STAGING_DIR_PREFIX, DEFAULT_ADAPTER_MAX_BODY_BYTES;
 var init_cli_utils = __esm({
   "src/cli-utils.ts"() {
     "use strict";
@@ -957,15 +1889,20 @@ var init_cli_utils = __esm({
     import_node_fs = require("fs");
     import_node_module = require("module");
     import_node_child_process = require("child_process");
+    import_node_http2 = require("http");
     init_index();
-    CLI_VERSION = "0.0.0-PLACEHOLDER";
+    init_numeric_validation();
+    CLI_VERSION = resolveCliVersion();
     DEFAULT_WATCH_EXTENSIONS = ["ts", "js", "mjs", "cjs", "json"];
     DEFAULT_WATCH_DELAY = 500;
     moduleRequire = (0, import_node_module.createRequire)(
       (0, import_node_url.pathToFileURL)((0, import_node_path.resolve)(process.cwd(), "__wtt_runtime_preload__.js"))
     );
+    DEFAULT_WATCH_KILL_TIMEOUT_MS = 5e3;
     TEMP_BUILD_ENTRY_FILENAME = ".express-runtime-build-entry.ts";
     TEMP_SERVERLESS_ENTRY_FILENAME = ".express-runtime-build-serverless-entry.ts";
+    STAGING_DIR_PREFIX = ".wtt-build-";
+    DEFAULT_ADAPTER_MAX_BODY_BYTES = 1024 * 1024;
   }
 });
 
@@ -973,11 +1910,15 @@ var init_cli_utils = __esm({
 var cli_api_exports = {};
 __export(cli_api_exports, {
   CLI_VERSION: () => CLI_VERSION,
+  DEFAULT_ADAPTER_MAX_BODY_BYTES: () => DEFAULT_ADAPTER_MAX_BODY_BYTES,
+  TEMP_BUILD_ENTRY_FILENAME: () => TEMP_BUILD_ENTRY_FILENAME,
+  TEMP_SERVERLESS_ENTRY_FILENAME: () => TEMP_SERVERLESS_ENTRY_FILENAME,
   applyServerlessResult: () => applyServerlessResult,
   buildBundleFromEntryContent: () => buildBundleFromEntryContent,
   buildChildArgs: () => buildChildArgs,
   buildRuntime: () => buildRuntime,
   buildServerless: () => buildServerless,
+  collectBody: () => collectBody,
   createServerlessAdapterApp: () => createServerlessAdapterApp,
   extractExport: () => extractExport,
   generateRuntimeEntry: () => generateRuntimeEntry,
@@ -998,7 +1939,9 @@ __export(cli_api_exports, {
   runDevCommand: () => runDevCommand,
   runExpressDevCommand: () => runExpressDevCommand,
   runWithWatch: () => runWithWatch,
-  toServerlessEvent: () => toServerlessEvent
+  toServerlessEvent: () => toServerlessEvent,
+  validateMaxBodyBytes: () => validateMaxBodyBytes,
+  validateOutDirForClean: () => validateOutDirForClean
 });
 module.exports = __toCommonJS(cli_api_exports);
 async function runDevCommand(args, runner) {
@@ -1011,7 +1954,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, {
@@ -1025,9 +1969,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 Promise.resolve().then(() => (init_cli_utils(), cli_utils_exports));
+  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,
@@ -1048,14 +1993,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") {
@@ -1069,8 +2017,8 @@ 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);
@@ -1085,11 +2033,15 @@ init_cli_api();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CLI_VERSION,
+  DEFAULT_ADAPTER_MAX_BODY_BYTES,
+  TEMP_BUILD_ENTRY_FILENAME,
+  TEMP_SERVERLESS_ENTRY_FILENAME,
   applyServerlessResult,
   buildBundleFromEntryContent,
   buildChildArgs,
   buildRuntime,
   buildServerless,
+  collectBody,
   createServerlessAdapterApp,
   extractExport,
   generateRuntimeEntry,
@@ -1110,5 +2062,7 @@ init_cli_api();
   runDevCommand,
   runExpressDevCommand,
   runWithWatch,
-  toServerlessEvent
+  toServerlessEvent,
+  validateMaxBodyBytes,
+  validateOutDirForClean
 });