npm - @vercel/go - Versions diffs - 3.7.1 → 3.9.0 - Mend

@vercel/go 3.7.1 → 3.9.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/bin/proxy-linux-amd64 +0 -0
package/bin/proxy-linux-arm64 +0 -0
package/dist/index.js +768 -422
package/package.json +5 -3
package/bootstrap/go.mod +0 -3
package/bootstrap/vc-init.go +0 -274
/package/bootstrap/{vc-utils.go → utils.go} +0 -0

package/dist/index.js CHANGED Viewed

@@ -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());
@@ -1917,28 +1917,28 @@ var require_end_of_stream = __commonJS({
   }
 });
-// ../../node_modules/.pnpm/pump@3.0.2/node_modules/pump/index.js
+// ../../node_modules/.pnpm/pump@3.0.4/node_modules/pump/index.js
 var require_pump = __commonJS({
-  "../../node_modules/.pnpm/pump@3.0.2/node_modules/pump/index.js"(exports, module2) {
+  "../../node_modules/.pnpm/pump@3.0.4/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() {
     };
-    var ancient = /^v?\.0/.test(process.version);
+    var ancient = typeof process === "undefined" ? false : /^v?\.0/.test(process.version);
     var isFn = function(fn2) {
       return typeof fn2 === "function";
     };
     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();
         }
@@ -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,41 +3516,41 @@ 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;
-      function readFile4(path, options, cb) {
+      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 = readFile3;
+      function readFile3(path, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
         return go$readFile(path, options, cb);
@@ -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,7 +4370,7 @@ 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;
@@ -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 });
@@ -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),
@@ -5274,7 +5274,7 @@ var require_jsonfile = __commonJS({
     } catch (_2) {
       _fs = require("fs");
     }
-    function readFile4(file, options, callback) {
+    function readFile3(file, options, callback) {
       if (callback == null) {
         callback = options;
         options = {};
@@ -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))
@@ -5373,7 +5373,7 @@ var require_jsonfile = __commonJS({
       return content;
     }
     var jsonfile = {
-      readFile: readFile4,
+      readFile: readFile3,
       readFileSync,
       writeFile: writeFile2,
       writeFileSync
@@ -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,7 +5571,7 @@ 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 remove3 = require_remove().remove;
@@ -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")
@@ -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;
         }
       });
     }
@@ -7498,9 +7498,9 @@ var require_public_api = __commonJS({
   }
 });
-// ../../node_modules/.pnpm/node-fetch@2.6.7/node_modules/node-fetch/lib/index.js
+// ../../node_modules/.pnpm/node-fetch@2.6.9/node_modules/node-fetch/lib/index.js
 var require_lib4 = __commonJS({
-  "../../node_modules/.pnpm/node-fetch@2.6.7/node_modules/node-fetch/lib/index.js"(exports, module2) {
+  "../../node_modules/.pnpm/node-fetch@2.6.9/node_modules/node-fetch/lib/index.js"(exports, module2) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     function _interopDefault(ex) {
@@ -8495,6 +8495,11 @@ var require_lib4 = __commonJS({
       const dest = new URL$1(destination).hostname;
       return orig === dest || orig[orig.length - dest.length - 1] === "." && orig.endsWith(dest);
     };
+    var isSameProtocol = function isSameProtocol2(destination, original) {
+      const orig = new URL$1(original).protocol;
+      const dest = new URL$1(destination).protocol;
+      return orig === dest;
+    };
     function fetch(url, opts) {
       if (!fetch.Promise) {
         throw new Error("native promise missing, set fetch.Promise to your favorite alternative");
@@ -8510,7 +8515,7 @@ var require_lib4 = __commonJS({
           let error = new AbortError("The user aborted a request.");
           reject(error);
           if (request.body && request.body instanceof Stream.Readable) {
-            request.body.destroy(error);
+            destroyStream(request.body, error);
           }
           if (!response || !response.body)
             return;
@@ -8545,8 +8550,31 @@ var require_lib4 = __commonJS({
         }
         req.on("error", function(err) {
           reject(new FetchError(`request to ${request.url} failed, reason: ${err.message}`, "system", err));
+          if (response && response.body) {
+            destroyStream(response.body, err);
+          }
           finalize();
         });
+        fixResponseChunkedTransferBadEnding(req, function(err) {
+          if (signal && signal.aborted) {
+            return;
+          }
+          if (response && response.body) {
+            destroyStream(response.body, err);
+          }
+        });
+        if (parseInt(process.version.substring(1)) < 14) {
+          req.on("socket", function(s3) {
+            s3.addListener("close", function(hadError) {
+              const hasDataListener = s3.listenerCount("data") > 0;
+              if (response && hasDataListener && !hadError && !(signal && signal.aborted)) {
+                const err = new Error("Premature close");
+                err.code = "ERR_STREAM_PREMATURE_CLOSE";
+                response.body.emit("error", err);
+              }
+            });
+          });
+        }
         req.on("response", function(res) {
           clearTimeout(reqTimeout);
           const headers = createHeadersLenient(res.headers);
@@ -8597,7 +8625,7 @@ var require_lib4 = __commonJS({
                   timeout: request.timeout,
                   size: request.size
                 };
-                if (!isDomainOrSubdomain(request.url, locationURL)) {
+                if (!isDomainOrSubdomain(request.url, locationURL) || !isSameProtocol(request.url, locationURL)) {
                   for (const name of ["authorization", "www-authenticate", "cookie", "cookie2"]) {
                     requestOpts.headers.delete(name);
                   }
@@ -8658,6 +8686,12 @@ var require_lib4 = __commonJS({
               response = new Response(body, response_options);
               resolve(response);
             });
+            raw.on("end", function() {
+              if (!response) {
+                response = new Response(body, response_options);
+                resolve(response);
+              }
+            });
             return;
           }
           if (codings == "br" && typeof zlib.createBrotliDecompress === "function") {
@@ -8672,6 +8706,33 @@ var require_lib4 = __commonJS({
         writeToStream(req, request);
       });
     }
+    function fixResponseChunkedTransferBadEnding(request, errorCallback) {
+      let socket;
+      request.on("socket", function(s3) {
+        socket = s3;
+      });
+      request.on("response", function(response) {
+        const headers = response.headers;
+        if (headers["transfer-encoding"] === "chunked" && !headers["content-length"]) {
+          response.once("close", function(hadError) {
+            const hasDataListener = socket.listenerCount("data") > 0;
+            if (hasDataListener && !hadError) {
+              const err = new Error("Premature close");
+              err.code = "ERR_STREAM_PREMATURE_CLOSE";
+              errorCallback(err);
+            }
+          });
+        }
+      });
+    }
+    function destroyStream(stream, err) {
+      if (stream.destroy) {
+        stream.destroy(err);
+      } else {
+        stream.emit("error", err);
+        stream.end();
+      }
+    }
     fetch.isRedirect = function(code) {
       return code === 301 || code === 302 || code === 303 || code === 307 || code === 308;
     };
@@ -8786,7 +8847,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 +8872,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 +8881,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 +8904,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 +8943,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 +8993,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 +9422,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 +9459,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 +9488,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 });
@@ -10877,15 +10938,94 @@ var require_xdg_app_paths = __commonJS({
   }
 });
+// ../../internals/ipc-proxy/dist/index.js
+var require_dist2 = __commonJS({
+  "../../internals/ipc-proxy/dist/index.js"(exports, module2) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to2, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to2, key) && key !== except)
+            __defProp2(to2, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to2;
+    };
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var src_exports2 = {};
+    __export2(src_exports2, {
+      createStandaloneLambda: () => createStandaloneLambda2,
+      getBootstrapDir: () => getBootstrapDir,
+      getProxyBinaryPath: () => getProxyBinaryPath
+    });
+    module2.exports = __toCommonJS2(src_exports2);
+    var import_node_path10 = require("path");
+    var import_node_fs7 = require("fs");
+    var import_promises2 = require("fs/promises");
+    var import_build_utils6 = require("@vercel/build-utils");
+    function proxyBinaryName(architecture) {
+      return architecture === "arm64" ? "proxy-linux-arm64" : "proxy-linux-amd64";
+    }
+    function getProxyBinaryPath(architecture) {
+      const binPath = (0, import_node_path10.join)(__dirname, "..", "bin", proxyBinaryName(architecture));
+      if (!(0, import_node_fs7.existsSync)(binPath)) {
+        throw new Error(
+          `IPC proxy binary not found for architecture "${architecture}" at ${binPath}. Ensure @vercel-internals/ipc-proxy has been built and its prebuilt binaries copied alongside the consumer's dist output.`
+        );
+      }
+      return binPath;
+    }
+    function getBootstrapDir() {
+      return (0, import_node_path10.join)(__dirname, "..", "bootstrap");
+    }
+    async function createStandaloneLambda2(options) {
+      const {
+        userServerPath,
+        architecture,
+        lambdaOptions,
+        includedFiles,
+        runtimeLanguage,
+        supportsResponseStreaming = true
+      } = options;
+      const proxyPath = getProxyBinaryPath(architecture);
+      const [proxyData, userServerData] = await Promise.all([
+        (0, import_promises2.readFile)(proxyPath),
+        (0, import_promises2.readFile)(userServerPath)
+      ]);
+      return new import_build_utils6.Lambda({
+        ...lambdaOptions,
+        files: {
+          ...includedFiles,
+          executable: new import_build_utils6.FileBlob({ mode: 493, data: proxyData }),
+          "user-server": new import_build_utils6.FileBlob({ mode: 493, data: userServerData })
+        },
+        handler: "executable",
+        runtime: "executable",
+        supportsResponseStreaming,
+        architecture,
+        runtimeLanguage
+      });
+    }
+  }
+});
 // src/index.ts
 var src_exports = {};
 __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 +11037,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 +14260,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 +14395,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 +14435,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 +14466,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 +14570,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 +14583,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 +14662,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 +14806,93 @@ 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");
+var import_ipc_proxy = __toESM(require_dist2());
+// 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 +14902,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 +14917,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,94 +14940,84 @@ 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;
-  }
-  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}`);
-  try {
-    const bootstrapBuildDir = await (0, import_build_utils3.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"));
-    await (0, import_fs_extra3.copy)(bootstrapGoModSrc, (0, import_path6.join)(bootstrapBuildDir, "go.mod"));
-    const bootstrapEnv = {
-      PATH: process.env.PATH || "",
-      HOME: process.env.HOME || "",
-      TMPDIR: process.env.TMPDIR || "",
-      GOARCH: architecture === "arm64" ? "arm64" : "amd64",
-      GOOS: "linux",
-      CGO_ENABLED: "0"
-    };
-    const bootstrapGo = await createGo({
-      modulePath: bootstrapBuildDir,
-      opts: { cwd: bootstrapBuildDir, env: bootstrapEnv },
-      workPath: bootstrapBuildDir
+    (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 bootstrapGo.build(".", bootstrapPath);
-  } catch (err) {
-    console.error("Failed to build bootstrap wrapper");
-    throw err;
+    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 includedFiles = {};
   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;
       }
     }
   }
-  const [userServerData, bootstrapData] = await Promise.all([
-    (0, import_fs_extra3.readFile)(userServerPath),
-    (0, import_fs_extra3.readFile)(bootstrapPath)
-  ]);
-  const lambda = new import_build_utils3.Lambda({
-    ...lambdaOptions,
-    files: {
-      ...includedFiles,
-      // Bootstrap is the main entrypoint (handles IPC protocol)
-      executable: new import_build_utils3.FileBlob({ mode: 493, data: bootstrapData }),
-      // User's server is spawned by bootstrap
-      "user-server": new import_build_utils3.FileBlob({ mode: 493, data: userServerData })
-    },
-    handler: "executable",
-    runtime: "executable",
-    supportsResponseStreaming: true,
+  const lambda = await (0, import_ipc_proxy.createStandaloneLambda)({
+    userServerPath,
     architecture,
-    runtimeLanguage: "go"
+    lambdaOptions,
+    includedFiles,
+    runtimeLanguage: "go",
+    supportsResponseStreaming: true
+  });
+  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)(
+  const devUtils = (0, import_path6.join)(__dirname, "../bootstrap/utils.go");
+  (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 +15087,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 +15140,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 +15193,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 +15208,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 +15235,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 +15269,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 +15286,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 +15315,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 +15332,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 +15364,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 +15386,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 +15394,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 +15402,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 +15420,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 +15431,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 +15468,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 +15509,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 +15589,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 +15706,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 +15719,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 +15807,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 +15819,7 @@ async function prepareCache({
   build,
   detectEntrypoint,
   detectGoEntrypoint,
+  diagnostics,
   getNewHandlerFunctionName,
   prepareCache,
   shouldServe,