npm - @vercel/build-utils - Versions diffs - 14.1.0 → 14.2.0 - Mend

@vercel/build-utils 14.1.0 → 14.2.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 (16) hide show

package/CHANGELOG.md +12 -0
package/build.mjs +3 -11
package/dist/collect-build-result/validate-build-result.d.ts +1 -1
package/dist/collect-build-result/validate-build-result.js +1 -0
package/dist/fs/bun-helpers.d.ts +5 -0
package/dist/fs/bun-helpers.js +95 -0
package/dist/fs/node-version.js +11 -1
package/dist/fs/run-user-scripts.d.ts +4 -2
package/dist/fs/run-user-scripts.js +23 -3
package/dist/index.d.ts +2 -2
package/dist/index.js +433 -359
package/dist/types.d.ts +15 -6
package/package.json +2 -3
package/turbo.json +43 -7
package/dist/python.d.ts +0 -10
package/dist/python.js +0 -52

package/dist/index.js CHANGED Viewed

@@ -341,7 +341,7 @@ var require_BufferList = __commonJS({
         this.head = this.tail = null;
         this.length = 0;
       };
-      BufferList.prototype.join = function join9(s) {
+      BufferList.prototype.join = function join10(s) {
         if (this.length === 0)
           return "";
         var p = this.head;
@@ -2422,56 +2422,56 @@ var require_polyfills = __commonJS({
     }
     var chdir;
     module2.exports = patch;
-    function patch(fs12) {
+    function patch(fs11) {
       if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-        patchLchmod(fs12);
-      }
-      if (!fs12.lutimes) {
-        patchLutimes(fs12);
-      }
-      fs12.chown = chownFix(fs12.chown);
-      fs12.fchown = chownFix(fs12.fchown);
-      fs12.lchown = chownFix(fs12.lchown);
-      fs12.chmod = chmodFix(fs12.chmod);
-      fs12.fchmod = chmodFix(fs12.fchmod);
-      fs12.lchmod = chmodFix(fs12.lchmod);
-      fs12.chownSync = chownFixSync(fs12.chownSync);
-      fs12.fchownSync = chownFixSync(fs12.fchownSync);
-      fs12.lchownSync = chownFixSync(fs12.lchownSync);
-      fs12.chmodSync = chmodFixSync(fs12.chmodSync);
-      fs12.fchmodSync = chmodFixSync(fs12.fchmodSync);
-      fs12.lchmodSync = chmodFixSync(fs12.lchmodSync);
-      fs12.stat = statFix(fs12.stat);
-      fs12.fstat = statFix(fs12.fstat);
-      fs12.lstat = statFix(fs12.lstat);
-      fs12.statSync = statFixSync(fs12.statSync);
-      fs12.fstatSync = statFixSync(fs12.fstatSync);
-      fs12.lstatSync = statFixSync(fs12.lstatSync);
-      if (fs12.chmod && !fs12.lchmod) {
-        fs12.lchmod = function(path8, mode, cb) {
+        patchLchmod(fs11);
+      }
+      if (!fs11.lutimes) {
+        patchLutimes(fs11);
+      }
+      fs11.chown = chownFix(fs11.chown);
+      fs11.fchown = chownFix(fs11.fchown);
+      fs11.lchown = chownFix(fs11.lchown);
+      fs11.chmod = chmodFix(fs11.chmod);
+      fs11.fchmod = chmodFix(fs11.fchmod);
+      fs11.lchmod = chmodFix(fs11.lchmod);
+      fs11.chownSync = chownFixSync(fs11.chownSync);
+      fs11.fchownSync = chownFixSync(fs11.fchownSync);
+      fs11.lchownSync = chownFixSync(fs11.lchownSync);
+      fs11.chmodSync = chmodFixSync(fs11.chmodSync);
+      fs11.fchmodSync = chmodFixSync(fs11.fchmodSync);
+      fs11.lchmodSync = chmodFixSync(fs11.lchmodSync);
+      fs11.stat = statFix(fs11.stat);
+      fs11.fstat = statFix(fs11.fstat);
+      fs11.lstat = statFix(fs11.lstat);
+      fs11.statSync = statFixSync(fs11.statSync);
+      fs11.fstatSync = statFixSync(fs11.fstatSync);
+      fs11.lstatSync = statFixSync(fs11.lstatSync);
+      if (fs11.chmod && !fs11.lchmod) {
+        fs11.lchmod = function(path8, mode, cb) {
           if (cb)
             process.nextTick(cb);
         };
-        fs12.lchmodSync = function() {
+        fs11.lchmodSync = function() {
         };
       }
-      if (fs12.chown && !fs12.lchown) {
-        fs12.lchown = function(path8, uid, gid, cb) {
+      if (fs11.chown && !fs11.lchown) {
+        fs11.lchown = function(path8, uid, gid, cb) {
           if (cb)
             process.nextTick(cb);
         };
-        fs12.lchownSync = function() {
+        fs11.lchownSync = function() {
         };
       }
       if (platform === "win32") {
-        fs12.rename = typeof fs12.rename !== "function" ? fs12.rename : function(fs$rename) {
+        fs11.rename = typeof fs11.rename !== "function" ? fs11.rename : function(fs$rename) {
           function rename2(from, to, cb) {
             var start = Date.now();
             var backoff = 0;
             fs$rename(from, to, function CB(er) {
               if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 6e4) {
                 setTimeout(function() {
-                  fs12.stat(to, function(stater, st) {
+                  fs11.stat(to, function(stater, st) {
                     if (stater && stater.code === "ENOENT")
                       fs$rename(from, to, CB);
                     else
@@ -2489,9 +2489,9 @@ var require_polyfills = __commonJS({
           if (Object.setPrototypeOf)
             Object.setPrototypeOf(rename2, fs$rename);
           return rename2;
-        }(fs12.rename);
+        }(fs11.rename);
       }
-      fs12.read = typeof fs12.read !== "function" ? fs12.read : function(fs$read) {
+      fs11.read = typeof fs11.read !== "function" ? fs11.read : function(fs$read) {
         function read(fd, buffer, offset, length, position, callback_) {
           var callback;
           if (callback_ && typeof callback_ === "function") {
@@ -2499,23 +2499,23 @@ var require_polyfills = __commonJS({
             callback = function(er, _, __) {
               if (er && er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
-                return fs$read.call(fs12, fd, buffer, offset, length, position, callback);
+                return fs$read.call(fs11, fd, buffer, offset, length, position, callback);
               }
               callback_.apply(this, arguments);
             };
           }
-          return fs$read.call(fs12, fd, buffer, offset, length, position, callback);
+          return fs$read.call(fs11, fd, buffer, offset, length, position, callback);
         }
         if (Object.setPrototypeOf)
           Object.setPrototypeOf(read, fs$read);
         return read;
-      }(fs12.read);
-      fs12.readSync = typeof fs12.readSync !== "function" ? fs12.readSync : function(fs$readSync) {
+      }(fs11.read);
+      fs11.readSync = typeof fs11.readSync !== "function" ? fs11.readSync : function(fs$readSync) {
         return function(fd, buffer, offset, length, position) {
           var eagCounter = 0;
           while (true) {
             try {
-              return fs$readSync.call(fs12, fd, buffer, offset, length, position);
+              return fs$readSync.call(fs11, fd, buffer, offset, length, position);
             } catch (er) {
               if (er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
@@ -2525,10 +2525,10 @@ var require_polyfills = __commonJS({
             }
           }
         };
-      }(fs12.readSync);
-      function patchLchmod(fs13) {
-        fs13.lchmod = function(path8, mode, callback) {
-          fs13.open(
+      }(fs11.readSync);
+      function patchLchmod(fs12) {
+        fs12.lchmod = function(path8, mode, callback) {
+          fs12.open(
             path8,
             constants.O_WRONLY | constants.O_SYMLINK,
             mode,
@@ -2538,8 +2538,8 @@ var require_polyfills = __commonJS({
                   callback(err);
                 return;
               }
-              fs13.fchmod(fd, mode, function(err2) {
-                fs13.close(fd, function(err22) {
+              fs12.fchmod(fd, mode, function(err2) {
+                fs12.close(fd, function(err22) {
                   if (callback)
                     callback(err2 || err22);
                 });
@@ -2547,68 +2547,68 @@ var require_polyfills = __commonJS({
             }
           );
         };
-        fs13.lchmodSync = function(path8, mode) {
-          var fd = fs13.openSync(path8, constants.O_WRONLY | constants.O_SYMLINK, mode);
+        fs12.lchmodSync = function(path8, mode) {
+          var fd = fs12.openSync(path8, constants.O_WRONLY | constants.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
-            ret = fs13.fchmodSync(fd, mode);
+            ret = fs12.fchmodSync(fd, mode);
             threw = false;
           } finally {
             if (threw) {
               try {
-                fs13.closeSync(fd);
+                fs12.closeSync(fd);
               } catch (er) {
               }
             } else {
-              fs13.closeSync(fd);
+              fs12.closeSync(fd);
             }
           }
           return ret;
         };
       }
-      function patchLutimes(fs13) {
-        if (constants.hasOwnProperty("O_SYMLINK") && fs13.futimes) {
-          fs13.lutimes = function(path8, at, mt, cb) {
-            fs13.open(path8, constants.O_SYMLINK, function(er, fd) {
+      function patchLutimes(fs12) {
+        if (constants.hasOwnProperty("O_SYMLINK") && fs12.futimes) {
+          fs12.lutimes = function(path8, at, mt, cb) {
+            fs12.open(path8, constants.O_SYMLINK, function(er, fd) {
               if (er) {
                 if (cb)
                   cb(er);
                 return;
               }
-              fs13.futimes(fd, at, mt, function(er2) {
-                fs13.close(fd, function(er22) {
+              fs12.futimes(fd, at, mt, function(er2) {
+                fs12.close(fd, function(er22) {
                   if (cb)
                     cb(er2 || er22);
                 });
               });
             });
           };
-          fs13.lutimesSync = function(path8, at, mt) {
-            var fd = fs13.openSync(path8, constants.O_SYMLINK);
+          fs12.lutimesSync = function(path8, at, mt) {
+            var fd = fs12.openSync(path8, constants.O_SYMLINK);
             var ret;
             var threw = true;
             try {
-              ret = fs13.futimesSync(fd, at, mt);
+              ret = fs12.futimesSync(fd, at, mt);
               threw = false;
             } finally {
               if (threw) {
                 try {
-                  fs13.closeSync(fd);
+                  fs12.closeSync(fd);
                 } catch (er) {
                 }
               } else {
-                fs13.closeSync(fd);
+                fs12.closeSync(fd);
               }
             }
             return ret;
           };
-        } else if (fs13.futimes) {
-          fs13.lutimes = function(_a, _b, _c, cb) {
+        } else if (fs12.futimes) {
+          fs12.lutimes = function(_a, _b, _c, cb) {
             if (cb)
               process.nextTick(cb);
           };
-          fs13.lutimesSync = function() {
+          fs12.lutimesSync = function() {
           };
         }
       }
@@ -2616,7 +2616,7 @@ var require_polyfills = __commonJS({
         if (!orig)
           return orig;
         return function(target, mode, cb) {
-          return orig.call(fs12, target, mode, function(er) {
+          return orig.call(fs11, target, mode, function(er) {
             if (chownErOk(er))
               er = null;
             if (cb)
@@ -2629,7 +2629,7 @@ var require_polyfills = __commonJS({
           return orig;
         return function(target, mode) {
           try {
-            return orig.call(fs12, target, mode);
+            return orig.call(fs11, target, mode);
           } catch (er) {
             if (!chownErOk(er))
               throw er;
@@ -2640,7 +2640,7 @@ var require_polyfills = __commonJS({
         if (!orig)
           return orig;
         return function(target, uid, gid, cb) {
-          return orig.call(fs12, target, uid, gid, function(er) {
+          return orig.call(fs11, target, uid, gid, function(er) {
             if (chownErOk(er))
               er = null;
             if (cb)
@@ -2653,7 +2653,7 @@ var require_polyfills = __commonJS({
           return orig;
         return function(target, uid, gid) {
           try {
-            return orig.call(fs12, target, uid, gid);
+            return orig.call(fs11, target, uid, gid);
           } catch (er) {
             if (!chownErOk(er))
               throw er;
@@ -2678,14 +2678,14 @@ var require_polyfills = __commonJS({
             if (cb)
               cb.apply(this, arguments);
           }
-          return options ? orig.call(fs12, target, options, callback) : orig.call(fs12, target, callback);
+          return options ? orig.call(fs11, target, options, callback) : orig.call(fs11, target, callback);
         };
       }
       function statFixSync(orig) {
         if (!orig)
           return orig;
         return function(target, options) {
-          var stats = options ? orig.call(fs12, target, options) : orig.call(fs12, target);
+          var stats = options ? orig.call(fs11, target, options) : orig.call(fs11, target);
           if (stats) {
             if (stats.uid < 0)
               stats.uid += 4294967296;
@@ -2716,7 +2716,7 @@ var require_legacy_streams = __commonJS({
   "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/legacy-streams.js"(exports, module2) {
     var Stream = require("stream").Stream;
     module2.exports = legacy;
-    function legacy(fs12) {
+    function legacy(fs11) {
       return {
         ReadStream,
         WriteStream
@@ -2761,7 +2761,7 @@ var require_legacy_streams = __commonJS({
           });
           return;
         }
-        fs12.open(this.path, this.flags, this.mode, function(err, fd) {
+        fs11.open(this.path, this.flags, this.mode, function(err, fd) {
           if (err) {
             self2.emit("error", err);
             self2.readable = false;
@@ -2801,7 +2801,7 @@ var require_legacy_streams = __commonJS({
         this.busy = false;
         this._queue = [];
         if (this.fd === null) {
-          this._open = fs12.open;
+          this._open = fs11.open;
           this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
           this.flush();
         }
@@ -2836,7 +2836,7 @@ var require_clone = __commonJS({
 // ../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/graceful-fs.js
 var require_graceful_fs = __commonJS({
   "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/graceful-fs.js"(exports, module2) {
-    var fs12 = require("fs");
+    var fs11 = require("fs");
     var polyfills = require_polyfills();
     var legacy = require_legacy_streams();
     var clone = require_clone();
@@ -2868,12 +2868,12 @@ var require_graceful_fs = __commonJS({
         m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
         console.error(m);
       };
-    if (!fs12[gracefulQueue]) {
+    if (!fs11[gracefulQueue]) {
       queue = global[gracefulQueue] || [];
-      publishQueue(fs12, queue);
-      fs12.close = function(fs$close) {
+      publishQueue(fs11, queue);
+      fs11.close = function(fs$close) {
         function close(fd, cb) {
-          return fs$close.call(fs12, fd, function(err) {
+          return fs$close.call(fs11, fd, function(err) {
             if (!err) {
               resetQueue();
             }
@@ -2885,40 +2885,40 @@ var require_graceful_fs = __commonJS({
           value: fs$close
         });
         return close;
-      }(fs12.close);
-      fs12.closeSync = function(fs$closeSync) {
+      }(fs11.close);
+      fs11.closeSync = function(fs$closeSync) {
         function closeSync(fd) {
-          fs$closeSync.apply(fs12, arguments);
+          fs$closeSync.apply(fs11, arguments);
           resetQueue();
         }
         Object.defineProperty(closeSync, previousSymbol, {
           value: fs$closeSync
         });
         return closeSync;
-      }(fs12.closeSync);
+      }(fs11.closeSync);
       if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
         process.on("exit", function() {
-          debug2(fs12[gracefulQueue]);
-          require("assert").equal(fs12[gracefulQueue].length, 0);
+          debug2(fs11[gracefulQueue]);
+          require("assert").equal(fs11[gracefulQueue].length, 0);
         });
       }
     }
     var queue;
     if (!global[gracefulQueue]) {
-      publishQueue(global, fs12[gracefulQueue]);
-    }
-    module2.exports = patch(clone(fs12));
-    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs12.__patched) {
-      module2.exports = patch(fs12);
-      fs12.__patched = true;
-    }
-    function patch(fs13) {
-      polyfills(fs13);
-      fs13.gracefulify = patch;
-      fs13.createReadStream = createReadStream;
-      fs13.createWriteStream = createWriteStream;
-      var fs$readFile = fs13.readFile;
-      fs13.readFile = readFile3;
+      publishQueue(global, fs11[gracefulQueue]);
+    }
+    module2.exports = patch(clone(fs11));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs11.__patched) {
+      module2.exports = patch(fs11);
+      fs11.__patched = true;
+    }
+    function patch(fs12) {
+      polyfills(fs12);
+      fs12.gracefulify = patch;
+      fs12.createReadStream = createReadStream;
+      fs12.createWriteStream = createWriteStream;
+      var fs$readFile = fs12.readFile;
+      fs12.readFile = readFile3;
       function readFile3(path8, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
@@ -2934,8 +2934,8 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$writeFile = fs13.writeFile;
-      fs13.writeFile = writeFile;
+      var fs$writeFile = fs12.writeFile;
+      fs12.writeFile = writeFile;
       function writeFile(path8, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
@@ -2951,9 +2951,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$appendFile = fs13.appendFile;
+      var fs$appendFile = fs12.appendFile;
       if (fs$appendFile)
-        fs13.appendFile = appendFile;
+        fs12.appendFile = appendFile;
       function appendFile(path8, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
@@ -2969,9 +2969,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$copyFile = fs13.copyFile;
+      var fs$copyFile = fs12.copyFile;
       if (fs$copyFile)
-        fs13.copyFile = copyFile;
+        fs12.copyFile = copyFile;
       function copyFile(src, dest, flags, cb) {
         if (typeof flags === "function") {
           cb = flags;
@@ -2989,8 +2989,8 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$readdir = fs13.readdir;
-      fs13.readdir = readdir2;
+      var fs$readdir = fs12.readdir;
+      fs12.readdir = readdir2;
       var noReaddirOptionVersions = /^v[0-5]\./;
       function readdir2(path8, options, cb) {
         if (typeof options === "function")
@@ -3031,21 +3031,21 @@ var require_graceful_fs = __commonJS({
         }
       }
       if (process.version.substr(0, 4) === "v0.8") {
-        var legStreams = legacy(fs13);
+        var legStreams = legacy(fs12);
         ReadStream = legStreams.ReadStream;
         WriteStream = legStreams.WriteStream;
       }
-      var fs$ReadStream = fs13.ReadStream;
+      var fs$ReadStream = fs12.ReadStream;
       if (fs$ReadStream) {
         ReadStream.prototype = Object.create(fs$ReadStream.prototype);
         ReadStream.prototype.open = ReadStream$open;
       }
-      var fs$WriteStream = fs13.WriteStream;
+      var fs$WriteStream = fs12.WriteStream;
       if (fs$WriteStream) {
         WriteStream.prototype = Object.create(fs$WriteStream.prototype);
         WriteStream.prototype.open = WriteStream$open;
       }
-      Object.defineProperty(fs13, "ReadStream", {
+      Object.defineProperty(fs12, "ReadStream", {
         get: function() {
           return ReadStream;
         },
@@ -3055,7 +3055,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      Object.defineProperty(fs13, "WriteStream", {
+      Object.defineProperty(fs12, "WriteStream", {
         get: function() {
           return WriteStream;
         },
@@ -3066,7 +3066,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileReadStream = ReadStream;
-      Object.defineProperty(fs13, "FileReadStream", {
+      Object.defineProperty(fs12, "FileReadStream", {
         get: function() {
           return FileReadStream;
         },
@@ -3077,7 +3077,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileWriteStream = WriteStream;
-      Object.defineProperty(fs13, "FileWriteStream", {
+      Object.defineProperty(fs12, "FileWriteStream", {
         get: function() {
           return FileWriteStream;
         },
@@ -3126,13 +3126,13 @@ var require_graceful_fs = __commonJS({
         });
       }
       function createReadStream(path8, options) {
-        return new fs13.ReadStream(path8, options);
+        return new fs12.ReadStream(path8, options);
       }
       function createWriteStream(path8, options) {
-        return new fs13.WriteStream(path8, options);
+        return new fs12.WriteStream(path8, options);
       }
-      var fs$open = fs13.open;
-      fs13.open = open;
+      var fs$open = fs12.open;
+      fs12.open = open;
       function open(path8, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
@@ -3148,20 +3148,20 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      return fs13;
+      return fs12;
     }
     function enqueue(elem) {
       debug2("ENQUEUE", elem[0].name, elem[1]);
-      fs12[gracefulQueue].push(elem);
+      fs11[gracefulQueue].push(elem);
       retry2();
     }
     var retryTimer;
     function resetQueue() {
       var now = Date.now();
-      for (var i = 0; i < fs12[gracefulQueue].length; ++i) {
-        if (fs12[gracefulQueue][i].length > 2) {
-          fs12[gracefulQueue][i][3] = now;
-          fs12[gracefulQueue][i][4] = now;
+      for (var i = 0; i < fs11[gracefulQueue].length; ++i) {
+        if (fs11[gracefulQueue][i].length > 2) {
+          fs11[gracefulQueue][i][3] = now;
+          fs11[gracefulQueue][i][4] = now;
         }
       }
       retry2();
@@ -3169,9 +3169,9 @@ var require_graceful_fs = __commonJS({
     function retry2() {
       clearTimeout(retryTimer);
       retryTimer = void 0;
-      if (fs12[gracefulQueue].length === 0)
+      if (fs11[gracefulQueue].length === 0)
         return;
-      var elem = fs12[gracefulQueue].shift();
+      var elem = fs11[gracefulQueue].shift();
       var fn = elem[0];
       var args = elem[1];
       var err = elem[2];
@@ -3193,7 +3193,7 @@ var require_graceful_fs = __commonJS({
           debug2("RETRY", fn.name, args);
           fn.apply(null, args.concat([startTime]));
         } else {
-          fs12[gracefulQueue].push(elem);
+          fs11[gracefulQueue].push(elem);
         }
       }
       if (retryTimer === void 0) {
@@ -3208,7 +3208,7 @@ var require_fs = __commonJS({
   "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/fs/index.js"(exports) {
     "use strict";
     var u = require_universalify().fromCallback;
-    var fs12 = require_graceful_fs();
+    var fs11 = require_graceful_fs();
     var api = [
       "access",
       "appendFile",
@@ -3245,27 +3245,27 @@ var require_fs = __commonJS({
       "utimes",
       "writeFile"
     ].filter((key) => {
-      return typeof fs12[key] === "function";
+      return typeof fs11[key] === "function";
     });
-    Object.assign(exports, fs12);
+    Object.assign(exports, fs11);
     api.forEach((method) => {
-      exports[method] = u(fs12[method]);
+      exports[method] = u(fs11[method]);
     });
-    exports.realpath.native = u(fs12.realpath.native);
+    exports.realpath.native = u(fs11.realpath.native);
     exports.exists = function(filename, callback) {
       if (typeof callback === "function") {
-        return fs12.exists(filename, callback);
+        return fs11.exists(filename, callback);
       }
       return new Promise((resolve) => {
-        return fs12.exists(filename, resolve);
+        return fs11.exists(filename, resolve);
       });
     };
     exports.read = function(fd, buffer, offset, length, position, callback) {
       if (typeof callback === "function") {
-        return fs12.read(fd, buffer, offset, length, position, callback);
+        return fs11.read(fd, buffer, offset, length, position, callback);
       }
       return new Promise((resolve, reject) => {
-        fs12.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
+        fs11.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
           if (err)
             return reject(err);
           resolve({ bytesRead, buffer: buffer2 });
@@ -3274,23 +3274,23 @@ var require_fs = __commonJS({
     };
     exports.write = function(fd, buffer, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs12.write(fd, buffer, ...args);
+        return fs11.write(fd, buffer, ...args);
       }
       return new Promise((resolve, reject) => {
-        fs12.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
+        fs11.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
           if (err)
             return reject(err);
           resolve({ bytesWritten, buffer: buffer2 });
         });
       });
     };
-    if (typeof fs12.writev === "function") {
+    if (typeof fs11.writev === "function") {
       exports.writev = function(fd, buffers, ...args) {
         if (typeof args[args.length - 1] === "function") {
-          return fs12.writev(fd, buffers, ...args);
+          return fs11.writev(fd, buffers, ...args);
         }
         return new Promise((resolve, reject) => {
-          fs12.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
+          fs11.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
             if (err)
               return reject(err);
             resolve({ bytesWritten, buffers: buffers2 });
@@ -3323,7 +3323,7 @@ var require_utils = __commonJS({
 var require_make_dir = __commonJS({
   "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/mkdirs/make-dir.js"(exports, module2) {
     "use strict";
-    var fs12 = require_fs();
+    var fs11 = require_fs();
     var { checkPath } = require_utils();
     var getMode = (options) => {
       const defaults = { mode: 511 };
@@ -3333,14 +3333,14 @@ var require_make_dir = __commonJS({
     };
     module2.exports.makeDir = async (dir, options) => {
       checkPath(dir);
-      return fs12.mkdir(dir, {
+      return fs11.mkdir(dir, {
         mode: getMode(options),
         recursive: true
       });
     };
     module2.exports.makeDirSync = (dir, options) => {
       checkPath(dir);
-      return fs12.mkdirSync(dir, {
+      return fs11.mkdirSync(dir, {
         mode: getMode(options),
         recursive: true
       });
@@ -3371,13 +3371,13 @@ var require_mkdirs = __commonJS({
 var require_utimes = __commonJS({
   "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/util/utimes.js"(exports, module2) {
     "use strict";
-    var fs12 = require_graceful_fs();
+    var fs11 = require_graceful_fs();
     function utimesMillis(path8, atime, mtime2, callback) {
-      fs12.open(path8, "r+", (err, fd) => {
+      fs11.open(path8, "r+", (err, fd) => {
         if (err)
           return callback(err);
-        fs12.futimes(fd, atime, mtime2, (futimesErr) => {
-          fs12.close(fd, (closeErr) => {
+        fs11.futimes(fd, atime, mtime2, (futimesErr) => {
+          fs11.close(fd, (closeErr) => {
             if (callback)
               callback(futimesErr || closeErr);
           });
@@ -3385,9 +3385,9 @@ var require_utimes = __commonJS({
       });
     }
     function utimesMillisSync(path8, atime, mtime2) {
-      const fd = fs12.openSync(path8, "r+");
-      fs12.futimesSync(fd, atime, mtime2);
-      return fs12.closeSync(fd);
+      const fd = fs11.openSync(path8, "r+");
+      fs11.futimesSync(fd, atime, mtime2);
+      return fs11.closeSync(fd);
     }
     module2.exports = {
       utimesMillis,
@@ -3400,11 +3400,11 @@ var require_utimes = __commonJS({
 var require_stat = __commonJS({
   "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/util/stat.js"(exports, module2) {
     "use strict";
-    var fs12 = require_fs();
+    var fs11 = require_fs();
     var path8 = require("path");
     var util = require("util");
     function getStats(src, dest, opts) {
-      const statFunc = opts.dereference ? (file) => fs12.stat(file, { bigint: true }) : (file) => fs12.lstat(file, { bigint: true });
+      const statFunc = opts.dereference ? (file) => fs11.stat(file, { bigint: true }) : (file) => fs11.lstat(file, { bigint: true });
       return Promise.all([
         statFunc(src),
         statFunc(dest).catch((err) => {
@@ -3416,7 +3416,7 @@ var require_stat = __commonJS({
     }
     function getStatsSync(src, dest, opts) {
       let destStat;
-      const statFunc = opts.dereference ? (file) => fs12.statSync(file, { bigint: true }) : (file) => fs12.lstatSync(file, { bigint: true });
+      const statFunc = opts.dereference ? (file) => fs11.statSync(file, { bigint: true }) : (file) => fs11.lstatSync(file, { bigint: true });
       const srcStat = statFunc(src);
       try {
         destStat = statFunc(dest);
@@ -3482,7 +3482,7 @@ var require_stat = __commonJS({
       const destParent = path8.resolve(path8.dirname(dest));
       if (destParent === srcParent || destParent === path8.parse(destParent).root)
         return cb();
-      fs12.stat(destParent, { bigint: true }, (err, destStat) => {
+      fs11.stat(destParent, { bigint: true }, (err, destStat) => {
         if (err) {
           if (err.code === "ENOENT")
             return cb();
@@ -3501,7 +3501,7 @@ var require_stat = __commonJS({
         return;
       let destStat;
       try {
-        destStat = fs12.statSync(destParent, { bigint: true });
+        destStat = fs11.statSync(destParent, { bigint: true });
       } catch (err) {
         if (err.code === "ENOENT")
           return;
@@ -3538,7 +3538,7 @@ var require_stat = __commonJS({
 var require_copy_sync = __commonJS({
   "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/copy-sync/copy-sync.js"(exports, module2) {
     "use strict";
-    var fs12 = require_graceful_fs();
+    var fs11 = require_graceful_fs();
     var path8 = require("path");
     var mkdirsSync = require_mkdirs().mkdirsSync;
     var utimesMillisSync = require_utimes().utimesMillisSync;
@@ -3563,7 +3563,7 @@ var require_copy_sync = __commonJS({
       if (opts.filter && !opts.filter(src, dest))
         return;
       const destParent = path8.dirname(dest);
-      if (!fs12.existsSync(destParent))
+      if (!fs11.existsSync(destParent))
         mkdirsSync(destParent);
       return getStats(destStat, src, dest, opts);
     }
@@ -3573,7 +3573,7 @@ var require_copy_sync = __commonJS({
       return getStats(destStat, src, dest, opts);
     }
     function getStats(destStat, src, dest, opts) {
-      const statSync2 = opts.dereference ? fs12.statSync : fs12.lstatSync;
+      const statSync2 = opts.dereference ? fs11.statSync : fs11.lstatSync;
       const srcStat = statSync2(src);
       if (srcStat.isDirectory())
         return onDir(srcStat, destStat, src, dest, opts);
@@ -3594,14 +3594,14 @@ var require_copy_sync = __commonJS({
     }
     function mayCopyFile(srcStat, src, dest, opts) {
       if (opts.overwrite) {
-        fs12.unlinkSync(dest);
+        fs11.unlinkSync(dest);
         return copyFile(srcStat, src, dest, opts);
       } else if (opts.errorOnExist) {
         throw new Error(`'${dest}' already exists`);
       }
     }
     function copyFile(srcStat, src, dest, opts) {
-      fs12.copyFileSync(src, dest);
+      fs11.copyFileSync(src, dest);
       if (opts.preserveTimestamps)
         handleTimestamps(srcStat.mode, src, dest);
       return setDestMode(dest, srcStat.mode);
@@ -3618,10 +3618,10 @@ var require_copy_sync = __commonJS({
       return setDestMode(dest, srcMode | 128);
     }
     function setDestMode(dest, srcMode) {
-      return fs12.chmodSync(dest, srcMode);
+      return fs11.chmodSync(dest, srcMode);
     }
     function setDestTimestamps(src, dest) {
-      const updatedSrcStat = fs12.statSync(src);
+      const updatedSrcStat = fs11.statSync(src);
       return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
     }
     function onDir(srcStat, destStat, src, dest, opts) {
@@ -3630,12 +3630,12 @@ var require_copy_sync = __commonJS({
       return copyDir(src, dest, opts);
     }
     function mkDirAndCopy(srcMode, src, dest, opts) {
-      fs12.mkdirSync(dest);
+      fs11.mkdirSync(dest);
       copyDir(src, dest, opts);
       return setDestMode(dest, srcMode);
     }
     function copyDir(src, dest, opts) {
-      fs12.readdirSync(src).forEach((item) => copyDirItem(item, src, dest, opts));
+      fs11.readdirSync(src).forEach((item) => copyDirItem(item, src, dest, opts));
     }
     function copyDirItem(item, src, dest, opts) {
       const srcItem = path8.join(src, item);
@@ -3644,19 +3644,19 @@ var require_copy_sync = __commonJS({
       return startCopy(destStat, srcItem, destItem, opts);
     }
     function onLink(destStat, src, dest, opts) {
-      let resolvedSrc = fs12.readlinkSync(src);
+      let resolvedSrc = fs11.readlinkSync(src);
       if (opts.dereference) {
         resolvedSrc = path8.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
-        return fs12.symlinkSync(resolvedSrc, dest);
+        return fs11.symlinkSync(resolvedSrc, dest);
       } else {
         let resolvedDest;
         try {
-          resolvedDest = fs12.readlinkSync(dest);
+          resolvedDest = fs11.readlinkSync(dest);
         } catch (err) {
           if (err.code === "EINVAL" || err.code === "UNKNOWN")
-            return fs12.symlinkSync(resolvedSrc, dest);
+            return fs11.symlinkSync(resolvedSrc, dest);
           throw err;
         }
         if (opts.dereference) {
@@ -3665,15 +3665,15 @@ var require_copy_sync = __commonJS({
         if (stat2.isSrcSubdir(resolvedSrc, resolvedDest)) {
           throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
         }
-        if (fs12.statSync(dest).isDirectory() && stat2.isSrcSubdir(resolvedDest, resolvedSrc)) {
+        if (fs11.statSync(dest).isDirectory() && stat2.isSrcSubdir(resolvedDest, resolvedSrc)) {
           throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
         }
         return copyLink(resolvedSrc, dest);
       }
     }
     function copyLink(resolvedSrc, dest) {
-      fs12.unlinkSync(dest);
-      return fs12.symlinkSync(resolvedSrc, dest);
+      fs11.unlinkSync(dest);
+      return fs11.symlinkSync(resolvedSrc, dest);
     }
     module2.exports = copySync;
   }
@@ -3694,13 +3694,13 @@ var require_path_exists = __commonJS({
   "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/path-exists/index.js"(exports, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs12 = require_fs();
+    var fs11 = require_fs();
     function pathExists(path8) {
-      return fs12.access(path8).then(() => true).catch(() => false);
+      return fs11.access(path8).then(() => true).catch(() => false);
     }
     module2.exports = {
       pathExists: u(pathExists),
-      pathExistsSync: fs12.existsSync
+      pathExistsSync: fs11.existsSync
     };
   }
 });
@@ -3709,7 +3709,7 @@ var require_path_exists = __commonJS({
 var require_copy = __commonJS({
   "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/copy/copy.js"(exports, module2) {
     "use strict";
-    var fs12 = require_graceful_fs();
+    var fs11 = require_graceful_fs();
     var path8 = require("path");
     var mkdirs = require_mkdirs().mkdirs;
     var pathExists = require_path_exists().pathExists;
@@ -3772,7 +3772,7 @@ var require_copy = __commonJS({
       return getStats(destStat, src, dest, opts, cb);
     }
     function getStats(destStat, src, dest, opts, cb) {
-      const stat3 = opts.dereference ? fs12.stat : fs12.lstat;
+      const stat3 = opts.dereference ? fs11.stat : fs11.lstat;
       stat3(src, (err, srcStat) => {
         if (err)
           return cb(err);
@@ -3796,7 +3796,7 @@ var require_copy = __commonJS({
     }
     function mayCopyFile(srcStat, src, dest, opts, cb) {
       if (opts.overwrite) {
-        fs12.unlink(dest, (err) => {
+        fs11.unlink(dest, (err) => {
           if (err)
             return cb(err);
           return copyFile(srcStat, src, dest, opts, cb);
@@ -3807,7 +3807,7 @@ var require_copy = __commonJS({
         return cb();
     }
     function copyFile(srcStat, src, dest, opts, cb) {
-      fs12.copyFile(src, dest, (err) => {
+      fs11.copyFile(src, dest, (err) => {
         if (err)
           return cb(err);
         if (opts.preserveTimestamps)
@@ -3839,10 +3839,10 @@ var require_copy = __commonJS({
       });
     }
     function setDestMode(dest, srcMode, cb) {
-      return fs12.chmod(dest, srcMode, cb);
+      return fs11.chmod(dest, srcMode, cb);
     }
     function setDestTimestamps(src, dest, cb) {
-      fs12.stat(src, (err, updatedSrcStat) => {
+      fs11.stat(src, (err, updatedSrcStat) => {
         if (err)
           return cb(err);
         return utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime, cb);
@@ -3854,7 +3854,7 @@ var require_copy = __commonJS({
       return copyDir(src, dest, opts, cb);
     }
     function mkDirAndCopy(srcMode, src, dest, opts, cb) {
-      fs12.mkdir(dest, (err) => {
+      fs11.mkdir(dest, (err) => {
         if (err)
           return cb(err);
         copyDir(src, dest, opts, (err2) => {
@@ -3865,7 +3865,7 @@ var require_copy = __commonJS({
       });
     }
     function copyDir(src, dest, opts, cb) {
-      fs12.readdir(src, (err, items) => {
+      fs11.readdir(src, (err, items) => {
         if (err)
           return cb(err);
         return copyDirItems(items, src, dest, opts, cb);
@@ -3892,19 +3892,19 @@ var require_copy = __commonJS({
       });
     }
     function onLink(destStat, src, dest, opts, cb) {
-      fs12.readlink(src, (err, resolvedSrc) => {
+      fs11.readlink(src, (err, resolvedSrc) => {
         if (err)
           return cb(err);
         if (opts.dereference) {
           resolvedSrc = path8.resolve(process.cwd(), resolvedSrc);
         }
         if (!destStat) {
-          return fs12.symlink(resolvedSrc, dest, cb);
+          return fs11.symlink(resolvedSrc, dest, cb);
         } else {
-          fs12.readlink(dest, (err2, resolvedDest) => {
+          fs11.readlink(dest, (err2, resolvedDest) => {
             if (err2) {
               if (err2.code === "EINVAL" || err2.code === "UNKNOWN")
-                return fs12.symlink(resolvedSrc, dest, cb);
+                return fs11.symlink(resolvedSrc, dest, cb);
               return cb(err2);
             }
             if (opts.dereference) {
@@ -3922,10 +3922,10 @@ var require_copy = __commonJS({
       });
     }
     function copyLink(resolvedSrc, dest, cb) {
-      fs12.unlink(dest, (err) => {
+      fs11.unlink(dest, (err) => {
         if (err)
           return cb(err);
-        return fs12.symlink(resolvedSrc, dest, cb);
+        return fs11.symlink(resolvedSrc, dest, cb);
       });
     }
     module2.exports = copy;
@@ -3947,7 +3947,7 @@ var require_copy2 = __commonJS({
 var require_rimraf = __commonJS({
   "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/remove/rimraf.js"(exports, module2) {
     "use strict";
-    var fs12 = require_graceful_fs();
+    var fs11 = require_graceful_fs();
     var path8 = require("path");
     var assert7 = require("assert");
     var isWindows = process.platform === "win32";
@@ -3961,9 +3961,9 @@ var require_rimraf = __commonJS({
         "readdir"
       ];
       methods.forEach((m) => {
-        options[m] = options[m] || fs12[m];
+        options[m] = options[m] || fs11[m];
         m = m + "Sync";
-        options[m] = options[m] || fs12[m];
+        options[m] = options[m] || fs11[m];
       });
       options.maxBusyTries = options.maxBusyTries || 3;
     }
@@ -4186,17 +4186,17 @@ var require_rimraf = __commonJS({
 var require_remove = __commonJS({
   "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/remove/index.js"(exports, module2) {
     "use strict";
-    var fs12 = require_graceful_fs();
+    var fs11 = require_graceful_fs();
     var u = require_universalify().fromCallback;
     var rimraf = require_rimraf();
     function remove2(path8, callback) {
-      if (fs12.rm)
-        return fs12.rm(path8, { recursive: true, force: true }, callback);
+      if (fs11.rm)
+        return fs11.rm(path8, { recursive: true, force: true }, callback);
       rimraf(path8, callback);
     }
     function removeSync(path8) {
-      if (fs12.rmSync)
-        return fs12.rmSync(path8, { recursive: true, force: true });
+      if (fs11.rmSync)
+        return fs11.rmSync(path8, { recursive: true, force: true });
       rimraf.sync(path8);
     }
     module2.exports = {
@@ -4211,14 +4211,14 @@ var require_empty = __commonJS({
   "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/empty/index.js"(exports, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs12 = require_fs();
+    var fs11 = require_fs();
     var path8 = require("path");
     var mkdir = require_mkdirs();
     var remove2 = require_remove();
     var emptyDir = u(async function emptyDir2(dir) {
       let items;
       try {
-        items = await fs12.readdir(dir);
+        items = await fs11.readdir(dir);
       } catch {
         return mkdir.mkdirs(dir);
       }
@@ -4227,7 +4227,7 @@ var require_empty = __commonJS({
     function emptyDirSync(dir) {
       let items;
       try {
-        items = fs12.readdirSync(dir);
+        items = fs11.readdirSync(dir);
       } catch {
         return mkdir.mkdirsSync(dir);
       }
@@ -4251,21 +4251,21 @@ var require_file = __commonJS({
     "use strict";
     var u = require_universalify().fromCallback;
     var path8 = require("path");
-    var fs12 = require_graceful_fs();
+    var fs11 = require_graceful_fs();
     var mkdir = require_mkdirs();
     function createFile(file, callback) {
       function makeFile() {
-        fs12.writeFile(file, "", (err) => {
+        fs11.writeFile(file, "", (err) => {
           if (err)
             return callback(err);
           callback();
         });
       }
-      fs12.stat(file, (err, stats) => {
+      fs11.stat(file, (err, stats) => {
         if (!err && stats.isFile())
           return callback();
         const dir = path8.dirname(file);
-        fs12.stat(dir, (err2, stats2) => {
+        fs11.stat(dir, (err2, stats2) => {
           if (err2) {
             if (err2.code === "ENOENT") {
               return mkdir.mkdirs(dir, (err3) => {
@@ -4279,7 +4279,7 @@ var require_file = __commonJS({
           if (stats2.isDirectory())
             makeFile();
           else {
-            fs12.readdir(dir, (err3) => {
+            fs11.readdir(dir, (err3) => {
               if (err3)
                 return callback(err3);
             });
@@ -4290,15 +4290,15 @@ var require_file = __commonJS({
     function createFileSync(file) {
       let stats;
       try {
-        stats = fs12.statSync(file);
+        stats = fs11.statSync(file);
       } catch {
       }
       if (stats && stats.isFile())
         return;
       const dir = path8.dirname(file);
       try {
-        if (!fs12.statSync(dir).isDirectory()) {
-          fs12.readdirSync(dir);
+        if (!fs11.statSync(dir).isDirectory()) {
+          fs11.readdirSync(dir);
         }
       } catch (err) {
         if (err && err.code === "ENOENT")
@@ -4306,7 +4306,7 @@ var require_file = __commonJS({
         else
           throw err;
       }
-      fs12.writeFileSync(file, "");
+      fs11.writeFileSync(file, "");
     }
     module2.exports = {
       createFile: u(createFile),
@@ -4321,20 +4321,20 @@ var require_link = __commonJS({
     "use strict";
     var u = require_universalify().fromCallback;
     var path8 = require("path");
-    var fs12 = require_graceful_fs();
+    var fs11 = require_graceful_fs();
     var mkdir = require_mkdirs();
     var pathExists = require_path_exists().pathExists;
     var { areIdentical } = require_stat();
     function createLink(srcpath, dstpath, callback) {
       function makeLink(srcpath2, dstpath2) {
-        fs12.link(srcpath2, dstpath2, (err) => {
+        fs11.link(srcpath2, dstpath2, (err) => {
           if (err)
             return callback(err);
           callback(null);
         });
       }
-      fs12.lstat(dstpath, (_, dstStat) => {
-        fs12.lstat(srcpath, (err, srcStat) => {
+      fs11.lstat(dstpath, (_, dstStat) => {
+        fs11.lstat(srcpath, (err, srcStat) => {
           if (err) {
             err.message = err.message.replace("lstat", "ensureLink");
             return callback(err);
@@ -4359,11 +4359,11 @@ var require_link = __commonJS({
     function createLinkSync(srcpath, dstpath) {
       let dstStat;
       try {
-        dstStat = fs12.lstatSync(dstpath);
+        dstStat = fs11.lstatSync(dstpath);
       } catch {
       }
       try {
-        const srcStat = fs12.lstatSync(srcpath);
+        const srcStat = fs11.lstatSync(srcpath);
         if (dstStat && areIdentical(srcStat, dstStat))
           return;
       } catch (err) {
@@ -4371,11 +4371,11 @@ var require_link = __commonJS({
         throw err;
       }
       const dir = path8.dirname(dstpath);
-      const dirExists = fs12.existsSync(dir);
+      const dirExists = fs11.existsSync(dir);
       if (dirExists)
-        return fs12.linkSync(srcpath, dstpath);
+        return fs11.linkSync(srcpath, dstpath);
       mkdir.mkdirsSync(dir);
-      return fs12.linkSync(srcpath, dstpath);
+      return fs11.linkSync(srcpath, dstpath);
     }
     module2.exports = {
       createLink: u(createLink),
@@ -4389,11 +4389,11 @@ var require_symlink_paths = __commonJS({
   "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports, module2) {
     "use strict";
     var path8 = require("path");
-    var fs12 = require_graceful_fs();
+    var fs11 = require_graceful_fs();
     var pathExists = require_path_exists().pathExists;
     function symlinkPaths(srcpath, dstpath, callback) {
       if (path8.isAbsolute(srcpath)) {
-        return fs12.lstat(srcpath, (err) => {
+        return fs11.lstat(srcpath, (err) => {
           if (err) {
             err.message = err.message.replace("lstat", "ensureSymlink");
             return callback(err);
@@ -4415,7 +4415,7 @@ var require_symlink_paths = __commonJS({
               toDst: srcpath
             });
           } else {
-            return fs12.lstat(srcpath, (err2) => {
+            return fs11.lstat(srcpath, (err2) => {
               if (err2) {
                 err2.message = err2.message.replace("lstat", "ensureSymlink");
                 return callback(err2);
@@ -4432,7 +4432,7 @@ var require_symlink_paths = __commonJS({
     function symlinkPathsSync(srcpath, dstpath) {
       let exists;
       if (path8.isAbsolute(srcpath)) {
-        exists = fs12.existsSync(srcpath);
+        exists = fs11.existsSync(srcpath);
         if (!exists)
           throw new Error("absolute srcpath does not exist");
         return {
@@ -4442,14 +4442,14 @@ var require_symlink_paths = __commonJS({
       } else {
         const dstdir = path8.dirname(dstpath);
         const relativeToDst = path8.join(dstdir, srcpath);
-        exists = fs12.existsSync(relativeToDst);
+        exists = fs11.existsSync(relativeToDst);
         if (exists) {
           return {
             toCwd: relativeToDst,
             toDst: srcpath
           };
         } else {
-          exists = fs12.existsSync(srcpath);
+          exists = fs11.existsSync(srcpath);
           if (!exists)
             throw new Error("relative srcpath does not exist");
           return {
@@ -4470,13 +4470,13 @@ var require_symlink_paths = __commonJS({
 var require_symlink_type = __commonJS({
   "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/ensure/symlink-type.js"(exports, module2) {
     "use strict";
-    var fs12 = require_graceful_fs();
+    var fs11 = 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);
-      fs12.lstat(srcpath, (err, stats) => {
+      fs11.lstat(srcpath, (err, stats) => {
         if (err)
           return callback(null, "file");
         type = stats && stats.isDirectory() ? "dir" : "file";
@@ -4488,7 +4488,7 @@ var require_symlink_type = __commonJS({
       if (type)
         return type;
       try {
-        stats = fs12.lstatSync(srcpath);
+        stats = fs11.lstatSync(srcpath);
       } catch {
         return "file";
       }
@@ -4507,7 +4507,7 @@ var require_symlink = __commonJS({
     "use strict";
     var u = require_universalify().fromCallback;
     var path8 = require("path");
-    var fs12 = require_fs();
+    var fs11 = require_fs();
     var _mkdirs = require_mkdirs();
     var mkdirs = _mkdirs.mkdirs;
     var mkdirsSync = _mkdirs.mkdirsSync;
@@ -4522,11 +4522,11 @@ var require_symlink = __commonJS({
     function createSymlink(srcpath, dstpath, type, callback) {
       callback = typeof type === "function" ? type : callback;
       type = typeof type === "function" ? false : type;
-      fs12.lstat(dstpath, (err, stats) => {
+      fs11.lstat(dstpath, (err, stats) => {
         if (!err && stats.isSymbolicLink()) {
           Promise.all([
-            fs12.stat(srcpath),
-            fs12.stat(dstpath)
+            fs11.stat(srcpath),
+            fs11.stat(dstpath)
           ]).then(([srcStat, dstStat]) => {
             if (areIdentical(srcStat, dstStat))
               return callback(null);
@@ -4549,11 +4549,11 @@ var require_symlink = __commonJS({
             if (err3)
               return callback(err3);
             if (dirExists)
-              return fs12.symlink(srcpath, dstpath, type2, callback);
+              return fs11.symlink(srcpath, dstpath, type2, callback);
             mkdirs(dir, (err4) => {
               if (err4)
                 return callback(err4);
-              fs12.symlink(srcpath, dstpath, type2, callback);
+              fs11.symlink(srcpath, dstpath, type2, callback);
             });
           });
         });
@@ -4562,12 +4562,12 @@ var require_symlink = __commonJS({
     function createSymlinkSync(srcpath, dstpath, type) {
       let stats;
       try {
-        stats = fs12.lstatSync(dstpath);
+        stats = fs11.lstatSync(dstpath);
       } catch {
       }
       if (stats && stats.isSymbolicLink()) {
-        const srcStat = fs12.statSync(srcpath);
-        const dstStat = fs12.statSync(dstpath);
+        const srcStat = fs11.statSync(srcpath);
+        const dstStat = fs11.statSync(dstpath);
         if (areIdentical(srcStat, dstStat))
           return;
       }
@@ -4575,11 +4575,11 @@ var require_symlink = __commonJS({
       srcpath = relative2.toDst;
       type = symlinkTypeSync(relative2.toCwd, type);
       const dir = path8.dirname(dstpath);
-      const exists = fs12.existsSync(dir);
+      const exists = fs11.existsSync(dir);
       if (exists)
-        return fs12.symlinkSync(srcpath, dstpath, type);
+        return fs11.symlinkSync(srcpath, dstpath, type);
       mkdirsSync(dir);
-      return fs12.symlinkSync(srcpath, dstpath, type);
+      return fs11.symlinkSync(srcpath, dstpath, type);
     }
     module2.exports = {
       createSymlink: u(createSymlink),
@@ -4650,9 +4650,9 @@ var require_jsonfile = __commonJS({
       if (typeof options === "string") {
         options = { encoding: options };
       }
-      const fs12 = options.fs || _fs;
+      const fs11 = options.fs || _fs;
       const shouldThrow = "throws" in options ? options.throws : true;
-      let data = await universalify.fromCallback(fs12.readFile)(file, options);
+      let data = await universalify.fromCallback(fs11.readFile)(file, options);
       data = stripBom(data);
       let obj;
       try {
@@ -4672,10 +4672,10 @@ var require_jsonfile = __commonJS({
       if (typeof options === "string") {
         options = { encoding: options };
       }
-      const fs12 = options.fs || _fs;
+      const fs11 = options.fs || _fs;
       const shouldThrow = "throws" in options ? options.throws : true;
       try {
-        let content = fs12.readFileSync(file, options);
+        let content = fs11.readFileSync(file, options);
         content = stripBom(content);
         return JSON.parse(content, options.reviver);
       } catch (err) {
@@ -4688,15 +4688,15 @@ var require_jsonfile = __commonJS({
       }
     }
     async function _writeFile(file, obj, options = {}) {
-      const fs12 = options.fs || _fs;
+      const fs11 = options.fs || _fs;
       const str = stringify2(obj, options);
-      await universalify.fromCallback(fs12.writeFile)(file, str, options);
+      await universalify.fromCallback(fs11.writeFile)(file, str, options);
     }
     var writeFile = universalify.fromPromise(_writeFile);
     function writeFileSync(file, obj, options = {}) {
-      const fs12 = options.fs || _fs;
+      const fs11 = options.fs || _fs;
       const str = stringify2(obj, options);
-      return fs12.writeFileSync(file, str, options);
+      return fs11.writeFileSync(file, str, options);
     }
     module2.exports = {
       readFile: readFile3,
@@ -4727,7 +4727,7 @@ var require_output = __commonJS({
   "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/output/index.js"(exports, module2) {
     "use strict";
     var u = require_universalify().fromCallback;
-    var fs12 = require_graceful_fs();
+    var fs11 = require_graceful_fs();
     var path8 = require("path");
     var mkdir = require_mkdirs();
     var pathExists = require_path_exists().pathExists;
@@ -4741,21 +4741,21 @@ var require_output = __commonJS({
         if (err)
           return callback(err);
         if (itDoes)
-          return fs12.writeFile(file, data, encoding, callback);
+          return fs11.writeFile(file, data, encoding, callback);
         mkdir.mkdirs(dir, (err2) => {
           if (err2)
             return callback(err2);
-          fs12.writeFile(file, data, encoding, callback);
+          fs11.writeFile(file, data, encoding, callback);
         });
       });
     }
     function outputFileSync(file, ...args) {
       const dir = path8.dirname(file);
-      if (fs12.existsSync(dir)) {
-        return fs12.writeFileSync(file, ...args);
+      if (fs11.existsSync(dir)) {
+        return fs11.writeFileSync(file, ...args);
       }
       mkdir.mkdirsSync(dir);
-      fs12.writeFileSync(file, ...args);
+      fs11.writeFileSync(file, ...args);
     }
     module2.exports = {
       outputFile: u(outputFile),
@@ -4814,7 +4814,7 @@ var require_json = __commonJS({
 var require_move_sync = __commonJS({
   "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/move-sync/move-sync.js"(exports, module2) {
     "use strict";
-    var fs12 = require_graceful_fs();
+    var fs11 = require_graceful_fs();
     var path8 = require("path");
     var copySync = require_copy_sync2().copySync;
     var removeSync = require_remove().removeSync;
@@ -4841,13 +4841,13 @@ var require_move_sync = __commonJS({
         removeSync(dest);
         return rename2(src, dest, overwrite);
       }
-      if (fs12.existsSync(dest))
+      if (fs11.existsSync(dest))
         throw new Error("dest already exists.");
       return rename2(src, dest, overwrite);
     }
     function rename2(src, dest, overwrite) {
       try {
-        fs12.renameSync(src, dest);
+        fs11.renameSync(src, dest);
       } catch (err) {
         if (err.code !== "EXDEV")
           throw err;
@@ -4880,7 +4880,7 @@ var require_move_sync2 = __commonJS({
 var require_move = __commonJS({
   "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/move/move.js"(exports, module2) {
     "use strict";
-    var fs12 = require_graceful_fs();
+    var fs11 = require_graceful_fs();
     var path8 = require("path");
     var copy = require_copy2().copy;
     var remove2 = require_remove().remove;
@@ -4934,7 +4934,7 @@ var require_move = __commonJS({
       });
     }
     function rename2(src, dest, overwrite, cb) {
-      fs12.rename(src, dest, (err) => {
+      fs11.rename(src, dest, (err) => {
         if (!err)
           return cb();
         if (err.code !== "EXDEV")
@@ -6015,7 +6015,7 @@ var require_buffer_crc32 = __commonJS({
 // ../../node_modules/.pnpm/yazl@2.5.1/node_modules/yazl/index.js
 var require_yazl = __commonJS({
   "../../node_modules/.pnpm/yazl@2.5.1/node_modules/yazl/index.js"(exports) {
-    var fs12 = require("fs");
+    var fs11 = require("fs");
     var Transform = require("stream").Transform;
     var PassThrough = require("stream").PassThrough;
     var zlib = require("zlib");
@@ -6040,7 +6040,7 @@ var require_yazl = __commonJS({
         options = {};
       var entry = new Entry(metadataPath, false, options);
       self2.entries.push(entry);
-      fs12.stat(realPath, function(err, stats) {
+      fs11.stat(realPath, function(err, stats) {
         if (err)
           return self2.emit("error", err);
         if (!stats.isFile())
@@ -6051,7 +6051,7 @@ var require_yazl = __commonJS({
         if (options.mode == null)
           entry.setFileAttributesMode(stats.mode);
         entry.setFileDataPumpFunction(function() {
-          var readStream = fs12.createReadStream(realPath);
+          var readStream = fs11.createReadStream(realPath);
           entry.state = Entry.FILE_DATA_IN_PROGRESS;
           readStream.on("error", function(err2) {
             self2.emit("error", err2);
@@ -7623,7 +7623,7 @@ var require_old = __commonJS({
   "../../node_modules/.pnpm/fs.realpath@1.0.0/node_modules/fs.realpath/old.js"(exports) {
     var pathModule = require("path");
     var isWindows = process.platform === "win32";
-    var fs12 = require("fs");
+    var fs11 = require("fs");
     var DEBUG = process.env.NODE_DEBUG && /fs/.test(process.env.NODE_DEBUG);
     function rethrow() {
       var callback;
@@ -7688,7 +7688,7 @@ var require_old = __commonJS({
         base = m[0];
         previous = "";
         if (isWindows && !knownHard[base]) {
-          fs12.lstatSync(base);
+          fs11.lstatSync(base);
           knownHard[base] = true;
         }
       }
@@ -7706,7 +7706,7 @@ var require_old = __commonJS({
         if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
           resolvedLink = cache[base];
         } else {
-          var stat2 = fs12.lstatSync(base);
+          var stat2 = fs11.lstatSync(base);
           if (!stat2.isSymbolicLink()) {
             knownHard[base] = true;
             if (cache)
@@ -7721,8 +7721,8 @@ var require_old = __commonJS({
             }
           }
           if (linkTarget === null) {
-            fs12.statSync(base);
-            linkTarget = fs12.readlinkSync(base);
+            fs11.statSync(base);
+            linkTarget = fs11.readlinkSync(base);
           }
           resolvedLink = pathModule.resolve(previous, linkTarget);
           if (cache)
@@ -7759,7 +7759,7 @@ var require_old = __commonJS({
         base = m[0];
         previous = "";
         if (isWindows && !knownHard[base]) {
-          fs12.lstat(base, function(err) {
+          fs11.lstat(base, function(err) {
             if (err)
               return cb(err);
             knownHard[base] = true;
@@ -7787,7 +7787,7 @@ var require_old = __commonJS({
         if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
           return gotResolvedLink(cache[base]);
         }
-        return fs12.lstat(base, gotStat);
+        return fs11.lstat(base, gotStat);
       }
       function gotStat(err, stat2) {
         if (err)
@@ -7804,10 +7804,10 @@ var require_old = __commonJS({
             return gotTarget(null, seenLinks[id], base);
           }
         }
-        fs12.stat(base, function(err2) {
+        fs11.stat(base, function(err2) {
           if (err2)
             return cb(err2);
-          fs12.readlink(base, function(err3, target) {
+          fs11.readlink(base, function(err3, target) {
             if (!isWindows)
               seenLinks[id] = target;
             gotTarget(err3, target);
@@ -7839,9 +7839,9 @@ var require_fs2 = __commonJS({
     realpath.realpathSync = realpathSync;
     realpath.monkeypatch = monkeypatch;
     realpath.unmonkeypatch = unmonkeypatch;
-    var fs12 = require("fs");
-    var origRealpath = fs12.realpath;
-    var origRealpathSync = fs12.realpathSync;
+    var fs11 = require("fs");
+    var origRealpath = fs11.realpath;
+    var origRealpathSync = fs11.realpathSync;
     var version = process.version;
     var ok = /^v[0-5]\./.test(version);
     var old = require_old();
@@ -7879,12 +7879,12 @@ var require_fs2 = __commonJS({
       }
     }
     function monkeypatch() {
-      fs12.realpath = realpath;
-      fs12.realpathSync = realpathSync;
+      fs11.realpath = realpath;
+      fs11.realpathSync = realpathSync;
     }
     function unmonkeypatch() {
-      fs12.realpath = origRealpath;
-      fs12.realpathSync = origRealpathSync;
+      fs11.realpath = origRealpath;
+      fs11.realpathSync = origRealpathSync;
     }
   }
 });
@@ -8606,7 +8606,7 @@ var require_common = __commonJS({
     function ownProp(obj, field) {
       return Object.prototype.hasOwnProperty.call(obj, field);
     }
-    var fs12 = require("fs");
+    var fs11 = require("fs");
     var path8 = require("path");
     var minimatch3 = require_minimatch2();
     var isAbsolute = require("path").isAbsolute;
@@ -8661,7 +8661,7 @@ var require_common = __commonJS({
       self2.stat = !!options.stat;
       self2.noprocess = !!options.noprocess;
       self2.absolute = !!options.absolute;
-      self2.fs = options.fs || fs12;
+      self2.fs = options.fs || fs11;
       self2.maxLength = options.maxLength || Infinity;
       self2.cache = options.cache || /* @__PURE__ */ Object.create(null);
       self2.statCache = options.statCache || /* @__PURE__ */ Object.create(null);
@@ -9760,7 +9760,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 fs12 = require("fs");
+    var fs11 = require("fs");
     function checkPathExt(path8, options) {
       var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
       if (!pathext) {
@@ -9785,12 +9785,12 @@ var require_windows = __commonJS({
       return checkPathExt(path8, options);
     }
     function isexe(path8, options, cb) {
-      fs12.stat(path8, function(er, stat2) {
+      fs11.stat(path8, function(er, stat2) {
         cb(er, er ? false : checkStat(stat2, path8, options));
       });
     }
     function sync(path8, options) {
-      return checkStat(fs12.statSync(path8), path8, options);
+      return checkStat(fs11.statSync(path8), path8, options);
     }
   }
 });
@@ -9800,14 +9800,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 fs12 = require("fs");
+    var fs11 = require("fs");
     function isexe(path8, options, cb) {
-      fs12.stat(path8, function(er, stat2) {
+      fs11.stat(path8, function(er, stat2) {
         cb(er, er ? false : checkStat(stat2, options));
       });
     }
     function sync(path8, options) {
-      return checkStat(fs12.statSync(path8), options);
+      return checkStat(fs11.statSync(path8), options);
     }
     function checkStat(stat2, options) {
       return stat2.isFile() && checkMode(stat2, options);
@@ -9831,7 +9831,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 fs12 = require("fs");
+    var fs11 = require("fs");
     var core;
     if (process.platform === "win32" || global.TESTING_WINDOWS) {
       core = require_windows();
@@ -10107,7 +10107,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 fs12 = require("fs");
+    var fs11 = require("fs");
     var shebangCommand = require_shebang_command();
     function readShebang(command) {
       const size = 150;
@@ -10120,9 +10120,9 @@ var require_readShebang = __commonJS({
       }
       let fd;
       try {
-        fd = fs12.openSync(command, "r");
-        fs12.readSync(fd, buffer, 0, size, 0);
-        fs12.closeSync(fd);
+        fd = fs11.openSync(command, "r");
+        fs11.readSync(fd, buffer, 0, size, 0);
+        fs11.closeSync(fd);
       } catch (e) {
       }
       return shebangCommand(buffer.toString());
@@ -11343,7 +11343,7 @@ var require_cross_spawn = __commonJS({
     var cp = require("child_process");
     var parse6 = require_parse();
     var enoent = require_enoent();
-    function spawn2(command, args, options) {
+    function spawn3(command, args, options) {
       const parsed = parse6(command, args, options);
       const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
       enoent.hookChildProcess(spawned, parsed);
@@ -11355,8 +11355,8 @@ var require_cross_spawn = __commonJS({
       result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
       return result;
     }
-    module2.exports = spawn2;
-    module2.exports.spawn = spawn2;
+    module2.exports = spawn3;
+    module2.exports.spawn = spawn3;
     module2.exports.sync = spawnSync;
     module2.exports._parse = parse6;
     module2.exports._enoent = enoent;
@@ -34386,6 +34386,7 @@ __export(src_exports, {
   getNodeBinPath: () => getNodeBinPath,
   getNodeBinPaths: () => getNodeBinPaths,
   getNodeVersion: () => getNodeVersion,
+  getOrCreateBunBinary: () => getOrCreateBunBinary,
   getPackageJson: () => getPackageJson,
   getPathForPackageManager: () => getPathForPackageManager,
   getPlatformEnv: () => getPlatformEnv,
@@ -34421,7 +34422,6 @@ __export(src_exports, {
   isNodeBackendFramework: () => isNodeBackendFramework,
   isNodeEntrypoint: () => isNodeEntrypoint,
   isPackageInstalled: () => isPackageInstalled,
-  isPythonEntrypoint: () => isPythonEntrypoint,
   isPythonFramework: () => isPythonFramework,
   isQueueBackedService: () => isQueueBackedService,
   isQueueTriggeredService: () => isQueueTriggeredService,
@@ -35796,6 +35796,12 @@ var NODE_VERSIONS = [
   })
 ];
 var BUN_VERSIONS = [
+  new BunVersion({
+    major: 1,
+    minor: 4,
+    range: "1.4.x",
+    runtime: "bun1.4.x"
+  }),
   new BunVersion({
     major: 1,
     range: "1.x",
@@ -35885,11 +35891,15 @@ async function getSupportedNodeVersion(engineRange, isAuto = false, availableVer
 function getSupportedBunVersion(engineRange) {
   if ((0, import_semver.validRange)(engineRange)) {
     const selected = BUN_VERSIONS.find((version) => {
-      return (0, import_semver.intersects)(version.range, engineRange);
+      if (!(0, import_semver.intersects)(version.range, engineRange)) {
+        return false;
+      }
+      return version.minor === void 0 ? true : !(0, import_semver.intersects)(`<${version.major}.${version.minor}.0`, engineRange);
     });
     if (selected) {
       return new BunVersion({
         major: selected.major,
+        minor: selected.minor,
         range: selected.range,
         runtime: selected.runtime
       });
@@ -37314,6 +37324,7 @@ function getEnvForPackageManager({
   cliType,
   lockfileVersion,
   packageJsonPackageManager,
+  nodeVersion,
   env,
   packageJsonEngines,
   turboSupportsCorepackHome,
@@ -37333,6 +37344,7 @@ function getEnvForPackageManager({
     lockfileVersion,
     corepackPackageManager: packageJsonPackageManager,
     corepackEnabled,
+    nodeVersion,
     packageJsonEngines,
     projectCreatedAt
   });
@@ -37348,14 +37360,23 @@ function getEnvForPackageManager({
   const newEnv = {
     ...env
   };
+  const bunRuntimePath = nodeVersion && isBunVersion(nodeVersion) ? `/bun${nodeVersion.major}${nodeVersion.minor === void 0 ? "" : `.${nodeVersion.minor}`}` : void 0;
   const alreadyInPath = (newPath2) => {
     const oldPath = env.PATH ?? "";
     return oldPath.split(import_path6.default.delimiter).includes(newPath2);
   };
-  if (newPath && !alreadyInPath(newPath)) {
+  const hasSelectedBunPath = cliType === "bun" && nodeVersion === void 0 && (env.PATH ?? "").split(import_path6.default.delimiter).some((segment) => /^\/bun\d+(?:\.\d+)?$/.test(segment));
+  const pathsToPrepend = Array.from(
+    new Set(
+      [newPath, bunRuntimePath].filter((value) => !!value)
+    )
+  ).filter(
+    (value) => !alreadyInPath(value) && !(hasSelectedBunPath && value === newPath)
+  );
+  if (pathsToPrepend.length > 0) {
     const oldPath = env.PATH + "";
-    newEnv.PATH = `${newPath}${import_path6.default.delimiter}${oldPath}`;
-    if (detectedLockfile && detectedPackageManager) {
+    newEnv.PATH = `${pathsToPrepend.join(import_path6.default.delimiter)}${oldPath ? import_path6.default.delimiter : ""}${oldPath}`;
+    if (newPath && pathsToPrepend.includes(newPath) && detectedLockfile && detectedPackageManager) {
       const detectedV9PnpmLockfile = detectedLockfile === "pnpm-lock.yaml" && lockfileVersion === 9;
       const pnpm10UsingPackageJsonPackageManager = detectedPackageManager === "pnpm@10.x" && packageJsonPackageManager;
       if (pnpm10UsingPackageJsonPackageManager) {
@@ -37451,6 +37472,7 @@ function getPathOverrideForPackageManager({
   lockfileVersion,
   corepackPackageManager,
   corepackEnabled = true,
+  nodeVersion,
   packageJsonEngines,
   projectCreatedAt
 }) {
@@ -37478,6 +37500,14 @@ function getPathOverrideForPackageManager({
       );
     }
   }
+  if (cliType === "bun" && detectedPackageManger && nodeVersion && isBunVersion(nodeVersion)) {
+    const minor = nodeVersion.minor;
+    return {
+      ...detectedPackageManger,
+      path: `/bun${nodeVersion.major}${minor === void 0 ? "" : `.${minor}`}`,
+      detectedPackageManager: `bun@${nodeVersion.range}`
+    };
+  }
   return detectedPackageManger ?? NO_OVERRIDE;
 }
 function checkEnginesPnpmAgainstDetected(enginesPnpm, detectedPackageManger) {
@@ -37788,8 +37818,67 @@ var installDependencies = (0, import_util6.deprecate)(
   "installDependencies() is deprecated. Please use runNpmInstall() instead."
 );
+// src/fs/bun-helpers.ts
+var import_os2 = require("os");
+var import_path7 = require("path");
+var import_child_process = require("child_process");
+function spawnAsync2(command, args, options) {
+  return new Promise((resolve, reject) => {
+    const child = (0, import_child_process.spawn)(command, args, options);
+    child.once("error", reject);
+    child.once("close", resolve);
+  });
+}
+async function getOrCreateBunBinary() {
+  const bunCommand = process.platform === "win32" ? "bun.exe" : "bun";
+  const installPath = (0, import_path7.join)((0, import_os2.homedir)(), ".bun", "bin", bunCommand);
+  try {
+    if (await spawnAsync2(bunCommand, ["--version"], { stdio: "ignore" }) === 0) {
+      debug("Bun already installed and available in PATH");
+      return bunCommand;
+    }
+  } catch {
+    debug("Bun not found in PATH");
+  }
+  try {
+    if (await spawnAsync2(installPath, ["--version"], { stdio: "ignore" }) === 0) {
+      debug("Bun already installed in default location");
+      return installPath;
+    }
+  } catch {
+    debug("Bun not found in default location");
+  }
+  console.log("Installing Bun...");
+  try {
+    const exitCode = process.platform === "win32" ? await spawnAsync2(
+      "powershell",
+      ["-c", "irm bun.sh/install.ps1 | iex"],
+      { stdio: "inherit" }
+    ) : await spawnAsync2(
+      "bash",
+      ["-c", "curl -fsSL https://bun.sh/install | bash"],
+      { stdio: "inherit" }
+    );
+    if (exitCode !== 0) {
+      throw new Error(`Installation script exited with code ${exitCode}`);
+    }
+  } catch (error) {
+    throw new Error(`Failed to install Bun: ${error}`);
+  }
+  try {
+    if (await spawnAsync2(installPath, ["--version"], { stdio: "ignore" }) === 0) {
+      debug("Bun was installed successfully");
+      return installPath;
+    }
+  } catch {
+  }
+  throw new Error(
+    "Bun installation failed. Please install manually and try again."
+  );
+}
 // src/get-ignore-filter.ts
-var import_path7 = __toESM(require("path"));
+var import_path8 = __toESM(require("path"));
 var import_fs_extra8 = __toESM(require_lib());
 var import_ignore = __toESM(require_ignore());
 function isCodedError(error) {
@@ -37809,12 +37898,12 @@ async function get_ignore_filter_default(downloadPath, rootDirectory) {
       throw error;
     }
   };
-  const vercelIgnorePath = import_path7.default.join(
+  const vercelIgnorePath = import_path8.default.join(
     downloadPath,
     rootDirectory || "",
     ".vercelignore"
   );
-  const nowIgnorePath = import_path7.default.join(
+  const nowIgnorePath = import_path8.default.join(
     downloadPath,
     rootDirectory || "",
     ".nowignore"
@@ -37979,22 +38068,22 @@ function getExperimentalServiceUrlEnvVars(options) {
 }
 // src/hard-link-dir.ts
-var import_path8 = __toESM(require("path"));
+var import_path9 = __toESM(require("path"));
 var import_fs2 = require("fs");
 async function hardLinkDir(src, destDirs) {
   if (destDirs.length === 0)
     return;
-  destDirs = destDirs.filter((destDir) => import_path8.default.relative(destDir, src) !== "");
+  destDirs = destDirs.filter((destDir) => import_path9.default.relative(destDir, src) !== "");
   const files = await import_fs2.promises.readdir(src);
   await Promise.all(
     files.map(async (file) => {
       if (file === "node_modules")
         return;
-      const srcFile = import_path8.default.join(src, file);
+      const srcFile = import_path9.default.join(src, file);
       if ((await import_fs2.promises.lstat(srcFile)).isDirectory()) {
         const destSubdirs = await Promise.all(
           destDirs.map(async (destDir) => {
-            const destSubdir = import_path8.default.join(destDir, file);
+            const destSubdir = import_path9.default.join(destDir, file);
             try {
               await import_fs2.promises.mkdir(destSubdir, { recursive: true });
             } catch (err) {
@@ -38009,7 +38098,7 @@ async function hardLinkDir(src, destDirs) {
       }
       await Promise.all(
         destDirs.map(async (destDir) => {
-          const destFile = import_path8.default.join(destDir, file);
+          const destFile = import_path9.default.join(destDir, file);
           try {
             await linkOrCopyFile(srcFile, destFile);
           } catch (err) {
@@ -38028,7 +38117,7 @@ async function linkOrCopyFile(srcFile, destFile) {
     await linkOrCopy(srcFile, destFile);
   } catch (err) {
     if (err.code === "ENOENT") {
-      await import_fs2.promises.mkdir(import_path8.default.dirname(destFile), { recursive: true });
+      await import_fs2.promises.mkdir(import_path9.default.dirname(destFile), { recursive: true });
       await linkOrCopy(srcFile, destFile);
       return;
     }
@@ -38048,10 +38137,10 @@ async function linkOrCopy(srcFile, destFile) {
 }
 // src/validate-npmrc.ts
-var import_path9 = require("path");
+var import_path10 = require("path");
 var import_promises = require("fs/promises");
 async function validateNpmrc(cwd) {
-  const npmrc = await (0, import_promises.readFile)((0, import_path9.join)(cwd, ".npmrc"), "utf-8").catch((err) => {
+  const npmrc = await (0, import_promises.readFile)((0, import_path10.join)(cwd, ".npmrc"), "utf-8").catch((err) => {
     if (err.code !== "ENOENT")
       throw err;
   });
@@ -38104,7 +38193,7 @@ async function getProvidedRuntime() {
 }
 // src/should-serve.ts
-var import_path10 = require("path");
+var import_path11 = require("path");
 var shouldServe = ({
   entrypoint,
   files,
@@ -38115,7 +38204,7 @@ var shouldServe = ({
   if (entrypoint === requestPath && hasProp2(files, entrypoint)) {
     return true;
   }
-  const { dir, name } = (0, import_path10.parse)(entrypoint);
+  const { dir, name } = (0, import_path11.parse)(entrypoint);
   if (name === "index" && dir === requestPath && hasProp2(files, entrypoint)) {
     return true;
   }
@@ -38378,21 +38467,21 @@ var packageManifestSchema = {
 // src/package-manifest.ts
 var import_fs3 = __toESM(require("fs"));
-var import_path11 = require("path");
+var import_path12 = require("path");
 var MANIFEST_VERSION = "20260304";
 var MANIFEST_FILENAME = "package-manifest.json";
 function manifestPath(runtime) {
-  return (0, import_path11.join)(".vercel", runtime, MANIFEST_FILENAME);
+  return (0, import_path12.join)(".vercel", runtime, MANIFEST_FILENAME);
 }
 async function writeProjectManifest(manifest, workPath, runtime) {
-  const outPath = (0, import_path11.join)(workPath, manifestPath(runtime));
-  await import_fs3.default.promises.mkdir((0, import_path11.dirname)(outPath), { recursive: true });
+  const outPath = (0, import_path12.join)(workPath, manifestPath(runtime));
+  await import_fs3.default.promises.mkdir((0, import_path12.dirname)(outPath), { recursive: true });
   await import_fs3.default.promises.writeFile(outPath, JSON.stringify(manifest, null, 2));
 }
 function createDiagnostics(runtime) {
   return async ({ workPath }) => {
     try {
-      const filePath = (0, import_path11.join)(workPath, manifestPath(runtime));
+      const filePath = (0, import_path12.join)(workPath, manifestPath(runtime));
       const data = await import_fs3.default.promises.readFile(filePath, "utf-8");
       return {
         [MANIFEST_FILENAME]: new FileBlob({ data })
@@ -38405,7 +38494,7 @@ function createDiagnostics(runtime) {
 // src/node-diagnostics.ts
 var import_fs4 = __toESM(require("fs"));
-var import_path12 = __toESM(require("path"));
+var import_path13 = __toESM(require("path"));
 var import_js_yaml3 = __toESM(require_js_yaml2());
 var import_parsers = __toESM(require_lib4());
 function classifySource(resolvedUrl) {
@@ -38717,12 +38806,12 @@ async function readPackageJson(startDir) {
   for (; ; ) {
     try {
       const content = await import_fs4.default.promises.readFile(
-        import_path12.default.join(current, "package.json"),
+        import_path13.default.join(current, "package.json"),
         "utf-8"
       );
       return JSON.parse(content);
     } catch {
-      const parent = import_path12.default.dirname(current);
+      const parent = import_path13.default.dirname(current);
       if (parent === current)
         return null;
       current = parent;
@@ -38810,7 +38899,7 @@ async function generateProjectManifest({
       for (const filename of [".node-version", ".nvmrc"]) {
         try {
           const val = await import_fs4.default.promises.readFile(
-            import_path12.default.join(workPath, filename),
+            import_path13.default.join(workPath, filename),
             "utf-8"
           );
           const trimmed = val.trim();
@@ -39387,24 +39476,8 @@ function shouldUseExperimentalBackends(framework) {
   return isExperimentalBackendsEnabled() && isBackendFramework(framework);
 }
-// src/python.ts
-var import_fs6 = __toESM(require("fs"));
-var import_python_analysis = require("@vercel/python-analysis");
-async function isPythonEntrypoint(file) {
-  try {
-    const fsPath = file.fsPath;
-    if (!fsPath)
-      return false;
-    const content = await import_fs6.default.promises.readFile(fsPath, "utf-8");
-    return await (0, import_python_analysis.findAppOrHandler)(content) !== null;
-  } catch (err) {
-    debug(`Failed to check Python entrypoint: ${err}`);
-    return false;
-  }
-}
 // src/node-entrypoint.ts
-var import_fs7 = __toESM(require("fs"));
+var import_fs6 = __toESM(require("fs"));
 // ../../node_modules/.pnpm/es-module-lexer@1.5.0/node_modules/es-module-lexer/dist/lexer.js
 var ImportType;
@@ -39583,7 +39656,7 @@ async function isNodeEntrypoint(file) {
     const fsPath = file.fsPath;
     if (!fsPath)
       return true;
-    const content = await import_fs7.default.promises.readFile(fsPath, "utf-8");
+    const content = await import_fs6.default.promises.readFile(fsPath, "utf-8");
     if (!content.trim())
       return false;
     const { names, esmUnparsed } = await getHandlerExportNames(content);
@@ -39836,6 +39909,7 @@ var SUPPORTED_AL2023_RUNTIMES = [
   "python3.13",
   "python3.14",
   "ruby3.3",
+  "bun1.4.x",
   "bun1.x",
   "executable"
 ];
@@ -40176,11 +40250,11 @@ function validateFrameworkVersion(framework) {
 }
 // src/deserialize/hydrate-files-map.ts
-var import_path13 = require("path");
+var import_path14 = require("path");
 async function hydrateFilesMap(files, filesMap, repoRootPath, fileFsRefsCache) {
   for (const [funcPath, projectPath] of Object.entries(filesMap)) {
     files[funcPath] = await fileFsRefCached(
-      (0, import_path13.join)(repoRootPath, projectPath),
+      (0, import_path14.join)(repoRootPath, projectPath),
       fileFsRefsCache
     );
   }
@@ -40195,7 +40269,7 @@ async function fileFsRefCached(fsPath, cache) {
 }
 // src/deserialize/create-functions-iterator.ts
-var import_path14 = require("path");
+var import_path15 = require("path");
 var import_fs_extra9 = __toESM(require_lib());
 var SUFFIX = ".func";
 async function* createFunctionsIterator(dir, root = dir) {
@@ -40209,11 +40283,11 @@ async function* createFunctionsIterator(dir, root = dir) {
     paths = [];
   }
   for (const path8 of paths) {
-    const abs = (0, import_path14.join)(dir, path8);
+    const abs = (0, import_path15.join)(dir, path8);
     const s = await (0, import_fs_extra9.stat)(abs);
     if (s.isDirectory()) {
       if (path8.endsWith(SUFFIX)) {
-        yield (0, import_path14.relative)(root, abs.substring(0, abs.length - SUFFIX.length));
+        yield (0, import_path15.relative)(root, abs.substring(0, abs.length - SUFFIX.length));
       } else {
         yield* createFunctionsIterator(abs, root);
       }
@@ -40234,8 +40308,8 @@ async function maybeReadJSON(path8) {
 }
 // src/deserialize/deserialize-build-output.ts
-var fs11 = __toESM(require_lib());
-var import_path15 = require("path");
+var fs10 = __toESM(require_lib());
+var import_path16 = require("path");
 // src/deserialize/deserialize-edge-function.ts
 async function deserializeEdgeFunction(files, config, repoRootPath, fileFsRefsCache) {
@@ -40298,14 +40372,14 @@ function applyOutputOverrides(output, overrides, warn) {
 async function deserializePrerenderFallback(prerenderConfigPath, fallbackConfig) {
   if (typeof fallbackConfig === "string") {
     return file_fs_ref_default.fromFsPath({
-      fsPath: (0, import_path15.join)((0, import_path15.dirname)(prerenderConfigPath), fallbackConfig)
+      fsPath: (0, import_path16.join)((0, import_path16.dirname)(prerenderConfigPath), fallbackConfig)
     });
   }
   if (fallbackConfig) {
     return file_fs_ref_default.fromFsPath({
       mode: fallbackConfig.mode,
       contentType: fallbackConfig.contentType,
-      fsPath: (0, import_path15.join)((0, import_path15.dirname)(prerenderConfigPath), fallbackConfig.fsPath)
+      fsPath: (0, import_path16.join)((0, import_path16.dirname)(prerenderConfigPath), fallbackConfig.fsPath)
     });
   }
   return null;
@@ -40391,7 +40465,7 @@ async function deserializeBuildOutput(options) {
     getMeta
   } = options;
   let hasServerActions = false;
-  const configPath = (0, import_path15.join)(outputDir, "config.json");
+  const configPath = (0, import_path16.join)(outputDir, "config.json");
   const config = await maybeReadJSON(configPath);
   if (!config) {
     throw new Error(`Config file was not found at "${configPath}"`);
@@ -40402,8 +40476,8 @@ async function deserializeBuildOutput(options) {
     );
   }
   validateDeploymentId(config.deploymentId);
-  const flags = await maybeReadJSON((0, import_path15.join)(outputDir, "flags.json"));
-  const staticDir = (0, import_path15.join)(outputDir, "static");
+  const flags = await maybeReadJSON((0, import_path16.join)(outputDir, "flags.json"));
+  const staticDir = (0, import_path16.join)(outputDir, "static");
   const output = await glob("**", {
     cwd: staticDir,
     follow: true
@@ -40411,19 +40485,19 @@ async function deserializeBuildOutput(options) {
   applyOutputOverrides(output, config.overrides, warn);
   const fileFsRefsCache = /* @__PURE__ */ new Map();
   const prerenders = /* @__PURE__ */ new Map();
-  const functionsDir = (0, import_path15.join)(outputDir, "functions");
+  const functionsDir = (0, import_path16.join)(outputDir, "functions");
   const functionSymlinks = /* @__PURE__ */ new Map();
   for await (const path8 of createFunctionsIterator(functionsDir)) {
     let lambda = void 0;
-    const fnDir = (0, import_path15.join)(functionsDir, `${path8}.func`);
+    const fnDir = (0, import_path16.join)(functionsDir, `${path8}.func`);
     try {
-      const link = await fs11.readlink(fnDir);
-      const target = (0, import_path15.join)((0, import_path15.dirname)(path8), link).slice(0, -5);
+      const link = await fs10.readlink(fnDir);
+      const target = (0, import_path16.join)((0, import_path16.dirname)(path8), link).slice(0, -5);
       functionSymlinks.set(path8, target);
     } catch (err) {
       if (err.code !== "EINVAL")
         throw err;
-      const funcConfigPath = (0, import_path15.join)(fnDir, ".vc-config.json");
+      const funcConfigPath = (0, import_path16.join)(fnDir, ".vc-config.json");
       const funcConfig = await maybeReadJSON(
         funcConfigPath
       );
@@ -40457,7 +40531,7 @@ async function deserializeBuildOutput(options) {
         );
       }
     }
-    const prerenderConfigPath = (0, import_path15.join)(
+    const prerenderConfigPath = (0, import_path16.join)(
       functionsDir,
       `${path8}.prerender-config.json`
     );
@@ -40557,13 +40631,13 @@ function validatePrerender(prerender) {
 }
 // src/collect-build-result/get-content-type.ts
-var import_path16 = require("path");
+var import_path17 = require("path");
 var import_mime_types = __toESM(require_mime_types());
 function getContentType(path8) {
   if (path8.endsWith(".html")) {
     return "text/html; charset=utf-8";
   }
-  return import_mime_types.default.contentType((0, import_path16.extname)(path8)) || "application/octet-stream";
+  return import_mime_types.default.contentType((0, import_path17.extname)(path8)) || "application/octet-stream";
 }
 // src/collect-build-result/file-to-build-output-file.ts
@@ -40717,6 +40791,7 @@ function getExtendedPayload({
   getNodeBinPath,
   getNodeBinPaths,
   getNodeVersion,
+  getOrCreateBunBinary,
   getPackageJson,
   getPathForPackageManager,
   getPlatformEnv,
@@ -40752,7 +40827,6 @@ function getExtendedPayload({
   isNodeBackendFramework,
   isNodeEntrypoint,
   isPackageInstalled,
-  isPythonEntrypoint,
   isPythonFramework,
   isQueueBackedService,
   isQueueTriggeredService,