vercel-cli 48.6.6__py3-none-any.whl → 50.4.6__py3-none-any.whl

vercel_cli/vendor/node_modules/@vercel/build-utils/dist/index.js

@@ -318,7 +318,7 @@ var require_BufferList = __commonJS({
         this.head = this.tail = null;
         this.length = 0;
       };
-      BufferList.prototype.join = function join4(s) {
+      BufferList.prototype.join = function join6(s) {
         if (this.length === 0)
           return "";
         var p = this.head;
@@ -2399,56 +2399,56 @@ var require_polyfills = __commonJS({
     }
     var chdir;
     module2.exports = patch;
-    function patch(fs6) {
+    function patch(fs7) {
       if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-        patchLchmod(fs6);
-      }
-      if (!fs6.lutimes) {
-        patchLutimes(fs6);
-      }
-      fs6.chown = chownFix(fs6.chown);
-      fs6.fchown = chownFix(fs6.fchown);
-      fs6.lchown = chownFix(fs6.lchown);
-      fs6.chmod = chmodFix(fs6.chmod);
-      fs6.fchmod = chmodFix(fs6.fchmod);
-      fs6.lchmod = chmodFix(fs6.lchmod);
-      fs6.chownSync = chownFixSync(fs6.chownSync);
-      fs6.fchownSync = chownFixSync(fs6.fchownSync);
-      fs6.lchownSync = chownFixSync(fs6.lchownSync);
-      fs6.chmodSync = chmodFixSync(fs6.chmodSync);
-      fs6.fchmodSync = chmodFixSync(fs6.fchmodSync);
-      fs6.lchmodSync = chmodFixSync(fs6.lchmodSync);
-      fs6.stat = statFix(fs6.stat);
-      fs6.fstat = statFix(fs6.fstat);
-      fs6.lstat = statFix(fs6.lstat);
-      fs6.statSync = statFixSync(fs6.statSync);
-      fs6.fstatSync = statFixSync(fs6.fstatSync);
-      fs6.lstatSync = statFixSync(fs6.lstatSync);
-      if (fs6.chmod && !fs6.lchmod) {
-        fs6.lchmod = function(path7, mode, cb) {
+        patchLchmod(fs7);
+      }
+      if (!fs7.lutimes) {
+        patchLutimes(fs7);
+      }
+      fs7.chown = chownFix(fs7.chown);
+      fs7.fchown = chownFix(fs7.fchown);
+      fs7.lchown = chownFix(fs7.lchown);
+      fs7.chmod = chmodFix(fs7.chmod);
+      fs7.fchmod = chmodFix(fs7.fchmod);
+      fs7.lchmod = chmodFix(fs7.lchmod);
+      fs7.chownSync = chownFixSync(fs7.chownSync);
+      fs7.fchownSync = chownFixSync(fs7.fchownSync);
+      fs7.lchownSync = chownFixSync(fs7.lchownSync);
+      fs7.chmodSync = chmodFixSync(fs7.chmodSync);
+      fs7.fchmodSync = chmodFixSync(fs7.fchmodSync);
+      fs7.lchmodSync = chmodFixSync(fs7.lchmodSync);
+      fs7.stat = statFix(fs7.stat);
+      fs7.fstat = statFix(fs7.fstat);
+      fs7.lstat = statFix(fs7.lstat);
+      fs7.statSync = statFixSync(fs7.statSync);
+      fs7.fstatSync = statFixSync(fs7.fstatSync);
+      fs7.lstatSync = statFixSync(fs7.lstatSync);
+      if (fs7.chmod && !fs7.lchmod) {
+        fs7.lchmod = function(path7, mode, cb) {
           if (cb)
             process.nextTick(cb);
         };
-        fs6.lchmodSync = function() {
+        fs7.lchmodSync = function() {
         };
       }
-      if (fs6.chown && !fs6.lchown) {
-        fs6.lchown = function(path7, uid, gid, cb) {
+      if (fs7.chown && !fs7.lchown) {
+        fs7.lchown = function(path7, uid, gid, cb) {
           if (cb)
             process.nextTick(cb);
         };
-        fs6.lchownSync = function() {
+        fs7.lchownSync = function() {
         };
       }
       if (platform === "win32") {
-        fs6.rename = typeof fs6.rename !== "function" ? fs6.rename : function(fs$rename) {
+        fs7.rename = typeof fs7.rename !== "function" ? fs7.rename : function(fs$rename) {
           function rename2(from, to, cb) {
             var start = Date.now();
             var backoff = 0;
             fs$rename(from, to, function CB(er) {
               if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 6e4) {
                 setTimeout(function() {
-                  fs6.stat(to, function(stater, st) {
+                  fs7.stat(to, function(stater, st) {
                     if (stater && stater.code === "ENOENT")
                       fs$rename(from, to, CB);
                     else
@@ -2466,9 +2466,9 @@ var require_polyfills = __commonJS({
           if (Object.setPrototypeOf)
             Object.setPrototypeOf(rename2, fs$rename);
           return rename2;
-        }(fs6.rename);
+        }(fs7.rename);
       }
-      fs6.read = typeof fs6.read !== "function" ? fs6.read : function(fs$read) {
+      fs7.read = typeof fs7.read !== "function" ? fs7.read : function(fs$read) {
         function read(fd, buffer, offset, length, position, callback_) {
           var callback;
           if (callback_ && typeof callback_ === "function") {
@@ -2476,23 +2476,23 @@ var require_polyfills = __commonJS({
             callback = function(er, _, __) {
               if (er && er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
-                return fs$read.call(fs6, fd, buffer, offset, length, position, callback);
+                return fs$read.call(fs7, fd, buffer, offset, length, position, callback);
               }
               callback_.apply(this, arguments);
             };
           }
-          return fs$read.call(fs6, fd, buffer, offset, length, position, callback);
+          return fs$read.call(fs7, fd, buffer, offset, length, position, callback);
         }
         if (Object.setPrototypeOf)
           Object.setPrototypeOf(read, fs$read);
         return read;
-      }(fs6.read);
-      fs6.readSync = typeof fs6.readSync !== "function" ? fs6.readSync : function(fs$readSync) {
+      }(fs7.read);
+      fs7.readSync = typeof fs7.readSync !== "function" ? fs7.readSync : function(fs$readSync) {
         return function(fd, buffer, offset, length, position) {
           var eagCounter = 0;
           while (true) {
             try {
-              return fs$readSync.call(fs6, fd, buffer, offset, length, position);
+              return fs$readSync.call(fs7, fd, buffer, offset, length, position);
             } catch (er) {
               if (er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
@@ -2502,10 +2502,10 @@ var require_polyfills = __commonJS({
             }
           }
         };
-      }(fs6.readSync);
-      function patchLchmod(fs7) {
-        fs7.lchmod = function(path7, mode, callback) {
-          fs7.open(
+      }(fs7.readSync);
+      function patchLchmod(fs8) {
+        fs8.lchmod = function(path7, mode, callback) {
+          fs8.open(
             path7,
             constants.O_WRONLY | constants.O_SYMLINK,
             mode,
@@ -2515,8 +2515,8 @@ var require_polyfills = __commonJS({
                   callback(err);
                 return;
               }
-              fs7.fchmod(fd, mode, function(err2) {
-                fs7.close(fd, function(err22) {
+              fs8.fchmod(fd, mode, function(err2) {
+                fs8.close(fd, function(err22) {
                   if (callback)
                     callback(err2 || err22);
                 });
@@ -2524,68 +2524,68 @@ var require_polyfills = __commonJS({
             }
           );
         };
-        fs7.lchmodSync = function(path7, mode) {
-          var fd = fs7.openSync(path7, constants.O_WRONLY | constants.O_SYMLINK, mode);
+        fs8.lchmodSync = function(path7, mode) {
+          var fd = fs8.openSync(path7, constants.O_WRONLY | constants.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
-            ret = fs7.fchmodSync(fd, mode);
+            ret = fs8.fchmodSync(fd, mode);
             threw = false;
           } finally {
             if (threw) {
               try {
-                fs7.closeSync(fd);
+                fs8.closeSync(fd);
               } catch (er) {
               }
             } else {
-              fs7.closeSync(fd);
+              fs8.closeSync(fd);
             }
           }
           return ret;
         };
       }
-      function patchLutimes(fs7) {
-        if (constants.hasOwnProperty("O_SYMLINK") && fs7.futimes) {
-          fs7.lutimes = function(path7, at, mt, cb) {
-            fs7.open(path7, constants.O_SYMLINK, function(er, fd) {
+      function patchLutimes(fs8) {
+        if (constants.hasOwnProperty("O_SYMLINK") && fs8.futimes) {
+          fs8.lutimes = function(path7, at, mt, cb) {
+            fs8.open(path7, constants.O_SYMLINK, function(er, fd) {
               if (er) {
                 if (cb)
                   cb(er);
                 return;
               }
-              fs7.futimes(fd, at, mt, function(er2) {
-                fs7.close(fd, function(er22) {
+              fs8.futimes(fd, at, mt, function(er2) {
+                fs8.close(fd, function(er22) {
                   if (cb)
                     cb(er2 || er22);
                 });
               });
             });
           };
-          fs7.lutimesSync = function(path7, at, mt) {
-            var fd = fs7.openSync(path7, constants.O_SYMLINK);
+          fs8.lutimesSync = function(path7, at, mt) {
+            var fd = fs8.openSync(path7, constants.O_SYMLINK);
             var ret;
             var threw = true;
             try {
-              ret = fs7.futimesSync(fd, at, mt);
+              ret = fs8.futimesSync(fd, at, mt);
               threw = false;
             } finally {
               if (threw) {
                 try {
-                  fs7.closeSync(fd);
+                  fs8.closeSync(fd);
                 } catch (er) {
                 }
               } else {
-                fs7.closeSync(fd);
+                fs8.closeSync(fd);
               }
             }
             return ret;
           };
-        } else if (fs7.futimes) {
-          fs7.lutimes = function(_a, _b, _c, cb) {
+        } else if (fs8.futimes) {
+          fs8.lutimes = function(_a, _b, _c, cb) {
             if (cb)
               process.nextTick(cb);
           };
-          fs7.lutimesSync = function() {
+          fs8.lutimesSync = function() {
           };
         }
       }
@@ -2593,7 +2593,7 @@ var require_polyfills = __commonJS({
         if (!orig)
           return orig;
         return function(target, mode, cb) {
-          return orig.call(fs6, target, mode, function(er) {
+          return orig.call(fs7, target, mode, function(er) {
             if (chownErOk(er))
               er = null;
             if (cb)
@@ -2606,7 +2606,7 @@ var require_polyfills = __commonJS({
           return orig;
         return function(target, mode) {
           try {
-            return orig.call(fs6, target, mode);
+            return orig.call(fs7, target, mode);
           } catch (er) {
             if (!chownErOk(er))
               throw er;
@@ -2617,7 +2617,7 @@ var require_polyfills = __commonJS({
         if (!orig)
           return orig;
         return function(target, uid, gid, cb) {
-          return orig.call(fs6, target, uid, gid, function(er) {
+          return orig.call(fs7, target, uid, gid, function(er) {
             if (chownErOk(er))
               er = null;
             if (cb)
@@ -2630,7 +2630,7 @@ var require_polyfills = __commonJS({
           return orig;
         return function(target, uid, gid) {
           try {
-            return orig.call(fs6, target, uid, gid);
+            return orig.call(fs7, target, uid, gid);
           } catch (er) {
             if (!chownErOk(er))
               throw er;
@@ -2655,14 +2655,14 @@ var require_polyfills = __commonJS({
             if (cb)
               cb.apply(this, arguments);
           }
-          return options ? orig.call(fs6, target, options, callback) : orig.call(fs6, target, callback);
+          return options ? orig.call(fs7, target, options, callback) : orig.call(fs7, target, callback);
         };
       }
       function statFixSync(orig) {
         if (!orig)
           return orig;
         return function(target, options) {
-          var stats = options ? orig.call(fs6, target, options) : orig.call(fs6, target);
+          var stats = options ? orig.call(fs7, target, options) : orig.call(fs7, target);
           if (stats) {
             if (stats.uid < 0)
               stats.uid += 4294967296;
@@ -2693,7 +2693,7 @@ var require_legacy_streams = __commonJS({
   "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/legacy-streams.js"(exports2, module2) {
     var Stream = require("stream").Stream;
     module2.exports = legacy;
-    function legacy(fs6) {
+    function legacy(fs7) {
       return {
         ReadStream,
         WriteStream
@@ -2738,7 +2738,7 @@ var require_legacy_streams = __commonJS({
           });
           return;
         }
-        fs6.open(this.path, this.flags, this.mode, function(err, fd) {
+        fs7.open(this.path, this.flags, this.mode, function(err, fd) {
           if (err) {
             self2.emit("error", err);
             self2.readable = false;
@@ -2778,7 +2778,7 @@ var require_legacy_streams = __commonJS({
         this.busy = false;
         this._queue = [];
         if (this.fd === null) {
-          this._open = fs6.open;
+          this._open = fs7.open;
           this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
           this.flush();
         }
@@ -2813,7 +2813,7 @@ var require_clone = __commonJS({
 // ../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/graceful-fs.js
 var require_graceful_fs = __commonJS({
   "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/graceful-fs.js"(exports2, module2) {
-    var fs6 = require("fs");
+    var fs7 = require("fs");
     var polyfills = require_polyfills();
     var legacy = require_legacy_streams();
     var clone = require_clone();
@@ -2845,12 +2845,12 @@ var require_graceful_fs = __commonJS({
         m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
         console.error(m);
       };
-    if (!fs6[gracefulQueue]) {
+    if (!fs7[gracefulQueue]) {
       queue = global[gracefulQueue] || [];
-      publishQueue(fs6, queue);
-      fs6.close = function(fs$close) {
+      publishQueue(fs7, queue);
+      fs7.close = function(fs$close) {
         function close(fd, cb) {
-          return fs$close.call(fs6, fd, function(err) {
+          return fs$close.call(fs7, fd, function(err) {
             if (!err) {
               resetQueue();
             }
@@ -2862,40 +2862,40 @@ var require_graceful_fs = __commonJS({
           value: fs$close
         });
         return close;
-      }(fs6.close);
-      fs6.closeSync = function(fs$closeSync) {
+      }(fs7.close);
+      fs7.closeSync = function(fs$closeSync) {
         function closeSync(fd) {
-          fs$closeSync.apply(fs6, arguments);
+          fs$closeSync.apply(fs7, arguments);
           resetQueue();
         }
         Object.defineProperty(closeSync, previousSymbol, {
           value: fs$closeSync
         });
         return closeSync;
-      }(fs6.closeSync);
+      }(fs7.closeSync);
       if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
         process.on("exit", function() {
-          debug2(fs6[gracefulQueue]);
-          require("assert").equal(fs6[gracefulQueue].length, 0);
+          debug2(fs7[gracefulQueue]);
+          require("assert").equal(fs7[gracefulQueue].length, 0);
         });
       }
     }
     var queue;
     if (!global[gracefulQueue]) {
-      publishQueue(global, fs6[gracefulQueue]);
-    }
-    module2.exports = patch(clone(fs6));
-    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs6.__patched) {
-      module2.exports = patch(fs6);
-      fs6.__patched = true;
-    }
-    function patch(fs7) {
-      polyfills(fs7);
-      fs7.gracefulify = patch;
-      fs7.createReadStream = createReadStream;
-      fs7.createWriteStream = createWriteStream;
-      var fs$readFile = fs7.readFile;
-      fs7.readFile = readFile4;
+      publishQueue(global, fs7[gracefulQueue]);
+    }
+    module2.exports = patch(clone(fs7));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs7.__patched) {
+      module2.exports = patch(fs7);
+      fs7.__patched = true;
+    }
+    function patch(fs8) {
+      polyfills(fs8);
+      fs8.gracefulify = patch;
+      fs8.createReadStream = createReadStream;
+      fs8.createWriteStream = createWriteStream;
+      var fs$readFile = fs8.readFile;
+      fs8.readFile = readFile4;
       function readFile4(path7, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
@@ -2911,8 +2911,8 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$writeFile = fs7.writeFile;
-      fs7.writeFile = writeFile;
+      var fs$writeFile = fs8.writeFile;
+      fs8.writeFile = writeFile;
       function writeFile(path7, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
@@ -2928,9 +2928,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$appendFile = fs7.appendFile;
+      var fs$appendFile = fs8.appendFile;
       if (fs$appendFile)
-        fs7.appendFile = appendFile;
+        fs8.appendFile = appendFile;
       function appendFile(path7, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
@@ -2946,9 +2946,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$copyFile = fs7.copyFile;
+      var fs$copyFile = fs8.copyFile;
       if (fs$copyFile)
-        fs7.copyFile = copyFile;
+        fs8.copyFile = copyFile;
       function copyFile(src, dest, flags, cb) {
         if (typeof flags === "function") {
           cb = flags;
@@ -2966,8 +2966,8 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$readdir = fs7.readdir;
-      fs7.readdir = readdir;
+      var fs$readdir = fs8.readdir;
+      fs8.readdir = readdir;
       var noReaddirOptionVersions = /^v[0-5]\./;
       function readdir(path7, options, cb) {
         if (typeof options === "function")
@@ -3008,21 +3008,21 @@ var require_graceful_fs = __commonJS({
         }
       }
       if (process.version.substr(0, 4) === "v0.8") {
-        var legStreams = legacy(fs7);
+        var legStreams = legacy(fs8);
         ReadStream = legStreams.ReadStream;
         WriteStream = legStreams.WriteStream;
       }
-      var fs$ReadStream = fs7.ReadStream;
+      var fs$ReadStream = fs8.ReadStream;
       if (fs$ReadStream) {
         ReadStream.prototype = Object.create(fs$ReadStream.prototype);
         ReadStream.prototype.open = ReadStream$open;
       }
-      var fs$WriteStream = fs7.WriteStream;
+      var fs$WriteStream = fs8.WriteStream;
       if (fs$WriteStream) {
         WriteStream.prototype = Object.create(fs$WriteStream.prototype);
         WriteStream.prototype.open = WriteStream$open;
       }
-      Object.defineProperty(fs7, "ReadStream", {
+      Object.defineProperty(fs8, "ReadStream", {
         get: function() {
           return ReadStream;
         },
@@ -3032,7 +3032,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      Object.defineProperty(fs7, "WriteStream", {
+      Object.defineProperty(fs8, "WriteStream", {
         get: function() {
           return WriteStream;
         },
@@ -3043,7 +3043,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileReadStream = ReadStream;
-      Object.defineProperty(fs7, "FileReadStream", {
+      Object.defineProperty(fs8, "FileReadStream", {
         get: function() {
           return FileReadStream;
         },
@@ -3054,7 +3054,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileWriteStream = WriteStream;
-      Object.defineProperty(fs7, "FileWriteStream", {
+      Object.defineProperty(fs8, "FileWriteStream", {
         get: function() {
           return FileWriteStream;
         },
@@ -3103,13 +3103,13 @@ var require_graceful_fs = __commonJS({
         });
       }
       function createReadStream(path7, options) {
-        return new fs7.ReadStream(path7, options);
+        return new fs8.ReadStream(path7, options);
       }
       function createWriteStream(path7, options) {
-        return new fs7.WriteStream(path7, options);
+        return new fs8.WriteStream(path7, options);
       }
-      var fs$open = fs7.open;
-      fs7.open = open;
+      var fs$open = fs8.open;
+      fs8.open = open;
       function open(path7, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
@@ -3125,20 +3125,20 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      return fs7;
+      return fs8;
     }
     function enqueue(elem) {
       debug2("ENQUEUE", elem[0].name, elem[1]);
-      fs6[gracefulQueue].push(elem);
+      fs7[gracefulQueue].push(elem);
       retry2();
     }
     var retryTimer;
     function resetQueue() {
       var now = Date.now();
-      for (var i = 0; i < fs6[gracefulQueue].length; ++i) {
-        if (fs6[gracefulQueue][i].length > 2) {
-          fs6[gracefulQueue][i][3] = now;
-          fs6[gracefulQueue][i][4] = now;
+      for (var i = 0; i < fs7[gracefulQueue].length; ++i) {
+        if (fs7[gracefulQueue][i].length > 2) {
+          fs7[gracefulQueue][i][3] = now;
+          fs7[gracefulQueue][i][4] = now;
         }
       }
       retry2();
@@ -3146,9 +3146,9 @@ var require_graceful_fs = __commonJS({
     function retry2() {
       clearTimeout(retryTimer);
       retryTimer = void 0;
-      if (fs6[gracefulQueue].length === 0)
+      if (fs7[gracefulQueue].length === 0)
         return;
-      var elem = fs6[gracefulQueue].shift();
+      var elem = fs7[gracefulQueue].shift();
       var fn = elem[0];
       var args = elem[1];
       var err = elem[2];
@@ -3170,7 +3170,7 @@ var require_graceful_fs = __commonJS({
           debug2("RETRY", fn.name, args);
           fn.apply(null, args.concat([startTime]));
         } else {
-          fs6[gracefulQueue].push(elem);
+          fs7[gracefulQueue].push(elem);
         }
       }
       if (retryTimer === void 0) {
@@ -3185,7 +3185,7 @@ var require_fs = __commonJS({
   "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/fs/index.js"(exports2) {
     "use strict";
     var u = require_universalify().fromCallback;
-    var fs6 = require_graceful_fs();
+    var fs7 = require_graceful_fs();
     var api = [
       "access",
       "appendFile",
@@ -3222,27 +3222,27 @@ var require_fs = __commonJS({
       "utimes",
       "writeFile"
     ].filter((key) => {
-      return typeof fs6[key] === "function";
+      return typeof fs7[key] === "function";
     });
-    Object.assign(exports2, fs6);
+    Object.assign(exports2, fs7);
     api.forEach((method) => {
-      exports2[method] = u(fs6[method]);
+      exports2[method] = u(fs7[method]);
     });
-    exports2.realpath.native = u(fs6.realpath.native);
+    exports2.realpath.native = u(fs7.realpath.native);
     exports2.exists = function(filename, callback) {
       if (typeof callback === "function") {
-        return fs6.exists(filename, callback);
+        return fs7.exists(filename, callback);
       }
       return new Promise((resolve) => {
-        return fs6.exists(filename, resolve);
+        return fs7.exists(filename, resolve);
       });
     };
     exports2.read = function(fd, buffer, offset, length, position, callback) {
       if (typeof callback === "function") {
-        return fs6.read(fd, buffer, offset, length, position, callback);
+        return fs7.read(fd, buffer, offset, length, position, callback);
       }
       return new Promise((resolve, reject) => {
-        fs6.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
+        fs7.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
           if (err)
             return reject(err);
           resolve({ bytesRead, buffer: buffer2 });
@@ -3251,23 +3251,23 @@ var require_fs = __commonJS({
     };
     exports2.write = function(fd, buffer, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs6.write(fd, buffer, ...args);
+        return fs7.write(fd, buffer, ...args);
       }
       return new Promise((resolve, reject) => {
-        fs6.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
+        fs7.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
           if (err)
             return reject(err);
           resolve({ bytesWritten, buffer: buffer2 });
         });
       });
     };
-    if (typeof fs6.writev === "function") {
+    if (typeof fs7.writev === "function") {
       exports2.writev = function(fd, buffers, ...args) {
         if (typeof args[args.length - 1] === "function") {
-          return fs6.writev(fd, buffers, ...args);
+          return fs7.writev(fd, buffers, ...args);
         }
         return new Promise((resolve, reject) => {
-          fs6.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
+          fs7.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
             if (err)
               return reject(err);
             resolve({ bytesWritten, buffers: buffers2 });
@@ -3300,7 +3300,7 @@ var require_utils = __commonJS({
 var require_make_dir = __commonJS({
   "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/mkdirs/make-dir.js"(exports2, module2) {
     "use strict";
-    var fs6 = require_fs();
+    var fs7 = require_fs();
     var { checkPath } = require_utils();
     var getMode = (options) => {
       const defaults = { mode: 511 };
@@ -3310,14 +3310,14 @@ var require_make_dir = __commonJS({
     };
     module2.exports.makeDir = async (dir, options) => {
       checkPath(dir);
-      return fs6.mkdir(dir, {
+      return fs7.mkdir(dir, {
         mode: getMode(options),
         recursive: true
       });
     };
     module2.exports.makeDirSync = (dir, options) => {
       checkPath(dir);
-      return fs6.mkdirSync(dir, {
+      return fs7.mkdirSync(dir, {
         mode: getMode(options),
         recursive: true
       });
@@ -3348,13 +3348,13 @@ var require_mkdirs = __commonJS({
 var require_utimes = __commonJS({
   "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/util/utimes.js"(exports2, module2) {
     "use strict";
-    var fs6 = require_graceful_fs();
+    var fs7 = require_graceful_fs();
     function utimesMillis(path7, atime, mtime2, callback) {
-      fs6.open(path7, "r+", (err, fd) => {
+      fs7.open(path7, "r+", (err, fd) => {
         if (err)
           return callback(err);
-        fs6.futimes(fd, atime, mtime2, (futimesErr) => {
-          fs6.close(fd, (closeErr) => {
+        fs7.futimes(fd, atime, mtime2, (futimesErr) => {
+          fs7.close(fd, (closeErr) => {
             if (callback)
               callback(futimesErr || closeErr);
           });
@@ -3362,9 +3362,9 @@ var require_utimes = __commonJS({
       });
     }
     function utimesMillisSync(path7, atime, mtime2) {
-      const fd = fs6.openSync(path7, "r+");
-      fs6.futimesSync(fd, atime, mtime2);
-      return fs6.closeSync(fd);
+      const fd = fs7.openSync(path7, "r+");
+      fs7.futimesSync(fd, atime, mtime2);
+      return fs7.closeSync(fd);
     }
     module2.exports = {
       utimesMillis,
@@ -3377,11 +3377,11 @@ var require_utimes = __commonJS({
 var require_stat = __commonJS({
   "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/util/stat.js"(exports2, module2) {
     "use strict";
-    var fs6 = require_fs();
+    var fs7 = require_fs();
     var path7 = require("path");
     var util = require("util");
     function getStats(src, dest, opts) {
-      const statFunc = opts.dereference ? (file) => fs6.stat(file, { bigint: true }) : (file) => fs6.lstat(file, { bigint: true });
+      const statFunc = opts.dereference ? (file) => fs7.stat(file, { bigint: true }) : (file) => fs7.lstat(file, { bigint: true });
       return Promise.all([
         statFunc(src),
         statFunc(dest).catch((err) => {
@@ -3393,7 +3393,7 @@ var require_stat = __commonJS({
     }
     function getStatsSync(src, dest, opts) {
       let destStat;
-      const statFunc = opts.dereference ? (file) => fs6.statSync(file, { bigint: true }) : (file) => fs6.lstatSync(file, { bigint: true });
+      const statFunc = opts.dereference ? (file) => fs7.statSync(file, { bigint: true }) : (file) => fs7.lstatSync(file, { bigint: true });
       const srcStat = statFunc(src);
       try {
         destStat = statFunc(dest);
@@ -3459,7 +3459,7 @@ var require_stat = __commonJS({
       const destParent = path7.resolve(path7.dirname(dest));
       if (destParent === srcParent || destParent === path7.parse(destParent).root)
         return cb();
-      fs6.stat(destParent, { bigint: true }, (err, destStat) => {
+      fs7.stat(destParent, { bigint: true }, (err, destStat) => {
         if (err) {
           if (err.code === "ENOENT")
             return cb();
@@ -3478,7 +3478,7 @@ var require_stat = __commonJS({
         return;
       let destStat;
       try {
-        destStat = fs6.statSync(destParent, { bigint: true });
+        destStat = fs7.statSync(destParent, { bigint: true });
       } catch (err) {
         if (err.code === "ENOENT")
           return;
@@ -3515,7 +3515,7 @@ var require_stat = __commonJS({
 var require_copy_sync = __commonJS({
   "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/copy-sync/copy-sync.js"(exports2, module2) {
     "use strict";
-    var fs6 = require_graceful_fs();
+    var fs7 = require_graceful_fs();
     var path7 = require("path");
     var mkdirsSync = require_mkdirs().mkdirsSync;
     var utimesMillisSync = require_utimes().utimesMillisSync;
@@ -3540,7 +3540,7 @@ var require_copy_sync = __commonJS({
       if (opts.filter && !opts.filter(src, dest))
         return;
       const destParent = path7.dirname(dest);
-      if (!fs6.existsSync(destParent))
+      if (!fs7.existsSync(destParent))
         mkdirsSync(destParent);
       return getStats(destStat, src, dest, opts);
     }
@@ -3550,7 +3550,7 @@ var require_copy_sync = __commonJS({
       return getStats(destStat, src, dest, opts);
     }
     function getStats(destStat, src, dest, opts) {
-      const statSync2 = opts.dereference ? fs6.statSync : fs6.lstatSync;
+      const statSync2 = opts.dereference ? fs7.statSync : fs7.lstatSync;
       const srcStat = statSync2(src);
       if (srcStat.isDirectory())
         return onDir(srcStat, destStat, src, dest, opts);
@@ -3571,14 +3571,14 @@ var require_copy_sync = __commonJS({
     }
     function mayCopyFile(srcStat, src, dest, opts) {
       if (opts.overwrite) {
-        fs6.unlinkSync(dest);
+        fs7.unlinkSync(dest);
         return copyFile(srcStat, src, dest, opts);
       } else if (opts.errorOnExist) {
         throw new Error(`'${dest}' already exists`);
       }
     }
     function copyFile(srcStat, src, dest, opts) {
-      fs6.copyFileSync(src, dest);
+      fs7.copyFileSync(src, dest);
       if (opts.preserveTimestamps)
         handleTimestamps(srcStat.mode, src, dest);
       return setDestMode(dest, srcStat.mode);
@@ -3595,10 +3595,10 @@ var require_copy_sync = __commonJS({
       return setDestMode(dest, srcMode | 128);
     }
     function setDestMode(dest, srcMode) {
-      return fs6.chmodSync(dest, srcMode);
+      return fs7.chmodSync(dest, srcMode);
     }
     function setDestTimestamps(src, dest) {
-      const updatedSrcStat = fs6.statSync(src);
+      const updatedSrcStat = fs7.statSync(src);
       return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
     }
     function onDir(srcStat, destStat, src, dest, opts) {
@@ -3607,12 +3607,12 @@ var require_copy_sync = __commonJS({
       return copyDir(src, dest, opts);
     }
     function mkDirAndCopy(srcMode, src, dest, opts) {
-      fs6.mkdirSync(dest);
+      fs7.mkdirSync(dest);
       copyDir(src, dest, opts);
       return setDestMode(dest, srcMode);
     }
     function copyDir(src, dest, opts) {
-      fs6.readdirSync(src).forEach((item) => copyDirItem(item, src, dest, opts));
+      fs7.readdirSync(src).forEach((item) => copyDirItem(item, src, dest, opts));
     }
     function copyDirItem(item, src, dest, opts) {
       const srcItem = path7.join(src, item);
@@ -3621,19 +3621,19 @@ var require_copy_sync = __commonJS({
       return startCopy(destStat, srcItem, destItem, opts);
     }
     function onLink(destStat, src, dest, opts) {
-      let resolvedSrc = fs6.readlinkSync(src);
+      let resolvedSrc = fs7.readlinkSync(src);
       if (opts.dereference) {
         resolvedSrc = path7.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
-        return fs6.symlinkSync(resolvedSrc, dest);
+        return fs7.symlinkSync(resolvedSrc, dest);
       } else {
         let resolvedDest;
         try {
-          resolvedDest = fs6.readlinkSync(dest);
+          resolvedDest = fs7.readlinkSync(dest);
         } catch (err) {
           if (err.code === "EINVAL" || err.code === "UNKNOWN")
-            return fs6.symlinkSync(resolvedSrc, dest);
+            return fs7.symlinkSync(resolvedSrc, dest);
           throw err;
         }
         if (opts.dereference) {
@@ -3642,15 +3642,15 @@ var require_copy_sync = __commonJS({
         if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
           throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
         }
-        if (fs6.statSync(dest).isDirectory() && stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
+        if (fs7.statSync(dest).isDirectory() && stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
           throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
         }
         return copyLink(resolvedSrc, dest);
       }
     }
     function copyLink(resolvedSrc, dest) {
-      fs6.unlinkSync(dest);
-      return fs6.symlinkSync(resolvedSrc, dest);
+      fs7.unlinkSync(dest);
+      return fs7.symlinkSync(resolvedSrc, dest);
     }
     module2.exports = copySync;
   }
@@ -3671,13 +3671,13 @@ var require_path_exists = __commonJS({
   "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/path-exists/index.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs6 = require_fs();
+    var fs7 = require_fs();
     function pathExists(path7) {
-      return fs6.access(path7).then(() => true).catch(() => false);
+      return fs7.access(path7).then(() => true).catch(() => false);
     }
     module2.exports = {
       pathExists: u(pathExists),
-      pathExistsSync: fs6.existsSync
+      pathExistsSync: fs7.existsSync
     };
   }
 });
@@ -3686,7 +3686,7 @@ var require_path_exists = __commonJS({
 var require_copy = __commonJS({
   "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/copy/copy.js"(exports2, module2) {
     "use strict";
-    var fs6 = require_graceful_fs();
+    var fs7 = require_graceful_fs();
     var path7 = require("path");
     var mkdirs = require_mkdirs().mkdirs;
     var pathExists = require_path_exists().pathExists;
@@ -3749,7 +3749,7 @@ var require_copy = __commonJS({
       return getStats(destStat, src, dest, opts, cb);
     }
     function getStats(destStat, src, dest, opts, cb) {
-      const stat2 = opts.dereference ? fs6.stat : fs6.lstat;
+      const stat2 = opts.dereference ? fs7.stat : fs7.lstat;
       stat2(src, (err, srcStat) => {
         if (err)
           return cb(err);
@@ -3773,7 +3773,7 @@ var require_copy = __commonJS({
     }
     function mayCopyFile(srcStat, src, dest, opts, cb) {
       if (opts.overwrite) {
-        fs6.unlink(dest, (err) => {
+        fs7.unlink(dest, (err) => {
           if (err)
             return cb(err);
           return copyFile(srcStat, src, dest, opts, cb);
@@ -3784,7 +3784,7 @@ var require_copy = __commonJS({
         return cb();
     }
     function copyFile(srcStat, src, dest, opts, cb) {
-      fs6.copyFile(src, dest, (err) => {
+      fs7.copyFile(src, dest, (err) => {
         if (err)
           return cb(err);
         if (opts.preserveTimestamps)
@@ -3816,10 +3816,10 @@ var require_copy = __commonJS({
       });
     }
     function setDestMode(dest, srcMode, cb) {
-      return fs6.chmod(dest, srcMode, cb);
+      return fs7.chmod(dest, srcMode, cb);
     }
     function setDestTimestamps(src, dest, cb) {
-      fs6.stat(src, (err, updatedSrcStat) => {
+      fs7.stat(src, (err, updatedSrcStat) => {
         if (err)
           return cb(err);
         return utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime, cb);
@@ -3831,7 +3831,7 @@ var require_copy = __commonJS({
       return copyDir(src, dest, opts, cb);
     }
     function mkDirAndCopy(srcMode, src, dest, opts, cb) {
-      fs6.mkdir(dest, (err) => {
+      fs7.mkdir(dest, (err) => {
         if (err)
           return cb(err);
         copyDir(src, dest, opts, (err2) => {
@@ -3842,7 +3842,7 @@ var require_copy = __commonJS({
       });
     }
     function copyDir(src, dest, opts, cb) {
-      fs6.readdir(src, (err, items) => {
+      fs7.readdir(src, (err, items) => {
         if (err)
           return cb(err);
         return copyDirItems(items, src, dest, opts, cb);
@@ -3869,19 +3869,19 @@ var require_copy = __commonJS({
       });
     }
     function onLink(destStat, src, dest, opts, cb) {
-      fs6.readlink(src, (err, resolvedSrc) => {
+      fs7.readlink(src, (err, resolvedSrc) => {
         if (err)
           return cb(err);
         if (opts.dereference) {
           resolvedSrc = path7.resolve(process.cwd(), resolvedSrc);
         }
         if (!destStat) {
-          return fs6.symlink(resolvedSrc, dest, cb);
+          return fs7.symlink(resolvedSrc, dest, cb);
         } else {
-          fs6.readlink(dest, (err2, resolvedDest) => {
+          fs7.readlink(dest, (err2, resolvedDest) => {
             if (err2) {
               if (err2.code === "EINVAL" || err2.code === "UNKNOWN")
-                return fs6.symlink(resolvedSrc, dest, cb);
+                return fs7.symlink(resolvedSrc, dest, cb);
               return cb(err2);
             }
             if (opts.dereference) {
@@ -3899,10 +3899,10 @@ var require_copy = __commonJS({
       });
     }
     function copyLink(resolvedSrc, dest, cb) {
-      fs6.unlink(dest, (err) => {
+      fs7.unlink(dest, (err) => {
         if (err)
           return cb(err);
-        return fs6.symlink(resolvedSrc, dest, cb);
+        return fs7.symlink(resolvedSrc, dest, cb);
       });
     }
     module2.exports = copy;
@@ -3924,7 +3924,7 @@ var require_copy2 = __commonJS({
 var require_rimraf = __commonJS({
   "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/remove/rimraf.js"(exports2, module2) {
     "use strict";
-    var fs6 = require_graceful_fs();
+    var fs7 = require_graceful_fs();
     var path7 = require("path");
     var assert7 = require("assert");
     var isWindows = process.platform === "win32";
@@ -3938,9 +3938,9 @@ var require_rimraf = __commonJS({
         "readdir"
       ];
       methods.forEach((m) => {
-        options[m] = options[m] || fs6[m];
+        options[m] = options[m] || fs7[m];
         m = m + "Sync";
-        options[m] = options[m] || fs6[m];
+        options[m] = options[m] || fs7[m];
       });
       options.maxBusyTries = options.maxBusyTries || 3;
     }
@@ -4163,17 +4163,17 @@ var require_rimraf = __commonJS({
 var require_remove = __commonJS({
   "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/remove/index.js"(exports2, module2) {
     "use strict";
-    var fs6 = require_graceful_fs();
+    var fs7 = require_graceful_fs();
     var u = require_universalify().fromCallback;
     var rimraf = require_rimraf();
     function remove2(path7, callback) {
-      if (fs6.rm)
-        return fs6.rm(path7, { recursive: true, force: true }, callback);
+      if (fs7.rm)
+        return fs7.rm(path7, { recursive: true, force: true }, callback);
       rimraf(path7, callback);
     }
     function removeSync(path7) {
-      if (fs6.rmSync)
-        return fs6.rmSync(path7, { recursive: true, force: true });
+      if (fs7.rmSync)
+        return fs7.rmSync(path7, { recursive: true, force: true });
       rimraf.sync(path7);
     }
     module2.exports = {
@@ -4188,14 +4188,14 @@ var require_empty = __commonJS({
   "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/empty/index.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs6 = require_fs();
+    var fs7 = require_fs();
     var path7 = require("path");
     var mkdir = require_mkdirs();
     var remove2 = require_remove();
     var emptyDir = u(async function emptyDir2(dir) {
       let items;
       try {
-        items = await fs6.readdir(dir);
+        items = await fs7.readdir(dir);
       } catch {
         return mkdir.mkdirs(dir);
       }
@@ -4204,7 +4204,7 @@ var require_empty = __commonJS({
     function emptyDirSync(dir) {
       let items;
       try {
-        items = fs6.readdirSync(dir);
+        items = fs7.readdirSync(dir);
       } catch {
         return mkdir.mkdirsSync(dir);
       }
@@ -4228,21 +4228,21 @@ var require_file = __commonJS({
     "use strict";
     var u = require_universalify().fromCallback;
     var path7 = require("path");
-    var fs6 = require_graceful_fs();
+    var fs7 = require_graceful_fs();
     var mkdir = require_mkdirs();
     function createFile(file, callback) {
       function makeFile() {
-        fs6.writeFile(file, "", (err) => {
+        fs7.writeFile(file, "", (err) => {
           if (err)
             return callback(err);
           callback();
         });
       }
-      fs6.stat(file, (err, stats) => {
+      fs7.stat(file, (err, stats) => {
         if (!err && stats.isFile())
           return callback();
         const dir = path7.dirname(file);
-        fs6.stat(dir, (err2, stats2) => {
+        fs7.stat(dir, (err2, stats2) => {
           if (err2) {
             if (err2.code === "ENOENT") {
               return mkdir.mkdirs(dir, (err3) => {
@@ -4256,7 +4256,7 @@ var require_file = __commonJS({
           if (stats2.isDirectory())
             makeFile();
           else {
-            fs6.readdir(dir, (err3) => {
+            fs7.readdir(dir, (err3) => {
               if (err3)
                 return callback(err3);
             });
@@ -4267,15 +4267,15 @@ var require_file = __commonJS({
     function createFileSync(file) {
       let stats;
       try {
-        stats = fs6.statSync(file);
+        stats = fs7.statSync(file);
       } catch {
       }
       if (stats && stats.isFile())
         return;
       const dir = path7.dirname(file);
       try {
-        if (!fs6.statSync(dir).isDirectory()) {
-          fs6.readdirSync(dir);
+        if (!fs7.statSync(dir).isDirectory()) {
+          fs7.readdirSync(dir);
         }
       } catch (err) {
         if (err && err.code === "ENOENT")
@@ -4283,7 +4283,7 @@ var require_file = __commonJS({
         else
           throw err;
       }
-      fs6.writeFileSync(file, "");
+      fs7.writeFileSync(file, "");
     }
     module2.exports = {
       createFile: u(createFile),
@@ -4298,20 +4298,20 @@ var require_link = __commonJS({
     "use strict";
     var u = require_universalify().fromCallback;
     var path7 = require("path");
-    var fs6 = require_graceful_fs();
+    var fs7 = require_graceful_fs();
     var mkdir = require_mkdirs();
     var pathExists = require_path_exists().pathExists;
     var { areIdentical } = require_stat();
     function createLink(srcpath, dstpath, callback) {
       function makeLink(srcpath2, dstpath2) {
-        fs6.link(srcpath2, dstpath2, (err) => {
+        fs7.link(srcpath2, dstpath2, (err) => {
           if (err)
             return callback(err);
           callback(null);
         });
       }
-      fs6.lstat(dstpath, (_, dstStat) => {
-        fs6.lstat(srcpath, (err, srcStat) => {
+      fs7.lstat(dstpath, (_, dstStat) => {
+        fs7.lstat(srcpath, (err, srcStat) => {
           if (err) {
             err.message = err.message.replace("lstat", "ensureLink");
             return callback(err);
@@ -4336,11 +4336,11 @@ var require_link = __commonJS({
     function createLinkSync(srcpath, dstpath) {
       let dstStat;
       try {
-        dstStat = fs6.lstatSync(dstpath);
+        dstStat = fs7.lstatSync(dstpath);
       } catch {
       }
       try {
-        const srcStat = fs6.lstatSync(srcpath);
+        const srcStat = fs7.lstatSync(srcpath);
         if (dstStat && areIdentical(srcStat, dstStat))
           return;
       } catch (err) {
@@ -4348,11 +4348,11 @@ var require_link = __commonJS({
         throw err;
       }
       const dir = path7.dirname(dstpath);
-      const dirExists = fs6.existsSync(dir);
+      const dirExists = fs7.existsSync(dir);
       if (dirExists)
-        return fs6.linkSync(srcpath, dstpath);
+        return fs7.linkSync(srcpath, dstpath);
       mkdir.mkdirsSync(dir);
-      return fs6.linkSync(srcpath, dstpath);
+      return fs7.linkSync(srcpath, dstpath);
     }
     module2.exports = {
       createLink: u(createLink),
@@ -4366,11 +4366,11 @@ var require_symlink_paths = __commonJS({
   "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports2, module2) {
     "use strict";
     var path7 = require("path");
-    var fs6 = require_graceful_fs();
+    var fs7 = require_graceful_fs();
     var pathExists = require_path_exists().pathExists;
     function symlinkPaths(srcpath, dstpath, callback) {
       if (path7.isAbsolute(srcpath)) {
-        return fs6.lstat(srcpath, (err) => {
+        return fs7.lstat(srcpath, (err) => {
           if (err) {
             err.message = err.message.replace("lstat", "ensureSymlink");
             return callback(err);
@@ -4392,7 +4392,7 @@ var require_symlink_paths = __commonJS({
               toDst: srcpath
             });
           } else {
-            return fs6.lstat(srcpath, (err2) => {
+            return fs7.lstat(srcpath, (err2) => {
               if (err2) {
                 err2.message = err2.message.replace("lstat", "ensureSymlink");
                 return callback(err2);
@@ -4409,7 +4409,7 @@ var require_symlink_paths = __commonJS({
     function symlinkPathsSync(srcpath, dstpath) {
       let exists;
       if (path7.isAbsolute(srcpath)) {
-        exists = fs6.existsSync(srcpath);
+        exists = fs7.existsSync(srcpath);
         if (!exists)
           throw new Error("absolute srcpath does not exist");
         return {
@@ -4419,14 +4419,14 @@ var require_symlink_paths = __commonJS({
       } else {
         const dstdir = path7.dirname(dstpath);
         const relativeToDst = path7.join(dstdir, srcpath);
-        exists = fs6.existsSync(relativeToDst);
+        exists = fs7.existsSync(relativeToDst);
         if (exists) {
           return {
             toCwd: relativeToDst,
             toDst: srcpath
           };
         } else {
-          exists = fs6.existsSync(srcpath);
+          exists = fs7.existsSync(srcpath);
           if (!exists)
             throw new Error("relative srcpath does not exist");
           return {
@@ -4447,13 +4447,13 @@ var require_symlink_paths = __commonJS({
 var require_symlink_type = __commonJS({
   "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/ensure/symlink-type.js"(exports2, module2) {
     "use strict";
-    var fs6 = require_graceful_fs();
+    var fs7 = require_graceful_fs();
     function symlinkType(srcpath, type, callback) {
       callback = typeof type === "function" ? type : callback;
       type = typeof type === "function" ? false : type;
       if (type)
         return callback(null, type);
-      fs6.lstat(srcpath, (err, stats) => {
+      fs7.lstat(srcpath, (err, stats) => {
         if (err)
           return callback(null, "file");
         type = stats && stats.isDirectory() ? "dir" : "file";
@@ -4465,7 +4465,7 @@ var require_symlink_type = __commonJS({
       if (type)
         return type;
       try {
-        stats = fs6.lstatSync(srcpath);
+        stats = fs7.lstatSync(srcpath);
       } catch {
         return "file";
       }
@@ -4484,7 +4484,7 @@ var require_symlink = __commonJS({
     "use strict";
     var u = require_universalify().fromCallback;
     var path7 = require("path");
-    var fs6 = require_fs();
+    var fs7 = require_fs();
     var _mkdirs = require_mkdirs();
     var mkdirs = _mkdirs.mkdirs;
     var mkdirsSync = _mkdirs.mkdirsSync;
@@ -4499,11 +4499,11 @@ var require_symlink = __commonJS({
     function createSymlink(srcpath, dstpath, type, callback) {
       callback = typeof type === "function" ? type : callback;
       type = typeof type === "function" ? false : type;
-      fs6.lstat(dstpath, (err, stats) => {
+      fs7.lstat(dstpath, (err, stats) => {
         if (!err && stats.isSymbolicLink()) {
           Promise.all([
-            fs6.stat(srcpath),
-            fs6.stat(dstpath)
+            fs7.stat(srcpath),
+            fs7.stat(dstpath)
           ]).then(([srcStat, dstStat]) => {
             if (areIdentical(srcStat, dstStat))
               return callback(null);
@@ -4526,11 +4526,11 @@ var require_symlink = __commonJS({
             if (err3)
               return callback(err3);
             if (dirExists)
-              return fs6.symlink(srcpath, dstpath, type2, callback);
+              return fs7.symlink(srcpath, dstpath, type2, callback);
             mkdirs(dir, (err4) => {
               if (err4)
                 return callback(err4);
-              fs6.symlink(srcpath, dstpath, type2, callback);
+              fs7.symlink(srcpath, dstpath, type2, callback);
             });
           });
         });
@@ -4539,12 +4539,12 @@ var require_symlink = __commonJS({
     function createSymlinkSync(srcpath, dstpath, type) {
       let stats;
       try {
-        stats = fs6.lstatSync(dstpath);
+        stats = fs7.lstatSync(dstpath);
       } catch {
       }
       if (stats && stats.isSymbolicLink()) {
-        const srcStat = fs6.statSync(srcpath);
-        const dstStat = fs6.statSync(dstpath);
+        const srcStat = fs7.statSync(srcpath);
+        const dstStat = fs7.statSync(dstpath);
         if (areIdentical(srcStat, dstStat))
           return;
       }
@@ -4552,11 +4552,11 @@ var require_symlink = __commonJS({
       srcpath = relative.toDst;
       type = symlinkTypeSync(relative.toCwd, type);
       const dir = path7.dirname(dstpath);
-      const exists = fs6.existsSync(dir);
+      const exists = fs7.existsSync(dir);
       if (exists)
-        return fs6.symlinkSync(srcpath, dstpath, type);
+        return fs7.symlinkSync(srcpath, dstpath, type);
       mkdirsSync(dir);
-      return fs6.symlinkSync(srcpath, dstpath, type);
+      return fs7.symlinkSync(srcpath, dstpath, type);
     }
     module2.exports = {
       createSymlink: u(createSymlink),
@@ -4624,9 +4624,9 @@ var require_jsonfile = __commonJS({
       if (typeof options === "string") {
         options = { encoding: options };
       }
-      const fs6 = options.fs || _fs;
+      const fs7 = options.fs || _fs;
       const shouldThrow = "throws" in options ? options.throws : true;
-      let data = await universalify.fromCallback(fs6.readFile)(file, options);
+      let data = await universalify.fromCallback(fs7.readFile)(file, options);
       data = stripBom(data);
       let obj;
       try {
@@ -4646,10 +4646,10 @@ var require_jsonfile = __commonJS({
       if (typeof options === "string") {
         options = { encoding: options };
       }
-      const fs6 = options.fs || _fs;
+      const fs7 = options.fs || _fs;
       const shouldThrow = "throws" in options ? options.throws : true;
       try {
-        let content = fs6.readFileSync(file, options);
+        let content = fs7.readFileSync(file, options);
         content = stripBom(content);
         return JSON.parse(content, options.reviver);
       } catch (err) {
@@ -4662,15 +4662,15 @@ var require_jsonfile = __commonJS({
       }
     }
     async function _writeFile(file, obj, options = {}) {
-      const fs6 = options.fs || _fs;
+      const fs7 = options.fs || _fs;
       const str = stringify(obj, options);
-      await universalify.fromCallback(fs6.writeFile)(file, str, options);
+      await universalify.fromCallback(fs7.writeFile)(file, str, options);
     }
     var writeFile = universalify.fromPromise(_writeFile);
     function writeFileSync(file, obj, options = {}) {
-      const fs6 = options.fs || _fs;
+      const fs7 = options.fs || _fs;
       const str = stringify(obj, options);
-      return fs6.writeFileSync(file, str, options);
+      return fs7.writeFileSync(file, str, options);
     }
     var jsonfile = {
       readFile: readFile4,
@@ -4702,7 +4702,7 @@ var require_output = __commonJS({
   "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/output/index.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromCallback;
-    var fs6 = require_graceful_fs();
+    var fs7 = require_graceful_fs();
     var path7 = require("path");
     var mkdir = require_mkdirs();
     var pathExists = require_path_exists().pathExists;
@@ -4716,21 +4716,21 @@ var require_output = __commonJS({
         if (err)
           return callback(err);
         if (itDoes)
-          return fs6.writeFile(file, data, encoding, callback);
+          return fs7.writeFile(file, data, encoding, callback);
         mkdir.mkdirs(dir, (err2) => {
           if (err2)
             return callback(err2);
-          fs6.writeFile(file, data, encoding, callback);
+          fs7.writeFile(file, data, encoding, callback);
         });
       });
     }
     function outputFileSync(file, ...args) {
       const dir = path7.dirname(file);
-      if (fs6.existsSync(dir)) {
-        return fs6.writeFileSync(file, ...args);
+      if (fs7.existsSync(dir)) {
+        return fs7.writeFileSync(file, ...args);
       }
       mkdir.mkdirsSync(dir);
-      fs6.writeFileSync(file, ...args);
+      fs7.writeFileSync(file, ...args);
     }
     module2.exports = {
       outputFile: u(outputFile),
@@ -4789,7 +4789,7 @@ var require_json = __commonJS({
 var require_move_sync = __commonJS({
   "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/move-sync/move-sync.js"(exports2, module2) {
     "use strict";
-    var fs6 = require_graceful_fs();
+    var fs7 = require_graceful_fs();
     var path7 = require("path");
     var copySync = require_copy_sync2().copySync;
     var removeSync = require_remove().removeSync;
@@ -4816,13 +4816,13 @@ var require_move_sync = __commonJS({
         removeSync(dest);
         return rename2(src, dest, overwrite);
       }
-      if (fs6.existsSync(dest))
+      if (fs7.existsSync(dest))
         throw new Error("dest already exists.");
       return rename2(src, dest, overwrite);
     }
     function rename2(src, dest, overwrite) {
       try {
-        fs6.renameSync(src, dest);
+        fs7.renameSync(src, dest);
       } catch (err) {
         if (err.code !== "EXDEV")
           throw err;
@@ -4855,7 +4855,7 @@ var require_move_sync2 = __commonJS({
 var require_move = __commonJS({
   "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/move/move.js"(exports2, module2) {
     "use strict";
-    var fs6 = require_graceful_fs();
+    var fs7 = require_graceful_fs();
     var path7 = require("path");
     var copy = require_copy2().copy;
     var remove2 = require_remove().remove;
@@ -4909,7 +4909,7 @@ var require_move = __commonJS({
       });
     }
     function rename2(src, dest, overwrite, cb) {
-      fs6.rename(src, dest, (err) => {
+      fs7.rename(src, dest, (err) => {
         if (!err)
           return cb();
         if (err.code !== "EXDEV")
@@ -8953,7 +8953,7 @@ var require_buffer_crc32 = __commonJS({
 // ../../node_modules/.pnpm/yazl@2.5.1/node_modules/yazl/index.js
 var require_yazl = __commonJS({
   "../../node_modules/.pnpm/yazl@2.5.1/node_modules/yazl/index.js"(exports2) {
-    var fs6 = require("fs");
+    var fs7 = require("fs");
     var Transform = require("stream").Transform;
     var PassThrough = require("stream").PassThrough;
     var zlib = require("zlib");
@@ -8978,7 +8978,7 @@ var require_yazl = __commonJS({
         options = {};
       var entry = new Entry(metadataPath, false, options);
       self2.entries.push(entry);
-      fs6.stat(realPath, function(err, stats) {
+      fs7.stat(realPath, function(err, stats) {
         if (err)
           return self2.emit("error", err);
         if (!stats.isFile())
@@ -8989,7 +8989,7 @@ var require_yazl = __commonJS({
         if (options.mode == null)
           entry.setFileAttributesMode(stats.mode);
         entry.setFileDataPumpFunction(function() {
-          var readStream = fs6.createReadStream(realPath);
+          var readStream = fs7.createReadStream(realPath);
           entry.state = Entry.FILE_DATA_IN_PROGRESS;
           readStream.on("error", function(err2) {
             self2.emit("error", err2);
@@ -10559,7 +10559,7 @@ var require_old = __commonJS({
   "../../node_modules/.pnpm/fs.realpath@1.0.0/node_modules/fs.realpath/old.js"(exports2) {
     var pathModule = require("path");
     var isWindows = process.platform === "win32";
-    var fs6 = require("fs");
+    var fs7 = require("fs");
     var DEBUG = process.env.NODE_DEBUG && /fs/.test(process.env.NODE_DEBUG);
     function rethrow() {
       var callback;
@@ -10624,7 +10624,7 @@ var require_old = __commonJS({
         base = m[0];
         previous = "";
         if (isWindows && !knownHard[base]) {
-          fs6.lstatSync(base);
+          fs7.lstatSync(base);
           knownHard[base] = true;
         }
       }
@@ -10642,7 +10642,7 @@ var require_old = __commonJS({
         if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
           resolvedLink = cache[base];
         } else {
-          var stat = fs6.lstatSync(base);
+          var stat = fs7.lstatSync(base);
           if (!stat.isSymbolicLink()) {
             knownHard[base] = true;
             if (cache)
@@ -10657,8 +10657,8 @@ var require_old = __commonJS({
             }
           }
           if (linkTarget === null) {
-            fs6.statSync(base);
-            linkTarget = fs6.readlinkSync(base);
+            fs7.statSync(base);
+            linkTarget = fs7.readlinkSync(base);
           }
           resolvedLink = pathModule.resolve(previous, linkTarget);
           if (cache)
@@ -10695,7 +10695,7 @@ var require_old = __commonJS({
         base = m[0];
         previous = "";
         if (isWindows && !knownHard[base]) {
-          fs6.lstat(base, function(err) {
+          fs7.lstat(base, function(err) {
             if (err)
               return cb(err);
             knownHard[base] = true;
@@ -10723,7 +10723,7 @@ var require_old = __commonJS({
         if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
           return gotResolvedLink(cache[base]);
         }
-        return fs6.lstat(base, gotStat);
+        return fs7.lstat(base, gotStat);
       }
       function gotStat(err, stat) {
         if (err)
@@ -10740,10 +10740,10 @@ var require_old = __commonJS({
             return gotTarget(null, seenLinks[id], base);
           }
         }
-        fs6.stat(base, function(err2) {
+        fs7.stat(base, function(err2) {
           if (err2)
             return cb(err2);
-          fs6.readlink(base, function(err3, target) {
+          fs7.readlink(base, function(err3, target) {
             if (!isWindows)
               seenLinks[id] = target;
             gotTarget(err3, target);
@@ -10775,9 +10775,9 @@ var require_fs2 = __commonJS({
     realpath.realpathSync = realpathSync;
     realpath.monkeypatch = monkeypatch;
     realpath.unmonkeypatch = unmonkeypatch;
-    var fs6 = require("fs");
-    var origRealpath = fs6.realpath;
-    var origRealpathSync = fs6.realpathSync;
+    var fs7 = require("fs");
+    var origRealpath = fs7.realpath;
+    var origRealpathSync = fs7.realpathSync;
     var version = process.version;
     var ok = /^v[0-5]\./.test(version);
     var old = require_old();
@@ -10815,12 +10815,12 @@ var require_fs2 = __commonJS({
       }
     }
     function monkeypatch() {
-      fs6.realpath = realpath;
-      fs6.realpathSync = realpathSync;
+      fs7.realpath = realpath;
+      fs7.realpathSync = realpathSync;
     }
     function unmonkeypatch() {
-      fs6.realpath = origRealpath;
-      fs6.realpathSync = origRealpathSync;
+      fs7.realpath = origRealpath;
+      fs7.realpathSync = origRealpathSync;
     }
   }
 });
@@ -11540,7 +11540,7 @@ var require_common = __commonJS({
     function ownProp(obj, field) {
       return Object.prototype.hasOwnProperty.call(obj, field);
     }
-    var fs6 = require("fs");
+    var fs7 = require("fs");
     var path7 = require("path");
     var minimatch2 = require_minimatch2();
     var isAbsolute = require("path").isAbsolute;
@@ -11595,7 +11595,7 @@ var require_common = __commonJS({
       self2.stat = !!options.stat;
       self2.noprocess = !!options.noprocess;
       self2.absolute = !!options.absolute;
-      self2.fs = options.fs || fs6;
+      self2.fs = options.fs || fs7;
       self2.maxLength = options.maxLength || Infinity;
       self2.cache = options.cache || /* @__PURE__ */ Object.create(null);
       self2.statCache = options.statCache || /* @__PURE__ */ Object.create(null);
@@ -12694,7 +12694,7 @@ var require_windows = __commonJS({
   "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/windows.js"(exports2, module2) {
     module2.exports = isexe;
     isexe.sync = sync;
-    var fs6 = require("fs");
+    var fs7 = require("fs");
     function checkPathExt(path7, options) {
       var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
       if (!pathext) {
@@ -12719,12 +12719,12 @@ var require_windows = __commonJS({
       return checkPathExt(path7, options);
     }
     function isexe(path7, options, cb) {
-      fs6.stat(path7, function(er, stat) {
+      fs7.stat(path7, function(er, stat) {
         cb(er, er ? false : checkStat(stat, path7, options));
       });
     }
     function sync(path7, options) {
-      return checkStat(fs6.statSync(path7), path7, options);
+      return checkStat(fs7.statSync(path7), path7, options);
     }
   }
 });
@@ -12734,14 +12734,14 @@ var require_mode = __commonJS({
   "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/mode.js"(exports2, module2) {
     module2.exports = isexe;
     isexe.sync = sync;
-    var fs6 = require("fs");
+    var fs7 = require("fs");
     function isexe(path7, options, cb) {
-      fs6.stat(path7, function(er, stat) {
+      fs7.stat(path7, function(er, stat) {
         cb(er, er ? false : checkStat(stat, options));
       });
     }
     function sync(path7, options) {
-      return checkStat(fs6.statSync(path7), options);
+      return checkStat(fs7.statSync(path7), options);
     }
     function checkStat(stat, options) {
       return stat.isFile() && checkMode(stat, options);
@@ -12765,7 +12765,7 @@ var require_mode = __commonJS({
 // ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js
 var require_isexe = __commonJS({
   "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js"(exports2, module2) {
-    var fs6 = require("fs");
+    var fs7 = require("fs");
     var core;
     if (process.platform === "win32" || global.TESTING_WINDOWS) {
       core = require_windows();
@@ -13041,7 +13041,7 @@ var require_shebang_command = __commonJS({
 var require_readShebang = __commonJS({
   "../../node_modules/.pnpm/cross-spawn@6.0.5/node_modules/cross-spawn/lib/util/readShebang.js"(exports2, module2) {
     "use strict";
-    var fs6 = require("fs");
+    var fs7 = require("fs");
     var shebangCommand = require_shebang_command();
     function readShebang(command) {
       const size = 150;
@@ -13054,9 +13054,9 @@ var require_readShebang = __commonJS({
       }
       let fd;
       try {
-        fd = fs6.openSync(command, "r");
-        fs6.readSync(fd, buffer, 0, size, 0);
-        fs6.closeSync(fd);
+        fd = fs7.openSync(command, "r");
+        fs7.readSync(fd, buffer, 0, size, 0);
+        fs7.closeSync(fd);
       } catch (e) {
       }
       return shebangCommand(buffer.toString());
@@ -14144,7 +14144,7 @@ var require_parse = __commonJS({
     var escape = require_escape();
     var readShebang = require_readShebang();
     var semver = require_semver();
-    var isWin2 = process.platform === "win32";
+    var isWin3 = process.platform === "win32";
     var isExecutableRegExp = /\.(?:com|exe)$/i;
     var isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
     var supportsShellOption = niceTry(() => semver.satisfies(process.version, "^4.8.0 || ^5.7.0 || >= 6.0.0", true)) || false;
@@ -14159,7 +14159,7 @@ var require_parse = __commonJS({
       return parsed.file;
     }
     function parseNonShell(parsed) {
-      if (!isWin2) {
+      if (!isWin3) {
         return parsed;
       }
       const commandFile = detectShebang(parsed);
@@ -14181,7 +14181,7 @@ var require_parse = __commonJS({
         return parsed;
       }
       const shellCommand = [parsed.command].concat(parsed.args).join(" ");
-      if (isWin2) {
+      if (isWin3) {
         parsed.command = typeof parsed.options.shell === "string" ? parsed.options.shell : process.env.comspec || "cmd.exe";
         parsed.args = ["/d", "/s", "/c", `"${shellCommand}"`];
         parsed.options.windowsVerbatimArguments = true;
@@ -14224,7 +14224,7 @@ var require_parse = __commonJS({
 var require_enoent = __commonJS({
   "../../node_modules/.pnpm/cross-spawn@6.0.5/node_modules/cross-spawn/lib/enoent.js"(exports2, module2) {
     "use strict";
-    var isWin2 = process.platform === "win32";
+    var isWin3 = process.platform === "win32";
     function notFoundError(original, syscall) {
       return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), {
         code: "ENOENT",
@@ -14235,7 +14235,7 @@ var require_enoent = __commonJS({
       });
     }
     function hookChildProcess(cp, parsed) {
-      if (!isWin2) {
+      if (!isWin3) {
         return;
       }
       const originalEmit = cp.emit;
@@ -14250,13 +14250,13 @@ var require_enoent = __commonJS({
       };
     }
     function verifyENOENT(status, parsed) {
-      if (isWin2 && status === 1 && !parsed.file) {
+      if (isWin3 && status === 1 && !parsed.file) {
         return notFoundError(parsed.original, "spawn");
       }
       return null;
     }
     function verifyENOENTSync(status, parsed) {
-      if (isWin2 && status === 1 && !parsed.file) {
+      if (isWin3 && status === 1 && !parsed.file) {
         return notFoundError(parsed.original, "spawnSync");
       }
       return null;
@@ -21814,158 +21814,2063 @@ var require_ignore = __commonJS({
   }
 });
 
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  BACKEND_FRAMEWORKS: () => BACKEND_FRAMEWORKS,
-  BUILDER_COMPILE_STEP: () => BUILDER_COMPILE_STEP,
-  BUILDER_INSTALLER_STEP: () => BUILDER_INSTALLER_STEP,
-  BunVersion: () => BunVersion,
-  EdgeFunction: () => EdgeFunction,
-  FileBlob: () => FileBlob,
-  FileFsRef: () => file_fs_ref_default,
-  FileRef: () => FileRef,
-  Lambda: () => Lambda,
-  NODE_VERSIONS: () => NODE_VERSIONS,
-  NodeVersion: () => NodeVersion,
-  NodejsLambda: () => NodejsLambda,
-  NowBuildError: () => NowBuildError,
-  Prerender: () => Prerender,
-  Span: () => Span,
-  Version: () => Version,
-  buildsSchema: () => buildsSchema,
-  cloneEnv: () => cloneEnv,
-  createLambda: () => createLambda,
-  debug: () => debug,
-  defaultCachePathGlob: () => defaultCachePathGlob,
-  detectPackageManager: () => detectPackageManager,
-  download: () => download,
-  downloadFile: () => downloadFile,
-  execCommand: () => execCommand,
-  functionsSchema: () => functionsSchema,
-  generateNodeBuilderFunctions: () => generateNodeBuilderFunctions,
-  getDiscontinuedNodeVersions: () => getDiscontinuedNodeVersions,
-  getEnvForPackageManager: () => getEnvForPackageManager,
-  getIgnoreFilter: () => get_ignore_filter_default,
-  getInstalledPackageVersion: () => getInstalledPackageVersion,
-  getLambdaOptionsFromFunction: () => getLambdaOptionsFromFunction,
-  getLatestNodeVersion: () => getLatestNodeVersion,
-  getNodeBinPath: () => getNodeBinPath,
-  getNodeBinPaths: () => getNodeBinPaths,
-  getNodeVersion: () => getNodeVersion,
-  getOsRelease: () => getOsRelease,
-  getPathForPackageManager: () => getPathForPackageManager,
-  getPlatformEnv: () => getPlatformEnv,
-  getPrefixedEnvVars: () => getPrefixedEnvVars,
-  getPrettyError: () => getPrettyError,
-  getProvidedRuntime: () => getProvidedRuntime,
-  getScriptName: () => getScriptName,
-  getSpawnOptions: () => getSpawnOptions,
-  getSupportedBunVersion: () => getSupportedBunVersion,
-  getSupportedNodeVersion: () => getSupportedNodeVersion,
-  getWriteableDirectory: () => getWritableDirectory,
-  glob: () => glob,
-  hardLinkDir: () => hardLinkDir,
-  installDependencies: () => installDependencies,
-  isBackendFramework: () => isBackendFramework,
-  isBunVersion: () => isBunVersion,
-  isDirectory: () => isDirectory,
-  isExperimentalBackendsEnabled: () => isExperimentalBackendsEnabled,
-  isSymbolicLink: () => isSymbolicLink,
-  normalizePath: () => normalizePath,
-  readConfigFile: () => readConfigFile,
-  rename: () => rename,
-  runBundleInstall: () => runBundleInstall,
-  runCustomInstallCommand: () => runCustomInstallCommand,
-  runNpmInstall: () => runNpmInstall,
-  runPackageJsonScript: () => runPackageJsonScript,
-  runPipInstall: () => runPipInstall,
-  runShellScript: () => runShellScript,
-  scanParentDirs: () => scanParentDirs,
-  shouldServe: () => shouldServe,
-  shouldUseExperimentalBackends: () => shouldUseExperimentalBackends,
-  spawnAsync: () => spawnAsync,
-  spawnCommand: () => spawnCommand,
-  streamToBuffer: () => streamToBuffer,
-  streamToBufferChunks: () => streamToBufferChunks,
-  traverseUpDirectories: () => traverseUpDirectories,
-  validateNpmrc: () => validateNpmrc,
-  walkParentDirs: () => walkParentDirs
+// ../../node_modules/.pnpm/which@2.0.2/node_modules/which/which.js
+var require_which2 = __commonJS({
+  "../../node_modules/.pnpm/which@2.0.2/node_modules/which/which.js"(exports2, module2) {
+    var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
+    var path7 = require("path");
+    var COLON = isWindows ? ";" : ":";
+    var isexe = require_isexe();
+    var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
+    var getPathInfo = (cmd, opt) => {
+      const colon = opt.colon || COLON;
+      const pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? [""] : [
+        // windows always checks the cwd first
+        ...isWindows ? [process.cwd()] : [],
+        ...(opt.path || process.env.PATH || /* istanbul ignore next: very unusual */
+        "").split(colon)
+      ];
+      const pathExtExe = isWindows ? opt.pathExt || process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM" : "";
+      const pathExt = isWindows ? pathExtExe.split(colon) : [""];
+      if (isWindows) {
+        if (cmd.indexOf(".") !== -1 && pathExt[0] !== "")
+          pathExt.unshift("");
+      }
+      return {
+        pathEnv,
+        pathExt,
+        pathExtExe
+      };
+    };
+    var which = (cmd, opt, cb) => {
+      if (typeof opt === "function") {
+        cb = opt;
+        opt = {};
+      }
+      if (!opt)
+        opt = {};
+      const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+      const found = [];
+      const step = (i) => new Promise((resolve, reject) => {
+        if (i === pathEnv.length)
+          return opt.all && found.length ? resolve(found) : reject(getNotFoundError(cmd));
+        const ppRaw = pathEnv[i];
+        const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+        const pCmd = path7.join(pathPart, cmd);
+        const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+        resolve(subStep(p, i, 0));
+      });
+      const subStep = (p, i, ii) => new Promise((resolve, reject) => {
+        if (ii === pathExt.length)
+          return resolve(step(i + 1));
+        const ext = pathExt[ii];
+        isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
+          if (!er && is) {
+            if (opt.all)
+              found.push(p + ext);
+            else
+              return resolve(p + ext);
+          }
+          return resolve(subStep(p, i, ii + 1));
+        });
+      });
+      return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
+    };
+    var whichSync = (cmd, opt) => {
+      opt = opt || {};
+      const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+      const found = [];
+      for (let i = 0; i < pathEnv.length; i++) {
+        const ppRaw = pathEnv[i];
+        const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+        const pCmd = path7.join(pathPart, cmd);
+        const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+        for (let j = 0; j < pathExt.length; j++) {
+          const cur = p + pathExt[j];
+          try {
+            const is = isexe.sync(cur, { pathExt: pathExtExe });
+            if (is) {
+              if (opt.all)
+                found.push(cur);
+              else
+                return cur;
+            }
+          } catch (ex) {
+          }
+        }
+      }
+      if (opt.all && found.length)
+        return found;
+      if (opt.nothrow)
+        return null;
+      throw getNotFoundError(cmd);
+    };
+    module2.exports = which;
+    which.sync = whichSync;
+  }
 });
-module.exports = __toCommonJS(src_exports);
 
-// src/file-blob.ts
-var import_assert = __toESM(require("assert"));
-var import_into_stream = __toESM(require_into_stream());
-var FileBlob = class _FileBlob {
-  constructor({ mode = 33188, contentType, data }) {
-    (0, import_assert.default)(typeof mode === "number");
-    (0, import_assert.default)(typeof data === "string" || Buffer.isBuffer(data));
-    this.type = "FileBlob";
-    this.mode = mode;
-    this.contentType = contentType;
-    this.data = data;
+// ../../node_modules/.pnpm/path-key@3.1.1/node_modules/path-key/index.js
+var require_path_key2 = __commonJS({
+  "../../node_modules/.pnpm/path-key@3.1.1/node_modules/path-key/index.js"(exports2, module2) {
+    "use strict";
+    var pathKey = (options = {}) => {
+      const environment = options.env || process.env;
+      const platform = options.platform || process.platform;
+      if (platform !== "win32") {
+        return "PATH";
+      }
+      return Object.keys(environment).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
+    };
+    module2.exports = pathKey;
+    module2.exports.default = pathKey;
   }
-  static async fromStream({
-    mode = 33188,
-    contentType,
-    stream
-  }) {
-    (0, import_assert.default)(typeof mode === "number");
-    (0, import_assert.default)(typeof stream.pipe === "function");
-    const chunks = [];
-    await new Promise((resolve, reject) => {
-      stream.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
-      stream.on("error", (error) => reject(error));
-      stream.on("end", () => resolve());
-    });
-    const data = Buffer.concat(chunks);
-    return new _FileBlob({ mode, contentType, data });
+});
+
+// ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/resolveCommand.js
+var require_resolveCommand2 = __commonJS({
+  "../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/resolveCommand.js"(exports2, module2) {
+    "use strict";
+    var path7 = require("path");
+    var which = require_which2();
+    var getPathKey = require_path_key2();
+    function resolveCommandAttempt(parsed, withoutPathExt) {
+      const env = parsed.options.env || process.env;
+      const cwd = process.cwd();
+      const hasCustomCwd = parsed.options.cwd != null;
+      const shouldSwitchCwd = hasCustomCwd && process.chdir !== void 0 && !process.chdir.disabled;
+      if (shouldSwitchCwd) {
+        try {
+          process.chdir(parsed.options.cwd);
+        } catch (err) {
+        }
+      }
+      let resolved;
+      try {
+        resolved = which.sync(parsed.command, {
+          path: env[getPathKey({ env })],
+          pathExt: withoutPathExt ? path7.delimiter : void 0
+        });
+      } catch (e) {
+      } finally {
+        if (shouldSwitchCwd) {
+          process.chdir(cwd);
+        }
+      }
+      if (resolved) {
+        resolved = path7.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+      }
+      return resolved;
+    }
+    function resolveCommand(parsed) {
+      return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
+    }
+    module2.exports = resolveCommand;
   }
-  async toStreamAsync() {
-    return this.toStream();
+});
+
+// ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/escape.js
+var require_escape2 = __commonJS({
+  "../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/escape.js"(exports2, module2) {
+    "use strict";
+    var metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
+    function escapeCommand(arg) {
+      arg = arg.replace(metaCharsRegExp, "^$1");
+      return arg;
+    }
+    function escapeArgument(arg, doubleEscapeMetaChars) {
+      arg = `${arg}`;
+      arg = arg.replace(/(?=(\\+?)?)\1"/g, '$1$1\\"');
+      arg = arg.replace(/(?=(\\+?)?)\1$/, "$1$1");
+      arg = `"${arg}"`;
+      arg = arg.replace(metaCharsRegExp, "^$1");
+      if (doubleEscapeMetaChars) {
+        arg = arg.replace(metaCharsRegExp, "^$1");
+      }
+      return arg;
+    }
+    module2.exports.command = escapeCommand;
+    module2.exports.argument = escapeArgument;
   }
-  toStream() {
-    return (0, import_into_stream.default)(this.data);
+});
+
+// ../../node_modules/.pnpm/shebang-regex@3.0.0/node_modules/shebang-regex/index.js
+var require_shebang_regex2 = __commonJS({
+  "../../node_modules/.pnpm/shebang-regex@3.0.0/node_modules/shebang-regex/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = /^#!(.*)/;
   }
-};
+});
 
-// src/file-fs-ref.ts
-var import_assert2 = __toESM(require("assert"));
-var import_fs_extra = __toESM(require_lib());
-var import_multistream = __toESM(require_multistream());
-var import_path = __toESM(require("path"));
-var import_async_sema = __toESM(require_async_sema());
-var semaToPreventEMFILE = new import_async_sema.default(20);
-var FileFsRef = class _FileFsRef {
-  constructor({
-    mode = 33188,
-    contentType,
-    fsPath,
-    size
-  }) {
-    (0, import_assert2.default)(typeof mode === "number");
-    (0, import_assert2.default)(typeof fsPath === "string");
-    this.type = "FileFsRef";
-    this.mode = mode;
-    this.contentType = contentType;
-    this.fsPath = fsPath;
-    this.size = size;
+// ../../node_modules/.pnpm/shebang-command@2.0.0/node_modules/shebang-command/index.js
+var require_shebang_command2 = __commonJS({
+  "../../node_modules/.pnpm/shebang-command@2.0.0/node_modules/shebang-command/index.js"(exports2, module2) {
+    "use strict";
+    var shebangRegex = require_shebang_regex2();
+    module2.exports = (string = "") => {
+      const match = string.match(shebangRegex);
+      if (!match) {
+        return null;
+      }
+      const [path7, argument] = match[0].replace(/#! ?/, "").split(" ");
+      const binary = path7.split("/").pop();
+      if (binary === "env") {
+        return argument;
+      }
+      return argument ? `${binary} ${argument}` : binary;
+    };
   }
-  static async fromFsPath({
-    mode,
-    contentType,
-    fsPath,
-    size
-  }) {
-    let m = mode;
-    let s = size;
-    if (!m || typeof s === "undefined") {
-      const stat = await import_fs_extra.default.lstat(fsPath);
-      m = stat.mode;
-      s = stat.size;
-    }
-    return new _FileFsRef({ mode: m, contentType, fsPath, size: s });
+});
+
+// ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/readShebang.js
+var require_readShebang2 = __commonJS({
+  "../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/readShebang.js"(exports2, module2) {
+    "use strict";
+    var fs7 = require("fs");
+    var shebangCommand = require_shebang_command2();
+    function readShebang(command) {
+      const size = 150;
+      const buffer = Buffer.alloc(size);
+      let fd;
+      try {
+        fd = fs7.openSync(command, "r");
+        fs7.readSync(fd, buffer, 0, size, 0);
+        fs7.closeSync(fd);
+      } catch (e) {
+      }
+      return shebangCommand(buffer.toString());
+    }
+    module2.exports = readShebang;
+  }
+});
+
+// ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/parse.js
+var require_parse4 = __commonJS({
+  "../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/parse.js"(exports2, module2) {
+    "use strict";
+    var path7 = require("path");
+    var resolveCommand = require_resolveCommand2();
+    var escape = require_escape2();
+    var readShebang = require_readShebang2();
+    var isWin3 = process.platform === "win32";
+    var isExecutableRegExp = /\.(?:com|exe)$/i;
+    var isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+    function detectShebang(parsed) {
+      parsed.file = resolveCommand(parsed);
+      const shebang = parsed.file && readShebang(parsed.file);
+      if (shebang) {
+        parsed.args.unshift(parsed.file);
+        parsed.command = shebang;
+        return resolveCommand(parsed);
+      }
+      return parsed.file;
+    }
+    function parseNonShell(parsed) {
+      if (!isWin3) {
+        return parsed;
+      }
+      const commandFile = detectShebang(parsed);
+      const needsShell = !isExecutableRegExp.test(commandFile);
+      if (parsed.options.forceShell || needsShell) {
+        const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
+        parsed.command = path7.normalize(parsed.command);
+        parsed.command = escape.command(parsed.command);
+        parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
+        const shellCommand = [parsed.command].concat(parsed.args).join(" ");
+        parsed.args = ["/d", "/s", "/c", `"${shellCommand}"`];
+        parsed.command = process.env.comspec || "cmd.exe";
+        parsed.options.windowsVerbatimArguments = true;
+      }
+      return parsed;
+    }
+    function parse3(command, args, options) {
+      if (args && !Array.isArray(args)) {
+        options = args;
+        args = null;
+      }
+      args = args ? args.slice(0) : [];
+      options = Object.assign({}, options);
+      const parsed = {
+        command,
+        args,
+        options,
+        file: void 0,
+        original: {
+          command,
+          args
+        }
+      };
+      return options.shell ? parsed : parseNonShell(parsed);
+    }
+    module2.exports = parse3;
+  }
+});
+
+// ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/enoent.js
+var require_enoent2 = __commonJS({
+  "../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/enoent.js"(exports2, module2) {
+    "use strict";
+    var isWin3 = process.platform === "win32";
+    function notFoundError(original, syscall) {
+      return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), {
+        code: "ENOENT",
+        errno: "ENOENT",
+        syscall: `${syscall} ${original.command}`,
+        path: original.command,
+        spawnargs: original.args
+      });
+    }
+    function hookChildProcess(cp, parsed) {
+      if (!isWin3) {
+        return;
+      }
+      const originalEmit = cp.emit;
+      cp.emit = function(name, arg1) {
+        if (name === "exit") {
+          const err = verifyENOENT(arg1, parsed);
+          if (err) {
+            return originalEmit.call(cp, "error", err);
+          }
+        }
+        return originalEmit.apply(cp, arguments);
+      };
+    }
+    function verifyENOENT(status, parsed) {
+      if (isWin3 && status === 1 && !parsed.file) {
+        return notFoundError(parsed.original, "spawn");
+      }
+      return null;
+    }
+    function verifyENOENTSync(status, parsed) {
+      if (isWin3 && status === 1 && !parsed.file) {
+        return notFoundError(parsed.original, "spawnSync");
+      }
+      return null;
+    }
+    module2.exports = {
+      hookChildProcess,
+      verifyENOENT,
+      verifyENOENTSync,
+      notFoundError
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/index.js
+var require_cross_spawn2 = __commonJS({
+  "../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/index.js"(exports2, module2) {
+    "use strict";
+    var cp = require("child_process");
+    var parse3 = require_parse4();
+    var enoent = require_enoent2();
+    function spawn2(command, args, options) {
+      const parsed = parse3(command, args, options);
+      const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
+      enoent.hookChildProcess(spawned, parsed);
+      return spawned;
+    }
+    function spawnSync(command, args, options) {
+      const parsed = parse3(command, args, options);
+      const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
+      result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
+      return result;
+    }
+    module2.exports = spawn2;
+    module2.exports.spawn = spawn2;
+    module2.exports.sync = spawnSync;
+    module2.exports._parse = parse3;
+    module2.exports._enoent = enoent;
+  }
+});
+
+// ../../node_modules/.pnpm/strip-final-newline@2.0.0/node_modules/strip-final-newline/index.js
+var require_strip_final_newline = __commonJS({
+  "../../node_modules/.pnpm/strip-final-newline@2.0.0/node_modules/strip-final-newline/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = (input) => {
+      const LF = typeof input === "string" ? "\n" : "\n".charCodeAt();
+      const CR = typeof input === "string" ? "\r" : "\r".charCodeAt();
+      if (input[input.length - 1] === LF) {
+        input = input.slice(0, input.length - 1);
+      }
+      if (input[input.length - 1] === CR) {
+        input = input.slice(0, input.length - 1);
+      }
+      return input;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/npm-run-path@4.0.1/node_modules/npm-run-path/index.js
+var require_npm_run_path = __commonJS({
+  "../../node_modules/.pnpm/npm-run-path@4.0.1/node_modules/npm-run-path/index.js"(exports2, module2) {
+    "use strict";
+    var path7 = require("path");
+    var pathKey = require_path_key2();
+    var npmRunPath = (options) => {
+      options = {
+        cwd: process.cwd(),
+        path: process.env[pathKey()],
+        execPath: process.execPath,
+        ...options
+      };
+      let previous;
+      let cwdPath = path7.resolve(options.cwd);
+      const result = [];
+      while (previous !== cwdPath) {
+        result.push(path7.join(cwdPath, "node_modules/.bin"));
+        previous = cwdPath;
+        cwdPath = path7.resolve(cwdPath, "..");
+      }
+      const execPathDir = path7.resolve(options.cwd, options.execPath, "..");
+      result.push(execPathDir);
+      return result.concat(options.path).join(path7.delimiter);
+    };
+    module2.exports = npmRunPath;
+    module2.exports.default = npmRunPath;
+    module2.exports.env = (options) => {
+      options = {
+        env: process.env,
+        ...options
+      };
+      const env = { ...options.env };
+      const path8 = pathKey({ env });
+      options.path = env[path8];
+      env[path8] = module2.exports(options);
+      return env;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/mimic-fn@2.1.0/node_modules/mimic-fn/index.js
+var require_mimic_fn = __commonJS({
+  "../../node_modules/.pnpm/mimic-fn@2.1.0/node_modules/mimic-fn/index.js"(exports2, module2) {
+    "use strict";
+    var mimicFn = (to, from) => {
+      for (const prop of Reflect.ownKeys(from)) {
+        Object.defineProperty(to, prop, Object.getOwnPropertyDescriptor(from, prop));
+      }
+      return to;
+    };
+    module2.exports = mimicFn;
+    module2.exports.default = mimicFn;
+  }
+});
+
+// ../../node_modules/.pnpm/onetime@5.1.2/node_modules/onetime/index.js
+var require_onetime = __commonJS({
+  "../../node_modules/.pnpm/onetime@5.1.2/node_modules/onetime/index.js"(exports2, module2) {
+    "use strict";
+    var mimicFn = require_mimic_fn();
+    var calledFunctions = /* @__PURE__ */ new WeakMap();
+    var onetime = (function_, options = {}) => {
+      if (typeof function_ !== "function") {
+        throw new TypeError("Expected a function");
+      }
+      let returnValue;
+      let callCount = 0;
+      const functionName = function_.displayName || function_.name || "<anonymous>";
+      const onetime2 = function(...arguments_) {
+        calledFunctions.set(onetime2, ++callCount);
+        if (callCount === 1) {
+          returnValue = function_.apply(this, arguments_);
+          function_ = null;
+        } else if (options.throw === true) {
+          throw new Error(`Function \`${functionName}\` can only be called once`);
+        }
+        return returnValue;
+      };
+      mimicFn(onetime2, function_);
+      calledFunctions.set(onetime2, callCount);
+      return onetime2;
+    };
+    module2.exports = onetime;
+    module2.exports.default = onetime;
+    module2.exports.callCount = (function_) => {
+      if (!calledFunctions.has(function_)) {
+        throw new Error(`The given function \`${function_.name}\` is not wrapped by the \`onetime\` package`);
+      }
+      return calledFunctions.get(function_);
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/human-signals@1.1.1/node_modules/human-signals/build/src/core.js
+var require_core2 = __commonJS({
+  "../../node_modules/.pnpm/human-signals@1.1.1/node_modules/human-signals/build/src/core.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.SIGNALS = void 0;
+    var SIGNALS = [
+      {
+        name: "SIGHUP",
+        number: 1,
+        action: "terminate",
+        description: "Terminal closed",
+        standard: "posix"
+      },
+      {
+        name: "SIGINT",
+        number: 2,
+        action: "terminate",
+        description: "User interruption with CTRL-C",
+        standard: "ansi"
+      },
+      {
+        name: "SIGQUIT",
+        number: 3,
+        action: "core",
+        description: "User interruption with CTRL-\\",
+        standard: "posix"
+      },
+      {
+        name: "SIGILL",
+        number: 4,
+        action: "core",
+        description: "Invalid machine instruction",
+        standard: "ansi"
+      },
+      {
+        name: "SIGTRAP",
+        number: 5,
+        action: "core",
+        description: "Debugger breakpoint",
+        standard: "posix"
+      },
+      {
+        name: "SIGABRT",
+        number: 6,
+        action: "core",
+        description: "Aborted",
+        standard: "ansi"
+      },
+      {
+        name: "SIGIOT",
+        number: 6,
+        action: "core",
+        description: "Aborted",
+        standard: "bsd"
+      },
+      {
+        name: "SIGBUS",
+        number: 7,
+        action: "core",
+        description: "Bus error due to misaligned, non-existing address or paging error",
+        standard: "bsd"
+      },
+      {
+        name: "SIGEMT",
+        number: 7,
+        action: "terminate",
+        description: "Command should be emulated but is not implemented",
+        standard: "other"
+      },
+      {
+        name: "SIGFPE",
+        number: 8,
+        action: "core",
+        description: "Floating point arithmetic error",
+        standard: "ansi"
+      },
+      {
+        name: "SIGKILL",
+        number: 9,
+        action: "terminate",
+        description: "Forced termination",
+        standard: "posix",
+        forced: true
+      },
+      {
+        name: "SIGUSR1",
+        number: 10,
+        action: "terminate",
+        description: "Application-specific signal",
+        standard: "posix"
+      },
+      {
+        name: "SIGSEGV",
+        number: 11,
+        action: "core",
+        description: "Segmentation fault",
+        standard: "ansi"
+      },
+      {
+        name: "SIGUSR2",
+        number: 12,
+        action: "terminate",
+        description: "Application-specific signal",
+        standard: "posix"
+      },
+      {
+        name: "SIGPIPE",
+        number: 13,
+        action: "terminate",
+        description: "Broken pipe or socket",
+        standard: "posix"
+      },
+      {
+        name: "SIGALRM",
+        number: 14,
+        action: "terminate",
+        description: "Timeout or timer",
+        standard: "posix"
+      },
+      {
+        name: "SIGTERM",
+        number: 15,
+        action: "terminate",
+        description: "Termination",
+        standard: "ansi"
+      },
+      {
+        name: "SIGSTKFLT",
+        number: 16,
+        action: "terminate",
+        description: "Stack is empty or overflowed",
+        standard: "other"
+      },
+      {
+        name: "SIGCHLD",
+        number: 17,
+        action: "ignore",
+        description: "Child process terminated, paused or unpaused",
+        standard: "posix"
+      },
+      {
+        name: "SIGCLD",
+        number: 17,
+        action: "ignore",
+        description: "Child process terminated, paused or unpaused",
+        standard: "other"
+      },
+      {
+        name: "SIGCONT",
+        number: 18,
+        action: "unpause",
+        description: "Unpaused",
+        standard: "posix",
+        forced: true
+      },
+      {
+        name: "SIGSTOP",
+        number: 19,
+        action: "pause",
+        description: "Paused",
+        standard: "posix",
+        forced: true
+      },
+      {
+        name: "SIGTSTP",
+        number: 20,
+        action: "pause",
+        description: 'Paused using CTRL-Z or "suspend"',
+        standard: "posix"
+      },
+      {
+        name: "SIGTTIN",
+        number: 21,
+        action: "pause",
+        description: "Background process cannot read terminal input",
+        standard: "posix"
+      },
+      {
+        name: "SIGBREAK",
+        number: 21,
+        action: "terminate",
+        description: "User interruption with CTRL-BREAK",
+        standard: "other"
+      },
+      {
+        name: "SIGTTOU",
+        number: 22,
+        action: "pause",
+        description: "Background process cannot write to terminal output",
+        standard: "posix"
+      },
+      {
+        name: "SIGURG",
+        number: 23,
+        action: "ignore",
+        description: "Socket received out-of-band data",
+        standard: "bsd"
+      },
+      {
+        name: "SIGXCPU",
+        number: 24,
+        action: "core",
+        description: "Process timed out",
+        standard: "bsd"
+      },
+      {
+        name: "SIGXFSZ",
+        number: 25,
+        action: "core",
+        description: "File too big",
+        standard: "bsd"
+      },
+      {
+        name: "SIGVTALRM",
+        number: 26,
+        action: "terminate",
+        description: "Timeout or timer",
+        standard: "bsd"
+      },
+      {
+        name: "SIGPROF",
+        number: 27,
+        action: "terminate",
+        description: "Timeout or timer",
+        standard: "bsd"
+      },
+      {
+        name: "SIGWINCH",
+        number: 28,
+        action: "ignore",
+        description: "Terminal window size changed",
+        standard: "bsd"
+      },
+      {
+        name: "SIGIO",
+        number: 29,
+        action: "terminate",
+        description: "I/O is available",
+        standard: "other"
+      },
+      {
+        name: "SIGPOLL",
+        number: 29,
+        action: "terminate",
+        description: "Watched event",
+        standard: "other"
+      },
+      {
+        name: "SIGINFO",
+        number: 29,
+        action: "ignore",
+        description: "Request for process information",
+        standard: "other"
+      },
+      {
+        name: "SIGPWR",
+        number: 30,
+        action: "terminate",
+        description: "Device running out of power",
+        standard: "systemv"
+      },
+      {
+        name: "SIGSYS",
+        number: 31,
+        action: "core",
+        description: "Invalid system call",
+        standard: "other"
+      },
+      {
+        name: "SIGUNUSED",
+        number: 31,
+        action: "terminate",
+        description: "Invalid system call",
+        standard: "other"
+      }
+    ];
+    exports2.SIGNALS = SIGNALS;
+  }
+});
+
+// ../../node_modules/.pnpm/human-signals@1.1.1/node_modules/human-signals/build/src/realtime.js
+var require_realtime = __commonJS({
+  "../../node_modules/.pnpm/human-signals@1.1.1/node_modules/human-signals/build/src/realtime.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.SIGRTMAX = exports2.getRealtimeSignals = void 0;
+    var getRealtimeSignals = function() {
+      const length = SIGRTMAX - SIGRTMIN + 1;
+      return Array.from({ length }, getRealtimeSignal);
+    };
+    exports2.getRealtimeSignals = getRealtimeSignals;
+    var getRealtimeSignal = function(value, index) {
+      return {
+        name: `SIGRT${index + 1}`,
+        number: SIGRTMIN + index,
+        action: "terminate",
+        description: "Application-specific signal (realtime)",
+        standard: "posix"
+      };
+    };
+    var SIGRTMIN = 34;
+    var SIGRTMAX = 64;
+    exports2.SIGRTMAX = SIGRTMAX;
+  }
+});
+
+// ../../node_modules/.pnpm/human-signals@1.1.1/node_modules/human-signals/build/src/signals.js
+var require_signals = __commonJS({
+  "../../node_modules/.pnpm/human-signals@1.1.1/node_modules/human-signals/build/src/signals.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.getSignals = void 0;
+    var _os = require("os");
+    var _core = require_core2();
+    var _realtime = require_realtime();
+    var getSignals = function() {
+      const realtimeSignals = (0, _realtime.getRealtimeSignals)();
+      const signals = [..._core.SIGNALS, ...realtimeSignals].map(normalizeSignal);
+      return signals;
+    };
+    exports2.getSignals = getSignals;
+    var normalizeSignal = function({
+      name,
+      number: defaultNumber,
+      description,
+      action,
+      forced = false,
+      standard
+    }) {
+      const {
+        signals: { [name]: constantSignal }
+      } = _os.constants;
+      const supported = constantSignal !== void 0;
+      const number = supported ? constantSignal : defaultNumber;
+      return { name, number, description, supported, action, forced, standard };
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/human-signals@1.1.1/node_modules/human-signals/build/src/main.js
+var require_main = __commonJS({
+  "../../node_modules/.pnpm/human-signals@1.1.1/node_modules/human-signals/build/src/main.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.signalsByNumber = exports2.signalsByName = void 0;
+    var _os = require("os");
+    var _signals = require_signals();
+    var _realtime = require_realtime();
+    var getSignalsByName = function() {
+      const signals = (0, _signals.getSignals)();
+      return signals.reduce(getSignalByName, {});
+    };
+    var getSignalByName = function(signalByNameMemo, { name, number, description, supported, action, forced, standard }) {
+      return {
+        ...signalByNameMemo,
+        [name]: { name, number, description, supported, action, forced, standard }
+      };
+    };
+    var signalsByName = getSignalsByName();
+    exports2.signalsByName = signalsByName;
+    var getSignalsByNumber = function() {
+      const signals = (0, _signals.getSignals)();
+      const length = _realtime.SIGRTMAX + 1;
+      const signalsA = Array.from({ length }, (value, number) => getSignalByNumber(number, signals));
+      return Object.assign({}, ...signalsA);
+    };
+    var getSignalByNumber = function(number, signals) {
+      const signal = findSignalByNumber(number, signals);
+      if (signal === void 0) {
+        return {};
+      }
+      const { name, description, supported, action, forced, standard } = signal;
+      return {
+        [number]: {
+          name,
+          number,
+          description,
+          supported,
+          action,
+          forced,
+          standard
+        }
+      };
+    };
+    var findSignalByNumber = function(number, signals) {
+      const signal = signals.find(({ name }) => _os.constants.signals[name] === number);
+      if (signal !== void 0) {
+        return signal;
+      }
+      return signals.find((signalA) => signalA.number === number);
+    };
+    var signalsByNumber = getSignalsByNumber();
+    exports2.signalsByNumber = signalsByNumber;
+  }
+});
+
+// ../../node_modules/.pnpm/execa@3.2.0/node_modules/execa/lib/error.js
+var require_error = __commonJS({
+  "../../node_modules/.pnpm/execa@3.2.0/node_modules/execa/lib/error.js"(exports2, module2) {
+    "use strict";
+    var { signalsByName } = require_main();
+    var getErrorPrefix = ({ timedOut, timeout, errorCode, signal, signalDescription, exitCode, isCanceled }) => {
+      if (timedOut) {
+        return `timed out after ${timeout} milliseconds`;
+      }
+      if (isCanceled) {
+        return "was canceled";
+      }
+      if (errorCode !== void 0) {
+        return `failed with ${errorCode}`;
+      }
+      if (signal !== void 0) {
+        return `was killed with ${signal} (${signalDescription})`;
+      }
+      if (exitCode !== void 0) {
+        return `failed with exit code ${exitCode}`;
+      }
+      return "failed";
+    };
+    var makeError = ({
+      stdout,
+      stderr,
+      all,
+      error,
+      signal,
+      exitCode,
+      command,
+      timedOut,
+      isCanceled,
+      killed,
+      parsed: { options: { timeout } }
+    }) => {
+      exitCode = exitCode === null ? void 0 : exitCode;
+      signal = signal === null ? void 0 : signal;
+      const signalDescription = signal === void 0 ? void 0 : signalsByName[signal].description;
+      const errorCode = error && error.code;
+      const prefix = getErrorPrefix({ timedOut, timeout, errorCode, signal, signalDescription, exitCode, isCanceled });
+      const message = `Command ${prefix}: ${command}`;
+      if (error instanceof Error) {
+        error.originalMessage = error.message;
+        error.message = `${message}
+${error.message}`;
+      } else {
+        error = new Error(message);
+      }
+      error.command = command;
+      error.exitCode = exitCode;
+      error.signal = signal;
+      error.signalDescription = signalDescription;
+      error.stdout = stdout;
+      error.stderr = stderr;
+      if (all !== void 0) {
+        error.all = all;
+      }
+      if ("bufferedData" in error) {
+        delete error.bufferedData;
+      }
+      error.failed = true;
+      error.timedOut = Boolean(timedOut);
+      error.isCanceled = isCanceled;
+      error.killed = killed && !timedOut;
+      return error;
+    };
+    module2.exports = makeError;
+  }
+});
+
+// ../../node_modules/.pnpm/execa@3.2.0/node_modules/execa/lib/stdio.js
+var require_stdio = __commonJS({
+  "../../node_modules/.pnpm/execa@3.2.0/node_modules/execa/lib/stdio.js"(exports2, module2) {
+    "use strict";
+    var aliases = ["stdin", "stdout", "stderr"];
+    var hasAlias = (opts) => aliases.some((alias) => opts[alias] !== void 0);
+    var normalizeStdio = (opts) => {
+      if (!opts) {
+        return;
+      }
+      const { stdio } = opts;
+      if (stdio === void 0) {
+        return aliases.map((alias) => opts[alias]);
+      }
+      if (hasAlias(opts)) {
+        throw new Error(`It's not possible to provide \`stdio\` in combination with one of ${aliases.map((alias) => `\`${alias}\``).join(", ")}`);
+      }
+      if (typeof stdio === "string") {
+        return stdio;
+      }
+      if (!Array.isArray(stdio)) {
+        throw new TypeError(`Expected \`stdio\` to be of type \`string\` or \`Array\`, got \`${typeof stdio}\``);
+      }
+      const length = Math.max(stdio.length, aliases.length);
+      return Array.from({ length }, (value, index) => stdio[index]);
+    };
+    module2.exports = normalizeStdio;
+    module2.exports.node = (opts) => {
+      const stdio = normalizeStdio(opts);
+      if (stdio === "ipc") {
+        return "ipc";
+      }
+      if (stdio === void 0 || typeof stdio === "string") {
+        return [stdio, stdio, stdio, "ipc"];
+      }
+      if (stdio.includes("ipc")) {
+        return stdio;
+      }
+      return [...stdio, "ipc"];
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/signals.js
+var require_signals2 = __commonJS({
+  "../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/signals.js"(exports2, module2) {
+    module2.exports = [
+      "SIGABRT",
+      "SIGALRM",
+      "SIGHUP",
+      "SIGINT",
+      "SIGTERM"
+    ];
+    if (process.platform !== "win32") {
+      module2.exports.push(
+        "SIGVTALRM",
+        "SIGXCPU",
+        "SIGXFSZ",
+        "SIGUSR2",
+        "SIGTRAP",
+        "SIGSYS",
+        "SIGQUIT",
+        "SIGIOT"
+        // should detect profiler and enable/disable accordingly.
+        // see #21
+        // 'SIGPROF'
+      );
+    }
+    if (process.platform === "linux") {
+      module2.exports.push(
+        "SIGIO",
+        "SIGPOLL",
+        "SIGPWR",
+        "SIGSTKFLT",
+        "SIGUNUSED"
+      );
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/index.js
+var require_signal_exit = __commonJS({
+  "../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/index.js"(exports2, module2) {
+    var process2 = global.process;
+    var processOk = function(process3) {
+      return process3 && typeof process3 === "object" && typeof process3.removeListener === "function" && typeof process3.emit === "function" && typeof process3.reallyExit === "function" && typeof process3.listeners === "function" && typeof process3.kill === "function" && typeof process3.pid === "number" && typeof process3.on === "function";
+    };
+    if (!processOk(process2)) {
+      module2.exports = function() {
+        return function() {
+        };
+      };
+    } else {
+      assert7 = require("assert");
+      signals = require_signals2();
+      isWin3 = /^win/i.test(process2.platform);
+      EE = require("events");
+      if (typeof EE !== "function") {
+        EE = EE.EventEmitter;
+      }
+      if (process2.__signal_exit_emitter__) {
+        emitter = process2.__signal_exit_emitter__;
+      } else {
+        emitter = process2.__signal_exit_emitter__ = new EE();
+        emitter.count = 0;
+        emitter.emitted = {};
+      }
+      if (!emitter.infinite) {
+        emitter.setMaxListeners(Infinity);
+        emitter.infinite = true;
+      }
+      module2.exports = function(cb, opts) {
+        if (!processOk(global.process)) {
+          return function() {
+          };
+        }
+        assert7.equal(typeof cb, "function", "a callback must be provided for exit handler");
+        if (loaded === false) {
+          load();
+        }
+        var ev = "exit";
+        if (opts && opts.alwaysLast) {
+          ev = "afterexit";
+        }
+        var remove2 = function() {
+          emitter.removeListener(ev, cb);
+          if (emitter.listeners("exit").length === 0 && emitter.listeners("afterexit").length === 0) {
+            unload();
+          }
+        };
+        emitter.on(ev, cb);
+        return remove2;
+      };
+      unload = function unload2() {
+        if (!loaded || !processOk(global.process)) {
+          return;
+        }
+        loaded = false;
+        signals.forEach(function(sig) {
+          try {
+            process2.removeListener(sig, sigListeners[sig]);
+          } catch (er) {
+          }
+        });
+        process2.emit = originalProcessEmit;
+        process2.reallyExit = originalProcessReallyExit;
+        emitter.count -= 1;
+      };
+      module2.exports.unload = unload;
+      emit = function emit2(event, code, signal) {
+        if (emitter.emitted[event]) {
+          return;
+        }
+        emitter.emitted[event] = true;
+        emitter.emit(event, code, signal);
+      };
+      sigListeners = {};
+      signals.forEach(function(sig) {
+        sigListeners[sig] = function listener() {
+          if (!processOk(global.process)) {
+            return;
+          }
+          var listeners = process2.listeners(sig);
+          if (listeners.length === emitter.count) {
+            unload();
+            emit("exit", null, sig);
+            emit("afterexit", null, sig);
+            if (isWin3 && sig === "SIGHUP") {
+              sig = "SIGINT";
+            }
+            process2.kill(process2.pid, sig);
+          }
+        };
+      });
+      module2.exports.signals = function() {
+        return signals;
+      };
+      loaded = false;
+      load = function load2() {
+        if (loaded || !processOk(global.process)) {
+          return;
+        }
+        loaded = true;
+        emitter.count += 1;
+        signals = signals.filter(function(sig) {
+          try {
+            process2.on(sig, sigListeners[sig]);
+            return true;
+          } catch (er) {
+            return false;
+          }
+        });
+        process2.emit = processEmit;
+        process2.reallyExit = processReallyExit;
+      };
+      module2.exports.load = load;
+      originalProcessReallyExit = process2.reallyExit;
+      processReallyExit = function processReallyExit2(code) {
+        if (!processOk(global.process)) {
+          return;
+        }
+        process2.exitCode = code || /* istanbul ignore next */
+        0;
+        emit("exit", process2.exitCode, null);
+        emit("afterexit", process2.exitCode, null);
+        originalProcessReallyExit.call(process2, process2.exitCode);
+      };
+      originalProcessEmit = process2.emit;
+      processEmit = function processEmit2(ev, arg) {
+        if (ev === "exit" && processOk(global.process)) {
+          if (arg !== void 0) {
+            process2.exitCode = arg;
+          }
+          var ret = originalProcessEmit.apply(this, arguments);
+          emit("exit", process2.exitCode, null);
+          emit("afterexit", process2.exitCode, null);
+          return ret;
+        } else {
+          return originalProcessEmit.apply(this, arguments);
+        }
+      };
+    }
+    var assert7;
+    var signals;
+    var isWin3;
+    var EE;
+    var emitter;
+    var unload;
+    var emit;
+    var sigListeners;
+    var loaded;
+    var load;
+    var originalProcessReallyExit;
+    var processReallyExit;
+    var originalProcessEmit;
+    var processEmit;
+  }
+});
+
+// ../../node_modules/.pnpm/p-finally@2.0.1/node_modules/p-finally/index.js
+var require_p_finally = __commonJS({
+  "../../node_modules/.pnpm/p-finally@2.0.1/node_modules/p-finally/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = async (promise, onFinally = () => {
+    }) => {
+      let value;
+      try {
+        value = await promise;
+      } catch (error) {
+        await onFinally();
+        throw error;
+      }
+      await onFinally();
+      return value;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/execa@3.2.0/node_modules/execa/lib/kill.js
+var require_kill = __commonJS({
+  "../../node_modules/.pnpm/execa@3.2.0/node_modules/execa/lib/kill.js"(exports2, module2) {
+    "use strict";
+    var os = require("os");
+    var onExit = require_signal_exit();
+    var pFinally = require_p_finally();
+    var DEFAULT_FORCE_KILL_TIMEOUT = 1e3 * 5;
+    var spawnedKill = (kill, signal = "SIGTERM", options = {}) => {
+      const killResult = kill(signal);
+      setKillTimeout(kill, signal, options, killResult);
+      return killResult;
+    };
+    var setKillTimeout = (kill, signal, options, killResult) => {
+      if (!shouldForceKill(signal, options, killResult)) {
+        return;
+      }
+      const timeout = getForceKillAfterTimeout(options);
+      setTimeout(() => {
+        kill("SIGKILL");
+      }, timeout).unref();
+    };
+    var shouldForceKill = (signal, { forceKillAfterTimeout }, killResult) => {
+      return isSigterm(signal) && forceKillAfterTimeout !== false && killResult;
+    };
+    var isSigterm = (signal) => {
+      return signal === os.constants.signals.SIGTERM || typeof signal === "string" && signal.toUpperCase() === "SIGTERM";
+    };
+    var getForceKillAfterTimeout = ({ forceKillAfterTimeout = true }) => {
+      if (forceKillAfterTimeout === true) {
+        return DEFAULT_FORCE_KILL_TIMEOUT;
+      }
+      if (!Number.isInteger(forceKillAfterTimeout) || forceKillAfterTimeout < 0) {
+        throw new TypeError(`Expected the \`forceKillAfterTimeout\` option to be a non-negative integer, got \`${forceKillAfterTimeout}\` (${typeof forceKillAfterTimeout})`);
+      }
+      return forceKillAfterTimeout;
+    };
+    var spawnedCancel = (spawned, context) => {
+      const killResult = spawned.kill();
+      if (killResult) {
+        context.isCanceled = true;
+      }
+    };
+    var timeoutKill = (spawned, signal, reject) => {
+      spawned.kill(signal);
+      reject(Object.assign(new Error("Timed out"), { timedOut: true, signal }));
+    };
+    var setupTimeout = (spawned, { timeout, killSignal = "SIGTERM" }, spawnedPromise) => {
+      if (timeout === 0 || timeout === void 0) {
+        return spawnedPromise;
+      }
+      if (!Number.isInteger(timeout) || timeout < 0) {
+        throw new TypeError(`Expected the \`timeout\` option to be a non-negative integer, got \`${timeout}\` (${typeof timeout})`);
+      }
+      let timeoutId;
+      const timeoutPromise = new Promise((resolve, reject) => {
+        timeoutId = setTimeout(() => {
+          timeoutKill(spawned, killSignal, reject);
+        }, timeout);
+      });
+      const safeSpawnedPromise = pFinally(spawnedPromise, () => {
+        clearTimeout(timeoutId);
+      });
+      return Promise.race([timeoutPromise, safeSpawnedPromise]);
+    };
+    var setExitHandler = (spawned, { cleanup, detached }, timedPromise) => {
+      if (!cleanup || detached) {
+        return timedPromise;
+      }
+      const removeExitHandler = onExit(() => {
+        spawned.kill();
+      });
+      return pFinally(timedPromise, removeExitHandler);
+    };
+    module2.exports = {
+      spawnedKill,
+      spawnedCancel,
+      setupTimeout,
+      setExitHandler
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/is-stream@2.0.1/node_modules/is-stream/index.js
+var require_is_stream = __commonJS({
+  "../../node_modules/.pnpm/is-stream@2.0.1/node_modules/is-stream/index.js"(exports2, module2) {
+    "use strict";
+    var isStream = (stream) => stream !== null && typeof stream === "object" && typeof stream.pipe === "function";
+    isStream.writable = (stream) => isStream(stream) && stream.writable !== false && typeof stream._write === "function" && typeof stream._writableState === "object";
+    isStream.readable = (stream) => isStream(stream) && stream.readable !== false && typeof stream._read === "function" && typeof stream._readableState === "object";
+    isStream.duplex = (stream) => isStream.writable(stream) && isStream.readable(stream);
+    isStream.transform = (stream) => isStream.duplex(stream) && typeof stream._transform === "function";
+    module2.exports = isStream;
+  }
+});
+
+// ../../node_modules/.pnpm/pump@3.0.2/node_modules/pump/index.js
+var require_pump = __commonJS({
+  "../../node_modules/.pnpm/pump@3.0.2/node_modules/pump/index.js"(exports2, module2) {
+    var once = require_once();
+    var eos2 = require_end_of_stream();
+    var fs7;
+    try {
+      fs7 = require("fs");
+    } catch (e) {
+    }
+    var noop = function() {
+    };
+    var ancient = /^v?\.0/.test(process.version);
+    var isFn = function(fn) {
+      return typeof fn === "function";
+    };
+    var isFS = function(stream) {
+      if (!ancient)
+        return false;
+      if (!fs7)
+        return false;
+      return (stream instanceof (fs7.ReadStream || noop) || stream instanceof (fs7.WriteStream || noop)) && isFn(stream.close);
+    };
+    var isRequest = function(stream) {
+      return stream.setHeader && isFn(stream.abort);
+    };
+    var destroyer = function(stream, reading, writing, callback) {
+      callback = once(callback);
+      var closed = false;
+      stream.on("close", function() {
+        closed = true;
+      });
+      eos2(stream, { readable: reading, writable: writing }, function(err) {
+        if (err)
+          return callback(err);
+        closed = true;
+        callback();
+      });
+      var destroyed = false;
+      return function(err) {
+        if (closed)
+          return;
+        if (destroyed)
+          return;
+        destroyed = true;
+        if (isFS(stream))
+          return stream.close(noop);
+        if (isRequest(stream))
+          return stream.abort();
+        if (isFn(stream.destroy))
+          return stream.destroy();
+        callback(err || new Error("stream was destroyed"));
+      };
+    };
+    var call = function(fn) {
+      fn();
+    };
+    var pipe = function(from, to) {
+      return from.pipe(to);
+    };
+    var pump = function() {
+      var streams = Array.prototype.slice.call(arguments);
+      var callback = isFn(streams[streams.length - 1] || noop) && streams.pop() || noop;
+      if (Array.isArray(streams[0]))
+        streams = streams[0];
+      if (streams.length < 2)
+        throw new Error("pump requires two streams per minimum");
+      var error;
+      var destroys = streams.map(function(stream, i) {
+        var reading = i < streams.length - 1;
+        var writing = i > 0;
+        return destroyer(stream, reading, writing, function(err) {
+          if (!error)
+            error = err;
+          if (err)
+            destroys.forEach(call);
+          if (reading)
+            return;
+          destroys.forEach(call);
+          callback(error);
+        });
+      });
+      return streams.reduce(pipe);
+    };
+    module2.exports = pump;
+  }
+});
+
+// ../../node_modules/.pnpm/get-stream@5.2.0/node_modules/get-stream/buffer-stream.js
+var require_buffer_stream = __commonJS({
+  "../../node_modules/.pnpm/get-stream@5.2.0/node_modules/get-stream/buffer-stream.js"(exports2, module2) {
+    "use strict";
+    var { PassThrough: PassThroughStream } = require("stream");
+    module2.exports = (options) => {
+      options = { ...options };
+      const { array } = options;
+      let { encoding } = options;
+      const isBuffer = encoding === "buffer";
+      let objectMode = false;
+      if (array) {
+        objectMode = !(encoding || isBuffer);
+      } else {
+        encoding = encoding || "utf8";
+      }
+      if (isBuffer) {
+        encoding = null;
+      }
+      const stream = new PassThroughStream({ objectMode });
+      if (encoding) {
+        stream.setEncoding(encoding);
+      }
+      let length = 0;
+      const chunks = [];
+      stream.on("data", (chunk) => {
+        chunks.push(chunk);
+        if (objectMode) {
+          length = chunks.length;
+        } else {
+          length += chunk.length;
+        }
+      });
+      stream.getBufferedValue = () => {
+        if (array) {
+          return chunks;
+        }
+        return isBuffer ? Buffer.concat(chunks, length) : chunks.join("");
+      };
+      stream.getBufferedLength = () => length;
+      return stream;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/get-stream@5.2.0/node_modules/get-stream/index.js
+var require_get_stream = __commonJS({
+  "../../node_modules/.pnpm/get-stream@5.2.0/node_modules/get-stream/index.js"(exports2, module2) {
+    "use strict";
+    var { constants: BufferConstants } = require("buffer");
+    var pump = require_pump();
+    var bufferStream = require_buffer_stream();
+    var MaxBufferError = class extends Error {
+      constructor() {
+        super("maxBuffer exceeded");
+        this.name = "MaxBufferError";
+      }
+    };
+    async function getStream(inputStream, options) {
+      if (!inputStream) {
+        return Promise.reject(new Error("Expected a stream"));
+      }
+      options = {
+        maxBuffer: Infinity,
+        ...options
+      };
+      const { maxBuffer } = options;
+      let stream;
+      await new Promise((resolve, reject) => {
+        const rejectPromise = (error) => {
+          if (error && stream.getBufferedLength() <= BufferConstants.MAX_LENGTH) {
+            error.bufferedData = stream.getBufferedValue();
+          }
+          reject(error);
+        };
+        stream = pump(inputStream, bufferStream(options), (error) => {
+          if (error) {
+            rejectPromise(error);
+            return;
+          }
+          resolve();
+        });
+        stream.on("data", () => {
+          if (stream.getBufferedLength() > maxBuffer) {
+            rejectPromise(new MaxBufferError());
+          }
+        });
+      });
+      return stream.getBufferedValue();
+    }
+    module2.exports = getStream;
+    module2.exports.default = getStream;
+    module2.exports.buffer = (stream, options) => getStream(stream, { ...options, encoding: "buffer" });
+    module2.exports.array = (stream, options) => getStream(stream, { ...options, array: true });
+    module2.exports.MaxBufferError = MaxBufferError;
+  }
+});
+
+// ../../node_modules/.pnpm/merge-stream@2.0.0/node_modules/merge-stream/index.js
+var require_merge_stream = __commonJS({
+  "../../node_modules/.pnpm/merge-stream@2.0.0/node_modules/merge-stream/index.js"(exports2, module2) {
+    "use strict";
+    var { PassThrough } = require("stream");
+    module2.exports = function() {
+      var sources = [];
+      var output = new PassThrough({ objectMode: true });
+      output.setMaxListeners(0);
+      output.add = add;
+      output.isEmpty = isEmpty;
+      output.on("unpipe", remove2);
+      Array.prototype.slice.call(arguments).forEach(add);
+      return output;
+      function add(source) {
+        if (Array.isArray(source)) {
+          source.forEach(add);
+          return this;
+        }
+        sources.push(source);
+        source.once("end", remove2.bind(null, source));
+        source.once("error", output.emit.bind(output, "error"));
+        source.pipe(output, { end: false });
+        return this;
+      }
+      function isEmpty() {
+        return sources.length == 0;
+      }
+      function remove2(source) {
+        sources = sources.filter(function(it) {
+          return it !== source;
+        });
+        if (!sources.length && output.readable) {
+          output.end();
+        }
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/execa@3.2.0/node_modules/execa/lib/stream.js
+var require_stream2 = __commonJS({
+  "../../node_modules/.pnpm/execa@3.2.0/node_modules/execa/lib/stream.js"(exports2, module2) {
+    "use strict";
+    var isStream = require_is_stream();
+    var getStream = require_get_stream();
+    var mergeStream = require_merge_stream();
+    var handleInput = (spawned, input) => {
+      if (input === void 0 || spawned.stdin === void 0) {
+        return;
+      }
+      if (isStream(input)) {
+        input.pipe(spawned.stdin);
+      } else {
+        spawned.stdin.end(input);
+      }
+    };
+    var makeAllStream = (spawned, { all }) => {
+      if (!all || !spawned.stdout && !spawned.stderr) {
+        return;
+      }
+      const mixed = mergeStream();
+      if (spawned.stdout) {
+        mixed.add(spawned.stdout);
+      }
+      if (spawned.stderr) {
+        mixed.add(spawned.stderr);
+      }
+      return mixed;
+    };
+    var getBufferedData = async (stream, streamPromise) => {
+      if (!stream) {
+        return;
+      }
+      stream.destroy();
+      try {
+        return await streamPromise;
+      } catch (error) {
+        return error.bufferedData;
+      }
+    };
+    var getStreamPromise = (stream, { encoding, buffer, maxBuffer }) => {
+      if (!stream || !buffer) {
+        return;
+      }
+      if (encoding) {
+        return getStream(stream, { encoding, maxBuffer });
+      }
+      return getStream.buffer(stream, { maxBuffer });
+    };
+    var getSpawnedResult = async ({ stdout, stderr, all }, { encoding, buffer, maxBuffer }, processDone) => {
+      const stdoutPromise = getStreamPromise(stdout, { encoding, buffer, maxBuffer });
+      const stderrPromise = getStreamPromise(stderr, { encoding, buffer, maxBuffer });
+      const allPromise = getStreamPromise(all, { encoding, buffer, maxBuffer: maxBuffer * 2 });
+      try {
+        return await Promise.all([processDone, stdoutPromise, stderrPromise, allPromise]);
+      } catch (error) {
+        return Promise.all([
+          { error, signal: error.signal, timedOut: error.timedOut },
+          getBufferedData(stdout, stdoutPromise),
+          getBufferedData(stderr, stderrPromise),
+          getBufferedData(all, allPromise)
+        ]);
+      }
+    };
+    var validateInputSync = ({ input }) => {
+      if (isStream(input)) {
+        throw new TypeError("The `input` option cannot be a stream in sync mode");
+      }
+    };
+    module2.exports = {
+      handleInput,
+      makeAllStream,
+      getSpawnedResult,
+      validateInputSync
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/execa@3.2.0/node_modules/execa/lib/promise.js
+var require_promise = __commonJS({
+  "../../node_modules/.pnpm/execa@3.2.0/node_modules/execa/lib/promise.js"(exports2, module2) {
+    "use strict";
+    var mergePromiseProperty = (spawned, promise, property) => {
+      const value = typeof promise === "function" ? (...args) => promise()[property](...args) : promise[property].bind(promise);
+      Object.defineProperty(spawned, property, {
+        value,
+        writable: true,
+        enumerable: false,
+        configurable: true
+      });
+    };
+    var mergePromise = (spawned, promise) => {
+      mergePromiseProperty(spawned, promise, "then");
+      mergePromiseProperty(spawned, promise, "catch");
+      if (Promise.prototype.finally) {
+        mergePromiseProperty(spawned, promise, "finally");
+      }
+      return spawned;
+    };
+    var getSpawnedPromise = (spawned) => {
+      return new Promise((resolve, reject) => {
+        spawned.on("exit", (exitCode, signal) => {
+          resolve({ exitCode, signal });
+        });
+        spawned.on("error", (error) => {
+          reject(error);
+        });
+        if (spawned.stdin) {
+          spawned.stdin.on("error", (error) => {
+            reject(error);
+          });
+        }
+      });
+    };
+    module2.exports = {
+      mergePromise,
+      getSpawnedPromise
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/execa@3.2.0/node_modules/execa/lib/command.js
+var require_command = __commonJS({
+  "../../node_modules/.pnpm/execa@3.2.0/node_modules/execa/lib/command.js"(exports2, module2) {
+    "use strict";
+    var SPACES_REGEXP = / +/g;
+    var joinCommand = (file, args = []) => {
+      if (!Array.isArray(args)) {
+        return file;
+      }
+      return [file, ...args].join(" ");
+    };
+    var handleEscaping = (tokens, token, index) => {
+      if (index === 0) {
+        return [token];
+      }
+      const previousToken = tokens[tokens.length - 1];
+      if (previousToken.endsWith("\\")) {
+        return [...tokens.slice(0, -1), `${previousToken.slice(0, -1)} ${token}`];
+      }
+      return [...tokens, token];
+    };
+    var parseCommand = (command) => {
+      return command.trim().split(SPACES_REGEXP).reduce(handleEscaping, []);
+    };
+    module2.exports = {
+      joinCommand,
+      parseCommand
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/execa@3.2.0/node_modules/execa/index.js
+var require_execa = __commonJS({
+  "../../node_modules/.pnpm/execa@3.2.0/node_modules/execa/index.js"(exports2, module2) {
+    "use strict";
+    var path7 = require("path");
+    var childProcess = require("child_process");
+    var crossSpawn = require_cross_spawn2();
+    var stripFinalNewline = require_strip_final_newline();
+    var npmRunPath = require_npm_run_path();
+    var onetime = require_onetime();
+    var makeError = require_error();
+    var normalizeStdio = require_stdio();
+    var { spawnedKill, spawnedCancel, setupTimeout, setExitHandler } = require_kill();
+    var { handleInput, getSpawnedResult, makeAllStream, validateInputSync } = require_stream2();
+    var { mergePromise, getSpawnedPromise } = require_promise();
+    var { joinCommand, parseCommand } = require_command();
+    var DEFAULT_MAX_BUFFER = 1e3 * 1e3 * 100;
+    var getEnv = ({ env: envOption, extendEnv, preferLocal, localDir, execPath }) => {
+      const env = extendEnv ? { ...process.env, ...envOption } : envOption;
+      if (preferLocal) {
+        return npmRunPath.env({ env, cwd: localDir, execPath });
+      }
+      return env;
+    };
+    var handleArgs = (file, args, options = {}) => {
+      const parsed = crossSpawn._parse(file, args, options);
+      file = parsed.command;
+      args = parsed.args;
+      options = parsed.options;
+      options = {
+        maxBuffer: DEFAULT_MAX_BUFFER,
+        buffer: true,
+        stripFinalNewline: true,
+        extendEnv: true,
+        preferLocal: false,
+        localDir: options.cwd || process.cwd(),
+        execPath: process.execPath,
+        encoding: "utf8",
+        reject: true,
+        cleanup: true,
+        all: false,
+        ...options,
+        windowsHide: true
+      };
+      options.env = getEnv(options);
+      options.stdio = normalizeStdio(options);
+      if (process.platform === "win32" && path7.basename(file, ".exe") === "cmd") {
+        args.unshift("/q");
+      }
+      return { file, args, options, parsed };
+    };
+    var handleOutput = (options, value, error) => {
+      if (typeof value !== "string" && !Buffer.isBuffer(value)) {
+        return error === void 0 ? void 0 : "";
+      }
+      if (options.stripFinalNewline) {
+        return stripFinalNewline(value);
+      }
+      return value;
+    };
+    var execa2 = (file, args, options) => {
+      const parsed = handleArgs(file, args, options);
+      const command = joinCommand(file, args);
+      let spawned;
+      try {
+        spawned = childProcess.spawn(parsed.file, parsed.args, parsed.options);
+      } catch (error) {
+        const dummySpawned = new childProcess.ChildProcess();
+        const errorPromise = Promise.reject(makeError({
+          error,
+          stdout: "",
+          stderr: "",
+          all: "",
+          command,
+          parsed,
+          timedOut: false,
+          isCanceled: false,
+          killed: false
+        }));
+        return mergePromise(dummySpawned, errorPromise);
+      }
+      const spawnedPromise = getSpawnedPromise(spawned);
+      const timedPromise = setupTimeout(spawned, parsed.options, spawnedPromise);
+      const processDone = setExitHandler(spawned, parsed.options, timedPromise);
+      const context = { isCanceled: false };
+      spawned.kill = spawnedKill.bind(null, spawned.kill.bind(spawned));
+      spawned.cancel = spawnedCancel.bind(null, spawned, context);
+      const handlePromise = async () => {
+        const [{ error, exitCode, signal, timedOut }, stdoutResult, stderrResult, allResult] = await getSpawnedResult(spawned, parsed.options, processDone);
+        const stdout = handleOutput(parsed.options, stdoutResult);
+        const stderr = handleOutput(parsed.options, stderrResult);
+        const all = handleOutput(parsed.options, allResult);
+        if (error || exitCode !== 0 || signal !== null) {
+          const returnedError = makeError({
+            error,
+            exitCode,
+            signal,
+            stdout,
+            stderr,
+            all,
+            command,
+            parsed,
+            timedOut,
+            isCanceled: context.isCanceled,
+            killed: spawned.killed
+          });
+          if (!parsed.options.reject) {
+            return returnedError;
+          }
+          throw returnedError;
+        }
+        return {
+          command,
+          exitCode: 0,
+          stdout,
+          stderr,
+          all,
+          failed: false,
+          timedOut: false,
+          isCanceled: false,
+          killed: false
+        };
+      };
+      const handlePromiseOnce = onetime(handlePromise);
+      crossSpawn._enoent.hookChildProcess(spawned, parsed.parsed);
+      handleInput(spawned, parsed.options.input);
+      spawned.all = makeAllStream(spawned, parsed.options);
+      return mergePromise(spawned, handlePromiseOnce);
+    };
+    module2.exports = execa2;
+    module2.exports.sync = (file, args, options) => {
+      const parsed = handleArgs(file, args, options);
+      const command = joinCommand(file, args);
+      validateInputSync(parsed.options);
+      let result;
+      try {
+        result = childProcess.spawnSync(parsed.file, parsed.args, parsed.options);
+      } catch (error) {
+        throw makeError({
+          error,
+          stdout: "",
+          stderr: "",
+          all: "",
+          command,
+          parsed,
+          timedOut: false,
+          isCanceled: false,
+          killed: false
+        });
+      }
+      const stdout = handleOutput(parsed.options, result.stdout, result.error);
+      const stderr = handleOutput(parsed.options, result.stderr, result.error);
+      if (result.error || result.status !== 0 || result.signal !== null) {
+        const error = makeError({
+          stdout,
+          stderr,
+          error: result.error,
+          signal: result.signal,
+          exitCode: result.status,
+          command,
+          parsed,
+          timedOut: result.error && result.error.code === "ETIMEDOUT",
+          isCanceled: false,
+          killed: result.signal !== null
+        });
+        if (!parsed.options.reject) {
+          return error;
+        }
+        throw error;
+      }
+      return {
+        command,
+        exitCode: 0,
+        stdout,
+        stderr,
+        failed: false,
+        timedOut: false,
+        isCanceled: false,
+        killed: false
+      };
+    };
+    module2.exports.command = (command, options) => {
+      const [file, ...args] = parseCommand(command);
+      return execa2(file, args, options);
+    };
+    module2.exports.commandSync = (command, options) => {
+      const [file, ...args] = parseCommand(command);
+      return execa2.sync(file, args, options);
+    };
+    module2.exports.node = (scriptPath, args, options = {}) => {
+      if (args && !Array.isArray(args) && typeof args === "object") {
+        options = args;
+        args = [];
+      }
+      const stdio = normalizeStdio.node(options);
+      const { nodePath = process.execPath, nodeOptions = process.execArgv } = options;
+      return execa2(
+        nodePath,
+        [
+          ...nodeOptions,
+          scriptPath,
+          ...Array.isArray(args) ? args : []
+        ],
+        {
+          ...options,
+          stdin: void 0,
+          stdout: void 0,
+          stderr: void 0,
+          stdio,
+          shell: false
+        }
+      );
+    };
+  }
+});
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  BACKEND_FRAMEWORKS: () => BACKEND_FRAMEWORKS,
+  BUILDER_COMPILE_STEP: () => BUILDER_COMPILE_STEP,
+  BUILDER_INSTALLER_STEP: () => BUILDER_INSTALLER_STEP,
+  BunVersion: () => BunVersion,
+  EdgeFunction: () => EdgeFunction,
+  FileBlob: () => FileBlob,
+  FileFsRef: () => file_fs_ref_default,
+  FileRef: () => FileRef,
+  Lambda: () => Lambda,
+  NODE_VERSIONS: () => NODE_VERSIONS,
+  NodeVersion: () => NodeVersion,
+  NodejsLambda: () => NodejsLambda,
+  NowBuildError: () => NowBuildError,
+  Prerender: () => Prerender,
+  Span: () => Span,
+  Version: () => Version,
+  buildsSchema: () => buildsSchema,
+  cloneEnv: () => cloneEnv,
+  createLambda: () => createLambda,
+  debug: () => debug,
+  defaultCachePathGlob: () => defaultCachePathGlob,
+  detectPackageManager: () => detectPackageManager,
+  download: () => download,
+  downloadFile: () => downloadFile,
+  execCommand: () => execCommand,
+  findPackageJson: () => findPackageJson,
+  functionsSchema: () => functionsSchema,
+  generateNodeBuilderFunctions: () => generateNodeBuilderFunctions,
+  getDiscontinuedNodeVersions: () => getDiscontinuedNodeVersions,
+  getEnvForPackageManager: () => getEnvForPackageManager,
+  getIgnoreFilter: () => get_ignore_filter_default,
+  getInstalledPackageVersion: () => getInstalledPackageVersion,
+  getLambdaOptionsFromFunction: () => getLambdaOptionsFromFunction,
+  getLatestNodeVersion: () => getLatestNodeVersion,
+  getNodeBinPath: () => getNodeBinPath,
+  getNodeBinPaths: () => getNodeBinPaths,
+  getNodeVersion: () => getNodeVersion,
+  getOsRelease: () => getOsRelease,
+  getPackageJson: () => getPackageJson,
+  getPathForPackageManager: () => getPathForPackageManager,
+  getPlatformEnv: () => getPlatformEnv,
+  getPrefixedEnvVars: () => getPrefixedEnvVars,
+  getPrettyError: () => getPrettyError,
+  getProvidedRuntime: () => getProvidedRuntime,
+  getScriptName: () => getScriptName,
+  getSpawnOptions: () => getSpawnOptions,
+  getSupportedBunVersion: () => getSupportedBunVersion,
+  getSupportedNodeVersion: () => getSupportedNodeVersion,
+  getWriteableDirectory: () => getWritableDirectory,
+  glob: () => glob,
+  hardLinkDir: () => hardLinkDir,
+  installDependencies: () => installDependencies,
+  isBackendBuilder: () => isBackendBuilder,
+  isBackendFramework: () => isBackendFramework,
+  isBunVersion: () => isBunVersion,
+  isDirectory: () => isDirectory,
+  isExperimentalBackendsEnabled: () => isExperimentalBackendsEnabled,
+  isExperimentalBackendsWithoutIntrospectionEnabled: () => isExperimentalBackendsWithoutIntrospectionEnabled,
+  isPythonEntrypoint: () => isPythonEntrypoint,
+  isSymbolicLink: () => isSymbolicLink,
+  normalizePath: () => normalizePath,
+  readConfigFile: () => readConfigFile,
+  rename: () => rename,
+  resetCustomInstallCommandSet: () => resetCustomInstallCommandSet,
+  runBundleInstall: () => runBundleInstall,
+  runCustomInstallCommand: () => runCustomInstallCommand,
+  runNpmInstall: () => runNpmInstall,
+  runPackageJsonScript: () => runPackageJsonScript,
+  runPipInstall: () => runPipInstall,
+  runShellScript: () => runShellScript,
+  runStdlibPyScript: () => runStdlibPyScript,
+  scanParentDirs: () => scanParentDirs,
+  shouldServe: () => shouldServe,
+  shouldUseExperimentalBackends: () => shouldUseExperimentalBackends,
+  spawnAsync: () => spawnAsync,
+  spawnCommand: () => spawnCommand,
+  streamToBuffer: () => streamToBuffer,
+  streamToBufferChunks: () => streamToBufferChunks,
+  traverseUpDirectories: () => traverseUpDirectories,
+  validateNpmrc: () => validateNpmrc,
+  walkParentDirs: () => walkParentDirs
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/file-blob.ts
+var import_assert = __toESM(require("assert"));
+var import_into_stream = __toESM(require_into_stream());
+var FileBlob = class _FileBlob {
+  constructor({ mode = 33188, contentType, data }) {
+    (0, import_assert.default)(typeof mode === "number");
+    (0, import_assert.default)(typeof data === "string" || Buffer.isBuffer(data));
+    this.type = "FileBlob";
+    this.mode = mode;
+    this.contentType = contentType;
+    this.data = data;
+  }
+  static async fromStream({
+    mode = 33188,
+    contentType,
+    stream
+  }) {
+    (0, import_assert.default)(typeof mode === "number");
+    (0, import_assert.default)(typeof stream.pipe === "function");
+    const chunks = [];
+    await new Promise((resolve, reject) => {
+      stream.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
+      stream.on("error", (error) => reject(error));
+      stream.on("end", () => resolve());
+    });
+    const data = Buffer.concat(chunks);
+    return new _FileBlob({ mode, contentType, data });
+  }
+  async toStreamAsync() {
+    return this.toStream();
+  }
+  toStream() {
+    return (0, import_into_stream.default)(this.data);
+  }
+};
+
+// src/file-fs-ref.ts
+var import_assert2 = __toESM(require("assert"));
+var import_fs_extra = __toESM(require_lib());
+var import_multistream = __toESM(require_multistream());
+var import_path = __toESM(require("path"));
+var import_async_sema = __toESM(require_async_sema());
+var semaToPreventEMFILE = new import_async_sema.default(20);
+var FileFsRef = class _FileFsRef {
+  constructor({
+    mode = 33188,
+    contentType,
+    fsPath,
+    size
+  }) {
+    (0, import_assert2.default)(typeof mode === "number");
+    (0, import_assert2.default)(typeof fsPath === "string");
+    this.type = "FileFsRef";
+    this.mode = mode;
+    this.contentType = contentType;
+    this.fsPath = fsPath;
+    this.size = size;
+  }
+  static async fromFsPath({
+    mode,
+    contentType,
+    fsPath,
+    size
+  }) {
+    let m = mode;
+    let s = size;
+    if (!m || typeof s === "undefined") {
+      const stat = await import_fs_extra.default.lstat(fsPath);
+      m = stat.mode;
+      s = stat.size;
+    }
+    return new _FileFsRef({ mode: m, contentType, fsPath, size: s });
   }
   static async fromStream({
     mode = 33188,
@@ -22399,6 +24304,7 @@ var Lambda = class {
     const {
       handler,
       runtime,
+      runtimeLanguage,
       maxDuration,
       architecture,
       memory,
@@ -22412,7 +24318,8 @@ var Lambda = class {
       operationType,
       framework,
       experimentalTriggers,
-      supportsCancellation
+      supportsCancellation,
+      shouldDisableAutomaticFetchInstrumentation
     } = opts;
     if ("files" in opts) {
       (0, import_assert4.default)(typeof opts.files === "object", '"files" must be an object');
@@ -22429,6 +24336,12 @@ var Lambda = class {
         '"architecture" must be either "x86_64" or "arm64"'
       );
     }
+    if (runtimeLanguage !== void 0) {
+      (0, import_assert4.default)(
+        runtimeLanguage === "rust" || runtimeLanguage === "go",
+        '"runtimeLanguage" is invalid. Valid options: "rust", "go"'
+      );
+    }
     if ("experimentalAllowBundling" in opts && opts.experimentalAllowBundling !== void 0) {
       (0, import_assert4.default)(
         typeof opts.experimentalAllowBundling === "boolean",
@@ -22552,6 +24465,7 @@ var Lambda = class {
     this.files = "files" in opts ? opts.files : void 0;
     this.handler = handler;
     this.runtime = runtime;
+    this.runtimeLanguage = runtimeLanguage;
     this.architecture = getDefaultLambdaArchitecture(architecture);
     this.memory = memory;
     this.maxDuration = maxDuration;
@@ -22566,6 +24480,7 @@ var Lambda = class {
     this.experimentalAllowBundling = "experimentalAllowBundling" in opts ? opts.experimentalAllowBundling : void 0;
     this.experimentalTriggers = experimentalTriggers;
     this.supportsCancellation = supportsCancellation;
+    this.shouldDisableAutomaticFetchInstrumentation = shouldDisableAutomaticFetchInstrumentation;
   }
   async createZip() {
     let { zipBuffer } = this;
@@ -22922,7 +24837,7 @@ function rename(files, delegate) {
 // src/fs/run-user-scripts.ts
 var import_assert6 = __toESM(require("assert"));
 var import_fs_extra7 = __toESM(require_lib());
-var import_path5 = __toESM(require("path"));
+var import_path6 = __toESM(require("path"));
 var import_async_sema4 = __toESM(require_async_sema());
 var import_cross_spawn = __toESM(require_cross_spawn());
 var import_semver2 = __toESM(require_semver2());
@@ -22960,6 +24875,11 @@ var BunVersion = class extends Version {
 
 // src/fs/node-version.ts
 var NODE_VERSIONS = [
+  new NodeVersion({
+    major: 24,
+    range: "24.x",
+    runtime: "nodejs24.x"
+  }),
   new NodeVersion({
     major: 22,
     range: "22.x",
@@ -23059,7 +24979,7 @@ async function getSupportedNodeVersion(engineRange, isAuto = false, availableVer
     if (!found) {
       throw new NowBuildError({
         code: "BUILD_UTILS_NODE_VERSION_INVALID",
-        link: "http://vercel.link/node-version",
+        link: "https://vercel.link/node-version",
         message: `Found invalid Node.js Version: "${engineRange}". ${getHint(
           isAuto,
           availableVersions
@@ -23074,7 +24994,7 @@ async function getSupportedNodeVersion(engineRange, isAuto = false, availableVer
     const intro = `Node.js Version "${selection.range}" is discontinued and must be upgraded.`;
     throw new NowBuildError({
       code: "BUILD_UTILS_NODE_VERSION_DISCONTINUED",
-      link: "http://vercel.link/node-version",
+      link: "https://vercel.link/node-version",
       message: `${intro} ${getHint(isAuto)}`
     });
   }
@@ -23124,6 +25044,7 @@ var import_js_yaml = __toESM(require_js_yaml2());
 var import_toml = __toESM(require_toml());
 var import_fs_extra6 = __toESM(require_lib());
 var import_error_utils = __toESM(require_dist());
+var import_path5 = require("path");
 async function readFileOrNull(file) {
   try {
     const data = await (0, import_fs_extra6.readFile)(file);
@@ -23159,6 +25080,14 @@ async function readConfigFile(files) {
   }
   return null;
 }
+async function getPackageJson(dir) {
+  const packagePath = (0, import_path5.join)(dir, "package.json");
+  try {
+    return JSON.parse(await (0, import_fs_extra6.readFile)(packagePath, "utf8"));
+  } catch (err) {
+    return {};
+  }
+}
 
 // src/clone-env.ts
 var { hasOwnProperty: hasOwnProperty2 } = Object.prototype;
@@ -23229,13 +25158,13 @@ function* traverseUpDirectories({
   start,
   base
 }) {
-  let current = import_path5.default.normalize(start);
-  const normalizedRoot = base ? import_path5.default.normalize(base) : void 0;
+  let current = import_path6.default.normalize(start);
+  const normalizedRoot = base ? import_path6.default.normalize(base) : void 0;
   while (current) {
     yield current;
     if (current === normalizedRoot)
       break;
-    const next = import_path5.default.join(current, "..");
+    const next = import_path6.default.join(current, "..");
     current = next === current ? void 0 : next;
   }
 }
@@ -23245,29 +25174,29 @@ async function readProjectRootInfo({
 }) {
   let curRootPackageJsonPath;
   for (const dir of traverseUpDirectories({ start, base })) {
-    const packageJsonPath = import_path5.default.join(dir, "package.json");
+    const packageJsonPath = import_path6.default.join(dir, "package.json");
     if (await import_fs_extra7.default.pathExists(packageJsonPath)) {
       curRootPackageJsonPath = packageJsonPath;
     }
   }
   return curRootPackageJsonPath ? {
     packageJson: await import_fs_extra7.default.readJson(curRootPackageJsonPath),
-    rootDir: import_path5.default.dirname(curRootPackageJsonPath)
+    rootDir: import_path6.default.dirname(curRootPackageJsonPath)
   } : void 0;
 }
 async function getNodeBinPath({
   cwd
 }) {
   const { lockfilePath } = await scanParentDirs(cwd);
-  const dir = import_path5.default.dirname(lockfilePath || cwd);
-  return import_path5.default.join(dir, "node_modules", ".bin");
+  const dir = import_path6.default.dirname(lockfilePath || cwd);
+  return import_path6.default.join(dir, "node_modules", ".bin");
 }
 function getNodeBinPaths({
   start,
   base
 }) {
   return Array.from(traverseUpDirectories({ start, base })).map(
-    (dir) => import_path5.default.join(dir, "node_modules/.bin")
+    (dir) => import_path6.default.join(dir, "node_modules/.bin")
   );
 }
 async function chmodPlusX(fsPath) {
@@ -23279,10 +25208,10 @@ async function chmodPlusX(fsPath) {
   await import_fs_extra7.default.chmod(fsPath, base8);
 }
 async function runShellScript(fsPath, args = [], spawnOpts) {
-  (0, import_assert6.default)(import_path5.default.isAbsolute(fsPath));
-  const destPath = import_path5.default.dirname(fsPath);
+  (0, import_assert6.default)(import_path6.default.isAbsolute(fsPath));
+  const destPath = import_path6.default.dirname(fsPath);
   await chmodPlusX(fsPath);
-  const command = `./${import_path5.default.basename(fsPath)}`;
+  const command = `./${import_path6.default.basename(fsPath)}`;
   await spawnAsync(command, args, {
     ...spawnOpts,
     cwd: destPath,
@@ -23300,7 +25229,7 @@ function getSpawnOptions(meta, nodeVersion) {
   if (!meta.isDev) {
     let found = false;
     const oldPath = opts.env.PATH || process.env.PATH || "";
-    const pathSegments = oldPath.split(import_path5.default.delimiter).map((segment) => {
+    const pathSegments = oldPath.split(import_path6.default.delimiter).map((segment) => {
       if (/^\/node[0-9]+\/bin/.test(segment)) {
         found = true;
         return `/node${nodeVersion.major}/bin`;
@@ -23310,7 +25239,7 @@ function getSpawnOptions(meta, nodeVersion) {
     if (!found) {
       pathSegments.unshift(`/node${nodeVersion.major}/bin`);
     }
-    opts.env.PATH = pathSegments.filter(Boolean).join(import_path5.default.delimiter);
+    opts.env.PATH = pathSegments.filter(Boolean).join(import_path6.default.delimiter);
   }
   return opts;
 }
@@ -23323,7 +25252,7 @@ async function getNodeVersion(destPath, fallbackVersion = process.env.VERCEL_PRO
     latestVersion.runtime = "nodejs";
     return latestVersion;
   }
-  const { packageJson } = await scanParentDirs(destPath, true);
+  const { packageJson } = await findPackageJson(destPath, true);
   const configuredVersion = config.nodeVersion || fallbackVersion;
   const packageJsonVersion = packageJson?.engines?.node;
   const supportedNodeVersion = await getSupportedNodeVersion(
@@ -23335,23 +25264,23 @@ async function getNodeVersion(destPath, fallbackVersion = process.env.VERCEL_PRO
     const { node } = packageJson.engines;
     if (configuredVersion && !(0, import_semver2.intersects)(configuredVersion, supportedNodeVersion.range)) {
       console.warn(
-        `Warning: Due to "engines": { "node": "${node}" } in your \`package.json\` file, the Node.js Version defined in your Project Settings ("${configuredVersion}") will not apply, Node.js Version "${supportedNodeVersion.range}" will be used instead. Learn More: http://vercel.link/node-version`
+        `Warning: Due to "engines": { "node": "${node}" } in your \`package.json\` file, the Node.js Version defined in your Project Settings ("${configuredVersion}") will not apply, Node.js Version "${supportedNodeVersion.range}" will be used instead. Learn More: https://vercel.link/node-version`
       );
     }
     if ((0, import_semver2.coerce)(node)?.raw === node) {
       console.warn(
-        `Warning: Detected "engines": { "node": "${node}" } in your \`package.json\` with major.minor.patch, but only major Node.js Version can be selected. Learn More: http://vercel.link/node-version`
+        `Warning: Detected "engines": { "node": "${node}" } in your \`package.json\` with major.minor.patch, but only major Node.js Version can be selected. Learn More: https://vercel.link/node-version`
       );
     } else if ((0, import_semver2.validRange)(node) && (0, import_semver2.intersects)(`${latestVersion.major + 1}.x`, node)) {
       console.warn(
-        `Warning: Detected "engines": { "node": "${node}" } in your \`package.json\` that will automatically upgrade when a new major Node.js Version is released. Learn More: http://vercel.link/node-version`
+        `Warning: Detected "engines": { "node": "${node}" } in your \`package.json\` that will automatically upgrade when a new major Node.js Version is released. Learn More: https://vercel.link/node-version`
       );
     }
   }
   return supportedNodeVersion;
 }
-async function scanParentDirs(destPath, readPackageJson = false, base = "/") {
-  (0, import_assert6.default)(import_path5.default.isAbsolute(destPath));
+async function findPackageJson(destPath, readPackageJson = false, base = "/") {
+  (0, import_assert6.default)(import_path6.default.isAbsolute(destPath));
   const pkgJsonPath = await walkParentDirs({
     base,
     start: destPath,
@@ -23367,6 +25296,18 @@ async function scanParentDirs(destPath, readPackageJson = false, base = "/") {
       );
     }
   }
+  return {
+    packageJsonPath: pkgJsonPath || void 0,
+    packageJson
+  };
+}
+async function scanParentDirs(destPath, readPackageJson = false, base = "/") {
+  (0, import_assert6.default)(import_path6.default.isAbsolute(destPath));
+  const { packageJsonPath: pkgJsonPath, packageJson } = await findPackageJson(
+    destPath,
+    readPackageJson,
+    base
+  );
   const {
     paths: [
       yarnLockPath,
@@ -23464,8 +25405,8 @@ async function checkTurboSupportsCorepack(turboVersionRange, rootDir) {
   if (turboVersionSpecifierSupportsCorepack(turboVersionRange)) {
     return true;
   }
-  const turboJsonPath = import_path5.default.join(rootDir, "turbo.json");
-  const turboJsoncPath = import_path5.default.join(rootDir, "turbo.jsonc");
+  const turboJsonPath = import_path6.default.join(rootDir, "turbo.json");
+  const turboJsoncPath = import_path6.default.join(rootDir, "turbo.jsonc");
   const [turboJsonExists, turboJsoncExists] = await Promise.all([
     import_fs_extra7.default.pathExists(turboJsonPath),
     import_fs_extra7.default.pathExists(turboJsoncPath)
@@ -23482,7 +25423,7 @@ async function checkTurboSupportsCorepack(turboVersionRange, rootDir) {
       turboJson = import_json5.default.parse(await import_fs_extra7.default.readFile(turboConfigPath, "utf8"));
     } catch (err) {
       console.warn(
-        `WARNING: Failed to parse ${import_path5.default.basename(turboConfigPath)}`
+        `WARNING: Failed to parse ${import_path6.default.basename(turboConfigPath)}`
       );
     }
   }
@@ -23542,10 +25483,10 @@ async function walkParentDirs({
   start,
   filename
 }) {
-  (0, import_assert6.default)(import_path5.default.isAbsolute(base), 'Expected "base" to be absolute path');
-  (0, import_assert6.default)(import_path5.default.isAbsolute(start), 'Expected "start" to be absolute path');
+  (0, import_assert6.default)(import_path6.default.isAbsolute(base), 'Expected "base" to be absolute path');
+  (0, import_assert6.default)(import_path6.default.isAbsolute(start), 'Expected "start" to be absolute path');
   for (const dir of traverseUpDirectories({ start, base })) {
-    const fullPath = import_path5.default.join(dir, filename);
+    const fullPath = import_path6.default.join(dir, filename);
     if (await import_fs_extra7.default.pathExists(fullPath)) {
       return fullPath;
     }
@@ -23559,12 +25500,12 @@ async function walkParentDirsMulti({
 }) {
   let packageManager;
   for (const dir of traverseUpDirectories({ start, base })) {
-    const fullPaths = filenames.map((f) => import_path5.default.join(dir, f));
+    const fullPaths = filenames.map((f) => import_path6.default.join(dir, f));
     const existResults = await Promise.all(
       fullPaths.map((f) => import_fs_extra7.default.pathExists(f))
     );
     const foundOneOrMore = existResults.some((b) => b);
-    const packageJsonPath = import_path5.default.join(dir, "package.json");
+    const packageJsonPath = import_path6.default.join(dir, "package.json");
     const packageJson = await import_fs_extra7.default.readJSON(packageJsonPath).catch(() => null);
     if (packageJson?.packageManager) {
       packageManager = packageJson.packageManager;
@@ -23586,7 +25527,7 @@ function getInstallCommandForPackageManager(packageManager, args) {
     case "npm":
       return {
         prettyCommand: "npm install",
-        commandArguments: args.filter((a) => a !== "--prefer-offline").concat(["install", "--no-audit", "--unsafe-perm"])
+        commandArguments: args.filter((a) => a !== "--prefer-offline").concat(["install", "--no-audit"])
       };
     case "pnpm":
       return {
@@ -23638,12 +25579,16 @@ function checkIfAlreadyInstalled(runNpmInstallSet, packageJsonPath) {
   return { alreadyInstalled, runNpmInstallSet: initializedRunNpmInstallSet };
 }
 var runNpmInstallSema = new import_async_sema4.default(1);
+var customInstallCommandSet;
+function resetCustomInstallCommandSet() {
+  customInstallCommandSet = void 0;
+}
 async function runNpmInstall(destPath, args = [], spawnOpts, meta, projectCreatedAt) {
   if (meta?.isDev) {
     debug("Skipping dependency installation because dev mode is enabled");
     return false;
   }
-  (0, import_assert6.default)(import_path5.default.isAbsolute(destPath));
+  (0, import_assert6.default)(import_path6.default.isAbsolute(destPath));
   try {
     await runNpmInstallSema.acquire();
     const {
@@ -23669,6 +25614,14 @@ async function runNpmInstall(destPath, args = [], spawnOpts, meta, projectCreate
       if (alreadyInstalled) {
         return false;
       }
+      if (process.env.VERCEL_INSTALL_COMPLETED === "1") {
+        debug(
+          `Skipping dependency installation for ${packageJsonPath} because VERCEL_INSTALL_COMPLETED is set`
+        );
+        runNpmInstallSet.add(packageJsonPath);
+        meta.runNpmInstallSet = runNpmInstallSet;
+        return false;
+      }
       meta.runNpmInstallSet = runNpmInstallSet;
     }
     if (cliType === "yarn") {
@@ -23753,11 +25706,11 @@ function getEnvForPackageManager({
   };
   const alreadyInPath = (newPath2) => {
     const oldPath = env.PATH ?? "";
-    return oldPath.split(import_path5.default.delimiter).includes(newPath2);
+    return oldPath.split(import_path6.default.delimiter).includes(newPath2);
   };
   if (newPath && !alreadyInPath(newPath)) {
     const oldPath = env.PATH + "";
-    newEnv.PATH = `${newPath}${import_path5.default.delimiter}${oldPath}`;
+    newEnv.PATH = `${newPath}${import_path6.default.delimiter}${oldPath}`;
     if (detectedLockfile && detectedPackageManager) {
       const detectedV9PnpmLockfile = detectedLockfile === "pnpm-lock.yaml" && lockfileVersion === 9;
       const pnpm10UsingPackageJsonPackageManager = detectedPackageManager === "pnpm@10.x" && packageJsonPackageManager;
@@ -23779,11 +25732,6 @@ To use ${otherVersion}, manually opt in using corepack (https://vercel.com/docs/
           `Detected \`${detectedLockfile}\` ${versionString}generated by ${detectedPackageManager}`
         );
       }
-      if (cliType === "bun") {
-        console.warn(
-          "Warning: Bun is used as a package manager at build time only, not at runtime with Functions"
-        );
-      }
     }
   }
   if (cliType === "yarn" && !env.YARN_NODE_LINKER) {
@@ -24041,7 +25989,7 @@ function getPathForPackageManager({
   }
   const alreadyInPath = (newPath) => {
     const oldPath = env.PATH ?? "";
-    return oldPath.split(import_path5.default.delimiter).includes(newPath);
+    return oldPath.split(import_path6.default.delimiter).includes(newPath);
   };
   switch (true) {
     case (cliType === "yarn" && !env.YARN_NODE_LINKER):
@@ -24063,6 +26011,24 @@ async function runCustomInstallCommand({
   spawnOpts,
   projectCreatedAt
 }) {
+  const normalizedPath = import_path6.default.normalize(destPath);
+  const { alreadyInstalled, runNpmInstallSet } = checkIfAlreadyInstalled(
+    customInstallCommandSet,
+    normalizedPath
+  );
+  customInstallCommandSet = runNpmInstallSet;
+  if (alreadyInstalled) {
+    debug(
+      `Skipping custom install command for ${normalizedPath} because it was already run`
+    );
+    return false;
+  }
+  if (process.env.VERCEL_INSTALL_COMPLETED === "1") {
+    debug(
+      `Skipping custom install command for ${normalizedPath} because VERCEL_INSTALL_COMPLETED is set`
+    );
+    return false;
+  }
   console.log(`Running "install" command: \`${installCommand}\`...`);
   const {
     cliType,
@@ -24086,9 +26052,10 @@ async function runCustomInstallCommand({
     env,
     cwd: destPath
   });
+  return true;
 }
 async function runPackageJsonScript(destPath, scriptNames, spawnOpts, projectCreatedAt) {
-  (0, import_assert6.default)(import_path5.default.isAbsolute(destPath));
+  (0, import_assert6.default)(import_path6.default.isAbsolute(destPath));
   const {
     packageJson,
     cliType,
@@ -24138,7 +26105,7 @@ async function runBundleInstall(destPath, args = [], spawnOpts, meta) {
     debug("Skipping dependency installation because dev mode is enabled");
     return;
   }
-  (0, import_assert6.default)(import_path5.default.isAbsolute(destPath));
+  (0, import_assert6.default)(import_path6.default.isAbsolute(destPath));
   const opts = { ...spawnOpts, cwd: destPath, prettyCommand: "bundle install" };
   await spawnAsync("bundle", args.concat(["install"]), opts);
 }
@@ -24147,7 +26114,7 @@ async function runPipInstall(destPath, args = [], spawnOpts, meta) {
     debug("Skipping dependency installation because dev mode is enabled");
     return;
   }
-  (0, import_assert6.default)(import_path5.default.isAbsolute(destPath));
+  (0, import_assert6.default)(import_path6.default.isAbsolute(destPath));
   const opts = { ...spawnOpts, cwd: destPath, prettyCommand: "pip3 install" };
   await spawnAsync(
     "pip3",
@@ -24171,7 +26138,7 @@ var installDependencies = (0, import_util2.deprecate)(
 );
 
 // src/get-ignore-filter.ts
-var import_path6 = __toESM(require("path"));
+var import_path7 = __toESM(require("path"));
 var import_fs_extra8 = __toESM(require_lib());
 var import_ignore = __toESM(require_ignore());
 function isCodedError(error) {
@@ -24191,12 +26158,12 @@ async function get_ignore_filter_default(downloadPath, rootDirectory) {
       throw error;
     }
   };
-  const vercelIgnorePath = import_path6.default.join(
+  const vercelIgnorePath = import_path7.default.join(
     downloadPath,
     rootDirectory || "",
     ".vercelignore"
   );
-  const nowIgnorePath = import_path6.default.join(
+  const nowIgnorePath = import_path7.default.join(
     downloadPath,
     rootDirectory || "",
     ".nowignore"
@@ -24259,22 +26226,22 @@ function getPrefixedEnvVars({
 }
 
 // src/hard-link-dir.ts
-var import_path7 = __toESM(require("path"));
+var import_path8 = __toESM(require("path"));
 var import_fs2 = require("fs");
 async function hardLinkDir(src, destDirs) {
   if (destDirs.length === 0)
     return;
-  destDirs = destDirs.filter((destDir) => import_path7.default.relative(destDir, src) !== "");
+  destDirs = destDirs.filter((destDir) => import_path8.default.relative(destDir, src) !== "");
   const files = await import_fs2.promises.readdir(src);
   await Promise.all(
     files.map(async (file) => {
       if (file === "node_modules")
         return;
-      const srcFile = import_path7.default.join(src, file);
+      const srcFile = import_path8.default.join(src, file);
       if ((await import_fs2.promises.lstat(srcFile)).isDirectory()) {
         const destSubdirs = await Promise.all(
           destDirs.map(async (destDir) => {
-            const destSubdir = import_path7.default.join(destDir, file);
+            const destSubdir = import_path8.default.join(destDir, file);
             try {
               await import_fs2.promises.mkdir(destSubdir, { recursive: true });
             } catch (err) {
@@ -24289,7 +26256,7 @@ async function hardLinkDir(src, destDirs) {
       }
       await Promise.all(
         destDirs.map(async (destDir) => {
-          const destFile = import_path7.default.join(destDir, file);
+          const destFile = import_path8.default.join(destDir, file);
           try {
             await linkOrCopyFile(srcFile, destFile);
           } catch (err) {
@@ -24308,7 +26275,7 @@ async function linkOrCopyFile(srcFile, destFile) {
     await linkOrCopy(srcFile, destFile);
   } catch (err) {
     if (err.code === "ENOENT") {
-      await import_fs2.promises.mkdir(import_path7.default.dirname(destFile), { recursive: true });
+      await import_fs2.promises.mkdir(import_path8.default.dirname(destFile), { recursive: true });
       await linkOrCopy(srcFile, destFile);
       return;
     }
@@ -24328,10 +26295,10 @@ async function linkOrCopy(srcFile, destFile) {
 }
 
 // src/validate-npmrc.ts
-var import_path8 = require("path");
+var import_path9 = require("path");
 var import_promises = require("fs/promises");
 async function validateNpmrc(cwd) {
-  const npmrc = await (0, import_promises.readFile)((0, import_path8.join)(cwd, ".npmrc"), "utf-8").catch((err) => {
+  const npmrc = await (0, import_promises.readFile)((0, import_path9.join)(cwd, ".npmrc"), "utf-8").catch((err) => {
     if (err.code !== "ENOENT")
       throw err;
   });
@@ -24392,7 +26359,7 @@ async function getProvidedRuntime() {
 }
 
 // src/should-serve.ts
-var import_path9 = require("path");
+var import_path10 = require("path");
 var shouldServe = ({
   entrypoint,
   files,
@@ -24403,7 +26370,7 @@ var shouldServe = ({
   if (entrypoint === requestPath && hasProp(files, entrypoint)) {
     return true;
   }
-  const { dir, name } = (0, import_path9.parse)(entrypoint);
+  const { dir, name } = (0, import_path10.parse)(entrypoint);
   if (name === "index" && dir === requestPath && hasProp(files, entrypoint)) {
     return true;
   }
@@ -24610,7 +26577,7 @@ var defaultCachePathGlob = "**/{node_modules,.yarn/cache}/**";
 var import_node_path = require("path");
 var import_node_fs = __toESM(require("fs"));
 var import_node_module = require("module");
-function generateNodeBuilderFunctions(frameworkName, regex, validFilenames, validExtensions, nodeBuild) {
+function generateNodeBuilderFunctions(frameworkName, regex, validFilenames, validExtensions, nodeBuild, opts) {
   const entrypointsForMessage = validFilenames.map((filename) => `- ${filename}.{${validExtensions.join(",")}}`).join("\n");
   const require_ = (0, import_node_module.createRequire)(__filename);
   const build = async (args) => {
@@ -24632,7 +26599,9 @@ function generateNodeBuilderFunctions(frameworkName, regex, validFilenames, vali
       considerBuildCommand: true,
       entrypointCallback: async () => {
         return entrypointCallback(args);
-      }
+      },
+      checks: opts?.checks ?? (() => {
+      })
     });
     let version = void 0;
     try {
@@ -24771,21 +26740,88 @@ var BACKEND_FRAMEWORKS = [
   "express",
   "hono",
   "h3",
+  "koa",
   "nestjs",
-  "fastify"
+  "fastify",
+  "elysia"
+];
+var BACKEND_BUILDERS = [
+  "@vercel/express",
+  "@vercel/hono",
+  "@vercel/h3",
+  "@vercel/koa",
+  "@vercel/nestjs",
+  "@vercel/fastify",
+  "@vercel/elysia"
 ];
 function isBackendFramework(framework) {
   if (!framework)
     return false;
   return BACKEND_FRAMEWORKS.includes(framework);
 }
+function isExperimentalBackendsWithoutIntrospectionEnabled() {
+  return process.env.VERCEL_BACKENDS_BUILDS === "1";
+}
 function isExperimentalBackendsEnabled() {
-  return process.env.VERCEL_EXPERIMENTAL_BACKENDS === "1" || // Previously used for experimental express and hono builds
+  return isExperimentalBackendsWithoutIntrospectionEnabled() || process.env.VERCEL_EXPERIMENTAL_BACKENDS === "1" || // Previously used for experimental express and hono builds
   process.env.VERCEL_EXPERIMENTAL_EXPRESS_BUILD === "1" || process.env.VERCEL_EXPERIMENTAL_HONO_BUILD === "1";
 }
+function isBackendBuilder(builder) {
+  if (!builder)
+    return false;
+  const use = builder.use;
+  return BACKEND_BUILDERS.includes(use);
+}
 function shouldUseExperimentalBackends(framework) {
   return isExperimentalBackendsEnabled() && isBackendFramework(framework);
 }
+
+// src/python.ts
+var import_fs3 = __toESM(require("fs"));
+var import_path11 = require("path");
+var import_execa = __toESM(require_execa());
+var isWin2 = process.platform === "win32";
+async function runStdlibPyScript(options) {
+  const { scriptName, pythonPath, args = [], cwd } = options;
+  const scriptPath = (0, import_path11.join)(__dirname, "..", "lib", "python", `${scriptName}.py`);
+  if (!import_fs3.default.existsSync(scriptPath)) {
+    throw new Error(`Python script not found: ${scriptPath}`);
+  }
+  const pythonCmd = pythonPath ?? (isWin2 ? "python" : "python3");
+  debug(
+    `Running stdlib Python script: ${pythonCmd} ${scriptPath} ${args.join(" ")}`
+  );
+  try {
+    const result = await (0, import_execa.default)(pythonCmd, [scriptPath, ...args], { cwd });
+    return { exitCode: 0, stdout: result.stdout, stderr: result.stderr };
+  } catch (err) {
+    const execaErr = err;
+    return {
+      exitCode: execaErr.exitCode ?? 1,
+      stdout: execaErr.stdout ?? "",
+      stderr: execaErr.stderr ?? ""
+    };
+  }
+}
+async function isPythonEntrypoint(file) {
+  try {
+    const fsPath = file.fsPath;
+    if (!fsPath)
+      return false;
+    const content = await import_fs3.default.promises.readFile(fsPath, "utf-8");
+    if (!content.includes("app") && !content.includes("handler") && !content.includes("Handler")) {
+      return false;
+    }
+    const result = await runStdlibPyScript({
+      scriptName: "ast_parser",
+      args: [fsPath]
+    });
+    return result.exitCode === 0;
+  } catch (err) {
+    debug(`Failed to check Python entrypoint: ${err}`);
+    return false;
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BACKEND_FRAMEWORKS,
@@ -24813,6 +26849,7 @@ function shouldUseExperimentalBackends(framework) {
   download,
   downloadFile,
   execCommand,
+  findPackageJson,
   functionsSchema,
   generateNodeBuilderFunctions,
   getDiscontinuedNodeVersions,
@@ -24825,6 +26862,7 @@ function shouldUseExperimentalBackends(framework) {
   getNodeBinPaths,
   getNodeVersion,
   getOsRelease,
+  getPackageJson,
   getPathForPackageManager,
   getPlatformEnv,
   getPrefixedEnvVars,
@@ -24838,20 +26876,25 @@ function shouldUseExperimentalBackends(framework) {
   glob,
   hardLinkDir,
   installDependencies,
+  isBackendBuilder,
   isBackendFramework,
   isBunVersion,
   isDirectory,
   isExperimentalBackendsEnabled,
+  isExperimentalBackendsWithoutIntrospectionEnabled,
+  isPythonEntrypoint,
   isSymbolicLink,
   normalizePath,
   readConfigFile,
   rename,
+  resetCustomInstallCommandSet,
   runBundleInstall,
   runCustomInstallCommand,
   runNpmInstall,
   runPackageJsonScript,
   runPipInstall,
   runShellScript,
+  runStdlibPyScript,
   scanParentDirs,
   shouldServe,
   shouldUseExperimentalBackends,