@vercel/node 3.0.14 → 3.0.15

package/dist/dev-server.mjs

@@ -588,7 +588,6 @@ async function serializeBody(request) {
 
 // src/edge-functions/edge-handler.mts
 import esbuild from "esbuild";
-import exitHook from "exit-hook";
 import { buildToHeaders } from "@edge-runtime/node-utils";
 import { fileURLToPath } from "url";
 var NODE_VERSION_MAJOR = process.version.match(/^v(\d+)\.\d+/)?.[1];
@@ -707,8 +706,22 @@ async function createEdgeRuntimeServer(params) {
       }
     });
     const server = await runServer({ runtime });
-    exitHook(() => server.close());
-    return server;
+    const onExit2 = async () => {
+      const WAIT_UNTIL_TIMEOUT = 10 * 1e3;
+      const waitUntil = server.close();
+      return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          console.warn(
+            `Edge Runtime server is still running after ${WAIT_UNTIL_TIMEOUT} ms (hint: do you have a long-running waitUntil() promise?)`
+          );
+          resolve();
+        }, WAIT_UNTIL_TIMEOUT);
+        waitUntil.then(() => resolve()).catch(reject).finally(() => {
+          clearTimeout(timeout);
+        });
+      });
+    };
+    return { server, onExit: onExit2 };
   } catch (error) {
     console.error("Failed to instantiate edge runtime.");
     logError(error);
@@ -721,8 +734,10 @@ async function createEdgeEventHandler(entrypointFullPath, entrypointRelativePath
     entrypointRelativePath,
     isMiddleware
   );
-  const server = await createEdgeRuntimeServer(userCode);
-  return async function(request) {
+  const result = await createEdgeRuntimeServer(userCode);
+  const server = result?.server;
+  const onExit2 = result?.onExit;
+  const handler = async function(request) {
     if (!server) {
       process.exit(1);
     }
@@ -757,6 +772,10 @@ ${fakeStackTrace}`
       encoding: "utf8"
     };
   };
+  return {
+    handler,
+    onExit: onExit2
+  };
 }
 function entrypointToRequestPath(entrypointRelativePath, isZeroConfig) {
   return "/" + entrypointToOutputPath(entrypointRelativePath, isZeroConfig);
@@ -972,7 +991,6 @@ async function addHelpers(_req, _res) {
 
 // src/serverless-functions/serverless-handler.mts
 import { createServer } from "http";
-import exitHook2 from "exit-hook";
 import { Headers as Headers3, request as undiciRequest2 } from "undici";
 import { listen } from "async-listen";
 import { isAbsolute } from "path";
@@ -991,8 +1009,12 @@ var HTTP_METHODS = [
 ];
 async function createServerlessServer(userCode) {
   const server = createServer(userCode);
-  exitHook2(() => server.close());
-  return { url: await listen(server) };
+  return {
+    url: await listen(server),
+    onExit: async () => {
+      server.close();
+    }
+  };
 }
 async function compileUserCode2(entrypointPath, options) {
   const id = isAbsolute(entrypointPath) ? pathToFileURL(entrypointPath).href : entrypointPath;
@@ -1020,7 +1042,7 @@ async function createServerlessEventHandler(entrypointPath, options) {
   const userCode = await compileUserCode2(entrypointPath, options);
   const server = await createServerlessServer(userCode);
   const isStreaming = options.mode === "streaming";
-  return async function(request) {
+  const handler = async function(request) {
     const url = new URL(request.url ?? "/", server.url);
     const response = await undiciRequest2(url, {
       body: await serializeBody(request),
@@ -1044,6 +1066,10 @@ async function createServerlessEventHandler(entrypointPath, options) {
       encoding: "utf8"
     };
   };
+  return {
+    handler,
+    onExit: server.onExit
+  };
 }
 
 // src/dev-server.mts
@@ -1076,6 +1102,7 @@ async function createEventHandler(entrypoint2, config, options) {
 }
 var handleEvent;
 var handlerEventError;
+var onExit;
 async function main() {
   const config = JSON.parse(process.env.VERCEL_DEV_CONFIG || "{}");
   delete process.env.VERCEL_DEV_CONFIG;
@@ -1085,9 +1112,11 @@ async function main() {
   const proxyServer = createServer2(onDevRequest);
   await listen2(proxyServer, { host: "127.0.0.1", port: 0 });
   try {
-    handleEvent = await createEventHandler(entrypoint, config, {
+    const result = await createEventHandler(entrypoint, config, {
       shouldAddHelpers
     });
+    handleEvent = result.handler;
+    onExit = result.onExit;
   } catch (error) {
     logError(error);
     handlerEventError = error;
@@ -1134,6 +1163,18 @@ main().catch((err) => {
   logError(err);
   process.exit(1);
 });
+process.on("message", async (m) => {
+  switch (m) {
+    case "shutdown":
+      if (onExit) {
+        await onExit();
+      }
+      process.exit(0);
+    default:
+      console.error(`unknown IPC message from parent:`, m);
+      break;
+  }
+});
 /*! Bundled license information:
 
 content-type/index.js:

package/dist/index.js

@@ -78,6 +78,112 @@ var require_dist = __commonJS({
   }
 });
 
+// ../../node_modules/.pnpm/tree-kill@1.2.2/node_modules/tree-kill/index.js
+var require_tree_kill = __commonJS({
+  "../../node_modules/.pnpm/tree-kill@1.2.2/node_modules/tree-kill/index.js"(exports, module2) {
+    "use strict";
+    var childProcess = require("child_process");
+    var spawn2 = childProcess.spawn;
+    var exec = childProcess.exec;
+    module2.exports = function(pid, signal, callback) {
+      if (typeof signal === "function" && callback === void 0) {
+        callback = signal;
+        signal = void 0;
+      }
+      pid = parseInt(pid);
+      if (Number.isNaN(pid)) {
+        if (callback) {
+          return callback(new Error("pid must be a number"));
+        } else {
+          throw new Error("pid must be a number");
+        }
+      }
+      var tree = {};
+      var pidsToProcess = {};
+      tree[pid] = [];
+      pidsToProcess[pid] = 1;
+      switch (process.platform) {
+        case "win32":
+          exec("taskkill /pid " + pid + " /T /F", callback);
+          break;
+        case "darwin":
+          buildProcessTree(pid, tree, pidsToProcess, function(parentPid) {
+            return spawn2("pgrep", ["-P", parentPid]);
+          }, function() {
+            killAll(tree, signal, callback);
+          });
+          break;
+        default:
+          buildProcessTree(pid, tree, pidsToProcess, function(parentPid) {
+            return spawn2("ps", ["-o", "pid", "--no-headers", "--ppid", parentPid]);
+          }, function() {
+            killAll(tree, signal, callback);
+          });
+          break;
+      }
+    };
+    function killAll(tree, signal, callback) {
+      var killed = {};
+      try {
+        Object.keys(tree).forEach(function(pid) {
+          tree[pid].forEach(function(pidpid) {
+            if (!killed[pidpid]) {
+              killPid(pidpid, signal);
+              killed[pidpid] = 1;
+            }
+          });
+          if (!killed[pid]) {
+            killPid(pid, signal);
+            killed[pid] = 1;
+          }
+        });
+      } catch (err) {
+        if (callback) {
+          return callback(err);
+        } else {
+          throw err;
+        }
+      }
+      if (callback) {
+        return callback();
+      }
+    }
+    function killPid(pid, signal) {
+      try {
+        process.kill(parseInt(pid, 10), signal);
+      } catch (err) {
+        if (err.code !== "ESRCH")
+          throw err;
+      }
+    }
+    function buildProcessTree(parentPid, tree, pidsToProcess, spawnChildProcessesList, cb) {
+      var ps = spawnChildProcessesList(parentPid);
+      var allData = "";
+      ps.stdout.on("data", function(data) {
+        var data = data.toString("ascii");
+        allData += data;
+      });
+      var onClose = function(code) {
+        delete pidsToProcess[parentPid];
+        if (code != 0) {
+          if (Object.keys(pidsToProcess).length == 0) {
+            cb();
+          }
+          return;
+        }
+        allData.match(/\d+/g).forEach(function(pid) {
+          pid = parseInt(pid, 10);
+          tree[parentPid].push(pid);
+          tree[pid] = [];
+          pidsToProcess[pid] = 1;
+          buildProcessTree(pid, tree, pidsToProcess, spawnChildProcessesList, cb);
+        });
+      };
+      ps.on("close", onClose);
+    }
+  }
+});
+
 // ../../node_modules/.pnpm/@babel+traverse@7.23.2/node_modules/@babel/traverse/lib/path/lib/virtual-types.js
 var require_virtual_types = __commonJS({
   "../../node_modules/.pnpm/@babel+traverse@7.23.2/node_modules/@babel/traverse/lib/path/lib/virtual-types.js"(exports) {
@@ -19065,9 +19171,175 @@ var require_sourcemap_codec_umd = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/@jridgewell+resolve-uri@3.1.1/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.umd.js
+// ../../node_modules/.pnpm/@jridgewell+sourcemap-codec@1.4.14/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.umd.js
+var require_sourcemap_codec_umd2 = __commonJS({
+  "../../node_modules/.pnpm/@jridgewell+sourcemap-codec@1.4.14/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.umd.js"(exports, module2) {
+    (function(global2, factory) {
+      typeof exports === "object" && typeof module2 !== "undefined" ? factory(exports) : typeof define === "function" && define.amd ? define(["exports"], factory) : (global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self, factory(global2.sourcemapCodec = {}));
+    })(exports, function(exports2) {
+      "use strict";
+      const comma = ",".charCodeAt(0);
+      const semicolon = ";".charCodeAt(0);
+      const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+      const intToChar = new Uint8Array(64);
+      const charToInt = new Uint8Array(128);
+      for (let i = 0; i < chars.length; i++) {
+        const c = chars.charCodeAt(i);
+        intToChar[i] = c;
+        charToInt[c] = i;
+      }
+      const td = typeof TextDecoder !== "undefined" ? /* @__PURE__ */ new TextDecoder() : typeof Buffer !== "undefined" ? {
+        decode(buf) {
+          const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
+          return out.toString();
+        }
+      } : {
+        decode(buf) {
+          let out = "";
+          for (let i = 0; i < buf.length; i++) {
+            out += String.fromCharCode(buf[i]);
+          }
+          return out;
+        }
+      };
+      function decode(mappings) {
+        const state = new Int32Array(5);
+        const decoded = [];
+        let index = 0;
+        do {
+          const semi = indexOf(mappings, index);
+          const line = [];
+          let sorted = true;
+          let lastCol = 0;
+          state[0] = 0;
+          for (let i = index; i < semi; i++) {
+            let seg;
+            i = decodeInteger(mappings, i, state, 0);
+            const col = state[0];
+            if (col < lastCol)
+              sorted = false;
+            lastCol = col;
+            if (hasMoreVlq(mappings, i, semi)) {
+              i = decodeInteger(mappings, i, state, 1);
+              i = decodeInteger(mappings, i, state, 2);
+              i = decodeInteger(mappings, i, state, 3);
+              if (hasMoreVlq(mappings, i, semi)) {
+                i = decodeInteger(mappings, i, state, 4);
+                seg = [col, state[1], state[2], state[3], state[4]];
+              } else {
+                seg = [col, state[1], state[2], state[3]];
+              }
+            } else {
+              seg = [col];
+            }
+            line.push(seg);
+          }
+          if (!sorted)
+            sort(line);
+          decoded.push(line);
+          index = semi + 1;
+        } while (index <= mappings.length);
+        return decoded;
+      }
+      function indexOf(mappings, index) {
+        const idx = mappings.indexOf(";", index);
+        return idx === -1 ? mappings.length : idx;
+      }
+      function decodeInteger(mappings, pos, state, j) {
+        let value2 = 0;
+        let shift = 0;
+        let integer = 0;
+        do {
+          const c = mappings.charCodeAt(pos++);
+          integer = charToInt[c];
+          value2 |= (integer & 31) << shift;
+          shift += 5;
+        } while (integer & 32);
+        const shouldNegate = value2 & 1;
+        value2 >>>= 1;
+        if (shouldNegate) {
+          value2 = -2147483648 | -value2;
+        }
+        state[j] += value2;
+        return pos;
+      }
+      function hasMoreVlq(mappings, i, length) {
+        if (i >= length)
+          return false;
+        return mappings.charCodeAt(i) !== comma;
+      }
+      function sort(line) {
+        line.sort(sortComparator);
+      }
+      function sortComparator(a, b) {
+        return a[0] - b[0];
+      }
+      function encode(decoded) {
+        const state = new Int32Array(5);
+        const bufLength = 1024 * 16;
+        const subLength = bufLength - 36;
+        const buf = new Uint8Array(bufLength);
+        const sub = buf.subarray(0, subLength);
+        let pos = 0;
+        let out = "";
+        for (let i = 0; i < decoded.length; i++) {
+          const line = decoded[i];
+          if (i > 0) {
+            if (pos === bufLength) {
+              out += td.decode(buf);
+              pos = 0;
+            }
+            buf[pos++] = semicolon;
+          }
+          if (line.length === 0)
+            continue;
+          state[0] = 0;
+          for (let j = 0; j < line.length; j++) {
+            const segment = line[j];
+            if (pos > subLength) {
+              out += td.decode(sub);
+              buf.copyWithin(0, subLength, pos);
+              pos -= subLength;
+            }
+            if (j > 0)
+              buf[pos++] = comma;
+            pos = encodeInteger(buf, pos, state, segment, 0);
+            if (segment.length === 1)
+              continue;
+            pos = encodeInteger(buf, pos, state, segment, 1);
+            pos = encodeInteger(buf, pos, state, segment, 2);
+            pos = encodeInteger(buf, pos, state, segment, 3);
+            if (segment.length === 4)
+              continue;
+            pos = encodeInteger(buf, pos, state, segment, 4);
+          }
+        }
+        return out + td.decode(buf.subarray(0, pos));
+      }
+      function encodeInteger(buf, pos, state, segment, j) {
+        const next = segment[j];
+        let num = next - state[j];
+        state[j] = next;
+        num = num < 0 ? -num << 1 | 1 : num << 1;
+        do {
+          let clamped = num & 31;
+          num >>>= 5;
+          if (num > 0)
+            clamped |= 32;
+          buf[pos++] = intToChar[clamped];
+        } while (num > 0);
+        return pos;
+      }
+      exports2.decode = decode;
+      exports2.encode = encode;
+      Object.defineProperty(exports2, "__esModule", { value: true });
+    });
+  }
+});
+
+// ../../node_modules/.pnpm/@jridgewell+resolve-uri@3.1.0/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.umd.js
 var require_resolve_uri_umd = __commonJS({
-  "../../node_modules/.pnpm/@jridgewell+resolve-uri@3.1.1/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.umd.js"(exports, module2) {
+  "../../node_modules/.pnpm/@jridgewell+resolve-uri@3.1.0/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.umd.js"(exports, module2) {
     (function(global2, factory) {
       typeof exports === "object" && typeof module2 !== "undefined" ? module2.exports = factory() : typeof define === "function" && define.amd ? define(factory) : (global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self, global2.resolveURI = factory());
     })(exports, function() {
@@ -19248,11 +19520,11 @@ var require_resolve_uri_umd = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/@jridgewell+trace-mapping@0.3.20/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.umd.js
+// ../../node_modules/.pnpm/@jridgewell+trace-mapping@0.3.18/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.umd.js
 var require_trace_mapping_umd = __commonJS({
-  "../../node_modules/.pnpm/@jridgewell+trace-mapping@0.3.20/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.umd.js"(exports, module2) {
+  "../../node_modules/.pnpm/@jridgewell+trace-mapping@0.3.18/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.umd.js"(exports, module2) {
     (function(global2, factory) {
-      typeof exports === "object" && typeof module2 !== "undefined" ? factory(exports, require_sourcemap_codec_umd(), require_resolve_uri_umd()) : typeof define === "function" && define.amd ? define(["exports", "@jridgewell/sourcemap-codec", "@jridgewell/resolve-uri"], factory) : (global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self, factory(global2.traceMapping = {}, global2.sourcemapCodec, global2.resolveURI));
+      typeof exports === "object" && typeof module2 !== "undefined" ? factory(exports, require_sourcemap_codec_umd2(), require_resolve_uri_umd()) : typeof define === "function" && define.amd ? define(["exports", "@jridgewell/sourcemap-codec", "@jridgewell/resolve-uri"], factory) : (global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self, factory(global2.traceMapping = {}, global2.sourcemapCodec, global2.resolveURI));
     })(exports, function(exports2, sourcemapCodec, resolveUri) {
       "use strict";
       function _interopDefaultLegacy(e) {
@@ -19506,7 +19778,7 @@ var require_trace_mapping_umd = __commonJS({
           const { version: version2, file, names, sourceRoot, sources, sourcesContent } = parsed;
           this.version = version2;
           this.file = file;
-          this.names = names || [];
+          this.names = names;
           this.sourceRoot = sourceRoot;
           this.sources = sources;
           this.sourcesContent = sourcesContent;
@@ -104838,9 +105110,12 @@ async function readMessage(child) {
 }
 
 // src/index.ts
+var import_tree_kill = __toESM(require_tree_kill());
+var import_util = require("util");
 var require_2 = (0, import_module2.createRequire)(__filename);
 var tscPath = (0, import_path4.resolve)((0, import_path4.dirname)(require_2.resolve("typescript")), "../bin/tsc");
 var libPathRegEx = /^node_modules|[\/\\]node_modules[\/\\]/;
+var treeKill = (0, import_util.promisify)(import_tree_kill.default);
 async function downloadInstallAndBundle({
   files,
   entrypoint,
@@ -105268,7 +105543,14 @@ var startDevServer = async (opts) => {
         console.error("Type check for %j failed:", entrypoint, err);
       });
     }
-    return { port: message.value.port, pid };
+    const shutdown = async () => {
+      child.send("shutdown", async (err) => {
+        if (err) {
+          await treeKill(pid);
+        }
+      });
+    };
+    return { port: message.value.port, pid, shutdown };
   } else {
     const [exitCode, signal] = message.value;
     const reason = signal ? `"${signal}" signal` : `exit code ${exitCode}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/node",
-  "version": "3.0.14",
+  "version": "3.0.15",
   "license": "Apache-2.0",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/node-js",
@@ -19,13 +19,12 @@
     "@types/node": "14.18.33",
     "@vercel/build-utils": "7.4.1",
     "@vercel/error-utils": "2.0.2",
-    "@vercel/nft": "0.24.2",
+    "@vercel/nft": "0.26.2",
     "@vercel/static-config": "3.0.0",
     "async-listen": "3.0.0",
     "edge-runtime": "2.5.7",
     "esbuild": "0.14.47",
     "etag": "1.8.1",
-    "exit-hook": "2.2.1",
     "node-fetch": "2.6.9",
     "path-to-regexp": "6.2.1",
     "ts-morph": "12.0.0",
@@ -48,7 +47,8 @@
     "execa": "3.2.0",
     "fs-extra": "11.1.0",
     "jest-junit": "16.0.0",
-    "source-map-support": "0.5.12"
+    "source-map-support": "0.5.12",
+    "tree-kill": "1.2.2"
   },
   "scripts": {
     "build": "node build.mjs",