@vercel/go 3.7.1 → 3.8.0

package/dist/index.js

@@ -75,7 +75,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 fs2 = require("fs");
+    var fs3 = require("fs");
     function checkPathExt(path, options) {
       var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
       if (!pathext) {
@@ -100,12 +100,12 @@ var require_windows = __commonJS({
       return checkPathExt(path, options);
     }
     function isexe(path, options, cb) {
-      fs2.stat(path, function(er2, stat) {
+      fs3.stat(path, function(er2, stat) {
         cb(er2, er2 ? false : checkStat(stat, path, options));
       });
     }
     function sync(path, options) {
-      return checkStat(fs2.statSync(path), path, options);
+      return checkStat(fs3.statSync(path), path, options);
     }
   }
 });
@@ -115,14 +115,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 fs2 = require("fs");
+    var fs3 = require("fs");
     function isexe(path, options, cb) {
-      fs2.stat(path, function(er2, stat) {
+      fs3.stat(path, function(er2, stat) {
         cb(er2, er2 ? false : checkStat(stat, options));
       });
     }
     function sync(path, options) {
-      return checkStat(fs2.statSync(path), options);
+      return checkStat(fs3.statSync(path), options);
     }
     function checkStat(stat, options) {
       return stat.isFile() && checkMode(stat, options);
@@ -146,7 +146,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 fs2 = require("fs");
+    var fs3 = require("fs");
     var core;
     if (process.platform === "win32" || global.TESTING_WINDOWS) {
       core = require_windows();
@@ -422,7 +422,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 fs2 = require("fs");
+    var fs3 = require("fs");
     var shebangCommand = require_shebang_command();
     function readShebang(command) {
       const size = 150;
@@ -435,9 +435,9 @@ var require_readShebang = __commonJS({
       }
       let fd;
       try {
-        fd = fs2.openSync(command, "r");
-        fs2.readSync(fd, buffer, 0, size, 0);
-        fs2.closeSync(fd);
+        fd = fs3.openSync(command, "r");
+        fs3.readSync(fd, buffer, 0, size, 0);
+        fs3.closeSync(fd);
       } catch (e) {
       }
       return shebangCommand(buffer.toString());
@@ -1922,9 +1922,9 @@ var require_pump = __commonJS({
   "../../node_modules/.pnpm/pump@3.0.2/node_modules/pump/index.js"(exports, module2) {
     var once2 = require_once();
     var eos = require_end_of_stream();
-    var fs2;
+    var fs3;
     try {
-      fs2 = require("fs");
+      fs3 = require("fs");
     } catch (e) {
     }
     var noop = function() {
@@ -1936,9 +1936,9 @@ var require_pump = __commonJS({
     var isFS = function(stream) {
       if (!ancient)
         return false;
-      if (!fs2)
+      if (!fs3)
         return false;
-      return (stream instanceof (fs2.ReadStream || noop) || stream instanceof (fs2.WriteStream || noop)) && isFn(stream.close);
+      return (stream instanceof (fs3.ReadStream || noop) || stream instanceof (fs3.WriteStream || noop)) && isFn(stream.close);
     };
     var isRequest = function(stream) {
       return stream.setHeader && isFn(stream.abort);
@@ -3053,56 +3053,56 @@ var require_polyfills = __commonJS({
     }
     var chdir;
     module2.exports = patch;
-    function patch(fs2) {
+    function patch(fs3) {
       if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-        patchLchmod(fs2);
-      }
-      if (!fs2.lutimes) {
-        patchLutimes(fs2);
-      }
-      fs2.chown = chownFix(fs2.chown);
-      fs2.fchown = chownFix(fs2.fchown);
-      fs2.lchown = chownFix(fs2.lchown);
-      fs2.chmod = chmodFix(fs2.chmod);
-      fs2.fchmod = chmodFix(fs2.fchmod);
-      fs2.lchmod = chmodFix(fs2.lchmod);
-      fs2.chownSync = chownFixSync(fs2.chownSync);
-      fs2.fchownSync = chownFixSync(fs2.fchownSync);
-      fs2.lchownSync = chownFixSync(fs2.lchownSync);
-      fs2.chmodSync = chmodFixSync(fs2.chmodSync);
-      fs2.fchmodSync = chmodFixSync(fs2.fchmodSync);
-      fs2.lchmodSync = chmodFixSync(fs2.lchmodSync);
-      fs2.stat = statFix(fs2.stat);
-      fs2.fstat = statFix(fs2.fstat);
-      fs2.lstat = statFix(fs2.lstat);
-      fs2.statSync = statFixSync(fs2.statSync);
-      fs2.fstatSync = statFixSync(fs2.fstatSync);
-      fs2.lstatSync = statFixSync(fs2.lstatSync);
-      if (fs2.chmod && !fs2.lchmod) {
-        fs2.lchmod = function(path, mode, cb) {
+        patchLchmod(fs3);
+      }
+      if (!fs3.lutimes) {
+        patchLutimes(fs3);
+      }
+      fs3.chown = chownFix(fs3.chown);
+      fs3.fchown = chownFix(fs3.fchown);
+      fs3.lchown = chownFix(fs3.lchown);
+      fs3.chmod = chmodFix(fs3.chmod);
+      fs3.fchmod = chmodFix(fs3.fchmod);
+      fs3.lchmod = chmodFix(fs3.lchmod);
+      fs3.chownSync = chownFixSync(fs3.chownSync);
+      fs3.fchownSync = chownFixSync(fs3.fchownSync);
+      fs3.lchownSync = chownFixSync(fs3.lchownSync);
+      fs3.chmodSync = chmodFixSync(fs3.chmodSync);
+      fs3.fchmodSync = chmodFixSync(fs3.fchmodSync);
+      fs3.lchmodSync = chmodFixSync(fs3.lchmodSync);
+      fs3.stat = statFix(fs3.stat);
+      fs3.fstat = statFix(fs3.fstat);
+      fs3.lstat = statFix(fs3.lstat);
+      fs3.statSync = statFixSync(fs3.statSync);
+      fs3.fstatSync = statFixSync(fs3.fstatSync);
+      fs3.lstatSync = statFixSync(fs3.lstatSync);
+      if (fs3.chmod && !fs3.lchmod) {
+        fs3.lchmod = function(path, mode, cb) {
           if (cb)
             process.nextTick(cb);
         };
-        fs2.lchmodSync = function() {
+        fs3.lchmodSync = function() {
         };
       }
-      if (fs2.chown && !fs2.lchown) {
-        fs2.lchown = function(path, uid, gid, cb) {
+      if (fs3.chown && !fs3.lchown) {
+        fs3.lchown = function(path, uid, gid, cb) {
           if (cb)
             process.nextTick(cb);
         };
-        fs2.lchownSync = function() {
+        fs3.lchownSync = function() {
         };
       }
       if (platform === "win32") {
-        fs2.rename = typeof fs2.rename !== "function" ? fs2.rename : function(fs$rename) {
+        fs3.rename = typeof fs3.rename !== "function" ? fs3.rename : function(fs$rename) {
           function rename(from, to2, cb) {
             var start = Date.now();
             var backoff = 0;
             fs$rename(from, to2, function CB(er2) {
               if (er2 && (er2.code === "EACCES" || er2.code === "EPERM" || er2.code === "EBUSY") && Date.now() - start < 6e4) {
                 setTimeout(function() {
-                  fs2.stat(to2, function(stater, st2) {
+                  fs3.stat(to2, function(stater, st2) {
                     if (stater && stater.code === "ENOENT")
                       fs$rename(from, to2, CB);
                     else
@@ -3120,9 +3120,9 @@ var require_polyfills = __commonJS({
           if (Object.setPrototypeOf)
             Object.setPrototypeOf(rename, fs$rename);
           return rename;
-        }(fs2.rename);
+        }(fs3.rename);
       }
-      fs2.read = typeof fs2.read !== "function" ? fs2.read : function(fs$read) {
+      fs3.read = typeof fs3.read !== "function" ? fs3.read : function(fs$read) {
         function read(fd, buffer, offset, length, position, callback_) {
           var callback;
           if (callback_ && typeof callback_ === "function") {
@@ -3130,23 +3130,23 @@ var require_polyfills = __commonJS({
             callback = function(er2, _2, __) {
               if (er2 && er2.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
-                return fs$read.call(fs2, fd, buffer, offset, length, position, callback);
+                return fs$read.call(fs3, fd, buffer, offset, length, position, callback);
               }
               callback_.apply(this, arguments);
             };
           }
-          return fs$read.call(fs2, fd, buffer, offset, length, position, callback);
+          return fs$read.call(fs3, fd, buffer, offset, length, position, callback);
         }
         if (Object.setPrototypeOf)
           Object.setPrototypeOf(read, fs$read);
         return read;
-      }(fs2.read);
-      fs2.readSync = typeof fs2.readSync !== "function" ? fs2.readSync : function(fs$readSync) {
+      }(fs3.read);
+      fs3.readSync = typeof fs3.readSync !== "function" ? fs3.readSync : function(fs$readSync) {
         return function(fd, buffer, offset, length, position) {
           var eagCounter = 0;
           while (true) {
             try {
-              return fs$readSync.call(fs2, fd, buffer, offset, length, position);
+              return fs$readSync.call(fs3, fd, buffer, offset, length, position);
             } catch (er2) {
               if (er2.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
@@ -3156,10 +3156,10 @@ var require_polyfills = __commonJS({
             }
           }
         };
-      }(fs2.readSync);
-      function patchLchmod(fs3) {
-        fs3.lchmod = function(path, mode, callback) {
-          fs3.open(
+      }(fs3.readSync);
+      function patchLchmod(fs4) {
+        fs4.lchmod = function(path, mode, callback) {
+          fs4.open(
             path,
             constants.O_WRONLY | constants.O_SYMLINK,
             mode,
@@ -3169,8 +3169,8 @@ var require_polyfills = __commonJS({
                   callback(err);
                 return;
               }
-              fs3.fchmod(fd, mode, function(err2) {
-                fs3.close(fd, function(err22) {
+              fs4.fchmod(fd, mode, function(err2) {
+                fs4.close(fd, function(err22) {
                   if (callback)
                     callback(err2 || err22);
                 });
@@ -3178,68 +3178,68 @@ var require_polyfills = __commonJS({
             }
           );
         };
-        fs3.lchmodSync = function(path, mode) {
-          var fd = fs3.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode);
+        fs4.lchmodSync = function(path, mode) {
+          var fd = fs4.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
-            ret = fs3.fchmodSync(fd, mode);
+            ret = fs4.fchmodSync(fd, mode);
             threw = false;
           } finally {
             if (threw) {
               try {
-                fs3.closeSync(fd);
+                fs4.closeSync(fd);
               } catch (er2) {
               }
             } else {
-              fs3.closeSync(fd);
+              fs4.closeSync(fd);
             }
           }
           return ret;
         };
       }
-      function patchLutimes(fs3) {
-        if (constants.hasOwnProperty("O_SYMLINK") && fs3.futimes) {
-          fs3.lutimes = function(path, at2, mt2, cb) {
-            fs3.open(path, constants.O_SYMLINK, function(er2, fd) {
+      function patchLutimes(fs4) {
+        if (constants.hasOwnProperty("O_SYMLINK") && fs4.futimes) {
+          fs4.lutimes = function(path, at2, mt2, cb) {
+            fs4.open(path, constants.O_SYMLINK, function(er2, fd) {
               if (er2) {
                 if (cb)
                   cb(er2);
                 return;
               }
-              fs3.futimes(fd, at2, mt2, function(er3) {
-                fs3.close(fd, function(er22) {
+              fs4.futimes(fd, at2, mt2, function(er3) {
+                fs4.close(fd, function(er22) {
                   if (cb)
                     cb(er3 || er22);
                 });
               });
             });
           };
-          fs3.lutimesSync = function(path, at2, mt2) {
-            var fd = fs3.openSync(path, constants.O_SYMLINK);
+          fs4.lutimesSync = function(path, at2, mt2) {
+            var fd = fs4.openSync(path, constants.O_SYMLINK);
             var ret;
             var threw = true;
             try {
-              ret = fs3.futimesSync(fd, at2, mt2);
+              ret = fs4.futimesSync(fd, at2, mt2);
               threw = false;
             } finally {
               if (threw) {
                 try {
-                  fs3.closeSync(fd);
+                  fs4.closeSync(fd);
                 } catch (er2) {
                 }
               } else {
-                fs3.closeSync(fd);
+                fs4.closeSync(fd);
               }
             }
             return ret;
           };
-        } else if (fs3.futimes) {
-          fs3.lutimes = function(_a14, _b7, _c7, cb) {
+        } else if (fs4.futimes) {
+          fs4.lutimes = function(_a14, _b7, _c7, cb) {
             if (cb)
               process.nextTick(cb);
           };
-          fs3.lutimesSync = function() {
+          fs4.lutimesSync = function() {
           };
         }
       }
@@ -3247,7 +3247,7 @@ var require_polyfills = __commonJS({
         if (!orig)
           return orig;
         return function(target, mode, cb) {
-          return orig.call(fs2, target, mode, function(er2) {
+          return orig.call(fs3, target, mode, function(er2) {
             if (chownErOk(er2))
               er2 = null;
             if (cb)
@@ -3260,7 +3260,7 @@ var require_polyfills = __commonJS({
           return orig;
         return function(target, mode) {
           try {
-            return orig.call(fs2, target, mode);
+            return orig.call(fs3, target, mode);
           } catch (er2) {
             if (!chownErOk(er2))
               throw er2;
@@ -3271,7 +3271,7 @@ var require_polyfills = __commonJS({
         if (!orig)
           return orig;
         return function(target, uid, gid, cb) {
-          return orig.call(fs2, target, uid, gid, function(er2) {
+          return orig.call(fs3, target, uid, gid, function(er2) {
             if (chownErOk(er2))
               er2 = null;
             if (cb)
@@ -3284,7 +3284,7 @@ var require_polyfills = __commonJS({
           return orig;
         return function(target, uid, gid) {
           try {
-            return orig.call(fs2, target, uid, gid);
+            return orig.call(fs3, target, uid, gid);
           } catch (er2) {
             if (!chownErOk(er2))
               throw er2;
@@ -3309,14 +3309,14 @@ var require_polyfills = __commonJS({
             if (cb)
               cb.apply(this, arguments);
           }
-          return options ? orig.call(fs2, target, options, callback) : orig.call(fs2, target, callback);
+          return options ? orig.call(fs3, target, options, callback) : orig.call(fs3, target, callback);
         };
       }
       function statFixSync(orig) {
         if (!orig)
           return orig;
         return function(target, options) {
-          var stats = options ? orig.call(fs2, target, options) : orig.call(fs2, target);
+          var stats = options ? orig.call(fs3, target, options) : orig.call(fs3, target);
           if (stats) {
             if (stats.uid < 0)
               stats.uid += 4294967296;
@@ -3347,7 +3347,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(fs2) {
+    function legacy(fs3) {
       return {
         ReadStream,
         WriteStream
@@ -3392,7 +3392,7 @@ var require_legacy_streams = __commonJS({
           });
           return;
         }
-        fs2.open(this.path, this.flags, this.mode, function(err, fd) {
+        fs3.open(this.path, this.flags, this.mode, function(err, fd) {
           if (err) {
             self.emit("error", err);
             self.readable = false;
@@ -3432,7 +3432,7 @@ var require_legacy_streams = __commonJS({
         this.busy = false;
         this._queue = [];
         if (this.fd === null) {
-          this._open = fs2.open;
+          this._open = fs3.open;
           this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
           this.flush();
         }
@@ -3453,13 +3453,13 @@ var require_clone = __commonJS({
       if (obj === null || typeof obj !== "object")
         return obj;
       if (obj instanceof Object)
-        var copy3 = { __proto__: getPrototypeOf(obj) };
+        var copy4 = { __proto__: getPrototypeOf(obj) };
       else
-        var copy3 = /* @__PURE__ */ Object.create(null);
+        var copy4 = /* @__PURE__ */ Object.create(null);
       Object.getOwnPropertyNames(obj).forEach(function(key) {
-        Object.defineProperty(copy3, key, Object.getOwnPropertyDescriptor(obj, key));
+        Object.defineProperty(copy4, key, Object.getOwnPropertyDescriptor(obj, key));
       });
-      return copy3;
+      return copy4;
     }
   }
 });
@@ -3467,7 +3467,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 fs2 = require("fs");
+    var fs3 = require("fs");
     var polyfills = require_polyfills();
     var legacy = require_legacy_streams();
     var clone = require_clone();
@@ -3499,12 +3499,12 @@ var require_graceful_fs = __commonJS({
         m2 = "GFS4: " + m2.split(/\n/).join("\nGFS4: ");
         console.error(m2);
       };
-    if (!fs2[gracefulQueue]) {
+    if (!fs3[gracefulQueue]) {
       queue = global[gracefulQueue] || [];
-      publishQueue(fs2, queue);
-      fs2.close = function(fs$close) {
+      publishQueue(fs3, queue);
+      fs3.close = function(fs$close) {
         function close(fd, cb) {
-          return fs$close.call(fs2, fd, function(err) {
+          return fs$close.call(fs3, fd, function(err) {
             if (!err) {
               resetQueue();
             }
@@ -3516,40 +3516,40 @@ var require_graceful_fs = __commonJS({
           value: fs$close
         });
         return close;
-      }(fs2.close);
-      fs2.closeSync = function(fs$closeSync) {
+      }(fs3.close);
+      fs3.closeSync = function(fs$closeSync) {
         function closeSync(fd) {
-          fs$closeSync.apply(fs2, arguments);
+          fs$closeSync.apply(fs3, arguments);
           resetQueue();
         }
         Object.defineProperty(closeSync, previousSymbol, {
           value: fs$closeSync
         });
         return closeSync;
-      }(fs2.closeSync);
+      }(fs3.closeSync);
       if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
         process.on("exit", function() {
-          debug5(fs2[gracefulQueue]);
-          require("assert").equal(fs2[gracefulQueue].length, 0);
+          debug5(fs3[gracefulQueue]);
+          require("assert").equal(fs3[gracefulQueue].length, 0);
         });
       }
     }
     var queue;
     if (!global[gracefulQueue]) {
-      publishQueue(global, fs2[gracefulQueue]);
-    }
-    module2.exports = patch(clone(fs2));
-    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs2.__patched) {
-      module2.exports = patch(fs2);
-      fs2.__patched = true;
-    }
-    function patch(fs3) {
-      polyfills(fs3);
-      fs3.gracefulify = patch;
-      fs3.createReadStream = createReadStream;
-      fs3.createWriteStream = createWriteStream2;
-      var fs$readFile = fs3.readFile;
-      fs3.readFile = readFile4;
+      publishQueue(global, fs3[gracefulQueue]);
+    }
+    module2.exports = patch(clone(fs3));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs3.__patched) {
+      module2.exports = patch(fs3);
+      fs3.__patched = true;
+    }
+    function patch(fs4) {
+      polyfills(fs4);
+      fs4.gracefulify = patch;
+      fs4.createReadStream = createReadStream;
+      fs4.createWriteStream = createWriteStream2;
+      var fs$readFile = fs4.readFile;
+      fs4.readFile = readFile4;
       function readFile4(path, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
@@ -3565,8 +3565,8 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$writeFile = fs3.writeFile;
-      fs3.writeFile = writeFile2;
+      var fs$writeFile = fs4.writeFile;
+      fs4.writeFile = writeFile2;
       function writeFile2(path, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
@@ -3582,9 +3582,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$appendFile = fs3.appendFile;
+      var fs$appendFile = fs4.appendFile;
       if (fs$appendFile)
-        fs3.appendFile = appendFile;
+        fs4.appendFile = appendFile;
       function appendFile(path, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
@@ -3600,9 +3600,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$copyFile = fs3.copyFile;
+      var fs$copyFile = fs4.copyFile;
       if (fs$copyFile)
-        fs3.copyFile = copyFile;
+        fs4.copyFile = copyFile;
       function copyFile(src, dest, flags, cb) {
         if (typeof flags === "function") {
           cb = flags;
@@ -3620,8 +3620,8 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$readdir = fs3.readdir;
-      fs3.readdir = readdir2;
+      var fs$readdir = fs4.readdir;
+      fs4.readdir = readdir2;
       var noReaddirOptionVersions = /^v[0-5]\./;
       function readdir2(path, options, cb) {
         if (typeof options === "function")
@@ -3662,21 +3662,21 @@ var require_graceful_fs = __commonJS({
         }
       }
       if (process.version.substr(0, 4) === "v0.8") {
-        var legStreams = legacy(fs3);
+        var legStreams = legacy(fs4);
         ReadStream = legStreams.ReadStream;
         WriteStream = legStreams.WriteStream;
       }
-      var fs$ReadStream = fs3.ReadStream;
+      var fs$ReadStream = fs4.ReadStream;
       if (fs$ReadStream) {
         ReadStream.prototype = Object.create(fs$ReadStream.prototype);
         ReadStream.prototype.open = ReadStream$open;
       }
-      var fs$WriteStream = fs3.WriteStream;
+      var fs$WriteStream = fs4.WriteStream;
       if (fs$WriteStream) {
         WriteStream.prototype = Object.create(fs$WriteStream.prototype);
         WriteStream.prototype.open = WriteStream$open;
       }
-      Object.defineProperty(fs3, "ReadStream", {
+      Object.defineProperty(fs4, "ReadStream", {
         get: function() {
           return ReadStream;
         },
@@ -3686,7 +3686,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      Object.defineProperty(fs3, "WriteStream", {
+      Object.defineProperty(fs4, "WriteStream", {
         get: function() {
           return WriteStream;
         },
@@ -3697,7 +3697,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileReadStream = ReadStream;
-      Object.defineProperty(fs3, "FileReadStream", {
+      Object.defineProperty(fs4, "FileReadStream", {
         get: function() {
           return FileReadStream;
         },
@@ -3708,7 +3708,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileWriteStream = WriteStream;
-      Object.defineProperty(fs3, "FileWriteStream", {
+      Object.defineProperty(fs4, "FileWriteStream", {
         get: function() {
           return FileWriteStream;
         },
@@ -3757,13 +3757,13 @@ var require_graceful_fs = __commonJS({
         });
       }
       function createReadStream(path, options) {
-        return new fs3.ReadStream(path, options);
+        return new fs4.ReadStream(path, options);
       }
       function createWriteStream2(path, options) {
-        return new fs3.WriteStream(path, options);
+        return new fs4.WriteStream(path, options);
       }
-      var fs$open = fs3.open;
-      fs3.open = open;
+      var fs$open = fs4.open;
+      fs4.open = open;
       function open(path, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
@@ -3779,20 +3779,20 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      return fs3;
+      return fs4;
     }
     function enqueue(elem) {
       debug5("ENQUEUE", elem[0].name, elem[1]);
-      fs2[gracefulQueue].push(elem);
+      fs3[gracefulQueue].push(elem);
       retry2();
     }
     var retryTimer;
     function resetQueue() {
       var now = Date.now();
-      for (var i = 0; i < fs2[gracefulQueue].length; ++i) {
-        if (fs2[gracefulQueue][i].length > 2) {
-          fs2[gracefulQueue][i][3] = now;
-          fs2[gracefulQueue][i][4] = now;
+      for (var i = 0; i < fs3[gracefulQueue].length; ++i) {
+        if (fs3[gracefulQueue][i].length > 2) {
+          fs3[gracefulQueue][i][3] = now;
+          fs3[gracefulQueue][i][4] = now;
         }
       }
       retry2();
@@ -3800,9 +3800,9 @@ var require_graceful_fs = __commonJS({
     function retry2() {
       clearTimeout(retryTimer);
       retryTimer = void 0;
-      if (fs2[gracefulQueue].length === 0)
+      if (fs3[gracefulQueue].length === 0)
         return;
-      var elem = fs2[gracefulQueue].shift();
+      var elem = fs3[gracefulQueue].shift();
       var fn2 = elem[0];
       var args = elem[1];
       var err = elem[2];
@@ -3824,7 +3824,7 @@ var require_graceful_fs = __commonJS({
           debug5("RETRY", fn2.name, args);
           fn2.apply(null, args.concat([startTime]));
         } else {
-          fs2[gracefulQueue].push(elem);
+          fs3[gracefulQueue].push(elem);
         }
       }
       if (retryTimer === void 0) {
@@ -3839,7 +3839,7 @@ var require_fs = __commonJS({
   "../../node_modules/.pnpm/fs-extra@7.0.1/node_modules/fs-extra/lib/fs/index.js"(exports) {
     "use strict";
     var u2 = require_universalify().fromCallback;
-    var fs2 = require_graceful_fs();
+    var fs3 = require_graceful_fs();
     var api = [
       "access",
       "appendFile",
@@ -3874,31 +3874,31 @@ var require_fs = __commonJS({
       "utimes",
       "writeFile"
     ].filter((key) => {
-      return typeof fs2[key] === "function";
+      return typeof fs3[key] === "function";
     });
-    Object.keys(fs2).forEach((key) => {
+    Object.keys(fs3).forEach((key) => {
       if (key === "promises") {
         return;
       }
-      exports[key] = fs2[key];
+      exports[key] = fs3[key];
     });
     api.forEach((method) => {
-      exports[method] = u2(fs2[method]);
+      exports[method] = u2(fs3[method]);
     });
     exports.exists = function(filename, callback) {
       if (typeof callback === "function") {
-        return fs2.exists(filename, callback);
+        return fs3.exists(filename, callback);
       }
       return new Promise((resolve) => {
-        return fs2.exists(filename, resolve);
+        return fs3.exists(filename, resolve);
       });
     };
     exports.read = function(fd, buffer, offset, length, position, callback) {
       if (typeof callback === "function") {
-        return fs2.read(fd, buffer, offset, length, position, callback);
+        return fs3.read(fd, buffer, offset, length, position, callback);
       }
       return new Promise((resolve, reject) => {
-        fs2.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
+        fs3.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
           if (err)
             return reject(err);
           resolve({ bytesRead, buffer: buffer2 });
@@ -3907,10 +3907,10 @@ var require_fs = __commonJS({
     };
     exports.write = function(fd, buffer, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs2.write(fd, buffer, ...args);
+        return fs3.write(fd, buffer, ...args);
       }
       return new Promise((resolve, reject) => {
-        fs2.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
+        fs3.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
           if (err)
             return reject(err);
           resolve({ bytesWritten, buffer: buffer2 });
@@ -3948,7 +3948,7 @@ var require_win32 = __commonJS({
 var require_mkdirs = __commonJS({
   "../../node_modules/.pnpm/fs-extra@7.0.1/node_modules/fs-extra/lib/mkdirs/mkdirs.js"(exports, module2) {
     "use strict";
-    var fs2 = require_graceful_fs();
+    var fs3 = require_graceful_fs();
     var path = require("path");
     var invalidWin32Path = require_win32().invalidWin32Path;
     var o777 = parseInt("0777", 8);
@@ -3965,7 +3965,7 @@ var require_mkdirs = __commonJS({
         return callback(errInval);
       }
       let mode = opts.mode;
-      const xfs = opts.fs || fs2;
+      const xfs = opts.fs || fs3;
       if (mode === void 0) {
         mode = o777 & ~process.umask();
       }
@@ -4009,7 +4009,7 @@ var require_mkdirs = __commonJS({
 var require_mkdirs_sync = __commonJS({
   "../../node_modules/.pnpm/fs-extra@7.0.1/node_modules/fs-extra/lib/mkdirs/mkdirs-sync.js"(exports, module2) {
     "use strict";
-    var fs2 = require_graceful_fs();
+    var fs3 = require_graceful_fs();
     var path = require("path");
     var invalidWin32Path = require_win32().invalidWin32Path;
     var o777 = parseInt("0777", 8);
@@ -4018,7 +4018,7 @@ var require_mkdirs_sync = __commonJS({
         opts = { mode: opts };
       }
       let mode = opts.mode;
-      const xfs = opts.fs || fs2;
+      const xfs = opts.fs || fs3;
       if (process.platform === "win32" && invalidWin32Path(p2)) {
         const errInval = new Error(p2 + " contains invalid WIN32 path characters.");
         errInval.code = "EINVAL";
@@ -4079,36 +4079,36 @@ var require_mkdirs2 = __commonJS({
 var require_utimes = __commonJS({
   "../../node_modules/.pnpm/fs-extra@7.0.1/node_modules/fs-extra/lib/util/utimes.js"(exports, module2) {
     "use strict";
-    var fs2 = require_graceful_fs();
+    var fs3 = require_graceful_fs();
     var os2 = require("os");
     var path = require("path");
     function hasMillisResSync() {
       let tmpfile = path.join("millis-test-sync" + Date.now().toString() + Math.random().toString().slice(2));
       tmpfile = path.join(os2.tmpdir(), tmpfile);
       const d = /* @__PURE__ */ new Date(1435410243862);
-      fs2.writeFileSync(tmpfile, "https://github.com/jprichardson/node-fs-extra/pull/141");
-      const fd = fs2.openSync(tmpfile, "r+");
-      fs2.futimesSync(fd, d, d);
-      fs2.closeSync(fd);
-      return fs2.statSync(tmpfile).mtime > 1435410243e3;
+      fs3.writeFileSync(tmpfile, "https://github.com/jprichardson/node-fs-extra/pull/141");
+      const fd = fs3.openSync(tmpfile, "r+");
+      fs3.futimesSync(fd, d, d);
+      fs3.closeSync(fd);
+      return fs3.statSync(tmpfile).mtime > 1435410243e3;
     }
     function hasMillisRes(callback) {
       let tmpfile = path.join("millis-test" + Date.now().toString() + Math.random().toString().slice(2));
       tmpfile = path.join(os2.tmpdir(), tmpfile);
       const d = /* @__PURE__ */ new Date(1435410243862);
-      fs2.writeFile(tmpfile, "https://github.com/jprichardson/node-fs-extra/pull/141", (err) => {
+      fs3.writeFile(tmpfile, "https://github.com/jprichardson/node-fs-extra/pull/141", (err) => {
         if (err)
           return callback(err);
-        fs2.open(tmpfile, "r+", (err2, fd) => {
+        fs3.open(tmpfile, "r+", (err2, fd) => {
           if (err2)
             return callback(err2);
-          fs2.futimes(fd, d, d, (err3) => {
+          fs3.futimes(fd, d, d, (err3) => {
             if (err3)
               return callback(err3);
-            fs2.close(fd, (err4) => {
+            fs3.close(fd, (err4) => {
               if (err4)
                 return callback(err4);
-              fs2.stat(tmpfile, (err5, stats) => {
+              fs3.stat(tmpfile, (err5, stats) => {
                 if (err5)
                   return callback(err5);
                 callback(null, stats.mtime > 1435410243e3);
@@ -4128,11 +4128,11 @@ var require_utimes = __commonJS({
       }
     }
     function utimesMillis(path2, atime, mtime, callback) {
-      fs2.open(path2, "r+", (err, fd) => {
+      fs3.open(path2, "r+", (err, fd) => {
         if (err)
           return callback(err);
-        fs2.futimes(fd, atime, mtime, (futimesErr) => {
-          fs2.close(fd, (closeErr) => {
+        fs3.futimes(fd, atime, mtime, (futimesErr) => {
+          fs3.close(fd, (closeErr) => {
             if (callback)
               callback(futimesErr || closeErr);
           });
@@ -4140,9 +4140,9 @@ var require_utimes = __commonJS({
       });
     }
     function utimesMillisSync(path2, atime, mtime) {
-      const fd = fs2.openSync(path2, "r+");
-      fs2.futimesSync(fd, atime, mtime);
-      return fs2.closeSync(fd);
+      const fd = fs3.openSync(path2, "r+");
+      fs3.futimesSync(fd, atime, mtime);
+      return fs3.closeSync(fd);
     }
     module2.exports = {
       hasMillisRes,
@@ -4175,7 +4175,7 @@ var require_buffer = __commonJS({
 var require_copy_sync = __commonJS({
   "../../node_modules/.pnpm/fs-extra@7.0.1/node_modules/fs-extra/lib/copy-sync/copy-sync.js"(exports, module2) {
     "use strict";
-    var fs2 = require_graceful_fs();
+    var fs3 = require_graceful_fs();
     var path = require("path");
     var mkdirpSync = require_mkdirs2().mkdirsSync;
     var utimesSync = require_utimes().utimesMillisSync;
@@ -4196,7 +4196,7 @@ var require_copy_sync = __commonJS({
       if (opts.filter && !opts.filter(src, dest))
         return;
       const destParent = path.dirname(dest);
-      if (!fs2.existsSync(destParent))
+      if (!fs3.existsSync(destParent))
         mkdirpSync(destParent);
       return startCopy(destStat, src, dest, opts);
     }
@@ -4206,7 +4206,7 @@ var require_copy_sync = __commonJS({
       return getStats(destStat, src, dest, opts);
     }
     function getStats(destStat, src, dest, opts) {
-      const statSync = opts.dereference ? fs2.statSync : fs2.lstatSync;
+      const statSync = opts.dereference ? fs3.statSync : fs3.lstatSync;
       const srcStat = statSync(src);
       if (srcStat.isDirectory())
         return onDir(srcStat, destStat, src, dest, opts);
@@ -4222,16 +4222,16 @@ var require_copy_sync = __commonJS({
     }
     function mayCopyFile(srcStat, src, dest, opts) {
       if (opts.overwrite) {
-        fs2.unlinkSync(dest);
+        fs3.unlinkSync(dest);
         return copyFile(srcStat, src, dest, opts);
       } else if (opts.errorOnExist) {
         throw new Error(`'${dest}' already exists`);
       }
     }
     function copyFile(srcStat, src, dest, opts) {
-      if (typeof fs2.copyFileSync === "function") {
-        fs2.copyFileSync(src, dest);
-        fs2.chmodSync(dest, srcStat.mode);
+      if (typeof fs3.copyFileSync === "function") {
+        fs3.copyFileSync(src, dest);
+        fs3.chmodSync(dest, srcStat.mode);
         if (opts.preserveTimestamps) {
           return utimesSync(dest, srcStat.atime, srcStat.mtime);
         }
@@ -4242,18 +4242,18 @@ var require_copy_sync = __commonJS({
     function copyFileFallback(srcStat, src, dest, opts) {
       const BUF_LENGTH = 64 * 1024;
       const _buff = require_buffer()(BUF_LENGTH);
-      const fdr = fs2.openSync(src, "r");
-      const fdw = fs2.openSync(dest, "w", srcStat.mode);
+      const fdr = fs3.openSync(src, "r");
+      const fdw = fs3.openSync(dest, "w", srcStat.mode);
       let pos = 0;
       while (pos < srcStat.size) {
-        const bytesRead = fs2.readSync(fdr, _buff, 0, BUF_LENGTH, pos);
-        fs2.writeSync(fdw, _buff, 0, bytesRead);
+        const bytesRead = fs3.readSync(fdr, _buff, 0, BUF_LENGTH, pos);
+        fs3.writeSync(fdw, _buff, 0, bytesRead);
         pos += bytesRead;
       }
       if (opts.preserveTimestamps)
-        fs2.futimesSync(fdw, srcStat.atime, srcStat.mtime);
-      fs2.closeSync(fdr);
-      fs2.closeSync(fdw);
+        fs3.futimesSync(fdw, srcStat.atime, srcStat.mtime);
+      fs3.closeSync(fdr);
+      fs3.closeSync(fdw);
     }
     function onDir(srcStat, destStat, src, dest, opts) {
       if (destStat === notExist)
@@ -4264,12 +4264,12 @@ var require_copy_sync = __commonJS({
       return copyDir(src, dest, opts);
     }
     function mkDirAndCopy(srcStat, src, dest, opts) {
-      fs2.mkdirSync(dest);
+      fs3.mkdirSync(dest);
       copyDir(src, dest, opts);
-      return fs2.chmodSync(dest, srcStat.mode);
+      return fs3.chmodSync(dest, srcStat.mode);
     }
     function copyDir(src, dest, opts) {
-      fs2.readdirSync(src).forEach((item) => copyDirItem(item, src, dest, opts));
+      fs3.readdirSync(src).forEach((item) => copyDirItem(item, src, dest, opts));
     }
     function copyDirItem(item, src, dest, opts) {
       const srcItem = path.join(src, item);
@@ -4278,19 +4278,19 @@ var require_copy_sync = __commonJS({
       return startCopy(destStat, srcItem, destItem, opts);
     }
     function onLink(destStat, src, dest, opts) {
-      let resolvedSrc = fs2.readlinkSync(src);
+      let resolvedSrc = fs3.readlinkSync(src);
       if (opts.dereference) {
         resolvedSrc = path.resolve(process.cwd(), resolvedSrc);
       }
       if (destStat === notExist) {
-        return fs2.symlinkSync(resolvedSrc, dest);
+        return fs3.symlinkSync(resolvedSrc, dest);
       } else {
         let resolvedDest;
         try {
-          resolvedDest = fs2.readlinkSync(dest);
+          resolvedDest = fs3.readlinkSync(dest);
         } catch (err) {
           if (err.code === "EINVAL" || err.code === "UNKNOWN")
-            return fs2.symlinkSync(resolvedSrc, dest);
+            return fs3.symlinkSync(resolvedSrc, dest);
           throw err;
         }
         if (opts.dereference) {
@@ -4299,15 +4299,15 @@ var require_copy_sync = __commonJS({
         if (isSrcSubdir(resolvedSrc, resolvedDest)) {
           throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
         }
-        if (fs2.statSync(dest).isDirectory() && isSrcSubdir(resolvedDest, resolvedSrc)) {
+        if (fs3.statSync(dest).isDirectory() && isSrcSubdir(resolvedDest, resolvedSrc)) {
           throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
         }
         return copyLink(resolvedSrc, dest);
       }
     }
     function copyLink(resolvedSrc, dest) {
-      fs2.unlinkSync(dest);
-      return fs2.symlinkSync(resolvedSrc, dest);
+      fs3.unlinkSync(dest);
+      return fs3.symlinkSync(resolvedSrc, dest);
     }
     function isSrcSubdir(src, dest) {
       const srcArray = path.resolve(src).split(path.sep);
@@ -4315,10 +4315,10 @@ var require_copy_sync = __commonJS({
       return srcArray.reduce((acc, current, i) => acc && destArray[i] === current, true);
     }
     function checkStats(src, dest) {
-      const srcStat = fs2.statSync(src);
+      const srcStat = fs3.statSync(src);
       let destStat;
       try {
-        destStat = fs2.statSync(dest);
+        destStat = fs3.statSync(dest);
       } catch (err) {
         if (err.code === "ENOENT")
           return { srcStat, destStat: notExist };
@@ -4355,13 +4355,13 @@ var require_path_exists = __commonJS({
   "../../node_modules/.pnpm/fs-extra@7.0.1/node_modules/fs-extra/lib/path-exists/index.js"(exports, module2) {
     "use strict";
     var u2 = require_universalify().fromPromise;
-    var fs2 = require_fs();
+    var fs3 = require_fs();
     function pathExists5(path) {
-      return fs2.access(path).then(() => true).catch(() => false);
+      return fs3.access(path).then(() => true).catch(() => false);
     }
     module2.exports = {
       pathExists: u2(pathExists5),
-      pathExistsSync: fs2.existsSync
+      pathExistsSync: fs3.existsSync
     };
   }
 });
@@ -4370,13 +4370,13 @@ var require_path_exists = __commonJS({
 var require_copy = __commonJS({
   "../../node_modules/.pnpm/fs-extra@7.0.1/node_modules/fs-extra/lib/copy/copy.js"(exports, module2) {
     "use strict";
-    var fs2 = require_graceful_fs();
+    var fs3 = require_graceful_fs();
     var path = require("path");
     var mkdirp3 = require_mkdirs2().mkdirs;
     var pathExists5 = require_path_exists().pathExists;
     var utimes = require_utimes().utimesMillis;
     var notExist = Symbol("notExist");
-    function copy3(src, dest, opts, cb) {
+    function copy4(src, dest, opts, cb) {
       if (typeof opts === "function" && !cb) {
         cb = opts;
         opts = {};
@@ -4431,7 +4431,7 @@ var require_copy = __commonJS({
       return getStats(destStat, src, dest, opts, cb);
     }
     function getStats(destStat, src, dest, opts, cb) {
-      const stat = opts.dereference ? fs2.stat : fs2.lstat;
+      const stat = opts.dereference ? fs3.stat : fs3.lstat;
       stat(src, (err, srcStat) => {
         if (err)
           return cb(err);
@@ -4450,7 +4450,7 @@ var require_copy = __commonJS({
     }
     function mayCopyFile(srcStat, src, dest, opts, cb) {
       if (opts.overwrite) {
-        fs2.unlink(dest, (err) => {
+        fs3.unlink(dest, (err) => {
           if (err)
             return cb(err);
           return copyFile(srcStat, src, dest, opts, cb);
@@ -4461,8 +4461,8 @@ var require_copy = __commonJS({
         return cb();
     }
     function copyFile(srcStat, src, dest, opts, cb) {
-      if (typeof fs2.copyFile === "function") {
-        return fs2.copyFile(src, dest, (err) => {
+      if (typeof fs3.copyFile === "function") {
+        return fs3.copyFile(src, dest, (err) => {
           if (err)
             return cb(err);
           return setDestModeAndTimestamps(srcStat, dest, opts, cb);
@@ -4471,14 +4471,14 @@ var require_copy = __commonJS({
       return copyFileFallback(srcStat, src, dest, opts, cb);
     }
     function copyFileFallback(srcStat, src, dest, opts, cb) {
-      const rs2 = fs2.createReadStream(src);
+      const rs2 = fs3.createReadStream(src);
       rs2.on("error", (err) => cb(err)).once("open", () => {
-        const ws2 = fs2.createWriteStream(dest, { mode: srcStat.mode });
+        const ws2 = fs3.createWriteStream(dest, { mode: srcStat.mode });
         ws2.on("error", (err) => cb(err)).on("open", () => rs2.pipe(ws2)).once("close", () => setDestModeAndTimestamps(srcStat, dest, opts, cb));
       });
     }
     function setDestModeAndTimestamps(srcStat, dest, opts, cb) {
-      fs2.chmod(dest, srcStat.mode, (err) => {
+      fs3.chmod(dest, srcStat.mode, (err) => {
         if (err)
           return cb(err);
         if (opts.preserveTimestamps) {
@@ -4496,18 +4496,18 @@ var require_copy = __commonJS({
       return copyDir(src, dest, opts, cb);
     }
     function mkDirAndCopy(srcStat, src, dest, opts, cb) {
-      fs2.mkdir(dest, (err) => {
+      fs3.mkdir(dest, (err) => {
         if (err)
           return cb(err);
         copyDir(src, dest, opts, (err2) => {
           if (err2)
             return cb(err2);
-          return fs2.chmod(dest, srcStat.mode, cb);
+          return fs3.chmod(dest, srcStat.mode, cb);
         });
       });
     }
     function copyDir(src, dest, opts, cb) {
-      fs2.readdir(src, (err, items) => {
+      fs3.readdir(src, (err, items) => {
         if (err)
           return cb(err);
         return copyDirItems(items, src, dest, opts, cb);
@@ -4533,19 +4533,19 @@ var require_copy = __commonJS({
       });
     }
     function onLink(destStat, src, dest, opts, cb) {
-      fs2.readlink(src, (err, resolvedSrc) => {
+      fs3.readlink(src, (err, resolvedSrc) => {
         if (err)
           return cb(err);
         if (opts.dereference) {
           resolvedSrc = path.resolve(process.cwd(), resolvedSrc);
         }
         if (destStat === notExist) {
-          return fs2.symlink(resolvedSrc, dest, cb);
+          return fs3.symlink(resolvedSrc, dest, cb);
         } else {
-          fs2.readlink(dest, (err2, resolvedDest) => {
+          fs3.readlink(dest, (err2, resolvedDest) => {
             if (err2) {
               if (err2.code === "EINVAL" || err2.code === "UNKNOWN")
-                return fs2.symlink(resolvedSrc, dest, cb);
+                return fs3.symlink(resolvedSrc, dest, cb);
               return cb(err2);
             }
             if (opts.dereference) {
@@ -4563,10 +4563,10 @@ var require_copy = __commonJS({
       });
     }
     function copyLink(resolvedSrc, dest, cb) {
-      fs2.unlink(dest, (err) => {
+      fs3.unlink(dest, (err) => {
         if (err)
           return cb(err);
-        return fs2.symlink(resolvedSrc, dest, cb);
+        return fs3.symlink(resolvedSrc, dest, cb);
       });
     }
     function isSrcSubdir(src, dest) {
@@ -4575,10 +4575,10 @@ var require_copy = __commonJS({
       return srcArray.reduce((acc, current, i) => acc && destArray[i] === current, true);
     }
     function checkStats(src, dest, cb) {
-      fs2.stat(src, (err, srcStat) => {
+      fs3.stat(src, (err, srcStat) => {
         if (err)
           return cb(err);
-        fs2.stat(dest, (err2, destStat) => {
+        fs3.stat(dest, (err2, destStat) => {
           if (err2) {
             if (err2.code === "ENOENT")
               return cb(null, { srcStat, destStat: notExist });
@@ -4602,7 +4602,7 @@ var require_copy = __commonJS({
         return cb(null, destStat);
       });
     }
-    module2.exports = copy3;
+    module2.exports = copy4;
   }
 });
 
@@ -4621,7 +4621,7 @@ var require_copy2 = __commonJS({
 var require_rimraf = __commonJS({
   "../../node_modules/.pnpm/fs-extra@7.0.1/node_modules/fs-extra/lib/remove/rimraf.js"(exports, module2) {
     "use strict";
-    var fs2 = require_graceful_fs();
+    var fs3 = require_graceful_fs();
     var path = require("path");
     var assert = require("assert");
     var isWindows = process.platform === "win32";
@@ -4635,9 +4635,9 @@ var require_rimraf = __commonJS({
         "readdir"
       ];
       methods.forEach((m2) => {
-        options[m2] = options[m2] || fs2[m2];
+        options[m2] = options[m2] || fs3[m2];
         m2 = m2 + "Sync";
-        options[m2] = options[m2] || fs2[m2];
+        options[m2] = options[m2] || fs3[m2];
       });
       options.maxBusyTries = options.maxBusyTries || 3;
     }
@@ -4886,14 +4886,14 @@ var require_empty = __commonJS({
   "../../node_modules/.pnpm/fs-extra@7.0.1/node_modules/fs-extra/lib/empty/index.js"(exports, module2) {
     "use strict";
     var u2 = require_universalify().fromCallback;
-    var fs2 = require("fs");
+    var fs3 = require("fs");
     var path = require("path");
     var mkdir = require_mkdirs2();
     var remove3 = require_remove();
     var emptyDir = u2(function emptyDir2(dir, callback) {
       callback = callback || function() {
       };
-      fs2.readdir(dir, (err, items) => {
+      fs3.readdir(dir, (err, items) => {
         if (err)
           return mkdir.mkdirs(dir, callback);
         items = items.map((item) => path.join(dir, item));
@@ -4913,7 +4913,7 @@ var require_empty = __commonJS({
     function emptyDirSync(dir) {
       let items;
       try {
-        items = fs2.readdirSync(dir);
+        items = fs3.readdirSync(dir);
       } catch (err) {
         return mkdir.mkdirsSync(dir);
       }
@@ -4937,18 +4937,18 @@ var require_file = __commonJS({
     "use strict";
     var u2 = require_universalify().fromCallback;
     var path = require("path");
-    var fs2 = require_graceful_fs();
+    var fs3 = require_graceful_fs();
     var mkdir = require_mkdirs2();
     var pathExists5 = require_path_exists().pathExists;
     function createFile(file, callback) {
       function makeFile() {
-        fs2.writeFile(file, "", (err) => {
+        fs3.writeFile(file, "", (err) => {
           if (err)
             return callback(err);
           callback();
         });
       }
-      fs2.stat(file, (err, stats) => {
+      fs3.stat(file, (err, stats) => {
         if (!err && stats.isFile())
           return callback();
         const dir = path.dirname(file);
@@ -4968,16 +4968,16 @@ var require_file = __commonJS({
     function createFileSync(file) {
       let stats;
       try {
-        stats = fs2.statSync(file);
+        stats = fs3.statSync(file);
       } catch (e) {
       }
       if (stats && stats.isFile())
         return;
       const dir = path.dirname(file);
-      if (!fs2.existsSync(dir)) {
+      if (!fs3.existsSync(dir)) {
         mkdir.mkdirsSync(dir);
       }
-      fs2.writeFileSync(file, "");
+      fs3.writeFileSync(file, "");
     }
     module2.exports = {
       createFile: u2(createFile),
@@ -4992,12 +4992,12 @@ var require_link = __commonJS({
     "use strict";
     var u2 = require_universalify().fromCallback;
     var path = require("path");
-    var fs2 = require_graceful_fs();
+    var fs3 = require_graceful_fs();
     var mkdir = require_mkdirs2();
     var pathExists5 = require_path_exists().pathExists;
     function createLink(srcpath, dstpath, callback) {
       function makeLink(srcpath2, dstpath2) {
-        fs2.link(srcpath2, dstpath2, (err) => {
+        fs3.link(srcpath2, dstpath2, (err) => {
           if (err)
             return callback(err);
           callback(null);
@@ -5008,7 +5008,7 @@ var require_link = __commonJS({
           return callback(err);
         if (destinationExists)
           return callback(null);
-        fs2.lstat(srcpath, (err2) => {
+        fs3.lstat(srcpath, (err2) => {
           if (err2) {
             err2.message = err2.message.replace("lstat", "ensureLink");
             return callback(err2);
@@ -5029,21 +5029,21 @@ var require_link = __commonJS({
       });
     }
     function createLinkSync(srcpath, dstpath) {
-      const destinationExists = fs2.existsSync(dstpath);
+      const destinationExists = fs3.existsSync(dstpath);
       if (destinationExists)
         return void 0;
       try {
-        fs2.lstatSync(srcpath);
+        fs3.lstatSync(srcpath);
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureLink");
         throw err;
       }
       const dir = path.dirname(dstpath);
-      const dirExists = fs2.existsSync(dir);
+      const dirExists = fs3.existsSync(dir);
       if (dirExists)
-        return fs2.linkSync(srcpath, dstpath);
+        return fs3.linkSync(srcpath, dstpath);
       mkdir.mkdirsSync(dir);
-      return fs2.linkSync(srcpath, dstpath);
+      return fs3.linkSync(srcpath, dstpath);
     }
     module2.exports = {
       createLink: u2(createLink),
@@ -5057,11 +5057,11 @@ var require_symlink_paths = __commonJS({
   "../../node_modules/.pnpm/fs-extra@7.0.1/node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports, module2) {
     "use strict";
     var path = require("path");
-    var fs2 = require_graceful_fs();
+    var fs3 = require_graceful_fs();
     var pathExists5 = require_path_exists().pathExists;
     function symlinkPaths(srcpath, dstpath, callback) {
       if (path.isAbsolute(srcpath)) {
-        return fs2.lstat(srcpath, (err) => {
+        return fs3.lstat(srcpath, (err) => {
           if (err) {
             err.message = err.message.replace("lstat", "ensureSymlink");
             return callback(err);
@@ -5083,7 +5083,7 @@ var require_symlink_paths = __commonJS({
               "toDst": srcpath
             });
           } else {
-            return fs2.lstat(srcpath, (err2) => {
+            return fs3.lstat(srcpath, (err2) => {
               if (err2) {
                 err2.message = err2.message.replace("lstat", "ensureSymlink");
                 return callback(err2);
@@ -5100,7 +5100,7 @@ var require_symlink_paths = __commonJS({
     function symlinkPathsSync(srcpath, dstpath) {
       let exists;
       if (path.isAbsolute(srcpath)) {
-        exists = fs2.existsSync(srcpath);
+        exists = fs3.existsSync(srcpath);
         if (!exists)
           throw new Error("absolute srcpath does not exist");
         return {
@@ -5110,14 +5110,14 @@ var require_symlink_paths = __commonJS({
       } else {
         const dstdir = path.dirname(dstpath);
         const relativeToDst = path.join(dstdir, srcpath);
-        exists = fs2.existsSync(relativeToDst);
+        exists = fs3.existsSync(relativeToDst);
         if (exists) {
           return {
             "toCwd": relativeToDst,
             "toDst": srcpath
           };
         } else {
-          exists = fs2.existsSync(srcpath);
+          exists = fs3.existsSync(srcpath);
           if (!exists)
             throw new Error("relative srcpath does not exist");
           return {
@@ -5138,13 +5138,13 @@ var require_symlink_paths = __commonJS({
 var require_symlink_type = __commonJS({
   "../../node_modules/.pnpm/fs-extra@7.0.1/node_modules/fs-extra/lib/ensure/symlink-type.js"(exports, module2) {
     "use strict";
-    var fs2 = require_graceful_fs();
+    var fs3 = 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);
-      fs2.lstat(srcpath, (err, stats) => {
+      fs3.lstat(srcpath, (err, stats) => {
         if (err)
           return callback(null, "file");
         type = stats && stats.isDirectory() ? "dir" : "file";
@@ -5156,7 +5156,7 @@ var require_symlink_type = __commonJS({
       if (type)
         return type;
       try {
-        stats = fs2.lstatSync(srcpath);
+        stats = fs3.lstatSync(srcpath);
       } catch (e) {
         return "file";
       }
@@ -5175,7 +5175,7 @@ var require_symlink = __commonJS({
     "use strict";
     var u2 = require_universalify().fromCallback;
     var path = require("path");
-    var fs2 = require_graceful_fs();
+    var fs3 = require_graceful_fs();
     var _mkdirs = require_mkdirs2();
     var mkdirs = _mkdirs.mkdirs;
     var mkdirsSync = _mkdirs.mkdirsSync;
@@ -5206,11 +5206,11 @@ var require_symlink = __commonJS({
               if (err4)
                 return callback(err4);
               if (dirExists)
-                return fs2.symlink(srcpath, dstpath, type2, callback);
+                return fs3.symlink(srcpath, dstpath, type2, callback);
               mkdirs(dir, (err5) => {
                 if (err5)
                   return callback(err5);
-                fs2.symlink(srcpath, dstpath, type2, callback);
+                fs3.symlink(srcpath, dstpath, type2, callback);
               });
             });
           });
@@ -5218,18 +5218,18 @@ var require_symlink = __commonJS({
       });
     }
     function createSymlinkSync(srcpath, dstpath, type) {
-      const destinationExists = fs2.existsSync(dstpath);
+      const destinationExists = fs3.existsSync(dstpath);
       if (destinationExists)
         return void 0;
       const relative2 = symlinkPathsSync(srcpath, dstpath);
       srcpath = relative2.toDst;
       type = symlinkTypeSync(relative2.toCwd, type);
       const dir = path.dirname(dstpath);
-      const exists = fs2.existsSync(dir);
+      const exists = fs3.existsSync(dir);
       if (exists)
-        return fs2.symlinkSync(srcpath, dstpath, type);
+        return fs3.symlinkSync(srcpath, dstpath, type);
       mkdirsSync(dir);
-      return fs2.symlinkSync(srcpath, dstpath, type);
+      return fs3.symlinkSync(srcpath, dstpath, type);
     }
     module2.exports = {
       createSymlink: u2(createSymlink),
@@ -5283,12 +5283,12 @@ var require_jsonfile = __commonJS({
         options = { encoding: options };
       }
       options = options || {};
-      var fs2 = options.fs || _fs;
+      var fs3 = options.fs || _fs;
       var shouldThrow = true;
       if ("throws" in options) {
         shouldThrow = options.throws;
       }
-      fs2.readFile(file, options, function(err, data) {
+      fs3.readFile(file, options, function(err, data) {
         if (err)
           return callback(err);
         data = stripBom(data);
@@ -5311,13 +5311,13 @@ var require_jsonfile = __commonJS({
       if (typeof options === "string") {
         options = { encoding: options };
       }
-      var fs2 = options.fs || _fs;
+      var fs3 = options.fs || _fs;
       var shouldThrow = true;
       if ("throws" in options) {
         shouldThrow = options.throws;
       }
       try {
-        var content = fs2.readFileSync(file, options);
+        var content = fs3.readFileSync(file, options);
         content = stripBom(content);
         return JSON.parse(content, options.reviver);
       } catch (err) {
@@ -5349,7 +5349,7 @@ var require_jsonfile = __commonJS({
         options = {};
       }
       options = options || {};
-      var fs2 = options.fs || _fs;
+      var fs3 = options.fs || _fs;
       var str = "";
       try {
         str = stringify(obj, options);
@@ -5358,13 +5358,13 @@ var require_jsonfile = __commonJS({
           callback(err, null);
         return;
       }
-      fs2.writeFile(file, str, options, callback);
+      fs3.writeFile(file, str, options, callback);
     }
     function writeFileSync(file, obj, options) {
       options = options || {};
-      var fs2 = options.fs || _fs;
+      var fs3 = options.fs || _fs;
       var str = stringify(obj, options);
-      return fs2.writeFileSync(file, str, options);
+      return fs3.writeFileSync(file, str, options);
     }
     function stripBom(content) {
       if (Buffer.isBuffer(content))
@@ -5432,13 +5432,13 @@ var require_output_json = __commonJS({
 var require_output_json_sync = __commonJS({
   "../../node_modules/.pnpm/fs-extra@7.0.1/node_modules/fs-extra/lib/json/output-json-sync.js"(exports, module2) {
     "use strict";
-    var fs2 = require_graceful_fs();
+    var fs3 = require_graceful_fs();
     var path = require("path");
     var mkdir = require_mkdirs2();
     var jsonFile = require_jsonfile2();
     function outputJsonSync(file, data, options) {
       const dir = path.dirname(file);
-      if (!fs2.existsSync(dir)) {
+      if (!fs3.existsSync(dir)) {
         mkdir.mkdirsSync(dir);
       }
       jsonFile.writeJsonSync(file, data, options);
@@ -5469,7 +5469,7 @@ var require_json = __commonJS({
 var require_move_sync = __commonJS({
   "../../node_modules/.pnpm/fs-extra@7.0.1/node_modules/fs-extra/lib/move-sync/index.js"(exports, module2) {
     "use strict";
-    var fs2 = require_graceful_fs();
+    var fs3 = require_graceful_fs();
     var path = require("path");
     var copySync = require_copy_sync2().copySync;
     var removeSync = require_remove().removeSync;
@@ -5481,7 +5481,7 @@ var require_move_sync = __commonJS({
       src = path.resolve(src);
       dest = path.resolve(dest);
       if (src === dest)
-        return fs2.accessSync(src);
+        return fs3.accessSync(src);
       if (isSrcSubdir(src, dest))
         throw new Error(`Cannot move '${src}' into itself '${dest}'.`);
       mkdirpSync(path.dirname(dest));
@@ -5489,7 +5489,7 @@ var require_move_sync = __commonJS({
       function tryRenameSync() {
         if (overwrite) {
           try {
-            return fs2.renameSync(src, dest);
+            return fs3.renameSync(src, dest);
           } catch (err) {
             if (err.code === "ENOTEMPTY" || err.code === "EEXIST" || err.code === "EPERM") {
               removeSync(dest);
@@ -5502,8 +5502,8 @@ var require_move_sync = __commonJS({
           }
         } else {
           try {
-            fs2.linkSync(src, dest);
-            return fs2.unlinkSync(src);
+            fs3.linkSync(src, dest);
+            return fs3.unlinkSync(src);
           } catch (err) {
             if (err.code === "EXDEV" || err.code === "EISDIR" || err.code === "EPERM" || err.code === "ENOTSUP") {
               return moveSyncAcrossDevice(src, dest, overwrite);
@@ -5514,7 +5514,7 @@ var require_move_sync = __commonJS({
       }
     }
     function moveSyncAcrossDevice(src, dest, overwrite) {
-      const stat = fs2.statSync(src);
+      const stat = fs3.statSync(src);
       if (stat.isDirectory()) {
         return moveDirSyncAcrossDevice(src, dest, overwrite);
       } else {
@@ -5525,18 +5525,18 @@ var require_move_sync = __commonJS({
       const BUF_LENGTH = 64 * 1024;
       const _buff = buffer(BUF_LENGTH);
       const flags = overwrite ? "w" : "wx";
-      const fdr = fs2.openSync(src, "r");
-      const stat = fs2.fstatSync(fdr);
-      const fdw = fs2.openSync(dest, flags, stat.mode);
+      const fdr = fs3.openSync(src, "r");
+      const stat = fs3.fstatSync(fdr);
+      const fdw = fs3.openSync(dest, flags, stat.mode);
       let pos = 0;
       while (pos < stat.size) {
-        const bytesRead = fs2.readSync(fdr, _buff, 0, BUF_LENGTH, pos);
-        fs2.writeSync(fdw, _buff, 0, bytesRead);
+        const bytesRead = fs3.readSync(fdr, _buff, 0, BUF_LENGTH, pos);
+        fs3.writeSync(fdw, _buff, 0, bytesRead);
         pos += bytesRead;
       }
-      fs2.closeSync(fdr);
-      fs2.closeSync(fdw);
-      return fs2.unlinkSync(src);
+      fs3.closeSync(fdr);
+      fs3.closeSync(fdw);
+      return fs3.unlinkSync(src);
     }
     function moveDirSyncAcrossDevice(src, dest, overwrite) {
       const options = {
@@ -5555,7 +5555,7 @@ var require_move_sync = __commonJS({
     }
     function isSrcSubdir(src, dest) {
       try {
-        return fs2.statSync(src).isDirectory() && src !== dest && dest.indexOf(src) > -1 && dest.split(path.dirname(src) + path.sep)[1].split(path.sep)[0] === path.basename(src);
+        return fs3.statSync(src).isDirectory() && src !== dest && dest.indexOf(src) > -1 && dest.split(path.dirname(src) + path.sep)[1].split(path.sep)[0] === path.basename(src);
       } catch (e) {
         return false;
       }
@@ -5571,9 +5571,9 @@ var require_move = __commonJS({
   "../../node_modules/.pnpm/fs-extra@7.0.1/node_modules/fs-extra/lib/move/index.js"(exports, module2) {
     "use strict";
     var u2 = require_universalify().fromCallback;
-    var fs2 = require_graceful_fs();
+    var fs3 = require_graceful_fs();
     var path = require("path");
-    var copy3 = require_copy2().copy;
+    var copy4 = require_copy2().copy;
     var remove3 = require_remove().remove;
     var mkdirp3 = require_mkdirs2().mkdirp;
     var pathExists5 = require_path_exists().pathExists;
@@ -5586,8 +5586,8 @@ var require_move = __commonJS({
       src = path.resolve(src);
       dest = path.resolve(dest);
       if (src === dest)
-        return fs2.access(src, cb);
-      fs2.stat(src, (err, st2) => {
+        return fs3.access(src, cb);
+      fs3.stat(src, (err, st2) => {
         if (err)
           return cb(err);
         if (st2.isDirectory() && isSrcSubdir(src, dest)) {
@@ -5617,7 +5617,7 @@ var require_move = __commonJS({
       });
     }
     function rename(src, dest, overwrite, cb) {
-      fs2.rename(src, dest, (err) => {
+      fs3.rename(src, dest, (err) => {
         if (!err)
           return cb();
         if (err.code !== "EXDEV")
@@ -5630,7 +5630,7 @@ var require_move = __commonJS({
         overwrite,
         errorOnExist: true
       };
-      copy3(src, dest, opts, (err) => {
+      copy4(src, dest, opts, (err) => {
         if (err)
           return cb(err);
         return remove3(src, cb);
@@ -5654,7 +5654,7 @@ var require_output = __commonJS({
   "../../node_modules/.pnpm/fs-extra@7.0.1/node_modules/fs-extra/lib/output/index.js"(exports, module2) {
     "use strict";
     var u2 = require_universalify().fromCallback;
-    var fs2 = require_graceful_fs();
+    var fs3 = require_graceful_fs();
     var path = require("path");
     var mkdir = require_mkdirs2();
     var pathExists5 = require_path_exists().pathExists;
@@ -5668,21 +5668,21 @@ var require_output = __commonJS({
         if (err)
           return callback(err);
         if (itDoes)
-          return fs2.writeFile(file, data, encoding, callback);
+          return fs3.writeFile(file, data, encoding, callback);
         mkdir.mkdirs(dir, (err2) => {
           if (err2)
             return callback(err2);
-          fs2.writeFile(file, data, encoding, callback);
+          fs3.writeFile(file, data, encoding, callback);
         });
       });
     }
     function outputFileSync(file, ...args) {
       const dir = path.dirname(file);
-      if (fs2.existsSync(dir)) {
-        return fs2.writeFileSync(file, ...args);
+      if (fs3.existsSync(dir)) {
+        return fs3.writeFileSync(file, ...args);
       }
       mkdir.mkdirsSync(dir);
-      fs2.writeFileSync(file, ...args);
+      fs3.writeFileSync(file, ...args);
     }
     module2.exports = {
       outputFile: u2(outputFile),
@@ -5712,11 +5712,11 @@ var require_lib2 = __commonJS({
       require_path_exists(),
       require_remove()
     );
-    var fs2 = require("fs");
-    if (Object.getOwnPropertyDescriptor(fs2, "promises")) {
+    var fs3 = require("fs");
+    if (Object.getOwnPropertyDescriptor(fs3, "promises")) {
       Object.defineProperty(module2.exports, "promises", {
         get() {
-          return fs2.promises;
+          return fs3.promises;
         }
       });
     }
@@ -8786,7 +8786,7 @@ var require_pend = __commonJS({
 // ../../node_modules/.pnpm/fd-slicer@1.1.0/node_modules/fd-slicer/index.js
 var require_fd_slicer = __commonJS({
   "../../node_modules/.pnpm/fd-slicer@1.1.0/node_modules/fd-slicer/index.js"(exports) {
-    var fs2 = require("fs");
+    var fs3 = require("fs");
     var util = require("util");
     var stream = require("stream");
     var Readable = stream.Readable;
@@ -8811,7 +8811,7 @@ var require_fd_slicer = __commonJS({
     FdSlicer.prototype.read = function(buffer, offset, length, position, callback) {
       var self = this;
       self.pend.go(function(cb) {
-        fs2.read(self.fd, buffer, offset, length, position, function(err, bytesRead, buffer2) {
+        fs3.read(self.fd, buffer, offset, length, position, function(err, bytesRead, buffer2) {
           cb();
           callback(err, bytesRead, buffer2);
         });
@@ -8820,7 +8820,7 @@ var require_fd_slicer = __commonJS({
     FdSlicer.prototype.write = function(buffer, offset, length, position, callback) {
       var self = this;
       self.pend.go(function(cb) {
-        fs2.write(self.fd, buffer, offset, length, position, function(err, written, buffer2) {
+        fs3.write(self.fd, buffer, offset, length, position, function(err, written, buffer2) {
           cb();
           callback(err, written, buffer2);
         });
@@ -8843,7 +8843,7 @@ var require_fd_slicer = __commonJS({
       if (self.refCount < 0)
         throw new Error("invalid unref");
       if (self.autoClose) {
-        fs2.close(self.fd, onCloseDone);
+        fs3.close(self.fd, onCloseDone);
       }
       function onCloseDone(err) {
         if (err) {
@@ -8882,7 +8882,7 @@ var require_fd_slicer = __commonJS({
         if (self.destroyed)
           return cb();
         var buffer = new Buffer(toRead);
-        fs2.read(self.context.fd, buffer, 0, toRead, self.pos, function(err, bytesRead) {
+        fs3.read(self.context.fd, buffer, 0, toRead, self.pos, function(err, bytesRead) {
           if (err) {
             self.destroy(err);
           } else if (bytesRead === 0) {
@@ -8932,7 +8932,7 @@ var require_fd_slicer = __commonJS({
       self.context.pend.go(function(cb) {
         if (self.destroyed)
           return cb();
-        fs2.write(self.context.fd, buffer, 0, buffer.length, self.pos, function(err2, bytes) {
+        fs3.write(self.context.fd, buffer, 0, buffer.length, self.pos, function(err2, bytes) {
           if (err2) {
             self.destroy();
             cb();
@@ -9361,7 +9361,7 @@ var require_buffer_crc32 = __commonJS({
 // ../../node_modules/.pnpm/yauzl@2.10.0/node_modules/yauzl/index.js
 var require_yauzl = __commonJS({
   "../../node_modules/.pnpm/yauzl@2.10.0/node_modules/yauzl/index.js"(exports) {
-    var fs2 = require("fs");
+    var fs3 = require("fs");
     var zlib = require("zlib");
     var fd_slicer = require_fd_slicer();
     var crc32 = require_buffer_crc32();
@@ -9398,12 +9398,12 @@ var require_yauzl = __commonJS({
         options.strictFileNames = false;
       if (callback == null)
         callback = defaultCallback;
-      fs2.open(path, "r", function(err, fd) {
+      fs3.open(path, "r", function(err, fd) {
         if (err)
           return callback(err);
         fromFd(fd, options, function(err2, zipfile) {
           if (err2)
-            fs2.close(fd, defaultCallback);
+            fs3.close(fd, defaultCallback);
           callback(err2, zipfile);
         });
       });
@@ -9427,7 +9427,7 @@ var require_yauzl = __commonJS({
         options.strictFileNames = false;
       if (callback == null)
         callback = defaultCallback;
-      fs2.fstat(fd, function(err, stats) {
+      fs3.fstat(fd, function(err, stats) {
         if (err)
           return callback(err);
         var reader = fd_slicer.createFromFd(fd, { autoClose: true });
@@ -10883,9 +10883,10 @@ __export(src_exports, {
   build: () => build,
   detectEntrypoint: () => detectEntrypoint,
   detectGoEntrypoint: () => detectGoEntrypoint,
+  diagnostics: () => diagnostics,
   getNewHandlerFunctionName: () => getNewHandlerFunctionName,
   prepareCache: () => prepareCache,
-  shouldServe: () => import_build_utils4.shouldServe,
+  shouldServe: () => import_build_utils5.shouldServe,
   startDevServer: () => startDevServer,
   version: () => version
 });
@@ -10897,7 +10898,7 @@ var import_child_process2 = require("child_process");
 var import_once = __toESM(require_dist());
 var import_path7 = require("path");
 var import_fs_extra4 = __toESM(require_lib2());
-var import_build_utils4 = require("@vercel/build-utils");
+var import_build_utils5 = require("@vercel/build-utils");
 
 // src/go-helpers.ts
 var import_crypto = require("crypto");
@@ -14120,6 +14121,7 @@ var wo = (s3) => {
 var import_execa = __toESM(require_execa());
 var import_node_fetch = __toESM(require_lib4());
 var import_fs_extra = __toESM(require_lib2());
+var import_fs5 = __toESM(require("fs"));
 var import_path4 = require("path");
 var import_string_argv = __toESM(require_string_argv());
 var import_build_utils = require("@vercel/build-utils");
@@ -14254,12 +14256,13 @@ Learn more: https://vercel.com/docs/functions/serverless-functions/runtimes/go
   return JSON.parse(analyzed);
 }
 var GoWrapper = class {
-  constructor(env, opts = {}) {
+  constructor(env, opts = {}, resolvedVersion) {
     if (!opts.cwd) {
       opts.cwd = process.cwd();
     }
     this.env = env;
     this.opts = opts;
+    this.resolvedVersion = resolvedVersion;
   }
   async execute(...args) {
     const { opts, env } = this;
@@ -14293,6 +14296,24 @@ var GoWrapper = class {
     }
     return this.execute(...args);
   }
+  /**
+   * Runs `go mod edit -json <path>` and returns the parsed structure.
+   */
+  async modEditJson(goModPath) {
+    try {
+      (0, import_build_utils.debug)(`Exec: go mod edit -json ${goModPath}`);
+      const result = await (0, import_execa.default)("go", ["mod", "edit", "-json", goModPath], {
+        ...this.opts,
+        env: this.env,
+        extendEnv: false,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      return JSON.parse(result.stdout);
+    } catch (err) {
+      (0, import_build_utils.debug)(`Failed to read go.mod for manifest: ${err}`);
+      return null;
+    }
+  }
   vendor() {
     return this.execute("mod", "vendor");
   }
@@ -14306,6 +14327,9 @@ var GoWrapper = class {
     }
     return this.execute(...args);
   }
+  getEnv() {
+    return this.env;
+  }
   build(src, dest, { vendorMode = false } = {}) {
     (0, import_build_utils.debug)(`Building optimized 'go' binary ${src} -> ${dest}`);
     const sources = Array.isArray(src) ? src : [src];
@@ -14407,7 +14431,7 @@ async function createGo({
       if (version2 === goSelectedVersion || short === goSelectedVersion) {
         (0, import_build_utils.debug)(`Selected go ${version2} (from ${label})`);
         await setGoEnv(goDir);
-        return new GoWrapper(env, opts);
+        return new GoWrapper(env, opts, version2);
       } else {
         (0, import_build_utils.debug)(`Found go ${version2} in ${label}, but need ${goSelectedVersion}`);
       }
@@ -14420,7 +14444,7 @@ async function createGo({
     version: goSelectedVersion
   });
   await setGoEnv(goGlobalCacheDir);
-  return new GoWrapper(env, opts);
+  return new GoWrapper(env, opts, goSelectedVersion);
 }
 async function download({ dest, version: version2 }) {
   const { filename, url } = getGoUrl(version2);
@@ -14499,6 +14523,83 @@ async function parseGoModVersionFromModule(modulePath) {
   }
   return version2;
 }
+async function isElfBinary(filePath) {
+  const fd = await import_fs5.default.promises.open(filePath, "r");
+  try {
+    const buf = new Uint8Array(4);
+    await fd.read(buf, 0, 4, 0);
+    return buf[0] === 127 && buf[1] === 69 && buf[2] === 76 && buf[3] === 70;
+  } finally {
+    await fd.close();
+  }
+}
+async function getGoModuleName(goModPath) {
+  try {
+    const content = await (0, import_fs_extra.readFile)(goModPath, "utf8");
+    const match = content.match(/^\s*module\s+(.+)$/m);
+    if (match) {
+      const modulePath = match[1].trim();
+      return (0, import_path4.basename)(modulePath);
+    }
+  } catch {
+  }
+  return void 0;
+}
+async function findGoBinary(workPath, destPath, goModPath, buildStartTime) {
+  if (await (0, import_fs_extra.pathExists)(destPath)) {
+    return;
+  }
+  const moduleName = goModPath ? await getGoModuleName(goModPath) : void 0;
+  const candidates = [moduleName, "server", "app", "main", "api"].filter(
+    (c) => Boolean(c)
+  );
+  for (const name of candidates) {
+    const p2 = (0, import_path4.join)(workPath, name);
+    if (await (0, import_fs_extra.pathExists)(p2)) {
+      const stat = await import_fs5.default.promises.stat(p2);
+      if (stat.isFile() && stat.mtimeMs >= buildStartTime && await isElfBinary(p2)) {
+        (0, import_build_utils.debug)(`Found Go binary: ${name}`);
+        await (0, import_fs_extra.copy)(p2, destPath);
+        return;
+      }
+    }
+  }
+  const found = [];
+  const entries = await import_fs5.default.promises.readdir(workPath);
+  for (const entry of entries) {
+    if (candidates.includes(entry))
+      continue;
+    const p2 = (0, import_path4.join)(workPath, entry);
+    const stat = await import_fs5.default.promises.stat(p2);
+    if (stat.isFile() && stat.mtimeMs >= buildStartTime && await isElfBinary(p2)) {
+      found.push(entry);
+    }
+  }
+  const binDir = (0, import_path4.join)(workPath, "bin");
+  if (await (0, import_fs_extra.pathExists)(binDir)) {
+    const binEntries = await import_fs5.default.promises.readdir(binDir);
+    for (const entry of binEntries) {
+      const p2 = (0, import_path4.join)(binDir, entry);
+      const stat = await import_fs5.default.promises.stat(p2);
+      if (stat.isFile() && stat.mtimeMs >= buildStartTime && await isElfBinary(p2)) {
+        found.push((0, import_path4.join)("bin", entry));
+      }
+    }
+  }
+  if (found.length === 1) {
+    (0, import_build_utils.debug)(`Found Go binary: ${found[0]}`);
+    await (0, import_fs_extra.copy)((0, import_path4.join)(workPath, found[0]), destPath);
+    return;
+  }
+  if (found.length > 1) {
+    throw new Error(
+      `Found multiple ELF binaries after buildCommand: ${found.join(", ")}. Use \`go build -o $VERCEL_OUTPUT_FILE\` to specify which binary to deploy.`
+    );
+  }
+  throw new Error(
+    "No compiled Go binary found after buildCommand. Ensure your command produces a Linux binary (GOOS=linux is set), or use `go build -o $VERCEL_OUTPUT_FILE`."
+  );
+}
 function parseGoModVersion(content) {
   const goMatches = /^\s*go\s+(\d+)\.(\d+)(?:\.(\d+))?\s*(?:\/\/.*)?$/gm.exec(
     content
@@ -14566,7 +14667,92 @@ var detectEntrypoint = async ({ workPath }) => {
 var import_child_process = require("child_process");
 var import_path6 = require("path");
 var import_fs_extra3 = __toESM(require_lib2());
+var import_build_utils4 = require("@vercel/build-utils");
+
+// src/diagnostics.ts
 var import_build_utils3 = require("@vercel/build-utils");
+function applyReplaces(goMod) {
+  const requires = goMod.Require ?? [];
+  const replaces = goMod.Replace ?? [];
+  const result = [];
+  for (const req of requires) {
+    const specific = replaces.find(
+      (r) => r.Old.Path === req.Path && r.Old.Version === req.Version
+    );
+    const wildcard = replaces.find(
+      (r) => r.Old.Path === req.Path && r.Old.Version === void 0
+    );
+    const rule = specific ?? wildcard;
+    const indirect = req.Indirect === true;
+    if (!rule) {
+      result.push({ name: req.Path, version: req.Version, indirect });
+      continue;
+    }
+    if (rule.New.Version === void 0) {
+      continue;
+    }
+    result.push({
+      name: rule.New.Path,
+      version: rule.New.Version,
+      indirect
+    });
+  }
+  return result;
+}
+async function generateProjectManifest({
+  workPath,
+  goModJson,
+  resolvedGoVersion,
+  framework,
+  serviceType
+}) {
+  try {
+    if (!goModJson)
+      return;
+    const projectModule = goModJson.Module?.Path;
+    const modules = applyReplaces(goModJson).filter(
+      (m2) => m2.name !== projectModule
+    );
+    const requested = goModJson.Go;
+    const directDeps = [];
+    const transitiveDeps = [];
+    for (const mod of modules) {
+      const dep = {
+        name: mod.name,
+        type: mod.indirect ? "transitive" : "direct",
+        scopes: ["prod"],
+        requested: mod.version,
+        resolved: mod.version,
+        source: "registry",
+        sourceUrl: "https://proxy.golang.org"
+      };
+      if (mod.indirect) {
+        transitiveDeps.push(dep);
+      } else {
+        directDeps.push(dep);
+      }
+    }
+    const manifest = {
+      version: import_build_utils3.MANIFEST_VERSION,
+      runtime: "go",
+      ...framework ? { framework } : {},
+      ...serviceType ? { serviceType } : {},
+      runtimeVersion: {
+        ...requested ? { requested } : {},
+        resolved: resolvedGoVersion
+      },
+      dependencies: [
+        ...directDeps.sort((a, b2) => a.name.localeCompare(b2.name)),
+        ...transitiveDeps.sort((a, b2) => a.name.localeCompare(b2.name))
+      ]
+    };
+    await (0, import_build_utils3.writeProjectManifest)(manifest, workPath, "go");
+  } catch {
+  }
+}
+var diagnostics = (0, import_build_utils3.createDiagnostics)("go");
+
+// src/standalone-server.ts
 async function findGoModPath(entrypointDir, workPath) {
   let goModPath = void 0;
   let isGoModInRootDir = false;
@@ -14576,7 +14762,7 @@ async function findGoModPath(entrypointDir, workPath) {
     const goMod = (0, import_path6.join)(dir, "go.mod");
     if (await (0, import_fs_extra3.pathExists)(goMod)) {
       goModPath = goMod;
-      (0, import_build_utils3.debug)(`Found ${goModPath}"`);
+      (0, import_build_utils4.debug)(`Found ${goModPath}"`);
       break;
     }
     dir = (0, import_path6.dirname)(dir);
@@ -14591,16 +14777,18 @@ async function buildStandaloneServer({
   entrypoint,
   config,
   workPath,
-  meta = {}
+  meta = {},
+  registerPreDeploy,
+  service
 }) {
-  (0, import_build_utils3.debug)(`Building standalone Go server: ${entrypoint}`);
-  await (0, import_build_utils3.download)(files, workPath, meta);
-  const lambdaOptions = await (0, import_build_utils3.getLambdaOptionsFromFunction)({
+  (0, import_build_utils4.debug)(`Building standalone Go server: ${entrypoint}`);
+  await (0, import_build_utils4.download)(files, workPath, meta);
+  const lambdaOptions = await (0, import_build_utils4.getLambdaOptionsFromFunction)({
     sourceFile: entrypoint,
     config
   });
   const architecture = lambdaOptions?.architecture || "x86_64";
-  const env = (0, import_build_utils3.cloneEnv)(process.env, meta.env, {
+  const env = (0, import_build_utils4.cloneEnv)(process.env, meta.env, {
     GOARCH: architecture === "arm64" ? "arm64" : "amd64",
     GOOS: "linux",
     CGO_ENABLED: "0"
@@ -14612,31 +14800,42 @@ async function buildStandaloneServer({
     opts: { cwd: workPath, env },
     workPath
   });
-  const outDir = await (0, import_build_utils3.getWriteableDirectory)();
+  const outDir = await (0, import_build_utils4.getWriteableDirectory)();
   const userServerPath = (0, import_path6.join)(outDir, "user-server");
   const bootstrapPath = (0, import_path6.join)(outDir, "executable");
   const vendorModulesPath = (0, import_path6.join)(workPath, "vendor", "modules.txt");
   const isVendored = await (0, import_fs_extra3.pathExists)(vendorModulesPath);
   if (isVendored) {
-    (0, import_build_utils3.debug)("Detected vendor directory, using -mod=vendor for build");
-  }
-  const buildTarget = entrypoint === "main.go" ? "." : "./" + (0, import_path6.dirname)(entrypoint);
-  (0, import_build_utils3.debug)(
-    `Building user Go server (${architecture}): go build ${buildTarget} -> ${userServerPath}`
-  );
-  try {
-    await go.build(buildTarget, userServerPath, { vendorMode: isVendored });
-  } catch (err) {
-    console.error(`Failed to build standalone Go server: ${buildTarget}`);
-    throw err;
+    (0, import_build_utils4.debug)("Detected vendor directory, using -mod=vendor for build");
+  }
+  const buildCommand = config?.buildCommand ?? config?.projectSettings?.buildCommand ?? void 0;
+  if (typeof buildCommand === "string") {
+    (0, import_build_utils4.debug)(`Running custom build command: ${buildCommand}`);
+    const buildStartTime = Date.now();
+    await (0, import_build_utils4.execCommand)(buildCommand, {
+      env: { ...go.getEnv(), VERCEL_OUTPUT_FILE: userServerPath },
+      cwd: workPath
+    });
+    await findGoBinary(workPath, userServerPath, goModPath, buildStartTime);
+  } else {
+    const buildTarget = entrypoint === "main.go" ? "." : "./" + (0, import_path6.dirname)(entrypoint);
+    (0, import_build_utils4.debug)(
+      `Building user Go server (${architecture}): go build ${buildTarget} -> ${userServerPath}`
+    );
+    try {
+      await go.build(buildTarget, userServerPath, { vendorMode: isVendored });
+    } catch (err) {
+      console.error(`Failed to build standalone Go server: ${buildTarget}`);
+      throw err;
+    }
   }
   const bootstrapDir = (0, import_path6.join)(__dirname, "../bootstrap");
   const bootstrapSrc = (0, import_path6.join)(bootstrapDir, "vc-init.go");
   const utilsSrc = (0, import_path6.join)(bootstrapDir, "vc-utils.go");
   const bootstrapGoModSrc = (0, import_path6.join)(bootstrapDir, "go.mod");
-  (0, import_build_utils3.debug)(`Building bootstrap wrapper: ${bootstrapSrc} -> ${bootstrapPath}`);
+  (0, import_build_utils4.debug)(`Building bootstrap wrapper: ${bootstrapSrc} -> ${bootstrapPath}`);
   try {
-    const bootstrapBuildDir = await (0, import_build_utils3.getWriteableDirectory)();
+    const bootstrapBuildDir = await (0, import_build_utils4.getWriteableDirectory)();
     const bootstrapGoFile = (0, import_path6.join)(bootstrapBuildDir, "main.go");
     await (0, import_fs_extra3.copy)(bootstrapSrc, bootstrapGoFile);
     await (0, import_fs_extra3.copy)(utilsSrc, (0, import_path6.join)(bootstrapBuildDir, "vc-utils.go"));
@@ -14663,7 +14862,7 @@ async function buildStandaloneServer({
   if (config && config.includeFiles) {
     const patterns = Array.isArray(config.includeFiles) ? config.includeFiles : [config.includeFiles];
     for (const pattern of patterns) {
-      const fsFiles = await (0, import_build_utils3.glob)(pattern, workPath);
+      const fsFiles = await (0, import_build_utils4.glob)(pattern, workPath);
       for (const [assetName, asset] of Object.entries(fsFiles)) {
         includedFiles[assetName] = asset;
       }
@@ -14673,14 +14872,14 @@ async function buildStandaloneServer({
     (0, import_fs_extra3.readFile)(userServerPath),
     (0, import_fs_extra3.readFile)(bootstrapPath)
   ]);
-  const lambda = new import_build_utils3.Lambda({
+  const lambda = new import_build_utils4.Lambda({
     ...lambdaOptions,
     files: {
       ...includedFiles,
       // Bootstrap is the main entrypoint (handles IPC protocol)
-      executable: new import_build_utils3.FileBlob({ mode: 493, data: bootstrapData }),
+      executable: new import_build_utils4.FileBlob({ mode: 493, data: bootstrapData }),
       // User's server is spawned by bootstrap
-      "user-server": new import_build_utils3.FileBlob({ mode: 493, data: userServerData })
+      "user-server": new import_build_utils4.FileBlob({ mode: 493, data: userServerData })
     },
     handler: "executable",
     runtime: "executable",
@@ -14688,18 +14887,38 @@ async function buildStandaloneServer({
     architecture,
     runtimeLanguage: "go"
   });
+  const preDeployCommand = config?.preDeployCommand;
+  if (registerPreDeploy && typeof preDeployCommand === "string") {
+    const capturedEnv = { ...env };
+    const capturedCwd = workPath;
+    registerPreDeploy(async () => {
+      (0, import_build_utils4.debug)(`Running pre-deploy command: \`${preDeployCommand}\``);
+      await (0, import_build_utils4.execCommand)(preDeployCommand, {
+        env: capturedEnv,
+        cwd: capturedCwd
+      });
+    });
+  }
+  const goModJson = goModPath ? await go.modEditJson(goModPath) : null;
+  await generateProjectManifest({
+    workPath,
+    goModJson,
+    resolvedGoVersion: go.resolvedVersion,
+    framework: config.framework ?? void 0,
+    serviceType: service ? (0, import_build_utils4.getReportedServiceType)(service) : void 0
+  });
   return { output: lambda };
 }
 async function startStandaloneDevServer(opts, resolvedEntrypoint) {
   const { workPath, meta = {} } = opts;
   const port = Math.floor(Math.random() * (65535 - 49152) + 49152);
-  const env = (0, import_build_utils3.cloneEnv)(process.env, meta.env, {
+  const env = (0, import_build_utils4.cloneEnv)(process.env, meta.env, {
     PORT: String(port)
   });
   const runTarget = resolvedEntrypoint === "main.go" ? "." : "./" + (0, import_path6.dirname)(resolvedEntrypoint);
   const devWrapper = (0, import_path6.join)(__dirname, "../bootstrap/vc-init-dev.go");
   const devUtils = (0, import_path6.join)(__dirname, "../bootstrap/vc-utils.go");
-  (0, import_build_utils3.debug)(
+  (0, import_build_utils4.debug)(
     `Starting standalone Go dev server wrapper: go run ${devWrapper} (target ${runTarget}, port ${port})`
   );
   const child = (0, import_child_process.spawn)("go", ["run", "-tags", "vcdev", devWrapper, devUtils], {
@@ -14769,31 +14988,38 @@ function getRenamedEntrypoint(entrypoint) {
   const filename = (0, import_path7.basename)(entrypoint);
   if (filename.startsWith("[")) {
     const newEntrypoint = entrypoint.replace("/[", "/now-bracket[");
-    (0, import_build_utils4.debug)(`Renamed entrypoint from ${entrypoint} to ${newEntrypoint}`);
+    (0, import_build_utils5.debug)(`Renamed entrypoint from ${entrypoint} to ${newEntrypoint}`);
     return newEntrypoint;
   }
   return void 0;
 }
 var version = 3;
 async function build(options) {
-  const { files, config, workPath, meta = {} } = options;
+  const {
+    files,
+    config,
+    workPath,
+    meta = {},
+    service,
+    registerPreDeploy
+  } = options;
   let { entrypoint } = options;
-  const goPath = await (0, import_build_utils4.getWriteableDirectory)();
+  const goPath = await (0, import_build_utils5.getWriteableDirectory)();
   const srcPath = (0, import_path7.join)(goPath, "src", "lambda");
   const downloadPath = meta.skipDownload ? workPath : srcPath;
-  await (0, import_build_utils4.download)(files, downloadPath, meta);
+  await (0, import_build_utils5.download)(files, downloadPath, meta);
   const undo = {
     fileActions: [],
     directoryCreation: [],
     functionRenames: []
   };
-  const env = (0, import_build_utils4.cloneEnv)(process.env, meta.env, {
+  const env = (0, import_build_utils5.cloneEnv)(process.env, meta.env, {
     GOARCH: "amd64",
     GOOS: "linux"
   });
   try {
     if (env.GIT_CREDENTIALS) {
-      (0, import_build_utils4.debug)("Initialize Git credentials...");
+      (0, import_build_utils5.debug)("Initialize Git credentials...");
       await initPrivateGit(env.GIT_CREDENTIALS);
     }
     if (env.GO111MODULE) {
@@ -14815,7 +15041,7 @@ Manually assigning 'GO111MODULE' is not recommended.
           `No Go entrypoint found. Expected one of: ${GO_CANDIDATE_ENTRYPOINTS.join(", ")}`
         );
       }
-      (0, import_build_utils4.debug)(`Using standalone Go server mode for ${resolvedEntrypoint}`);
+      (0, import_build_utils5.debug)(`Using standalone Go server mode for ${resolvedEntrypoint}`);
       return buildStandaloneServer({
         ...options,
         entrypoint: resolvedEntrypoint
@@ -14868,7 +15094,7 @@ Manually assigning 'GO111MODULE' is not recommended.
     if (config && config.includeFiles) {
       const patterns = Array.isArray(config.includeFiles) ? config.includeFiles : [config.includeFiles];
       for (const pattern of patterns) {
-        const fsFiles = await (0, import_build_utils4.glob)(pattern, entrypointDirname);
+        const fsFiles = await (0, import_build_utils5.glob)(pattern, entrypointDirname);
         for (const [assetName, asset] of Object.entries(fsFiles)) {
           includedFiles[assetName] = asset;
         }
@@ -14883,7 +15109,15 @@ Manually assigning 'GO111MODULE' is not recommended.
       },
       workPath
     });
-    const outDir = await (0, import_build_utils4.getWriteableDirectory)();
+    const goModJson = goModPath ? await go.modEditJson(goModPath) : null;
+    await generateProjectManifest({
+      workPath,
+      goModJson,
+      resolvedGoVersion: go.resolvedVersion,
+      framework: config.framework ?? void 0,
+      serviceType: service ? (0, import_build_utils5.getReportedServiceType)(service) : void 0
+    });
+    const outDir = await (0, import_build_utils5.getWriteableDirectory)();
     const buildOptions = {
       downloadPath,
       entrypoint,
@@ -14902,20 +15136,32 @@ Manually assigning 'GO111MODULE' is not recommended.
     } else {
       await buildHandlerWithGoMod(buildOptions);
     }
-    const runtime = await (0, import_build_utils4.getProvidedRuntime)();
-    const lambda = new import_build_utils4.Lambda({
-      files: { ...await (0, import_build_utils4.glob)("**", outDir), ...includedFiles },
+    const runtime = await (0, import_build_utils5.getProvidedRuntime)();
+    const lambda = new import_build_utils5.Lambda({
+      files: { ...await (0, import_build_utils5.glob)("**", outDir), ...includedFiles },
       handler: HANDLER_FILENAME,
       runtime,
       runtimeLanguage: "go",
       supportsWrapper: true,
       environment: {}
     });
+    const preDeployCommand = config?.preDeployCommand;
+    if (registerPreDeploy && typeof preDeployCommand === "string") {
+      const capturedEnv = { ...env };
+      const capturedCwd = workPath;
+      registerPreDeploy(async () => {
+        (0, import_build_utils5.debug)(`Running pre-deploy command: \`${preDeployCommand}\``);
+        await (0, import_build_utils5.execCommand)(preDeployCommand, {
+          env: capturedEnv,
+          cwd: capturedCwd
+        });
+      });
+    }
     return {
       output: lambda
     };
   } catch (error) {
-    (0, import_build_utils4.debug)(`Go Builder Error: ${error}`);
+    (0, import_build_utils5.debug)(`Go Builder Error: ${error}`);
     throw error;
   } finally {
     try {
@@ -14924,7 +15170,7 @@ Manually assigning 'GO111MODULE' is not recommended.
       if (error instanceof Error) {
         console.error(`Build cleanup failed: ${error.message}`);
       }
-      (0, import_build_utils4.debug)("Cleanup Error: " + error);
+      (0, import_build_utils5.debug)("Cleanup Error: " + error);
     }
   }
 }
@@ -14941,7 +15187,7 @@ async function buildHandlerWithGoMod({
   packageName,
   undo
 }) {
-  (0, import_build_utils4.debug)(
+  (0, import_build_utils5.debug)(
     `Building Go handler as package "${packageName}" (with${goModPath ? "" : "out"} go.mod)`
   );
   let goModDirname;
@@ -14970,7 +15216,7 @@ async function buildHandlerWithGoMod({
   );
   const isVendored = await (0, import_fs_extra4.pathExists)(vendorModulesPath);
   if (isVendored) {
-    (0, import_build_utils4.debug)("Detected vendor directory in project");
+    (0, import_build_utils5.debug)("Detected vendor directory in project");
     const vendorModulesBackup = vendorModulesPath + ".bak";
     await (0, import_fs_extra4.copy)(vendorModulesPath, vendorModulesBackup);
     undo.fileActions.push({
@@ -14987,13 +15233,13 @@ async function buildHandlerWithGoMod({
   }
   let mainGoFile;
   if (goModPath && isGoModInRootDir) {
-    (0, import_build_utils4.debug)(`[mod-root] Write main file to ${downloadPath}`);
+    (0, import_build_utils5.debug)(`[mod-root] Write main file to ${downloadPath}`);
     mainGoFile = (0, import_path7.join)(downloadPath, MAIN_GO_FILENAME);
   } else if (goModDirname && !isGoModInRootDir) {
-    (0, import_build_utils4.debug)(`[mod-other] Write main file to ${goModDirname}`);
+    (0, import_build_utils5.debug)(`[mod-other] Write main file to ${goModDirname}`);
     mainGoFile = (0, import_path7.join)(goModDirname, MAIN_GO_FILENAME);
   } else {
-    (0, import_build_utils4.debug)(`[entrypoint] Write main file to ${entrypointDirname}`);
+    (0, import_build_utils5.debug)(`[entrypoint] Write main file to ${entrypointDirname}`);
     mainGoFile = (0, import_path7.join)(entrypointDirname, MAIN_GO_FILENAME);
   }
   await Promise.all([
@@ -15019,7 +15265,7 @@ async function buildHandlerWithGoMod({
       );
     }
     if (!goModPath || (0, import_path7.dirname)(entrypointAbsolute) === (0, import_path7.dirname)(goModPath)) {
-      (0, import_build_utils4.debug)(
+      (0, import_build_utils5.debug)(
         `moving entrypoint "${entrypointAbsolute}" to "${finalDestination}"`
       );
       await (0, import_fs_extra4.move)(entrypointAbsolute, finalDestination);
@@ -15041,7 +15287,7 @@ async function buildHandlerWithGoMod({
   } else {
     baseGoModPath = entrypointDirname;
   }
-  (0, import_build_utils4.debug)("Tidy `go.mod` file...");
+  (0, import_build_utils5.debug)("Tidy `go.mod` file...");
   try {
     await go.mod({ tolerateErrors: isVendored });
   } catch (err) {
@@ -15049,7 +15295,7 @@ async function buildHandlerWithGoMod({
     throw err;
   }
   if (isVendored) {
-    (0, import_build_utils4.debug)("Regenerating vendor directory after go.mod rewrite...");
+    (0, import_build_utils5.debug)("Regenerating vendor directory after go.mod rewrite...");
     try {
       await go.vendor();
     } catch (err) {
@@ -15057,7 +15303,7 @@ async function buildHandlerWithGoMod({
       throw err;
     }
   }
-  (0, import_build_utils4.debug)("Running `go build`...");
+  (0, import_build_utils5.debug)("Running `go build`...");
   const destPath = (0, import_path7.join)(outDir, HANDLER_FILENAME);
   try {
     const src = [(0, import_path7.join)(baseGoModPath, MAIN_GO_FILENAME)];
@@ -15075,7 +15321,7 @@ async function buildHandlerAsPackageMain({
   outDir,
   undo
 }) {
-  (0, import_build_utils4.debug)('Building Go handler as package "main" (legacy)');
+  (0, import_build_utils5.debug)('Building Go handler as package "main" (legacy)');
   await writeEntrypoint(
     (0, import_path7.join)(entrypointDirname, MAIN_GO_FILENAME),
     "",
@@ -15086,14 +15332,14 @@ async function buildHandlerAsPackageMain({
     // delete
     from: (0, import_path7.join)(entrypointDirname, MAIN_GO_FILENAME)
   });
-  (0, import_build_utils4.debug)("Running `go get`...");
+  (0, import_build_utils5.debug)("Running `go get`...");
   try {
     await go.get();
   } catch (err) {
     console.error("Failed to `go get`");
     throw err;
   }
-  (0, import_build_utils4.debug)("Running `go build`...");
+  (0, import_build_utils5.debug)("Running `go build`...");
   const destPath = (0, import_path7.join)(outDir, HANDLER_FILENAME);
   try {
     const src = [
@@ -15123,10 +15369,10 @@ function getNewHandlerFunctionName(originalFunctionName, entrypoint) {
       "Handler function renaming failed because entrypoint was empty."
     );
   }
-  (0, import_build_utils4.debug)(`Found exported function "${originalFunctionName}" in "${entrypoint}"`);
+  (0, import_build_utils5.debug)(`Found exported function "${originalFunctionName}" in "${entrypoint}"`);
   const pathSlug = entrypoint.replace(/(\s|\\|\/|\]|\[|-|\.)/g, "_");
   const newHandlerName = `${originalFunctionName}_${pathSlug}`;
-  (0, import_build_utils4.debug)(
+  (0, import_build_utils5.debug)(
     `Renaming handler function temporarily from "${originalFunctionName}" to "${newHandlerName}"`
   );
   return newHandlerName;
@@ -15164,7 +15410,7 @@ async function findGoModPath2(entrypointDir, workPath) {
     const goMod = (0, import_path7.join)(dir, "go.mod");
     if (await (0, import_fs_extra4.pathExists)(goMod)) {
       goModPath = goMod;
-      (0, import_build_utils4.debug)(`Found ${goModPath}"`);
+      (0, import_build_utils5.debug)(`Found ${goModPath}"`);
       break;
     }
     dir = (0, import_path7.dirname)(dir);
@@ -15244,7 +15490,7 @@ async function writeGoMod({
     }
   }
   const destGoModPath = (0, import_path7.join)(destDir, "go.mod");
-  (0, import_build_utils4.debug)(`Writing ${destGoModPath}`);
+  (0, import_build_utils5.debug)(`Writing ${destGoModPath}`);
   await (0, import_fs_extra4.writeFile)(destGoModPath, contents, "utf-8");
 }
 async function findGoWorkFile(goWorkDir, workPath) {
@@ -15361,7 +15607,7 @@ async function startDevServer(opts) {
     TMP,
     `vercel-dev-port-${Math.random().toString(32).substring(2)}`
   );
-  const env = (0, import_build_utils4.cloneEnv)(process.env, meta.env, {
+  const env = (0, import_build_utils5.cloneEnv)(process.env, meta.env, {
     VERCEL_DEV_PORT_FILE: portFile
   });
   const executable = `./vercel-dev-server-go${process.platform === "win32" ? ".exe" : ""}`;
@@ -15374,7 +15620,7 @@ async function startDevServer(opts) {
     workPath
   });
   await go.build("./...", executable);
-  (0, import_build_utils4.debug)(`SPAWNING ${executable} CWD=${tmp}`);
+  (0, import_build_utils5.debug)(`SPAWNING ${executable} CWD=${tmp}`);
   const child = (0, import_child_process2.spawn)(executable, [], {
     cwd: tmp,
     env,
@@ -15462,11 +15708,11 @@ async function prepareCache({
   const stat = await (0, import_fs_extra4.lstat)(goCacheDir);
   if (stat.isSymbolicLink()) {
     const goGlobalCacheDir = await (0, import_fs_extra4.readlink)(goCacheDir);
-    (0, import_build_utils4.debug)(`Preparing cache by moving ${goGlobalCacheDir} -> ${goCacheDir}`);
+    (0, import_build_utils5.debug)(`Preparing cache by moving ${goGlobalCacheDir} -> ${goCacheDir}`);
     await (0, import_fs_extra4.unlink)(goCacheDir);
     await (0, import_fs_extra4.move)(goGlobalCacheDir, goCacheDir);
   }
-  const cache = await (0, import_build_utils4.glob)(`${localCacheDir}/**`, workPath);
+  const cache = await (0, import_build_utils5.glob)(`${localCacheDir}/**`, workPath);
   return cache;
 }
 // Annotate the CommonJS export names for ESM import in node:
@@ -15474,6 +15720,7 @@ async function prepareCache({
   build,
   detectEntrypoint,
   detectGoEntrypoint,
+  diagnostics,
   getNewHandlerFunctionName,
   prepareCache,
   shouldServe,