@web-ts-toolkit/express-runtime 0.42.2 → 0.44.0

package/{chunk-UPFG3S34.mjs → chunk-KBNC4WIR.mjs}

@@ -1,14 +1,17 @@
 import {
   MAX_INTEGER_OPTION_VALUE,
+  MAX_TIMER_DURATION_MS,
   createExpressApp,
   parsePortValue,
-  validateFiniteInteger
-} from "./chunk-VPFBKM2K.mjs";
+  validateFiniteInteger,
+  validateTimerDuration
+} from "./chunk-QNRHWPTO.mjs";
 
 // src/cli-utils.ts
 import { pathToFileURL } from "url";
 import {
   dirname,
+  basename,
   resolve as pathResolve,
   extname,
   join as pathJoin,
@@ -75,6 +78,12 @@ function parseIntegerFlag(raw, name, min = 0, max = MAX_INTEGER_OPTION_VALUE) {
   }
   return validateFiniteInteger(Number(raw), { name, min, max });
 }
+function parseTimerFlag(raw, name) {
+  if (!/^(0|[1-9]\d*)$/.test(raw)) {
+    throw new Error(`Invalid ${name}: ${raw}. Must be a finite integer in 0..${MAX_TIMER_DURATION_MS}.`);
+  }
+  return validateTimerDuration(Number(raw), name);
+}
 function parsePortFlag(raw, name = "--port") {
   try {
     return parsePortValue(raw, name);
@@ -114,13 +123,13 @@ 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)
+  --shutdown-timeout <ms>       Max ms to wait for in-flight requests (default: 5000; 0..2147483647)
   --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)
+  --delay <ms>                  Debounce ms before restarting on change (default: 500; 0..2147483647)
 
 Build options:
   --init <path>                 Init hook module (default export, async function)
@@ -129,14 +138,14 @@ Build options:
   --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)
+  --external <pkg>              Mark package as external (repeatable; express and @web-ts-toolkit/express-runtime 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)
+  --shutdown-timeout <ms>       Max ms to wait for in-flight requests (default: 5000; 0..2147483647)
   --require <module>            Module(s) to preload before app load (repeatable)
   --env <path>                  Env file(s) to load (repeatable; existing env vars are not overridden)
 
@@ -147,14 +156,14 @@ Build-serverless options:
   --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)
+  --external <pkg>              Mark package as external (repeatable; express and @web-ts-toolkit/express-runtime 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)
+  --shutdown-timeout <ms>       Max ms to wait for in-flight requests (default: 5000; 0..2147483647)
   --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)
@@ -184,7 +193,7 @@ Notes:
   - --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 build/build-serverless mode, express and @web-ts-toolkit/express-runtime are 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
@@ -270,12 +279,12 @@ function parseDevArgs(argv) {
       continue;
     }
     if (arg === "--shutdown-timeout") {
-      options.shutdownTimeout = parseIntegerFlag(readValue(argv, index, arg), "--shutdown-timeout");
+      options.shutdownTimeout = parseTimerFlag(readValue(argv, index, arg), "--shutdown-timeout");
       index += 1;
       continue;
     }
     if (arg.startsWith("--shutdown-timeout=")) {
-      options.shutdownTimeout = parseIntegerFlag(
+      options.shutdownTimeout = parseTimerFlag(
         readInlineValue(arg, "--shutdown-timeout=", "--shutdown-timeout"),
         "--shutdown-timeout"
       );
@@ -325,12 +334,12 @@ function parseDevArgs(argv) {
       continue;
     }
     if (arg === "--delay") {
-      watchDelay = parseIntegerFlag(readValue(argv, index, arg), "--delay");
+      watchDelay = parseTimerFlag(readValue(argv, index, arg), "--delay");
       index += 1;
       continue;
     }
     if (arg.startsWith("--delay=")) {
-      watchDelay = parseIntegerFlag(readInlineValue(arg, "--delay=", "--delay"), "--delay");
+      watchDelay = parseTimerFlag(readInlineValue(arg, "--delay=", "--delay"), "--delay");
       continue;
     }
     if (!arg.startsWith("--")) {
@@ -625,12 +634,12 @@ function loadEnvFiles(paths) {
     }
   }
 }
-var moduleRequire = createRequire(
-  pathToFileURL(pathResolve(process.cwd(), "__wtt_runtime_preload__.js"))
-);
 async function preloadModules(modules) {
+  const invocationRequire = createRequire(
+    pathToFileURL(pathResolve(process.cwd(), "__wtt_runtime_preload__.js"))
+  );
   for (const mod of modules) {
-    moduleRequire(mod);
+    invocationRequire(mod);
   }
 }
 var DEFAULT_WATCH_KILL_TIMEOUT_MS = 5e3;
@@ -638,6 +647,12 @@ function toDiagnosticMessage(prefix, error) {
   const message = error instanceof Error ? error.message : String(error);
   return `${prefix}: ${message}`;
 }
+function isChildGone(proc) {
+  const exitCode = proc.exitCode;
+  const signalCode = proc.signalCode;
+  if (exitCode != null || signalCode != null) return true;
+  return proc.pid === void 0;
+}
 function createWatchSupervisor(args, deps = {}) {
   const forkImpl = deps.fork ?? fork;
   const watchImpl = deps.watch ?? watch;
@@ -646,6 +661,11 @@ function createWatchSupervisor(args, deps = {}) {
   const setTimeoutImpl = deps.setTimeout ?? setTimeout;
   const clearTimeoutImpl = deps.clearTimeout ?? clearTimeout;
   const killTimeoutMs = deps.killTimeoutMs ?? DEFAULT_WATCH_KILL_TIMEOUT_MS;
+  validateTimerDuration(args.watchDelay, "--delay");
+  validateTimerDuration(killTimeoutMs, "killTimeoutMs");
+  if (args.options.shutdownTimeout !== void 0) {
+    validateTimerDuration(args.options.shutdownTimeout, "--shutdown-timeout");
+  }
   const cliPath = process.argv[1];
   const childArgv = buildChildArgs(args);
   let child = null;
@@ -702,7 +722,7 @@ function createWatchSupervisor(args, deps = {}) {
     }
     child = nextChild;
     nextChild.once("error", (error) => {
-      if (child === nextChild) {
+      if (isChildGone(nextChild) && child === nextChild) {
         child = null;
       }
       fail(toDiagnosticMessage("Watch child process error", error));
@@ -732,10 +752,15 @@ function createWatchSupervisor(args, deps = {}) {
         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();
+        if (error) {
+          if (terminatingChild === target) terminatingChild = null;
+          if (child === target && isChildGone(target)) child = null;
+          reject(error);
+        } else {
+          if (child === target) child = null;
+          if (terminatingChild === target) terminatingChild = null;
+          resolve();
+        }
       };
       const onExit = () => settle();
       const onError = (error) => settle(error);
@@ -864,7 +889,7 @@ function createWatchSupervisor(args, deps = {}) {
   };
 }
 function buildChildArgs(args) {
-  const result = ["dev", args.appPath];
+  const result = ["dev"];
   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");
@@ -873,17 +898,23 @@ function buildChildArgs(args) {
   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);
+  result.push("--", args.appPath);
   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));
+  let exited = false;
+  const exitOnce = (code) => {
+    if (exited) return;
+    exited = true;
+    exitImpl?.(code);
+  };
   const controller = createWatchSupervisor(args, {
     ...deps,
-    exit: exitImpl
+    exit: exitOnce
   });
-  let shutdownStarted = false;
   const ownedHandlers = [];
   const removeOwnedHandlers = () => {
     for (const [signal, handler] of ownedHandlers.splice(0)) {
@@ -891,8 +922,11 @@ function runWithWatch(args, deps = {}) {
     }
   };
   const shutdown = async () => {
-    removeOwnedHandlers();
-    await controller.shutdown();
+    try {
+      await controller.shutdown();
+    } finally {
+      removeOwnedHandlers();
+    }
   };
   const wrappedController = {
     shutdown,
@@ -901,14 +935,38 @@ function runWithWatch(args, deps = {}) {
     isShuttingDown: controller.isShuttingDown
   };
   if (installSignalHandlers) {
-    const shutdownAndExit = () => {
-      if (shutdownStarted) return;
-      shutdownStarted = true;
-      void shutdown().then(() => exitImpl?.(0));
+    let signalCount = 0;
+    const shutdownAndExit = (signal) => {
+      signalCount += 1;
+      if (signalCount === 1) {
+        void shutdown().then(
+          () => exitOnce(0),
+          () => exitOnce(1)
+        );
+        return;
+      }
+      if (signalCount === 2) {
+        try {
+          const live = controller.getChild();
+          if (live?.pid) {
+            try {
+              live.kill("SIGKILL");
+            } catch (_error) {
+              void _error;
+            }
+          }
+        } catch (_error) {
+          void _error;
+        }
+        void signal;
+        return;
+      }
     };
-    ownedHandlers.push(["SIGINT", shutdownAndExit], ["SIGTERM", shutdownAndExit]);
-    process.on("SIGINT", shutdownAndExit);
-    process.on("SIGTERM", shutdownAndExit);
+    const onSigint = () => shutdownAndExit("SIGINT");
+    const onSigterm = () => shutdownAndExit("SIGTERM");
+    ownedHandlers.push(["SIGINT", onSigint], ["SIGTERM", onSigterm]);
+    process.on("SIGINT", onSigint);
+    process.on("SIGTERM", onSigterm);
   }
   return wrappedController;
 }
@@ -949,56 +1007,107 @@ function generateRuntimeEntry(appPath, initPath) {
 function validateOutDirForClean(outDir, clean, appPath, initPath) {
   if (!clean) return;
   const cwd = process.cwd();
+  const canonicalCwd = canonicalizeCwd(cwd);
   const outAbs = pathResolve(cwd, outDir);
-  const normalized = pathNormalize(outAbs);
-  const root = pathParse(normalized).root;
-  if (normalized === root) {
-    throw new Error(`Refusing to clean filesystem root: ${outDir} resolves to ${normalized}`);
+  const canonicalOut = canonicalizePhysicalPath(outAbs, "outDir");
+  const root = pathParse(canonicalOut).root;
+  if (canonicalOut === root) {
+    throw new Error(`Refusing to clean filesystem root: ${outDir} resolves to ${canonicalOut}`);
   }
-  if (normalized === pathNormalize(cwd)) {
+  if (canonicalOut === canonicalCwd) {
     throw new Error(`Refusing to clean project directory: ${outDir} resolves to cwd ${cwd}`);
   }
-  if (cwd !== root && (cwd === normalized || cwd.startsWith(normalized + pathSep))) {
+  if (canonicalCwd === canonicalOut || canonicalCwd.startsWith(canonicalOut + pathSep)) {
     throw new Error(
-      `Refusing to clean ancestor of project directory: ${outDir} resolves to ${normalized} which contains cwd ${cwd}`
+      `Refusing to clean ancestor of project directory: ${outDir} resolves to ${canonicalOut} which contains cwd ${cwd}`
     );
   }
   try {
-    if (existsSync(outAbs)) {
-      const st = lstatSync(outAbs);
-      if (st.isSymbolicLink()) {
-        throw new Error(`Refusing to clean symlinked outDir: ${outDir} resolves to symlink ${outAbs}`);
-      }
+    const st = lstatSync(outAbs);
+    if (st.isSymbolicLink()) {
+      throw new Error(`Refusing to clean symlinked outDir: ${outDir} resolves to symlink ${outAbs}`);
     }
   } catch (e) {
     if (e.message.startsWith("Refusing to clean")) throw e;
+    const code = e.code;
+    if (code !== "ENOENT" && code !== "ENOTDIR") {
+      throw new Error(
+        `Refusing to clean outDir with unresolvable state: ${outDir} (${outAbs}): ${e.message}`,
+        { cause: e }
+      );
+    }
   }
   const checkOverlap = (inputPath, label) => {
     if (!inputPath) return;
     const inputAbs = pathResolve(cwd, inputPath);
-    const inputNorm = pathNormalize(inputAbs);
-    if (inputNorm === normalized) {
+    const canonicalInput = canonicalizePhysicalPath(inputAbs, label);
+    if (canonicalInput === canonicalOut) {
       throw new Error(`Refusing to clean outDir that is the same as ${label}: ${outDir} == ${inputPath}`);
     }
-    if (inputNorm.startsWith(normalized + pathSep)) {
+    if (canonicalInput.startsWith(canonicalOut + pathSep)) {
       throw new Error(`Refusing to clean outDir that contains ${label}: ${outDir} contains ${inputPath}`);
     }
+    if (canonicalOut.startsWith(canonicalInput + pathSep)) {
+      throw new Error(`Refusing to clean outDir inside ${label}: ${outDir} is inside ${inputPath}`);
+    }
   };
   checkOverlap(appPath, "appPath");
   checkOverlap(initPath, "initPath");
 }
-function createUniqueStagingDir() {
+function canonicalizePhysicalPath(absPath, label) {
+  const normalizedStart = pathNormalize(absPath);
+  let current = normalizedStart;
+  const suffixParts = [];
+  while (true) {
+    try {
+      const real = realpathSync(current);
+      if (suffixParts.length === 0) return pathNormalize(real);
+      return pathNormalize(pathJoin(real, ...suffixParts.slice().reverse()));
+    } catch (error) {
+      const code = error.code;
+      if (code === "ENOENT" || code === "ENOTDIR") {
+        const parent = dirname(current);
+        if (parent === current) {
+          throw new Error(`Refusing to clean ${label}: unable to resolve existing ancestor of ${absPath}`, {
+            cause: error
+          });
+        }
+        suffixParts.push(basename(current));
+        current = parent;
+        continue;
+      }
+      throw new Error(`Refusing to clean ${label}: unable to resolve ${absPath}: ${error.message}`, {
+        cause: error
+      });
+    }
+  }
+}
+function canonicalizeCwd(cwd) {
+  try {
+    return pathNormalize(realpathSync(cwd));
+  } catch (error) {
+    throw new Error(`Refusing to clean: unable to resolve project directory ${cwd}: ${error.message}`, {
+      cause: error
+    });
+  }
+}
+function createUniqueStagingDir(deps = {}) {
   const cwd = process.cwd();
   const prefix = pathJoin(cwd, STAGING_DIR_PREFIX);
-  const dir = mkdtempSync(prefix);
+  const mkdtemp = deps.mkdtempSyncImpl ?? mkdtempSync;
+  const lstat = deps.lstatSyncImpl ?? lstatSync;
+  const rm = deps.rmSyncImpl ?? rmSync;
+  const dir = mkdtemp(prefix);
   try {
-    const st = lstatSync(dir);
+    const st = lstat(dir);
     if (st.isSymbolicLink()) {
-      rmSync(dir, { recursive: true, force: true });
       throw new Error(`Staging directory is a symlink: ${dir}`);
     }
   } catch (e) {
-    if (e.message.includes("Staging directory is a symlink")) throw e;
+    try {
+      rm(dir, { recursive: true, force: true });
+    } catch {
+    }
     throw e;
   }
   try {
@@ -1007,41 +1116,58 @@ function createUniqueStagingDir() {
   }
   return dir;
 }
-function writeStagingEntry(dir, content) {
+function writeStagingEntry(dir, content, deps = {}) {
   const entryPath = pathJoin(dir, "entry.ts");
+  const lstat = deps.lstatSyncImpl ?? lstatSync;
+  const writeFile = deps.writeFileSyncImpl ?? writeFileSync;
+  const rm = deps.rmSyncImpl ?? rmSync;
   try {
-    if (existsSync(entryPath)) {
-      const st = lstatSync(entryPath);
-      if (st.isSymbolicLink()) {
-        throw new Error(`Refusing to overwrite symlink at staging path: ${entryPath}`);
-      }
-      throw new Error(`Staging file already exists: ${entryPath}`);
+    const st = lstat(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;
+    const message = e.message;
+    if (message.startsWith("Refusing to") || message.startsWith("Staging file already exists")) throw e;
+    const code = e.code;
+    if (code !== "ENOENT" && code !== "ENOTDIR") {
+      throw new Error(`Refusing to use staging path with unresolvable state: ${entryPath}: ${message}`, {
+        cause: e
+      });
+    }
   }
-  writeFileSync(entryPath, content, { encoding: "utf8", flag: "wx", mode: 384 });
+  writeFile(entryPath, content, { encoding: "utf8", flag: "wx", mode: 384 });
   try {
-    const st = lstatSync(entryPath);
+    const st = lstat(entryPath);
     if (st.isSymbolicLink()) {
-      rmSync(entryPath, { force: true });
+      try {
+        rm(entryPath, { force: true });
+      } catch {
+      }
       throw new Error(`Staging file is a symlink after write: ${entryPath}`);
     }
   } catch (e) {
     if (e.message.includes("Staging file is a symlink")) throw e;
+    try {
+      rm(entryPath, { force: true });
+    } catch {
+    }
+    throw new Error(`Refusing to use staging file with unresolvable state: ${entryPath}: ${e.message}`, {
+      cause: e
+    });
   }
   return entryPath;
 }
-async function buildBundleFromEntryContent(args) {
+async function buildBundleFromEntryContent(args, deps = {}) {
   validateOutDirForClean(args.outDir, args.clean);
-  const tsupModule = await import("tsup");
-  const { build } = tsupModule;
-  const stagingDir = createUniqueStagingDir();
-  const tempEntryPath = writeStagingEntry(stagingDir, args.entryContent);
-  const absOutDir = pathResolve(process.cwd(), args.outDir);
+  const buildImpl = deps.buildImpl ?? (await import("tsup")).build;
+  const rm = deps.rmSyncImpl ?? rmSync;
+  const stagingDir = createUniqueStagingDir(deps);
   try {
-    await build({
+    const tempEntryPath = writeStagingEntry(stagingDir, args.entryContent, deps);
+    const absOutDir = pathResolve(process.cwd(), args.outDir);
+    await buildImpl({
       config: false,
       entry: { [args.outName]: tempEntryPath },
       tsconfig: args.tsconfigPath,
@@ -1055,7 +1181,10 @@ async function buildBundleFromEntryContent(args) {
       splitting: false
     });
   } finally {
-    rmSync(stagingDir, { recursive: true, force: true });
+    try {
+      rm(stagingDir, { recursive: true, force: true });
+    } catch {
+    }
   }
 }
 async function buildRuntime(args) {
@@ -1155,11 +1284,14 @@ function collectBody(req, maxBytes) {
       if (finished) return;
       finished = true;
       cleanup();
+      let body;
       try {
-        resolve(Buffer.concat(chunks, total));
+        body = Buffer.concat(chunks, total);
       } catch (e) {
-        fail(e);
+        reject(e);
+        return;
       }
+      resolve(body);
     };
     const onError = (err) => {
       const e = err;
@@ -1183,13 +1315,13 @@ function collectBody(req, maxBytes) {
     }
   });
 }
-function toServerlessEvent(method, url, headers, body) {
-  const parsedUrl = new URL(url, "http://localhost");
-  const { queryStringParameters, multiValueQueryStringParameters } = parseAwsRestQuery(parsedUrl.search);
-  const { singleValueHeaders, multiValueHeaders } = normalizeAwsRestHeaders(headers);
+function toServerlessEvent(method, url, headers, body, rawHeaders) {
+  const { path, search } = splitRequestTarget(url);
+  const { queryStringParameters, multiValueQueryStringParameters } = parseAwsRestQuery(search);
+  const { singleValueHeaders, multiValueHeaders } = buildAwsRestHeaders(headers, rawHeaders);
   return {
     httpMethod: method,
-    path: parsedUrl.pathname,
+    path,
     headers: singleValueHeaders,
     multiValueHeaders,
     queryStringParameters,
@@ -1204,12 +1336,49 @@ function toServerlessEvent(method, url, headers, body) {
     }
   };
 }
+function splitRequestTarget(target) {
+  if (target === "") {
+    return { path: "/", search: "" };
+  }
+  let remainder = target;
+  const absoluteMatch = remainder.match(/^([A-Za-z][A-Za-z0-9+.-]*):\/\//);
+  if (absoluteMatch) {
+    const afterScheme = remainder.slice(absoluteMatch[0].length);
+    const boundary = afterScheme.search(/[/?#]/);
+    if (boundary === -1) {
+      return { path: "/", search: "" };
+    }
+    remainder = afterScheme.slice(boundary);
+    if (remainder.startsWith("?") || remainder.startsWith("#")) {
+      remainder = `/${remainder}`;
+    }
+  } else if (remainder === "*" || remainder.startsWith("*?") || remainder.startsWith("*#")) {
+    remainder = remainder.slice(1);
+    if (remainder === "") {
+      return { path: "*", search: "" };
+    }
+    const hashIndex2 = remainder.indexOf("#");
+    const withoutFragment2 = hashIndex2 === -1 ? remainder : remainder.slice(0, hashIndex2);
+    return { path: "*", search: withoutFragment2 };
+  } else if (!remainder.startsWith("/")) {
+    throw new Error(
+      `Unsupported request target: ${JSON.stringify(target)}. Expected an origin-form path ("/path?query"), an absolute-form URI ("scheme://authority/path?query"), or "*"`
+    );
+  }
+  const hashIndex = remainder.indexOf("#");
+  const withoutFragment = hashIndex === -1 ? remainder : remainder.slice(0, hashIndex);
+  const queryIndex = withoutFragment.indexOf("?");
+  if (queryIndex === -1) {
+    return { path: withoutFragment, search: "" };
+  }
+  return { path: withoutFragment.slice(0, queryIndex), search: withoutFragment.slice(queryIndex) };
+}
 function parseAwsRestQuery(search) {
   if (search === "" || search === "?") {
     return { queryStringParameters: null, multiValueQueryStringParameters: null };
   }
-  const single = {};
-  const multi = {};
+  const single = /* @__PURE__ */ Object.create(null);
+  const multi = /* @__PURE__ */ Object.create(null);
   const query = search.startsWith("?") ? search.slice(1) : search;
   for (const pair of query.split("&")) {
     if (pair === "") continue;
@@ -1219,7 +1388,11 @@ function parseAwsRestQuery(search) {
     const key = decodeQueryComponent(rawKey);
     const value = decodeQueryComponent(rawValue);
     single[key] = value;
-    (multi[key] ??= []).push(value);
+    if (Object.prototype.hasOwnProperty.call(multi, key)) {
+      multi[key].push(value);
+    } else {
+      multi[key] = [value];
+    }
   }
   return {
     queryStringParameters: Object.keys(single).length > 0 ? single : null,
@@ -1235,8 +1408,8 @@ function decodeQueryComponent(value) {
   }
 }
 function normalizeAwsRestHeaders(headers) {
-  const singleValueHeaders = {};
-  const multiValueHeaders = {};
+  const singleValueHeaders = /* @__PURE__ */ Object.create(null);
+  const multiValueHeaders = /* @__PURE__ */ Object.create(null);
   for (const [key, value] of Object.entries(headers)) {
     if (value === void 0) continue;
     const values = Array.isArray(value) ? value.map(String) : [String(value)];
@@ -1245,23 +1418,92 @@ function normalizeAwsRestHeaders(headers) {
   }
   return { singleValueHeaders, multiValueHeaders };
 }
+function buildAwsRestHeaders(headers, rawHeaders) {
+  const fromRaw = headersFromRawHeadersList(rawHeaders);
+  if (fromRaw) return fromRaw;
+  if (isPlainRecord(rawHeaders)) {
+    return normalizeAwsRestHeaders(rawHeaders);
+  }
+  return normalizeAwsRestHeaders(headers);
+}
+function headersFromRawHeadersList(rawHeaders) {
+  if (!Array.isArray(rawHeaders)) return null;
+  if (rawHeaders.length % 2 !== 0) return null;
+  for (const entry of rawHeaders) {
+    if (typeof entry !== "string") return null;
+  }
+  const singleValueHeaders = /* @__PURE__ */ Object.create(null);
+  const multiValueHeaders = /* @__PURE__ */ Object.create(null);
+  for (let index = 0; index < rawHeaders.length; index += 2) {
+    const name = rawHeaders[index].toLowerCase();
+    const value = rawHeaders[index + 1];
+    if (Object.prototype.hasOwnProperty.call(multiValueHeaders, name)) {
+      multiValueHeaders[name].push(value);
+    } else {
+      multiValueHeaders[name] = [value];
+    }
+  }
+  for (const key of Object.keys(multiValueHeaders)) {
+    singleValueHeaders[key] = multiValueHeaders[key].join(", ");
+  }
+  return { singleValueHeaders, multiValueHeaders };
+}
 function applyServerlessResult(result, res) {
   const response = validateServerlessResult(result);
   res.status(response.statusCode);
-  for (const [key, value] of Object.entries(response.headers)) {
-    res.setHeader(key, value);
+  let baseline;
+  try {
+    baseline = new Set(Object.keys(res.getHeaders()).map((name) => name.toLowerCase()));
+  } catch (_e) {
+    void _e;
+    baseline = void 0;
   }
-  for (const [key, values] of Object.entries(response.multiValueHeaders)) {
-    if (key.toLowerCase() === "set-cookie") {
-      res.setHeader(key, values);
+  try {
+    for (const [key, value] of Object.entries(response.headers)) {
+      res.setHeader(key, value);
+    }
+    for (const [key, values] of Object.entries(response.multiValueHeaders)) {
+      if (key.toLowerCase() === "set-cookie") {
+        res.setHeader(key, values);
+      } else {
+        res.setHeader(key, values.join(","));
+      }
+    }
+    if (response.isBase64Encoded) {
+      res.end(response.decodedBody);
     } else {
-      res.setHeader(key, values.join(","));
+      res.end(response.body);
     }
-  }
-  if (response.isBase64Encoded) {
-    res.end(response.decodedBody);
-  } else {
-    res.end(response.body);
+  } catch (error) {
+    if (!res.headersSent) {
+      try {
+        if (baseline !== void 0) {
+          for (const name of Object.keys(res.getHeaders())) {
+            if (!baseline.has(name.toLowerCase())) {
+              res.removeHeader(name);
+            }
+          }
+        } else {
+          for (const [key] of Object.entries(response.headers)) {
+            try {
+              res.removeHeader(key);
+            } catch (_e) {
+              void _e;
+            }
+          }
+          for (const [key] of Object.entries(response.multiValueHeaders)) {
+            try {
+              res.removeHeader(key);
+            } catch (_e) {
+              void _e;
+            }
+          }
+        }
+      } catch (_e) {
+        void _e;
+      }
+    }
+    throw error;
   }
 }
 function validateServerlessResult(result) {
@@ -1313,7 +1555,7 @@ function validateSingleValueHeaders(value, name) {
   if (!isPlainRecord(value)) {
     throw new Error(`Invalid serverless result ${name}: expected an object of string header values.`);
   }
-  const headers = {};
+  const headers = /* @__PURE__ */ Object.create(null);
   for (const [key, headerValue] of Object.entries(value)) {
     if (headerValue === void 0) continue;
     if (typeof headerValue !== "string") {
@@ -1329,12 +1571,16 @@ function validateMultiValueHeaders(value, name) {
   if (!isPlainRecord(value)) {
     throw new Error(`Invalid serverless result ${name}: expected an object of string-array header values.`);
   }
-  const headers = {};
+  const headers = /* @__PURE__ */ Object.create(null);
   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.`);
     }
+    if (headerValue.length === 0) {
+      validateServerlessHeaderName(key, `${name}.${key}`);
+      continue;
+    }
     for (const entry of headerValue) {
       validateServerlessHeader(key, entry, `${name}.${key}`);
     }
@@ -1342,6 +1588,13 @@ function validateMultiValueHeaders(value, name) {
   }
   return headers;
 }
+function validateServerlessHeaderName(key, label) {
+  try {
+    validateHeaderName(key);
+  } catch (error) {
+    throw new Error(`Invalid serverless result header ${label}: ${error.message}`, { cause: error });
+  }
+}
 function validateServerlessHeader(key, value, label) {
   try {
     validateHeaderName(key);
@@ -1400,18 +1653,42 @@ function createServerlessAdapterApp(handler, options = {}) {
         }
         let result;
         try {
-          const event = toServerlessEvent(req.method, req.url, req.headers, body);
+          const raw = req.rawHeaders ?? req.headersDistinct;
+          const event = toServerlessEvent(req.method, req.url, req.headers, body, raw);
           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;
         }
+        let baselineHeaders;
+        try {
+          baselineHeaders = new Set(Object.keys(res.getHeaders()).map((name) => name.toLowerCase()));
+        } catch (_e) {
+          void _e;
+          baselineHeaders = void 0;
+        }
         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");
+          if (!res.headersSent && !res.writableEnded) {
+            try {
+              for (const name of Object.keys(res.getHeaders())) {
+                const lower = name.toLowerCase();
+                if (lower === "content-length") continue;
+                if (baselineHeaders !== void 0 && baselineHeaders.has(lower)) continue;
+                try {
+                  res.removeHeader(name);
+                } catch (_e) {
+                  void _e;
+                }
+              }
+            } catch (_e) {
+              void _e;
+            }
+            res.status(500).end("Internal server error");
+          }
         }
       });
     },