@vercel/ruby 2.4.0 → 2.5.0

package/dist/index.js

@@ -48,7 +48,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 fs = require("fs");
     function checkPathExt(path, options) {
       var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
       if (!pathext) {
@@ -73,12 +73,12 @@ var require_windows = __commonJS({
       return checkPathExt(path, options);
     }
     function isexe(path, options, cb) {
-      fs2.stat(path, function(er, stat) {
+      fs.stat(path, function(er, stat) {
         cb(er, er ? false : checkStat(stat, path, options));
       });
     }
     function sync(path, options) {
-      return checkStat(fs2.statSync(path), path, options);
+      return checkStat(fs.statSync(path), path, options);
     }
   }
 });
@@ -88,14 +88,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 fs = require("fs");
     function isexe(path, options, cb) {
-      fs2.stat(path, function(er, stat) {
+      fs.stat(path, function(er, stat) {
         cb(er, er ? false : checkStat(stat, options));
       });
     }
     function sync(path, options) {
-      return checkStat(fs2.statSync(path), options);
+      return checkStat(fs.statSync(path), options);
     }
     function checkStat(stat, options) {
       return stat.isFile() && checkMode(stat, options);
@@ -119,7 +119,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 fs = require("fs");
     var core;
     if (process.platform === "win32" || global.TESTING_WINDOWS) {
       core = require_windows();
@@ -395,7 +395,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 fs = require("fs");
     var shebangCommand = require_shebang_command();
     function readShebang(command) {
       const size = 150;
@@ -408,9 +408,9 @@ var require_readShebang = __commonJS({
       }
       let fd;
       try {
-        fd = fs2.openSync(command, "r");
-        fs2.readSync(fd, buffer, 0, size, 0);
-        fs2.closeSync(fd);
+        fd = fs.openSync(command, "r");
+        fs.readSync(fd, buffer, 0, size, 0);
+        fs.closeSync(fd);
       } catch (e) {
       }
       return shebangCommand(buffer.toString());
@@ -2371,28 +2371,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 once = require_once();
     var eos = require_end_of_stream();
-    var fs2;
+    var fs;
     try {
-      fs2 = require("fs");
+      fs = 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(fn) {
       return typeof fn === "function";
     };
     var isFS = function(stream) {
       if (!ancient)
         return false;
-      if (!fs2)
+      if (!fs)
         return false;
-      return (stream instanceof (fs2.ReadStream || noop) || stream instanceof (fs2.WriteStream || noop)) && isFn(stream.close);
+      return (stream instanceof (fs.ReadStream || noop) || stream instanceof (fs.WriteStream || noop)) && isFn(stream.close);
     };
     var isRequest = function(stream) {
       return stream.setHeader && isFn(stream.abort);
@@ -3028,56 +3028,56 @@ var require_polyfills = __commonJS({
     }
     var chdir;
     module2.exports = patch;
-    function patch(fs2) {
+    function patch(fs) {
       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(fs);
+      }
+      if (!fs.lutimes) {
+        patchLutimes(fs);
+      }
+      fs.chown = chownFix(fs.chown);
+      fs.fchown = chownFix(fs.fchown);
+      fs.lchown = chownFix(fs.lchown);
+      fs.chmod = chmodFix(fs.chmod);
+      fs.fchmod = chmodFix(fs.fchmod);
+      fs.lchmod = chmodFix(fs.lchmod);
+      fs.chownSync = chownFixSync(fs.chownSync);
+      fs.fchownSync = chownFixSync(fs.fchownSync);
+      fs.lchownSync = chownFixSync(fs.lchownSync);
+      fs.chmodSync = chmodFixSync(fs.chmodSync);
+      fs.fchmodSync = chmodFixSync(fs.fchmodSync);
+      fs.lchmodSync = chmodFixSync(fs.lchmodSync);
+      fs.stat = statFix(fs.stat);
+      fs.fstat = statFix(fs.fstat);
+      fs.lstat = statFix(fs.lstat);
+      fs.statSync = statFixSync(fs.statSync);
+      fs.fstatSync = statFixSync(fs.fstatSync);
+      fs.lstatSync = statFixSync(fs.lstatSync);
+      if (fs.chmod && !fs.lchmod) {
+        fs.lchmod = function(path, mode, cb) {
           if (cb)
             process.nextTick(cb);
         };
-        fs2.lchmodSync = function() {
+        fs.lchmodSync = function() {
         };
       }
-      if (fs2.chown && !fs2.lchown) {
-        fs2.lchown = function(path, uid, gid, cb) {
+      if (fs.chown && !fs.lchown) {
+        fs.lchown = function(path, uid, gid, cb) {
           if (cb)
             process.nextTick(cb);
         };
-        fs2.lchownSync = function() {
+        fs.lchownSync = function() {
         };
       }
       if (platform === "win32") {
-        fs2.rename = typeof fs2.rename !== "function" ? fs2.rename : function(fs$rename) {
+        fs.rename = typeof fs.rename !== "function" ? fs.rename : function(fs$rename) {
           function rename(from, to, cb) {
             var start = Date.now();
             var backoff = 0;
             fs$rename(from, to, function CB(er) {
               if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 6e4) {
                 setTimeout(function() {
-                  fs2.stat(to, function(stater, st) {
+                  fs.stat(to, function(stater, st) {
                     if (stater && stater.code === "ENOENT")
                       fs$rename(from, to, CB);
                     else
@@ -3095,9 +3095,9 @@ var require_polyfills = __commonJS({
           if (Object.setPrototypeOf)
             Object.setPrototypeOf(rename, fs$rename);
           return rename;
-        }(fs2.rename);
+        }(fs.rename);
       }
-      fs2.read = typeof fs2.read !== "function" ? fs2.read : function(fs$read) {
+      fs.read = typeof fs.read !== "function" ? fs.read : function(fs$read) {
         function read(fd, buffer, offset, length, position, callback_) {
           var callback;
           if (callback_ && typeof callback_ === "function") {
@@ -3105,23 +3105,23 @@ var require_polyfills = __commonJS({
             callback = function(er, _, __) {
               if (er && er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
-                return fs$read.call(fs2, fd, buffer, offset, length, position, callback);
+                return fs$read.call(fs, 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(fs, 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) {
+      }(fs.read);
+      fs.readSync = typeof fs.readSync !== "function" ? fs.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(fs, fd, buffer, offset, length, position);
             } catch (er) {
               if (er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
@@ -3131,10 +3131,10 @@ var require_polyfills = __commonJS({
             }
           }
         };
-      }(fs2.readSync);
-      function patchLchmod(fs3) {
-        fs3.lchmod = function(path, mode, callback) {
-          fs3.open(
+      }(fs.readSync);
+      function patchLchmod(fs2) {
+        fs2.lchmod = function(path, mode, callback) {
+          fs2.open(
             path,
             constants.O_WRONLY | constants.O_SYMLINK,
             mode,
@@ -3144,8 +3144,8 @@ var require_polyfills = __commonJS({
                   callback(err);
                 return;
               }
-              fs3.fchmod(fd, mode, function(err2) {
-                fs3.close(fd, function(err22) {
+              fs2.fchmod(fd, mode, function(err2) {
+                fs2.close(fd, function(err22) {
                   if (callback)
                     callback(err2 || err22);
                 });
@@ -3153,68 +3153,68 @@ var require_polyfills = __commonJS({
             }
           );
         };
-        fs3.lchmodSync = function(path, mode) {
-          var fd = fs3.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode);
+        fs2.lchmodSync = function(path, mode) {
+          var fd = fs2.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
-            ret = fs3.fchmodSync(fd, mode);
+            ret = fs2.fchmodSync(fd, mode);
             threw = false;
           } finally {
             if (threw) {
               try {
-                fs3.closeSync(fd);
+                fs2.closeSync(fd);
               } catch (er) {
               }
             } else {
-              fs3.closeSync(fd);
+              fs2.closeSync(fd);
             }
           }
           return ret;
         };
       }
-      function patchLutimes(fs3) {
-        if (constants.hasOwnProperty("O_SYMLINK") && fs3.futimes) {
-          fs3.lutimes = function(path, at, mt, cb) {
-            fs3.open(path, constants.O_SYMLINK, function(er, fd) {
+      function patchLutimes(fs2) {
+        if (constants.hasOwnProperty("O_SYMLINK") && fs2.futimes) {
+          fs2.lutimes = function(path, at, mt, cb) {
+            fs2.open(path, constants.O_SYMLINK, function(er, fd) {
               if (er) {
                 if (cb)
                   cb(er);
                 return;
               }
-              fs3.futimes(fd, at, mt, function(er2) {
-                fs3.close(fd, function(er22) {
+              fs2.futimes(fd, at, mt, function(er2) {
+                fs2.close(fd, function(er22) {
                   if (cb)
                     cb(er2 || er22);
                 });
               });
             });
           };
-          fs3.lutimesSync = function(path, at, mt) {
-            var fd = fs3.openSync(path, constants.O_SYMLINK);
+          fs2.lutimesSync = function(path, at, mt) {
+            var fd = fs2.openSync(path, constants.O_SYMLINK);
             var ret;
             var threw = true;
             try {
-              ret = fs3.futimesSync(fd, at, mt);
+              ret = fs2.futimesSync(fd, at, mt);
               threw = false;
             } finally {
               if (threw) {
                 try {
-                  fs3.closeSync(fd);
+                  fs2.closeSync(fd);
                 } catch (er) {
                 }
               } else {
-                fs3.closeSync(fd);
+                fs2.closeSync(fd);
               }
             }
             return ret;
           };
-        } else if (fs3.futimes) {
-          fs3.lutimes = function(_a, _b, _c, cb) {
+        } else if (fs2.futimes) {
+          fs2.lutimes = function(_a, _b, _c, cb) {
             if (cb)
               process.nextTick(cb);
           };
-          fs3.lutimesSync = function() {
+          fs2.lutimesSync = function() {
           };
         }
       }
@@ -3222,7 +3222,7 @@ var require_polyfills = __commonJS({
         if (!orig)
           return orig;
         return function(target, mode, cb) {
-          return orig.call(fs2, target, mode, function(er) {
+          return orig.call(fs, target, mode, function(er) {
             if (chownErOk(er))
               er = null;
             if (cb)
@@ -3235,7 +3235,7 @@ var require_polyfills = __commonJS({
           return orig;
         return function(target, mode) {
           try {
-            return orig.call(fs2, target, mode);
+            return orig.call(fs, target, mode);
           } catch (er) {
             if (!chownErOk(er))
               throw er;
@@ -3246,7 +3246,7 @@ var require_polyfills = __commonJS({
         if (!orig)
           return orig;
         return function(target, uid, gid, cb) {
-          return orig.call(fs2, target, uid, gid, function(er) {
+          return orig.call(fs, target, uid, gid, function(er) {
             if (chownErOk(er))
               er = null;
             if (cb)
@@ -3259,7 +3259,7 @@ var require_polyfills = __commonJS({
           return orig;
         return function(target, uid, gid) {
           try {
-            return orig.call(fs2, target, uid, gid);
+            return orig.call(fs, target, uid, gid);
           } catch (er) {
             if (!chownErOk(er))
               throw er;
@@ -3284,14 +3284,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(fs, target, options, callback) : orig.call(fs, 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(fs, target, options) : orig.call(fs, target);
           if (stats) {
             if (stats.uid < 0)
               stats.uid += 4294967296;
@@ -3322,7 +3322,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(fs) {
       return {
         ReadStream,
         WriteStream
@@ -3367,7 +3367,7 @@ var require_legacy_streams = __commonJS({
           });
           return;
         }
-        fs2.open(this.path, this.flags, this.mode, function(err, fd) {
+        fs.open(this.path, this.flags, this.mode, function(err, fd) {
           if (err) {
             self.emit("error", err);
             self.readable = false;
@@ -3407,7 +3407,7 @@ var require_legacy_streams = __commonJS({
         this.busy = false;
         this._queue = [];
         if (this.fd === null) {
-          this._open = fs2.open;
+          this._open = fs.open;
           this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
           this.flush();
         }
@@ -3442,7 +3442,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 fs = require("fs");
     var polyfills = require_polyfills();
     var legacy = require_legacy_streams();
     var clone = require_clone();
@@ -3474,12 +3474,12 @@ var require_graceful_fs = __commonJS({
         m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
         console.error(m);
       };
-    if (!fs2[gracefulQueue]) {
+    if (!fs[gracefulQueue]) {
       queue = global[gracefulQueue] || [];
-      publishQueue(fs2, queue);
-      fs2.close = function(fs$close) {
+      publishQueue(fs, queue);
+      fs.close = function(fs$close) {
         function close(fd, cb) {
-          return fs$close.call(fs2, fd, function(err) {
+          return fs$close.call(fs, fd, function(err) {
             if (!err) {
               resetQueue();
             }
@@ -3491,40 +3491,40 @@ var require_graceful_fs = __commonJS({
           value: fs$close
         });
         return close;
-      }(fs2.close);
-      fs2.closeSync = function(fs$closeSync) {
+      }(fs.close);
+      fs.closeSync = function(fs$closeSync) {
         function closeSync(fd) {
-          fs$closeSync.apply(fs2, arguments);
+          fs$closeSync.apply(fs, arguments);
           resetQueue();
         }
         Object.defineProperty(closeSync, previousSymbol, {
           value: fs$closeSync
         });
         return closeSync;
-      }(fs2.closeSync);
+      }(fs.closeSync);
       if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
         process.on("exit", function() {
-          debug4(fs2[gracefulQueue]);
-          require("assert").equal(fs2[gracefulQueue].length, 0);
+          debug4(fs[gracefulQueue]);
+          require("assert").equal(fs[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 = createWriteStream;
-      var fs$readFile = fs3.readFile;
-      fs3.readFile = readFile2;
+      publishQueue(global, fs[gracefulQueue]);
+    }
+    module2.exports = patch(clone(fs));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs.__patched) {
+      module2.exports = patch(fs);
+      fs.__patched = true;
+    }
+    function patch(fs2) {
+      polyfills(fs2);
+      fs2.gracefulify = patch;
+      fs2.createReadStream = createReadStream;
+      fs2.createWriteStream = createWriteStream;
+      var fs$readFile = fs2.readFile;
+      fs2.readFile = readFile2;
       function readFile2(path, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
@@ -3540,8 +3540,8 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$writeFile = fs3.writeFile;
-      fs3.writeFile = writeFile2;
+      var fs$writeFile = fs2.writeFile;
+      fs2.writeFile = writeFile2;
       function writeFile2(path, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
@@ -3557,9 +3557,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$appendFile = fs3.appendFile;
+      var fs$appendFile = fs2.appendFile;
       if (fs$appendFile)
-        fs3.appendFile = appendFile;
+        fs2.appendFile = appendFile;
       function appendFile(path, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
@@ -3575,9 +3575,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$copyFile = fs3.copyFile;
+      var fs$copyFile = fs2.copyFile;
       if (fs$copyFile)
-        fs3.copyFile = copyFile;
+        fs2.copyFile = copyFile;
       function copyFile(src, dest, flags, cb) {
         if (typeof flags === "function") {
           cb = flags;
@@ -3595,8 +3595,8 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$readdir = fs3.readdir;
-      fs3.readdir = readdir;
+      var fs$readdir = fs2.readdir;
+      fs2.readdir = readdir;
       var noReaddirOptionVersions = /^v[0-5]\./;
       function readdir(path, options, cb) {
         if (typeof options === "function")
@@ -3637,21 +3637,21 @@ var require_graceful_fs = __commonJS({
         }
       }
       if (process.version.substr(0, 4) === "v0.8") {
-        var legStreams = legacy(fs3);
+        var legStreams = legacy(fs2);
         ReadStream = legStreams.ReadStream;
         WriteStream = legStreams.WriteStream;
       }
-      var fs$ReadStream = fs3.ReadStream;
+      var fs$ReadStream = fs2.ReadStream;
       if (fs$ReadStream) {
         ReadStream.prototype = Object.create(fs$ReadStream.prototype);
         ReadStream.prototype.open = ReadStream$open;
       }
-      var fs$WriteStream = fs3.WriteStream;
+      var fs$WriteStream = fs2.WriteStream;
       if (fs$WriteStream) {
         WriteStream.prototype = Object.create(fs$WriteStream.prototype);
         WriteStream.prototype.open = WriteStream$open;
       }
-      Object.defineProperty(fs3, "ReadStream", {
+      Object.defineProperty(fs2, "ReadStream", {
         get: function() {
           return ReadStream;
         },
@@ -3661,7 +3661,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      Object.defineProperty(fs3, "WriteStream", {
+      Object.defineProperty(fs2, "WriteStream", {
         get: function() {
           return WriteStream;
         },
@@ -3672,7 +3672,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileReadStream = ReadStream;
-      Object.defineProperty(fs3, "FileReadStream", {
+      Object.defineProperty(fs2, "FileReadStream", {
         get: function() {
           return FileReadStream;
         },
@@ -3683,7 +3683,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileWriteStream = WriteStream;
-      Object.defineProperty(fs3, "FileWriteStream", {
+      Object.defineProperty(fs2, "FileWriteStream", {
         get: function() {
           return FileWriteStream;
         },
@@ -3732,13 +3732,13 @@ var require_graceful_fs = __commonJS({
         });
       }
       function createReadStream(path, options) {
-        return new fs3.ReadStream(path, options);
+        return new fs2.ReadStream(path, options);
       }
       function createWriteStream(path, options) {
-        return new fs3.WriteStream(path, options);
+        return new fs2.WriteStream(path, options);
       }
-      var fs$open = fs3.open;
-      fs3.open = open;
+      var fs$open = fs2.open;
+      fs2.open = open;
       function open(path, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
@@ -3754,20 +3754,20 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      return fs3;
+      return fs2;
     }
     function enqueue(elem) {
       debug4("ENQUEUE", elem[0].name, elem[1]);
-      fs2[gracefulQueue].push(elem);
+      fs[gracefulQueue].push(elem);
       retry();
     }
     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 < fs[gracefulQueue].length; ++i) {
+        if (fs[gracefulQueue][i].length > 2) {
+          fs[gracefulQueue][i][3] = now;
+          fs[gracefulQueue][i][4] = now;
         }
       }
       retry();
@@ -3775,9 +3775,9 @@ var require_graceful_fs = __commonJS({
     function retry() {
       clearTimeout(retryTimer);
       retryTimer = void 0;
-      if (fs2[gracefulQueue].length === 0)
+      if (fs[gracefulQueue].length === 0)
         return;
-      var elem = fs2[gracefulQueue].shift();
+      var elem = fs[gracefulQueue].shift();
       var fn = elem[0];
       var args = elem[1];
       var err = elem[2];
@@ -3799,7 +3799,7 @@ var require_graceful_fs = __commonJS({
           debug4("RETRY", fn.name, args);
           fn.apply(null, args.concat([startTime]));
         } else {
-          fs2[gracefulQueue].push(elem);
+          fs[gracefulQueue].push(elem);
         }
       }
       if (retryTimer === void 0) {
@@ -3814,7 +3814,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 u = require_universalify().fromCallback;
-    var fs2 = require_graceful_fs();
+    var fs = require_graceful_fs();
     var api = [
       "access",
       "appendFile",
@@ -3849,31 +3849,31 @@ var require_fs = __commonJS({
       "utimes",
       "writeFile"
     ].filter((key) => {
-      return typeof fs2[key] === "function";
+      return typeof fs[key] === "function";
     });
-    Object.keys(fs2).forEach((key) => {
+    Object.keys(fs).forEach((key) => {
       if (key === "promises") {
         return;
       }
-      exports[key] = fs2[key];
+      exports[key] = fs[key];
     });
     api.forEach((method) => {
-      exports[method] = u(fs2[method]);
+      exports[method] = u(fs[method]);
     });
     exports.exists = function(filename, callback) {
       if (typeof callback === "function") {
-        return fs2.exists(filename, callback);
+        return fs.exists(filename, callback);
       }
       return new Promise((resolve) => {
-        return fs2.exists(filename, resolve);
+        return fs.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 fs.read(fd, buffer, offset, length, position, callback);
       }
       return new Promise((resolve, reject) => {
-        fs2.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
+        fs.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
           if (err)
             return reject(err);
           resolve({ bytesRead, buffer: buffer2 });
@@ -3882,10 +3882,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 fs.write(fd, buffer, ...args);
       }
       return new Promise((resolve, reject) => {
-        fs2.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
+        fs.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
           if (err)
             return reject(err);
           resolve({ bytesWritten, buffer: buffer2 });
@@ -3923,7 +3923,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 fs = require_graceful_fs();
     var path = require("path");
     var invalidWin32Path = require_win32().invalidWin32Path;
     var o777 = parseInt("0777", 8);
@@ -3940,7 +3940,7 @@ var require_mkdirs = __commonJS({
         return callback(errInval);
       }
       let mode = opts.mode;
-      const xfs = opts.fs || fs2;
+      const xfs = opts.fs || fs;
       if (mode === void 0) {
         mode = o777 & ~process.umask();
       }
@@ -3984,7 +3984,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 fs = require_graceful_fs();
     var path = require("path");
     var invalidWin32Path = require_win32().invalidWin32Path;
     var o777 = parseInt("0777", 8);
@@ -3993,7 +3993,7 @@ var require_mkdirs_sync = __commonJS({
         opts = { mode: opts };
       }
       let mode = opts.mode;
-      const xfs = opts.fs || fs2;
+      const xfs = opts.fs || fs;
       if (process.platform === "win32" && invalidWin32Path(p)) {
         const errInval = new Error(p + " contains invalid WIN32 path characters.");
         errInval.code = "EINVAL";
@@ -4054,36 +4054,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 fs = require_graceful_fs();
     var os = 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(os.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;
+      fs.writeFileSync(tmpfile, "https://github.com/jprichardson/node-fs-extra/pull/141");
+      const fd = fs.openSync(tmpfile, "r+");
+      fs.futimesSync(fd, d, d);
+      fs.closeSync(fd);
+      return fs.statSync(tmpfile).mtime > 1435410243e3;
     }
     function hasMillisRes(callback) {
       let tmpfile = path.join("millis-test" + Date.now().toString() + Math.random().toString().slice(2));
       tmpfile = path.join(os.tmpdir(), tmpfile);
       const d = /* @__PURE__ */ new Date(1435410243862);
-      fs2.writeFile(tmpfile, "https://github.com/jprichardson/node-fs-extra/pull/141", (err) => {
+      fs.writeFile(tmpfile, "https://github.com/jprichardson/node-fs-extra/pull/141", (err) => {
         if (err)
           return callback(err);
-        fs2.open(tmpfile, "r+", (err2, fd) => {
+        fs.open(tmpfile, "r+", (err2, fd) => {
           if (err2)
             return callback(err2);
-          fs2.futimes(fd, d, d, (err3) => {
+          fs.futimes(fd, d, d, (err3) => {
             if (err3)
               return callback(err3);
-            fs2.close(fd, (err4) => {
+            fs.close(fd, (err4) => {
               if (err4)
                 return callback(err4);
-              fs2.stat(tmpfile, (err5, stats) => {
+              fs.stat(tmpfile, (err5, stats) => {
                 if (err5)
                   return callback(err5);
                 callback(null, stats.mtime > 1435410243e3);
@@ -4103,11 +4103,11 @@ var require_utimes = __commonJS({
       }
     }
     function utimesMillis(path2, atime, mtime, callback) {
-      fs2.open(path2, "r+", (err, fd) => {
+      fs.open(path2, "r+", (err, fd) => {
         if (err)
           return callback(err);
-        fs2.futimes(fd, atime, mtime, (futimesErr) => {
-          fs2.close(fd, (closeErr) => {
+        fs.futimes(fd, atime, mtime, (futimesErr) => {
+          fs.close(fd, (closeErr) => {
             if (callback)
               callback(futimesErr || closeErr);
           });
@@ -4115,9 +4115,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 = fs.openSync(path2, "r+");
+      fs.futimesSync(fd, atime, mtime);
+      return fs.closeSync(fd);
     }
     module2.exports = {
       hasMillisRes,
@@ -4150,7 +4150,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 fs = require_graceful_fs();
     var path = require("path");
     var mkdirpSync = require_mkdirs2().mkdirsSync;
     var utimesSync = require_utimes().utimesMillisSync;
@@ -4171,7 +4171,7 @@ var require_copy_sync = __commonJS({
       if (opts.filter && !opts.filter(src, dest))
         return;
       const destParent = path.dirname(dest);
-      if (!fs2.existsSync(destParent))
+      if (!fs.existsSync(destParent))
         mkdirpSync(destParent);
       return startCopy(destStat, src, dest, opts);
     }
@@ -4181,7 +4181,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 ? fs.statSync : fs.lstatSync;
       const srcStat = statSync(src);
       if (srcStat.isDirectory())
         return onDir(srcStat, destStat, src, dest, opts);
@@ -4197,16 +4197,16 @@ var require_copy_sync = __commonJS({
     }
     function mayCopyFile(srcStat, src, dest, opts) {
       if (opts.overwrite) {
-        fs2.unlinkSync(dest);
+        fs.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 fs.copyFileSync === "function") {
+        fs.copyFileSync(src, dest);
+        fs.chmodSync(dest, srcStat.mode);
         if (opts.preserveTimestamps) {
           return utimesSync(dest, srcStat.atime, srcStat.mtime);
         }
@@ -4217,18 +4217,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 = fs.openSync(src, "r");
+      const fdw = fs.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 = fs.readSync(fdr, _buff, 0, BUF_LENGTH, pos);
+        fs.writeSync(fdw, _buff, 0, bytesRead);
         pos += bytesRead;
       }
       if (opts.preserveTimestamps)
-        fs2.futimesSync(fdw, srcStat.atime, srcStat.mtime);
-      fs2.closeSync(fdr);
-      fs2.closeSync(fdw);
+        fs.futimesSync(fdw, srcStat.atime, srcStat.mtime);
+      fs.closeSync(fdr);
+      fs.closeSync(fdw);
     }
     function onDir(srcStat, destStat, src, dest, opts) {
       if (destStat === notExist)
@@ -4239,12 +4239,12 @@ var require_copy_sync = __commonJS({
       return copyDir(src, dest, opts);
     }
     function mkDirAndCopy(srcStat, src, dest, opts) {
-      fs2.mkdirSync(dest);
+      fs.mkdirSync(dest);
       copyDir(src, dest, opts);
-      return fs2.chmodSync(dest, srcStat.mode);
+      return fs.chmodSync(dest, srcStat.mode);
     }
     function copyDir(src, dest, opts) {
-      fs2.readdirSync(src).forEach((item) => copyDirItem(item, src, dest, opts));
+      fs.readdirSync(src).forEach((item) => copyDirItem(item, src, dest, opts));
     }
     function copyDirItem(item, src, dest, opts) {
       const srcItem = path.join(src, item);
@@ -4253,19 +4253,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 = fs.readlinkSync(src);
       if (opts.dereference) {
         resolvedSrc = path.resolve(process.cwd(), resolvedSrc);
       }
       if (destStat === notExist) {
-        return fs2.symlinkSync(resolvedSrc, dest);
+        return fs.symlinkSync(resolvedSrc, dest);
       } else {
         let resolvedDest;
         try {
-          resolvedDest = fs2.readlinkSync(dest);
+          resolvedDest = fs.readlinkSync(dest);
         } catch (err) {
           if (err.code === "EINVAL" || err.code === "UNKNOWN")
-            return fs2.symlinkSync(resolvedSrc, dest);
+            return fs.symlinkSync(resolvedSrc, dest);
           throw err;
         }
         if (opts.dereference) {
@@ -4274,15 +4274,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 (fs.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);
+      fs.unlinkSync(dest);
+      return fs.symlinkSync(resolvedSrc, dest);
     }
     function isSrcSubdir(src, dest) {
       const srcArray = path.resolve(src).split(path.sep);
@@ -4290,10 +4290,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 = fs.statSync(src);
       let destStat;
       try {
-        destStat = fs2.statSync(dest);
+        destStat = fs.statSync(dest);
       } catch (err) {
         if (err.code === "ENOENT")
           return { srcStat, destStat: notExist };
@@ -4330,13 +4330,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 u = require_universalify().fromPromise;
-    var fs2 = require_fs();
+    var fs = require_fs();
     function pathExists2(path) {
-      return fs2.access(path).then(() => true).catch(() => false);
+      return fs.access(path).then(() => true).catch(() => false);
     }
     module2.exports = {
       pathExists: u(pathExists2),
-      pathExistsSync: fs2.existsSync
+      pathExistsSync: fs.existsSync
     };
   }
 });
@@ -4345,7 +4345,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 fs = require_graceful_fs();
     var path = require("path");
     var mkdirp = require_mkdirs2().mkdirs;
     var pathExists2 = require_path_exists().pathExists;
@@ -4406,7 +4406,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 ? fs.stat : fs.lstat;
       stat(src, (err, srcStat) => {
         if (err)
           return cb(err);
@@ -4425,7 +4425,7 @@ var require_copy = __commonJS({
     }
     function mayCopyFile(srcStat, src, dest, opts, cb) {
       if (opts.overwrite) {
-        fs2.unlink(dest, (err) => {
+        fs.unlink(dest, (err) => {
           if (err)
             return cb(err);
           return copyFile(srcStat, src, dest, opts, cb);
@@ -4436,8 +4436,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 fs.copyFile === "function") {
+        return fs.copyFile(src, dest, (err) => {
           if (err)
             return cb(err);
           return setDestModeAndTimestamps(srcStat, dest, opts, cb);
@@ -4446,14 +4446,14 @@ var require_copy = __commonJS({
       return copyFileFallback(srcStat, src, dest, opts, cb);
     }
     function copyFileFallback(srcStat, src, dest, opts, cb) {
-      const rs = fs2.createReadStream(src);
+      const rs = fs.createReadStream(src);
       rs.on("error", (err) => cb(err)).once("open", () => {
-        const ws = fs2.createWriteStream(dest, { mode: srcStat.mode });
+        const ws = fs.createWriteStream(dest, { mode: srcStat.mode });
         ws.on("error", (err) => cb(err)).on("open", () => rs.pipe(ws)).once("close", () => setDestModeAndTimestamps(srcStat, dest, opts, cb));
       });
     }
     function setDestModeAndTimestamps(srcStat, dest, opts, cb) {
-      fs2.chmod(dest, srcStat.mode, (err) => {
+      fs.chmod(dest, srcStat.mode, (err) => {
         if (err)
           return cb(err);
         if (opts.preserveTimestamps) {
@@ -4471,18 +4471,18 @@ var require_copy = __commonJS({
       return copyDir(src, dest, opts, cb);
     }
     function mkDirAndCopy(srcStat, src, dest, opts, cb) {
-      fs2.mkdir(dest, (err) => {
+      fs.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 fs.chmod(dest, srcStat.mode, cb);
         });
       });
     }
     function copyDir(src, dest, opts, cb) {
-      fs2.readdir(src, (err, items) => {
+      fs.readdir(src, (err, items) => {
         if (err)
           return cb(err);
         return copyDirItems(items, src, dest, opts, cb);
@@ -4508,19 +4508,19 @@ var require_copy = __commonJS({
       });
     }
     function onLink(destStat, src, dest, opts, cb) {
-      fs2.readlink(src, (err, resolvedSrc) => {
+      fs.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 fs.symlink(resolvedSrc, dest, cb);
         } else {
-          fs2.readlink(dest, (err2, resolvedDest) => {
+          fs.readlink(dest, (err2, resolvedDest) => {
             if (err2) {
               if (err2.code === "EINVAL" || err2.code === "UNKNOWN")
-                return fs2.symlink(resolvedSrc, dest, cb);
+                return fs.symlink(resolvedSrc, dest, cb);
               return cb(err2);
             }
             if (opts.dereference) {
@@ -4538,10 +4538,10 @@ var require_copy = __commonJS({
       });
     }
     function copyLink(resolvedSrc, dest, cb) {
-      fs2.unlink(dest, (err) => {
+      fs.unlink(dest, (err) => {
         if (err)
           return cb(err);
-        return fs2.symlink(resolvedSrc, dest, cb);
+        return fs.symlink(resolvedSrc, dest, cb);
       });
     }
     function isSrcSubdir(src, dest) {
@@ -4550,10 +4550,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) => {
+      fs.stat(src, (err, srcStat) => {
         if (err)
           return cb(err);
-        fs2.stat(dest, (err2, destStat) => {
+        fs.stat(dest, (err2, destStat) => {
           if (err2) {
             if (err2.code === "ENOENT")
               return cb(null, { srcStat, destStat: notExist });
@@ -4596,7 +4596,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 fs = require_graceful_fs();
     var path = require("path");
     var assert = require("assert");
     var isWindows = process.platform === "win32";
@@ -4610,9 +4610,9 @@ var require_rimraf = __commonJS({
         "readdir"
       ];
       methods.forEach((m) => {
-        options[m] = options[m] || fs2[m];
+        options[m] = options[m] || fs[m];
         m = m + "Sync";
-        options[m] = options[m] || fs2[m];
+        options[m] = options[m] || fs[m];
       });
       options.maxBusyTries = options.maxBusyTries || 3;
     }
@@ -4861,14 +4861,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 u = require_universalify().fromCallback;
-    var fs2 = require("fs");
+    var fs = require("fs");
     var path = require("path");
     var mkdir = require_mkdirs2();
     var remove2 = require_remove();
     var emptyDir = u(function emptyDir2(dir, callback) {
       callback = callback || function() {
       };
-      fs2.readdir(dir, (err, items) => {
+      fs.readdir(dir, (err, items) => {
         if (err)
           return mkdir.mkdirs(dir, callback);
         items = items.map((item) => path.join(dir, item));
@@ -4888,7 +4888,7 @@ var require_empty = __commonJS({
     function emptyDirSync(dir) {
       let items;
       try {
-        items = fs2.readdirSync(dir);
+        items = fs.readdirSync(dir);
       } catch (err) {
         return mkdir.mkdirsSync(dir);
       }
@@ -4912,18 +4912,18 @@ var require_file = __commonJS({
     "use strict";
     var u = require_universalify().fromCallback;
     var path = require("path");
-    var fs2 = require_graceful_fs();
+    var fs = require_graceful_fs();
     var mkdir = require_mkdirs2();
     var pathExists2 = require_path_exists().pathExists;
     function createFile(file, callback) {
       function makeFile() {
-        fs2.writeFile(file, "", (err) => {
+        fs.writeFile(file, "", (err) => {
           if (err)
             return callback(err);
           callback();
         });
       }
-      fs2.stat(file, (err, stats) => {
+      fs.stat(file, (err, stats) => {
         if (!err && stats.isFile())
           return callback();
         const dir = path.dirname(file);
@@ -4943,16 +4943,16 @@ var require_file = __commonJS({
     function createFileSync(file) {
       let stats;
       try {
-        stats = fs2.statSync(file);
+        stats = fs.statSync(file);
       } catch (e) {
       }
       if (stats && stats.isFile())
         return;
       const dir = path.dirname(file);
-      if (!fs2.existsSync(dir)) {
+      if (!fs.existsSync(dir)) {
         mkdir.mkdirsSync(dir);
       }
-      fs2.writeFileSync(file, "");
+      fs.writeFileSync(file, "");
     }
     module2.exports = {
       createFile: u(createFile),
@@ -4967,12 +4967,12 @@ var require_link = __commonJS({
     "use strict";
     var u = require_universalify().fromCallback;
     var path = require("path");
-    var fs2 = require_graceful_fs();
+    var fs = require_graceful_fs();
     var mkdir = require_mkdirs2();
     var pathExists2 = require_path_exists().pathExists;
     function createLink(srcpath, dstpath, callback) {
       function makeLink(srcpath2, dstpath2) {
-        fs2.link(srcpath2, dstpath2, (err) => {
+        fs.link(srcpath2, dstpath2, (err) => {
           if (err)
             return callback(err);
           callback(null);
@@ -4983,7 +4983,7 @@ var require_link = __commonJS({
           return callback(err);
         if (destinationExists)
           return callback(null);
-        fs2.lstat(srcpath, (err2) => {
+        fs.lstat(srcpath, (err2) => {
           if (err2) {
             err2.message = err2.message.replace("lstat", "ensureLink");
             return callback(err2);
@@ -5004,21 +5004,21 @@ var require_link = __commonJS({
       });
     }
     function createLinkSync(srcpath, dstpath) {
-      const destinationExists = fs2.existsSync(dstpath);
+      const destinationExists = fs.existsSync(dstpath);
       if (destinationExists)
         return void 0;
       try {
-        fs2.lstatSync(srcpath);
+        fs.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 = fs.existsSync(dir);
       if (dirExists)
-        return fs2.linkSync(srcpath, dstpath);
+        return fs.linkSync(srcpath, dstpath);
       mkdir.mkdirsSync(dir);
-      return fs2.linkSync(srcpath, dstpath);
+      return fs.linkSync(srcpath, dstpath);
     }
     module2.exports = {
       createLink: u(createLink),
@@ -5032,11 +5032,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 fs = require_graceful_fs();
     var pathExists2 = require_path_exists().pathExists;
     function symlinkPaths(srcpath, dstpath, callback) {
       if (path.isAbsolute(srcpath)) {
-        return fs2.lstat(srcpath, (err) => {
+        return fs.lstat(srcpath, (err) => {
           if (err) {
             err.message = err.message.replace("lstat", "ensureSymlink");
             return callback(err);
@@ -5058,7 +5058,7 @@ var require_symlink_paths = __commonJS({
               "toDst": srcpath
             });
           } else {
-            return fs2.lstat(srcpath, (err2) => {
+            return fs.lstat(srcpath, (err2) => {
               if (err2) {
                 err2.message = err2.message.replace("lstat", "ensureSymlink");
                 return callback(err2);
@@ -5075,7 +5075,7 @@ var require_symlink_paths = __commonJS({
     function symlinkPathsSync(srcpath, dstpath) {
       let exists;
       if (path.isAbsolute(srcpath)) {
-        exists = fs2.existsSync(srcpath);
+        exists = fs.existsSync(srcpath);
         if (!exists)
           throw new Error("absolute srcpath does not exist");
         return {
@@ -5085,14 +5085,14 @@ var require_symlink_paths = __commonJS({
       } else {
         const dstdir = path.dirname(dstpath);
         const relativeToDst = path.join(dstdir, srcpath);
-        exists = fs2.existsSync(relativeToDst);
+        exists = fs.existsSync(relativeToDst);
         if (exists) {
           return {
             "toCwd": relativeToDst,
             "toDst": srcpath
           };
         } else {
-          exists = fs2.existsSync(srcpath);
+          exists = fs.existsSync(srcpath);
           if (!exists)
             throw new Error("relative srcpath does not exist");
           return {
@@ -5113,13 +5113,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 fs = 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) => {
+      fs.lstat(srcpath, (err, stats) => {
         if (err)
           return callback(null, "file");
         type = stats && stats.isDirectory() ? "dir" : "file";
@@ -5131,7 +5131,7 @@ var require_symlink_type = __commonJS({
       if (type)
         return type;
       try {
-        stats = fs2.lstatSync(srcpath);
+        stats = fs.lstatSync(srcpath);
       } catch (e) {
         return "file";
       }
@@ -5150,7 +5150,7 @@ var require_symlink = __commonJS({
     "use strict";
     var u = require_universalify().fromCallback;
     var path = require("path");
-    var fs2 = require_graceful_fs();
+    var fs = require_graceful_fs();
     var _mkdirs = require_mkdirs2();
     var mkdirs = _mkdirs.mkdirs;
     var mkdirsSync = _mkdirs.mkdirsSync;
@@ -5181,11 +5181,11 @@ var require_symlink = __commonJS({
               if (err4)
                 return callback(err4);
               if (dirExists)
-                return fs2.symlink(srcpath, dstpath, type2, callback);
+                return fs.symlink(srcpath, dstpath, type2, callback);
               mkdirs(dir, (err5) => {
                 if (err5)
                   return callback(err5);
-                fs2.symlink(srcpath, dstpath, type2, callback);
+                fs.symlink(srcpath, dstpath, type2, callback);
               });
             });
           });
@@ -5193,18 +5193,18 @@ var require_symlink = __commonJS({
       });
     }
     function createSymlinkSync(srcpath, dstpath, type) {
-      const destinationExists = fs2.existsSync(dstpath);
+      const destinationExists = fs.existsSync(dstpath);
       if (destinationExists)
         return void 0;
       const relative = symlinkPathsSync(srcpath, dstpath);
       srcpath = relative.toDst;
       type = symlinkTypeSync(relative.toCwd, type);
       const dir = path.dirname(dstpath);
-      const exists = fs2.existsSync(dir);
+      const exists = fs.existsSync(dir);
       if (exists)
-        return fs2.symlinkSync(srcpath, dstpath, type);
+        return fs.symlinkSync(srcpath, dstpath, type);
       mkdirsSync(dir);
-      return fs2.symlinkSync(srcpath, dstpath, type);
+      return fs.symlinkSync(srcpath, dstpath, type);
     }
     module2.exports = {
       createSymlink: u(createSymlink),
@@ -5258,12 +5258,12 @@ var require_jsonfile = __commonJS({
         options = { encoding: options };
       }
       options = options || {};
-      var fs2 = options.fs || _fs;
+      var fs = options.fs || _fs;
       var shouldThrow = true;
       if ("throws" in options) {
         shouldThrow = options.throws;
       }
-      fs2.readFile(file, options, function(err, data) {
+      fs.readFile(file, options, function(err, data) {
         if (err)
           return callback(err);
         data = stripBom(data);
@@ -5286,13 +5286,13 @@ var require_jsonfile = __commonJS({
       if (typeof options === "string") {
         options = { encoding: options };
       }
-      var fs2 = options.fs || _fs;
+      var fs = options.fs || _fs;
       var shouldThrow = true;
       if ("throws" in options) {
         shouldThrow = options.throws;
       }
       try {
-        var content = fs2.readFileSync(file, options);
+        var content = fs.readFileSync(file, options);
         content = stripBom(content);
         return JSON.parse(content, options.reviver);
       } catch (err) {
@@ -5324,7 +5324,7 @@ var require_jsonfile = __commonJS({
         options = {};
       }
       options = options || {};
-      var fs2 = options.fs || _fs;
+      var fs = options.fs || _fs;
       var str = "";
       try {
         str = stringify(obj, options);
@@ -5333,13 +5333,13 @@ var require_jsonfile = __commonJS({
           callback(err, null);
         return;
       }
-      fs2.writeFile(file, str, options, callback);
+      fs.writeFile(file, str, options, callback);
     }
     function writeFileSync2(file, obj, options) {
       options = options || {};
-      var fs2 = options.fs || _fs;
+      var fs = options.fs || _fs;
       var str = stringify(obj, options);
-      return fs2.writeFileSync(file, str, options);
+      return fs.writeFileSync(file, str, options);
     }
     function stripBom(content) {
       if (Buffer.isBuffer(content))
@@ -5407,13 +5407,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 fs = 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 (!fs.existsSync(dir)) {
         mkdir.mkdirsSync(dir);
       }
       jsonFile.writeJsonSync(file, data, options);
@@ -5444,7 +5444,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 fs = require_graceful_fs();
     var path = require("path");
     var copySync = require_copy_sync2().copySync;
     var removeSync = require_remove().removeSync;
@@ -5456,7 +5456,7 @@ var require_move_sync = __commonJS({
       src = path.resolve(src);
       dest = path.resolve(dest);
       if (src === dest)
-        return fs2.accessSync(src);
+        return fs.accessSync(src);
       if (isSrcSubdir(src, dest))
         throw new Error(`Cannot move '${src}' into itself '${dest}'.`);
       mkdirpSync(path.dirname(dest));
@@ -5464,7 +5464,7 @@ var require_move_sync = __commonJS({
       function tryRenameSync() {
         if (overwrite) {
           try {
-            return fs2.renameSync(src, dest);
+            return fs.renameSync(src, dest);
           } catch (err) {
             if (err.code === "ENOTEMPTY" || err.code === "EEXIST" || err.code === "EPERM") {
               removeSync(dest);
@@ -5477,8 +5477,8 @@ var require_move_sync = __commonJS({
           }
         } else {
           try {
-            fs2.linkSync(src, dest);
-            return fs2.unlinkSync(src);
+            fs.linkSync(src, dest);
+            return fs.unlinkSync(src);
           } catch (err) {
             if (err.code === "EXDEV" || err.code === "EISDIR" || err.code === "EPERM" || err.code === "ENOTSUP") {
               return moveSyncAcrossDevice(src, dest, overwrite);
@@ -5489,7 +5489,7 @@ var require_move_sync = __commonJS({
       }
     }
     function moveSyncAcrossDevice(src, dest, overwrite) {
-      const stat = fs2.statSync(src);
+      const stat = fs.statSync(src);
       if (stat.isDirectory()) {
         return moveDirSyncAcrossDevice(src, dest, overwrite);
       } else {
@@ -5500,18 +5500,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 = fs.openSync(src, "r");
+      const stat = fs.fstatSync(fdr);
+      const fdw = fs.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 = fs.readSync(fdr, _buff, 0, BUF_LENGTH, pos);
+        fs.writeSync(fdw, _buff, 0, bytesRead);
         pos += bytesRead;
       }
-      fs2.closeSync(fdr);
-      fs2.closeSync(fdw);
-      return fs2.unlinkSync(src);
+      fs.closeSync(fdr);
+      fs.closeSync(fdw);
+      return fs.unlinkSync(src);
     }
     function moveDirSyncAcrossDevice(src, dest, overwrite) {
       const options = {
@@ -5530,7 +5530,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 fs.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;
       }
@@ -5546,7 +5546,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 u = require_universalify().fromCallback;
-    var fs2 = require_graceful_fs();
+    var fs = require_graceful_fs();
     var path = require("path");
     var copy = require_copy2().copy;
     var remove2 = require_remove().remove;
@@ -5561,8 +5561,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, st) => {
+        return fs.access(src, cb);
+      fs.stat(src, (err, st) => {
         if (err)
           return cb(err);
         if (st.isDirectory() && isSrcSubdir(src, dest)) {
@@ -5592,7 +5592,7 @@ var require_move = __commonJS({
       });
     }
     function rename(src, dest, overwrite, cb) {
-      fs2.rename(src, dest, (err) => {
+      fs.rename(src, dest, (err) => {
         if (!err)
           return cb();
         if (err.code !== "EXDEV")
@@ -5629,7 +5629,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 u = require_universalify().fromCallback;
-    var fs2 = require_graceful_fs();
+    var fs = require_graceful_fs();
     var path = require("path");
     var mkdir = require_mkdirs2();
     var pathExists2 = require_path_exists().pathExists;
@@ -5643,21 +5643,21 @@ var require_output = __commonJS({
         if (err)
           return callback(err);
         if (itDoes)
-          return fs2.writeFile(file, data, encoding, callback);
+          return fs.writeFile(file, data, encoding, callback);
         mkdir.mkdirs(dir, (err2) => {
           if (err2)
             return callback(err2);
-          fs2.writeFile(file, data, encoding, callback);
+          fs.writeFile(file, data, encoding, callback);
         });
       });
     }
     function outputFileSync(file, ...args) {
       const dir = path.dirname(file);
-      if (fs2.existsSync(dir)) {
-        return fs2.writeFileSync(file, ...args);
+      if (fs.existsSync(dir)) {
+        return fs.writeFileSync(file, ...args);
       }
       mkdir.mkdirsSync(dir);
-      fs2.writeFileSync(file, ...args);
+      fs.writeFileSync(file, ...args);
     }
     module2.exports = {
       outputFile: u(outputFile),
@@ -5687,11 +5687,11 @@ var require_lib = __commonJS({
       require_path_exists(),
       require_remove()
     );
-    var fs2 = require("fs");
-    if (Object.getOwnPropertyDescriptor(fs2, "promises")) {
+    var fs = require("fs");
+    if (Object.getOwnPropertyDescriptor(fs, "promises")) {
       Object.defineProperty(module2.exports, "promises", {
         get() {
-          return fs2.promises;
+          return fs.promises;
         }
       });
     }
@@ -7158,185 +7158,12 @@ function isInstalled({ major, minor }) {
 }
 
 // src/diagnostics.ts
-var import_fs = __toESM(require("fs"));
 var import_build_utils2 = require("@vercel/build-utils");
-var GEM_SPEC_PATTERN = /^(\S+) \(([^)]+)\)$/;
-var DEPENDENCY_PATTERN = /^([^\s!]+)(!?)(?:\s+\(([^)]+)\))?$/;
-function parseGemfileLock(content) {
-  const gems = /* @__PURE__ */ new Map();
-  const pathGems = /* @__PURE__ */ new Set();
-  const directGems = /* @__PURE__ */ new Map();
-  let Section;
-  ((Section2) => {
-    Section2["GEM"] = "gem";
-    Section2["GIT"] = "git";
-    Section2["PATH"] = "path";
-    Section2["PLUGIN"] = "plugin";
-    Section2["DEPENDENCIES"] = "dependencies";
-  })(Section || (Section = {}));
-  let SubSection;
-  ((SubSection2) => {
-    SubSection2["SPECS"] = "specs";
-  })(SubSection || (SubSection = {}));
-  let section = null;
-  let subSection = null;
-  let currentRemote = "";
-  for (const rawLine of content.split("\n")) {
-    const line = rawLine.trimEnd();
-    if (!line)
-      continue;
-    if (!line.startsWith(" ")) {
-      currentRemote = "";
-      if (line === "GEM")
-        section = "gem" /* GEM */;
-      else if (line === "GIT")
-        section = "git" /* GIT */;
-      else if (line === "PATH")
-        section = "path" /* PATH */;
-      else if (line === "PLUGIN SOURCE")
-        section = "plugin" /* PLUGIN */;
-      else if (line === "DEPENDENCIES")
-        section = "dependencies" /* DEPENDENCIES */;
-      else
-        section = null;
-      subSection = null;
-      continue;
-    }
-    const indent = line.length - line.trimStart().length;
-    const text = line.trimStart();
-    if (section === "gem" /* GEM */ || section === "git" /* GIT */ || section === "plugin" /* PLUGIN */) {
-      if (indent === 2) {
-        if (text.startsWith("remote:")) {
-          currentRemote = text.slice("remote:".length).trim();
-          subSection = null;
-        } else if (text === "specs:") {
-          subSection = "specs" /* SPECS */;
-        }
-      } else if (indent === 4 && subSection === "specs" /* SPECS */) {
-        const m = text.match(GEM_SPEC_PATTERN);
-        if (!m)
-          continue;
-        const [, name, version2] = m;
-        let gem;
-        if (section === "git" /* GIT */) {
-          gem = { version: version2, source: "git" /* GIT */, sourceUrl: currentRemote };
-        } else if (section === "plugin" /* PLUGIN */) {
-          gem = { version: version2, source: "plugin" /* PLUGIN */, sourceUrl: currentRemote };
-        } else {
-          let sourceUrl = currentRemote;
-          try {
-            sourceUrl = new URL(currentRemote).origin;
-          } catch {
-          }
-          gem = { version: version2, source: "registry" /* REGISTRY */, sourceUrl };
-        }
-        if (gems.has(name)) {
-          const existing = gems.get(name);
-          const isPlatformVariant = /-[a-zA-Z]/.test(version2);
-          const existingIsPlatformVariant = /-[a-zA-Z]/.test(existing.version);
-          if (isPlatformVariant)
-            continue;
-          if (existing.source === gem.source && !existingIsPlatformVariant)
-            continue;
-          if (gem.source !== "registry" /* REGISTRY */)
-            continue;
-        }
-        gems.set(name, gem);
-      }
-    }
-    if (section === "path" /* PATH */) {
-      if (indent === 2 && text === "specs:") {
-        subSection = "specs" /* SPECS */;
-      } else if (indent === 4 && subSection === "specs" /* SPECS */) {
-        const m = text.match(GEM_SPEC_PATTERN);
-        if (!m)
-          continue;
-        const [, name] = m;
-        pathGems.add(name);
-      }
-    }
-    if (section === "dependencies" /* DEPENDENCIES */) {
-      if (indent === 2) {
-        const m = text.match(DEPENDENCY_PATTERN);
-        if (!m)
-          continue;
-        const [, name, , version2] = m;
-        directGems.set(name, version2);
-      }
-    }
-  }
-  for (const name of pathGems) {
-    directGems.delete(name);
-  }
-  return { gems, directGems };
-}
-async function generateProjectManifest({
-  workPath,
-  gemfileLockPath,
-  framework,
-  serviceType
-}) {
-  try {
-    if (!gemfileLockPath)
-      return;
-    let content;
-    try {
-      content = await import_fs.default.promises.readFile(gemfileLockPath, "utf-8");
-    } catch {
-      return;
-    }
-    const { gems, directGems } = parseGemfileLock(content);
-    const directEntries = [];
-    const transitiveEntries = [];
-    for (const [name, version2] of directGems) {
-      const gem = gems.get(name);
-      const entry = {
-        name,
-        type: "direct",
-        scopes: ["prod"],
-        ...version2 ? { requested: version2 } : {},
-        resolved: gem?.version ?? ""
-      };
-      if (gem?.source)
-        entry.source = gem.source;
-      if (gem?.sourceUrl)
-        entry.sourceUrl = gem.sourceUrl;
-      directEntries.push(entry);
-    }
-    for (const [name, gem] of gems) {
-      if (directGems.has(name))
-        continue;
-      const entry = {
-        name,
-        type: "transitive",
-        scopes: ["prod"],
-        resolved: gem.version
-      };
-      if (gem.source)
-        entry.source = gem.source;
-      if (gem.sourceUrl)
-        entry.sourceUrl = gem.sourceUrl;
-      transitiveEntries.push(entry);
-    }
-    const manifest = {
-      version: import_build_utils2.MANIFEST_VERSION,
-      runtime: "ruby",
-      ...framework ? { framework } : {},
-      ...serviceType ? { serviceType } : {},
-      dependencies: [
-        ...directEntries.sort((a, b) => a.name.localeCompare(b.name)),
-        ...transitiveEntries.sort((a, b) => a.name.localeCompare(b.name))
-      ]
-    };
-    await (0, import_build_utils2.writeProjectManifest)(manifest, workPath, "ruby");
-  } catch {
-  }
-}
 var diagnostics = (0, import_build_utils2.createDiagnostics)("ruby");
 
 // src/start-dev-server.ts
 var import_child_process2 = require("child_process");
-var import_fs2 = require("fs");
+var import_fs = require("fs");
 var import_path2 = require("path");
 var import_which2 = __toESM(require_lib2());
 var import_build_utils3 = require("@vercel/build-utils");
@@ -7408,16 +7235,16 @@ function installGlobalCleanupHandlers() {
 function createDevRubyShim(workPath, entrypoint) {
   try {
     const vercelRubyDir = (0, import_path2.join)(workPath, ".vercel", "ruby");
-    (0, import_fs2.mkdirSync)(vercelRubyDir, { recursive: true });
+    (0, import_fs.mkdirSync)(vercelRubyDir, { recursive: true });
     const shimPath = (0, import_path2.join)(vercelRubyDir, `vc_init_dev.rb`);
     const utilsPath = (0, import_path2.join)(vercelRubyDir, "vc__utils__ruby.rb");
     const templatePath = (0, import_path2.join)(__dirname, "..", "vc_init_dev.rb");
     const utilsTemplatePath = (0, import_path2.join)(__dirname, "..", "vc_utils.rb");
-    const template = (0, import_fs2.readFileSync)(templatePath, "utf8");
-    const utilsTemplate = (0, import_fs2.readFileSync)(utilsTemplatePath, "utf8");
+    const template = (0, import_fs.readFileSync)(templatePath, "utf8");
+    const utilsTemplate = (0, import_fs.readFileSync)(utilsTemplatePath, "utf8");
     const shimSource = template.replace(/__VC_DEV_ENTRYPOINT__/g, entrypoint);
-    (0, import_fs2.writeFileSync)(shimPath, shimSource, "utf8");
-    (0, import_fs2.writeFileSync)(utilsPath, utilsTemplate, "utf8");
+    (0, import_fs.writeFileSync)(shimPath, shimSource, "utf8");
+    (0, import_fs.writeFileSync)(utilsPath, utilsTemplate, "utf8");
     (0, import_build_utils3.debug)(`Prepared Ruby dev shim at ${shimPath}`);
     return shimPath;
   } catch (err) {
@@ -7428,10 +7255,10 @@ function createDevRubyShim(workPath, entrypoint) {
 function detectGemfile(workPath, entrypoint) {
   const entryDir = (0, import_path2.dirname)(entrypoint);
   const localGemfile = (0, import_path2.join)(workPath, entryDir, "Gemfile");
-  if ((0, import_fs2.existsSync)(localGemfile))
+  if ((0, import_fs.existsSync)(localGemfile))
     return localGemfile;
   const rootGemfile = (0, import_path2.join)(workPath, "Gemfile");
-  if ((0, import_fs2.existsSync)(rootGemfile))
+  if ((0, import_fs.existsSync)(rootGemfile))
     return rootGemfile;
   return null;
 }
@@ -7855,7 +7682,7 @@ var build = async ({
     environment: {}
   });
   try {
-    await generateProjectManifest({
+    await (0, import_build_utils2.generateRubyProjectManifest)({
       workPath,
       gemfileLockPath: (0, import_path3.join)((0, import_path3.dirname)(gemfilePath), "Gemfile.lock"),
       framework: config?.framework ?? void 0,