npm - @vercel/ruby - Versions diffs - 2.4.0-canary.20260211174907.cdd2da6 → 2.4.0 - Mend

@vercel/ruby 2.4.0-canary.20260211174907.cdd2da6 → 2.4.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 (5) hide show

package/dist/index.js CHANGED Viewed

@@ -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 fs = require("fs");
+    var fs2 = 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) {
-      fs.stat(path, function(er, stat) {
+      fs2.stat(path, function(er, stat) {
         cb(er, er ? false : checkStat(stat, path, options));
       });
     }
     function sync(path, options) {
-      return checkStat(fs.statSync(path), path, options);
+      return checkStat(fs2.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 fs = require("fs");
+    var fs2 = require("fs");
     function isexe(path, options, cb) {
-      fs.stat(path, function(er, stat) {
+      fs2.stat(path, function(er, stat) {
         cb(er, er ? false : checkStat(stat, options));
       });
     }
     function sync(path, options) {
-      return checkStat(fs.statSync(path), options);
+      return checkStat(fs2.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 fs = require("fs");
+    var fs2 = 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 fs = require("fs");
+    var fs2 = 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 = fs.openSync(command, "r");
-        fs.readSync(fd, buffer, 0, size, 0);
-        fs.closeSync(fd);
+        fd = fs2.openSync(command, "r");
+        fs2.readSync(fd, buffer, 0, size, 0);
+        fs2.closeSync(fd);
       } catch (e) {
       }
       return shebangCommand(buffer.toString());
@@ -2376,9 +2376,9 @@ var require_pump = __commonJS({
   "../../node_modules/.pnpm/pump@3.0.2/node_modules/pump/index.js"(exports, module2) {
     var once = require_once();
     var eos = require_end_of_stream();
-    var fs;
+    var fs2;
     try {
-      fs = require("fs");
+      fs2 = require("fs");
     } catch (e) {
     }
     var noop = function() {
@@ -2390,9 +2390,9 @@ var require_pump = __commonJS({
     var isFS = function(stream) {
       if (!ancient)
         return false;
-      if (!fs)
+      if (!fs2)
         return false;
-      return (stream instanceof (fs.ReadStream || noop) || stream instanceof (fs.WriteStream || noop)) && isFn(stream.close);
+      return (stream instanceof (fs2.ReadStream || noop) || stream instanceof (fs2.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(fs) {
+    function patch(fs2) {
       if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-        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) {
+        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) {
           if (cb)
             process.nextTick(cb);
         };
-        fs.lchmodSync = function() {
+        fs2.lchmodSync = function() {
         };
       }
-      if (fs.chown && !fs.lchown) {
-        fs.lchown = function(path, uid, gid, cb) {
+      if (fs2.chown && !fs2.lchown) {
+        fs2.lchown = function(path, uid, gid, cb) {
           if (cb)
             process.nextTick(cb);
         };
-        fs.lchownSync = function() {
+        fs2.lchownSync = function() {
         };
       }
       if (platform === "win32") {
-        fs.rename = typeof fs.rename !== "function" ? fs.rename : function(fs$rename) {
+        fs2.rename = typeof fs2.rename !== "function" ? fs2.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() {
-                  fs.stat(to, function(stater, st) {
+                  fs2.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;
-        }(fs.rename);
+        }(fs2.rename);
       }
-      fs.read = typeof fs.read !== "function" ? fs.read : function(fs$read) {
+      fs2.read = typeof fs2.read !== "function" ? fs2.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(fs, fd, buffer, offset, length, position, callback);
+                return fs$read.call(fs2, fd, buffer, offset, length, position, callback);
               }
               callback_.apply(this, arguments);
             };
           }
-          return fs$read.call(fs, fd, buffer, offset, length, position, callback);
+          return fs$read.call(fs2, fd, buffer, offset, length, position, callback);
         }
         if (Object.setPrototypeOf)
           Object.setPrototypeOf(read, fs$read);
         return read;
-      }(fs.read);
-      fs.readSync = typeof fs.readSync !== "function" ? fs.readSync : function(fs$readSync) {
+      }(fs2.read);
+      fs2.readSync = typeof fs2.readSync !== "function" ? fs2.readSync : function(fs$readSync) {
         return function(fd, buffer, offset, length, position) {
           var eagCounter = 0;
           while (true) {
             try {
-              return fs$readSync.call(fs, fd, buffer, offset, length, position);
+              return fs$readSync.call(fs2, fd, buffer, offset, length, position);
             } catch (er) {
               if (er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
@@ -3131,10 +3131,10 @@ var require_polyfills = __commonJS({
             }
           }
         };
-      }(fs.readSync);
-      function patchLchmod(fs2) {
-        fs2.lchmod = function(path, mode, callback) {
-          fs2.open(
+      }(fs2.readSync);
+      function patchLchmod(fs3) {
+        fs3.lchmod = function(path, mode, callback) {
+          fs3.open(
             path,
             constants.O_WRONLY | constants.O_SYMLINK,
             mode,
@@ -3144,8 +3144,8 @@ var require_polyfills = __commonJS({
                   callback(err);
                 return;
               }
-              fs2.fchmod(fd, mode, function(err2) {
-                fs2.close(fd, function(err22) {
+              fs3.fchmod(fd, mode, function(err2) {
+                fs3.close(fd, function(err22) {
                   if (callback)
                     callback(err2 || err22);
                 });
@@ -3153,68 +3153,68 @@ var require_polyfills = __commonJS({
             }
           );
         };
-        fs2.lchmodSync = function(path, mode) {
-          var fd = fs2.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode);
+        fs3.lchmodSync = function(path, mode) {
+          var fd = fs3.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
-            ret = fs2.fchmodSync(fd, mode);
+            ret = fs3.fchmodSync(fd, mode);
             threw = false;
           } finally {
             if (threw) {
               try {
-                fs2.closeSync(fd);
+                fs3.closeSync(fd);
               } catch (er) {
               }
             } else {
-              fs2.closeSync(fd);
+              fs3.closeSync(fd);
             }
           }
           return ret;
         };
       }
-      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) {
+      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) {
               if (er) {
                 if (cb)
                   cb(er);
                 return;
               }
-              fs2.futimes(fd, at, mt, function(er2) {
-                fs2.close(fd, function(er22) {
+              fs3.futimes(fd, at, mt, function(er2) {
+                fs3.close(fd, function(er22) {
                   if (cb)
                     cb(er2 || er22);
                 });
               });
             });
           };
-          fs2.lutimesSync = function(path, at, mt) {
-            var fd = fs2.openSync(path, constants.O_SYMLINK);
+          fs3.lutimesSync = function(path, at, mt) {
+            var fd = fs3.openSync(path, constants.O_SYMLINK);
             var ret;
             var threw = true;
             try {
-              ret = fs2.futimesSync(fd, at, mt);
+              ret = fs3.futimesSync(fd, at, mt);
               threw = false;
             } finally {
               if (threw) {
                 try {
-                  fs2.closeSync(fd);
+                  fs3.closeSync(fd);
                 } catch (er) {
                 }
               } else {
-                fs2.closeSync(fd);
+                fs3.closeSync(fd);
               }
             }
             return ret;
           };
-        } else if (fs2.futimes) {
-          fs2.lutimes = function(_a, _b, _c, cb) {
+        } else if (fs3.futimes) {
+          fs3.lutimes = function(_a, _b, _c, cb) {
             if (cb)
               process.nextTick(cb);
           };
-          fs2.lutimesSync = function() {
+          fs3.lutimesSync = function() {
           };
         }
       }
@@ -3222,7 +3222,7 @@ var require_polyfills = __commonJS({
         if (!orig)
           return orig;
         return function(target, mode, cb) {
-          return orig.call(fs, target, mode, function(er) {
+          return orig.call(fs2, 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(fs, target, mode);
+            return orig.call(fs2, 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(fs, target, uid, gid, function(er) {
+          return orig.call(fs2, 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(fs, target, uid, gid);
+            return orig.call(fs2, 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(fs, target, options, callback) : orig.call(fs, target, callback);
+          return options ? orig.call(fs2, target, options, callback) : orig.call(fs2, target, callback);
         };
       }
       function statFixSync(orig) {
         if (!orig)
           return orig;
         return function(target, options) {
-          var stats = options ? orig.call(fs, target, options) : orig.call(fs, target);
+          var stats = options ? orig.call(fs2, target, options) : orig.call(fs2, 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(fs) {
+    function legacy(fs2) {
       return {
         ReadStream,
         WriteStream
@@ -3367,7 +3367,7 @@ var require_legacy_streams = __commonJS({
           });
           return;
         }
-        fs.open(this.path, this.flags, this.mode, function(err, fd) {
+        fs2.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 = fs.open;
+          this._open = fs2.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 fs = require("fs");
+    var fs2 = 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 (!fs[gracefulQueue]) {
+    if (!fs2[gracefulQueue]) {
       queue = global[gracefulQueue] || [];
-      publishQueue(fs, queue);
-      fs.close = function(fs$close) {
+      publishQueue(fs2, queue);
+      fs2.close = function(fs$close) {
         function close(fd, cb) {
-          return fs$close.call(fs, fd, function(err) {
+          return fs$close.call(fs2, fd, function(err) {
             if (!err) {
               resetQueue();
             }
@@ -3491,40 +3491,40 @@ var require_graceful_fs = __commonJS({
           value: fs$close
         });
         return close;
-      }(fs.close);
-      fs.closeSync = function(fs$closeSync) {
+      }(fs2.close);
+      fs2.closeSync = function(fs$closeSync) {
         function closeSync(fd) {
-          fs$closeSync.apply(fs, arguments);
+          fs$closeSync.apply(fs2, arguments);
           resetQueue();
         }
         Object.defineProperty(closeSync, previousSymbol, {
           value: fs$closeSync
         });
         return closeSync;
-      }(fs.closeSync);
+      }(fs2.closeSync);
       if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
         process.on("exit", function() {
-          debug4(fs[gracefulQueue]);
-          require("assert").equal(fs[gracefulQueue].length, 0);
+          debug4(fs2[gracefulQueue]);
+          require("assert").equal(fs2[gracefulQueue].length, 0);
         });
       }
     }
     var queue;
     if (!global[gracefulQueue]) {
-      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;
+      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;
       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 = fs2.writeFile;
-      fs2.writeFile = writeFile2;
+      var fs$writeFile = fs3.writeFile;
+      fs3.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 = fs2.appendFile;
+      var fs$appendFile = fs3.appendFile;
       if (fs$appendFile)
-        fs2.appendFile = appendFile;
+        fs3.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 = fs2.copyFile;
+      var fs$copyFile = fs3.copyFile;
       if (fs$copyFile)
-        fs2.copyFile = copyFile;
+        fs3.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 = fs2.readdir;
-      fs2.readdir = readdir;
+      var fs$readdir = fs3.readdir;
+      fs3.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(fs2);
+        var legStreams = legacy(fs3);
         ReadStream = legStreams.ReadStream;
         WriteStream = legStreams.WriteStream;
       }
-      var fs$ReadStream = fs2.ReadStream;
+      var fs$ReadStream = fs3.ReadStream;
       if (fs$ReadStream) {
         ReadStream.prototype = Object.create(fs$ReadStream.prototype);
         ReadStream.prototype.open = ReadStream$open;
       }
-      var fs$WriteStream = fs2.WriteStream;
+      var fs$WriteStream = fs3.WriteStream;
       if (fs$WriteStream) {
         WriteStream.prototype = Object.create(fs$WriteStream.prototype);
         WriteStream.prototype.open = WriteStream$open;
       }
-      Object.defineProperty(fs2, "ReadStream", {
+      Object.defineProperty(fs3, "ReadStream", {
         get: function() {
           return ReadStream;
         },
@@ -3661,7 +3661,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      Object.defineProperty(fs2, "WriteStream", {
+      Object.defineProperty(fs3, "WriteStream", {
         get: function() {
           return WriteStream;
         },
@@ -3672,7 +3672,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileReadStream = ReadStream;
-      Object.defineProperty(fs2, "FileReadStream", {
+      Object.defineProperty(fs3, "FileReadStream", {
         get: function() {
           return FileReadStream;
         },
@@ -3683,7 +3683,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileWriteStream = WriteStream;
-      Object.defineProperty(fs2, "FileWriteStream", {
+      Object.defineProperty(fs3, "FileWriteStream", {
         get: function() {
           return FileWriteStream;
         },
@@ -3732,13 +3732,13 @@ var require_graceful_fs = __commonJS({
         });
       }
       function createReadStream(path, options) {
-        return new fs2.ReadStream(path, options);
+        return new fs3.ReadStream(path, options);
       }
       function createWriteStream(path, options) {
-        return new fs2.WriteStream(path, options);
+        return new fs3.WriteStream(path, options);
       }
-      var fs$open = fs2.open;
-      fs2.open = open;
+      var fs$open = fs3.open;
+      fs3.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 fs2;
+      return fs3;
     }
     function enqueue(elem) {
       debug4("ENQUEUE", elem[0].name, elem[1]);
-      fs[gracefulQueue].push(elem);
+      fs2[gracefulQueue].push(elem);
       retry();
     }
     var retryTimer;
     function resetQueue() {
       var now = Date.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;
+      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;
         }
       }
       retry();
@@ -3775,9 +3775,9 @@ var require_graceful_fs = __commonJS({
     function retry() {
       clearTimeout(retryTimer);
       retryTimer = void 0;
-      if (fs[gracefulQueue].length === 0)
+      if (fs2[gracefulQueue].length === 0)
         return;
-      var elem = fs[gracefulQueue].shift();
+      var elem = fs2[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 {
-          fs[gracefulQueue].push(elem);
+          fs2[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 fs = require_graceful_fs();
+    var fs2 = require_graceful_fs();
     var api = [
       "access",
       "appendFile",
@@ -3849,31 +3849,31 @@ var require_fs = __commonJS({
       "utimes",
       "writeFile"
     ].filter((key) => {
-      return typeof fs[key] === "function";
+      return typeof fs2[key] === "function";
     });
-    Object.keys(fs).forEach((key) => {
+    Object.keys(fs2).forEach((key) => {
       if (key === "promises") {
         return;
       }
-      exports[key] = fs[key];
+      exports[key] = fs2[key];
     });
     api.forEach((method) => {
-      exports[method] = u(fs[method]);
+      exports[method] = u(fs2[method]);
     });
     exports.exists = function(filename, callback) {
       if (typeof callback === "function") {
-        return fs.exists(filename, callback);
+        return fs2.exists(filename, callback);
       }
       return new Promise((resolve) => {
-        return fs.exists(filename, resolve);
+        return fs2.exists(filename, resolve);
       });
     };
     exports.read = function(fd, buffer, offset, length, position, callback) {
       if (typeof callback === "function") {
-        return fs.read(fd, buffer, offset, length, position, callback);
+        return fs2.read(fd, buffer, offset, length, position, callback);
       }
       return new Promise((resolve, reject) => {
-        fs.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
+        fs2.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 fs.write(fd, buffer, ...args);
+        return fs2.write(fd, buffer, ...args);
       }
       return new Promise((resolve, reject) => {
-        fs.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
+        fs2.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 fs = require_graceful_fs();
+    var fs2 = 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 || fs;
+      const xfs = opts.fs || fs2;
       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 fs = require_graceful_fs();
+    var fs2 = 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 || fs;
+      const xfs = opts.fs || fs2;
       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 fs = require_graceful_fs();
+    var fs2 = 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);
-      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;
+      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;
     }
     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);
-      fs.writeFile(tmpfile, "https://github.com/jprichardson/node-fs-extra/pull/141", (err) => {
+      fs2.writeFile(tmpfile, "https://github.com/jprichardson/node-fs-extra/pull/141", (err) => {
         if (err)
           return callback(err);
-        fs.open(tmpfile, "r+", (err2, fd) => {
+        fs2.open(tmpfile, "r+", (err2, fd) => {
           if (err2)
             return callback(err2);
-          fs.futimes(fd, d, d, (err3) => {
+          fs2.futimes(fd, d, d, (err3) => {
             if (err3)
               return callback(err3);
-            fs.close(fd, (err4) => {
+            fs2.close(fd, (err4) => {
               if (err4)
                 return callback(err4);
-              fs.stat(tmpfile, (err5, stats) => {
+              fs2.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) {
-      fs.open(path2, "r+", (err, fd) => {
+      fs2.open(path2, "r+", (err, fd) => {
         if (err)
           return callback(err);
-        fs.futimes(fd, atime, mtime, (futimesErr) => {
-          fs.close(fd, (closeErr) => {
+        fs2.futimes(fd, atime, mtime, (futimesErr) => {
+          fs2.close(fd, (closeErr) => {
             if (callback)
               callback(futimesErr || closeErr);
           });
@@ -4115,9 +4115,9 @@ var require_utimes = __commonJS({
       });
     }
     function utimesMillisSync(path2, atime, mtime) {
-      const fd = fs.openSync(path2, "r+");
-      fs.futimesSync(fd, atime, mtime);
-      return fs.closeSync(fd);
+      const fd = fs2.openSync(path2, "r+");
+      fs2.futimesSync(fd, atime, mtime);
+      return fs2.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 fs = require_graceful_fs();
+    var fs2 = 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 (!fs.existsSync(destParent))
+      if (!fs2.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 ? fs.statSync : fs.lstatSync;
+      const statSync = opts.dereference ? fs2.statSync : fs2.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) {
-        fs.unlinkSync(dest);
+        fs2.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 fs.copyFileSync === "function") {
-        fs.copyFileSync(src, dest);
-        fs.chmodSync(dest, srcStat.mode);
+      if (typeof fs2.copyFileSync === "function") {
+        fs2.copyFileSync(src, dest);
+        fs2.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 = fs.openSync(src, "r");
-      const fdw = fs.openSync(dest, "w", srcStat.mode);
+      const fdr = fs2.openSync(src, "r");
+      const fdw = fs2.openSync(dest, "w", srcStat.mode);
       let pos = 0;
       while (pos < srcStat.size) {
-        const bytesRead = fs.readSync(fdr, _buff, 0, BUF_LENGTH, pos);
-        fs.writeSync(fdw, _buff, 0, bytesRead);
+        const bytesRead = fs2.readSync(fdr, _buff, 0, BUF_LENGTH, pos);
+        fs2.writeSync(fdw, _buff, 0, bytesRead);
         pos += bytesRead;
       }
       if (opts.preserveTimestamps)
-        fs.futimesSync(fdw, srcStat.atime, srcStat.mtime);
-      fs.closeSync(fdr);
-      fs.closeSync(fdw);
+        fs2.futimesSync(fdw, srcStat.atime, srcStat.mtime);
+      fs2.closeSync(fdr);
+      fs2.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) {
-      fs.mkdirSync(dest);
+      fs2.mkdirSync(dest);
       copyDir(src, dest, opts);
-      return fs.chmodSync(dest, srcStat.mode);
+      return fs2.chmodSync(dest, srcStat.mode);
     }
     function copyDir(src, dest, opts) {
-      fs.readdirSync(src).forEach((item) => copyDirItem(item, src, dest, opts));
+      fs2.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 = fs.readlinkSync(src);
+      let resolvedSrc = fs2.readlinkSync(src);
       if (opts.dereference) {
         resolvedSrc = path.resolve(process.cwd(), resolvedSrc);
       }
       if (destStat === notExist) {
-        return fs.symlinkSync(resolvedSrc, dest);
+        return fs2.symlinkSync(resolvedSrc, dest);
       } else {
         let resolvedDest;
         try {
-          resolvedDest = fs.readlinkSync(dest);
+          resolvedDest = fs2.readlinkSync(dest);
         } catch (err) {
           if (err.code === "EINVAL" || err.code === "UNKNOWN")
-            return fs.symlinkSync(resolvedSrc, dest);
+            return fs2.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 (fs.statSync(dest).isDirectory() && isSrcSubdir(resolvedDest, resolvedSrc)) {
+        if (fs2.statSync(dest).isDirectory() && isSrcSubdir(resolvedDest, resolvedSrc)) {
           throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
         }
         return copyLink(resolvedSrc, dest);
       }
     }
     function copyLink(resolvedSrc, dest) {
-      fs.unlinkSync(dest);
-      return fs.symlinkSync(resolvedSrc, dest);
+      fs2.unlinkSync(dest);
+      return fs2.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 = fs.statSync(src);
+      const srcStat = fs2.statSync(src);
       let destStat;
       try {
-        destStat = fs.statSync(dest);
+        destStat = fs2.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 fs = require_fs();
+    var fs2 = require_fs();
     function pathExists2(path) {
-      return fs.access(path).then(() => true).catch(() => false);
+      return fs2.access(path).then(() => true).catch(() => false);
     }
     module2.exports = {
       pathExists: u(pathExists2),
-      pathExistsSync: fs.existsSync
+      pathExistsSync: fs2.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 fs = require_graceful_fs();
+    var fs2 = 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 ? fs.stat : fs.lstat;
+      const stat = opts.dereference ? fs2.stat : fs2.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) {
-        fs.unlink(dest, (err) => {
+        fs2.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 fs.copyFile === "function") {
-        return fs.copyFile(src, dest, (err) => {
+      if (typeof fs2.copyFile === "function") {
+        return fs2.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 = fs.createReadStream(src);
+      const rs = fs2.createReadStream(src);
       rs.on("error", (err) => cb(err)).once("open", () => {
-        const ws = fs.createWriteStream(dest, { mode: srcStat.mode });
+        const ws = fs2.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) {
-      fs.chmod(dest, srcStat.mode, (err) => {
+      fs2.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) {
-      fs.mkdir(dest, (err) => {
+      fs2.mkdir(dest, (err) => {
         if (err)
           return cb(err);
         copyDir(src, dest, opts, (err2) => {
           if (err2)
             return cb(err2);
-          return fs.chmod(dest, srcStat.mode, cb);
+          return fs2.chmod(dest, srcStat.mode, cb);
         });
       });
     }
     function copyDir(src, dest, opts, cb) {
-      fs.readdir(src, (err, items) => {
+      fs2.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) {
-      fs.readlink(src, (err, resolvedSrc) => {
+      fs2.readlink(src, (err, resolvedSrc) => {
         if (err)
           return cb(err);
         if (opts.dereference) {
           resolvedSrc = path.resolve(process.cwd(), resolvedSrc);
         }
         if (destStat === notExist) {
-          return fs.symlink(resolvedSrc, dest, cb);
+          return fs2.symlink(resolvedSrc, dest, cb);
         } else {
-          fs.readlink(dest, (err2, resolvedDest) => {
+          fs2.readlink(dest, (err2, resolvedDest) => {
             if (err2) {
               if (err2.code === "EINVAL" || err2.code === "UNKNOWN")
-                return fs.symlink(resolvedSrc, dest, cb);
+                return fs2.symlink(resolvedSrc, dest, cb);
               return cb(err2);
             }
             if (opts.dereference) {
@@ -4538,10 +4538,10 @@ var require_copy = __commonJS({
       });
     }
     function copyLink(resolvedSrc, dest, cb) {
-      fs.unlink(dest, (err) => {
+      fs2.unlink(dest, (err) => {
         if (err)
           return cb(err);
-        return fs.symlink(resolvedSrc, dest, cb);
+        return fs2.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) {
-      fs.stat(src, (err, srcStat) => {
+      fs2.stat(src, (err, srcStat) => {
         if (err)
           return cb(err);
-        fs.stat(dest, (err2, destStat) => {
+        fs2.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 fs = require_graceful_fs();
+    var fs2 = 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] || fs[m];
+        options[m] = options[m] || fs2[m];
         m = m + "Sync";
-        options[m] = options[m] || fs[m];
+        options[m] = options[m] || fs2[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 fs = require("fs");
+    var fs2 = require("fs");
     var path = require("path");
     var mkdir = require_mkdirs2();
     var remove2 = require_remove();
     var emptyDir = u(function emptyDir2(dir, callback) {
       callback = callback || function() {
       };
-      fs.readdir(dir, (err, items) => {
+      fs2.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 = fs.readdirSync(dir);
+        items = fs2.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 fs = require_graceful_fs();
+    var fs2 = require_graceful_fs();
     var mkdir = require_mkdirs2();
     var pathExists2 = require_path_exists().pathExists;
     function createFile(file, callback) {
       function makeFile() {
-        fs.writeFile(file, "", (err) => {
+        fs2.writeFile(file, "", (err) => {
           if (err)
             return callback(err);
           callback();
         });
       }
-      fs.stat(file, (err, stats) => {
+      fs2.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 = fs.statSync(file);
+        stats = fs2.statSync(file);
       } catch (e) {
       }
       if (stats && stats.isFile())
         return;
       const dir = path.dirname(file);
-      if (!fs.existsSync(dir)) {
+      if (!fs2.existsSync(dir)) {
         mkdir.mkdirsSync(dir);
       }
-      fs.writeFileSync(file, "");
+      fs2.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 fs = require_graceful_fs();
+    var fs2 = require_graceful_fs();
     var mkdir = require_mkdirs2();
     var pathExists2 = require_path_exists().pathExists;
     function createLink(srcpath, dstpath, callback) {
       function makeLink(srcpath2, dstpath2) {
-        fs.link(srcpath2, dstpath2, (err) => {
+        fs2.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);
-        fs.lstat(srcpath, (err2) => {
+        fs2.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 = fs.existsSync(dstpath);
+      const destinationExists = fs2.existsSync(dstpath);
       if (destinationExists)
         return void 0;
       try {
-        fs.lstatSync(srcpath);
+        fs2.lstatSync(srcpath);
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureLink");
         throw err;
       }
       const dir = path.dirname(dstpath);
-      const dirExists = fs.existsSync(dir);
+      const dirExists = fs2.existsSync(dir);
       if (dirExists)
-        return fs.linkSync(srcpath, dstpath);
+        return fs2.linkSync(srcpath, dstpath);
       mkdir.mkdirsSync(dir);
-      return fs.linkSync(srcpath, dstpath);
+      return fs2.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 fs = require_graceful_fs();
+    var fs2 = require_graceful_fs();
     var pathExists2 = require_path_exists().pathExists;
     function symlinkPaths(srcpath, dstpath, callback) {
       if (path.isAbsolute(srcpath)) {
-        return fs.lstat(srcpath, (err) => {
+        return fs2.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 fs.lstat(srcpath, (err2) => {
+            return fs2.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 = fs.existsSync(srcpath);
+        exists = fs2.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 = fs.existsSync(relativeToDst);
+        exists = fs2.existsSync(relativeToDst);
         if (exists) {
           return {
             "toCwd": relativeToDst,
             "toDst": srcpath
           };
         } else {
-          exists = fs.existsSync(srcpath);
+          exists = fs2.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 fs = require_graceful_fs();
+    var fs2 = 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);
-      fs.lstat(srcpath, (err, stats) => {
+      fs2.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 = fs.lstatSync(srcpath);
+        stats = fs2.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 fs = require_graceful_fs();
+    var fs2 = 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 fs.symlink(srcpath, dstpath, type2, callback);
+                return fs2.symlink(srcpath, dstpath, type2, callback);
               mkdirs(dir, (err5) => {
                 if (err5)
                   return callback(err5);
-                fs.symlink(srcpath, dstpath, type2, callback);
+                fs2.symlink(srcpath, dstpath, type2, callback);
               });
             });
           });
@@ -5193,18 +5193,18 @@ var require_symlink = __commonJS({
       });
     }
     function createSymlinkSync(srcpath, dstpath, type) {
-      const destinationExists = fs.existsSync(dstpath);
+      const destinationExists = fs2.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 = fs.existsSync(dir);
+      const exists = fs2.existsSync(dir);
       if (exists)
-        return fs.symlinkSync(srcpath, dstpath, type);
+        return fs2.symlinkSync(srcpath, dstpath, type);
       mkdirsSync(dir);
-      return fs.symlinkSync(srcpath, dstpath, type);
+      return fs2.symlinkSync(srcpath, dstpath, type);
     }
     module2.exports = {
       createSymlink: u(createSymlink),
@@ -5258,12 +5258,12 @@ var require_jsonfile = __commonJS({
         options = { encoding: options };
       }
       options = options || {};
-      var fs = options.fs || _fs;
+      var fs2 = options.fs || _fs;
       var shouldThrow = true;
       if ("throws" in options) {
         shouldThrow = options.throws;
       }
-      fs.readFile(file, options, function(err, data) {
+      fs2.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 fs = options.fs || _fs;
+      var fs2 = options.fs || _fs;
       var shouldThrow = true;
       if ("throws" in options) {
         shouldThrow = options.throws;
       }
       try {
-        var content = fs.readFileSync(file, options);
+        var content = fs2.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 fs = options.fs || _fs;
+      var fs2 = options.fs || _fs;
       var str = "";
       try {
         str = stringify(obj, options);
@@ -5333,13 +5333,13 @@ var require_jsonfile = __commonJS({
           callback(err, null);
         return;
       }
-      fs.writeFile(file, str, options, callback);
+      fs2.writeFile(file, str, options, callback);
     }
     function writeFileSync2(file, obj, options) {
       options = options || {};
-      var fs = options.fs || _fs;
+      var fs2 = options.fs || _fs;
       var str = stringify(obj, options);
-      return fs.writeFileSync(file, str, options);
+      return fs2.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 fs = require_graceful_fs();
+    var fs2 = 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 (!fs.existsSync(dir)) {
+      if (!fs2.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 fs = require_graceful_fs();
+    var fs2 = 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 fs.accessSync(src);
+        return fs2.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 fs.renameSync(src, dest);
+            return fs2.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 {
-            fs.linkSync(src, dest);
-            return fs.unlinkSync(src);
+            fs2.linkSync(src, dest);
+            return fs2.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 = fs.statSync(src);
+      const stat = fs2.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 = fs.openSync(src, "r");
-      const stat = fs.fstatSync(fdr);
-      const fdw = fs.openSync(dest, flags, stat.mode);
+      const fdr = fs2.openSync(src, "r");
+      const stat = fs2.fstatSync(fdr);
+      const fdw = fs2.openSync(dest, flags, stat.mode);
       let pos = 0;
       while (pos < stat.size) {
-        const bytesRead = fs.readSync(fdr, _buff, 0, BUF_LENGTH, pos);
-        fs.writeSync(fdw, _buff, 0, bytesRead);
+        const bytesRead = fs2.readSync(fdr, _buff, 0, BUF_LENGTH, pos);
+        fs2.writeSync(fdw, _buff, 0, bytesRead);
         pos += bytesRead;
       }
-      fs.closeSync(fdr);
-      fs.closeSync(fdw);
-      return fs.unlinkSync(src);
+      fs2.closeSync(fdr);
+      fs2.closeSync(fdw);
+      return fs2.unlinkSync(src);
     }
     function moveDirSyncAcrossDevice(src, dest, overwrite) {
       const options = {
@@ -5530,7 +5530,7 @@ var require_move_sync = __commonJS({
     }
     function isSrcSubdir(src, dest) {
       try {
-        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);
+        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);
       } 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 fs = require_graceful_fs();
+    var fs2 = 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 fs.access(src, cb);
-      fs.stat(src, (err, st) => {
+        return fs2.access(src, cb);
+      fs2.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) {
-      fs.rename(src, dest, (err) => {
+      fs2.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 fs = require_graceful_fs();
+    var fs2 = 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 fs.writeFile(file, data, encoding, callback);
+          return fs2.writeFile(file, data, encoding, callback);
         mkdir.mkdirs(dir, (err2) => {
           if (err2)
             return callback(err2);
-          fs.writeFile(file, data, encoding, callback);
+          fs2.writeFile(file, data, encoding, callback);
         });
       });
     }
     function outputFileSync(file, ...args) {
       const dir = path.dirname(file);
-      if (fs.existsSync(dir)) {
-        return fs.writeFileSync(file, ...args);
+      if (fs2.existsSync(dir)) {
+        return fs2.writeFileSync(file, ...args);
       }
       mkdir.mkdirsSync(dir);
-      fs.writeFileSync(file, ...args);
+      fs2.writeFileSync(file, ...args);
     }
     module2.exports = {
       outputFile: u(outputFile),
@@ -5687,11 +5687,11 @@ var require_lib = __commonJS({
       require_path_exists(),
       require_remove()
     );
-    var fs = require("fs");
-    if (Object.getOwnPropertyDescriptor(fs, "promises")) {
+    var fs2 = require("fs");
+    if (Object.getOwnPropertyDescriptor(fs2, "promises")) {
       Object.defineProperty(module2.exports, "promises", {
         get() {
-          return fs.promises;
+          return fs2.promises;
         }
       });
     }
@@ -6940,6 +6940,7 @@ var require_semver2 = __commonJS({
 var src_exports = {};
 __export(src_exports, {
   build: () => build,
+  diagnostics: () => diagnostics,
   shouldServe: () => shouldServe,
   startDevServer: () => startDevServer,
   version: () => version
@@ -6949,7 +6950,7 @@ var import_os2 = require("os");
 var import_path3 = require("path");
 var import_execa2 = __toESM(require_execa());
 var import_fs_extra = __toESM(require_lib());
-var import_build_utils3 = require("@vercel/build-utils");
+var import_build_utils4 = require("@vercel/build-utils");
 // src/install-ruby.ts
 var import_execa = __toESM(require_execa());
@@ -7156,12 +7157,189 @@ function isInstalled({ major, minor }) {
   return Boolean(import_which.default.sync((0, import_path.join)(gemHome, "bin/ruby"), { nothrow: true })) && Boolean(import_which.default.sync((0, import_path.join)(gemHome, "bin/gem"), { nothrow: true }));
 }
+// 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_fs = require("fs");
+var import_fs2 = require("fs");
 var import_path2 = require("path");
 var import_which2 = __toESM(require_lib2());
-var import_build_utils2 = require("@vercel/build-utils");
+var import_build_utils3 = require("@vercel/build-utils");
 function silenceNodeWarnings() {
   const original = process.emitWarning.bind(
     process
@@ -7199,12 +7377,12 @@ function installGlobalCleanupHandlers() {
       try {
         process.kill(info.pid, "SIGTERM");
       } catch (err) {
-        (0, import_build_utils2.debug)(`Error sending SIGTERM to ${info.pid}: ${err}`);
+        (0, import_build_utils3.debug)(`Error sending SIGTERM to ${info.pid}: ${err}`);
       }
       try {
         process.kill(info.pid, "SIGKILL");
       } catch (err) {
-        (0, import_build_utils2.debug)(`Error sending SIGKILL to ${info.pid}: ${err}`);
+        (0, import_build_utils3.debug)(`Error sending SIGKILL to ${info.pid}: ${err}`);
       }
       PERSISTENT_SERVERS.delete(key);
     }
@@ -7212,7 +7390,7 @@ function installGlobalCleanupHandlers() {
       try {
         restoreWarnings();
       } catch (err) {
-        (0, import_build_utils2.debug)(`Error restoring warnings: ${err}`);
+        (0, import_build_utils3.debug)(`Error restoring warnings: ${err}`);
       }
       restoreWarnings = null;
     }
@@ -7230,26 +7408,30 @@ function installGlobalCleanupHandlers() {
 function createDevRubyShim(workPath, entrypoint) {
   try {
     const vercelRubyDir = (0, import_path2.join)(workPath, ".vercel", "ruby");
-    (0, import_fs.mkdirSync)(vercelRubyDir, { recursive: true });
+    (0, import_fs2.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 template = (0, import_fs.readFileSync)(templatePath, "utf8");
+    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 shimSource = template.replace(/__VC_DEV_ENTRYPOINT__/g, entrypoint);
-    (0, import_fs.writeFileSync)(shimPath, shimSource, "utf8");
-    (0, import_build_utils2.debug)(`Prepared Ruby dev shim at ${shimPath}`);
+    (0, import_fs2.writeFileSync)(shimPath, shimSource, "utf8");
+    (0, import_fs2.writeFileSync)(utilsPath, utilsTemplate, "utf8");
+    (0, import_build_utils3.debug)(`Prepared Ruby dev shim at ${shimPath}`);
     return shimPath;
   } catch (err) {
-    (0, import_build_utils2.debug)(`Failed to prepare Ruby dev shim: ${err?.message || err}`);
+    (0, import_build_utils3.debug)(`Failed to prepare Ruby dev shim: ${err?.message || err}`);
     return null;
   }
 }
 function detectGemfile(workPath, entrypoint) {
   const entryDir = (0, import_path2.dirname)(entrypoint);
   const localGemfile = (0, import_path2.join)(workPath, entryDir, "Gemfile");
-  if ((0, import_fs.existsSync)(localGemfile))
+  if ((0, import_fs2.existsSync)(localGemfile))
     return localGemfile;
   const rootGemfile = (0, import_path2.join)(workPath, "Gemfile");
-  if ((0, import_fs.existsSync)(rootGemfile))
+  if ((0, import_fs2.existsSync)(rootGemfile))
     return rootGemfile;
   return null;
 }
@@ -7260,8 +7442,22 @@ async function run(cmd, args, opts) {
       env: opts.env,
       stdio: ["ignore", "pipe", "pipe"]
     });
-    child.stdout?.on("data", (buf) => process.stdout.write(buf));
-    child.stderr?.on("data", (buf) => process.stderr.write(buf));
+    child.stdout?.on("data", (data) => {
+      const chunk = Buffer.isBuffer(data) ? data : Buffer.from(data);
+      if (opts.onStdout) {
+        opts.onStdout(chunk);
+      } else {
+        process.stdout.write(chunk.toString());
+      }
+    });
+    child.stderr?.on("data", (data) => {
+      const chunk = Buffer.isBuffer(data) ? data : Buffer.from(data);
+      if (opts.onStderr) {
+        opts.onStderr(chunk);
+      } else {
+        process.stderr.write(chunk.toString());
+      }
+    });
     child.on("close", (code, signal) => resolve({ code, signal }));
   });
 }
@@ -7309,7 +7505,7 @@ var startDevServer = async (opts) => {
       const shimPath = createDevRubyShim(workPath, entrypoint);
       if (!shimPath) {
         rejectChildReady(
-          new import_build_utils2.NowBuildError({
+          new import_build_utils3.NowBuildError({
             code: "RUBY_DEV_SHIM_ERROR",
             message: "Failed to create Ruby dev shim."
           })
@@ -7325,11 +7521,16 @@ var startDevServer = async (opts) => {
       }
       const checkDeps = async () => {
         if (gemfile && bundlerPath) {
-          (0, import_build_utils2.debug)(`Running "bundle check" for ${gemfile}`);
+          (0, import_build_utils3.debug)(`Running "bundle check" for ${gemfile}`);
           const check = await run(
             bundlerPath,
             ["check", "--gemfile", gemfile],
-            { cwd: projectDir, env }
+            {
+              cwd: projectDir,
+              env,
+              onStdout: opts.onStdout,
+              onStderr: opts.onStderr
+            }
           );
           if (check.code !== 0) {
             return false;
@@ -7339,7 +7540,7 @@ var startDevServer = async (opts) => {
       };
       checkDeps().then((ok) => {
         if (!ok) {
-          const err = new import_build_utils2.NowBuildError({
+          const err = new import_build_utils3.NowBuildError({
             code: "RUBY_GEMS_MISSING",
             message: 'Required gems are not installed. Run "vercel build" and try again.'
           });
@@ -7352,25 +7553,25 @@ var startDevServer = async (opts) => {
           cmd = bundlerPath;
           args = ["exec", "ruby", shimPath];
         }
-        (0, import_build_utils2.debug)(`Starting Ruby dev server: ${cmd} ${args.join(" ")}`);
+        (0, import_build_utils3.debug)(`Starting Ruby dev server: ${cmd} ${args.join(" ")}`);
         const child = (0, import_child_process2.spawn)(cmd, args, {
           cwd: workPath,
           env,
-          stdio: ["inherit", "pipe", "pipe"]
+          stdio: ["ignore", "pipe", "pipe"]
         });
         childProcess = child;
         stdoutLogListener = (buf) => {
-          const s = buf.toString();
-          for (const line of s.split(/\r?\n/)) {
-            if (line)
-              process.stdout.write(line.endsWith("\n") ? line : line + "\n");
+          if (opts.onStdout) {
+            opts.onStdout(buf);
+          } else {
+            process.stdout.write(buf.toString());
           }
         };
         stderrLogListener = (buf) => {
-          const s = buf.toString();
-          for (const line of s.split(/\r?\n/)) {
-            if (line)
-              process.stderr.write(line.endsWith("\n") ? line : line + "\n");
+          if (opts.onStderr) {
+            opts.onStderr(buf);
+          } else {
+            process.stderr.write(buf.toString());
           }
         };
         child.stdout?.on("data", stdoutLogListener);
@@ -7448,7 +7649,7 @@ async function matchPaths(configPatterns, workPath) {
   }
   const patternPaths = await Promise.all(
     patterns.map(async (pattern) => {
-      const files = await (0, import_build_utils3.glob)(pattern, workPath);
+      const files = await (0, import_build_utils4.glob)(pattern, workPath);
       return Object.keys(files);
     })
   );
@@ -7477,8 +7678,8 @@ async function prepareGemfile(gemfilePath, major) {
   return { modified };
 }
 async function bundleLock(bundlerPath, gemfilePath, rubyPath) {
-  const bundleAppConfig = await (0, import_build_utils3.getWriteableDirectory)();
-  const bundlerEnv = (0, import_build_utils3.cloneEnv)(process.env, {
+  const bundleAppConfig = await (0, import_build_utils4.getWriteableDirectory)();
+  const bundlerEnv = (0, import_build_utils4.cloneEnv)(process.env, {
     PATH: `${(0, import_path3.dirname)(rubyPath)}:${(0, import_path3.dirname)(bundlerPath)}:${process.env.PATH}`,
     BUNDLE_SILENCE_ROOT_WARNING: "1",
     BUNDLE_APP_CONFIG: bundleAppConfig,
@@ -7493,7 +7694,7 @@ async function bundleLock(bundlerPath, gemfilePath, rubyPath) {
     const darwinPlatform = darwinMajor ? `${darwinArchToken}-darwin-${darwinMajor}` : `${darwinArchToken}-darwin`;
     platforms.push(darwinPlatform);
   }
-  (0, import_build_utils3.debug)(`ruby: ensuring Gemfile.lock has platforms ${platforms.join(", ")}`);
+  (0, import_build_utils4.debug)(`ruby: ensuring Gemfile.lock has platforms ${platforms.join(", ")}`);
   const lockArgs = ["lock"];
   for (const platform of platforms) {
     lockArgs.push("--add-platform", platform);
@@ -7511,8 +7712,8 @@ async function bundleLock(bundlerPath, gemfilePath, rubyPath) {
   }
 }
 async function bundleInstall(bundlePath, bundleDir, gemfilePath, rubyPath) {
-  const bundleAppConfig = await (0, import_build_utils3.getWriteableDirectory)();
-  const bundlerEnv = (0, import_build_utils3.cloneEnv)(process.env, {
+  const bundleAppConfig = await (0, import_build_utils4.getWriteableDirectory)();
+  const bundlerEnv = (0, import_build_utils4.cloneEnv)(process.env, {
     PATH: `${(0, import_path3.dirname)(rubyPath)}:${(0, import_path3.dirname)(bundlePath)}:${process.env.PATH}`,
     BUNDLE_SILENCE_ROOT_WARNING: "1",
     BUNDLE_APP_CONFIG: bundleAppConfig,
@@ -7521,7 +7722,7 @@ async function bundleInstall(bundlePath, bundleDir, gemfilePath, rubyPath) {
     BUNDLE_PATH: bundleDir,
     BUNDLE_FROZEN: "true"
   });
-  (0, import_build_utils3.debug)('running "bundle install"');
+  (0, import_build_utils4.debug)('running "bundle install"');
   const installRes = await (0, import_execa2.default)(
     bundlePath,
     ["install", "--gemfile", gemfilePath],
@@ -7543,12 +7744,13 @@ var build = async ({
   files,
   entrypoint,
   config,
-  meta = {}
+  meta = {},
+  service
 }) => {
-  await (0, import_build_utils3.download)(files, workPath, meta);
+  await (0, import_build_utils4.download)(files, workPath, meta);
   const entrypointFsDirname = (0, import_path3.join)(workPath, (0, import_path3.dirname)(entrypoint));
   const gemfileName = "Gemfile";
-  let gemfilePath = await (0, import_build_utils3.walkParentDirs)({
+  let gemfilePath = await (0, import_build_utils4.walkParentDirs)({
     base: workPath,
     start: entrypointFsDirname,
     filename: gemfileName
@@ -7561,17 +7763,17 @@ var build = async ({
   const { gemHome, bundlerPath, vendorPath, runtime, rubyPath, major } = await installBundler(meta, gemfileContents);
   process.env.GEM_HOME = gemHome;
   try {
-    (0, import_build_utils3.debug)("preparing Gemfile");
+    (0, import_build_utils4.debug)("preparing Gemfile");
     await prepareGemfile(gemfilePath, major);
-    (0, import_build_utils3.debug)('running "bundle lock"');
+    (0, import_build_utils4.debug)('running "bundle lock"');
     await bundleLock(bundlerPath, gemfilePath, rubyPath);
   } catch (err) {
-    (0, import_build_utils3.debug)(
+    (0, import_build_utils4.debug)(
       "failed to normalize Gemfile/lockfile before vendor check",
       err
     );
   }
-  (0, import_build_utils3.debug)(`Checking existing vendor directory at "${vendorPath}"`);
+  (0, import_build_utils4.debug)(`Checking existing vendor directory at "${vendorPath}"`);
   const vendorDir = (0, import_path3.join)(workPath, vendorPath);
   const bundleDir = (0, import_path3.join)(workPath, "vendor", "bundle");
   const relativeVendorDir = (0, import_path3.join)(entrypointFsDirname, vendorPath);
@@ -7579,31 +7781,34 @@ var build = async ({
   const hasRelativeVendorDir = await (0, import_fs_extra.pathExists)(relativeVendorDir);
   if (hasRelativeVendorDir) {
     if (hasRootVendorDir) {
-      (0, import_build_utils3.debug)(
+      (0, import_build_utils4.debug)(
         "found two vendor directories, choosing the vendor directory relative to entrypoint"
       );
     } else {
-      (0, import_build_utils3.debug)("found vendor directory relative to entrypoint");
+      (0, import_build_utils4.debug)("found vendor directory relative to entrypoint");
     }
     await (0, import_fs_extra.move)(relativeVendorDir, vendorDir);
   } else if (hasRootVendorDir) {
-    (0, import_build_utils3.debug)("found vendor directory in project root");
+    (0, import_build_utils4.debug)("found vendor directory in project root");
   }
   await (0, import_fs_extra.ensureDir)(vendorDir);
   await bundleInstall(bundlerPath, bundleDir, gemfilePath, rubyPath);
   try {
     await (0, import_fs_extra.remove)((0, import_path3.join)(vendorDir, "cache"));
-  } catch (e) {
+  } catch (_e) {
   }
   const originalRbPath = (0, import_path3.join)(__dirname, "..", "vc_init.rb");
   const originalHandlerRbContents = await (0, import_fs_extra.readFile)(originalRbPath, "utf8");
-  (0, import_build_utils3.debug)("entrypoint is", entrypoint);
+  const originalUtilsRbPath = (0, import_path3.join)(__dirname, "..", "vc_utils.rb");
+  const originalUtilsRbContents = await (0, import_fs_extra.readFile)(originalUtilsRbPath, "utf8");
+  (0, import_build_utils4.debug)("entrypoint is", entrypoint);
   const userHandlerFilePath = entrypoint.replace(/\.rb$/, "");
   const nowHandlerRbContents = originalHandlerRbContents.replace(
     /__VC_HANDLER_FILENAME/g,
     userHandlerFilePath
   );
   const handlerRbFilename = "vc__handler__ruby";
+  const utilsRbFilename = "vc__utils__ruby.rb";
   const predefinedExcludes = [
     ".git/**",
     ".gitignore",
@@ -7617,10 +7822,13 @@ var build = async ({
     cwd: workPath,
     ignore: predefinedExcludes
   };
-  const outputFiles = await (0, import_build_utils3.glob)("**", globOptions);
-  outputFiles[`${handlerRbFilename}.rb`] = new import_build_utils3.FileBlob({
+  const outputFiles = await (0, import_build_utils4.glob)("**", globOptions);
+  outputFiles[`${handlerRbFilename}.rb`] = new import_build_utils4.FileBlob({
     data: nowHandlerRbContents
   });
+  outputFiles[utilsRbFilename] = new import_build_utils4.FileBlob({
+    data: originalUtilsRbContents
+  });
   if (config && (config.includeFiles || config.excludeFiles)) {
     const includedPaths = await matchPaths(config.includeFiles, workPath);
     const excludedPaths = await matchPaths(
@@ -7631,7 +7839,7 @@ var build = async ({
       if (includedPaths.includes(excludedPaths[i])) {
         continue;
       }
-      if (excludedPaths[i] === `${handlerRbFilename}.rb`) {
+      if (excludedPaths[i] === `${handlerRbFilename}.rb` || excludedPaths[i] === utilsRbFilename) {
         continue;
       }
       if (excludedPaths[i].startsWith(vendorPath)) {
@@ -7640,18 +7848,29 @@ var build = async ({
       delete outputFiles[excludedPaths[i]];
     }
   }
-  const output = new import_build_utils3.Lambda({
+  const output = new import_build_utils4.Lambda({
     files: outputFiles,
     handler: `${handlerRbFilename}.vc__handler`,
     runtime,
     environment: {}
   });
+  try {
+    await generateProjectManifest({
+      workPath,
+      gemfileLockPath: (0, import_path3.join)((0, import_path3.dirname)(gemfilePath), "Gemfile.lock"),
+      framework: config?.framework ?? void 0,
+      serviceType: service ? (0, import_build_utils4.getReportedServiceType)(service) : void 0
+    });
+  } catch (err) {
+    (0, import_build_utils4.debug)(`Failed to write ruby manifest: ${String(err)}`);
+  }
   return { output };
 };
 var shouldServe = () => true;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   build,
+  diagnostics,
   shouldServe,
   startDevServer,
   version