@pnpm/exe 11.24.0 → 11.25.0

package/dist/worker.js

@@ -61,54 +61,54 @@ var require_polyfills = __commonJS({
     }
     var chdir;
     module.exports = patch;
-    function patch(fs13) {
+    function patch(fs14) {
       if (constants2.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-        patchLchmod(fs13);
-      }
-      if (!fs13.lutimes) {
-        patchLutimes(fs13);
-      }
-      fs13.chown = chownFix(fs13.chown);
-      fs13.fchown = chownFix(fs13.fchown);
-      fs13.lchown = chownFix(fs13.lchown);
-      fs13.chmod = chmodFix(fs13.chmod);
-      fs13.fchmod = chmodFix(fs13.fchmod);
-      fs13.lchmod = chmodFix(fs13.lchmod);
-      fs13.chownSync = chownFixSync(fs13.chownSync);
-      fs13.fchownSync = chownFixSync(fs13.fchownSync);
-      fs13.lchownSync = chownFixSync(fs13.lchownSync);
-      fs13.chmodSync = chmodFixSync(fs13.chmodSync);
-      fs13.fchmodSync = chmodFixSync(fs13.fchmodSync);
-      fs13.lchmodSync = chmodFixSync(fs13.lchmodSync);
-      fs13.stat = statFix(fs13.stat);
-      fs13.fstat = statFix(fs13.fstat);
-      fs13.lstat = statFix(fs13.lstat);
-      fs13.statSync = statFixSync(fs13.statSync);
-      fs13.fstatSync = statFixSync(fs13.fstatSync);
-      fs13.lstatSync = statFixSync(fs13.lstatSync);
-      if (fs13.chmod && !fs13.lchmod) {
-        fs13.lchmod = function(path18, mode, cb) {
+        patchLchmod(fs14);
+      }
+      if (!fs14.lutimes) {
+        patchLutimes(fs14);
+      }
+      fs14.chown = chownFix(fs14.chown);
+      fs14.fchown = chownFix(fs14.fchown);
+      fs14.lchown = chownFix(fs14.lchown);
+      fs14.chmod = chmodFix(fs14.chmod);
+      fs14.fchmod = chmodFix(fs14.fchmod);
+      fs14.lchmod = chmodFix(fs14.lchmod);
+      fs14.chownSync = chownFixSync(fs14.chownSync);
+      fs14.fchownSync = chownFixSync(fs14.fchownSync);
+      fs14.lchownSync = chownFixSync(fs14.lchownSync);
+      fs14.chmodSync = chmodFixSync(fs14.chmodSync);
+      fs14.fchmodSync = chmodFixSync(fs14.fchmodSync);
+      fs14.lchmodSync = chmodFixSync(fs14.lchmodSync);
+      fs14.stat = statFix(fs14.stat);
+      fs14.fstat = statFix(fs14.fstat);
+      fs14.lstat = statFix(fs14.lstat);
+      fs14.statSync = statFixSync(fs14.statSync);
+      fs14.fstatSync = statFixSync(fs14.fstatSync);
+      fs14.lstatSync = statFixSync(fs14.lstatSync);
+      if (fs14.chmod && !fs14.lchmod) {
+        fs14.lchmod = function(path18, mode, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs13.lchmodSync = function() {
+        fs14.lchmodSync = function() {
         };
       }
-      if (fs13.chown && !fs13.lchown) {
-        fs13.lchown = function(path18, uid, gid, cb) {
+      if (fs14.chown && !fs14.lchown) {
+        fs14.lchown = function(path18, uid, gid, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs13.lchownSync = function() {
+        fs14.lchownSync = function() {
         };
       }
       if (platform === "win32") {
-        fs13.rename = typeof fs13.rename !== "function" ? fs13.rename : (function(fs$rename) {
+        fs14.rename = typeof fs14.rename !== "function" ? fs14.rename : (function(fs$rename) {
           function rename(from, to, cb) {
             var start = Date.now();
             var backoff = 0;
             fs$rename(from, to, function CB(er) {
               if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 6e4) {
                 setTimeout(function() {
-                  fs13.stat(to, function(stater, st) {
+                  fs14.stat(to, function(stater, st) {
                     if (stater && stater.code === "ENOENT")
                       fs$rename(from, to, CB);
                     else
@@ -124,9 +124,9 @@ var require_polyfills = __commonJS({
           }
           if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
           return rename;
-        })(fs13.rename);
+        })(fs14.rename);
       }
-      fs13.read = typeof fs13.read !== "function" ? fs13.read : (function(fs$read) {
+      fs14.read = typeof fs14.read !== "function" ? fs14.read : (function(fs$read) {
         function read2(fd, buffer, offset, length, position3, callback_) {
           var callback;
           if (callback_ && typeof callback_ === "function") {
@@ -134,22 +134,22 @@ var require_polyfills = __commonJS({
             callback = function(er, _, __) {
               if (er && er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
-                return fs$read.call(fs13, fd, buffer, offset, length, position3, callback);
+                return fs$read.call(fs14, fd, buffer, offset, length, position3, callback);
               }
               callback_.apply(this, arguments);
             };
           }
-          return fs$read.call(fs13, fd, buffer, offset, length, position3, callback);
+          return fs$read.call(fs14, fd, buffer, offset, length, position3, callback);
         }
         if (Object.setPrototypeOf) Object.setPrototypeOf(read2, fs$read);
         return read2;
-      })(fs13.read);
-      fs13.readSync = typeof fs13.readSync !== "function" ? fs13.readSync : /* @__PURE__ */ (function(fs$readSync) {
+      })(fs14.read);
+      fs14.readSync = typeof fs14.readSync !== "function" ? fs14.readSync : /* @__PURE__ */ (function(fs$readSync) {
         return function(fd, buffer, offset, length, position3) {
           var eagCounter = 0;
           while (true) {
             try {
-              return fs$readSync.call(fs13, fd, buffer, offset, length, position3);
+              return fs$readSync.call(fs14, fd, buffer, offset, length, position3);
             } catch (er) {
               if (er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
@@ -159,10 +159,10 @@ var require_polyfills = __commonJS({
             }
           }
         };
-      })(fs13.readSync);
-      function patchLchmod(fs14) {
-        fs14.lchmod = function(path18, mode, callback) {
-          fs14.open(
+      })(fs14.readSync);
+      function patchLchmod(fs15) {
+        fs15.lchmod = function(path18, mode, callback) {
+          fs15.open(
             path18,
             constants2.O_WRONLY | constants2.O_SYMLINK,
             mode,
@@ -171,80 +171,80 @@ var require_polyfills = __commonJS({
                 if (callback) callback(err);
                 return;
               }
-              fs14.fchmod(fd, mode, function(err2) {
-                fs14.close(fd, function(err22) {
+              fs15.fchmod(fd, mode, function(err2) {
+                fs15.close(fd, function(err22) {
                   if (callback) callback(err2 || err22);
                 });
               });
             }
           );
         };
-        fs14.lchmodSync = function(path18, mode) {
-          var fd = fs14.openSync(path18, constants2.O_WRONLY | constants2.O_SYMLINK, mode);
+        fs15.lchmodSync = function(path18, mode) {
+          var fd = fs15.openSync(path18, constants2.O_WRONLY | constants2.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
-            ret = fs14.fchmodSync(fd, mode);
+            ret = fs15.fchmodSync(fd, mode);
             threw = false;
           } finally {
             if (threw) {
               try {
-                fs14.closeSync(fd);
+                fs15.closeSync(fd);
               } catch (er) {
               }
             } else {
-              fs14.closeSync(fd);
+              fs15.closeSync(fd);
             }
           }
           return ret;
         };
       }
-      function patchLutimes(fs14) {
-        if (constants2.hasOwnProperty("O_SYMLINK") && fs14.futimes) {
-          fs14.lutimes = function(path18, at, mt, cb) {
-            fs14.open(path18, constants2.O_SYMLINK, function(er, fd) {
+      function patchLutimes(fs15) {
+        if (constants2.hasOwnProperty("O_SYMLINK") && fs15.futimes) {
+          fs15.lutimes = function(path18, at, mt, cb) {
+            fs15.open(path18, constants2.O_SYMLINK, function(er, fd) {
               if (er) {
                 if (cb) cb(er);
                 return;
               }
-              fs14.futimes(fd, at, mt, function(er2) {
-                fs14.close(fd, function(er22) {
+              fs15.futimes(fd, at, mt, function(er2) {
+                fs15.close(fd, function(er22) {
                   if (cb) cb(er2 || er22);
                 });
               });
             });
           };
-          fs14.lutimesSync = function(path18, at, mt) {
-            var fd = fs14.openSync(path18, constants2.O_SYMLINK);
+          fs15.lutimesSync = function(path18, at, mt) {
+            var fd = fs15.openSync(path18, constants2.O_SYMLINK);
             var ret;
             var threw = true;
             try {
-              ret = fs14.futimesSync(fd, at, mt);
+              ret = fs15.futimesSync(fd, at, mt);
               threw = false;
             } finally {
               if (threw) {
                 try {
-                  fs14.closeSync(fd);
+                  fs15.closeSync(fd);
                 } catch (er) {
                 }
               } else {
-                fs14.closeSync(fd);
+                fs15.closeSync(fd);
               }
             }
             return ret;
           };
-        } else if (fs14.futimes) {
-          fs14.lutimes = function(_a, _b, _c, cb) {
+        } else if (fs15.futimes) {
+          fs15.lutimes = function(_a, _b, _c, cb) {
             if (cb) process.nextTick(cb);
           };
-          fs14.lutimesSync = function() {
+          fs15.lutimesSync = function() {
           };
         }
       }
       function chmodFix(orig) {
         if (!orig) return orig;
         return function(target2, mode, cb) {
-          return orig.call(fs13, target2, mode, function(er) {
+          return orig.call(fs14, target2, mode, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -254,7 +254,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target2, mode) {
           try {
-            return orig.call(fs13, target2, mode);
+            return orig.call(fs14, target2, mode);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -263,7 +263,7 @@ var require_polyfills = __commonJS({
       function chownFix(orig) {
         if (!orig) return orig;
         return function(target2, uid, gid, cb) {
-          return orig.call(fs13, target2, uid, gid, function(er) {
+          return orig.call(fs14, target2, uid, gid, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -273,7 +273,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target2, uid, gid) {
           try {
-            return orig.call(fs13, target2, uid, gid);
+            return orig.call(fs14, target2, uid, gid);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -293,13 +293,13 @@ var require_polyfills = __commonJS({
             }
             if (cb) cb.apply(this, arguments);
           }
-          return options ? orig.call(fs13, target2, options, callback) : orig.call(fs13, target2, callback);
+          return options ? orig.call(fs14, target2, options, callback) : orig.call(fs14, target2, callback);
         };
       }
       function statFixSync(orig) {
         if (!orig) return orig;
         return function(target2, options) {
-          var stats = options ? orig.call(fs13, target2, options) : orig.call(fs13, target2);
+          var stats = options ? orig.call(fs14, target2, options) : orig.call(fs14, target2);
           if (stats) {
             if (stats.uid < 0) stats.uid += 4294967296;
             if (stats.gid < 0) stats.gid += 4294967296;
@@ -328,7 +328,7 @@ var require_legacy_streams = __commonJS({
   "../../../../../setup-pnpm/store/v11/links/@/graceful-fs/4.2.11/e60a23841f60609f733db41b2b1eced16c30ec8fe2e67c2a9b80e2dab0755700/node_modules/graceful-fs/legacy-streams.js"(exports, module) {
     var Stream = __require("stream").Stream;
     module.exports = legacy;
-    function legacy(fs13) {
+    function legacy(fs14) {
       return {
         ReadStream,
         WriteStream
@@ -371,7 +371,7 @@ var require_legacy_streams = __commonJS({
           });
           return;
         }
-        fs13.open(this.path, this.flags, this.mode, function(err, fd) {
+        fs14.open(this.path, this.flags, this.mode, function(err, fd) {
           if (err) {
             self2.emit("error", err);
             self2.readable = false;
@@ -410,7 +410,7 @@ var require_legacy_streams = __commonJS({
         this.busy = false;
         this._queue = [];
         if (this.fd === null) {
-          this._open = fs13.open;
+          this._open = fs14.open;
           this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
           this.flush();
         }
@@ -445,7 +445,7 @@ var require_clone = __commonJS({
 // ../../../../../setup-pnpm/store/v11/links/@/graceful-fs/4.2.11/e60a23841f60609f733db41b2b1eced16c30ec8fe2e67c2a9b80e2dab0755700/node_modules/graceful-fs/graceful-fs.js
 var require_graceful_fs = __commonJS({
   "../../../../../setup-pnpm/store/v11/links/@/graceful-fs/4.2.11/e60a23841f60609f733db41b2b1eced16c30ec8fe2e67c2a9b80e2dab0755700/node_modules/graceful-fs/graceful-fs.js"(exports, module) {
-    var fs13 = __require("fs");
+    var fs14 = __require("fs");
     var polyfills = require_polyfills();
     var legacy = require_legacy_streams();
     var clone = require_clone();
@@ -477,12 +477,12 @@ var require_graceful_fs = __commonJS({
         m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
         console.error(m);
       };
-    if (!fs13[gracefulQueue]) {
+    if (!fs14[gracefulQueue]) {
       queue = global[gracefulQueue] || [];
-      publishQueue(fs13, queue);
-      fs13.close = (function(fs$close) {
+      publishQueue(fs14, queue);
+      fs14.close = (function(fs$close) {
         function close(fd, cb) {
-          return fs$close.call(fs13, fd, function(err) {
+          return fs$close.call(fs14, fd, function(err) {
             if (!err) {
               resetQueue();
             }
@@ -494,40 +494,40 @@ var require_graceful_fs = __commonJS({
           value: fs$close
         });
         return close;
-      })(fs13.close);
-      fs13.closeSync = (function(fs$closeSync) {
+      })(fs14.close);
+      fs14.closeSync = (function(fs$closeSync) {
         function closeSync(fd) {
-          fs$closeSync.apply(fs13, arguments);
+          fs$closeSync.apply(fs14, arguments);
           resetQueue();
         }
         Object.defineProperty(closeSync, previousSymbol, {
           value: fs$closeSync
         });
         return closeSync;
-      })(fs13.closeSync);
+      })(fs14.closeSync);
       if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
         process.on("exit", function() {
-          debug(fs13[gracefulQueue]);
-          __require("assert").equal(fs13[gracefulQueue].length, 0);
+          debug(fs14[gracefulQueue]);
+          __require("assert").equal(fs14[gracefulQueue].length, 0);
         });
       }
     }
     var queue;
     if (!global[gracefulQueue]) {
-      publishQueue(global, fs13[gracefulQueue]);
-    }
-    module.exports = patch(clone(fs13));
-    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs13.__patched) {
-      module.exports = patch(fs13);
-      fs13.__patched = true;
-    }
-    function patch(fs14) {
-      polyfills(fs14);
-      fs14.gracefulify = patch;
-      fs14.createReadStream = createReadStream;
-      fs14.createWriteStream = createWriteStream;
-      var fs$readFile = fs14.readFile;
-      fs14.readFile = readFile;
+      publishQueue(global, fs14[gracefulQueue]);
+    }
+    module.exports = patch(clone(fs14));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs14.__patched) {
+      module.exports = patch(fs14);
+      fs14.__patched = true;
+    }
+    function patch(fs15) {
+      polyfills(fs15);
+      fs15.gracefulify = patch;
+      fs15.createReadStream = createReadStream;
+      fs15.createWriteStream = createWriteStream;
+      var fs$readFile = fs15.readFile;
+      fs15.readFile = readFile;
       function readFile(path18, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
@@ -543,8 +543,8 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$writeFile = fs14.writeFile;
-      fs14.writeFile = writeFile2;
+      var fs$writeFile = fs15.writeFile;
+      fs15.writeFile = writeFile2;
       function writeFile2(path18, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
@@ -560,9 +560,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$appendFile = fs14.appendFile;
+      var fs$appendFile = fs15.appendFile;
       if (fs$appendFile)
-        fs14.appendFile = appendFile;
+        fs15.appendFile = appendFile;
       function appendFile(path18, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
@@ -578,9 +578,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$copyFile = fs14.copyFile;
+      var fs$copyFile = fs15.copyFile;
       if (fs$copyFile)
-        fs14.copyFile = copyFile;
+        fs15.copyFile = copyFile;
       function copyFile(src2, dest, flags, cb) {
         if (typeof flags === "function") {
           cb = flags;
@@ -598,8 +598,8 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$readdir = fs14.readdir;
-      fs14.readdir = readdir;
+      var fs$readdir = fs15.readdir;
+      fs15.readdir = readdir;
       var noReaddirOptionVersions = /^v[0-5]\./;
       function readdir(path18, options, cb) {
         if (typeof options === "function")
@@ -640,21 +640,21 @@ var require_graceful_fs = __commonJS({
         }
       }
       if (process.version.substr(0, 4) === "v0.8") {
-        var legStreams = legacy(fs14);
+        var legStreams = legacy(fs15);
         ReadStream = legStreams.ReadStream;
         WriteStream = legStreams.WriteStream;
       }
-      var fs$ReadStream = fs14.ReadStream;
+      var fs$ReadStream = fs15.ReadStream;
       if (fs$ReadStream) {
         ReadStream.prototype = Object.create(fs$ReadStream.prototype);
         ReadStream.prototype.open = ReadStream$open;
       }
-      var fs$WriteStream = fs14.WriteStream;
+      var fs$WriteStream = fs15.WriteStream;
       if (fs$WriteStream) {
         WriteStream.prototype = Object.create(fs$WriteStream.prototype);
         WriteStream.prototype.open = WriteStream$open;
       }
-      Object.defineProperty(fs14, "ReadStream", {
+      Object.defineProperty(fs15, "ReadStream", {
         get: function() {
           return ReadStream;
         },
@@ -664,7 +664,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      Object.defineProperty(fs14, "WriteStream", {
+      Object.defineProperty(fs15, "WriteStream", {
         get: function() {
           return WriteStream;
         },
@@ -675,7 +675,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileReadStream = ReadStream;
-      Object.defineProperty(fs14, "FileReadStream", {
+      Object.defineProperty(fs15, "FileReadStream", {
         get: function() {
           return FileReadStream;
         },
@@ -686,7 +686,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileWriteStream = WriteStream;
-      Object.defineProperty(fs14, "FileWriteStream", {
+      Object.defineProperty(fs15, "FileWriteStream", {
         get: function() {
           return FileWriteStream;
         },
@@ -735,13 +735,13 @@ var require_graceful_fs = __commonJS({
         });
       }
       function createReadStream(path18, options) {
-        return new fs14.ReadStream(path18, options);
+        return new fs15.ReadStream(path18, options);
       }
       function createWriteStream(path18, options) {
-        return new fs14.WriteStream(path18, options);
+        return new fs15.WriteStream(path18, options);
       }
-      var fs$open = fs14.open;
-      fs14.open = open;
+      var fs$open = fs15.open;
+      fs15.open = open;
       function open(path18, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
@@ -757,20 +757,20 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      return fs14;
+      return fs15;
     }
     function enqueue(elem) {
       debug("ENQUEUE", elem[0].name, elem[1]);
-      fs13[gracefulQueue].push(elem);
+      fs14[gracefulQueue].push(elem);
       retry();
     }
     var retryTimer;
     function resetQueue() {
       var now = Date.now();
-      for (var i = 0; i < fs13[gracefulQueue].length; ++i) {
-        if (fs13[gracefulQueue][i].length > 2) {
-          fs13[gracefulQueue][i][3] = now;
-          fs13[gracefulQueue][i][4] = now;
+      for (var i = 0; i < fs14[gracefulQueue].length; ++i) {
+        if (fs14[gracefulQueue][i].length > 2) {
+          fs14[gracefulQueue][i][3] = now;
+          fs14[gracefulQueue][i][4] = now;
         }
       }
       retry();
@@ -778,9 +778,9 @@ var require_graceful_fs = __commonJS({
     function retry() {
       clearTimeout(retryTimer);
       retryTimer = void 0;
-      if (fs13[gracefulQueue].length === 0)
+      if (fs14[gracefulQueue].length === 0)
         return;
-      var elem = fs13[gracefulQueue].shift();
+      var elem = fs14[gracefulQueue].shift();
       var fn = elem[0];
       var args = elem[1];
       var err = elem[2];
@@ -802,7 +802,7 @@ var require_graceful_fs = __commonJS({
           debug("RETRY", fn.name, args);
           fn.apply(null, args.concat([startTime]));
         } else {
-          fs13[gracefulQueue].push(elem);
+          fs14[gracefulQueue].push(elem);
         }
       }
       if (retryTimer === void 0) {
@@ -1382,6 +1382,32 @@ var require_split2 = __commonJS({
   }
 });
 
+// ../../../../../setup-pnpm/store/v11/links/@/is-windows/1.0.2/8de297753f5a2f0d3154b27e41b774686b53f5e3c186cf9f734f0a5ce4054b2e/node_modules/is-windows/index.js
+var require_is_windows = __commonJS({
+  "../../../../../setup-pnpm/store/v11/links/@/is-windows/1.0.2/8de297753f5a2f0d3154b27e41b774686b53f5e3c186cf9f734f0a5ce4054b2e/node_modules/is-windows/index.js"(exports, module) {
+    (function(factory) {
+      if (exports && typeof exports === "object" && typeof module !== "undefined") {
+        module.exports = factory();
+      } else if (typeof define === "function" && define.amd) {
+        define([], factory);
+      } else if (typeof window !== "undefined") {
+        window.isWindows = factory();
+      } else if (typeof global !== "undefined") {
+        global.isWindows = factory();
+      } else if (typeof self !== "undefined") {
+        self.isWindows = factory();
+      } else {
+        this.isWindows = factory();
+      }
+    })(function() {
+      "use strict";
+      return function isWindows2() {
+        return process && (process.platform === "win32" || /^(msys|cygwin)$/.test(process.env.OSTYPE));
+      };
+    });
+  }
+});
+
 // ../../../../../setup-pnpm/store/v11/links/@/universalify/2.0.1/3983135594189f71b00fc07b6b17387b476e8a92e19ec2a61c1f0e0d68895f4d/node_modules/universalify/index.js
 var require_universalify = __commonJS({
   "../../../../../setup-pnpm/store/v11/links/@/universalify/2.0.1/3983135594189f71b00fc07b6b17387b476e8a92e19ec2a61c1f0e0d68895f4d/node_modules/universalify/index.js"(exports) {
@@ -1415,7 +1441,7 @@ var require_fs = __commonJS({
   "../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/fs/index.js"(exports) {
     "use strict";
     var u = require_universalify().fromCallback;
-    var fs13 = require_graceful_fs();
+    var fs14 = require_graceful_fs();
     var api = [
       "access",
       "appendFile",
@@ -1456,26 +1482,26 @@ var require_fs = __commonJS({
       "utimes",
       "writeFile"
     ].filter((key) => {
-      return typeof fs13[key] === "function";
+      return typeof fs14[key] === "function";
     });
-    Object.assign(exports, fs13);
+    Object.assign(exports, fs14);
     api.forEach((method) => {
-      exports[method] = u(fs13[method]);
+      exports[method] = u(fs14[method]);
     });
     exports.exists = function(filename, callback) {
       if (typeof callback === "function") {
-        return fs13.exists(filename, callback);
+        return fs14.exists(filename, callback);
       }
       return new Promise((resolve) => {
-        return fs13.exists(filename, resolve);
+        return fs14.exists(filename, resolve);
       });
     };
     exports.read = function(fd, buffer, offset, length, position3, callback) {
       if (typeof callback === "function") {
-        return fs13.read(fd, buffer, offset, length, position3, callback);
+        return fs14.read(fd, buffer, offset, length, position3, callback);
       }
       return new Promise((resolve, reject) => {
-        fs13.read(fd, buffer, offset, length, position3, (err, bytesRead, buffer2) => {
+        fs14.read(fd, buffer, offset, length, position3, (err, bytesRead, buffer2) => {
           if (err) return reject(err);
           resolve({ bytesRead, buffer: buffer2 });
         });
@@ -1483,10 +1509,10 @@ var require_fs = __commonJS({
     };
     exports.write = function(fd, buffer, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs13.write(fd, buffer, ...args);
+        return fs14.write(fd, buffer, ...args);
       }
       return new Promise((resolve, reject) => {
-        fs13.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
+        fs14.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
           if (err) return reject(err);
           resolve({ bytesWritten, buffer: buffer2 });
         });
@@ -1494,10 +1520,10 @@ var require_fs = __commonJS({
     };
     exports.readv = function(fd, buffers, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs13.readv(fd, buffers, ...args);
+        return fs14.readv(fd, buffers, ...args);
       }
       return new Promise((resolve, reject) => {
-        fs13.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
+        fs14.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
           if (err) return reject(err);
           resolve({ bytesRead, buffers: buffers2 });
         });
@@ -1505,17 +1531,17 @@ var require_fs = __commonJS({
     };
     exports.writev = function(fd, buffers, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs13.writev(fd, buffers, ...args);
+        return fs14.writev(fd, buffers, ...args);
       }
       return new Promise((resolve, reject) => {
-        fs13.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
+        fs14.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
           if (err) return reject(err);
           resolve({ bytesWritten, buffers: buffers2 });
         });
       });
     };
-    if (typeof fs13.realpath.native === "function") {
-      exports.realpath.native = u(fs13.realpath.native);
+    if (typeof fs14.realpath.native === "function") {
+      exports.realpath.native = u(fs14.realpath.native);
     } else {
       process.emitWarning(
         "fs.realpath.native is not a function. Is fs being monkey-patched?",
@@ -1548,7 +1574,7 @@ var require_utils = __commonJS({
 var require_make_dir = __commonJS({
   "../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/mkdirs/make-dir.js"(exports, module) {
     "use strict";
-    var fs13 = require_fs();
+    var fs14 = require_fs();
     var { checkPath } = require_utils();
     var getMode = (options) => {
       const defaults = { mode: 511 };
@@ -1557,14 +1583,14 @@ var require_make_dir = __commonJS({
     };
     module.exports.makeDir = async (dir, options) => {
       checkPath(dir);
-      return fs13.mkdir(dir, {
+      return fs14.mkdir(dir, {
         mode: getMode(options),
         recursive: true
       });
     };
     module.exports.makeDirSync = (dir, options) => {
       checkPath(dir);
-      return fs13.mkdirSync(dir, {
+      return fs14.mkdirSync(dir, {
         mode: getMode(options),
         recursive: true
       });
@@ -1596,13 +1622,13 @@ var require_path_exists = __commonJS({
   "../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/path-exists/index.js"(exports, module) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs13 = require_fs();
+    var fs14 = require_fs();
     function pathExists(path18) {
-      return fs13.access(path18).then(() => true).catch(() => false);
+      return fs14.access(path18).then(() => true).catch(() => false);
     }
     module.exports = {
       pathExists: u(pathExists),
-      pathExistsSync: fs13.existsSync
+      pathExistsSync: fs14.existsSync
     };
   }
 });
@@ -1611,16 +1637,16 @@ var require_path_exists = __commonJS({
 var require_utimes = __commonJS({
   "../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/util/utimes.js"(exports, module) {
     "use strict";
-    var fs13 = require_fs();
+    var fs14 = require_fs();
     var u = require_universalify().fromPromise;
     async function utimesMillis(path18, atime, mtime) {
-      const fd = await fs13.open(path18, "r+");
+      const fd = await fs14.open(path18, "r+");
       let closeErr = null;
       try {
-        await fs13.futimes(fd, atime, mtime);
+        await fs14.futimes(fd, atime, mtime);
       } finally {
         try {
-          await fs13.close(fd);
+          await fs14.close(fd);
         } catch (e) {
           closeErr = e;
         }
@@ -1630,9 +1656,9 @@ var require_utimes = __commonJS({
       }
     }
     function utimesMillisSync(path18, atime, mtime) {
-      const fd = fs13.openSync(path18, "r+");
-      fs13.futimesSync(fd, atime, mtime);
-      return fs13.closeSync(fd);
+      const fd = fs14.openSync(path18, "r+");
+      fs14.futimesSync(fd, atime, mtime);
+      return fs14.closeSync(fd);
     }
     module.exports = {
       utimesMillis: u(utimesMillis),
@@ -1645,11 +1671,11 @@ var require_utimes = __commonJS({
 var require_stat = __commonJS({
   "../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/util/stat.js"(exports, module) {
     "use strict";
-    var fs13 = require_fs();
+    var fs14 = require_fs();
     var path18 = __require("path");
     var u = require_universalify().fromPromise;
     function getStats(src2, dest, opts2) {
-      const statFunc = opts2.dereference ? (file) => fs13.stat(file, { bigint: true }) : (file) => fs13.lstat(file, { bigint: true });
+      const statFunc = opts2.dereference ? (file) => fs14.stat(file, { bigint: true }) : (file) => fs14.lstat(file, { bigint: true });
       return Promise.all([
         statFunc(src2),
         statFunc(dest).catch((err) => {
@@ -1660,7 +1686,7 @@ var require_stat = __commonJS({
     }
     function getStatsSync(src2, dest, opts2) {
       let destStat;
-      const statFunc = opts2.dereference ? (file) => fs13.statSync(file, { bigint: true }) : (file) => fs13.lstatSync(file, { bigint: true });
+      const statFunc = opts2.dereference ? (file) => fs14.statSync(file, { bigint: true }) : (file) => fs14.lstatSync(file, { bigint: true });
       const srcStat = statFunc(src2);
       try {
         destStat = statFunc(dest);
@@ -1722,7 +1748,7 @@ var require_stat = __commonJS({
       if (destParent === srcParent || destParent === path18.parse(destParent).root) return;
       let destStat;
       try {
-        destStat = await fs13.stat(destParent, { bigint: true });
+        destStat = await fs14.stat(destParent, { bigint: true });
       } catch (err) {
         if (err.code === "ENOENT") return;
         throw err;
@@ -1738,7 +1764,7 @@ var require_stat = __commonJS({
       if (destParent === srcParent || destParent === path18.parse(destParent).root) return;
       let destStat;
       try {
-        destStat = fs13.statSync(destParent, { bigint: true });
+        destStat = fs14.statSync(destParent, { bigint: true });
       } catch (err) {
         if (err.code === "ENOENT") return;
         throw err;
@@ -1805,7 +1831,7 @@ var require_async = __commonJS({
 var require_copy = __commonJS({
   "../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/copy/copy.js"(exports, module) {
     "use strict";
-    var fs13 = require_fs();
+    var fs14 = require_fs();
     var path18 = __require("path");
     var { mkdirs } = require_mkdirs();
     var { pathExists } = require_path_exists();
@@ -1841,7 +1867,7 @@ var require_copy = __commonJS({
       return opts2.filter(src2, dest);
     }
     async function getStatsAndPerformCopy(destStat, src2, dest, opts2) {
-      const statFn = opts2.dereference ? fs13.stat : fs13.lstat;
+      const statFn = opts2.dereference ? fs14.stat : fs14.lstat;
       const srcStat = await statFn(src2);
       if (srcStat.isDirectory()) return onDir(srcStat, destStat, src2, dest, opts2);
       if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile(srcStat, destStat, src2, dest, opts2);
@@ -1853,7 +1879,7 @@ var require_copy = __commonJS({
     async function onFile(srcStat, destStat, src2, dest, opts2) {
       if (!destStat) return copyFile(srcStat, src2, dest, opts2);
       if (opts2.overwrite) {
-        await fs13.unlink(dest);
+        await fs14.unlink(dest);
         return copyFile(srcStat, src2, dest, opts2);
       }
       if (opts2.errorOnExist) {
@@ -1861,27 +1887,27 @@ var require_copy = __commonJS({
       }
     }
     async function copyFile(srcStat, src2, dest, opts2) {
-      await fs13.copyFile(src2, dest);
+      await fs14.copyFile(src2, dest);
       if (opts2.preserveTimestamps) {
         if (fileIsNotWritable(srcStat.mode)) {
           await makeFileWritable(dest, srcStat.mode);
         }
-        const updatedSrcStat = await fs13.stat(src2);
+        const updatedSrcStat = await fs14.stat(src2);
         await utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
       }
-      return fs13.chmod(dest, srcStat.mode);
+      return fs14.chmod(dest, srcStat.mode);
     }
     function fileIsNotWritable(srcMode) {
       return (srcMode & 128) === 0;
     }
     function makeFileWritable(dest, srcMode) {
-      return fs13.chmod(dest, srcMode | 128);
+      return fs14.chmod(dest, srcMode | 128);
     }
     async function onDir(srcStat, destStat, src2, dest, opts2) {
       if (!destStat) {
-        await fs13.mkdir(dest);
+        await fs14.mkdir(dest);
       }
-      await asyncIteratorConcurrentProcess(await fs13.opendir(src2), async (item) => {
+      await asyncIteratorConcurrentProcess(await fs14.opendir(src2), async (item) => {
         const srcItem = path18.join(src2, item.name);
         const destItem = path18.join(dest, item.name);
         const include = await runFilter(srcItem, destItem, opts2);
@@ -1891,22 +1917,22 @@ var require_copy = __commonJS({
         }
       });
       if (!destStat) {
-        await fs13.chmod(dest, srcStat.mode);
+        await fs14.chmod(dest, srcStat.mode);
       }
     }
     async function onLink(destStat, src2, dest, opts2) {
-      let resolvedSrc = await fs13.readlink(src2);
+      let resolvedSrc = await fs14.readlink(src2);
       if (opts2.dereference) {
         resolvedSrc = path18.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
-        return fs13.symlink(resolvedSrc, dest);
+        return fs14.symlink(resolvedSrc, dest);
       }
       let resolvedDest = null;
       try {
-        resolvedDest = await fs13.readlink(dest);
+        resolvedDest = await fs14.readlink(dest);
       } catch (e) {
-        if (e.code === "EINVAL" || e.code === "UNKNOWN") return fs13.symlink(resolvedSrc, dest);
+        if (e.code === "EINVAL" || e.code === "UNKNOWN") return fs14.symlink(resolvedSrc, dest);
         throw e;
       }
       if (opts2.dereference) {
@@ -1920,8 +1946,8 @@ var require_copy = __commonJS({
           throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
         }
       }
-      await fs13.unlink(dest);
-      return fs13.symlink(resolvedSrc, dest);
+      await fs14.unlink(dest);
+      return fs14.symlink(resolvedSrc, dest);
     }
     module.exports = copy2;
   }
@@ -1931,7 +1957,7 @@ var require_copy = __commonJS({
 var require_copy_sync = __commonJS({
   "../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/copy/copy-sync.js"(exports, module) {
     "use strict";
-    var fs13 = require_graceful_fs();
+    var fs14 = require_graceful_fs();
     var path18 = __require("path");
     var mkdirsSync = require_mkdirs().mkdirsSync;
     var utimesMillisSync = require_utimes().utimesMillisSync;
@@ -1954,11 +1980,11 @@ var require_copy_sync = __commonJS({
       stat.checkParentPathsSync(src2, srcStat, dest, "copy");
       if (opts2.filter && !opts2.filter(src2, dest)) return;
       const destParent = path18.dirname(dest);
-      if (!fs13.existsSync(destParent)) mkdirsSync(destParent);
+      if (!fs14.existsSync(destParent)) mkdirsSync(destParent);
       return getStats(destStat, src2, dest, opts2);
     }
     function getStats(destStat, src2, dest, opts2) {
-      const statSync = opts2.dereference ? fs13.statSync : fs13.lstatSync;
+      const statSync = opts2.dereference ? fs14.statSync : fs14.lstatSync;
       const srcStat = statSync(src2);
       if (srcStat.isDirectory()) return onDir(srcStat, destStat, src2, dest, opts2);
       else if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile(srcStat, destStat, src2, dest, opts2);
@@ -1973,14 +1999,14 @@ var require_copy_sync = __commonJS({
     }
     function mayCopyFile(srcStat, src2, dest, opts2) {
       if (opts2.overwrite) {
-        fs13.unlinkSync(dest);
+        fs14.unlinkSync(dest);
         return copyFile(srcStat, src2, dest, opts2);
       } else if (opts2.errorOnExist) {
         throw new Error(`'${dest}' already exists`);
       }
     }
     function copyFile(srcStat, src2, dest, opts2) {
-      fs13.copyFileSync(src2, dest);
+      fs14.copyFileSync(src2, dest);
       if (opts2.preserveTimestamps) handleTimestamps(srcStat.mode, src2, dest);
       return setDestMode(dest, srcStat.mode);
     }
@@ -1995,10 +2021,10 @@ var require_copy_sync = __commonJS({
       return setDestMode(dest, srcMode | 128);
     }
     function setDestMode(dest, srcMode) {
-      return fs13.chmodSync(dest, srcMode);
+      return fs14.chmodSync(dest, srcMode);
     }
     function setDestTimestamps(src2, dest) {
-      const updatedSrcStat = fs13.statSync(src2);
+      const updatedSrcStat = fs14.statSync(src2);
       return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
     }
     function onDir(srcStat, destStat, src2, dest, opts2) {
@@ -2006,12 +2032,12 @@ var require_copy_sync = __commonJS({
       return copyDir(src2, dest, opts2);
     }
     function mkDirAndCopy(srcMode, src2, dest, opts2) {
-      fs13.mkdirSync(dest);
+      fs14.mkdirSync(dest);
       copyDir(src2, dest, opts2);
       return setDestMode(dest, srcMode);
     }
     function copyDir(src2, dest, opts2) {
-      const dir = fs13.opendirSync(src2);
+      const dir = fs14.opendirSync(src2);
       try {
         let dirent;
         while ((dirent = dir.readSync()) !== null) {
@@ -2029,18 +2055,18 @@ var require_copy_sync = __commonJS({
       return getStats(destStat, srcItem, destItem, opts2);
     }
     function onLink(destStat, src2, dest, opts2) {
-      let resolvedSrc = fs13.readlinkSync(src2);
+      let resolvedSrc = fs14.readlinkSync(src2);
       if (opts2.dereference) {
         resolvedSrc = path18.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
-        return fs13.symlinkSync(resolvedSrc, dest);
+        return fs14.symlinkSync(resolvedSrc, dest);
       } else {
         let resolvedDest;
         try {
-          resolvedDest = fs13.readlinkSync(dest);
+          resolvedDest = fs14.readlinkSync(dest);
         } catch (err) {
-          if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs13.symlinkSync(resolvedSrc, dest);
+          if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs14.symlinkSync(resolvedSrc, dest);
           throw err;
         }
         if (opts2.dereference) {
@@ -2058,8 +2084,8 @@ var require_copy_sync = __commonJS({
       }
     }
     function copyLink(resolvedSrc, dest) {
-      fs13.unlinkSync(dest);
-      return fs13.symlinkSync(resolvedSrc, dest);
+      fs14.unlinkSync(dest);
+      return fs14.symlinkSync(resolvedSrc, dest);
     }
     module.exports = copySync2;
   }
@@ -2081,13 +2107,13 @@ var require_copy2 = __commonJS({
 var require_remove = __commonJS({
   "../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/remove/index.js"(exports, module) {
     "use strict";
-    var fs13 = require_graceful_fs();
+    var fs14 = require_graceful_fs();
     var u = require_universalify().fromCallback;
     function remove(path18, callback) {
-      fs13.rm(path18, { recursive: true, force: true }, callback);
+      fs14.rm(path18, { recursive: true, force: true }, callback);
     }
     function removeSync(path18) {
-      fs13.rmSync(path18, { recursive: true, force: true });
+      fs14.rmSync(path18, { recursive: true, force: true });
     }
     module.exports = {
       remove: u(remove),
@@ -2101,14 +2127,14 @@ var require_empty = __commonJS({
   "../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/empty/index.js"(exports, module) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs13 = require_fs();
+    var fs14 = require_fs();
     var path18 = __require("path");
     var mkdir = require_mkdirs();
     var remove = require_remove();
     var emptyDir = u(async function emptyDir2(dir) {
       let items;
       try {
-        items = await fs13.readdir(dir);
+        items = await fs14.readdir(dir);
       } catch {
         return mkdir.mkdirs(dir);
       }
@@ -2117,7 +2143,7 @@ var require_empty = __commonJS({
     function emptyDirSync(dir) {
       let items;
       try {
-        items = fs13.readdirSync(dir);
+        items = fs14.readdirSync(dir);
       } catch {
         return mkdir.mkdirsSync(dir);
       }
@@ -2141,51 +2167,51 @@ var require_file = __commonJS({
     "use strict";
     var u = require_universalify().fromPromise;
     var path18 = __require("path");
-    var fs13 = require_fs();
+    var fs14 = require_fs();
     var mkdir = require_mkdirs();
     async function createFile(file) {
       let stats;
       try {
-        stats = await fs13.stat(file);
+        stats = await fs14.stat(file);
       } catch {
       }
       if (stats && stats.isFile()) return;
       const dir = path18.dirname(file);
       let dirStats = null;
       try {
-        dirStats = await fs13.stat(dir);
+        dirStats = await fs14.stat(dir);
       } catch (err) {
         if (err.code === "ENOENT") {
           await mkdir.mkdirs(dir);
-          await fs13.writeFile(file, "");
+          await fs14.writeFile(file, "");
           return;
         } else {
           throw err;
         }
       }
       if (dirStats.isDirectory()) {
-        await fs13.writeFile(file, "");
+        await fs14.writeFile(file, "");
       } else {
-        await fs13.readdir(dir);
+        await fs14.readdir(dir);
       }
     }
     function createFileSync(file) {
       let stats;
       try {
-        stats = fs13.statSync(file);
+        stats = fs14.statSync(file);
       } catch {
       }
       if (stats && stats.isFile()) return;
       const dir = path18.dirname(file);
       try {
-        if (!fs13.statSync(dir).isDirectory()) {
-          fs13.readdirSync(dir);
+        if (!fs14.statSync(dir).isDirectory()) {
+          fs14.readdirSync(dir);
         }
       } catch (err) {
         if (err && err.code === "ENOENT") mkdir.mkdirsSync(dir);
         else throw err;
       }
-      fs13.writeFileSync(file, "");
+      fs14.writeFileSync(file, "");
     }
     module.exports = {
       createFile: u(createFile),
@@ -2200,19 +2226,19 @@ var require_link = __commonJS({
     "use strict";
     var u = require_universalify().fromPromise;
     var path18 = __require("path");
-    var fs13 = require_fs();
+    var fs14 = require_fs();
     var mkdir = require_mkdirs();
     var { pathExists } = require_path_exists();
     var { areIdentical } = require_stat();
     async function createLink(srcpath, dstpath) {
       let dstStat;
       try {
-        dstStat = await fs13.lstat(dstpath);
+        dstStat = await fs14.lstat(dstpath);
       } catch {
       }
       let srcStat;
       try {
-        srcStat = await fs13.lstat(srcpath);
+        srcStat = await fs14.lstat(srcpath);
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureLink");
         throw err;
@@ -2223,26 +2249,26 @@ var require_link = __commonJS({
       if (!dirExists) {
         await mkdir.mkdirs(dir);
       }
-      await fs13.link(srcpath, dstpath);
+      await fs14.link(srcpath, dstpath);
     }
     function createLinkSync(srcpath, dstpath) {
       let dstStat;
       try {
-        dstStat = fs13.lstatSync(dstpath);
+        dstStat = fs14.lstatSync(dstpath);
       } catch {
       }
       try {
-        const srcStat = fs13.lstatSync(srcpath);
+        const srcStat = fs14.lstatSync(srcpath);
         if (dstStat && areIdentical(srcStat, dstStat)) return;
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureLink");
         throw err;
       }
       const dir = path18.dirname(dstpath);
-      const dirExists = fs13.existsSync(dir);
-      if (dirExists) return fs13.linkSync(srcpath, dstpath);
+      const dirExists = fs14.existsSync(dir);
+      if (dirExists) return fs14.linkSync(srcpath, dstpath);
       mkdir.mkdirsSync(dir);
-      return fs13.linkSync(srcpath, dstpath);
+      return fs14.linkSync(srcpath, dstpath);
     }
     module.exports = {
       createLink: u(createLink),
@@ -2256,13 +2282,13 @@ var require_symlink_paths = __commonJS({
   "../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports, module) {
     "use strict";
     var path18 = __require("path");
-    var fs13 = require_fs();
+    var fs14 = require_fs();
     var { pathExists } = require_path_exists();
     var u = require_universalify().fromPromise;
     async function symlinkPaths(srcpath, dstpath) {
       if (path18.isAbsolute(srcpath)) {
         try {
-          await fs13.lstat(srcpath);
+          await fs14.lstat(srcpath);
         } catch (err) {
           err.message = err.message.replace("lstat", "ensureSymlink");
           throw err;
@@ -2282,7 +2308,7 @@ var require_symlink_paths = __commonJS({
         };
       }
       try {
-        await fs13.lstat(srcpath);
+        await fs14.lstat(srcpath);
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureSymlink");
         throw err;
@@ -2294,7 +2320,7 @@ var require_symlink_paths = __commonJS({
     }
     function symlinkPathsSync(srcpath, dstpath) {
       if (path18.isAbsolute(srcpath)) {
-        const exists2 = fs13.existsSync(srcpath);
+        const exists2 = fs14.existsSync(srcpath);
         if (!exists2) throw new Error("absolute srcpath does not exist");
         return {
           toCwd: srcpath,
@@ -2303,14 +2329,14 @@ var require_symlink_paths = __commonJS({
       }
       const dstdir = path18.dirname(dstpath);
       const relativeToDst = path18.join(dstdir, srcpath);
-      const exists = fs13.existsSync(relativeToDst);
+      const exists = fs14.existsSync(relativeToDst);
       if (exists) {
         return {
           toCwd: relativeToDst,
           toDst: srcpath
         };
       }
-      const srcExists = fs13.existsSync(srcpath);
+      const srcExists = fs14.existsSync(srcpath);
       if (!srcExists) throw new Error("relative srcpath does not exist");
       return {
         toCwd: srcpath,
@@ -2328,13 +2354,13 @@ var require_symlink_paths = __commonJS({
 var require_symlink_type = __commonJS({
   "../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/ensure/symlink-type.js"(exports, module) {
     "use strict";
-    var fs13 = require_fs();
+    var fs14 = require_fs();
     var u = require_universalify().fromPromise;
     async function symlinkType(srcpath, type) {
       if (type) return type;
       let stats;
       try {
-        stats = await fs13.lstat(srcpath);
+        stats = await fs14.lstat(srcpath);
       } catch {
         return "file";
       }
@@ -2344,7 +2370,7 @@ var require_symlink_type = __commonJS({
       if (type) return type;
       let stats;
       try {
-        stats = fs13.lstatSync(srcpath);
+        stats = fs14.lstatSync(srcpath);
       } catch {
         return "file";
       }
@@ -2363,7 +2389,7 @@ var require_symlink = __commonJS({
     "use strict";
     var u = require_universalify().fromPromise;
     var path18 = __require("path");
-    var fs13 = require_fs();
+    var fs14 = require_fs();
     var { mkdirs, mkdirsSync } = require_mkdirs();
     var { symlinkPaths, symlinkPathsSync } = require_symlink_paths();
     var { symlinkType, symlinkTypeSync } = require_symlink_type();
@@ -2372,23 +2398,23 @@ var require_symlink = __commonJS({
     async function createSymlink(srcpath, dstpath, type) {
       let stats;
       try {
-        stats = await fs13.lstat(dstpath);
+        stats = await fs14.lstat(dstpath);
       } catch {
       }
       if (stats && stats.isSymbolicLink()) {
         let srcStat;
         if (path18.isAbsolute(srcpath)) {
-          srcStat = await fs13.stat(srcpath);
+          srcStat = await fs14.stat(srcpath);
         } else {
           const dstdir = path18.dirname(dstpath);
           const relativeToDst = path18.join(dstdir, srcpath);
           try {
-            srcStat = await fs13.stat(relativeToDst);
+            srcStat = await fs14.stat(relativeToDst);
           } catch {
-            srcStat = await fs13.stat(srcpath);
+            srcStat = await fs14.stat(srcpath);
           }
         }
-        const dstStat = await fs13.stat(dstpath);
+        const dstStat = await fs14.stat(dstpath);
         if (areIdentical(srcStat, dstStat)) return;
       }
       const relative = await symlinkPaths(srcpath, dstpath);
@@ -2398,38 +2424,38 @@ var require_symlink = __commonJS({
       if (!await pathExists(dir)) {
         await mkdirs(dir);
       }
-      return fs13.symlink(srcpath, dstpath, toType);
+      return fs14.symlink(srcpath, dstpath, toType);
     }
     function createSymlinkSync2(srcpath, dstpath, type) {
       let stats;
       try {
-        stats = fs13.lstatSync(dstpath);
+        stats = fs14.lstatSync(dstpath);
       } catch {
       }
       if (stats && stats.isSymbolicLink()) {
         let srcStat;
         if (path18.isAbsolute(srcpath)) {
-          srcStat = fs13.statSync(srcpath);
+          srcStat = fs14.statSync(srcpath);
         } else {
           const dstdir = path18.dirname(dstpath);
           const relativeToDst = path18.join(dstdir, srcpath);
           try {
-            srcStat = fs13.statSync(relativeToDst);
+            srcStat = fs14.statSync(relativeToDst);
           } catch {
-            srcStat = fs13.statSync(srcpath);
+            srcStat = fs14.statSync(srcpath);
           }
         }
-        const dstStat = fs13.statSync(dstpath);
+        const dstStat = fs14.statSync(dstpath);
         if (areIdentical(srcStat, dstStat)) return;
       }
       const relative = symlinkPathsSync(srcpath, dstpath);
       srcpath = relative.toDst;
       type = symlinkTypeSync(relative.toCwd, type);
       const dir = path18.dirname(dstpath);
-      const exists = fs13.existsSync(dir);
-      if (exists) return fs13.symlinkSync(srcpath, dstpath, type);
+      const exists = fs14.existsSync(dir);
+      if (exists) return fs14.symlinkSync(srcpath, dstpath, type);
       mkdirsSync(dir);
-      return fs13.symlinkSync(srcpath, dstpath, type);
+      return fs14.symlinkSync(srcpath, dstpath, type);
     }
     module.exports = {
       createSymlink: u(createSymlink),
@@ -2499,9 +2525,9 @@ var require_jsonfile = __commonJS({
       if (typeof options === "string") {
         options = { encoding: options };
       }
-      const fs13 = options.fs || _fs;
+      const fs14 = options.fs || _fs;
       const shouldThrow = "throws" in options ? options.throws : true;
-      let data = await universalify.fromCallback(fs13.readFile)(file, options);
+      let data = await universalify.fromCallback(fs14.readFile)(file, options);
       data = stripBom2(data);
       let obj;
       try {
@@ -2521,10 +2547,10 @@ var require_jsonfile = __commonJS({
       if (typeof options === "string") {
         options = { encoding: options };
       }
-      const fs13 = options.fs || _fs;
+      const fs14 = options.fs || _fs;
       const shouldThrow = "throws" in options ? options.throws : true;
       try {
-        let content = fs13.readFileSync(file, options);
+        let content = fs14.readFileSync(file, options);
         content = stripBom2(content);
         return JSON.parse(content, options.reviver);
       } catch (err) {
@@ -2537,15 +2563,15 @@ var require_jsonfile = __commonJS({
       }
     }
     async function _writeFile(file, obj, options = {}) {
-      const fs13 = options.fs || _fs;
+      const fs14 = options.fs || _fs;
       const str = stringify(obj, options);
-      await universalify.fromCallback(fs13.writeFile)(file, str, options);
+      await universalify.fromCallback(fs14.writeFile)(file, str, options);
     }
     var writeFile2 = universalify.fromPromise(_writeFile);
     function writeFileSync(file, obj, options = {}) {
-      const fs13 = options.fs || _fs;
+      const fs14 = options.fs || _fs;
       const str = stringify(obj, options);
-      return fs13.writeFileSync(file, str, options);
+      return fs14.writeFileSync(file, str, options);
     }
     module.exports = {
       readFile,
@@ -2576,7 +2602,7 @@ var require_output_file = __commonJS({
   "../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/output-file/index.js"(exports, module) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs13 = require_fs();
+    var fs14 = require_fs();
     var path18 = __require("path");
     var mkdir = require_mkdirs();
     var pathExists = require_path_exists().pathExists;
@@ -2585,14 +2611,14 @@ var require_output_file = __commonJS({
       if (!await pathExists(dir)) {
         await mkdir.mkdirs(dir);
       }
-      return fs13.writeFile(file, data, encoding);
+      return fs14.writeFile(file, data, encoding);
     }
     function outputFileSync(file, ...args) {
       const dir = path18.dirname(file);
-      if (!fs13.existsSync(dir)) {
+      if (!fs14.existsSync(dir)) {
         mkdir.mkdirsSync(dir);
       }
-      fs13.writeFileSync(file, ...args);
+      fs14.writeFileSync(file, ...args);
     }
     module.exports = {
       outputFile: u(outputFile),
@@ -2651,7 +2677,7 @@ var require_json = __commonJS({
 var require_move = __commonJS({
   "../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/move/move.js"(exports, module) {
     "use strict";
-    var fs13 = require_fs();
+    var fs14 = require_fs();
     var path18 = __require("path");
     var { copy: copy2 } = require_copy2();
     var { remove } = require_remove();
@@ -2678,7 +2704,7 @@ var require_move = __commonJS({
         }
       }
       try {
-        await fs13.rename(src2, dest);
+        await fs14.rename(src2, dest);
       } catch (err) {
         if (err.code !== "EXDEV") {
           throw err;
@@ -2703,7 +2729,7 @@ var require_move = __commonJS({
 var require_move_sync = __commonJS({
   "../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/move/move-sync.js"(exports, module) {
     "use strict";
-    var fs13 = require_graceful_fs();
+    var fs14 = require_graceful_fs();
     var path18 = __require("path");
     var copySync2 = require_copy2().copySync;
     var removeSync = require_remove().removeSync;
@@ -2728,12 +2754,12 @@ var require_move_sync = __commonJS({
         removeSync(dest);
         return rename(src2, dest, overwrite);
       }
-      if (fs13.existsSync(dest)) throw new Error("dest already exists.");
+      if (fs14.existsSync(dest)) throw new Error("dest already exists.");
       return rename(src2, dest, overwrite);
     }
     function rename(src2, dest, overwrite) {
       try {
-        fs13.renameSync(src2, dest);
+        fs14.renameSync(src2, dest);
       } catch (err) {
         if (err.code !== "EXDEV") throw err;
         return moveAcrossDevice(src2, dest, overwrite);
@@ -2785,32 +2811,6 @@ var require_lib = __commonJS({
   }
 });
 
-// ../../../../../setup-pnpm/store/v11/links/@/is-windows/1.0.2/8de297753f5a2f0d3154b27e41b774686b53f5e3c186cf9f734f0a5ce4054b2e/node_modules/is-windows/index.js
-var require_is_windows = __commonJS({
-  "../../../../../setup-pnpm/store/v11/links/@/is-windows/1.0.2/8de297753f5a2f0d3154b27e41b774686b53f5e3c186cf9f734f0a5ce4054b2e/node_modules/is-windows/index.js"(exports, module) {
-    (function(factory) {
-      if (exports && typeof exports === "object" && typeof module !== "undefined") {
-        module.exports = factory();
-      } else if (typeof define === "function" && define.amd) {
-        define([], factory);
-      } else if (typeof window !== "undefined") {
-        window.isWindows = factory();
-      } else if (typeof global !== "undefined") {
-        global.isWindows = factory();
-      } else if (typeof self !== "undefined") {
-        self.isWindows = factory();
-      } else {
-        this.isWindows = factory();
-      }
-    })(function() {
-      "use strict";
-      return function isWindows2() {
-        return process && (process.platform === "win32" || /^(msys|cygwin)$/.test(process.env.OSTYPE));
-      };
-    });
-  }
-});
-
 // ../../../../../setup-pnpm/store/v11/links/@/validate-npm-package-name/7.0.2/814dcb947be9900c7df1d25263921c519f02120f3fc85aa99a69894e271e5507/node_modules/validate-npm-package-name/lib/builtin-modules.json
 var require_builtin_modules = __commonJS({
   "../../../../../setup-pnpm/store/v11/links/@/validate-npm-package-name/7.0.2/814dcb947be9900c7df1d25263921c519f02120f3fc85aa99a69894e271e5507/node_modules/validate-npm-package-name/lib/builtin-modules.json"(exports, module) {
@@ -4922,7 +4922,7 @@ var require_fs2 = __commonJS({
   "../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.0/e439e6fd4e4e9f79a9b4208fa39fea4dd6d7c4364cffe6989d0b5179d7e3aec7/node_modules/fs-extra/lib/fs/index.js"(exports) {
     "use strict";
     var u = require_universalify().fromCallback;
-    var fs13 = require_graceful_fs();
+    var fs14 = require_graceful_fs();
     var api = [
       "access",
       "appendFile",
@@ -4963,26 +4963,26 @@ var require_fs2 = __commonJS({
       "utimes",
       "writeFile"
     ].filter((key) => {
-      return typeof fs13[key] === "function";
+      return typeof fs14[key] === "function";
     });
-    Object.assign(exports, fs13);
+    Object.assign(exports, fs14);
     api.forEach((method) => {
-      exports[method] = u(fs13[method]);
+      exports[method] = u(fs14[method]);
     });
     exports.exists = function(filename, callback) {
       if (typeof callback === "function") {
-        return fs13.exists(filename, callback);
+        return fs14.exists(filename, callback);
       }
       return new Promise((resolve) => {
-        return fs13.exists(filename, resolve);
+        return fs14.exists(filename, resolve);
       });
     };
     exports.read = function(fd, buffer, offset, length, position3, callback) {
       if (typeof callback === "function") {
-        return fs13.read(fd, buffer, offset, length, position3, callback);
+        return fs14.read(fd, buffer, offset, length, position3, callback);
       }
       return new Promise((resolve, reject) => {
-        fs13.read(fd, buffer, offset, length, position3, (err, bytesRead, buffer2) => {
+        fs14.read(fd, buffer, offset, length, position3, (err, bytesRead, buffer2) => {
           if (err) return reject(err);
           resolve({ bytesRead, buffer: buffer2 });
         });
@@ -4990,10 +4990,10 @@ var require_fs2 = __commonJS({
     };
     exports.write = function(fd, buffer, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs13.write(fd, buffer, ...args);
+        return fs14.write(fd, buffer, ...args);
       }
       return new Promise((resolve, reject) => {
-        fs13.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
+        fs14.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
           if (err) return reject(err);
           resolve({ bytesWritten, buffer: buffer2 });
         });
@@ -5001,10 +5001,10 @@ var require_fs2 = __commonJS({
     };
     exports.readv = function(fd, buffers, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs13.readv(fd, buffers, ...args);
+        return fs14.readv(fd, buffers, ...args);
       }
       return new Promise((resolve, reject) => {
-        fs13.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
+        fs14.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
           if (err) return reject(err);
           resolve({ bytesRead, buffers: buffers2 });
         });
@@ -5012,17 +5012,17 @@ var require_fs2 = __commonJS({
     };
     exports.writev = function(fd, buffers, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs13.writev(fd, buffers, ...args);
+        return fs14.writev(fd, buffers, ...args);
       }
       return new Promise((resolve, reject) => {
-        fs13.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
+        fs14.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
           if (err) return reject(err);
           resolve({ bytesWritten, buffers: buffers2 });
         });
       });
     };
-    if (typeof fs13.realpath.native === "function") {
-      exports.realpath.native = u(fs13.realpath.native);
+    if (typeof fs14.realpath.native === "function") {
+      exports.realpath.native = u(fs14.realpath.native);
     } else {
       process.emitWarning(
         "fs.realpath.native is not a function. Is fs being monkey-patched?",
@@ -5055,7 +5055,7 @@ var require_utils3 = __commonJS({
 var require_make_dir2 = __commonJS({
   "../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.0/e439e6fd4e4e9f79a9b4208fa39fea4dd6d7c4364cffe6989d0b5179d7e3aec7/node_modules/fs-extra/lib/mkdirs/make-dir.js"(exports, module) {
     "use strict";
-    var fs13 = require_fs2();
+    var fs14 = require_fs2();
     var { checkPath } = require_utils3();
     var getMode = (options) => {
       const defaults = { mode: 511 };
@@ -5064,14 +5064,14 @@ var require_make_dir2 = __commonJS({
     };
     module.exports.makeDir = async (dir, options) => {
       checkPath(dir);
-      return fs13.mkdir(dir, {
+      return fs14.mkdir(dir, {
         mode: getMode(options),
         recursive: true
       });
     };
     module.exports.makeDirSync = (dir, options) => {
       checkPath(dir);
-      return fs13.mkdirSync(dir, {
+      return fs14.mkdirSync(dir, {
         mode: getMode(options),
         recursive: true
       });
@@ -5103,13 +5103,13 @@ var require_path_exists2 = __commonJS({
   "../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.0/e439e6fd4e4e9f79a9b4208fa39fea4dd6d7c4364cffe6989d0b5179d7e3aec7/node_modules/fs-extra/lib/path-exists/index.js"(exports, module) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs13 = require_fs2();
+    var fs14 = require_fs2();
     function pathExists(path18) {
-      return fs13.access(path18).then(() => true).catch(() => false);
+      return fs14.access(path18).then(() => true).catch(() => false);
     }
     module.exports = {
       pathExists: u(pathExists),
-      pathExistsSync: fs13.existsSync
+      pathExistsSync: fs14.existsSync
     };
   }
 });
@@ -5118,18 +5118,18 @@ var require_path_exists2 = __commonJS({
 var require_utimes2 = __commonJS({
   "../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.0/e439e6fd4e4e9f79a9b4208fa39fea4dd6d7c4364cffe6989d0b5179d7e3aec7/node_modules/fs-extra/lib/util/utimes.js"(exports, module) {
     "use strict";
-    var fs13 = require_fs2();
+    var fs14 = require_fs2();
     var u = require_universalify().fromPromise;
     async function utimesMillis(path18, atime, mtime) {
-      const fd = await fs13.open(path18, "r+");
+      const fd = await fs14.open(path18, "r+");
       let error = null;
       try {
-        await fs13.futimes(fd, atime, mtime);
+        await fs14.futimes(fd, atime, mtime);
       } catch (futimesErr) {
         error = futimesErr;
       } finally {
         try {
-          await fs13.close(fd);
+          await fs14.close(fd);
         } catch (closeErr) {
           if (!error) error = closeErr;
         }
@@ -5139,15 +5139,15 @@ var require_utimes2 = __commonJS({
       }
     }
     function utimesMillisSync(path18, atime, mtime) {
-      const fd = fs13.openSync(path18, "r+");
+      const fd = fs14.openSync(path18, "r+");
       let error = null;
       try {
-        fs13.futimesSync(fd, atime, mtime);
+        fs14.futimesSync(fd, atime, mtime);
       } catch (futimesErr) {
         error = futimesErr;
       } finally {
         try {
-          fs13.closeSync(fd);
+          fs14.closeSync(fd);
         } catch (closeErr) {
           if (!error) error = closeErr;
         }
@@ -5167,11 +5167,11 @@ var require_utimes2 = __commonJS({
 var require_stat2 = __commonJS({
   "../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.0/e439e6fd4e4e9f79a9b4208fa39fea4dd6d7c4364cffe6989d0b5179d7e3aec7/node_modules/fs-extra/lib/util/stat.js"(exports, module) {
     "use strict";
-    var fs13 = require_fs2();
+    var fs14 = require_fs2();
     var path18 = __require("path");
     var u = require_universalify().fromPromise;
     function getStats(src2, dest, opts2) {
-      const statFunc = opts2.dereference ? (file) => fs13.stat(file, { bigint: true }) : (file) => fs13.lstat(file, { bigint: true });
+      const statFunc = opts2.dereference ? (file) => fs14.stat(file, { bigint: true }) : (file) => fs14.lstat(file, { bigint: true });
       return Promise.all([
         statFunc(src2),
         statFunc(dest).catch((err) => {
@@ -5182,7 +5182,7 @@ var require_stat2 = __commonJS({
     }
     function getStatsSync(src2, dest, opts2) {
       let destStat;
-      const statFunc = opts2.dereference ? (file) => fs13.statSync(file, { bigint: true }) : (file) => fs13.lstatSync(file, { bigint: true });
+      const statFunc = opts2.dereference ? (file) => fs14.statSync(file, { bigint: true }) : (file) => fs14.lstatSync(file, { bigint: true });
       const srcStat = statFunc(src2);
       try {
         destStat = statFunc(dest);
@@ -5244,7 +5244,7 @@ var require_stat2 = __commonJS({
       if (destParent === srcParent || destParent === path18.parse(destParent).root) return;
       let destStat;
       try {
-        destStat = await fs13.stat(destParent, { bigint: true });
+        destStat = await fs14.stat(destParent, { bigint: true });
       } catch (err) {
         if (err.code === "ENOENT") return checkParentPaths(src2, srcStat, destParent, funcName);
         throw err;
@@ -5260,7 +5260,7 @@ var require_stat2 = __commonJS({
       if (destParent === srcParent || destParent === path18.parse(destParent).root) return;
       let destStat;
       try {
-        destStat = fs13.statSync(destParent, { bigint: true });
+        destStat = fs14.statSync(destParent, { bigint: true });
       } catch (err) {
         if (err.code === "ENOENT") return checkParentPathsSync(src2, srcStat, destParent, funcName);
         throw err;
@@ -5327,7 +5327,7 @@ var require_async2 = __commonJS({
 var require_copy3 = __commonJS({
   "../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.0/e439e6fd4e4e9f79a9b4208fa39fea4dd6d7c4364cffe6989d0b5179d7e3aec7/node_modules/fs-extra/lib/copy/copy.js"(exports, module) {
     "use strict";
-    var fs13 = require_fs2();
+    var fs14 = require_fs2();
     var path18 = __require("path");
     var { mkdirs } = require_mkdirs2();
     var { pathExists } = require_path_exists2();
@@ -5363,7 +5363,7 @@ var require_copy3 = __commonJS({
       return opts2.filter(src2, dest);
     }
     async function getStatsAndPerformCopy(destStat, src2, dest, opts2) {
-      const statFn = opts2.dereference ? fs13.stat : fs13.lstat;
+      const statFn = opts2.dereference ? fs14.stat : fs14.lstat;
       const srcStat = await statFn(src2);
       if (srcStat.isDirectory()) return onDir(srcStat, destStat, src2, dest, opts2);
       if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile(srcStat, destStat, src2, dest, opts2);
@@ -5375,7 +5375,7 @@ var require_copy3 = __commonJS({
     async function onFile(srcStat, destStat, src2, dest, opts2) {
       if (!destStat) return copyFile(srcStat, src2, dest, opts2);
       if (opts2.overwrite) {
-        await fs13.unlink(dest);
+        await fs14.unlink(dest);
         return copyFile(srcStat, src2, dest, opts2);
       }
       if (opts2.errorOnExist) {
@@ -5383,27 +5383,27 @@ var require_copy3 = __commonJS({
       }
     }
     async function copyFile(srcStat, src2, dest, opts2) {
-      await fs13.copyFile(src2, dest);
+      await fs14.copyFile(src2, dest);
       if (opts2.preserveTimestamps) {
         if (fileIsNotWritable(srcStat.mode)) {
           await makeFileWritable(dest, srcStat.mode);
         }
-        const updatedSrcStat = await fs13.stat(src2);
+        const updatedSrcStat = await fs14.stat(src2);
         await utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
       }
-      return fs13.chmod(dest, srcStat.mode);
+      return fs14.chmod(dest, srcStat.mode);
     }
     function fileIsNotWritable(srcMode) {
       return (srcMode & 128) === 0;
     }
     function makeFileWritable(dest, srcMode) {
-      return fs13.chmod(dest, srcMode | 128);
+      return fs14.chmod(dest, srcMode | 128);
     }
     async function onDir(srcStat, destStat, src2, dest, opts2) {
       if (!destStat) {
-        await fs13.mkdir(dest);
+        await fs14.mkdir(dest);
       }
-      await asyncIteratorConcurrentProcess(await fs13.opendir(src2), async (item) => {
+      await asyncIteratorConcurrentProcess(await fs14.opendir(src2), async (item) => {
         const srcItem = path18.join(src2, item.name);
         const destItem = path18.join(dest, item.name);
         const include = await runFilter(srcItem, destItem, opts2);
@@ -5413,22 +5413,22 @@ var require_copy3 = __commonJS({
         }
       });
       if (!destStat) {
-        await fs13.chmod(dest, srcStat.mode);
+        await fs14.chmod(dest, srcStat.mode);
       }
     }
     async function onLink(destStat, src2, dest, opts2) {
-      let resolvedSrc = await fs13.readlink(src2);
+      let resolvedSrc = await fs14.readlink(src2);
       if (opts2.dereference) {
         resolvedSrc = path18.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
-        return fs13.symlink(resolvedSrc, dest);
+        return fs14.symlink(resolvedSrc, dest);
       }
       let resolvedDest = null;
       try {
-        resolvedDest = await fs13.readlink(dest);
+        resolvedDest = await fs14.readlink(dest);
       } catch (e) {
-        if (e.code === "EINVAL" || e.code === "UNKNOWN") return fs13.symlink(resolvedSrc, dest);
+        if (e.code === "EINVAL" || e.code === "UNKNOWN") return fs14.symlink(resolvedSrc, dest);
         throw e;
       }
       if (opts2.dereference) {
@@ -5442,8 +5442,8 @@ var require_copy3 = __commonJS({
           throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
         }
       }
-      await fs13.unlink(dest);
-      return fs13.symlink(resolvedSrc, dest);
+      await fs14.unlink(dest);
+      return fs14.symlink(resolvedSrc, dest);
     }
     module.exports = copy2;
   }
@@ -5453,7 +5453,7 @@ var require_copy3 = __commonJS({
 var require_copy_sync2 = __commonJS({
   "../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.0/e439e6fd4e4e9f79a9b4208fa39fea4dd6d7c4364cffe6989d0b5179d7e3aec7/node_modules/fs-extra/lib/copy/copy-sync.js"(exports, module) {
     "use strict";
-    var fs13 = require_graceful_fs();
+    var fs14 = require_graceful_fs();
     var path18 = __require("path");
     var mkdirsSync = require_mkdirs2().mkdirsSync;
     var utimesMillisSync = require_utimes2().utimesMillisSync;
@@ -5476,11 +5476,11 @@ var require_copy_sync2 = __commonJS({
       stat.checkParentPathsSync(src2, srcStat, dest, "copy");
       if (opts2.filter && !opts2.filter(src2, dest)) return;
       const destParent = path18.dirname(dest);
-      if (!fs13.existsSync(destParent)) mkdirsSync(destParent);
+      if (!fs14.existsSync(destParent)) mkdirsSync(destParent);
       return getStats(destStat, src2, dest, opts2);
     }
     function getStats(destStat, src2, dest, opts2) {
-      const statSync = opts2.dereference ? fs13.statSync : fs13.lstatSync;
+      const statSync = opts2.dereference ? fs14.statSync : fs14.lstatSync;
       const srcStat = statSync(src2);
       if (srcStat.isDirectory()) return onDir(srcStat, destStat, src2, dest, opts2);
       else if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile(srcStat, destStat, src2, dest, opts2);
@@ -5495,14 +5495,14 @@ var require_copy_sync2 = __commonJS({
     }
     function mayCopyFile(srcStat, src2, dest, opts2) {
       if (opts2.overwrite) {
-        fs13.unlinkSync(dest);
+        fs14.unlinkSync(dest);
         return copyFile(srcStat, src2, dest, opts2);
       } else if (opts2.errorOnExist) {
         throw new Error(`'${dest}' already exists`);
       }
     }
     function copyFile(srcStat, src2, dest, opts2) {
-      fs13.copyFileSync(src2, dest);
+      fs14.copyFileSync(src2, dest);
       if (opts2.preserveTimestamps) handleTimestamps(srcStat.mode, src2, dest);
       return setDestMode(dest, srcStat.mode);
     }
@@ -5517,10 +5517,10 @@ var require_copy_sync2 = __commonJS({
       return setDestMode(dest, srcMode | 128);
     }
     function setDestMode(dest, srcMode) {
-      return fs13.chmodSync(dest, srcMode);
+      return fs14.chmodSync(dest, srcMode);
     }
     function setDestTimestamps(src2, dest) {
-      const updatedSrcStat = fs13.statSync(src2);
+      const updatedSrcStat = fs14.statSync(src2);
       return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
     }
     function onDir(srcStat, destStat, src2, dest, opts2) {
@@ -5528,12 +5528,12 @@ var require_copy_sync2 = __commonJS({
       return copyDir(src2, dest, opts2);
     }
     function mkDirAndCopy(srcMode, src2, dest, opts2) {
-      fs13.mkdirSync(dest);
+      fs14.mkdirSync(dest);
       copyDir(src2, dest, opts2);
       return setDestMode(dest, srcMode);
     }
     function copyDir(src2, dest, opts2) {
-      const dir = fs13.opendirSync(src2);
+      const dir = fs14.opendirSync(src2);
       try {
         let dirent;
         while ((dirent = dir.readSync()) !== null) {
@@ -5551,18 +5551,18 @@ var require_copy_sync2 = __commonJS({
       return getStats(destStat, srcItem, destItem, opts2);
     }
     function onLink(destStat, src2, dest, opts2) {
-      let resolvedSrc = fs13.readlinkSync(src2);
+      let resolvedSrc = fs14.readlinkSync(src2);
       if (opts2.dereference) {
         resolvedSrc = path18.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
-        return fs13.symlinkSync(resolvedSrc, dest);
+        return fs14.symlinkSync(resolvedSrc, dest);
       } else {
         let resolvedDest;
         try {
-          resolvedDest = fs13.readlinkSync(dest);
+          resolvedDest = fs14.readlinkSync(dest);
         } catch (err) {
-          if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs13.symlinkSync(resolvedSrc, dest);
+          if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs14.symlinkSync(resolvedSrc, dest);
           throw err;
         }
         if (opts2.dereference) {
@@ -5580,8 +5580,8 @@ var require_copy_sync2 = __commonJS({
       }
     }
     function copyLink(resolvedSrc, dest) {
-      fs13.unlinkSync(dest);
-      return fs13.symlinkSync(resolvedSrc, dest);
+      fs14.unlinkSync(dest);
+      return fs14.symlinkSync(resolvedSrc, dest);
     }
     module.exports = copySync2;
   }
@@ -5603,13 +5603,13 @@ var require_copy4 = __commonJS({
 var require_remove2 = __commonJS({
   "../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.0/e439e6fd4e4e9f79a9b4208fa39fea4dd6d7c4364cffe6989d0b5179d7e3aec7/node_modules/fs-extra/lib/remove/index.js"(exports, module) {
     "use strict";
-    var fs13 = require_graceful_fs();
+    var fs14 = require_graceful_fs();
     var u = require_universalify().fromCallback;
     function remove(path18, callback) {
-      fs13.rm(path18, { recursive: true, force: true }, callback);
+      fs14.rm(path18, { recursive: true, force: true }, callback);
     }
     function removeSync(path18) {
-      fs13.rmSync(path18, { recursive: true, force: true });
+      fs14.rmSync(path18, { recursive: true, force: true });
     }
     module.exports = {
       remove: u(remove),
@@ -5623,14 +5623,14 @@ var require_empty2 = __commonJS({
   "../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.0/e439e6fd4e4e9f79a9b4208fa39fea4dd6d7c4364cffe6989d0b5179d7e3aec7/node_modules/fs-extra/lib/empty/index.js"(exports, module) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs13 = require_fs2();
+    var fs14 = require_fs2();
     var path18 = __require("path");
     var mkdir = require_mkdirs2();
     var remove = require_remove2();
     var emptyDir = u(async function emptyDir2(dir) {
       let items;
       try {
-        items = await fs13.readdir(dir);
+        items = await fs14.readdir(dir);
       } catch {
         return mkdir.mkdirs(dir);
       }
@@ -5639,7 +5639,7 @@ var require_empty2 = __commonJS({
     function emptyDirSync(dir) {
       let items;
       try {
-        items = fs13.readdirSync(dir);
+        items = fs14.readdirSync(dir);
       } catch {
         return mkdir.mkdirsSync(dir);
       }
@@ -5663,51 +5663,51 @@ var require_file2 = __commonJS({
     "use strict";
     var u = require_universalify().fromPromise;
     var path18 = __require("path");
-    var fs13 = require_fs2();
+    var fs14 = require_fs2();
     var mkdir = require_mkdirs2();
     async function createFile(file) {
       let stats;
       try {
-        stats = await fs13.stat(file);
+        stats = await fs14.stat(file);
       } catch {
       }
       if (stats && stats.isFile()) return;
       const dir = path18.dirname(file);
       let dirStats = null;
       try {
-        dirStats = await fs13.stat(dir);
+        dirStats = await fs14.stat(dir);
       } catch (err) {
         if (err.code === "ENOENT") {
           await mkdir.mkdirs(dir);
-          await fs13.writeFile(file, "");
+          await fs14.writeFile(file, "");
           return;
         } else {
           throw err;
         }
       }
       if (dirStats.isDirectory()) {
-        await fs13.writeFile(file, "");
+        await fs14.writeFile(file, "");
       } else {
-        await fs13.readdir(dir);
+        await fs14.readdir(dir);
       }
     }
     function createFileSync(file) {
       let stats;
       try {
-        stats = fs13.statSync(file);
+        stats = fs14.statSync(file);
       } catch {
       }
       if (stats && stats.isFile()) return;
       const dir = path18.dirname(file);
       try {
-        if (!fs13.statSync(dir).isDirectory()) {
-          fs13.readdirSync(dir);
+        if (!fs14.statSync(dir).isDirectory()) {
+          fs14.readdirSync(dir);
         }
       } catch (err) {
         if (err && err.code === "ENOENT") mkdir.mkdirsSync(dir);
         else throw err;
       }
-      fs13.writeFileSync(file, "");
+      fs14.writeFileSync(file, "");
     }
     module.exports = {
       createFile: u(createFile),
@@ -5722,19 +5722,19 @@ var require_link2 = __commonJS({
     "use strict";
     var u = require_universalify().fromPromise;
     var path18 = __require("path");
-    var fs13 = require_fs2();
+    var fs14 = require_fs2();
     var mkdir = require_mkdirs2();
     var { pathExists } = require_path_exists2();
     var { areIdentical } = require_stat2();
     async function createLink(srcpath, dstpath) {
       let dstStat;
       try {
-        dstStat = await fs13.lstat(dstpath, { bigint: true });
+        dstStat = await fs14.lstat(dstpath, { bigint: true });
       } catch {
       }
       let srcStat;
       try {
-        srcStat = await fs13.lstat(srcpath, { bigint: true });
+        srcStat = await fs14.lstat(srcpath, { bigint: true });
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureLink");
         throw err;
@@ -5745,26 +5745,26 @@ var require_link2 = __commonJS({
       if (!dirExists) {
         await mkdir.mkdirs(dir);
       }
-      await fs13.link(srcpath, dstpath);
+      await fs14.link(srcpath, dstpath);
     }
     function createLinkSync(srcpath, dstpath) {
       let dstStat;
       try {
-        dstStat = fs13.lstatSync(dstpath, { bigint: true });
+        dstStat = fs14.lstatSync(dstpath, { bigint: true });
       } catch {
       }
       try {
-        const srcStat = fs13.lstatSync(srcpath, { bigint: true });
+        const srcStat = fs14.lstatSync(srcpath, { bigint: true });
         if (dstStat && areIdentical(srcStat, dstStat)) return;
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureLink");
         throw err;
       }
       const dir = path18.dirname(dstpath);
-      const dirExists = fs13.existsSync(dir);
-      if (dirExists) return fs13.linkSync(srcpath, dstpath);
+      const dirExists = fs14.existsSync(dir);
+      if (dirExists) return fs14.linkSync(srcpath, dstpath);
       mkdir.mkdirsSync(dir);
-      return fs13.linkSync(srcpath, dstpath);
+      return fs14.linkSync(srcpath, dstpath);
     }
     module.exports = {
       createLink: u(createLink),
@@ -5778,13 +5778,13 @@ var require_symlink_paths2 = __commonJS({
   "../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.0/e439e6fd4e4e9f79a9b4208fa39fea4dd6d7c4364cffe6989d0b5179d7e3aec7/node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports, module) {
     "use strict";
     var path18 = __require("path");
-    var fs13 = require_fs2();
+    var fs14 = require_fs2();
     var { pathExists } = require_path_exists2();
     var u = require_universalify().fromPromise;
     async function symlinkPaths(srcpath, dstpath) {
       if (path18.isAbsolute(srcpath)) {
         try {
-          await fs13.lstat(srcpath);
+          await fs14.lstat(srcpath);
         } catch (err) {
           err.message = err.message.replace("lstat", "ensureSymlink");
           throw err;
@@ -5804,7 +5804,7 @@ var require_symlink_paths2 = __commonJS({
         };
       }
       try {
-        await fs13.lstat(srcpath);
+        await fs14.lstat(srcpath);
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureSymlink");
         throw err;
@@ -5816,7 +5816,7 @@ var require_symlink_paths2 = __commonJS({
     }
     function symlinkPathsSync(srcpath, dstpath) {
       if (path18.isAbsolute(srcpath)) {
-        const exists2 = fs13.existsSync(srcpath);
+        const exists2 = fs14.existsSync(srcpath);
         if (!exists2) throw new Error("absolute srcpath does not exist");
         return {
           toCwd: srcpath,
@@ -5825,14 +5825,14 @@ var require_symlink_paths2 = __commonJS({
       }
       const dstdir = path18.dirname(dstpath);
       const relativeToDst = path18.join(dstdir, srcpath);
-      const exists = fs13.existsSync(relativeToDst);
+      const exists = fs14.existsSync(relativeToDst);
       if (exists) {
         return {
           toCwd: relativeToDst,
           toDst: srcpath
         };
       }
-      const srcExists = fs13.existsSync(srcpath);
+      const srcExists = fs14.existsSync(srcpath);
       if (!srcExists) throw new Error("relative srcpath does not exist");
       return {
         toCwd: srcpath,
@@ -5850,13 +5850,13 @@ var require_symlink_paths2 = __commonJS({
 var require_symlink_type2 = __commonJS({
   "../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.0/e439e6fd4e4e9f79a9b4208fa39fea4dd6d7c4364cffe6989d0b5179d7e3aec7/node_modules/fs-extra/lib/ensure/symlink-type.js"(exports, module) {
     "use strict";
-    var fs13 = require_fs2();
+    var fs14 = require_fs2();
     var u = require_universalify().fromPromise;
     async function symlinkType(srcpath, type) {
       if (type) return type;
       let stats;
       try {
-        stats = await fs13.lstat(srcpath);
+        stats = await fs14.lstat(srcpath);
       } catch {
         return "file";
       }
@@ -5866,7 +5866,7 @@ var require_symlink_type2 = __commonJS({
       if (type) return type;
       let stats;
       try {
-        stats = fs13.lstatSync(srcpath);
+        stats = fs14.lstatSync(srcpath);
       } catch {
         return "file";
       }
@@ -5885,7 +5885,7 @@ var require_symlink2 = __commonJS({
     "use strict";
     var u = require_universalify().fromPromise;
     var path18 = __require("path");
-    var fs13 = require_fs2();
+    var fs14 = require_fs2();
     var { mkdirs, mkdirsSync } = require_mkdirs2();
     var { symlinkPaths, symlinkPathsSync } = require_symlink_paths2();
     var { symlinkType, symlinkTypeSync } = require_symlink_type2();
@@ -5894,25 +5894,25 @@ var require_symlink2 = __commonJS({
     async function createSymlink(srcpath, dstpath, type) {
       let stats;
       try {
-        stats = await fs13.lstat(dstpath);
+        stats = await fs14.lstat(dstpath);
       } catch {
       }
       if (stats && stats.isSymbolicLink()) {
         let srcStat;
         if (path18.isAbsolute(srcpath)) {
-          srcStat = await fs13.stat(srcpath, { bigint: true });
+          srcStat = await fs14.stat(srcpath, { bigint: true });
         } else {
           const dstdir = path18.dirname(dstpath);
           const relativeToDst = path18.join(dstdir, srcpath);
           try {
-            srcStat = await fs13.stat(relativeToDst, { bigint: true });
+            srcStat = await fs14.stat(relativeToDst, { bigint: true });
           } catch {
-            srcStat = await fs13.stat(srcpath, { bigint: true });
+            srcStat = await fs14.stat(srcpath, { bigint: true });
           }
         }
         let dstStat;
         try {
-          dstStat = await fs13.stat(dstpath, { bigint: true });
+          dstStat = await fs14.stat(dstpath, { bigint: true });
         } catch (err) {
           if (err.code !== "ENOENT") throw err;
         }
@@ -5925,30 +5925,30 @@ var require_symlink2 = __commonJS({
       if (!await pathExists(dir)) {
         await mkdirs(dir);
       }
-      return fs13.symlink(srcpath, dstpath, toType);
+      return fs14.symlink(srcpath, dstpath, toType);
     }
     function createSymlinkSync2(srcpath, dstpath, type) {
       let stats;
       try {
-        stats = fs13.lstatSync(dstpath);
+        stats = fs14.lstatSync(dstpath);
       } catch {
       }
       if (stats && stats.isSymbolicLink()) {
         let srcStat;
         if (path18.isAbsolute(srcpath)) {
-          srcStat = fs13.statSync(srcpath, { bigint: true });
+          srcStat = fs14.statSync(srcpath, { bigint: true });
         } else {
           const dstdir = path18.dirname(dstpath);
           const relativeToDst = path18.join(dstdir, srcpath);
           try {
-            srcStat = fs13.statSync(relativeToDst, { bigint: true });
+            srcStat = fs14.statSync(relativeToDst, { bigint: true });
           } catch {
-            srcStat = fs13.statSync(srcpath, { bigint: true });
+            srcStat = fs14.statSync(srcpath, { bigint: true });
           }
         }
         let dstStat;
         try {
-          dstStat = fs13.statSync(dstpath, { bigint: true });
+          dstStat = fs14.statSync(dstpath, { bigint: true });
         } catch (err) {
           if (err.code !== "ENOENT") throw err;
         }
@@ -5958,10 +5958,10 @@ var require_symlink2 = __commonJS({
       srcpath = relative.toDst;
       type = symlinkTypeSync(relative.toCwd, type);
       const dir = path18.dirname(dstpath);
-      const exists = fs13.existsSync(dir);
-      if (exists) return fs13.symlinkSync(srcpath, dstpath, type);
+      const exists = fs14.existsSync(dir);
+      if (exists) return fs14.symlinkSync(srcpath, dstpath, type);
       mkdirsSync(dir);
-      return fs13.symlinkSync(srcpath, dstpath, type);
+      return fs14.symlinkSync(srcpath, dstpath, type);
     }
     module.exports = {
       createSymlink: u(createSymlink),
@@ -6017,7 +6017,7 @@ var require_output_file2 = __commonJS({
   "../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.0/e439e6fd4e4e9f79a9b4208fa39fea4dd6d7c4364cffe6989d0b5179d7e3aec7/node_modules/fs-extra/lib/output-file/index.js"(exports, module) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs13 = require_fs2();
+    var fs14 = require_fs2();
     var path18 = __require("path");
     var mkdir = require_mkdirs2();
     var pathExists = require_path_exists2().pathExists;
@@ -6026,14 +6026,14 @@ var require_output_file2 = __commonJS({
       if (!await pathExists(dir)) {
         await mkdir.mkdirs(dir);
       }
-      return fs13.writeFile(file, data, encoding);
+      return fs14.writeFile(file, data, encoding);
     }
     function outputFileSync(file, ...args) {
       const dir = path18.dirname(file);
-      if (!fs13.existsSync(dir)) {
+      if (!fs14.existsSync(dir)) {
         mkdir.mkdirsSync(dir);
       }
-      fs13.writeFileSync(file, ...args);
+      fs14.writeFileSync(file, ...args);
     }
     module.exports = {
       outputFile: u(outputFile),
@@ -6092,7 +6092,7 @@ var require_json2 = __commonJS({
 var require_move3 = __commonJS({
   "../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.0/e439e6fd4e4e9f79a9b4208fa39fea4dd6d7c4364cffe6989d0b5179d7e3aec7/node_modules/fs-extra/lib/move/move.js"(exports, module) {
     "use strict";
-    var fs13 = require_fs2();
+    var fs14 = require_fs2();
     var path18 = __require("path");
     var { copy: copy2 } = require_copy4();
     var { remove } = require_remove2();
@@ -6119,7 +6119,7 @@ var require_move3 = __commonJS({
         }
       }
       try {
-        await fs13.rename(src2, dest);
+        await fs14.rename(src2, dest);
       } catch (err) {
         if (err.code !== "EXDEV") {
           throw err;
@@ -6144,7 +6144,7 @@ var require_move3 = __commonJS({
 var require_move_sync2 = __commonJS({
   "../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.0/e439e6fd4e4e9f79a9b4208fa39fea4dd6d7c4364cffe6989d0b5179d7e3aec7/node_modules/fs-extra/lib/move/move-sync.js"(exports, module) {
     "use strict";
-    var fs13 = require_graceful_fs();
+    var fs14 = require_graceful_fs();
     var path18 = __require("path");
     var copySync2 = require_copy4().copySync;
     var removeSync = require_remove2().removeSync;
@@ -6169,12 +6169,12 @@ var require_move_sync2 = __commonJS({
         removeSync(dest);
         return rename(src2, dest, overwrite);
       }
-      if (fs13.existsSync(dest)) throw new Error("dest already exists.");
+      if (fs14.existsSync(dest)) throw new Error("dest already exists.");
       return rename(src2, dest, overwrite);
     }
     function rename(src2, dest, overwrite) {
       try {
-        fs13.renameSync(src2, dest);
+        fs14.renameSync(src2, dest);
       } catch (err) {
         if (err.code !== "EXDEV") throw err;
         return moveAcrossDevice(src2, dest, overwrite);
@@ -6333,27 +6333,27 @@ var require_process = __commonJS({
 var require_filesystem = __commonJS({
   "../../../../../setup-pnpm/store/v11/links/@/detect-libc/2.1.2/a1e36129e998f9971b8906296c04a9314f612077e4f1e2a4342793f735c2fb37/node_modules/detect-libc/lib/filesystem.js"(exports, module) {
     "use strict";
-    var fs13 = __require("fs");
+    var fs14 = __require("fs");
     var LDD_PATH = "/usr/bin/ldd";
     var SELF_PATH = "/proc/self/exe";
     var MAX_LENGTH = 2048;
     var readFileSync = (path18) => {
-      const fd = fs13.openSync(path18, "r");
+      const fd = fs14.openSync(path18, "r");
       const buffer = Buffer.alloc(MAX_LENGTH);
-      const bytesRead = fs13.readSync(fd, buffer, 0, MAX_LENGTH, 0);
-      fs13.close(fd, () => {
+      const bytesRead = fs14.readSync(fd, buffer, 0, MAX_LENGTH, 0);
+      fs14.close(fd, () => {
       });
       return buffer.subarray(0, bytesRead);
     };
     var readFile = (path18) => new Promise((resolve, reject) => {
-      fs13.open(path18, "r", (err, fd) => {
+      fs14.open(path18, "r", (err, fd) => {
         if (err) {
           reject(err);
         } else {
           const buffer = Buffer.alloc(MAX_LENGTH);
-          fs13.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
+          fs14.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
             resolve(buffer.subarray(0, bytesRead));
-            fs13.close(fd, () => {
+            fs14.close(fd, () => {
             });
           });
         }
@@ -6663,7 +6663,7 @@ var require_detect_libc = __commonJS({
 // ../../../../../setup-pnpm/store/v11/links/@/node-gyp-build-optional-packages/5.2.2/e2d2fc28f4d0eaa7fac1904123db86f87839f4cdd1ffc0e2b124adc9c1d9f616/node_modules/node-gyp-build-optional-packages/node-gyp-build.js
 var require_node_gyp_build = __commonJS({
   "../../../../../setup-pnpm/store/v11/links/@/node-gyp-build-optional-packages/5.2.2/e2d2fc28f4d0eaa7fac1904123db86f87839f4cdd1ffc0e2b124adc9c1d9f616/node_modules/node-gyp-build-optional-packages/node-gyp-build.js"(exports, module) {
-    var fs13 = __require("fs");
+    var fs14 = __require("fs");
     var path18 = __require("path");
     var url = __require("url");
     var os = __require("os");
@@ -6750,7 +6750,7 @@ var require_node_gyp_build = __commonJS({
     };
     function readdirSync(dir) {
       try {
-        return fs13.readdirSync(dir);
+        return fs14.readdirSync(dir);
       } catch (err) {
         return [];
       }
@@ -6878,7 +6878,7 @@ var require_msgpackr_extract = __commonJS({
 
 // ../worker/lib/start.js
 import crypto5 from "node:crypto";
-import fs12 from "node:fs";
+import fs13 from "node:fs";
 import path17 from "node:path";
 import util8 from "node:util";
 import { parentPort } from "node:worker_threads";
@@ -6943,13 +6943,17 @@ function formatIntegrity(algorithm, hexDigest) {
 
 // ../fs/hard-link-dir/lib/index.js
 import assert from "node:assert";
-import fs3 from "node:fs";
-import path3 from "node:path";
+import fs2 from "node:fs";
+import path2 from "node:path";
 import util2 from "node:util";
 
 // ../fs/graceful-fs/lib/index.js
 var import_graceful_fs = __toESM(require_graceful_fs(), 1);
+import fs from "node:fs";
 import util, { promisify } from "node:util";
+var RENAME_RETRY_BUDGET_MS = 6e4;
+var RENAME_RETRY_BACKOFF_CAP_MS = 100;
+var renameRetrySleepBuffer = new Int32Array(new SharedArrayBuffer(4));
 var lib_default = {
   chmod: promisify(import_graceful_fs.default.chmod),
   copyFile: promisify(import_graceful_fs.default.copyFile),
@@ -6989,6 +6993,25 @@ function withEagainRetry(fn, maxRetries = 15) {
     throw new Error("Unreachable");
   };
 }
+function renameFileWithRetry(src2, dest) {
+  const startedAt = Date.now();
+  let backoffMs = 0;
+  for (; ; ) {
+    try {
+      fs.renameSync(src2, dest);
+      return;
+    } catch (err) {
+      if (!isTransientRenameError(err) || Date.now() - startedAt >= RENAME_RETRY_BUDGET_MS)
+        throw err;
+      if (backoffMs > 0)
+        Atomics.wait(renameRetrySleepBuffer, 0, 0, backoffMs);
+      backoffMs = Math.min(backoffMs + 10, RENAME_RETRY_BACKOFF_CAP_MS);
+    }
+  }
+}
+function isTransientRenameError(err) {
+  return process.platform === "win32" && util.types.isNativeError(err) && "code" in err && (err.code === "EPERM" || err.code === "EACCES" || err.code === "EBUSY");
+}
 
 // ../core/logger/lib/logger.js
 var import_bole = __toESM(require_bole(), 1);
@@ -7154,165 +7177,42 @@ var createGenerator = (generateForCustomCharacters2, generateRandomBytes2) => ({
 };
 var cryptoRandomString = createGenerator(generateForCustomCharacters, generateRandomBytes);
 cryptoRandomString.async = createGenerator(generateForCustomCharactersAsync, generateRandomBytesAsync);
-var crypto_random_string_default = cryptoRandomString;
-
-// ../../../../../setup-pnpm/store/v11/links/@/unique-string/3.0.0/a866cc9b5c54cfdb51fd873a65f819a8cf9cedf7f734bec6917212cc97bd4e56/node_modules/unique-string/index.js
-function uniqueString() {
-  return crypto_random_string_default({ length: 32 });
-}
 
 // ../../../../../setup-pnpm/store/v11/links/@/path-temp/3.0.0/8b4b1aa7fd55674c92bd1b76de62ec746ab9b416377d8b2ecb6a51c4d56db367/node_modules/path-temp/index.js
 import { threadId } from "node:worker_threads";
-function pathTemp(folder) {
-  return path.join(folder, `_tmp_${process.pid}_${uniqueString()}`);
-}
 function fastPathTemp(file) {
   return path.join(path.dirname(file), `${path.basename(file)}_tmp_${process.pid}_${threadId}`);
 }
 
-// ../../../../../setup-pnpm/store/v11/links/@/rename-overwrite/7.0.1/87428b418e43a94bf7c7f463bfc62ae5e0dc2e0a72cb36b94d07cf207fc3347b/node_modules/rename-overwrite/index.js
-var import_fs_extra = __toESM(require_lib(), 1);
-import crypto2 from "node:crypto";
-import fs2 from "node:fs";
-import path2 from "node:path";
-
-// ../../../../../setup-pnpm/store/v11/links/@zkochan/rimraf/4.0.0/e7aeecc18d1d120ecda04415cbe146a0ad1e4d158a9823e79bfdce5ee3173719/node_modules/@zkochan/rimraf/index.js
-import fs from "node:fs";
-function rimrafSync(p) {
-  try {
-    fs.rmSync(p, { recursive: true, force: true, maxRetries: 3 });
-  } catch (err) {
-    if (err.code === "ENOENT") return;
-    throw err;
-  }
-}
-
-// ../../../../../setup-pnpm/store/v11/links/@/rename-overwrite/7.0.1/87428b418e43a94bf7c7f463bfc62ae5e0dc2e0a72cb36b94d07cf207fc3347b/node_modules/rename-overwrite/index.js
-var { copySync, copy } = import_fs_extra.default;
-function renameOverwriteSync(oldPath, newPath, retry = 0) {
-  try {
-    fs2.renameSync(oldPath, newPath);
-  } catch (err) {
-    retry++;
-    if (retry > 3) throw err;
-    switch (err.code) {
-      // Windows Antivirus issues
-      case "EPERM":
-      case "EACCESS":
-      case "EBUSY": {
-        try {
-          rimrafSync(newPath);
-        } catch {
-        }
-        const start = Date.now();
-        let backoff = 0;
-        let lastError = err;
-        while (Date.now() - start < 6e4 && (lastError.code === "EPERM" || lastError.code === "EACCESS" || lastError.code === "EBUSY")) {
-          const waitUntil = Date.now() + backoff;
-          while (waitUntil > Date.now()) {
-          }
-          try {
-            fs2.renameSync(oldPath, newPath);
-            return;
-          } catch (err2) {
-            lastError = err2;
-          }
-          if (backoff < 100) {
-            backoff += 10;
-          }
-        }
-        throw lastError;
-      }
-      case "ENOTEMPTY":
-      case "EEXIST":
-      case "ENOTDIR":
-        try {
-          swapRenameSync(oldPath, newPath);
-        } catch {
-          rimrafSync(newPath);
-          fs2.renameSync(oldPath, newPath);
-        }
-        break;
-      case "ENOENT":
-        fs2.mkdirSync(path2.dirname(newPath), { recursive: true });
-        renameOverwriteSync(oldPath, newPath, retry);
-        return;
-      // Crossing filesystem boundaries so rename is not available
-      case "EXDEV":
-        try {
-          rimrafSync(newPath);
-        } catch (rimrafErr) {
-          if (rimrafErr.code !== "ENOENT") {
-            throw rimrafErr;
-          }
-        }
-        copySync(oldPath, newPath);
-        rimrafSync(oldPath);
-        break;
-      default:
-        throw err;
-    }
-  }
-}
-function tempPath(p) {
-  return `${p}_${process.pid.toString(16)}_${crypto2.randomBytes(4).toString("hex")}`;
-}
-function swapRenameSync(oldPath, newPath) {
-  const temp = tempPath(newPath);
-  fs2.renameSync(newPath, temp);
-  try {
-    fs2.renameSync(oldPath, newPath);
-  } catch (err) {
-    try {
-      fs2.renameSync(temp, newPath);
-    } catch {
-    }
-    throw err;
-  }
-  try {
-    rimrafSync(temp);
-  } catch {
-  }
-}
-
 // ../fs/hard-link-dir/lib/index.js
 function hardLinkDir(src2, destDirs) {
-  if (destDirs.length === 0)
+  const targetDirs = destDirs.filter((destDir) => path2.relative(destDir, src2) !== "");
+  if (targetDirs.length === 0)
     return;
-  const filteredDestDirs = [];
-  const tempDestDirs = [];
-  for (const destDir of destDirs) {
-    if (path3.relative(destDir, src2) === "") {
-      continue;
-    }
-    filteredDestDirs.push(destDir);
-    tempDestDirs.push(pathTemp(path3.dirname(destDir)));
-  }
-  _hardLinkDir(src2, tempDestDirs, true);
-  for (let i = 0; i < filteredDestDirs.length; i++) {
-    renameOverwriteSync(tempDestDirs[i], filteredDestDirs[i]);
+  for (const targetDir of targetDirs) {
+    lib_default.mkdirSync(targetDir, { recursive: true });
   }
+  _hardLinkDir(src2, targetDirs, true);
 }
 function _hardLinkDir(src2, destDirs, isRoot) {
   let files = [];
   try {
-    files = fs3.readdirSync(src2);
+    files = fs2.readdirSync(src2);
   } catch (err) {
     if (!isRoot || !(util2.types.isNativeError(err) && "code" in err && err.code === "ENOENT"))
       throw err;
     globalWarn(`Source directory not found when creating hardLinks for: ${src2}. Creating destinations as empty: ${destDirs.join(", ")}`);
-    for (const dir of destDirs) {
-      lib_default.mkdirSync(dir, { recursive: true });
-    }
     return;
   }
   for (const file of files) {
     if (file === "node_modules")
       continue;
-    const srcFile = path3.join(src2, file);
-    if (fs3.lstatSync(srcFile).isDirectory()) {
+    const srcFile = path2.join(src2, file);
+    const srcStats = fs2.lstatSync(srcFile, { bigint: true });
+    if (srcStats.isDirectory()) {
       const destSubdirs = destDirs.map((destDir) => {
-        const destSubdir = path3.join(destDir, file);
+        const destSubdir = path2.join(destDir, file);
+        clearMismatchedDirent(destSubdir, true);
         try {
           lib_default.mkdirSync(destSubdir, { recursive: true });
         } catch (err) {
@@ -7325,9 +7225,9 @@ function _hardLinkDir(src2, destDirs, isRoot) {
       continue;
     }
     for (const destDir of destDirs) {
-      const destFile = path3.join(destDir, file);
+      const destFile = path2.join(destDir, file);
       try {
-        linkOrCopyFile(srcFile, destFile);
+        linkOrCopyFile(srcFile, destFile, srcStats);
       } catch (err) {
         if (util2.types.isNativeError(err) && "code" in err && err.code === "ENOENT") {
           continue;
@@ -7337,13 +7237,14 @@ function _hardLinkDir(src2, destDirs, isRoot) {
     }
   }
 }
-function linkOrCopyFile(srcFile, destFile) {
+function linkOrCopyFile(srcFile, destFile, srcStats) {
   try {
     linkOrCopy(srcFile, destFile);
+    return;
   } catch (err) {
     assert(util2.types.isNativeError(err));
     if ("code" in err && err.code === "ENOENT") {
-      lib_default.mkdirSync(path3.dirname(destFile), { recursive: true });
+      lib_default.mkdirSync(path2.dirname(destFile), { recursive: true });
       linkOrCopy(srcFile, destFile);
       return;
     }
@@ -7351,6 +7252,48 @@ function linkOrCopyFile(srcFile, destFile) {
       throw err;
     }
   }
+  if (isSameFile(destFile, srcStats))
+    return;
+  replaceFile(srcFile, destFile);
+}
+function isSameFile(destFile, srcStats) {
+  let destStats;
+  try {
+    destStats = fs2.lstatSync(destFile, { bigint: true });
+  } catch (err) {
+    if (util2.types.isNativeError(err) && "code" in err && err.code === "ENOENT")
+      return false;
+    throw err;
+  }
+  return destStats.ino !== 0n && destStats.dev !== 0n && destStats.ino === srcStats.ino && destStats.dev === srcStats.dev;
+}
+function replaceFile(srcFile, destFile) {
+  const tempFile = fastPathTemp(destFile);
+  fs2.rmSync(tempFile, { recursive: true, force: true });
+  try {
+    linkOrCopy(srcFile, tempFile);
+    clearMismatchedDirent(destFile, false);
+    renameFileWithRetry(tempFile, destFile);
+  } catch (err) {
+    try {
+      fs2.unlinkSync(tempFile);
+    } catch {
+    }
+    throw err;
+  }
+}
+function clearMismatchedDirent(destPath, wantDirectory) {
+  let stats;
+  try {
+    stats = fs2.lstatSync(destPath);
+  } catch (err) {
+    if (util2.types.isNativeError(err) && "code" in err && err.code === "ENOENT")
+      return;
+    throw err;
+  }
+  if (stats.isDirectory() === wantDirectory)
+    return;
+  fs2.rmSync(destPath, { recursive: true, force: true });
 }
 function linkOrCopy(srcFile, destFile) {
   try {
@@ -7441,12 +7384,12 @@ var updateCheckLogger = logger("update-check");
 
 // ../../../../../setup-pnpm/store/v11/links/@/better-path-resolve/2.0.0/e066f8a0a157777f698ec4707dc0026edc830ea8827eeb29a3d32906ea207d48/node_modules/better-path-resolve/index.js
 var import_is_windows = __toESM(require_is_windows(), 1);
-import path4 from "node:path";
-var betterPathResolve = (0, import_is_windows.default)() ? winResolve : path4.resolve;
+import path3 from "node:path";
+var betterPathResolve = (0, import_is_windows.default)() ? winResolve : path3.resolve;
 function winResolve(p) {
-  if (arguments.length === 0) return path4.resolve();
+  if (arguments.length === 0) return path3.resolve();
   if (typeof p !== "string") {
-    return path4.resolve(p);
+    return path3.resolve(p);
   }
   if (p[1] === ":") {
     const cc = p[0].charCodeAt();
@@ -7457,13 +7400,120 @@ function winResolve(p) {
   if (p.endsWith(":")) {
     return p;
   }
-  return path4.resolve(p);
+  return path3.resolve(p);
 }
 
 // ../../../../../setup-pnpm/store/v11/links/@/symlink-dir/10.0.1/99651a995e6d76e095bc87316473b0e784f9c820abf21dbac80a697d2ae16c64/node_modules/symlink-dir/dist/index.js
-import { promises as fs4, symlinkSync, mkdirSync, readlinkSync, unlinkSync } from "fs";
+import { promises as fs5, symlinkSync, mkdirSync, readlinkSync, unlinkSync } from "fs";
 import { types } from "util";
 import pathLib from "path";
+
+// ../../../../../setup-pnpm/store/v11/links/@/rename-overwrite/7.0.1/87428b418e43a94bf7c7f463bfc62ae5e0dc2e0a72cb36b94d07cf207fc3347b/node_modules/rename-overwrite/index.js
+var import_fs_extra = __toESM(require_lib(), 1);
+import crypto2 from "node:crypto";
+import fs4 from "node:fs";
+import path4 from "node:path";
+
+// ../../../../../setup-pnpm/store/v11/links/@zkochan/rimraf/4.0.0/e7aeecc18d1d120ecda04415cbe146a0ad1e4d158a9823e79bfdce5ee3173719/node_modules/@zkochan/rimraf/index.js
+import fs3 from "node:fs";
+function rimrafSync(p) {
+  try {
+    fs3.rmSync(p, { recursive: true, force: true, maxRetries: 3 });
+  } catch (err) {
+    if (err.code === "ENOENT") return;
+    throw err;
+  }
+}
+
+// ../../../../../setup-pnpm/store/v11/links/@/rename-overwrite/7.0.1/87428b418e43a94bf7c7f463bfc62ae5e0dc2e0a72cb36b94d07cf207fc3347b/node_modules/rename-overwrite/index.js
+var { copySync, copy } = import_fs_extra.default;
+function renameOverwriteSync(oldPath, newPath, retry = 0) {
+  try {
+    fs4.renameSync(oldPath, newPath);
+  } catch (err) {
+    retry++;
+    if (retry > 3) throw err;
+    switch (err.code) {
+      // Windows Antivirus issues
+      case "EPERM":
+      case "EACCESS":
+      case "EBUSY": {
+        try {
+          rimrafSync(newPath);
+        } catch {
+        }
+        const start = Date.now();
+        let backoff = 0;
+        let lastError = err;
+        while (Date.now() - start < 6e4 && (lastError.code === "EPERM" || lastError.code === "EACCESS" || lastError.code === "EBUSY")) {
+          const waitUntil = Date.now() + backoff;
+          while (waitUntil > Date.now()) {
+          }
+          try {
+            fs4.renameSync(oldPath, newPath);
+            return;
+          } catch (err2) {
+            lastError = err2;
+          }
+          if (backoff < 100) {
+            backoff += 10;
+          }
+        }
+        throw lastError;
+      }
+      case "ENOTEMPTY":
+      case "EEXIST":
+      case "ENOTDIR":
+        try {
+          swapRenameSync(oldPath, newPath);
+        } catch {
+          rimrafSync(newPath);
+          fs4.renameSync(oldPath, newPath);
+        }
+        break;
+      case "ENOENT":
+        fs4.mkdirSync(path4.dirname(newPath), { recursive: true });
+        renameOverwriteSync(oldPath, newPath, retry);
+        return;
+      // Crossing filesystem boundaries so rename is not available
+      case "EXDEV":
+        try {
+          rimrafSync(newPath);
+        } catch (rimrafErr) {
+          if (rimrafErr.code !== "ENOENT") {
+            throw rimrafErr;
+          }
+        }
+        copySync(oldPath, newPath);
+        rimrafSync(oldPath);
+        break;
+      default:
+        throw err;
+    }
+  }
+}
+function tempPath(p) {
+  return `${p}_${process.pid.toString(16)}_${crypto2.randomBytes(4).toString("hex")}`;
+}
+function swapRenameSync(oldPath, newPath) {
+  const temp = tempPath(newPath);
+  fs4.renameSync(newPath, temp);
+  try {
+    fs4.renameSync(oldPath, newPath);
+  } catch (err) {
+    try {
+      fs4.renameSync(temp, newPath);
+    } catch {
+    }
+    throw err;
+  }
+  try {
+    rimrafSync(temp);
+  } catch {
+  }
+}
+
+// ../../../../../setup-pnpm/store/v11/links/@/symlink-dir/10.0.1/99651a995e6d76e095bc87316473b0e784f9c820abf21dbac80a697d2ae16c64/node_modules/symlink-dir/dist/index.js
 var IS_WINDOWS = process.platform === "win32" || /^(msys|cygwin)$/.test(process.env.OSTYPE);
 function resolveSrcOnWinJunction(src2) {
   return `${src2}\\`;
@@ -7520,13 +7570,13 @@ if (IS_WINDOWS) {
   createSymlinkSync = createTrueSymlinkSync;
 }
 function createTrueSymlinkAsync(target2, path18) {
-  return fs4.symlink(resolveSrcOnTrueSymlink(target2, path18), path18, "dir");
+  return fs5.symlink(resolveSrcOnTrueSymlink(target2, path18), path18, "dir");
 }
 function createTrueSymlinkSync(target2, path18) {
   symlinkSync(resolveSrcOnTrueSymlink(target2, path18), path18, "dir");
 }
 function createJunctionAsync(target2, path18) {
-  return fs4.symlink(resolveSrcOnWinJunction(target2), path18, "junction");
+  return fs5.symlink(resolveSrcOnWinJunction(target2), path18, "junction");
 }
 function createJunctionSync(target2, path18) {
   symlinkSync(resolveSrcOnWinJunction(target2), path18, "junction");
@@ -7637,7 +7687,7 @@ function symlinkDependencySync(dependencyRealLocation, destModulesDir, importAs)
 import crypto4 from "node:crypto";
 
 // ../store/cafs/lib/addFilesFromDir.js
-import fs5, {} from "node:fs";
+import fs6, {} from "node:fs";
 import path7 from "node:path";
 import util3 from "node:util";
 
@@ -7670,7 +7720,7 @@ function addFilesFromDir(addBuffer, dirname, opts2 = {}) {
   const filesIndex = /* @__PURE__ */ new Map();
   let manifest;
   let files;
-  const resolvedRoot = fs5.realpathSync(dirname);
+  const resolvedRoot = fs6.realpathSync(dirname);
   if (opts2.files) {
     files = [];
     for (const file of opts2.files) {
@@ -7705,7 +7755,7 @@ function addFilesFromDir(addBuffer, dirname, opts2 = {}) {
 function getStatIfContained(absolutePath, rootDir) {
   let lstat;
   try {
-    lstat = fs5.lstatSync(absolutePath);
+    lstat = fs6.lstatSync(absolutePath);
   } catch (err) {
     if (util3.types.isNativeError(err) && "code" in err && err.code === "ENOENT") {
       return null;
@@ -7720,7 +7770,7 @@ function getStatIfContained(absolutePath, rootDir) {
 function getSymlinkStatIfContained(absolutePath, rootDir) {
   let realPath;
   try {
-    realPath = fs5.realpathSync(absolutePath);
+    realPath = fs6.realpathSync(absolutePath);
   } catch (err) {
     if (util3.types.isNativeError(err) && "code" in err && err.code === "ENOENT") {
       return null;
@@ -7730,7 +7780,7 @@ function getSymlinkStatIfContained(absolutePath, rootDir) {
   if (!isSubdir(rootDir, realPath)) {
     return null;
   }
-  return { stat: fs5.statSync(realPath), realPath };
+  return { stat: fs6.statSync(realPath), realPath };
 }
 function findFilesInDir(dir, rootDir, opts2) {
   const files = [];
@@ -7744,7 +7794,7 @@ function findFilesInDir(dir, rootDir, opts2) {
   return files;
 }
 function findFiles(ctx, dir, relativeDir, currentRealPath) {
-  const files = fs5.readdirSync(dir, { withFileTypes: true });
+  const files = fs6.readdirSync(dir, { withFileTypes: true });
   for (const file of files) {
     const relativeSubdir = `${relativeDir}${relativeDir ? "/" : ""}${file.name}`;
     const absolutePath = path7.join(dir, file.name);
@@ -7779,7 +7829,7 @@ function findFiles(ctx, dir, relativeDir, currentRealPath) {
     }
     let stat;
     try {
-      stat = fs5.statSync(absolutePath);
+      stat = fs6.statSync(absolutePath);
     } catch (err) {
       if (util3.types.isNativeError(err) && "code" in err && err.code === "ENOENT") {
         continue;
@@ -8018,7 +8068,7 @@ function addFilesFromTarball(addBufferToCafs2, tarballBuffer, readManifest, igno
 
 // ../store/cafs/lib/checkPkgFilesIntegrity.js
 import crypto3 from "node:crypto";
-import fs6 from "node:fs";
+import fs7 from "node:fs";
 import util4 from "node:util";
 
 // ../store/cafs/lib/getFilePathInCafs.js
@@ -8040,6 +8090,8 @@ function contentPathFromHex(fileType, hex) {
 }
 
 // ../store/cafs/lib/checkPkgFilesIntegrity.js
+var CHUNK_SIZE = 64 * 1024;
+var GUARDED_OPEN = (fs7.constants.O_NOFOLLOW ?? 0) | (fs7.constants.O_NONBLOCK ?? 0);
 var verifiedFileIntegrity = { files: 0, ms: 0 };
 function takeVerifiedFileIntegrity() {
   const taken = verifiedFileIntegrity;
@@ -8069,7 +8121,9 @@ function checkPkgFilesIntegrity(storeDir, pkgIndex) {
   }
   return {
     ...verified,
-    sideEffectsMaps: sideEffectsMaps.size > 0 ? sideEffectsMaps : void 0
+    sideEffectsMaps: sideEffectsMaps.size > 0 ? sideEffectsMaps : void 0,
+    sideEffectsDiffs: sideEffectsMaps.size > 0 ? matchingSideEffects(pkgIndex.sideEffects, sideEffectsMaps) : void 0,
+    remoteSideEffectsQuarantine: pkgIndex.remoteSideEffectsQuarantine
   };
 }
 function buildFileMapsFromIndex(storeDir, pkgIndex) {
@@ -8099,9 +8153,16 @@ function buildFileMapsFromIndex(storeDir, pkgIndex) {
   return {
     passed: true,
     filesMap,
-    sideEffectsMaps: sideEffectsMaps.size > 0 ? sideEffectsMaps : void 0
+    sideEffectsMaps: sideEffectsMaps.size > 0 ? sideEffectsMaps : void 0,
+    sideEffectsDiffs: sideEffectsMaps.size > 0 ? matchingSideEffects(pkgIndex.sideEffects, sideEffectsMaps) : void 0,
+    remoteSideEffectsQuarantine: pkgIndex.remoteSideEffectsQuarantine
   };
 }
+function matchingSideEffects(sideEffects, sideEffectsMaps) {
+  if (sideEffects == null)
+    return void 0;
+  return new Map(Array.from(sideEffects).filter(([cacheKey]) => sideEffectsMaps.has(cacheKey)));
+}
 function checkFilesIntegrity(verifiedFilesCache, storeDir, algo, files) {
   let allVerified = true;
   const filesMap = /* @__PURE__ */ new Map();
@@ -8179,7 +8240,7 @@ function hashMatches(data, integrity) {
 }
 function checkFile(filename, checkedAt) {
   try {
-    const { mtimeMs, size } = fs6.statSync(filename);
+    const { mtimeMs, size } = fs7.statSync(filename);
     return {
       isModified: mtimeMs - (checkedAt ?? 0) > 100,
       size
@@ -8239,7 +8300,7 @@ function normalizeBundledManifest(manifest) {
 }
 
 // ../store/cafs/lib/writeBufferToCafs.js
-import fs7 from "node:fs";
+import fs8 from "node:fs";
 import path11 from "node:path";
 import util5 from "node:util";
 import workerThreads from "node:worker_threads";
@@ -8280,7 +8341,7 @@ function writeBufferToCafs(locker, storeDir, buffer, fileDest, mode, integrity)
   };
 }
 function writeOrCheck(fileDest, buffer, mode, integrity) {
-  const existingFile = fs7.statSync(fileDest, { throwIfNoEntry: false });
+  const existingFile = fs8.statSync(fileDest, { throwIfNoEntry: false });
   if (existingFile) {
     if (verifyFileIntegrity(fileDest, integrity)) {
       return Date.now();
@@ -8301,7 +8362,7 @@ function writeOrCheck(fileDest, buffer, mode, integrity) {
   return Date.now();
 }
 function writeFileAtomic(fileDest, buffer, mode) {
-  const temp = pathTemp2(fileDest);
+  const temp = pathTemp(fileDest);
   writeFile(temp, buffer, mode);
   optimisticRenameOverwrite(temp, fileDest);
   return Date.now();
@@ -8310,11 +8371,11 @@ function optimisticRenameOverwrite(temp, fileDest) {
   try {
     renameOverwriteSync(temp, fileDest);
   } catch (err) {
-    if (!(util5.types.isNativeError(err) && "code" in err && err.code === "ENOENT") || !fs7.existsSync(fileDest))
+    if (!(util5.types.isNativeError(err) && "code" in err && err.code === "ENOENT") || !fs8.existsSync(fileDest))
       throw err;
   }
 }
-function pathTemp2(file) {
+function pathTemp(file) {
   const basename = removeSuffix(path11.basename(file));
   return path11.join(path11.dirname(file), `${basename}${process.pid}${workerThreads.threadId}`);
 }
@@ -8368,7 +8429,7 @@ function addBufferToCafs(writeBufferToCafs2, buffer, mode) {
 }
 
 // ../store/create-cafs-store/lib/index.js
-import { promises as fs10 } from "node:fs";
+import { promises as fs11 } from "node:fs";
 import path16 from "node:path";
 
 // ../fs/indexed-pkg-importer/lib/index.js
@@ -8378,20 +8439,20 @@ import path15 from "node:path";
 import util7 from "node:util";
 
 // ../fs/indexed-pkg-importer/lib/importIndexedDir.js
-import fs9 from "node:fs";
+import fs10 from "node:fs";
 import path13 from "node:path";
 import util6 from "node:util";
 var import_fs_extra2 = __toESM(require_lib3(), 1);
 
 // ../../../../../setup-pnpm/store/v11/links/@/make-empty-dir/4.0.0/3607722a2f7d328bdf182e4db3290941113e732fd2d785b1a5837ab89bb24489/node_modules/make-empty-dir/index.js
-import fs8 from "node:fs";
+import fs9 from "node:fs";
 import path12 from "node:path";
 function makeEmptyDirSync(dir, opts2) {
   if (opts2 && opts2.recursive) {
-    fs8.mkdirSync(path12.dirname(dir), { recursive: true });
+    fs9.mkdirSync(path12.dirname(dir), { recursive: true });
   }
   try {
-    fs8.mkdirSync(dir);
+    fs9.mkdirSync(dir);
     return "created";
   } catch (err) {
     if (err.code === "EEXIST") {
@@ -8402,7 +8463,7 @@ function makeEmptyDirSync(dir, opts2) {
   }
 }
 function removeContentsOfDirSync(dir) {
-  const items = fs8.readdirSync(dir);
+  const items = fs9.readdirSync(dir);
   for (const item of items) {
     rimrafSync(path12.join(dir, item));
   }
@@ -8411,10 +8472,7 @@ function removeContentsOfDirSync(dir) {
 // ../fs/indexed-pkg-importer/lib/importIndexedDir.js
 var import_sanitize_filename = __toESM(require_sanitize_filename(), 1);
 var filenameConflictsLogger = logger("_filename-conflicts");
-var RENAME_RETRY_BUDGET_MS = 6e4;
-var RENAME_RETRY_BACKOFF_CAP_MS = 100;
 var FILE_COMPARE_BUFFER_SIZE = 64 * 1024;
-var renameRetrySleepBuffer = new Int32Array(new SharedArrayBuffer(4));
 function importIndexedDir(importer, newDir, filenames, opts2) {
   const dirImport = { importer, newDir, filenames, opts: opts2 };
   if (opts2.safeToSkip && opts2.resolvedFrom !== "local-dir") {
@@ -8452,10 +8510,10 @@ function importIndexedDir(importer, newDir, filenames, opts2) {
 }
 function importIntoSharedDir(dirImport) {
   const { importer, newDir, filenames } = dirImport;
-  fs9.mkdirSync(path13.dirname(newDir), { recursive: true });
+  fs10.mkdirSync(path13.dirname(newDir), { recursive: true });
   let created = false;
   try {
-    fs9.mkdirSync(newDir);
+    fs10.mkdirSync(newDir);
     created = true;
   } catch (err) {
     if (!util6.types.isNativeError(err) || !("code" in err) || err.code !== "EEXIST")
@@ -8502,7 +8560,7 @@ function replaceFileIfDifferent(importFile, src2, dest) {
     importFile(src2, tmp);
   } catch (err) {
     try {
-      fs9.unlinkSync(tmp);
+      fs10.unlinkSync(tmp);
     } catch {
     }
     throw err;
@@ -8512,7 +8570,7 @@ function replaceFileIfDifferent(importFile, src2, dest) {
     renameFileWithRetry(tmp, dest);
   } catch (err) {
     try {
-      fs9.unlinkSync(tmp);
+      fs10.unlinkSync(tmp);
     } catch {
     }
     if (mismatchReason(dest, src2) === void 0)
@@ -8520,29 +8578,10 @@ function replaceFileIfDifferent(importFile, src2, dest) {
     throw err;
   }
 }
-function renameFileWithRetry(src2, dest) {
-  const startedAt = Date.now();
-  let backoffMs = 0;
-  for (; ; ) {
-    try {
-      fs9.renameSync(src2, dest);
-      return;
-    } catch (err) {
-      if (!isTransientRenameError(err) || Date.now() - startedAt >= RENAME_RETRY_BUDGET_MS)
-        throw err;
-      if (backoffMs > 0)
-        Atomics.wait(renameRetrySleepBuffer, 0, 0, backoffMs);
-      backoffMs = Math.min(backoffMs + 10, RENAME_RETRY_BACKOFF_CAP_MS);
-    }
-  }
-}
-function isTransientRenameError(err) {
-  return process.platform === "win32" && util6.types.isNativeError(err) && "code" in err && (err.code === "EPERM" || err.code === "EACCES" || err.code === "EBUSY");
-}
 function clearDirBlockingFile(dest) {
   let stats;
   try {
-    stats = fs9.lstatSync(dest);
+    stats = fs10.lstatSync(dest);
   } catch (err) {
     if (util6.types.isNativeError(err) && "code" in err && err.code === "ENOENT")
       return;
@@ -8558,7 +8597,7 @@ function clearDirentBlockingDir(newDir, relativeDir) {
     dir = path13.join(dir, segment);
     let stats;
     try {
-      stats = fs9.lstatSync(dir);
+      stats = fs10.lstatSync(dir);
     } catch (err) {
       if (util6.types.isNativeError(err) && "code" in err && err.code === "ENOENT")
         return;
@@ -8566,7 +8605,7 @@ function clearDirentBlockingDir(newDir, relativeDir) {
     }
     if (stats.isDirectory())
       continue;
-    fs9.unlinkSync(dir);
+    fs10.unlinkSync(dir);
     return;
   }
 }
@@ -8592,9 +8631,9 @@ function retryWithFixedFileMap(err, dirImport) {
   return false;
 }
 function tryExclusiveImport(importer, newDir, filenames) {
-  fs9.mkdirSync(path13.dirname(newDir), { recursive: true });
+  fs10.mkdirSync(path13.dirname(newDir), { recursive: true });
   try {
-    fs9.mkdirSync(newDir);
+    fs10.mkdirSync(newDir);
   } catch (err) {
     if (util6.types.isNativeError(err) && "code" in err && err.code === "EEXIST")
       return false;
@@ -8632,7 +8671,7 @@ function fileMatches(dir, f, src2) {
 }
 function mismatchReason(target2, src2) {
   try {
-    const targetStat = fs9.lstatSync(target2, { bigint: true });
+    const targetStat = fs10.lstatSync(target2, { bigint: true });
     if (!targetStat.isFile())
       return "is not a regular file";
     const srcStat = lib_default.statSync(src2, { bigint: true });
@@ -8651,13 +8690,13 @@ function mismatchReason(target2, src2) {
 function filesHaveEqualContents(left, right) {
   const leftBuffer = Buffer.allocUnsafe(FILE_COMPARE_BUFFER_SIZE);
   const rightBuffer = Buffer.allocUnsafe(FILE_COMPARE_BUFFER_SIZE);
-  const leftFd = fs9.openSync(left, "r");
+  const leftFd = fs10.openSync(left, "r");
   try {
-    const rightFd = fs9.openSync(right, "r");
+    const rightFd = fs10.openSync(right, "r");
     try {
       for (; ; ) {
-        const leftBytes = fs9.readSync(leftFd, leftBuffer, 0, leftBuffer.length, null);
-        const rightBytes = fs9.readSync(rightFd, rightBuffer, 0, rightBuffer.length, null);
+        const leftBytes = fs10.readSync(leftFd, leftBuffer, 0, leftBuffer.length, null);
+        const rightBytes = fs10.readSync(rightFd, rightBuffer, 0, rightBuffer.length, null);
         if (leftBytes !== rightBytes)
           return false;
         if (leftBytes === 0)
@@ -8666,10 +8705,10 @@ function filesHaveEqualContents(left, right) {
           return false;
       }
     } finally {
-      fs9.closeSync(rightFd);
+      fs10.closeSync(rightFd);
     }
   } finally {
-    fs9.closeSync(leftFd);
+    fs10.closeSync(leftFd);
   }
 }
 function retryWithSanitizedFilenames({ importer, newDir, filenames, opts: opts2 }) {
@@ -8718,7 +8757,7 @@ function makeFileMapDirs(newDir, filenames, opts2) {
     if (opts2?.clearBlockers) {
       clearDirentBlockingDir(newDir, dir);
     }
-    fs9.mkdirSync(path13.join(newDir, dir), { recursive: true });
+    fs10.mkdirSync(path13.join(newDir, dir), { recursive: true });
   }
 }
 function getUniqueFileMap(fileMap) {
@@ -8765,8 +8804,8 @@ function renameEvenAcrossDevices(src2, dest) {
   }
 }
 function mergeModulesDirs(src2, dest) {
-  const srcFiles = fs9.readdirSync(src2);
-  const destFiles = new Set(fs9.readdirSync(dest));
+  const srcFiles = fs10.readdirSync(src2);
+  const destFiles = new Set(fs10.readdirSync(dest));
   const filesToMove = srcFiles.filter((file) => !destFiles.has(file));
   for (const file of filesToMove) {
     renameEvenAcrossDevices(path13.join(src2, file), path13.join(dest, file));
@@ -9253,18 +9292,18 @@ function createCafsStore(storeDir, opts2) {
     storeDir,
     importPackage: importPackage2,
     tempDir: async () => {
-      await fs10.mkdir(baseTempDir, { recursive: true });
-      return fs10.mkdtemp(path16.join(baseTempDir, "_tmp_"));
+      await fs11.mkdir(baseTempDir, { recursive: true });
+      return fs11.mkdtemp(path16.join(baseTempDir, "_tmp_"));
     }
   };
 }
 
 // ../store/index/lib/index.js
-import fs11 from "node:fs";
+import fs12 from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
 import { pathToFileURL } from "node:url";
 
-// ../../../../../setup-pnpm/store/v11/links/@/msgpackr/2.0.5/120f9075aeb95a409234328542916ec7ee3248f89cf91e593ced8e5252fd92a6/node_modules/msgpackr/unpack.js
+// ../../../../../setup-pnpm/store/v11/links/@/msgpackr/2.0.6/a2aca5241063066c88f702ea8b49ae301bed78743a72adc0cb6671e2b0499054/node_modules/msgpackr/unpack.js
 var decoder;
 try {
   decoder = new TextDecoder();
@@ -9713,11 +9752,7 @@ function read() {
       default:
         if (token >= 224)
           return token - 256;
-        if (token === void 0) {
-          let error = new Error("Unexpected end of MessagePack data");
-          error.incomplete = true;
-          throw error;
-        }
+        if (token === void 0) throw endOfMessagePackError();
         throw new Error("Unknown MessagePack token " + token);
     }
   }
@@ -9891,7 +9926,13 @@ function readStringJS(length) {
   }
   return result;
 }
+function endOfMessagePackError() {
+  let error = new Error("Unexpected end of MessagePack data");
+  error.incomplete = true;
+  return error;
+}
 function readArray(length) {
+  if (length > srcEnd - position) throw endOfMessagePackError();
   let array = new Array(length);
   for (let i = 0; i < length; i++) {
     array[i] = read();
@@ -9901,6 +9942,7 @@ function readArray(length) {
   return array;
 }
 function readMap(length) {
+  if (length > (srcEnd - position) / 2) throw endOfMessagePackError();
   if (currentUnpackr.mapsAsObjects) {
     let object = {};
     for (let i = 0; i < length; i++) {
@@ -10390,7 +10432,7 @@ var f32Array = new Float32Array(1);
 var u8Array = new Uint8Array(f32Array.buffer, 0, 4);
 Unpackr.SUPPORTS_STRUCT_HOOKS = true;
 
-// ../../../../../setup-pnpm/store/v11/links/@/msgpackr/2.0.5/120f9075aeb95a409234328542916ec7ee3248f89cf91e593ced8e5252fd92a6/node_modules/msgpackr/pack.js
+// ../../../../../setup-pnpm/store/v11/links/@/msgpackr/2.0.6/a2aca5241063066c88f702ea8b49ae301bed78743a72adc0cb6671e2b0499054/node_modules/msgpackr/pack.js
 var textEncoder;
 try {
   textEncoder = new TextEncoder();
@@ -11453,7 +11495,7 @@ var REUSE_BUFFER_MODE = 512;
 var RESET_BUFFER_MODE = 1024;
 var RESERVE_START_SPACE = 2048;
 
-// ../../../../../setup-pnpm/store/v11/links/@/msgpackr/2.0.5/120f9075aeb95a409234328542916ec7ee3248f89cf91e593ced8e5252fd92a6/node_modules/msgpackr/node-index.js
+// ../../../../../setup-pnpm/store/v11/links/@/msgpackr/2.0.6/a2aca5241063066c88f702ea8b49ae301bed78743a72adc0cb6671e2b0499054/node_modules/msgpackr/node-index.js
 import { createRequire } from "module";
 var nativeAccelerationDisabled = process.env.MSGPACKR_NATIVE_ACCELERATION_DISABLED !== void 0 && process.env.MSGPACKR_NATIVE_ACCELERATION_DISABLED.toLowerCase() === "true";
 if (!nativeAccelerationDisabled) {
@@ -11529,7 +11571,7 @@ var StoreIndex = class {
   }
   /** Open the SQLite connection. Overridden by {@link ReadOnlyStoreIndex}. */
   openDatabase(storeDir) {
-    fs11.mkdirSync(storeDir, { recursive: true });
+    fs12.mkdirSync(storeDir, { recursive: true });
     this.db = new DatabaseSync(`${storeDir}/index.db`);
     this.db.exec("PRAGMA busy_timeout=5000");
     sqliteRetry(() => {
@@ -11576,6 +11618,29 @@ var StoreIndex = class {
       this.stmtSet.run(key, buffer);
     });
   }
+  update(key, updateValue) {
+    this.flush();
+    return sqliteRetry(() => {
+      this.db.exec("BEGIN IMMEDIATE");
+      try {
+        const row = this.stmtGet.get(key);
+        if (row == null) {
+          this.db.exec("COMMIT");
+          return false;
+        }
+        this.stmtSet.run(key, packr.pack(updateValue(packr.unpack(row.data))));
+        this.db.exec("COMMIT");
+        return true;
+      } catch (updateError) {
+        try {
+          this.db.exec("ROLLBACK");
+        } catch (rollbackError) {
+          throw new AggregateError([updateError, rollbackError], `Failed to roll back store index update for ${key}`, { cause: rollbackError });
+        }
+        throw updateError;
+      }
+    });
+  }
   delete(key) {
     let result;
     sqliteRetry(() => {
@@ -11739,6 +11804,9 @@ var ReadOnlyStoreIndex = class extends StoreIndex {
   delete(_key) {
     this.throwReadOnly();
   }
+  update(_key, _updateValue) {
+    this.throwReadOnly();
+  }
   queueWrites(_writes) {
     this.throwReadOnly();
   }
@@ -11879,8 +11947,11 @@ If you want to ignore this issue, set strictStorePkgContentCheck to false in you
             files: {
               filesMap: verifyResult.filesMap,
               sideEffectsMaps: verifyResult.sideEffectsMaps,
+              sideEffectsDiffs: verifyResult.sideEffectsDiffs,
+              remoteSideEffectsQuarantine: verifyResult.remoteSideEffectsQuarantine,
               resolvedFrom: "store",
-              requiresBuild
+              requiresBuild,
+              requiresPrepare: pkgFilesIndex.requiresPrepare
             }
           }
         });
@@ -11981,24 +12052,24 @@ function packToShared(data) {
   return view;
 }
 function initStore({ storeDir }) {
-  fs12.mkdirSync(storeDir, { recursive: true });
+  fs13.mkdirSync(storeDir, { recursive: true });
   const hexChars = "0123456789abcdef".split("");
   const filesDirPath = path17.join(storeDir, "files");
   try {
-    fs12.mkdirSync(filesDirPath);
+    fs13.mkdirSync(filesDirPath);
   } catch {
   }
   for (const hex1 of hexChars) {
     for (const hex2 of hexChars) {
       try {
-        fs12.mkdirSync(path17.join(filesDirPath, `${hex1}${hex2}`));
+        fs13.mkdirSync(path17.join(filesDirPath, `${hex1}${hex2}`));
       } catch {
       }
     }
   }
   return { status: "success" };
 }
-function addFilesFromDir2({ appendManifest, dir, files, filesIndexFile, includeNodeModules, sideEffectsCacheKey, storeDir }) {
+function addFilesFromDir2({ appendManifest, dir, files, filesIndexFile, includeNodeModules, requiresPrepare, sideEffectsCacheKey, storeDir }) {
   if (!cafsCache.has(storeDir)) {
     cafsCache.set(storeDir, createCafs(storeDir));
   }
@@ -12017,7 +12088,9 @@ function addFilesFromDir2({ appendManifest, dir, files, filesIndexFile, includeN
   const { filesIntegrity, filesMap } = processFilesIndex(filesIndex);
   const bundledManifest = manifest != null ? normalizeBundledManifest(manifest) : void 0;
   let requiresBuild;
+  let storedRequiresPrepare = requiresPrepare;
   let indexWrites;
+  let sideEffects;
   if (sideEffectsCacheKey) {
     const existingFilesIndex = getStoreIndex(storeDir).get(filesIndexFile);
     if (!existingFilesIndex) {
@@ -12036,24 +12109,37 @@ function addFilesFromDir2({ appendManifest, dir, files, filesIndexFile, includeN
     if (existingFilesIndex.algo !== HASH_ALGORITHM) {
       throw new PnpmError("ALGO_MISMATCH", `Algorithm mismatch: package index uses "${existingFilesIndex.algo}" but side effects were computed with "${HASH_ALGORITHM}"`);
     }
-    existingFilesIndex.sideEffects.set(sideEffectsCacheKey, calculateDiff(existingFilesIndex.files, filesIntegrity));
+    sideEffects = calculateDiff(existingFilesIndex.files, filesIntegrity);
+    existingFilesIndex.sideEffects.set(sideEffectsCacheKey, sideEffects);
     if (existingFilesIndex.requiresBuild == null) {
       requiresBuild = pkgRequiresBuild(manifest, filesMap);
     } else {
       requiresBuild = existingFilesIndex.requiresBuild;
     }
+    storedRequiresPrepare = existingFilesIndex.requiresPrepare;
     indexWrites = [{ key: filesIndexFile, buffer: packToShared(existingFilesIndex) }];
   } else {
     requiresBuild = pkgRequiresBuild(bundledManifest, filesIntegrity);
     const pkgFilesIndex = {
       requiresBuild,
+      requiresPrepare,
       manifest: bundledManifest,
       algo: HASH_ALGORITHM,
       files: filesIntegrity
     };
     indexWrites = [{ key: filesIndexFile, buffer: packToShared(pkgFilesIndex) }];
   }
-  return { status: "success", value: { filesMap, manifest: bundledManifest, requiresBuild }, indexWrites };
+  return {
+    status: "success",
+    value: {
+      filesMap,
+      manifest: bundledManifest,
+      requiresBuild,
+      requiresPrepare: storedRequiresPrepare,
+      sideEffects
+    },
+    indexWrites
+  };
 }
 function addManifestToCafs(cafs, filesIndex, manifest) {
   const fileBuffer = Buffer.from(JSON.stringify(manifest, null, 2), "utf8");