npm - @vercel/build-utils - Versions diffs - 14.1.1 → 14.3.0 - Mend

@vercel/build-utils 14.1.1 → 14.3.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 (13) hide show

package/CHANGELOG.md +19 -0
package/build.mjs +3 -11
package/dist/fs/run-user-scripts.d.ts +19 -10
package/dist/fs/run-user-scripts.js +266 -85
package/dist/index.d.ts +0 -1
package/dist/index.js +586 -416
package/dist/service-path-utils.d.ts +2 -0
package/dist/service-path-utils.js +13 -2
package/dist/types.d.ts +24 -6
package/package.json +4 -5
package/turbo.json +43 -7
package/dist/python.d.ts +0 -10
package/dist/python.js +0 -52

package/dist/index.js CHANGED Viewed

@@ -2024,11 +2024,11 @@ var require_stream_readable = __commonJS({
 var require_stream_transform = __commonJS({
   "../../node_modules/.pnpm/readable-stream@2.3.8/node_modules/readable-stream/lib/_stream_transform.js"(exports, module2) {
     "use strict";
-    module2.exports = Transform;
+    module2.exports = Transform2;
     var Duplex = require_stream_duplex();
     var util = Object.create(require_util());
     util.inherits = require_inherits();
-    util.inherits(Transform, Duplex);
+    util.inherits(Transform2, Duplex);
     function afterTransform(er, data) {
       var ts = this._transformState;
       ts.transforming = false;
@@ -2047,9 +2047,9 @@ var require_stream_transform = __commonJS({
         this._read(rs.highWaterMark);
       }
     }
-    function Transform(options) {
-      if (!(this instanceof Transform))
-        return new Transform(options);
+    function Transform2(options) {
+      if (!(this instanceof Transform2))
+        return new Transform2(options);
       Duplex.call(this, options);
       this._transformState = {
         afterTransform: afterTransform.bind(this),
@@ -2079,14 +2079,14 @@ var require_stream_transform = __commonJS({
         done(this, null, null);
       }
     }
-    Transform.prototype.push = function(chunk, encoding) {
+    Transform2.prototype.push = function(chunk, encoding) {
       this._transformState.needTransform = false;
       return Duplex.prototype.push.call(this, chunk, encoding);
     };
-    Transform.prototype._transform = function(chunk, encoding, cb) {
+    Transform2.prototype._transform = function(chunk, encoding, cb) {
       throw new Error("_transform() is not implemented");
     };
-    Transform.prototype._write = function(chunk, encoding, cb) {
+    Transform2.prototype._write = function(chunk, encoding, cb) {
       var ts = this._transformState;
       ts.writecb = cb;
       ts.writechunk = chunk;
@@ -2097,7 +2097,7 @@ var require_stream_transform = __commonJS({
           this._read(rs.highWaterMark);
       }
     };
-    Transform.prototype._read = function(n) {
+    Transform2.prototype._read = function(n) {
       var ts = this._transformState;
       if (ts.writechunk !== null && ts.writecb && !ts.transforming) {
         ts.transforming = true;
@@ -2106,7 +2106,7 @@ var require_stream_transform = __commonJS({
         ts.needTransform = true;
       }
     };
-    Transform.prototype._destroy = function(err, cb) {
+    Transform2.prototype._destroy = function(err, cb) {
       var _this2 = this;
       Duplex.prototype._destroy.call(this, err, function(err2) {
         cb(err2);
@@ -2132,14 +2132,14 @@ var require_stream_passthrough = __commonJS({
   "../../node_modules/.pnpm/readable-stream@2.3.8/node_modules/readable-stream/lib/_stream_passthrough.js"(exports, module2) {
     "use strict";
     module2.exports = PassThrough;
-    var Transform = require_stream_transform();
+    var Transform2 = require_stream_transform();
     var util = Object.create(require_util());
     util.inherits = require_inherits();
-    util.inherits(PassThrough, Transform);
+    util.inherits(PassThrough, Transform2);
     function PassThrough(options) {
       if (!(this instanceof PassThrough))
         return new PassThrough(options);
-      Transform.call(this, options);
+      Transform2.call(this, options);
     }
     PassThrough.prototype._transform = function(chunk, encoding, cb) {
       cb(null, chunk);
@@ -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,8 +6015,8 @@ 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 Transform = require("stream").Transform;
+    var fs11 = require("fs");
+    var Transform2 = require("stream").Transform;
     var PassThrough = require("stream").PassThrough;
     var zlib = require("zlib");
     var util = require("util");
@@ -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);
@@ -6540,18 +6540,18 @@ var require_yazl = __commonJS({
       buffer.writeUInt32LE(low, offset);
       buffer.writeUInt32LE(high, offset + 4);
     }
-    util.inherits(ByteCounter, Transform);
+    util.inherits(ByteCounter, Transform2);
     function ByteCounter(options) {
-      Transform.call(this, options);
+      Transform2.call(this, options);
       this.byteCount = 0;
     }
     ByteCounter.prototype._transform = function(chunk, encoding, cb) {
       this.byteCount += chunk.length;
       cb(null, chunk);
     };
-    util.inherits(Crc32Watcher, Transform);
+    util.inherits(Crc32Watcher, Transform2);
     function Crc32Watcher(options) {
-      Transform.call(this, options);
+      Transform2.call(this, options);
       this.crc32 = 0;
     }
     Crc32Watcher.prototype._transform = function(chunk, encoding, cb) {
@@ -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());
@@ -34375,6 +34375,8 @@ __export(src_exports, {
   getInternalServiceCronPath: () => getInternalServiceCronPath,
   getInternalServiceCronPathPrefix: () => getInternalServiceCronPathPrefix,
   getInternalServiceFunctionPath: () => getInternalServiceFunctionPath,
+  getInternalServiceWorkerPath: () => getInternalServiceWorkerPath,
+  getInternalServiceWorkerPathPrefix: () => getInternalServiceWorkerPathPrefix,
   getLambdaByOutputPath: () => getLambdaByOutputPath,
   getLambdaEnvironment: () => getLambdaEnvironment,
   getLambdaOptionsFromFunction: () => getLambdaOptionsFromFunction,
@@ -34422,7 +34424,6 @@ __export(src_exports, {
   isNodeBackendFramework: () => isNodeBackendFramework,
   isNodeEntrypoint: () => isNodeEntrypoint,
   isPackageInstalled: () => isPackageInstalled,
-  isPythonEntrypoint: () => isPythonEntrypoint,
   isPythonFramework: () => isPythonFramework,
   isQueueBackedService: () => isQueueBackedService,
   isQueueTriggeredService: () => isQueueTriggeredService,
@@ -35661,6 +35662,7 @@ var import_path6 = __toESM(require("path"));
 var import_async_sema4 = __toESM(require_async_sema());
 var import_cross_spawn = __toESM(require_cross_spawn());
 var import_semver2 = __toESM(require_semver2());
+var import_stream2 = require("stream");
 var import_util6 = require("util");
 // src/fs/node-version.ts
@@ -36954,7 +36956,8 @@ async function scanParentDirs(destPath, readPackageJson2 = false, base = "/") {
       bunLockBinPath,
       vltLockPath
     ],
-    packageJsonPackageManager
+    packageJsonPackageManager,
+    packageJsonDevEngines
   } = await walkParentDirsMulti({
     base,
     start: destPath,
@@ -37021,6 +37024,7 @@ async function scanParentDirs(destPath, readPackageJson2 = false, base = "/") {
     cliType,
     packageJson,
     packageJsonPackageManager,
+    packageJsonDevEngines,
     lockfilePath,
     lockfileVersion,
     packageJsonPath,
@@ -37136,6 +37140,7 @@ async function walkParentDirsMulti({
   filenames
 }) {
   let packageManager;
+  let devEngines;
   for (const dir of traverseUpDirectories({ start, base })) {
     const fullPaths = filenames.map((f) => import_path6.default.join(dir, f));
     const existResults = await Promise.all(
@@ -37147,14 +37152,22 @@ async function walkParentDirsMulti({
     if (packageJson?.packageManager) {
       packageManager = packageJson.packageManager;
     }
+    if (packageJson?.devEngines) {
+      devEngines = packageJson.devEngines;
+    }
     if (foundOneOrMore) {
       return {
         paths: fullPaths.map((f, i) => existResults[i] ? f : void 0),
-        packageJsonPackageManager: packageManager
+        packageJsonPackageManager: packageManager,
+        packageJsonDevEngines: devEngines
       };
     }
   }
-  return { paths: [], packageJsonPackageManager: packageManager };
+  return {
+    paths: [],
+    packageJsonPackageManager: packageManager,
+    packageJsonDevEngines: devEngines
+  };
 }
 function isSet(v) {
   return v?.constructor?.name === "Set";
@@ -37191,6 +37204,29 @@ function getInstallCommandForPackageManager(packageManager, args) {
       };
   }
 }
+function stripPnpmVersionFooter(line) {
+  return line.replace(/ using pnpm v\d+\.\d+\.\d+(?=\r?$)/, "");
+}
+function createPnpmOutputFilter(destination) {
+  let incompleteLine = "";
+  return new import_stream2.Transform({
+    transform(chunk, _encoding, callback) {
+      const lines = `${incompleteLine}${chunk.toString()}`.split("\n");
+      incompleteLine = lines.pop() ?? "";
+      for (const line of lines) {
+        destination.write(`${stripPnpmVersionFooter(line)}
+`);
+      }
+      callback();
+    },
+    flush(callback) {
+      if (incompleteLine) {
+        destination.write(stripPnpmVersionFooter(incompleteLine));
+      }
+      callback();
+    }
+  });
+}
 async function runInstallCommand({
   packageManager,
   args,
@@ -37202,8 +37238,9 @@ async function runInstallCommand({
   if (process.env.NPM_ONLY_PRODUCTION) {
     commandArguments.push("--production");
   }
-  opts.outputStream = output?.stdout;
-  opts.errorStream = output?.stderr;
+  const shouldFilterPnpmOutput = packageManager === "pnpm";
+  opts.outputStream = shouldFilterPnpmOutput ? createPnpmOutputFilter(output?.stdout ?? process.stdout) : output?.stdout;
+  opts.errorStream = shouldFilterPnpmOutput ? output?.stderr ?? process.stderr : output?.stderr;
   await spawnAsync(packageManager, commandArguments, opts);
 }
 function initializeSet(set) {
@@ -37247,6 +37284,7 @@ async function runNpmInstall(destPath, args = [], spawnOpts, meta, projectCreate
       packageJson,
       lockfileVersion,
       packageJsonPackageManager,
+      packageJsonDevEngines,
       turboSupportsCorepackHome
     } = await scanParentDirs(destPath, true);
     if (!packageJsonPath) {
@@ -37285,12 +37323,6 @@ async function runNpmInstall(destPath, args = [], spawnOpts, meta, projectCreate
       }
     }
     const installTime = Date.now();
-    if (output?.stdout) {
-      output.stdout.write("Installing dependencies...\n");
-    } else {
-      console.log("Installing dependencies...");
-    }
-    debug(`Installing to ${destPath}`);
     const opts = { cwd: destPath, ...spawnOpts };
     const env = cloneEnv(opts.env || process.env);
     delete env.NODE_ENV;
@@ -37298,11 +37330,26 @@ async function runNpmInstall(destPath, args = [], spawnOpts, meta, projectCreate
       cliType,
       lockfileVersion,
       packageJsonPackageManager,
+      packageJsonDevEngines,
       env,
       packageJsonEngines: packageJson?.engines,
       turboSupportsCorepackHome,
       projectCreatedAt
     });
+    const packageManager = getPackageManagerDisplayName({
+      cliType,
+      lockfileVersion,
+      packageJsonPackageManager,
+      env: opts.env
+    });
+    const installMessage = `Installing dependencies with ${packageManager}`;
+    if (output?.stdout) {
+      output.stdout.write(`${installMessage}
+`);
+    } else {
+      console.log(installMessage);
+    }
+    debug(`Installing to ${destPath}`);
     const maySeeDynamicRequireYarnBug = process.env?.ENABLE_EXPERIMENTAL_COREPACK && packageJson?.packageManager?.startsWith("yarn") && packageJson?.type === "module";
     if (maySeeDynamicRequireYarnBug) {
       console.warn(
@@ -37321,10 +37368,42 @@ async function runNpmInstall(destPath, args = [], spawnOpts, meta, projectCreate
     runNpmInstallSema.release();
   }
 }
+function getPackageManagerDisplayName({
+  cliType,
+  lockfileVersion,
+  packageJsonPackageManager,
+  env
+}) {
+  const versionResult = import_cross_spawn.default.sync(cliType, ["--version"], {
+    env,
+    encoding: "utf8"
+  });
+  const version = versionResult.status === 0 ? versionResult.stdout.trim() : "";
+  if (version) {
+    return `${cliType} ${version}`;
+  }
+  if (packageJsonPackageManager && env.ENABLE_EXPERIMENTAL_COREPACK) {
+    return packageJsonPackageManager.replace("@", " ");
+  }
+  if (cliType === "pnpm") {
+    const selectedPath = env.PATH?.split(import_path6.default.delimiter).find(
+      (segment) => /^\/pnpm\d+\/node_modules\/\.bin$/.test(segment)
+    );
+    const major = selectedPath?.match(/^\/pnpm(\d+)\//)?.[1];
+    if (major) {
+      return `pnpm ${major}`;
+    }
+  }
+  if (cliType === "yarn") {
+    return detectYarnVersion(lockfileVersion).replace("@", " ").replace(/\.x$/, "");
+  }
+  return cliType;
+}
 function getEnvForPackageManager({
   cliType,
   lockfileVersion,
   packageJsonPackageManager,
+  packageJsonDevEngines,
   nodeVersion,
   env,
   packageJsonEngines,
@@ -37344,6 +37423,7 @@ function getEnvForPackageManager({
     cliType,
     lockfileVersion,
     corepackPackageManager: packageJsonPackageManager,
+    packageJsonDevEngines,
     corepackEnabled,
     nodeVersion,
     packageJsonEngines,
@@ -37377,28 +37457,6 @@ function getEnvForPackageManager({
   if (pathsToPrepend.length > 0) {
     const oldPath = env.PATH + "";
     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) {
-        const versionString = cliType === "pnpm" ? `version ${lockfileVersion} ` : "";
-        console.log(
-          `Detected \`${detectedLockfile}\` ${versionString}generated by ${detectedPackageManager} with package.json#packageManager ${packageJsonPackageManager}`
-        );
-      } else if (detectedV9PnpmLockfile) {
-        const otherVersion = detectedPackageManager === "pnpm@10.x" ? `pnpm@9.x` : `pnpm@10.x`;
-        console.log(
-          `Detected \`${detectedLockfile}\` ${lockfileVersion} which may be generated by pnpm@9.x or pnpm@10.x
-Using ${detectedPackageManager} based on project creation date
-To use ${otherVersion}, manually opt in using corepack (https://vercel.com/docs/deployments/configure-a-build#corepack)`
-        );
-      } else {
-        const versionString = cliType === "pnpm" ? `version ${lockfileVersion} ` : "";
-        console.log(
-          `Detected \`${detectedLockfile}\` ${versionString}generated by ${detectedPackageManager}`
-        );
-      }
-    }
   }
   if (cliType === "yarn" && !env.YARN_NODE_LINKER) {
     newEnv.YARN_NODE_LINKER = "node-modules";
@@ -37406,7 +37464,29 @@ To use ${otherVersion}, manually opt in using corepack (https://vercel.com/docs/
   return newEnv;
 }
 var PNPM_10_PREFERRED_AT = /* @__PURE__ */ new Date("2025-02-27T20:00:00Z");
-function detectPnpmVersion(lockfileVersion, projectCreatedAt) {
+var PNPM_11_PREFERRED_AT = /* @__PURE__ */ new Date("2026-08-19T20:00:00Z");
+var INSTALLED_PNPM_MAJORS = [11, 10, 9, 8, 7, 6];
+function pnpmPathOverride(major) {
+  return {
+    path: `/pnpm${major}/node_modules/.bin`,
+    detectedLockfile: "pnpm-lock.yaml",
+    detectedPackageManager: `pnpm@${major}.x`,
+    pnpmVersionRange: `${major}.x`
+  };
+}
+function isPnpmMajorAvailable(major) {
+  if (major <= 10) {
+    return true;
+  }
+  return import_fs_extra7.default.existsSync(`/pnpm${major}`);
+}
+function nodeSupportsPnpm11Default(nodeVersion) {
+  if (!nodeVersion || isBunVersion(nodeVersion)) {
+    return true;
+  }
+  return nodeVersion.major >= 22;
+}
+function detectPnpmVersion(lockfileVersion, projectCreatedAt, nodeVersion) {
   switch (true) {
     case lockfileVersion === void 0:
       return "not found";
@@ -37419,8 +37499,13 @@ function detectPnpmVersion(lockfileVersion, projectCreatedAt) {
     case lockfileVersion === 7:
       return "pnpm 9";
     case lockfileVersion === 9: {
-      const projectPrefersPnpm10 = projectCreatedAt && projectCreatedAt >= PNPM_10_PREFERRED_AT.getTime();
-      return projectPrefersPnpm10 ? "pnpm 10" : "pnpm 9";
+      if (projectCreatedAt && projectCreatedAt >= PNPM_11_PREFERRED_AT.getTime() && nodeSupportsPnpm11Default(nodeVersion) && isPnpmMajorAvailable(11)) {
+        return "pnpm 11";
+      }
+      if (projectCreatedAt && projectCreatedAt >= PNPM_10_PREFERRED_AT.getTime()) {
+        return "pnpm 10";
+      }
+      return "pnpm 9";
     }
     default:
       return "not found";
@@ -37450,6 +37535,7 @@ function validLockfileForPackageManager(cliType, lockfileVersion, packageManager
       return true;
     case "pnpm":
       switch (packageManagerMajorVersion) {
+        case 11:
         case 10:
           return lockfileVersion === 9;
         case 9:
@@ -37468,10 +37554,75 @@ function validLockfileForPackageManager(cliType, lockfileVersion, packageManager
       }
   }
 }
+function lockfileCompatibleWithPnpm(lockfileVersion, packageManagerVersion) {
+  if (lockfileVersion === void 0) {
+    return true;
+  }
+  return validLockfileForPackageManager(
+    "pnpm",
+    lockfileVersion,
+    packageManagerVersion
+  );
+}
+function highestInstalledPnpmMajor(versionRange, lockfileVersion) {
+  if (!(0, import_semver2.validRange)(versionRange)) {
+    return void 0;
+  }
+  for (const major of INSTALLED_PNPM_MAJORS) {
+    if (!isPnpmMajorAvailable(major)) {
+      continue;
+    }
+    if (!(0, import_semver2.intersects)(`${major}.x`, versionRange)) {
+      continue;
+    }
+    const versionForLockfile = (0, import_semver2.parse)(major === 9 ? "9.0.1" : `${major}.0.0`);
+    if (!versionForLockfile || !lockfileCompatibleWithPnpm(lockfileVersion, versionForLockfile)) {
+      continue;
+    }
+    return major;
+  }
+  return void 0;
+}
+function resolveDevEnginesPnpmRange(devEngines) {
+  if (!devEngines?.packageManager) {
+    return void 0;
+  }
+  const entries = Array.isArray(devEngines.packageManager) ? devEngines.packageManager : [devEngines.packageManager];
+  const pnpm = entries.find((entry) => entry.name === "pnpm" && entry.version);
+  return pnpm?.version;
+}
+function resolveCompatiblePnpmPin({
+  cliType,
+  lockfileVersion,
+  packageJsonDevEngines,
+  corepackPackageManager
+}) {
+  if (cliType !== "pnpm") {
+    return void 0;
+  }
+  const devEnginesRange = resolveDevEnginesPnpmRange(packageJsonDevEngines);
+  if (devEnginesRange) {
+    const major = highestInstalledPnpmMajor(devEnginesRange, lockfileVersion);
+    if (major !== void 0) {
+      return { override: pnpmPathOverride(major), source: "devEngines" };
+    }
+  }
+  const parsed = validateVersionSpecifier(corepackPackageManager);
+  if (parsed?.packageName === "pnpm") {
+    if (lockfileCompatibleWithPnpm(lockfileVersion, parsed.packageVersion) && isPnpmMajorAvailable(parsed.packageVersion.major)) {
+      return {
+        override: pnpmPathOverride(parsed.packageVersion.major),
+        source: "packageManager"
+      };
+    }
+  }
+  return void 0;
+}
 function getPathOverrideForPackageManager({
   cliType,
   lockfileVersion,
   corepackPackageManager,
+  packageJsonDevEngines,
   corepackEnabled = true,
   nodeVersion,
   packageJsonEngines,
@@ -37480,7 +37631,8 @@ function getPathOverrideForPackageManager({
   const detectedPackageManger = detectPackageManager(
     cliType,
     lockfileVersion,
-    projectCreatedAt
+    projectCreatedAt,
+    nodeVersion
   );
   const usingCorepack2 = corepackPackageManager && corepackEnabled;
   if (usingCorepack2) {
@@ -37492,14 +37644,20 @@ function getPathOverrideForPackageManager({
     );
     return NO_OVERRIDE;
   }
+  const pin = resolveCompatiblePnpmPin({
+    cliType,
+    lockfileVersion,
+    packageJsonDevEngines,
+    corepackPackageManager
+  });
+  let selected = pin?.override ?? detectedPackageManger;
   if (cliType === "pnpm" && packageJsonEngines?.pnpm) {
-    const usingDetected = detectedPackageManger?.pnpmVersionRange !== "10.x" || !corepackPackageManager;
-    if (usingDetected) {
-      checkEnginesPnpmAgainstDetected(
-        packageJsonEngines.pnpm,
-        detectedPackageManger
-      );
-    }
+    selected = applyEnginesPnpm({
+      enginesPnpm: packageJsonEngines.pnpm,
+      selected,
+      usedPin: Boolean(pin),
+      lockfileVersion
+    });
   }
   if (cliType === "bun" && detectedPackageManger && nodeVersion && isBunVersion(nodeVersion)) {
     const minor = nodeVersion.minor;
@@ -37509,20 +37667,53 @@ function getPathOverrideForPackageManager({
       detectedPackageManager: `bun@${nodeVersion.range}`
     };
   }
-  return detectedPackageManger ?? NO_OVERRIDE;
+  return selected ?? NO_OVERRIDE;
 }
-function checkEnginesPnpmAgainstDetected(enginesPnpm, detectedPackageManger) {
-  if (detectedPackageManger?.pnpmVersionRange && (0, import_semver2.validRange)(detectedPackageManger.pnpmVersionRange) && (0, import_semver2.validRange)(enginesPnpm)) {
-    if (!(0, import_semver2.intersects)(detectedPackageManger.pnpmVersionRange, enginesPnpm)) {
-      throw new Error(
-        `Detected pnpm "${detectedPackageManger.pnpmVersionRange}" is not compatible with the engines.pnpm "${enginesPnpm}" in your package.json. Either enable corepack with a valid package.json#packageManager value (https://vercel.com/docs/deployments/configure-a-build#corepack) or remove your package.json#engines.pnpm.`
-      );
+function applyEnginesPnpm({
+  enginesPnpm,
+  selected,
+  usedPin,
+  lockfileVersion
+}) {
+  const selectedRange = selected && "pnpmVersionRange" in selected ? selected.pnpmVersionRange : void 0;
+  if (selectedRange && (0, import_semver2.validRange)(selectedRange) && (0, import_semver2.validRange)(enginesPnpm)) {
+    if ((0, import_semver2.intersects)(selectedRange, enginesPnpm)) {
+      if (!usedPin) {
+        warnEnginesPnpmWithoutPin();
+      }
+      return selected;
     }
+    if (!usedPin) {
+      const major = highestInstalledPnpmMajor(enginesPnpm, lockfileVersion);
+      if (major !== void 0) {
+        return pnpmPathOverride(major);
+      }
+      if (shouldDeferPnpm11UntilImageHasBinary(enginesPnpm, lockfileVersion)) {
+        warnEnginesPnpmWithoutPin();
+        return selected;
+      }
+    }
+    throw new Error(
+      `Detected pnpm "${selectedRange}" is not compatible with the engines.pnpm "${enginesPnpm}" in your package.json. Set package.json#packageManager or package.json#devEngines.packageManager to a compatible pnpm version, or remove package.json#engines.pnpm.`
+    );
+  }
+  if (!usedPin) {
+    warnEnginesPnpmWithoutPin();
   }
+  return selected;
+}
+function warnEnginesPnpmWithoutPin() {
   console.warn(
     `Using package.json#engines.pnpm without corepack and package.json#packageManager could lead to failed builds with ERR_PNPM_UNSUPPORTED_ENGINE. Learn more: https://vercel.com/docs/errors/error-list#pnpm-engine-unsupported`
   );
 }
+function shouldDeferPnpm11UntilImageHasBinary(enginesPnpm, lockfileVersion) {
+  if (isPnpmMajorAvailable(11) || !(0, import_semver2.intersects)("11.x", enginesPnpm)) {
+    return false;
+  }
+  const pnpm11 = (0, import_semver2.parse)("11.0.0");
+  return Boolean(pnpm11 && lockfileCompatibleWithPnpm(lockfileVersion, pnpm11));
+}
 function validateCorepackPackageManager(cliType, lockfileVersion, corepackPackageManager, enginesPnpmVersionRange) {
   const validatedCorepackPackageManager = validateVersionSpecifier(
     corepackPackageManager
@@ -37584,50 +37775,33 @@ function validateVersionSpecifier(version) {
     packageVersion
   };
 }
-function detectPackageManager(cliType, lockfileVersion, projectCreatedAt) {
+function detectPackageManager(cliType, lockfileVersion, projectCreatedAt, nodeVersion) {
   switch (cliType) {
     case "npm":
       return void 0;
-    case "pnpm":
-      switch (detectPnpmVersion(lockfileVersion, projectCreatedAt)) {
+    case "pnpm": {
+      const detected = detectPnpmVersion(
+        lockfileVersion,
+        projectCreatedAt,
+        nodeVersion
+      );
+      switch (detected) {
+        case "pnpm 6":
+          return pnpmPathOverride(6);
         case "pnpm 7":
-          return {
-            path: "/pnpm7/node_modules/.bin",
-            detectedLockfile: "pnpm-lock.yaml",
-            detectedPackageManager: "pnpm@7.x",
-            pnpmVersionRange: "7.x"
-          };
+          return pnpmPathOverride(7);
         case "pnpm 8":
-          return {
-            path: "/pnpm8/node_modules/.bin",
-            detectedLockfile: "pnpm-lock.yaml",
-            detectedPackageManager: "pnpm@8.x",
-            pnpmVersionRange: "8.x"
-          };
+          return pnpmPathOverride(8);
         case "pnpm 9":
-          return {
-            path: "/pnpm9/node_modules/.bin",
-            detectedLockfile: "pnpm-lock.yaml",
-            detectedPackageManager: "pnpm@9.x",
-            pnpmVersionRange: "9.x"
-          };
+          return pnpmPathOverride(9);
         case "pnpm 10":
-          return {
-            path: "/pnpm10/node_modules/.bin",
-            detectedLockfile: "pnpm-lock.yaml",
-            detectedPackageManager: "pnpm@10.x",
-            pnpmVersionRange: "10.x"
-          };
-        case "pnpm 6":
-          return {
-            path: "/pnpm6/node_modules/.bin",
-            detectedLockfile: "pnpm-lock.yaml",
-            detectedPackageManager: "pnpm@6.x",
-            pnpmVersionRange: "6.x"
-          };
+          return pnpmPathOverride(10);
+        case "pnpm 11":
+          return pnpmPathOverride(11);
         default:
           return void 0;
       }
+    }
     case "bun":
       return {
         path: "/bun1",
@@ -37704,6 +37878,7 @@ async function runCustomInstallCommand({
     packageJson,
     packageJsonPath,
     packageJsonPackageManager,
+    packageJsonDevEngines,
     turboSupportsCorepackHome
   } = await scanParentDirs(destPath, true);
   if (installCompletedCovers(packageJsonPath)) {
@@ -37717,6 +37892,7 @@ async function runCustomInstallCommand({
     cliType,
     lockfileVersion,
     packageJsonPackageManager,
+    packageJsonDevEngines,
     env: spawnOpts?.env || {},
     packageJsonEngines: packageJson?.engines,
     turboSupportsCorepackHome,
@@ -37737,6 +37913,7 @@ async function runPackageJsonScript(destPath, scriptNames, spawnOpts, projectCre
     cliType,
     lockfileVersion,
     packageJsonPackageManager,
+    packageJsonDevEngines,
     turboSupportsCorepackHome
   } = await scanParentDirs(destPath, true);
   const scriptName = getScriptName(
@@ -37754,6 +37931,7 @@ async function runPackageJsonScript(destPath, scriptNames, spawnOpts, projectCre
       cliType,
       lockfileVersion,
       packageJsonPackageManager,
+      packageJsonDevEngines,
       env: cloneEnv(process.env, spawnOpts?.env),
       packageJsonEngines: packageJson?.engines,
       turboSupportsCorepackHome,
@@ -39477,24 +39655,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;
@@ -39673,7 +39835,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);
@@ -39707,6 +39869,13 @@ function getInternalServiceCronPath(serviceName, entrypoint, handler = "cron") {
   const normalizedEntrypoint = normalizeInternalServiceEntrypoint(entrypoint);
   return `${getInternalServiceCronPathPrefix(serviceName)}/${normalizedEntrypoint}/${handler}`;
 }
+function getInternalServiceWorkerPathPrefix(serviceName) {
+  return `${INTERNAL_SERVICE_PREFIX}/${serviceName}/workers`;
+}
+function getInternalServiceWorkerPath(serviceName, entrypoint, handler = "worker") {
+  const normalizedEntrypoint = normalizeInternalServiceEntrypoint(entrypoint);
+  return `${getInternalServiceWorkerPathPrefix(serviceName)}/${normalizedEntrypoint}/${handler}`;
+}
 // src/process-serverless/get-encrypted-env-file.ts
 function getEncryptedEnv(envFilename, envContent) {
@@ -40016,11 +40185,11 @@ function getAndVerifyOutputLambdasOrEdgeFuncs(buildResponse) {
 }
 // src/collect-build-result/stream-with-extended-payload.ts
-var import_stream2 = require("stream");
+var import_stream3 = require("stream");
 function streamWithExtendedPayload(stream, data) {
   return data ? new MultipartContentStream(stream, data) : stream;
 }
-var MultipartContentStream = class extends import_stream2.Readable {
+var MultipartContentStream = class extends import_stream3.Readable {
   constructor(stream, data) {
     super();
     stream.on("error", (err) => {
@@ -40325,7 +40494,7 @@ async function maybeReadJSON(path8) {
 }
 // src/deserialize/deserialize-build-output.ts
-var fs11 = __toESM(require_lib());
+var fs10 = __toESM(require_lib());
 var import_path16 = require("path");
 // src/deserialize/deserialize-edge-function.ts
@@ -40508,7 +40677,7 @@ async function deserializeBuildOutput(options) {
     let lambda = void 0;
     const fnDir = (0, import_path16.join)(functionsDir, `${path8}.func`);
     try {
-      const link = await fs11.readlink(fnDir);
+      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) {
@@ -40797,6 +40966,8 @@ function getExtendedPayload({
   getInternalServiceCronPath,
   getInternalServiceCronPathPrefix,
   getInternalServiceFunctionPath,
+  getInternalServiceWorkerPath,
+  getInternalServiceWorkerPathPrefix,
   getLambdaByOutputPath,
   getLambdaEnvironment,
   getLambdaOptionsFromFunction,
@@ -40844,7 +41015,6 @@ function getExtendedPayload({
   isNodeBackendFramework,
   isNodeEntrypoint,
   isPackageInstalled,
-  isPythonEntrypoint,
   isPythonFramework,
   isQueueBackedService,
   isQueueTriggeredService,