@vercel/build-utils 13.14.0 → 13.14.2

package/dist/index.js

@@ -2422,56 +2422,56 @@ var require_polyfills = __commonJS({
     }
     var chdir;
     module2.exports = patch;
-    function patch(fs7) {
+    function patch(fs8) {
       if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-        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) {
+        patchLchmod(fs8);
+      }
+      if (!fs8.lutimes) {
+        patchLutimes(fs8);
+      }
+      fs8.chown = chownFix(fs8.chown);
+      fs8.fchown = chownFix(fs8.fchown);
+      fs8.lchown = chownFix(fs8.lchown);
+      fs8.chmod = chmodFix(fs8.chmod);
+      fs8.fchmod = chmodFix(fs8.fchmod);
+      fs8.lchmod = chmodFix(fs8.lchmod);
+      fs8.chownSync = chownFixSync(fs8.chownSync);
+      fs8.fchownSync = chownFixSync(fs8.fchownSync);
+      fs8.lchownSync = chownFixSync(fs8.lchownSync);
+      fs8.chmodSync = chmodFixSync(fs8.chmodSync);
+      fs8.fchmodSync = chmodFixSync(fs8.fchmodSync);
+      fs8.lchmodSync = chmodFixSync(fs8.lchmodSync);
+      fs8.stat = statFix(fs8.stat);
+      fs8.fstat = statFix(fs8.fstat);
+      fs8.lstat = statFix(fs8.lstat);
+      fs8.statSync = statFixSync(fs8.statSync);
+      fs8.fstatSync = statFixSync(fs8.fstatSync);
+      fs8.lstatSync = statFixSync(fs8.lstatSync);
+      if (fs8.chmod && !fs8.lchmod) {
+        fs8.lchmod = function(path7, mode, cb) {
           if (cb)
             process.nextTick(cb);
         };
-        fs7.lchmodSync = function() {
+        fs8.lchmodSync = function() {
         };
       }
-      if (fs7.chown && !fs7.lchown) {
-        fs7.lchown = function(path7, uid, gid, cb) {
+      if (fs8.chown && !fs8.lchown) {
+        fs8.lchown = function(path7, uid, gid, cb) {
           if (cb)
             process.nextTick(cb);
         };
-        fs7.lchownSync = function() {
+        fs8.lchownSync = function() {
         };
       }
       if (platform === "win32") {
-        fs7.rename = typeof fs7.rename !== "function" ? fs7.rename : function(fs$rename) {
+        fs8.rename = typeof fs8.rename !== "function" ? fs8.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() {
-                  fs7.stat(to, function(stater, st) {
+                  fs8.stat(to, function(stater, st) {
                     if (stater && stater.code === "ENOENT")
                       fs$rename(from, to, CB);
                     else
@@ -2489,9 +2489,9 @@ var require_polyfills = __commonJS({
           if (Object.setPrototypeOf)
             Object.setPrototypeOf(rename2, fs$rename);
           return rename2;
-        }(fs7.rename);
+        }(fs8.rename);
       }
-      fs7.read = typeof fs7.read !== "function" ? fs7.read : function(fs$read) {
+      fs8.read = typeof fs8.read !== "function" ? fs8.read : function(fs$read) {
         function read(fd, buffer, offset, length, position, callback_) {
           var callback;
           if (callback_ && typeof callback_ === "function") {
@@ -2499,23 +2499,23 @@ var require_polyfills = __commonJS({
             callback = function(er, _, __) {
               if (er && er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
-                return fs$read.call(fs7, fd, buffer, offset, length, position, callback);
+                return fs$read.call(fs8, fd, buffer, offset, length, position, callback);
               }
               callback_.apply(this, arguments);
             };
           }
-          return fs$read.call(fs7, fd, buffer, offset, length, position, callback);
+          return fs$read.call(fs8, fd, buffer, offset, length, position, callback);
         }
         if (Object.setPrototypeOf)
           Object.setPrototypeOf(read, fs$read);
         return read;
-      }(fs7.read);
-      fs7.readSync = typeof fs7.readSync !== "function" ? fs7.readSync : function(fs$readSync) {
+      }(fs8.read);
+      fs8.readSync = typeof fs8.readSync !== "function" ? fs8.readSync : function(fs$readSync) {
         return function(fd, buffer, offset, length, position) {
           var eagCounter = 0;
           while (true) {
             try {
-              return fs$readSync.call(fs7, fd, buffer, offset, length, position);
+              return fs$readSync.call(fs8, fd, buffer, offset, length, position);
             } catch (er) {
               if (er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
@@ -2525,10 +2525,10 @@ var require_polyfills = __commonJS({
             }
           }
         };
-      }(fs7.readSync);
-      function patchLchmod(fs8) {
-        fs8.lchmod = function(path7, mode, callback) {
-          fs8.open(
+      }(fs8.readSync);
+      function patchLchmod(fs9) {
+        fs9.lchmod = function(path7, mode, callback) {
+          fs9.open(
             path7,
             constants.O_WRONLY | constants.O_SYMLINK,
             mode,
@@ -2538,8 +2538,8 @@ var require_polyfills = __commonJS({
                   callback(err);
                 return;
               }
-              fs8.fchmod(fd, mode, function(err2) {
-                fs8.close(fd, function(err22) {
+              fs9.fchmod(fd, mode, function(err2) {
+                fs9.close(fd, function(err22) {
                   if (callback)
                     callback(err2 || err22);
                 });
@@ -2547,68 +2547,68 @@ var require_polyfills = __commonJS({
             }
           );
         };
-        fs8.lchmodSync = function(path7, mode) {
-          var fd = fs8.openSync(path7, constants.O_WRONLY | constants.O_SYMLINK, mode);
+        fs9.lchmodSync = function(path7, mode) {
+          var fd = fs9.openSync(path7, constants.O_WRONLY | constants.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
-            ret = fs8.fchmodSync(fd, mode);
+            ret = fs9.fchmodSync(fd, mode);
             threw = false;
           } finally {
             if (threw) {
               try {
-                fs8.closeSync(fd);
+                fs9.closeSync(fd);
               } catch (er) {
               }
             } else {
-              fs8.closeSync(fd);
+              fs9.closeSync(fd);
             }
           }
           return ret;
         };
       }
-      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) {
+      function patchLutimes(fs9) {
+        if (constants.hasOwnProperty("O_SYMLINK") && fs9.futimes) {
+          fs9.lutimes = function(path7, at, mt, cb) {
+            fs9.open(path7, constants.O_SYMLINK, function(er, fd) {
               if (er) {
                 if (cb)
                   cb(er);
                 return;
               }
-              fs8.futimes(fd, at, mt, function(er2) {
-                fs8.close(fd, function(er22) {
+              fs9.futimes(fd, at, mt, function(er2) {
+                fs9.close(fd, function(er22) {
                   if (cb)
                     cb(er2 || er22);
                 });
               });
             });
           };
-          fs8.lutimesSync = function(path7, at, mt) {
-            var fd = fs8.openSync(path7, constants.O_SYMLINK);
+          fs9.lutimesSync = function(path7, at, mt) {
+            var fd = fs9.openSync(path7, constants.O_SYMLINK);
             var ret;
             var threw = true;
             try {
-              ret = fs8.futimesSync(fd, at, mt);
+              ret = fs9.futimesSync(fd, at, mt);
               threw = false;
             } finally {
               if (threw) {
                 try {
-                  fs8.closeSync(fd);
+                  fs9.closeSync(fd);
                 } catch (er) {
                 }
               } else {
-                fs8.closeSync(fd);
+                fs9.closeSync(fd);
               }
             }
             return ret;
           };
-        } else if (fs8.futimes) {
-          fs8.lutimes = function(_a, _b, _c, cb) {
+        } else if (fs9.futimes) {
+          fs9.lutimes = function(_a, _b, _c, cb) {
             if (cb)
               process.nextTick(cb);
           };
-          fs8.lutimesSync = function() {
+          fs9.lutimesSync = function() {
           };
         }
       }
@@ -2616,7 +2616,7 @@ var require_polyfills = __commonJS({
         if (!orig)
           return orig;
         return function(target, mode, cb) {
-          return orig.call(fs7, target, mode, function(er) {
+          return orig.call(fs8, target, mode, function(er) {
             if (chownErOk(er))
               er = null;
             if (cb)
@@ -2629,7 +2629,7 @@ var require_polyfills = __commonJS({
           return orig;
         return function(target, mode) {
           try {
-            return orig.call(fs7, target, mode);
+            return orig.call(fs8, target, mode);
           } catch (er) {
             if (!chownErOk(er))
               throw er;
@@ -2640,7 +2640,7 @@ var require_polyfills = __commonJS({
         if (!orig)
           return orig;
         return function(target, uid, gid, cb) {
-          return orig.call(fs7, target, uid, gid, function(er) {
+          return orig.call(fs8, target, uid, gid, function(er) {
             if (chownErOk(er))
               er = null;
             if (cb)
@@ -2653,7 +2653,7 @@ var require_polyfills = __commonJS({
           return orig;
         return function(target, uid, gid) {
           try {
-            return orig.call(fs7, target, uid, gid);
+            return orig.call(fs8, target, uid, gid);
           } catch (er) {
             if (!chownErOk(er))
               throw er;
@@ -2678,14 +2678,14 @@ var require_polyfills = __commonJS({
             if (cb)
               cb.apply(this, arguments);
           }
-          return options ? orig.call(fs7, target, options, callback) : orig.call(fs7, target, callback);
+          return options ? orig.call(fs8, target, options, callback) : orig.call(fs8, target, callback);
         };
       }
       function statFixSync(orig) {
         if (!orig)
           return orig;
         return function(target, options) {
-          var stats = options ? orig.call(fs7, target, options) : orig.call(fs7, target);
+          var stats = options ? orig.call(fs8, target, options) : orig.call(fs8, target);
           if (stats) {
             if (stats.uid < 0)
               stats.uid += 4294967296;
@@ -2716,7 +2716,7 @@ var require_legacy_streams = __commonJS({
   "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/legacy-streams.js"(exports, module2) {
     var Stream = require("stream").Stream;
     module2.exports = legacy;
-    function legacy(fs7) {
+    function legacy(fs8) {
       return {
         ReadStream,
         WriteStream
@@ -2761,7 +2761,7 @@ var require_legacy_streams = __commonJS({
           });
           return;
         }
-        fs7.open(this.path, this.flags, this.mode, function(err, fd) {
+        fs8.open(this.path, this.flags, this.mode, function(err, fd) {
           if (err) {
             self2.emit("error", err);
             self2.readable = false;
@@ -2801,7 +2801,7 @@ var require_legacy_streams = __commonJS({
         this.busy = false;
         this._queue = [];
         if (this.fd === null) {
-          this._open = fs7.open;
+          this._open = fs8.open;
           this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
           this.flush();
         }
@@ -2836,7 +2836,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"(exports, module2) {
-    var fs7 = require("fs");
+    var fs8 = require("fs");
     var polyfills = require_polyfills();
     var legacy = require_legacy_streams();
     var clone = require_clone();
@@ -2868,12 +2868,12 @@ var require_graceful_fs = __commonJS({
         m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
         console.error(m);
       };
-    if (!fs7[gracefulQueue]) {
+    if (!fs8[gracefulQueue]) {
       queue = global[gracefulQueue] || [];
-      publishQueue(fs7, queue);
-      fs7.close = function(fs$close) {
+      publishQueue(fs8, queue);
+      fs8.close = function(fs$close) {
         function close(fd, cb) {
-          return fs$close.call(fs7, fd, function(err) {
+          return fs$close.call(fs8, fd, function(err) {
             if (!err) {
               resetQueue();
             }
@@ -2885,40 +2885,40 @@ var require_graceful_fs = __commonJS({
           value: fs$close
         });
         return close;
-      }(fs7.close);
-      fs7.closeSync = function(fs$closeSync) {
+      }(fs8.close);
+      fs8.closeSync = function(fs$closeSync) {
         function closeSync(fd) {
-          fs$closeSync.apply(fs7, arguments);
+          fs$closeSync.apply(fs8, arguments);
           resetQueue();
         }
         Object.defineProperty(closeSync, previousSymbol, {
           value: fs$closeSync
         });
         return closeSync;
-      }(fs7.closeSync);
+      }(fs8.closeSync);
       if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
         process.on("exit", function() {
-          debug2(fs7[gracefulQueue]);
-          require("assert").equal(fs7[gracefulQueue].length, 0);
+          debug2(fs8[gracefulQueue]);
+          require("assert").equal(fs8[gracefulQueue].length, 0);
         });
       }
     }
     var queue;
     if (!global[gracefulQueue]) {
-      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;
+      publishQueue(global, fs8[gracefulQueue]);
+    }
+    module2.exports = patch(clone(fs8));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs8.__patched) {
+      module2.exports = patch(fs8);
+      fs8.__patched = true;
+    }
+    function patch(fs9) {
+      polyfills(fs9);
+      fs9.gracefulify = patch;
+      fs9.createReadStream = createReadStream;
+      fs9.createWriteStream = createWriteStream;
+      var fs$readFile = fs9.readFile;
+      fs9.readFile = readFile4;
       function readFile4(path7, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
@@ -2934,8 +2934,8 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$writeFile = fs8.writeFile;
-      fs8.writeFile = writeFile;
+      var fs$writeFile = fs9.writeFile;
+      fs9.writeFile = writeFile;
       function writeFile(path7, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
@@ -2951,9 +2951,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$appendFile = fs8.appendFile;
+      var fs$appendFile = fs9.appendFile;
       if (fs$appendFile)
-        fs8.appendFile = appendFile;
+        fs9.appendFile = appendFile;
       function appendFile(path7, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
@@ -2969,9 +2969,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$copyFile = fs8.copyFile;
+      var fs$copyFile = fs9.copyFile;
       if (fs$copyFile)
-        fs8.copyFile = copyFile;
+        fs9.copyFile = copyFile;
       function copyFile(src, dest, flags, cb) {
         if (typeof flags === "function") {
           cb = flags;
@@ -2989,8 +2989,8 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$readdir = fs8.readdir;
-      fs8.readdir = readdir;
+      var fs$readdir = fs9.readdir;
+      fs9.readdir = readdir;
       var noReaddirOptionVersions = /^v[0-5]\./;
       function readdir(path7, options, cb) {
         if (typeof options === "function")
@@ -3031,21 +3031,21 @@ var require_graceful_fs = __commonJS({
         }
       }
       if (process.version.substr(0, 4) === "v0.8") {
-        var legStreams = legacy(fs8);
+        var legStreams = legacy(fs9);
         ReadStream = legStreams.ReadStream;
         WriteStream = legStreams.WriteStream;
       }
-      var fs$ReadStream = fs8.ReadStream;
+      var fs$ReadStream = fs9.ReadStream;
       if (fs$ReadStream) {
         ReadStream.prototype = Object.create(fs$ReadStream.prototype);
         ReadStream.prototype.open = ReadStream$open;
       }
-      var fs$WriteStream = fs8.WriteStream;
+      var fs$WriteStream = fs9.WriteStream;
       if (fs$WriteStream) {
         WriteStream.prototype = Object.create(fs$WriteStream.prototype);
         WriteStream.prototype.open = WriteStream$open;
       }
-      Object.defineProperty(fs8, "ReadStream", {
+      Object.defineProperty(fs9, "ReadStream", {
         get: function() {
           return ReadStream;
         },
@@ -3055,7 +3055,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      Object.defineProperty(fs8, "WriteStream", {
+      Object.defineProperty(fs9, "WriteStream", {
         get: function() {
           return WriteStream;
         },
@@ -3066,7 +3066,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileReadStream = ReadStream;
-      Object.defineProperty(fs8, "FileReadStream", {
+      Object.defineProperty(fs9, "FileReadStream", {
         get: function() {
           return FileReadStream;
         },
@@ -3077,7 +3077,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileWriteStream = WriteStream;
-      Object.defineProperty(fs8, "FileWriteStream", {
+      Object.defineProperty(fs9, "FileWriteStream", {
         get: function() {
           return FileWriteStream;
         },
@@ -3126,13 +3126,13 @@ var require_graceful_fs = __commonJS({
         });
       }
       function createReadStream(path7, options) {
-        return new fs8.ReadStream(path7, options);
+        return new fs9.ReadStream(path7, options);
       }
       function createWriteStream(path7, options) {
-        return new fs8.WriteStream(path7, options);
+        return new fs9.WriteStream(path7, options);
       }
-      var fs$open = fs8.open;
-      fs8.open = open;
+      var fs$open = fs9.open;
+      fs9.open = open;
       function open(path7, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
@@ -3148,20 +3148,20 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      return fs8;
+      return fs9;
     }
     function enqueue(elem) {
       debug2("ENQUEUE", elem[0].name, elem[1]);
-      fs7[gracefulQueue].push(elem);
+      fs8[gracefulQueue].push(elem);
       retry2();
     }
     var retryTimer;
     function resetQueue() {
       var now = Date.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;
+      for (var i = 0; i < fs8[gracefulQueue].length; ++i) {
+        if (fs8[gracefulQueue][i].length > 2) {
+          fs8[gracefulQueue][i][3] = now;
+          fs8[gracefulQueue][i][4] = now;
         }
       }
       retry2();
@@ -3169,9 +3169,9 @@ var require_graceful_fs = __commonJS({
     function retry2() {
       clearTimeout(retryTimer);
       retryTimer = void 0;
-      if (fs7[gracefulQueue].length === 0)
+      if (fs8[gracefulQueue].length === 0)
         return;
-      var elem = fs7[gracefulQueue].shift();
+      var elem = fs8[gracefulQueue].shift();
       var fn = elem[0];
       var args = elem[1];
       var err = elem[2];
@@ -3193,7 +3193,7 @@ var require_graceful_fs = __commonJS({
           debug2("RETRY", fn.name, args);
           fn.apply(null, args.concat([startTime]));
         } else {
-          fs7[gracefulQueue].push(elem);
+          fs8[gracefulQueue].push(elem);
         }
       }
       if (retryTimer === void 0) {
@@ -3208,7 +3208,7 @@ var require_fs = __commonJS({
   "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/fs/index.js"(exports) {
     "use strict";
     var u = require_universalify().fromCallback;
-    var fs7 = require_graceful_fs();
+    var fs8 = require_graceful_fs();
     var api = [
       "access",
       "appendFile",
@@ -3245,27 +3245,27 @@ var require_fs = __commonJS({
       "utimes",
       "writeFile"
     ].filter((key) => {
-      return typeof fs7[key] === "function";
+      return typeof fs8[key] === "function";
     });
-    Object.assign(exports, fs7);
+    Object.assign(exports, fs8);
     api.forEach((method) => {
-      exports[method] = u(fs7[method]);
+      exports[method] = u(fs8[method]);
     });
-    exports.realpath.native = u(fs7.realpath.native);
+    exports.realpath.native = u(fs8.realpath.native);
     exports.exists = function(filename, callback) {
       if (typeof callback === "function") {
-        return fs7.exists(filename, callback);
+        return fs8.exists(filename, callback);
       }
       return new Promise((resolve) => {
-        return fs7.exists(filename, resolve);
+        return fs8.exists(filename, resolve);
       });
     };
     exports.read = function(fd, buffer, offset, length, position, callback) {
       if (typeof callback === "function") {
-        return fs7.read(fd, buffer, offset, length, position, callback);
+        return fs8.read(fd, buffer, offset, length, position, callback);
       }
       return new Promise((resolve, reject) => {
-        fs7.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
+        fs8.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
           if (err)
             return reject(err);
           resolve({ bytesRead, buffer: buffer2 });
@@ -3274,23 +3274,23 @@ var require_fs = __commonJS({
     };
     exports.write = function(fd, buffer, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs7.write(fd, buffer, ...args);
+        return fs8.write(fd, buffer, ...args);
       }
       return new Promise((resolve, reject) => {
-        fs7.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
+        fs8.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
           if (err)
             return reject(err);
           resolve({ bytesWritten, buffer: buffer2 });
         });
       });
     };
-    if (typeof fs7.writev === "function") {
+    if (typeof fs8.writev === "function") {
       exports.writev = function(fd, buffers, ...args) {
         if (typeof args[args.length - 1] === "function") {
-          return fs7.writev(fd, buffers, ...args);
+          return fs8.writev(fd, buffers, ...args);
         }
         return new Promise((resolve, reject) => {
-          fs7.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
+          fs8.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
             if (err)
               return reject(err);
             resolve({ bytesWritten, buffers: buffers2 });
@@ -3323,7 +3323,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"(exports, module2) {
     "use strict";
-    var fs7 = require_fs();
+    var fs8 = require_fs();
     var { checkPath } = require_utils();
     var getMode = (options) => {
       const defaults = { mode: 511 };
@@ -3333,14 +3333,14 @@ var require_make_dir = __commonJS({
     };
     module2.exports.makeDir = async (dir, options) => {
       checkPath(dir);
-      return fs7.mkdir(dir, {
+      return fs8.mkdir(dir, {
         mode: getMode(options),
         recursive: true
       });
     };
     module2.exports.makeDirSync = (dir, options) => {
       checkPath(dir);
-      return fs7.mkdirSync(dir, {
+      return fs8.mkdirSync(dir, {
         mode: getMode(options),
         recursive: true
       });
@@ -3371,13 +3371,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"(exports, module2) {
     "use strict";
-    var fs7 = require_graceful_fs();
+    var fs8 = require_graceful_fs();
     function utimesMillis(path7, atime, mtime2, callback) {
-      fs7.open(path7, "r+", (err, fd) => {
+      fs8.open(path7, "r+", (err, fd) => {
         if (err)
           return callback(err);
-        fs7.futimes(fd, atime, mtime2, (futimesErr) => {
-          fs7.close(fd, (closeErr) => {
+        fs8.futimes(fd, atime, mtime2, (futimesErr) => {
+          fs8.close(fd, (closeErr) => {
             if (callback)
               callback(futimesErr || closeErr);
           });
@@ -3385,9 +3385,9 @@ var require_utimes = __commonJS({
       });
     }
     function utimesMillisSync(path7, atime, mtime2) {
-      const fd = fs7.openSync(path7, "r+");
-      fs7.futimesSync(fd, atime, mtime2);
-      return fs7.closeSync(fd);
+      const fd = fs8.openSync(path7, "r+");
+      fs8.futimesSync(fd, atime, mtime2);
+      return fs8.closeSync(fd);
     }
     module2.exports = {
       utimesMillis,
@@ -3400,11 +3400,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"(exports, module2) {
     "use strict";
-    var fs7 = require_fs();
+    var fs8 = require_fs();
     var path7 = require("path");
     var util = require("util");
     function getStats(src, dest, opts) {
-      const statFunc = opts.dereference ? (file) => fs7.stat(file, { bigint: true }) : (file) => fs7.lstat(file, { bigint: true });
+      const statFunc = opts.dereference ? (file) => fs8.stat(file, { bigint: true }) : (file) => fs8.lstat(file, { bigint: true });
       return Promise.all([
         statFunc(src),
         statFunc(dest).catch((err) => {
@@ -3416,7 +3416,7 @@ var require_stat = __commonJS({
     }
     function getStatsSync(src, dest, opts) {
       let destStat;
-      const statFunc = opts.dereference ? (file) => fs7.statSync(file, { bigint: true }) : (file) => fs7.lstatSync(file, { bigint: true });
+      const statFunc = opts.dereference ? (file) => fs8.statSync(file, { bigint: true }) : (file) => fs8.lstatSync(file, { bigint: true });
       const srcStat = statFunc(src);
       try {
         destStat = statFunc(dest);
@@ -3482,7 +3482,7 @@ var require_stat = __commonJS({
       const destParent = path7.resolve(path7.dirname(dest));
       if (destParent === srcParent || destParent === path7.parse(destParent).root)
         return cb();
-      fs7.stat(destParent, { bigint: true }, (err, destStat) => {
+      fs8.stat(destParent, { bigint: true }, (err, destStat) => {
         if (err) {
           if (err.code === "ENOENT")
             return cb();
@@ -3501,7 +3501,7 @@ var require_stat = __commonJS({
         return;
       let destStat;
       try {
-        destStat = fs7.statSync(destParent, { bigint: true });
+        destStat = fs8.statSync(destParent, { bigint: true });
       } catch (err) {
         if (err.code === "ENOENT")
           return;
@@ -3538,7 +3538,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"(exports, module2) {
     "use strict";
-    var fs7 = require_graceful_fs();
+    var fs8 = require_graceful_fs();
     var path7 = require("path");
     var mkdirsSync = require_mkdirs().mkdirsSync;
     var utimesMillisSync = require_utimes().utimesMillisSync;
@@ -3563,7 +3563,7 @@ var require_copy_sync = __commonJS({
       if (opts.filter && !opts.filter(src, dest))
         return;
       const destParent = path7.dirname(dest);
-      if (!fs7.existsSync(destParent))
+      if (!fs8.existsSync(destParent))
         mkdirsSync(destParent);
       return getStats(destStat, src, dest, opts);
     }
@@ -3573,7 +3573,7 @@ var require_copy_sync = __commonJS({
       return getStats(destStat, src, dest, opts);
     }
     function getStats(destStat, src, dest, opts) {
-      const statSync2 = opts.dereference ? fs7.statSync : fs7.lstatSync;
+      const statSync2 = opts.dereference ? fs8.statSync : fs8.lstatSync;
       const srcStat = statSync2(src);
       if (srcStat.isDirectory())
         return onDir(srcStat, destStat, src, dest, opts);
@@ -3594,14 +3594,14 @@ var require_copy_sync = __commonJS({
     }
     function mayCopyFile(srcStat, src, dest, opts) {
       if (opts.overwrite) {
-        fs7.unlinkSync(dest);
+        fs8.unlinkSync(dest);
         return copyFile(srcStat, src, dest, opts);
       } else if (opts.errorOnExist) {
         throw new Error(`'${dest}' already exists`);
       }
     }
     function copyFile(srcStat, src, dest, opts) {
-      fs7.copyFileSync(src, dest);
+      fs8.copyFileSync(src, dest);
       if (opts.preserveTimestamps)
         handleTimestamps(srcStat.mode, src, dest);
       return setDestMode(dest, srcStat.mode);
@@ -3618,10 +3618,10 @@ var require_copy_sync = __commonJS({
       return setDestMode(dest, srcMode | 128);
     }
     function setDestMode(dest, srcMode) {
-      return fs7.chmodSync(dest, srcMode);
+      return fs8.chmodSync(dest, srcMode);
     }
     function setDestTimestamps(src, dest) {
-      const updatedSrcStat = fs7.statSync(src);
+      const updatedSrcStat = fs8.statSync(src);
       return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
     }
     function onDir(srcStat, destStat, src, dest, opts) {
@@ -3630,12 +3630,12 @@ var require_copy_sync = __commonJS({
       return copyDir(src, dest, opts);
     }
     function mkDirAndCopy(srcMode, src, dest, opts) {
-      fs7.mkdirSync(dest);
+      fs8.mkdirSync(dest);
       copyDir(src, dest, opts);
       return setDestMode(dest, srcMode);
     }
     function copyDir(src, dest, opts) {
-      fs7.readdirSync(src).forEach((item) => copyDirItem(item, src, dest, opts));
+      fs8.readdirSync(src).forEach((item) => copyDirItem(item, src, dest, opts));
     }
     function copyDirItem(item, src, dest, opts) {
       const srcItem = path7.join(src, item);
@@ -3644,19 +3644,19 @@ var require_copy_sync = __commonJS({
       return startCopy(destStat, srcItem, destItem, opts);
     }
     function onLink(destStat, src, dest, opts) {
-      let resolvedSrc = fs7.readlinkSync(src);
+      let resolvedSrc = fs8.readlinkSync(src);
       if (opts.dereference) {
         resolvedSrc = path7.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
-        return fs7.symlinkSync(resolvedSrc, dest);
+        return fs8.symlinkSync(resolvedSrc, dest);
       } else {
         let resolvedDest;
         try {
-          resolvedDest = fs7.readlinkSync(dest);
+          resolvedDest = fs8.readlinkSync(dest);
         } catch (err) {
           if (err.code === "EINVAL" || err.code === "UNKNOWN")
-            return fs7.symlinkSync(resolvedSrc, dest);
+            return fs8.symlinkSync(resolvedSrc, dest);
           throw err;
         }
         if (opts.dereference) {
@@ -3665,15 +3665,15 @@ var require_copy_sync = __commonJS({
         if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
           throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
         }
-        if (fs7.statSync(dest).isDirectory() && stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
+        if (fs8.statSync(dest).isDirectory() && stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
           throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
         }
         return copyLink(resolvedSrc, dest);
       }
     }
     function copyLink(resolvedSrc, dest) {
-      fs7.unlinkSync(dest);
-      return fs7.symlinkSync(resolvedSrc, dest);
+      fs8.unlinkSync(dest);
+      return fs8.symlinkSync(resolvedSrc, dest);
     }
     module2.exports = copySync;
   }
@@ -3694,13 +3694,13 @@ var require_path_exists = __commonJS({
   "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/path-exists/index.js"(exports, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs7 = require_fs();
+    var fs8 = require_fs();
     function pathExists(path7) {
-      return fs7.access(path7).then(() => true).catch(() => false);
+      return fs8.access(path7).then(() => true).catch(() => false);
     }
     module2.exports = {
       pathExists: u(pathExists),
-      pathExistsSync: fs7.existsSync
+      pathExistsSync: fs8.existsSync
     };
   }
 });
@@ -3709,7 +3709,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"(exports, module2) {
     "use strict";
-    var fs7 = require_graceful_fs();
+    var fs8 = require_graceful_fs();
     var path7 = require("path");
     var mkdirs = require_mkdirs().mkdirs;
     var pathExists = require_path_exists().pathExists;
@@ -3772,7 +3772,7 @@ var require_copy = __commonJS({
       return getStats(destStat, src, dest, opts, cb);
     }
     function getStats(destStat, src, dest, opts, cb) {
-      const stat2 = opts.dereference ? fs7.stat : fs7.lstat;
+      const stat2 = opts.dereference ? fs8.stat : fs8.lstat;
       stat2(src, (err, srcStat) => {
         if (err)
           return cb(err);
@@ -3796,7 +3796,7 @@ var require_copy = __commonJS({
     }
     function mayCopyFile(srcStat, src, dest, opts, cb) {
       if (opts.overwrite) {
-        fs7.unlink(dest, (err) => {
+        fs8.unlink(dest, (err) => {
           if (err)
             return cb(err);
           return copyFile(srcStat, src, dest, opts, cb);
@@ -3807,7 +3807,7 @@ var require_copy = __commonJS({
         return cb();
     }
     function copyFile(srcStat, src, dest, opts, cb) {
-      fs7.copyFile(src, dest, (err) => {
+      fs8.copyFile(src, dest, (err) => {
         if (err)
           return cb(err);
         if (opts.preserveTimestamps)
@@ -3839,10 +3839,10 @@ var require_copy = __commonJS({
       });
     }
     function setDestMode(dest, srcMode, cb) {
-      return fs7.chmod(dest, srcMode, cb);
+      return fs8.chmod(dest, srcMode, cb);
     }
     function setDestTimestamps(src, dest, cb) {
-      fs7.stat(src, (err, updatedSrcStat) => {
+      fs8.stat(src, (err, updatedSrcStat) => {
         if (err)
           return cb(err);
         return utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime, cb);
@@ -3854,7 +3854,7 @@ var require_copy = __commonJS({
       return copyDir(src, dest, opts, cb);
     }
     function mkDirAndCopy(srcMode, src, dest, opts, cb) {
-      fs7.mkdir(dest, (err) => {
+      fs8.mkdir(dest, (err) => {
         if (err)
           return cb(err);
         copyDir(src, dest, opts, (err2) => {
@@ -3865,7 +3865,7 @@ var require_copy = __commonJS({
       });
     }
     function copyDir(src, dest, opts, cb) {
-      fs7.readdir(src, (err, items) => {
+      fs8.readdir(src, (err, items) => {
         if (err)
           return cb(err);
         return copyDirItems(items, src, dest, opts, cb);
@@ -3892,19 +3892,19 @@ var require_copy = __commonJS({
       });
     }
     function onLink(destStat, src, dest, opts, cb) {
-      fs7.readlink(src, (err, resolvedSrc) => {
+      fs8.readlink(src, (err, resolvedSrc) => {
         if (err)
           return cb(err);
         if (opts.dereference) {
           resolvedSrc = path7.resolve(process.cwd(), resolvedSrc);
         }
         if (!destStat) {
-          return fs7.symlink(resolvedSrc, dest, cb);
+          return fs8.symlink(resolvedSrc, dest, cb);
         } else {
-          fs7.readlink(dest, (err2, resolvedDest) => {
+          fs8.readlink(dest, (err2, resolvedDest) => {
             if (err2) {
               if (err2.code === "EINVAL" || err2.code === "UNKNOWN")
-                return fs7.symlink(resolvedSrc, dest, cb);
+                return fs8.symlink(resolvedSrc, dest, cb);
               return cb(err2);
             }
             if (opts.dereference) {
@@ -3922,10 +3922,10 @@ var require_copy = __commonJS({
       });
     }
     function copyLink(resolvedSrc, dest, cb) {
-      fs7.unlink(dest, (err) => {
+      fs8.unlink(dest, (err) => {
         if (err)
           return cb(err);
-        return fs7.symlink(resolvedSrc, dest, cb);
+        return fs8.symlink(resolvedSrc, dest, cb);
       });
     }
     module2.exports = copy;
@@ -3947,7 +3947,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"(exports, module2) {
     "use strict";
-    var fs7 = require_graceful_fs();
+    var fs8 = require_graceful_fs();
     var path7 = require("path");
     var assert7 = require("assert");
     var isWindows = process.platform === "win32";
@@ -3961,9 +3961,9 @@ var require_rimraf = __commonJS({
         "readdir"
       ];
       methods.forEach((m) => {
-        options[m] = options[m] || fs7[m];
+        options[m] = options[m] || fs8[m];
         m = m + "Sync";
-        options[m] = options[m] || fs7[m];
+        options[m] = options[m] || fs8[m];
       });
       options.maxBusyTries = options.maxBusyTries || 3;
     }
@@ -4186,17 +4186,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"(exports, module2) {
     "use strict";
-    var fs7 = require_graceful_fs();
+    var fs8 = require_graceful_fs();
     var u = require_universalify().fromCallback;
     var rimraf = require_rimraf();
     function remove2(path7, callback) {
-      if (fs7.rm)
-        return fs7.rm(path7, { recursive: true, force: true }, callback);
+      if (fs8.rm)
+        return fs8.rm(path7, { recursive: true, force: true }, callback);
       rimraf(path7, callback);
     }
     function removeSync(path7) {
-      if (fs7.rmSync)
-        return fs7.rmSync(path7, { recursive: true, force: true });
+      if (fs8.rmSync)
+        return fs8.rmSync(path7, { recursive: true, force: true });
       rimraf.sync(path7);
     }
     module2.exports = {
@@ -4211,14 +4211,14 @@ var require_empty = __commonJS({
   "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/empty/index.js"(exports, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs7 = require_fs();
+    var fs8 = 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 fs7.readdir(dir);
+        items = await fs8.readdir(dir);
       } catch {
         return mkdir.mkdirs(dir);
       }
@@ -4227,7 +4227,7 @@ var require_empty = __commonJS({
     function emptyDirSync(dir) {
       let items;
       try {
-        items = fs7.readdirSync(dir);
+        items = fs8.readdirSync(dir);
       } catch {
         return mkdir.mkdirsSync(dir);
       }
@@ -4251,21 +4251,21 @@ var require_file = __commonJS({
     "use strict";
     var u = require_universalify().fromCallback;
     var path7 = require("path");
-    var fs7 = require_graceful_fs();
+    var fs8 = require_graceful_fs();
     var mkdir = require_mkdirs();
     function createFile(file, callback) {
       function makeFile() {
-        fs7.writeFile(file, "", (err) => {
+        fs8.writeFile(file, "", (err) => {
           if (err)
             return callback(err);
           callback();
         });
       }
-      fs7.stat(file, (err, stats) => {
+      fs8.stat(file, (err, stats) => {
         if (!err && stats.isFile())
           return callback();
         const dir = path7.dirname(file);
-        fs7.stat(dir, (err2, stats2) => {
+        fs8.stat(dir, (err2, stats2) => {
           if (err2) {
             if (err2.code === "ENOENT") {
               return mkdir.mkdirs(dir, (err3) => {
@@ -4279,7 +4279,7 @@ var require_file = __commonJS({
           if (stats2.isDirectory())
             makeFile();
           else {
-            fs7.readdir(dir, (err3) => {
+            fs8.readdir(dir, (err3) => {
               if (err3)
                 return callback(err3);
             });
@@ -4290,15 +4290,15 @@ var require_file = __commonJS({
     function createFileSync(file) {
       let stats;
       try {
-        stats = fs7.statSync(file);
+        stats = fs8.statSync(file);
       } catch {
       }
       if (stats && stats.isFile())
         return;
       const dir = path7.dirname(file);
       try {
-        if (!fs7.statSync(dir).isDirectory()) {
-          fs7.readdirSync(dir);
+        if (!fs8.statSync(dir).isDirectory()) {
+          fs8.readdirSync(dir);
         }
       } catch (err) {
         if (err && err.code === "ENOENT")
@@ -4306,7 +4306,7 @@ var require_file = __commonJS({
         else
           throw err;
       }
-      fs7.writeFileSync(file, "");
+      fs8.writeFileSync(file, "");
     }
     module2.exports = {
       createFile: u(createFile),
@@ -4321,20 +4321,20 @@ var require_link = __commonJS({
     "use strict";
     var u = require_universalify().fromCallback;
     var path7 = require("path");
-    var fs7 = require_graceful_fs();
+    var fs8 = 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) {
-        fs7.link(srcpath2, dstpath2, (err) => {
+        fs8.link(srcpath2, dstpath2, (err) => {
           if (err)
             return callback(err);
           callback(null);
         });
       }
-      fs7.lstat(dstpath, (_, dstStat) => {
-        fs7.lstat(srcpath, (err, srcStat) => {
+      fs8.lstat(dstpath, (_, dstStat) => {
+        fs8.lstat(srcpath, (err, srcStat) => {
           if (err) {
             err.message = err.message.replace("lstat", "ensureLink");
             return callback(err);
@@ -4359,11 +4359,11 @@ var require_link = __commonJS({
     function createLinkSync(srcpath, dstpath) {
       let dstStat;
       try {
-        dstStat = fs7.lstatSync(dstpath);
+        dstStat = fs8.lstatSync(dstpath);
       } catch {
       }
       try {
-        const srcStat = fs7.lstatSync(srcpath);
+        const srcStat = fs8.lstatSync(srcpath);
         if (dstStat && areIdentical(srcStat, dstStat))
           return;
       } catch (err) {
@@ -4371,11 +4371,11 @@ var require_link = __commonJS({
         throw err;
       }
       const dir = path7.dirname(dstpath);
-      const dirExists = fs7.existsSync(dir);
+      const dirExists = fs8.existsSync(dir);
       if (dirExists)
-        return fs7.linkSync(srcpath, dstpath);
+        return fs8.linkSync(srcpath, dstpath);
       mkdir.mkdirsSync(dir);
-      return fs7.linkSync(srcpath, dstpath);
+      return fs8.linkSync(srcpath, dstpath);
     }
     module2.exports = {
       createLink: u(createLink),
@@ -4389,11 +4389,11 @@ var require_symlink_paths = __commonJS({
   "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports, module2) {
     "use strict";
     var path7 = require("path");
-    var fs7 = require_graceful_fs();
+    var fs8 = require_graceful_fs();
     var pathExists = require_path_exists().pathExists;
     function symlinkPaths(srcpath, dstpath, callback) {
       if (path7.isAbsolute(srcpath)) {
-        return fs7.lstat(srcpath, (err) => {
+        return fs8.lstat(srcpath, (err) => {
           if (err) {
             err.message = err.message.replace("lstat", "ensureSymlink");
             return callback(err);
@@ -4415,7 +4415,7 @@ var require_symlink_paths = __commonJS({
               toDst: srcpath
             });
           } else {
-            return fs7.lstat(srcpath, (err2) => {
+            return fs8.lstat(srcpath, (err2) => {
               if (err2) {
                 err2.message = err2.message.replace("lstat", "ensureSymlink");
                 return callback(err2);
@@ -4432,7 +4432,7 @@ var require_symlink_paths = __commonJS({
     function symlinkPathsSync(srcpath, dstpath) {
       let exists;
       if (path7.isAbsolute(srcpath)) {
-        exists = fs7.existsSync(srcpath);
+        exists = fs8.existsSync(srcpath);
         if (!exists)
           throw new Error("absolute srcpath does not exist");
         return {
@@ -4442,14 +4442,14 @@ var require_symlink_paths = __commonJS({
       } else {
         const dstdir = path7.dirname(dstpath);
         const relativeToDst = path7.join(dstdir, srcpath);
-        exists = fs7.existsSync(relativeToDst);
+        exists = fs8.existsSync(relativeToDst);
         if (exists) {
           return {
             toCwd: relativeToDst,
             toDst: srcpath
           };
         } else {
-          exists = fs7.existsSync(srcpath);
+          exists = fs8.existsSync(srcpath);
           if (!exists)
             throw new Error("relative srcpath does not exist");
           return {
@@ -4470,13 +4470,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"(exports, module2) {
     "use strict";
-    var fs7 = require_graceful_fs();
+    var fs8 = 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);
-      fs7.lstat(srcpath, (err, stats) => {
+      fs8.lstat(srcpath, (err, stats) => {
         if (err)
           return callback(null, "file");
         type = stats && stats.isDirectory() ? "dir" : "file";
@@ -4488,7 +4488,7 @@ var require_symlink_type = __commonJS({
       if (type)
         return type;
       try {
-        stats = fs7.lstatSync(srcpath);
+        stats = fs8.lstatSync(srcpath);
       } catch {
         return "file";
       }
@@ -4507,7 +4507,7 @@ var require_symlink = __commonJS({
     "use strict";
     var u = require_universalify().fromCallback;
     var path7 = require("path");
-    var fs7 = require_fs();
+    var fs8 = require_fs();
     var _mkdirs = require_mkdirs();
     var mkdirs = _mkdirs.mkdirs;
     var mkdirsSync = _mkdirs.mkdirsSync;
@@ -4522,11 +4522,11 @@ var require_symlink = __commonJS({
     function createSymlink(srcpath, dstpath, type, callback) {
       callback = typeof type === "function" ? type : callback;
       type = typeof type === "function" ? false : type;
-      fs7.lstat(dstpath, (err, stats) => {
+      fs8.lstat(dstpath, (err, stats) => {
         if (!err && stats.isSymbolicLink()) {
           Promise.all([
-            fs7.stat(srcpath),
-            fs7.stat(dstpath)
+            fs8.stat(srcpath),
+            fs8.stat(dstpath)
           ]).then(([srcStat, dstStat]) => {
             if (areIdentical(srcStat, dstStat))
               return callback(null);
@@ -4549,11 +4549,11 @@ var require_symlink = __commonJS({
             if (err3)
               return callback(err3);
             if (dirExists)
-              return fs7.symlink(srcpath, dstpath, type2, callback);
+              return fs8.symlink(srcpath, dstpath, type2, callback);
             mkdirs(dir, (err4) => {
               if (err4)
                 return callback(err4);
-              fs7.symlink(srcpath, dstpath, type2, callback);
+              fs8.symlink(srcpath, dstpath, type2, callback);
             });
           });
         });
@@ -4562,12 +4562,12 @@ var require_symlink = __commonJS({
     function createSymlinkSync(srcpath, dstpath, type) {
       let stats;
       try {
-        stats = fs7.lstatSync(dstpath);
+        stats = fs8.lstatSync(dstpath);
       } catch {
       }
       if (stats && stats.isSymbolicLink()) {
-        const srcStat = fs7.statSync(srcpath);
-        const dstStat = fs7.statSync(dstpath);
+        const srcStat = fs8.statSync(srcpath);
+        const dstStat = fs8.statSync(dstpath);
         if (areIdentical(srcStat, dstStat))
           return;
       }
@@ -4575,11 +4575,11 @@ var require_symlink = __commonJS({
       srcpath = relative.toDst;
       type = symlinkTypeSync(relative.toCwd, type);
       const dir = path7.dirname(dstpath);
-      const exists = fs7.existsSync(dir);
+      const exists = fs8.existsSync(dir);
       if (exists)
-        return fs7.symlinkSync(srcpath, dstpath, type);
+        return fs8.symlinkSync(srcpath, dstpath, type);
       mkdirsSync(dir);
-      return fs7.symlinkSync(srcpath, dstpath, type);
+      return fs8.symlinkSync(srcpath, dstpath, type);
     }
     module2.exports = {
       createSymlink: u(createSymlink),
@@ -4647,9 +4647,9 @@ var require_jsonfile = __commonJS({
       if (typeof options === "string") {
         options = { encoding: options };
       }
-      const fs7 = options.fs || _fs;
+      const fs8 = options.fs || _fs;
       const shouldThrow = "throws" in options ? options.throws : true;
-      let data = await universalify.fromCallback(fs7.readFile)(file, options);
+      let data = await universalify.fromCallback(fs8.readFile)(file, options);
       data = stripBom(data);
       let obj;
       try {
@@ -4669,10 +4669,10 @@ var require_jsonfile = __commonJS({
       if (typeof options === "string") {
         options = { encoding: options };
       }
-      const fs7 = options.fs || _fs;
+      const fs8 = options.fs || _fs;
       const shouldThrow = "throws" in options ? options.throws : true;
       try {
-        let content = fs7.readFileSync(file, options);
+        let content = fs8.readFileSync(file, options);
         content = stripBom(content);
         return JSON.parse(content, options.reviver);
       } catch (err) {
@@ -4685,15 +4685,15 @@ var require_jsonfile = __commonJS({
       }
     }
     async function _writeFile(file, obj, options = {}) {
-      const fs7 = options.fs || _fs;
+      const fs8 = options.fs || _fs;
       const str = stringify2(obj, options);
-      await universalify.fromCallback(fs7.writeFile)(file, str, options);
+      await universalify.fromCallback(fs8.writeFile)(file, str, options);
     }
     var writeFile = universalify.fromPromise(_writeFile);
     function writeFileSync(file, obj, options = {}) {
-      const fs7 = options.fs || _fs;
+      const fs8 = options.fs || _fs;
       const str = stringify2(obj, options);
-      return fs7.writeFileSync(file, str, options);
+      return fs8.writeFileSync(file, str, options);
     }
     var jsonfile = {
       readFile: readFile4,
@@ -4725,7 +4725,7 @@ var require_output = __commonJS({
   "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/output/index.js"(exports, module2) {
     "use strict";
     var u = require_universalify().fromCallback;
-    var fs7 = require_graceful_fs();
+    var fs8 = require_graceful_fs();
     var path7 = require("path");
     var mkdir = require_mkdirs();
     var pathExists = require_path_exists().pathExists;
@@ -4739,21 +4739,21 @@ var require_output = __commonJS({
         if (err)
           return callback(err);
         if (itDoes)
-          return fs7.writeFile(file, data, encoding, callback);
+          return fs8.writeFile(file, data, encoding, callback);
         mkdir.mkdirs(dir, (err2) => {
           if (err2)
             return callback(err2);
-          fs7.writeFile(file, data, encoding, callback);
+          fs8.writeFile(file, data, encoding, callback);
         });
       });
     }
     function outputFileSync(file, ...args) {
       const dir = path7.dirname(file);
-      if (fs7.existsSync(dir)) {
-        return fs7.writeFileSync(file, ...args);
+      if (fs8.existsSync(dir)) {
+        return fs8.writeFileSync(file, ...args);
       }
       mkdir.mkdirsSync(dir);
-      fs7.writeFileSync(file, ...args);
+      fs8.writeFileSync(file, ...args);
     }
     module2.exports = {
       outputFile: u(outputFile),
@@ -4812,7 +4812,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"(exports, module2) {
     "use strict";
-    var fs7 = require_graceful_fs();
+    var fs8 = require_graceful_fs();
     var path7 = require("path");
     var copySync = require_copy_sync2().copySync;
     var removeSync = require_remove().removeSync;
@@ -4839,13 +4839,13 @@ var require_move_sync = __commonJS({
         removeSync(dest);
         return rename2(src, dest, overwrite);
       }
-      if (fs7.existsSync(dest))
+      if (fs8.existsSync(dest))
         throw new Error("dest already exists.");
       return rename2(src, dest, overwrite);
     }
     function rename2(src, dest, overwrite) {
       try {
-        fs7.renameSync(src, dest);
+        fs8.renameSync(src, dest);
       } catch (err) {
         if (err.code !== "EXDEV")
           throw err;
@@ -4878,7 +4878,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"(exports, module2) {
     "use strict";
-    var fs7 = require_graceful_fs();
+    var fs8 = require_graceful_fs();
     var path7 = require("path");
     var copy = require_copy2().copy;
     var remove2 = require_remove().remove;
@@ -4932,7 +4932,7 @@ var require_move = __commonJS({
       });
     }
     function rename2(src, dest, overwrite, cb) {
-      fs7.rename(src, dest, (err) => {
+      fs8.rename(src, dest, (err) => {
         if (!err)
           return cb();
         if (err.code !== "EXDEV")
@@ -8976,7 +8976,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"(exports) {
-    var fs7 = require("fs");
+    var fs8 = require("fs");
     var Transform = require("stream").Transform;
     var PassThrough = require("stream").PassThrough;
     var zlib = require("zlib");
@@ -9001,7 +9001,7 @@ var require_yazl = __commonJS({
         options = {};
       var entry = new Entry(metadataPath, false, options);
       self2.entries.push(entry);
-      fs7.stat(realPath, function(err, stats) {
+      fs8.stat(realPath, function(err, stats) {
         if (err)
           return self2.emit("error", err);
         if (!stats.isFile())
@@ -9012,7 +9012,7 @@ var require_yazl = __commonJS({
         if (options.mode == null)
           entry.setFileAttributesMode(stats.mode);
         entry.setFileDataPumpFunction(function() {
-          var readStream = fs7.createReadStream(realPath);
+          var readStream = fs8.createReadStream(realPath);
           entry.state = Entry.FILE_DATA_IN_PROGRESS;
           readStream.on("error", function(err2) {
             self2.emit("error", err2);
@@ -10582,7 +10582,7 @@ var require_old = __commonJS({
   "../../node_modules/.pnpm/fs.realpath@1.0.0/node_modules/fs.realpath/old.js"(exports) {
     var pathModule = require("path");
     var isWindows = process.platform === "win32";
-    var fs7 = require("fs");
+    var fs8 = require("fs");
     var DEBUG = process.env.NODE_DEBUG && /fs/.test(process.env.NODE_DEBUG);
     function rethrow() {
       var callback;
@@ -10647,7 +10647,7 @@ var require_old = __commonJS({
         base = m[0];
         previous = "";
         if (isWindows && !knownHard[base]) {
-          fs7.lstatSync(base);
+          fs8.lstatSync(base);
           knownHard[base] = true;
         }
       }
@@ -10665,7 +10665,7 @@ var require_old = __commonJS({
         if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
           resolvedLink = cache[base];
         } else {
-          var stat = fs7.lstatSync(base);
+          var stat = fs8.lstatSync(base);
           if (!stat.isSymbolicLink()) {
             knownHard[base] = true;
             if (cache)
@@ -10680,8 +10680,8 @@ var require_old = __commonJS({
             }
           }
           if (linkTarget === null) {
-            fs7.statSync(base);
-            linkTarget = fs7.readlinkSync(base);
+            fs8.statSync(base);
+            linkTarget = fs8.readlinkSync(base);
           }
           resolvedLink = pathModule.resolve(previous, linkTarget);
           if (cache)
@@ -10718,7 +10718,7 @@ var require_old = __commonJS({
         base = m[0];
         previous = "";
         if (isWindows && !knownHard[base]) {
-          fs7.lstat(base, function(err) {
+          fs8.lstat(base, function(err) {
             if (err)
               return cb(err);
             knownHard[base] = true;
@@ -10746,7 +10746,7 @@ var require_old = __commonJS({
         if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
           return gotResolvedLink(cache[base]);
         }
-        return fs7.lstat(base, gotStat);
+        return fs8.lstat(base, gotStat);
       }
       function gotStat(err, stat) {
         if (err)
@@ -10763,10 +10763,10 @@ var require_old = __commonJS({
             return gotTarget(null, seenLinks[id], base);
           }
         }
-        fs7.stat(base, function(err2) {
+        fs8.stat(base, function(err2) {
           if (err2)
             return cb(err2);
-          fs7.readlink(base, function(err3, target) {
+          fs8.readlink(base, function(err3, target) {
             if (!isWindows)
               seenLinks[id] = target;
             gotTarget(err3, target);
@@ -10798,9 +10798,9 @@ var require_fs2 = __commonJS({
     realpath.realpathSync = realpathSync;
     realpath.monkeypatch = monkeypatch;
     realpath.unmonkeypatch = unmonkeypatch;
-    var fs7 = require("fs");
-    var origRealpath = fs7.realpath;
-    var origRealpathSync = fs7.realpathSync;
+    var fs8 = require("fs");
+    var origRealpath = fs8.realpath;
+    var origRealpathSync = fs8.realpathSync;
     var version = process.version;
     var ok = /^v[0-5]\./.test(version);
     var old = require_old();
@@ -10838,12 +10838,12 @@ var require_fs2 = __commonJS({
       }
     }
     function monkeypatch() {
-      fs7.realpath = realpath;
-      fs7.realpathSync = realpathSync;
+      fs8.realpath = realpath;
+      fs8.realpathSync = realpathSync;
     }
     function unmonkeypatch() {
-      fs7.realpath = origRealpath;
-      fs7.realpathSync = origRealpathSync;
+      fs8.realpath = origRealpath;
+      fs8.realpathSync = origRealpathSync;
     }
   }
 });
@@ -11563,7 +11563,7 @@ var require_common = __commonJS({
     function ownProp(obj, field) {
       return Object.prototype.hasOwnProperty.call(obj, field);
     }
-    var fs7 = require("fs");
+    var fs8 = require("fs");
     var path7 = require("path");
     var minimatch2 = require_minimatch2();
     var isAbsolute = require("path").isAbsolute;
@@ -11618,7 +11618,7 @@ var require_common = __commonJS({
       self2.stat = !!options.stat;
       self2.noprocess = !!options.noprocess;
       self2.absolute = !!options.absolute;
-      self2.fs = options.fs || fs7;
+      self2.fs = options.fs || fs8;
       self2.maxLength = options.maxLength || Infinity;
       self2.cache = options.cache || /* @__PURE__ */ Object.create(null);
       self2.statCache = options.statCache || /* @__PURE__ */ Object.create(null);
@@ -12717,7 +12717,7 @@ var require_windows = __commonJS({
   "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/windows.js"(exports, module2) {
     module2.exports = isexe;
     isexe.sync = sync;
-    var fs7 = require("fs");
+    var fs8 = require("fs");
     function checkPathExt(path7, options) {
       var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
       if (!pathext) {
@@ -12742,12 +12742,12 @@ var require_windows = __commonJS({
       return checkPathExt(path7, options);
     }
     function isexe(path7, options, cb) {
-      fs7.stat(path7, function(er, stat) {
+      fs8.stat(path7, function(er, stat) {
         cb(er, er ? false : checkStat(stat, path7, options));
       });
     }
     function sync(path7, options) {
-      return checkStat(fs7.statSync(path7), path7, options);
+      return checkStat(fs8.statSync(path7), path7, options);
     }
   }
 });
@@ -12757,14 +12757,14 @@ var require_mode = __commonJS({
   "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/mode.js"(exports, module2) {
     module2.exports = isexe;
     isexe.sync = sync;
-    var fs7 = require("fs");
+    var fs8 = require("fs");
     function isexe(path7, options, cb) {
-      fs7.stat(path7, function(er, stat) {
+      fs8.stat(path7, function(er, stat) {
         cb(er, er ? false : checkStat(stat, options));
       });
     }
     function sync(path7, options) {
-      return checkStat(fs7.statSync(path7), options);
+      return checkStat(fs8.statSync(path7), options);
     }
     function checkStat(stat, options) {
       return stat.isFile() && checkMode(stat, options);
@@ -12788,7 +12788,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"(exports, module2) {
-    var fs7 = require("fs");
+    var fs8 = require("fs");
     var core;
     if (process.platform === "win32" || global.TESTING_WINDOWS) {
       core = require_windows();
@@ -13064,7 +13064,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"(exports, module2) {
     "use strict";
-    var fs7 = require("fs");
+    var fs8 = require("fs");
     var shebangCommand = require_shebang_command();
     function readShebang(command) {
       const size = 150;
@@ -13077,9 +13077,9 @@ var require_readShebang = __commonJS({
       }
       let fd;
       try {
-        fd = fs7.openSync(command, "r");
-        fs7.readSync(fd, buffer, 0, size, 0);
-        fs7.closeSync(fd);
+        fd = fs8.openSync(command, "r");
+        fs8.readSync(fd, buffer, 0, size, 0);
+        fs8.closeSync(fd);
       } catch (e) {
       }
       return shebangCommand(buffer.toString());
@@ -19975,6 +19975,7 @@ __export(src_exports, {
   isExperimentalBackendsEnabled: () => isExperimentalBackendsEnabled,
   isExperimentalBackendsWithoutIntrospectionEnabled: () => isExperimentalBackendsWithoutIntrospectionEnabled,
   isNodeBackendFramework: () => isNodeBackendFramework,
+  isNodeEntrypoint: () => isNodeEntrypoint,
   isPythonEntrypoint: () => isPythonEntrypoint,
   isPythonFramework: () => isPythonFramework,
   isRouteMiddleware: () => isRouteMiddleware,
@@ -24040,6 +24041,44 @@ async function isPythonEntrypoint(file) {
   }
 }
 
+// src/node-entrypoint.ts
+var import_fs4 = __toESM(require("fs"));
+var HTTP_METHODS = "GET|HEAD|OPTIONS|POST|PUT|DELETE|PATCH";
+var VALID_EXPORT_PATTERNS = [
+  // ESM default export: export default function handler() {}
+  /export\s+default\b/,
+  // CJS default export: module.exports = (req, res) => {}
+  /module\.exports\s*=/,
+  // ESM named HTTP method or fetch exports: export function GET() {}
+  new RegExp(
+    `export\\s+(?:async\\s+)?(?:function|const|let|var)\\s+(?:${HTTP_METHODS}|fetch)\\b`
+  ),
+  // ESM re-exports: export { GET } or export { handler as default }
+  new RegExp(`export\\s*\\{[^}]*\\b(?:${HTTP_METHODS}|fetch|default)\\b`),
+  // CJS named exports: exports.GET = ... or module.exports.GET = ...
+  new RegExp(`(?:module\\.)?exports\\.(?:${HTTP_METHODS}|fetch|default)\\s*=`),
+  // Server handler: http.createServer(...).listen() with no exports
+  /http\.createServer\s*\(/
+];
+function stripComments(content) {
+  return content.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
+}
+async function isNodeEntrypoint(file) {
+  try {
+    const fsPath = file.fsPath;
+    if (!fsPath)
+      return true;
+    const content = await import_fs4.default.promises.readFile(fsPath, "utf-8");
+    if (!content.trim())
+      return false;
+    const stripped = stripComments(content);
+    return VALID_EXPORT_PATTERNS.some((pattern) => pattern.test(stripped));
+  } catch (err) {
+    debug(`Failed to check Node.js entrypoint: ${err}`);
+    return true;
+  }
+}
+
 // src/process-serverless/get-encrypted-env-file.ts
 function getEncryptedEnv(envFilename, envContent) {
   if (!envFilename || !envContent) {
@@ -24227,7 +24266,7 @@ async function getLambdaSupportsStreaming(lambda, forceStreamingRuntime) {
   }
   return { supportsStreaming: void 0 };
 }
-var HTTP_METHODS = [
+var HTTP_METHODS2 = [
   "GET",
   "HEAD",
   "OPTIONS",
@@ -24245,7 +24284,7 @@ async function lambdaShouldStream(lambda) {
     const buffer = await streamToBuffer2(stream);
     const names = await getFileExports(lambda.handler, buffer.toString("utf8"));
     for (const name of names) {
-      if (HTTP_METHODS.includes(name)) {
+      if (HTTP_METHODS2.includes(name)) {
         return { supportsStreaming: true };
       }
     }
@@ -24556,7 +24595,7 @@ async function finalizeLambda(params) {
   lambda.supportsResponseStreaming = streamingResult.supportsStreaming;
   return {
     buffer: zipResult.buffer,
-    zipPath: zipResult.zipPath,
+    zipPath: zipResult.zipPath ?? null,
     digest: zipResult.digest,
     size: zipResult.size,
     uncompressedBytes,
@@ -24711,6 +24750,7 @@ function validateEnvWrapperSupport(encryptedEnvFilename, encryptedEnvContent, la
   isExperimentalBackendsEnabled,
   isExperimentalBackendsWithoutIntrospectionEnabled,
   isNodeBackendFramework,
+  isNodeEntrypoint,
   isPythonEntrypoint,
   isPythonFramework,
   isRouteMiddleware,