xtrm-tools 2.1.10 → 2.1.11

package/cli/dist/index.cjs

@@ -1202,8 +1202,8 @@ var require_command = __commonJS({
     "use strict";
     var EventEmitter2 = require("events").EventEmitter;
     var childProcess = require("child_process");
-    var path16 = require("path");
-    var fs17 = require("fs");
+    var path17 = require("path");
+    var fs18 = require("fs");
     var process19 = require("process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -2197,7 +2197,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} subcommandName
        */
       _checkForMissingExecutable(executableFile, executableDir, subcommandName) {
-        if (fs17.existsSync(executableFile)) return;
+        if (fs18.existsSync(executableFile)) return;
         const executableDirMessage = executableDir ? `searched for local subcommand relative to directory '${executableDir}'` : "no directory for search for local subcommand, use .executableDir() to supply a custom directory";
         const executableMissing = `'${executableFile}' does not exist
  - if '${subcommandName}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead
@@ -2215,11 +2215,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path16.resolve(baseDir, baseName);
-          if (fs17.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path16.extname(baseName))) return void 0;
+          const localBin = path17.resolve(baseDir, baseName);
+          if (fs18.existsSync(localBin)) return localBin;
+          if (sourceExt.includes(path17.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs17.existsSync(`${localBin}${ext}`)
+            (ext) => fs18.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -2231,21 +2231,21 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs17.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs18.realpathSync(this._scriptPath);
           } catch {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path16.resolve(
-            path16.dirname(resolvedScriptPath),
+          executableDir = path17.resolve(
+            path17.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path16.basename(
+            const legacyName = path17.basename(
               this._scriptPath,
-              path16.extname(this._scriptPath)
+              path17.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -2256,7 +2256,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path16.extname(executableFile));
+        launchWithNode = sourceExt.includes(path17.extname(executableFile));
         let proc;
         if (process19.platform !== "win32") {
           if (launchWithNode) {
@@ -3171,7 +3171,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path16.basename(filename, path16.extname(filename));
+        this._name = path17.basename(filename, path17.extname(filename));
         return this;
       }
       /**
@@ -3185,9 +3185,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path17) {
-        if (path17 === void 0) return this._executableDir;
-        this._executableDir = path17;
+      executableDir(path18) {
+        if (path18 === void 0) return this._executableDir;
+        this._executableDir = path18;
         return this;
       }
       /**
@@ -6053,7 +6053,7 @@ var require_dist = __commonJS({
         });
       };
     }
-    var prompts4 = require_prompts();
+    var prompts5 = require_prompts();
     var passOn = ["suggest", "format", "onState", "validate", "onRender", "type"];
     var noop = () => {
     };
@@ -6104,7 +6104,7 @@ var require_dist = __commonJS({
             var _question2 = question;
             name = _question2.name;
             type = _question2.type;
-            if (prompts4[type] === void 0) {
+            if (prompts5[type] === void 0) {
               throw new Error(`prompt type (${type}) is not defined`);
             }
             if (override2[question.name] !== void 0) {
@@ -6115,7 +6115,7 @@ var require_dist = __commonJS({
               }
             }
             try {
-              answer = prompt._injected ? getInjectedAnswer(prompt._injected, question.initial) : yield prompts4[type](question);
+              answer = prompt._injected ? getInjectedAnswer(prompt._injected, question.initial) : yield prompts5[type](question);
               answers[name] = answer = yield getFormattedAnswer(question, answer, true);
               quit = yield onSubmit(question, answer, answers);
             } catch (err) {
@@ -6147,7 +6147,7 @@ var require_dist = __commonJS({
     }
     module2.exports = Object.assign(prompt, {
       prompt,
-      prompts: prompts4,
+      prompts: prompts5,
       inject,
       override
     });
@@ -8234,7 +8234,7 @@ var require_prompts2 = __commonJS({
 var require_lib = __commonJS({
   "../node_modules/prompts/lib/index.js"(exports2, module2) {
     "use strict";
-    var prompts4 = require_prompts2();
+    var prompts5 = require_prompts2();
     var passOn = ["suggest", "format", "onState", "validate", "onRender", "type"];
     var noop = () => {
     };
@@ -8266,7 +8266,7 @@ var require_lib = __commonJS({
           throw new Error("prompt message is required");
         }
         ({ name, type } = question);
-        if (prompts4[type] === void 0) {
+        if (prompts5[type] === void 0) {
           throw new Error(`prompt type (${type}) is not defined`);
         }
         if (override2[question.name] !== void 0) {
@@ -8277,7 +8277,7 @@ var require_lib = __commonJS({
           }
         }
         try {
-          answer = prompt._injected ? getInjectedAnswer(prompt._injected, question.initial) : await prompts4[type](question);
+          answer = prompt._injected ? getInjectedAnswer(prompt._injected, question.initial) : await prompts5[type](question);
           answers[name] = answer = await getFormattedAnswer(question, answer, true);
           quit = await onSubmit(question, answer, answers);
         } catch (err) {
@@ -8300,7 +8300,7 @@ var require_lib = __commonJS({
     function override(answers) {
       prompt._override = Object.assign({}, answers);
     }
-    module2.exports = Object.assign(prompt, { prompt, prompts: prompts4, inject, override });
+    module2.exports = Object.assign(prompt, { prompt, prompts: prompts5, inject, override });
   }
 });
 
@@ -11639,54 +11639,54 @@ var require_polyfills = __commonJS({
     }
     var chdir;
     module2.exports = patch;
-    function patch(fs17) {
+    function patch(fs18) {
       if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-        patchLchmod(fs17);
-      }
-      if (!fs17.lutimes) {
-        patchLutimes(fs17);
-      }
-      fs17.chown = chownFix(fs17.chown);
-      fs17.fchown = chownFix(fs17.fchown);
-      fs17.lchown = chownFix(fs17.lchown);
-      fs17.chmod = chmodFix(fs17.chmod);
-      fs17.fchmod = chmodFix(fs17.fchmod);
-      fs17.lchmod = chmodFix(fs17.lchmod);
-      fs17.chownSync = chownFixSync(fs17.chownSync);
-      fs17.fchownSync = chownFixSync(fs17.fchownSync);
-      fs17.lchownSync = chownFixSync(fs17.lchownSync);
-      fs17.chmodSync = chmodFixSync(fs17.chmodSync);
-      fs17.fchmodSync = chmodFixSync(fs17.fchmodSync);
-      fs17.lchmodSync = chmodFixSync(fs17.lchmodSync);
-      fs17.stat = statFix(fs17.stat);
-      fs17.fstat = statFix(fs17.fstat);
-      fs17.lstat = statFix(fs17.lstat);
-      fs17.statSync = statFixSync(fs17.statSync);
-      fs17.fstatSync = statFixSync(fs17.fstatSync);
-      fs17.lstatSync = statFixSync(fs17.lstatSync);
-      if (fs17.chmod && !fs17.lchmod) {
-        fs17.lchmod = function(path16, mode, cb) {
+        patchLchmod(fs18);
+      }
+      if (!fs18.lutimes) {
+        patchLutimes(fs18);
+      }
+      fs18.chown = chownFix(fs18.chown);
+      fs18.fchown = chownFix(fs18.fchown);
+      fs18.lchown = chownFix(fs18.lchown);
+      fs18.chmod = chmodFix(fs18.chmod);
+      fs18.fchmod = chmodFix(fs18.fchmod);
+      fs18.lchmod = chmodFix(fs18.lchmod);
+      fs18.chownSync = chownFixSync(fs18.chownSync);
+      fs18.fchownSync = chownFixSync(fs18.fchownSync);
+      fs18.lchownSync = chownFixSync(fs18.lchownSync);
+      fs18.chmodSync = chmodFixSync(fs18.chmodSync);
+      fs18.fchmodSync = chmodFixSync(fs18.fchmodSync);
+      fs18.lchmodSync = chmodFixSync(fs18.lchmodSync);
+      fs18.stat = statFix(fs18.stat);
+      fs18.fstat = statFix(fs18.fstat);
+      fs18.lstat = statFix(fs18.lstat);
+      fs18.statSync = statFixSync(fs18.statSync);
+      fs18.fstatSync = statFixSync(fs18.fstatSync);
+      fs18.lstatSync = statFixSync(fs18.lstatSync);
+      if (fs18.chmod && !fs18.lchmod) {
+        fs18.lchmod = function(path17, mode, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs17.lchmodSync = function() {
+        fs18.lchmodSync = function() {
         };
       }
-      if (fs17.chown && !fs17.lchown) {
-        fs17.lchown = function(path16, uid, gid, cb) {
+      if (fs18.chown && !fs18.lchown) {
+        fs18.lchown = function(path17, uid, gid, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs17.lchownSync = function() {
+        fs18.lchownSync = function() {
         };
       }
       if (platform2 === "win32") {
-        fs17.rename = typeof fs17.rename !== "function" ? fs17.rename : (function(fs$rename) {
+        fs18.rename = typeof fs18.rename !== "function" ? fs18.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() {
-                  fs17.stat(to, function(stater, st) {
+                  fs18.stat(to, function(stater, st) {
                     if (stater && stater.code === "ENOENT")
                       fs$rename(from, to, CB);
                     else
@@ -11702,9 +11702,9 @@ var require_polyfills = __commonJS({
           }
           if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
           return rename;
-        })(fs17.rename);
+        })(fs18.rename);
       }
-      fs17.read = typeof fs17.read !== "function" ? fs17.read : (function(fs$read) {
+      fs18.read = typeof fs18.read !== "function" ? fs18.read : (function(fs$read) {
         function read(fd, buffer, offset, length, position, callback_) {
           var callback;
           if (callback_ && typeof callback_ === "function") {
@@ -11712,22 +11712,22 @@ var require_polyfills = __commonJS({
             callback = function(er, _, __) {
               if (er && er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
-                return fs$read.call(fs17, fd, buffer, offset, length, position, callback);
+                return fs$read.call(fs18, fd, buffer, offset, length, position, callback);
               }
               callback_.apply(this, arguments);
             };
           }
-          return fs$read.call(fs17, fd, buffer, offset, length, position, callback);
+          return fs$read.call(fs18, fd, buffer, offset, length, position, callback);
         }
         if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
         return read;
-      })(fs17.read);
-      fs17.readSync = typeof fs17.readSync !== "function" ? fs17.readSync : /* @__PURE__ */ (function(fs$readSync) {
+      })(fs18.read);
+      fs18.readSync = typeof fs18.readSync !== "function" ? fs18.readSync : /* @__PURE__ */ (function(fs$readSync) {
         return function(fd, buffer, offset, length, position) {
           var eagCounter = 0;
           while (true) {
             try {
-              return fs$readSync.call(fs17, fd, buffer, offset, length, position);
+              return fs$readSync.call(fs18, fd, buffer, offset, length, position);
             } catch (er) {
               if (er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
@@ -11737,11 +11737,11 @@ var require_polyfills = __commonJS({
             }
           }
         };
-      })(fs17.readSync);
-      function patchLchmod(fs18) {
-        fs18.lchmod = function(path16, mode, callback) {
-          fs18.open(
-            path16,
+      })(fs18.readSync);
+      function patchLchmod(fs19) {
+        fs19.lchmod = function(path17, mode, callback) {
+          fs19.open(
+            path17,
             constants.O_WRONLY | constants.O_SYMLINK,
             mode,
             function(err, fd) {
@@ -11749,80 +11749,80 @@ var require_polyfills = __commonJS({
                 if (callback) callback(err);
                 return;
               }
-              fs18.fchmod(fd, mode, function(err2) {
-                fs18.close(fd, function(err22) {
+              fs19.fchmod(fd, mode, function(err2) {
+                fs19.close(fd, function(err22) {
                   if (callback) callback(err2 || err22);
                 });
               });
             }
           );
         };
-        fs18.lchmodSync = function(path16, mode) {
-          var fd = fs18.openSync(path16, constants.O_WRONLY | constants.O_SYMLINK, mode);
+        fs19.lchmodSync = function(path17, mode) {
+          var fd = fs19.openSync(path17, constants.O_WRONLY | constants.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
-            ret = fs18.fchmodSync(fd, mode);
+            ret = fs19.fchmodSync(fd, mode);
             threw = false;
           } finally {
             if (threw) {
               try {
-                fs18.closeSync(fd);
+                fs19.closeSync(fd);
               } catch (er) {
               }
             } else {
-              fs18.closeSync(fd);
+              fs19.closeSync(fd);
             }
           }
           return ret;
         };
       }
-      function patchLutimes(fs18) {
-        if (constants.hasOwnProperty("O_SYMLINK") && fs18.futimes) {
-          fs18.lutimes = function(path16, at, mt, cb) {
-            fs18.open(path16, constants.O_SYMLINK, function(er, fd) {
+      function patchLutimes(fs19) {
+        if (constants.hasOwnProperty("O_SYMLINK") && fs19.futimes) {
+          fs19.lutimes = function(path17, at, mt, cb) {
+            fs19.open(path17, constants.O_SYMLINK, function(er, fd) {
               if (er) {
                 if (cb) cb(er);
                 return;
               }
-              fs18.futimes(fd, at, mt, function(er2) {
-                fs18.close(fd, function(er22) {
+              fs19.futimes(fd, at, mt, function(er2) {
+                fs19.close(fd, function(er22) {
                   if (cb) cb(er2 || er22);
                 });
               });
             });
           };
-          fs18.lutimesSync = function(path16, at, mt) {
-            var fd = fs18.openSync(path16, constants.O_SYMLINK);
+          fs19.lutimesSync = function(path17, at, mt) {
+            var fd = fs19.openSync(path17, constants.O_SYMLINK);
             var ret;
             var threw = true;
             try {
-              ret = fs18.futimesSync(fd, at, mt);
+              ret = fs19.futimesSync(fd, at, mt);
               threw = false;
             } finally {
               if (threw) {
                 try {
-                  fs18.closeSync(fd);
+                  fs19.closeSync(fd);
                 } catch (er) {
                 }
               } else {
-                fs18.closeSync(fd);
+                fs19.closeSync(fd);
               }
             }
             return ret;
           };
-        } else if (fs18.futimes) {
-          fs18.lutimes = function(_a2, _b, _c, cb) {
+        } else if (fs19.futimes) {
+          fs19.lutimes = function(_a2, _b, _c, cb) {
             if (cb) process.nextTick(cb);
           };
-          fs18.lutimesSync = function() {
+          fs19.lutimesSync = function() {
           };
         }
       }
       function chmodFix(orig) {
         if (!orig) return orig;
         return function(target, mode, cb) {
-          return orig.call(fs17, target, mode, function(er) {
+          return orig.call(fs18, target, mode, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -11832,7 +11832,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, mode) {
           try {
-            return orig.call(fs17, target, mode);
+            return orig.call(fs18, target, mode);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -11841,7 +11841,7 @@ var require_polyfills = __commonJS({
       function chownFix(orig) {
         if (!orig) return orig;
         return function(target, uid, gid, cb) {
-          return orig.call(fs17, target, uid, gid, function(er) {
+          return orig.call(fs18, target, uid, gid, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -11851,7 +11851,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, uid, gid) {
           try {
-            return orig.call(fs17, target, uid, gid);
+            return orig.call(fs18, target, uid, gid);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -11871,13 +11871,13 @@ var require_polyfills = __commonJS({
             }
             if (cb) cb.apply(this, arguments);
           }
-          return options ? orig.call(fs17, target, options, callback) : orig.call(fs17, target, callback);
+          return options ? orig.call(fs18, target, options, callback) : orig.call(fs18, target, callback);
         };
       }
       function statFixSync(orig) {
         if (!orig) return orig;
         return function(target, options) {
-          var stats = options ? orig.call(fs17, target, options) : orig.call(fs17, target);
+          var stats = options ? orig.call(fs18, target, options) : orig.call(fs18, target);
           if (stats) {
             if (stats.uid < 0) stats.uid += 4294967296;
             if (stats.gid < 0) stats.gid += 4294967296;
@@ -11907,16 +11907,16 @@ var require_legacy_streams = __commonJS({
     "use strict";
     var Stream = require("stream").Stream;
     module2.exports = legacy;
-    function legacy(fs17) {
+    function legacy(fs18) {
       return {
         ReadStream,
         WriteStream
       };
-      function ReadStream(path16, options) {
-        if (!(this instanceof ReadStream)) return new ReadStream(path16, options);
+      function ReadStream(path17, options) {
+        if (!(this instanceof ReadStream)) return new ReadStream(path17, options);
         Stream.call(this);
         var self = this;
-        this.path = path16;
+        this.path = path17;
         this.fd = null;
         this.readable = true;
         this.paused = false;
@@ -11950,7 +11950,7 @@ var require_legacy_streams = __commonJS({
           });
           return;
         }
-        fs17.open(this.path, this.flags, this.mode, function(err, fd) {
+        fs18.open(this.path, this.flags, this.mode, function(err, fd) {
           if (err) {
             self.emit("error", err);
             self.readable = false;
@@ -11961,10 +11961,10 @@ var require_legacy_streams = __commonJS({
           self._read();
         });
       }
-      function WriteStream(path16, options) {
-        if (!(this instanceof WriteStream)) return new WriteStream(path16, options);
+      function WriteStream(path17, options) {
+        if (!(this instanceof WriteStream)) return new WriteStream(path17, options);
         Stream.call(this);
-        this.path = path16;
+        this.path = path17;
         this.fd = null;
         this.writable = true;
         this.flags = "w";
@@ -11989,7 +11989,7 @@ var require_legacy_streams = __commonJS({
         this.busy = false;
         this._queue = [];
         if (this.fd === null) {
-          this._open = fs17.open;
+          this._open = fs18.open;
           this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
           this.flush();
         }
@@ -12025,7 +12025,7 @@ var require_clone = __commonJS({
 var require_graceful_fs = __commonJS({
   "../node_modules/graceful-fs/graceful-fs.js"(exports2, module2) {
     "use strict";
-    var fs17 = require("fs");
+    var fs18 = require("fs");
     var polyfills = require_polyfills();
     var legacy = require_legacy_streams();
     var clone3 = require_clone();
@@ -12057,12 +12057,12 @@ var require_graceful_fs = __commonJS({
         m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
         console.error(m);
       };
-    if (!fs17[gracefulQueue]) {
+    if (!fs18[gracefulQueue]) {
       queue = global[gracefulQueue] || [];
-      publishQueue(fs17, queue);
-      fs17.close = (function(fs$close) {
+      publishQueue(fs18, queue);
+      fs18.close = (function(fs$close) {
         function close(fd, cb) {
-          return fs$close.call(fs17, fd, function(err) {
+          return fs$close.call(fs18, fd, function(err) {
             if (!err) {
               resetQueue();
             }
@@ -12074,48 +12074,48 @@ var require_graceful_fs = __commonJS({
           value: fs$close
         });
         return close;
-      })(fs17.close);
-      fs17.closeSync = (function(fs$closeSync) {
+      })(fs18.close);
+      fs18.closeSync = (function(fs$closeSync) {
         function closeSync(fd) {
-          fs$closeSync.apply(fs17, arguments);
+          fs$closeSync.apply(fs18, arguments);
           resetQueue();
         }
         Object.defineProperty(closeSync, previousSymbol, {
           value: fs$closeSync
         });
         return closeSync;
-      })(fs17.closeSync);
+      })(fs18.closeSync);
       if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
         process.on("exit", function() {
-          debug(fs17[gracefulQueue]);
-          require("assert").equal(fs17[gracefulQueue].length, 0);
+          debug(fs18[gracefulQueue]);
+          require("assert").equal(fs18[gracefulQueue].length, 0);
         });
       }
     }
     var queue;
     if (!global[gracefulQueue]) {
-      publishQueue(global, fs17[gracefulQueue]);
-    }
-    module2.exports = patch(clone3(fs17));
-    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs17.__patched) {
-      module2.exports = patch(fs17);
-      fs17.__patched = true;
-    }
-    function patch(fs18) {
-      polyfills(fs18);
-      fs18.gracefulify = patch;
-      fs18.createReadStream = createReadStream;
-      fs18.createWriteStream = createWriteStream2;
-      var fs$readFile = fs18.readFile;
-      fs18.readFile = readFile;
-      function readFile(path16, options, cb) {
+      publishQueue(global, fs18[gracefulQueue]);
+    }
+    module2.exports = patch(clone3(fs18));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs18.__patched) {
+      module2.exports = patch(fs18);
+      fs18.__patched = true;
+    }
+    function patch(fs19) {
+      polyfills(fs19);
+      fs19.gracefulify = patch;
+      fs19.createReadStream = createReadStream;
+      fs19.createWriteStream = createWriteStream2;
+      var fs$readFile = fs19.readFile;
+      fs19.readFile = readFile;
+      function readFile(path17, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$readFile(path16, options, cb);
-        function go$readFile(path17, options2, cb2, startTime) {
-          return fs$readFile(path17, options2, function(err) {
+        return go$readFile(path17, options, cb);
+        function go$readFile(path18, options2, cb2, startTime) {
+          return fs$readFile(path18, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$readFile, [path17, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$readFile, [path18, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -12123,16 +12123,16 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$writeFile = fs18.writeFile;
-      fs18.writeFile = writeFile;
-      function writeFile(path16, data, options, cb) {
+      var fs$writeFile = fs19.writeFile;
+      fs19.writeFile = writeFile;
+      function writeFile(path17, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$writeFile(path16, data, options, cb);
-        function go$writeFile(path17, data2, options2, cb2, startTime) {
-          return fs$writeFile(path17, data2, options2, function(err) {
+        return go$writeFile(path17, data, options, cb);
+        function go$writeFile(path18, data2, options2, cb2, startTime) {
+          return fs$writeFile(path18, data2, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$writeFile, [path17, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$writeFile, [path18, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -12140,17 +12140,17 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$appendFile = fs18.appendFile;
+      var fs$appendFile = fs19.appendFile;
       if (fs$appendFile)
-        fs18.appendFile = appendFile;
-      function appendFile(path16, data, options, cb) {
+        fs19.appendFile = appendFile;
+      function appendFile(path17, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$appendFile(path16, data, options, cb);
-        function go$appendFile(path17, data2, options2, cb2, startTime) {
-          return fs$appendFile(path17, data2, options2, function(err) {
+        return go$appendFile(path17, data, options, cb);
+        function go$appendFile(path18, data2, options2, cb2, startTime) {
+          return fs$appendFile(path18, data2, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$appendFile, [path17, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$appendFile, [path18, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -12158,9 +12158,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$copyFile = fs18.copyFile;
+      var fs$copyFile = fs19.copyFile;
       if (fs$copyFile)
-        fs18.copyFile = copyFile;
+        fs19.copyFile = copyFile;
       function copyFile(src, dest, flags, cb) {
         if (typeof flags === "function") {
           cb = flags;
@@ -12178,34 +12178,34 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$readdir = fs18.readdir;
-      fs18.readdir = readdir;
+      var fs$readdir = fs19.readdir;
+      fs19.readdir = readdir;
       var noReaddirOptionVersions = /^v[0-5]\./;
-      function readdir(path16, options, cb) {
+      function readdir(path17, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path17, options2, cb2, startTime) {
-          return fs$readdir(path17, fs$readdirCallback(
-            path17,
+        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path18, options2, cb2, startTime) {
+          return fs$readdir(path18, fs$readdirCallback(
+            path18,
             options2,
             cb2,
             startTime
           ));
-        } : function go$readdir2(path17, options2, cb2, startTime) {
-          return fs$readdir(path17, options2, fs$readdirCallback(
-            path17,
+        } : function go$readdir2(path18, options2, cb2, startTime) {
+          return fs$readdir(path18, options2, fs$readdirCallback(
+            path18,
             options2,
             cb2,
             startTime
           ));
         };
-        return go$readdir(path16, options, cb);
-        function fs$readdirCallback(path17, options2, cb2, startTime) {
+        return go$readdir(path17, options, cb);
+        function fs$readdirCallback(path18, options2, cb2, startTime) {
           return function(err, files) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
               enqueue([
                 go$readdir,
-                [path17, options2, cb2],
+                [path18, options2, cb2],
                 err,
                 startTime || Date.now(),
                 Date.now()
@@ -12220,21 +12220,21 @@ var require_graceful_fs = __commonJS({
         }
       }
       if (process.version.substr(0, 4) === "v0.8") {
-        var legStreams = legacy(fs18);
+        var legStreams = legacy(fs19);
         ReadStream = legStreams.ReadStream;
         WriteStream = legStreams.WriteStream;
       }
-      var fs$ReadStream = fs18.ReadStream;
+      var fs$ReadStream = fs19.ReadStream;
       if (fs$ReadStream) {
         ReadStream.prototype = Object.create(fs$ReadStream.prototype);
         ReadStream.prototype.open = ReadStream$open;
       }
-      var fs$WriteStream = fs18.WriteStream;
+      var fs$WriteStream = fs19.WriteStream;
       if (fs$WriteStream) {
         WriteStream.prototype = Object.create(fs$WriteStream.prototype);
         WriteStream.prototype.open = WriteStream$open;
       }
-      Object.defineProperty(fs18, "ReadStream", {
+      Object.defineProperty(fs19, "ReadStream", {
         get: function() {
           return ReadStream;
         },
@@ -12244,7 +12244,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      Object.defineProperty(fs18, "WriteStream", {
+      Object.defineProperty(fs19, "WriteStream", {
         get: function() {
           return WriteStream;
         },
@@ -12255,7 +12255,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileReadStream = ReadStream;
-      Object.defineProperty(fs18, "FileReadStream", {
+      Object.defineProperty(fs19, "FileReadStream", {
         get: function() {
           return FileReadStream;
         },
@@ -12266,7 +12266,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileWriteStream = WriteStream;
-      Object.defineProperty(fs18, "FileWriteStream", {
+      Object.defineProperty(fs19, "FileWriteStream", {
         get: function() {
           return FileWriteStream;
         },
@@ -12276,7 +12276,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      function ReadStream(path16, options) {
+      function ReadStream(path17, options) {
         if (this instanceof ReadStream)
           return fs$ReadStream.apply(this, arguments), this;
         else
@@ -12296,7 +12296,7 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function WriteStream(path16, options) {
+      function WriteStream(path17, options) {
         if (this instanceof WriteStream)
           return fs$WriteStream.apply(this, arguments), this;
         else
@@ -12314,22 +12314,22 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function createReadStream(path16, options) {
-        return new fs18.ReadStream(path16, options);
+      function createReadStream(path17, options) {
+        return new fs19.ReadStream(path17, options);
       }
-      function createWriteStream2(path16, options) {
-        return new fs18.WriteStream(path16, options);
+      function createWriteStream2(path17, options) {
+        return new fs19.WriteStream(path17, options);
       }
-      var fs$open = fs18.open;
-      fs18.open = open;
-      function open(path16, flags, mode, cb) {
+      var fs$open = fs19.open;
+      fs19.open = open;
+      function open(path17, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
-        return go$open(path16, flags, mode, cb);
-        function go$open(path17, flags2, mode2, cb2, startTime) {
-          return fs$open(path17, flags2, mode2, function(err, fd) {
+        return go$open(path17, flags, mode, cb);
+        function go$open(path18, flags2, mode2, cb2, startTime) {
+          return fs$open(path18, flags2, mode2, function(err, fd) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$open, [path17, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$open, [path18, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -12337,20 +12337,20 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      return fs18;
+      return fs19;
     }
     function enqueue(elem) {
       debug("ENQUEUE", elem[0].name, elem[1]);
-      fs17[gracefulQueue].push(elem);
+      fs18[gracefulQueue].push(elem);
       retry();
     }
     var retryTimer;
     function resetQueue() {
       var now = Date.now();
-      for (var i = 0; i < fs17[gracefulQueue].length; ++i) {
-        if (fs17[gracefulQueue][i].length > 2) {
-          fs17[gracefulQueue][i][3] = now;
-          fs17[gracefulQueue][i][4] = now;
+      for (var i = 0; i < fs18[gracefulQueue].length; ++i) {
+        if (fs18[gracefulQueue][i].length > 2) {
+          fs18[gracefulQueue][i][3] = now;
+          fs18[gracefulQueue][i][4] = now;
         }
       }
       retry();
@@ -12358,9 +12358,9 @@ var require_graceful_fs = __commonJS({
     function retry() {
       clearTimeout(retryTimer);
       retryTimer = void 0;
-      if (fs17[gracefulQueue].length === 0)
+      if (fs18[gracefulQueue].length === 0)
         return;
-      var elem = fs17[gracefulQueue].shift();
+      var elem = fs18[gracefulQueue].shift();
       var fn = elem[0];
       var args = elem[1];
       var err = elem[2];
@@ -12382,7 +12382,7 @@ var require_graceful_fs = __commonJS({
           debug("RETRY", fn.name, args);
           fn.apply(null, args.concat([startTime]));
         } else {
-          fs17[gracefulQueue].push(elem);
+          fs18[gracefulQueue].push(elem);
         }
       }
       if (retryTimer === void 0) {
@@ -12397,7 +12397,7 @@ var require_fs = __commonJS({
   "../node_modules/fs-extra/lib/fs/index.js"(exports2) {
     "use strict";
     var u = require_universalify().fromCallback;
-    var fs17 = require_graceful_fs();
+    var fs18 = require_graceful_fs();
     var api = [
       "access",
       "appendFile",
@@ -12438,26 +12438,26 @@ var require_fs = __commonJS({
       "utimes",
       "writeFile"
     ].filter((key) => {
-      return typeof fs17[key] === "function";
+      return typeof fs18[key] === "function";
     });
-    Object.assign(exports2, fs17);
+    Object.assign(exports2, fs18);
     api.forEach((method) => {
-      exports2[method] = u(fs17[method]);
+      exports2[method] = u(fs18[method]);
     });
     exports2.exists = function(filename, callback) {
       if (typeof callback === "function") {
-        return fs17.exists(filename, callback);
+        return fs18.exists(filename, callback);
       }
       return new Promise((resolve2) => {
-        return fs17.exists(filename, resolve2);
+        return fs18.exists(filename, resolve2);
       });
     };
     exports2.read = function(fd, buffer, offset, length, position, callback) {
       if (typeof callback === "function") {
-        return fs17.read(fd, buffer, offset, length, position, callback);
+        return fs18.read(fd, buffer, offset, length, position, callback);
       }
       return new Promise((resolve2, reject) => {
-        fs17.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
+        fs18.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
           if (err) return reject(err);
           resolve2({ bytesRead, buffer: buffer2 });
         });
@@ -12465,10 +12465,10 @@ var require_fs = __commonJS({
     };
     exports2.write = function(fd, buffer, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs17.write(fd, buffer, ...args);
+        return fs18.write(fd, buffer, ...args);
       }
       return new Promise((resolve2, reject) => {
-        fs17.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
+        fs18.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
           if (err) return reject(err);
           resolve2({ bytesWritten, buffer: buffer2 });
         });
@@ -12476,10 +12476,10 @@ var require_fs = __commonJS({
     };
     exports2.readv = function(fd, buffers, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs17.readv(fd, buffers, ...args);
+        return fs18.readv(fd, buffers, ...args);
       }
       return new Promise((resolve2, reject) => {
-        fs17.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
+        fs18.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
           if (err) return reject(err);
           resolve2({ bytesRead, buffers: buffers2 });
         });
@@ -12487,17 +12487,17 @@ var require_fs = __commonJS({
     };
     exports2.writev = function(fd, buffers, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs17.writev(fd, buffers, ...args);
+        return fs18.writev(fd, buffers, ...args);
       }
       return new Promise((resolve2, reject) => {
-        fs17.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
+        fs18.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
           if (err) return reject(err);
           resolve2({ bytesWritten, buffers: buffers2 });
         });
       });
     };
-    if (typeof fs17.realpath.native === "function") {
-      exports2.realpath.native = u(fs17.realpath.native);
+    if (typeof fs18.realpath.native === "function") {
+      exports2.realpath.native = u(fs18.realpath.native);
     } else {
       process.emitWarning(
         "fs.realpath.native is not a function. Is fs being monkey-patched?",
@@ -12512,10 +12512,10 @@ var require_fs = __commonJS({
 var require_utils = __commonJS({
   "../node_modules/fs-extra/lib/mkdirs/utils.js"(exports2, module2) {
     "use strict";
-    var path16 = require("path");
+    var path17 = require("path");
     module2.exports.checkPath = function checkPath(pth) {
       if (process.platform === "win32") {
-        const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path16.parse(pth).root, ""));
+        const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path17.parse(pth).root, ""));
         if (pathHasInvalidWinCharacters) {
           const error49 = new Error(`Path contains invalid characters: ${pth}`);
           error49.code = "EINVAL";
@@ -12530,7 +12530,7 @@ var require_utils = __commonJS({
 var require_make_dir = __commonJS({
   "../node_modules/fs-extra/lib/mkdirs/make-dir.js"(exports2, module2) {
     "use strict";
-    var fs17 = require_fs();
+    var fs18 = require_fs();
     var { checkPath } = require_utils();
     var getMode = (options) => {
       const defaults = { mode: 511 };
@@ -12539,14 +12539,14 @@ var require_make_dir = __commonJS({
     };
     module2.exports.makeDir = async (dir, options) => {
       checkPath(dir);
-      return fs17.mkdir(dir, {
+      return fs18.mkdir(dir, {
         mode: getMode(options),
         recursive: true
       });
     };
     module2.exports.makeDirSync = (dir, options) => {
       checkPath(dir);
-      return fs17.mkdirSync(dir, {
+      return fs18.mkdirSync(dir, {
         mode: getMode(options),
         recursive: true
       });
@@ -12578,13 +12578,13 @@ var require_path_exists = __commonJS({
   "../node_modules/fs-extra/lib/path-exists/index.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs17 = require_fs();
-    function pathExists(path16) {
-      return fs17.access(path16).then(() => true).catch(() => false);
+    var fs18 = require_fs();
+    function pathExists(path17) {
+      return fs18.access(path17).then(() => true).catch(() => false);
     }
     module2.exports = {
       pathExists: u(pathExists),
-      pathExistsSync: fs17.existsSync
+      pathExistsSync: fs18.existsSync
     };
   }
 });
@@ -12593,16 +12593,16 @@ var require_path_exists = __commonJS({
 var require_utimes = __commonJS({
   "../node_modules/fs-extra/lib/util/utimes.js"(exports2, module2) {
     "use strict";
-    var fs17 = require_fs();
+    var fs18 = require_fs();
     var u = require_universalify().fromPromise;
-    async function utimesMillis(path16, atime, mtime) {
-      const fd = await fs17.open(path16, "r+");
+    async function utimesMillis(path17, atime, mtime) {
+      const fd = await fs18.open(path17, "r+");
       let closeErr = null;
       try {
-        await fs17.futimes(fd, atime, mtime);
+        await fs18.futimes(fd, atime, mtime);
       } finally {
         try {
-          await fs17.close(fd);
+          await fs18.close(fd);
         } catch (e) {
           closeErr = e;
         }
@@ -12611,10 +12611,10 @@ var require_utimes = __commonJS({
         throw closeErr;
       }
     }
-    function utimesMillisSync(path16, atime, mtime) {
-      const fd = fs17.openSync(path16, "r+");
-      fs17.futimesSync(fd, atime, mtime);
-      return fs17.closeSync(fd);
+    function utimesMillisSync(path17, atime, mtime) {
+      const fd = fs18.openSync(path17, "r+");
+      fs18.futimesSync(fd, atime, mtime);
+      return fs18.closeSync(fd);
     }
     module2.exports = {
       utimesMillis: u(utimesMillis),
@@ -12627,11 +12627,11 @@ var require_utimes = __commonJS({
 var require_stat = __commonJS({
   "../node_modules/fs-extra/lib/util/stat.js"(exports2, module2) {
     "use strict";
-    var fs17 = require_fs();
-    var path16 = require("path");
+    var fs18 = require_fs();
+    var path17 = require("path");
     var u = require_universalify().fromPromise;
     function getStats(src, dest, opts) {
-      const statFunc = opts.dereference ? (file2) => fs17.stat(file2, { bigint: true }) : (file2) => fs17.lstat(file2, { bigint: true });
+      const statFunc = opts.dereference ? (file2) => fs18.stat(file2, { bigint: true }) : (file2) => fs18.lstat(file2, { bigint: true });
       return Promise.all([
         statFunc(src),
         statFunc(dest).catch((err) => {
@@ -12642,7 +12642,7 @@ var require_stat = __commonJS({
     }
     function getStatsSync(src, dest, opts) {
       let destStat;
-      const statFunc = opts.dereference ? (file2) => fs17.statSync(file2, { bigint: true }) : (file2) => fs17.lstatSync(file2, { bigint: true });
+      const statFunc = opts.dereference ? (file2) => fs18.statSync(file2, { bigint: true }) : (file2) => fs18.lstatSync(file2, { bigint: true });
       const srcStat = statFunc(src);
       try {
         destStat = statFunc(dest);
@@ -12656,8 +12656,8 @@ var require_stat = __commonJS({
       const { srcStat, destStat } = await getStats(src, dest, opts);
       if (destStat) {
         if (areIdentical(srcStat, destStat)) {
-          const srcBaseName = path16.basename(src);
-          const destBaseName = path16.basename(dest);
+          const srcBaseName = path17.basename(src);
+          const destBaseName = path17.basename(dest);
           if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
             return { srcStat, destStat, isChangingCase: true };
           }
@@ -12679,8 +12679,8 @@ var require_stat = __commonJS({
       const { srcStat, destStat } = getStatsSync(src, dest, opts);
       if (destStat) {
         if (areIdentical(srcStat, destStat)) {
-          const srcBaseName = path16.basename(src);
-          const destBaseName = path16.basename(dest);
+          const srcBaseName = path17.basename(src);
+          const destBaseName = path17.basename(dest);
           if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
             return { srcStat, destStat, isChangingCase: true };
           }
@@ -12699,12 +12699,12 @@ var require_stat = __commonJS({
       return { srcStat, destStat };
     }
     async function checkParentPaths(src, srcStat, dest, funcName) {
-      const srcParent = path16.resolve(path16.dirname(src));
-      const destParent = path16.resolve(path16.dirname(dest));
-      if (destParent === srcParent || destParent === path16.parse(destParent).root) return;
+      const srcParent = path17.resolve(path17.dirname(src));
+      const destParent = path17.resolve(path17.dirname(dest));
+      if (destParent === srcParent || destParent === path17.parse(destParent).root) return;
       let destStat;
       try {
-        destStat = await fs17.stat(destParent, { bigint: true });
+        destStat = await fs18.stat(destParent, { bigint: true });
       } catch (err) {
         if (err.code === "ENOENT") return;
         throw err;
@@ -12715,12 +12715,12 @@ var require_stat = __commonJS({
       return checkParentPaths(src, srcStat, destParent, funcName);
     }
     function checkParentPathsSync(src, srcStat, dest, funcName) {
-      const srcParent = path16.resolve(path16.dirname(src));
-      const destParent = path16.resolve(path16.dirname(dest));
-      if (destParent === srcParent || destParent === path16.parse(destParent).root) return;
+      const srcParent = path17.resolve(path17.dirname(src));
+      const destParent = path17.resolve(path17.dirname(dest));
+      if (destParent === srcParent || destParent === path17.parse(destParent).root) return;
       let destStat;
       try {
-        destStat = fs17.statSync(destParent, { bigint: true });
+        destStat = fs18.statSync(destParent, { bigint: true });
       } catch (err) {
         if (err.code === "ENOENT") return;
         throw err;
@@ -12734,8 +12734,8 @@ var require_stat = __commonJS({
       return destStat.ino !== void 0 && destStat.dev !== void 0 && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev;
     }
     function isSrcSubdir(src, dest) {
-      const srcArr = path16.resolve(src).split(path16.sep).filter((i) => i);
-      const destArr = path16.resolve(dest).split(path16.sep).filter((i) => i);
+      const srcArr = path17.resolve(src).split(path17.sep).filter((i) => i);
+      const destArr = path17.resolve(dest).split(path17.sep).filter((i) => i);
       return srcArr.every((cur, i) => destArr[i] === cur);
     }
     function errMsg(src, dest, funcName) {
@@ -12787,8 +12787,8 @@ var require_async = __commonJS({
 var require_copy = __commonJS({
   "../node_modules/fs-extra/lib/copy/copy.js"(exports2, module2) {
     "use strict";
-    var fs17 = require_fs();
-    var path16 = require("path");
+    var fs18 = require_fs();
+    var path17 = require("path");
     var { mkdirs } = require_mkdirs();
     var { pathExists } = require_path_exists();
     var { utimesMillis } = require_utimes();
@@ -12811,7 +12811,7 @@ var require_copy = __commonJS({
       await stat.checkParentPaths(src, srcStat, dest, "copy");
       const include = await runFilter(src, dest, opts);
       if (!include) return;
-      const destParent = path16.dirname(dest);
+      const destParent = path17.dirname(dest);
       const dirExists = await pathExists(destParent);
       if (!dirExists) {
         await mkdirs(destParent);
@@ -12823,7 +12823,7 @@ var require_copy = __commonJS({
       return opts.filter(src, dest);
     }
     async function getStatsAndPerformCopy(destStat, src, dest, opts) {
-      const statFn = opts.dereference ? fs17.stat : fs17.lstat;
+      const statFn = opts.dereference ? fs18.stat : fs18.lstat;
       const srcStat = await statFn(src);
       if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts);
       if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts);
@@ -12835,7 +12835,7 @@ var require_copy = __commonJS({
     async function onFile(srcStat, destStat, src, dest, opts) {
       if (!destStat) return copyFile(srcStat, src, dest, opts);
       if (opts.overwrite) {
-        await fs17.unlink(dest);
+        await fs18.unlink(dest);
         return copyFile(srcStat, src, dest, opts);
       }
       if (opts.errorOnExist) {
@@ -12843,29 +12843,29 @@ var require_copy = __commonJS({
       }
     }
     async function copyFile(srcStat, src, dest, opts) {
-      await fs17.copyFile(src, dest);
+      await fs18.copyFile(src, dest);
       if (opts.preserveTimestamps) {
         if (fileIsNotWritable(srcStat.mode)) {
           await makeFileWritable(dest, srcStat.mode);
         }
-        const updatedSrcStat = await fs17.stat(src);
+        const updatedSrcStat = await fs18.stat(src);
         await utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
       }
-      return fs17.chmod(dest, srcStat.mode);
+      return fs18.chmod(dest, srcStat.mode);
     }
     function fileIsNotWritable(srcMode) {
       return (srcMode & 128) === 0;
     }
     function makeFileWritable(dest, srcMode) {
-      return fs17.chmod(dest, srcMode | 128);
+      return fs18.chmod(dest, srcMode | 128);
     }
     async function onDir(srcStat, destStat, src, dest, opts) {
       if (!destStat) {
-        await fs17.mkdir(dest);
+        await fs18.mkdir(dest);
       }
-      await asyncIteratorConcurrentProcess(await fs17.opendir(src), async (item) => {
-        const srcItem = path16.join(src, item.name);
-        const destItem = path16.join(dest, item.name);
+      await asyncIteratorConcurrentProcess(await fs18.opendir(src), async (item) => {
+        const srcItem = path17.join(src, item.name);
+        const destItem = path17.join(dest, item.name);
         const include = await runFilter(srcItem, destItem, opts);
         if (include) {
           const { destStat: destStat2 } = await stat.checkPaths(srcItem, destItem, "copy", opts);
@@ -12873,26 +12873,26 @@ var require_copy = __commonJS({
         }
       });
       if (!destStat) {
-        await fs17.chmod(dest, srcStat.mode);
+        await fs18.chmod(dest, srcStat.mode);
       }
     }
     async function onLink(destStat, src, dest, opts) {
-      let resolvedSrc = await fs17.readlink(src);
+      let resolvedSrc = await fs18.readlink(src);
       if (opts.dereference) {
-        resolvedSrc = path16.resolve(process.cwd(), resolvedSrc);
+        resolvedSrc = path17.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
-        return fs17.symlink(resolvedSrc, dest);
+        return fs18.symlink(resolvedSrc, dest);
       }
       let resolvedDest = null;
       try {
-        resolvedDest = await fs17.readlink(dest);
+        resolvedDest = await fs18.readlink(dest);
       } catch (e) {
-        if (e.code === "EINVAL" || e.code === "UNKNOWN") return fs17.symlink(resolvedSrc, dest);
+        if (e.code === "EINVAL" || e.code === "UNKNOWN") return fs18.symlink(resolvedSrc, dest);
         throw e;
       }
       if (opts.dereference) {
-        resolvedDest = path16.resolve(process.cwd(), resolvedDest);
+        resolvedDest = path17.resolve(process.cwd(), resolvedDest);
       }
       if (resolvedSrc !== resolvedDest) {
         if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
@@ -12902,8 +12902,8 @@ var require_copy = __commonJS({
           throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
         }
       }
-      await fs17.unlink(dest);
-      return fs17.symlink(resolvedSrc, dest);
+      await fs18.unlink(dest);
+      return fs18.symlink(resolvedSrc, dest);
     }
     module2.exports = copy;
   }
@@ -12913,8 +12913,8 @@ var require_copy = __commonJS({
 var require_copy_sync = __commonJS({
   "../node_modules/fs-extra/lib/copy/copy-sync.js"(exports2, module2) {
     "use strict";
-    var fs17 = require_graceful_fs();
-    var path16 = require("path");
+    var fs18 = require_graceful_fs();
+    var path17 = require("path");
     var mkdirsSync = require_mkdirs().mkdirsSync;
     var utimesMillisSync = require_utimes().utimesMillisSync;
     var stat = require_stat();
@@ -12935,12 +12935,12 @@ var require_copy_sync = __commonJS({
       const { srcStat, destStat } = stat.checkPathsSync(src, dest, "copy", opts);
       stat.checkParentPathsSync(src, srcStat, dest, "copy");
       if (opts.filter && !opts.filter(src, dest)) return;
-      const destParent = path16.dirname(dest);
-      if (!fs17.existsSync(destParent)) mkdirsSync(destParent);
+      const destParent = path17.dirname(dest);
+      if (!fs18.existsSync(destParent)) mkdirsSync(destParent);
       return getStats(destStat, src, dest, opts);
     }
     function getStats(destStat, src, dest, opts) {
-      const statSync = opts.dereference ? fs17.statSync : fs17.lstatSync;
+      const statSync = opts.dereference ? fs18.statSync : fs18.lstatSync;
       const srcStat = statSync(src);
       if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts);
       else if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts);
@@ -12955,14 +12955,14 @@ var require_copy_sync = __commonJS({
     }
     function mayCopyFile(srcStat, src, dest, opts) {
       if (opts.overwrite) {
-        fs17.unlinkSync(dest);
+        fs18.unlinkSync(dest);
         return copyFile(srcStat, src, dest, opts);
       } else if (opts.errorOnExist) {
         throw new Error(`'${dest}' already exists`);
       }
     }
     function copyFile(srcStat, src, dest, opts) {
-      fs17.copyFileSync(src, dest);
+      fs18.copyFileSync(src, dest);
       if (opts.preserveTimestamps) handleTimestamps(srcStat.mode, src, dest);
       return setDestMode(dest, srcStat.mode);
     }
@@ -12977,10 +12977,10 @@ var require_copy_sync = __commonJS({
       return setDestMode(dest, srcMode | 128);
     }
     function setDestMode(dest, srcMode) {
-      return fs17.chmodSync(dest, srcMode);
+      return fs18.chmodSync(dest, srcMode);
     }
     function setDestTimestamps(src, dest) {
-      const updatedSrcStat = fs17.statSync(src);
+      const updatedSrcStat = fs18.statSync(src);
       return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
     }
     function onDir(srcStat, destStat, src, dest, opts) {
@@ -12988,12 +12988,12 @@ var require_copy_sync = __commonJS({
       return copyDir(src, dest, opts);
     }
     function mkDirAndCopy(srcMode, src, dest, opts) {
-      fs17.mkdirSync(dest);
+      fs18.mkdirSync(dest);
       copyDir(src, dest, opts);
       return setDestMode(dest, srcMode);
     }
     function copyDir(src, dest, opts) {
-      const dir = fs17.opendirSync(src);
+      const dir = fs18.opendirSync(src);
       try {
         let dirent;
         while ((dirent = dir.readSync()) !== null) {
@@ -13004,29 +13004,29 @@ var require_copy_sync = __commonJS({
       }
     }
     function copyDirItem(item, src, dest, opts) {
-      const srcItem = path16.join(src, item);
-      const destItem = path16.join(dest, item);
+      const srcItem = path17.join(src, item);
+      const destItem = path17.join(dest, item);
       if (opts.filter && !opts.filter(srcItem, destItem)) return;
       const { destStat } = stat.checkPathsSync(srcItem, destItem, "copy", opts);
       return getStats(destStat, srcItem, destItem, opts);
     }
     function onLink(destStat, src, dest, opts) {
-      let resolvedSrc = fs17.readlinkSync(src);
+      let resolvedSrc = fs18.readlinkSync(src);
       if (opts.dereference) {
-        resolvedSrc = path16.resolve(process.cwd(), resolvedSrc);
+        resolvedSrc = path17.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
-        return fs17.symlinkSync(resolvedSrc, dest);
+        return fs18.symlinkSync(resolvedSrc, dest);
       } else {
         let resolvedDest;
         try {
-          resolvedDest = fs17.readlinkSync(dest);
+          resolvedDest = fs18.readlinkSync(dest);
         } catch (err) {
-          if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs17.symlinkSync(resolvedSrc, dest);
+          if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs18.symlinkSync(resolvedSrc, dest);
           throw err;
         }
         if (opts.dereference) {
-          resolvedDest = path16.resolve(process.cwd(), resolvedDest);
+          resolvedDest = path17.resolve(process.cwd(), resolvedDest);
         }
         if (resolvedSrc !== resolvedDest) {
           if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
@@ -13040,8 +13040,8 @@ var require_copy_sync = __commonJS({
       }
     }
     function copyLink(resolvedSrc, dest) {
-      fs17.unlinkSync(dest);
-      return fs17.symlinkSync(resolvedSrc, dest);
+      fs18.unlinkSync(dest);
+      return fs18.symlinkSync(resolvedSrc, dest);
     }
     module2.exports = copySync;
   }
@@ -13063,13 +13063,13 @@ var require_copy2 = __commonJS({
 var require_remove = __commonJS({
   "../node_modules/fs-extra/lib/remove/index.js"(exports2, module2) {
     "use strict";
-    var fs17 = require_graceful_fs();
+    var fs18 = require_graceful_fs();
     var u = require_universalify().fromCallback;
-    function remove(path16, callback) {
-      fs17.rm(path16, { recursive: true, force: true }, callback);
+    function remove(path17, callback) {
+      fs18.rm(path17, { recursive: true, force: true }, callback);
     }
-    function removeSync(path16) {
-      fs17.rmSync(path16, { recursive: true, force: true });
+    function removeSync(path17) {
+      fs18.rmSync(path17, { recursive: true, force: true });
     }
     module2.exports = {
       remove: u(remove),
@@ -13083,28 +13083,28 @@ var require_empty = __commonJS({
   "../node_modules/fs-extra/lib/empty/index.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs17 = require_fs();
-    var path16 = require("path");
+    var fs18 = require_fs();
+    var path17 = require("path");
     var mkdir = require_mkdirs();
     var remove = require_remove();
     var emptyDir = u(async function emptyDir2(dir) {
       let items;
       try {
-        items = await fs17.readdir(dir);
+        items = await fs18.readdir(dir);
       } catch {
         return mkdir.mkdirs(dir);
       }
-      return Promise.all(items.map((item) => remove.remove(path16.join(dir, item))));
+      return Promise.all(items.map((item) => remove.remove(path17.join(dir, item))));
     });
     function emptyDirSync(dir) {
       let items;
       try {
-        items = fs17.readdirSync(dir);
+        items = fs18.readdirSync(dir);
       } catch {
         return mkdir.mkdirsSync(dir);
       }
       items.forEach((item) => {
-        item = path16.join(dir, item);
+        item = path17.join(dir, item);
         remove.removeSync(item);
       });
     }
@@ -13122,52 +13122,52 @@ var require_file = __commonJS({
   "../node_modules/fs-extra/lib/ensure/file.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var path16 = require("path");
-    var fs17 = require_fs();
+    var path17 = require("path");
+    var fs18 = require_fs();
     var mkdir = require_mkdirs();
     async function createFile(file2) {
       let stats;
       try {
-        stats = await fs17.stat(file2);
+        stats = await fs18.stat(file2);
       } catch {
       }
       if (stats && stats.isFile()) return;
-      const dir = path16.dirname(file2);
+      const dir = path17.dirname(file2);
       let dirStats = null;
       try {
-        dirStats = await fs17.stat(dir);
+        dirStats = await fs18.stat(dir);
       } catch (err) {
         if (err.code === "ENOENT") {
           await mkdir.mkdirs(dir);
-          await fs17.writeFile(file2, "");
+          await fs18.writeFile(file2, "");
           return;
         } else {
           throw err;
         }
       }
       if (dirStats.isDirectory()) {
-        await fs17.writeFile(file2, "");
+        await fs18.writeFile(file2, "");
       } else {
-        await fs17.readdir(dir);
+        await fs18.readdir(dir);
       }
     }
     function createFileSync(file2) {
       let stats;
       try {
-        stats = fs17.statSync(file2);
+        stats = fs18.statSync(file2);
       } catch {
       }
       if (stats && stats.isFile()) return;
-      const dir = path16.dirname(file2);
+      const dir = path17.dirname(file2);
       try {
-        if (!fs17.statSync(dir).isDirectory()) {
-          fs17.readdirSync(dir);
+        if (!fs18.statSync(dir).isDirectory()) {
+          fs18.readdirSync(dir);
         }
       } catch (err) {
         if (err && err.code === "ENOENT") mkdir.mkdirsSync(dir);
         else throw err;
       }
-      fs17.writeFileSync(file2, "");
+      fs18.writeFileSync(file2, "");
     }
     module2.exports = {
       createFile: u(createFile),
@@ -13181,50 +13181,50 @@ var require_link = __commonJS({
   "../node_modules/fs-extra/lib/ensure/link.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var path16 = require("path");
-    var fs17 = require_fs();
+    var path17 = require("path");
+    var fs18 = 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 fs17.lstat(dstpath);
+        dstStat = await fs18.lstat(dstpath);
       } catch {
       }
       let srcStat;
       try {
-        srcStat = await fs17.lstat(srcpath);
+        srcStat = await fs18.lstat(srcpath);
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureLink");
         throw err;
       }
       if (dstStat && areIdentical(srcStat, dstStat)) return;
-      const dir = path16.dirname(dstpath);
+      const dir = path17.dirname(dstpath);
       const dirExists = await pathExists(dir);
       if (!dirExists) {
         await mkdir.mkdirs(dir);
       }
-      await fs17.link(srcpath, dstpath);
+      await fs18.link(srcpath, dstpath);
     }
     function createLinkSync(srcpath, dstpath) {
       let dstStat;
       try {
-        dstStat = fs17.lstatSync(dstpath);
+        dstStat = fs18.lstatSync(dstpath);
       } catch {
       }
       try {
-        const srcStat = fs17.lstatSync(srcpath);
+        const srcStat = fs18.lstatSync(srcpath);
         if (dstStat && areIdentical(srcStat, dstStat)) return;
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureLink");
         throw err;
       }
-      const dir = path16.dirname(dstpath);
-      const dirExists = fs17.existsSync(dir);
-      if (dirExists) return fs17.linkSync(srcpath, dstpath);
+      const dir = path17.dirname(dstpath);
+      const dirExists = fs18.existsSync(dir);
+      if (dirExists) return fs18.linkSync(srcpath, dstpath);
       mkdir.mkdirsSync(dir);
-      return fs17.linkSync(srcpath, dstpath);
+      return fs18.linkSync(srcpath, dstpath);
     }
     module2.exports = {
       createLink: u(createLink),
@@ -13237,14 +13237,14 @@ var require_link = __commonJS({
 var require_symlink_paths = __commonJS({
   "../node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports2, module2) {
     "use strict";
-    var path16 = require("path");
-    var fs17 = require_fs();
+    var path17 = require("path");
+    var fs18 = require_fs();
     var { pathExists } = require_path_exists();
     var u = require_universalify().fromPromise;
     async function symlinkPaths(srcpath, dstpath) {
-      if (path16.isAbsolute(srcpath)) {
+      if (path17.isAbsolute(srcpath)) {
         try {
-          await fs17.lstat(srcpath);
+          await fs18.lstat(srcpath);
         } catch (err) {
           err.message = err.message.replace("lstat", "ensureSymlink");
           throw err;
@@ -13254,8 +13254,8 @@ var require_symlink_paths = __commonJS({
           toDst: srcpath
         };
       }
-      const dstdir = path16.dirname(dstpath);
-      const relativeToDst = path16.join(dstdir, srcpath);
+      const dstdir = path17.dirname(dstpath);
+      const relativeToDst = path17.join(dstdir, srcpath);
       const exists = await pathExists(relativeToDst);
       if (exists) {
         return {
@@ -13264,39 +13264,39 @@ var require_symlink_paths = __commonJS({
         };
       }
       try {
-        await fs17.lstat(srcpath);
+        await fs18.lstat(srcpath);
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureSymlink");
         throw err;
       }
       return {
         toCwd: srcpath,
-        toDst: path16.relative(dstdir, srcpath)
+        toDst: path17.relative(dstdir, srcpath)
       };
     }
     function symlinkPathsSync(srcpath, dstpath) {
-      if (path16.isAbsolute(srcpath)) {
-        const exists2 = fs17.existsSync(srcpath);
+      if (path17.isAbsolute(srcpath)) {
+        const exists2 = fs18.existsSync(srcpath);
         if (!exists2) throw new Error("absolute srcpath does not exist");
         return {
           toCwd: srcpath,
           toDst: srcpath
         };
       }
-      const dstdir = path16.dirname(dstpath);
-      const relativeToDst = path16.join(dstdir, srcpath);
-      const exists = fs17.existsSync(relativeToDst);
+      const dstdir = path17.dirname(dstpath);
+      const relativeToDst = path17.join(dstdir, srcpath);
+      const exists = fs18.existsSync(relativeToDst);
       if (exists) {
         return {
           toCwd: relativeToDst,
           toDst: srcpath
         };
       }
-      const srcExists = fs17.existsSync(srcpath);
+      const srcExists = fs18.existsSync(srcpath);
       if (!srcExists) throw new Error("relative srcpath does not exist");
       return {
         toCwd: srcpath,
-        toDst: path16.relative(dstdir, srcpath)
+        toDst: path17.relative(dstdir, srcpath)
       };
     }
     module2.exports = {
@@ -13310,13 +13310,13 @@ var require_symlink_paths = __commonJS({
 var require_symlink_type = __commonJS({
   "../node_modules/fs-extra/lib/ensure/symlink-type.js"(exports2, module2) {
     "use strict";
-    var fs17 = require_fs();
+    var fs18 = require_fs();
     var u = require_universalify().fromPromise;
     async function symlinkType(srcpath, type) {
       if (type) return type;
       let stats;
       try {
-        stats = await fs17.lstat(srcpath);
+        stats = await fs18.lstat(srcpath);
       } catch {
         return "file";
       }
@@ -13326,7 +13326,7 @@ var require_symlink_type = __commonJS({
       if (type) return type;
       let stats;
       try {
-        stats = fs17.lstatSync(srcpath);
+        stats = fs18.lstatSync(srcpath);
       } catch {
         return "file";
       }
@@ -13344,8 +13344,8 @@ var require_symlink = __commonJS({
   "../node_modules/fs-extra/lib/ensure/symlink.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var path16 = require("path");
-    var fs17 = require_fs();
+    var path17 = require("path");
+    var fs18 = require_fs();
     var { mkdirs, mkdirsSync } = require_mkdirs();
     var { symlinkPaths, symlinkPathsSync } = require_symlink_paths();
     var { symlinkType, symlinkTypeSync } = require_symlink_type();
@@ -13354,44 +13354,44 @@ var require_symlink = __commonJS({
     async function createSymlink(srcpath, dstpath, type) {
       let stats;
       try {
-        stats = await fs17.lstat(dstpath);
+        stats = await fs18.lstat(dstpath);
       } catch {
       }
       if (stats && stats.isSymbolicLink()) {
         const [srcStat, dstStat] = await Promise.all([
-          fs17.stat(srcpath),
-          fs17.stat(dstpath)
+          fs18.stat(srcpath),
+          fs18.stat(dstpath)
         ]);
         if (areIdentical(srcStat, dstStat)) return;
       }
       const relative = await symlinkPaths(srcpath, dstpath);
       srcpath = relative.toDst;
       const toType = await symlinkType(relative.toCwd, type);
-      const dir = path16.dirname(dstpath);
+      const dir = path17.dirname(dstpath);
       if (!await pathExists(dir)) {
         await mkdirs(dir);
       }
-      return fs17.symlink(srcpath, dstpath, toType);
+      return fs18.symlink(srcpath, dstpath, toType);
     }
     function createSymlinkSync(srcpath, dstpath, type) {
       let stats;
       try {
-        stats = fs17.lstatSync(dstpath);
+        stats = fs18.lstatSync(dstpath);
       } catch {
       }
       if (stats && stats.isSymbolicLink()) {
-        const srcStat = fs17.statSync(srcpath);
-        const dstStat = fs17.statSync(dstpath);
+        const srcStat = fs18.statSync(srcpath);
+        const dstStat = fs18.statSync(dstpath);
         if (areIdentical(srcStat, dstStat)) return;
       }
       const relative = symlinkPathsSync(srcpath, dstpath);
       srcpath = relative.toDst;
       type = symlinkTypeSync(relative.toCwd, type);
-      const dir = path16.dirname(dstpath);
-      const exists = fs17.existsSync(dir);
-      if (exists) return fs17.symlinkSync(srcpath, dstpath, type);
+      const dir = path17.dirname(dstpath);
+      const exists = fs18.existsSync(dir);
+      if (exists) return fs18.symlinkSync(srcpath, dstpath, type);
       mkdirsSync(dir);
-      return fs17.symlinkSync(srcpath, dstpath, type);
+      return fs18.symlinkSync(srcpath, dstpath, type);
     }
     module2.exports = {
       createSymlink: u(createSymlink),
@@ -13460,9 +13460,9 @@ var require_jsonfile = __commonJS({
       if (typeof options === "string") {
         options = { encoding: options };
       }
-      const fs17 = options.fs || _fs;
+      const fs18 = options.fs || _fs;
       const shouldThrow = "throws" in options ? options.throws : true;
-      let data = await universalify.fromCallback(fs17.readFile)(file2, options);
+      let data = await universalify.fromCallback(fs18.readFile)(file2, options);
       data = stripBom(data);
       let obj;
       try {
@@ -13482,10 +13482,10 @@ var require_jsonfile = __commonJS({
       if (typeof options === "string") {
         options = { encoding: options };
       }
-      const fs17 = options.fs || _fs;
+      const fs18 = options.fs || _fs;
       const shouldThrow = "throws" in options ? options.throws : true;
       try {
-        let content = fs17.readFileSync(file2, options);
+        let content = fs18.readFileSync(file2, options);
         content = stripBom(content);
         return JSON.parse(content, options.reviver);
       } catch (err) {
@@ -13498,15 +13498,15 @@ var require_jsonfile = __commonJS({
       }
     }
     async function _writeFile(file2, obj, options = {}) {
-      const fs17 = options.fs || _fs;
+      const fs18 = options.fs || _fs;
       const str = stringify2(obj, options);
-      await universalify.fromCallback(fs17.writeFile)(file2, str, options);
+      await universalify.fromCallback(fs18.writeFile)(file2, str, options);
     }
     var writeFile = universalify.fromPromise(_writeFile);
     function writeFileSync2(file2, obj, options = {}) {
-      const fs17 = options.fs || _fs;
+      const fs18 = options.fs || _fs;
       const str = stringify2(obj, options);
-      return fs17.writeFileSync(file2, str, options);
+      return fs18.writeFileSync(file2, str, options);
     }
     module2.exports = {
       readFile,
@@ -13537,23 +13537,23 @@ var require_output_file = __commonJS({
   "../node_modules/fs-extra/lib/output-file/index.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs17 = require_fs();
-    var path16 = require("path");
+    var fs18 = require_fs();
+    var path17 = require("path");
     var mkdir = require_mkdirs();
     var pathExists = require_path_exists().pathExists;
     async function outputFile(file2, data, encoding = "utf-8") {
-      const dir = path16.dirname(file2);
+      const dir = path17.dirname(file2);
       if (!await pathExists(dir)) {
         await mkdir.mkdirs(dir);
       }
-      return fs17.writeFile(file2, data, encoding);
+      return fs18.writeFile(file2, data, encoding);
     }
     function outputFileSync(file2, ...args) {
-      const dir = path16.dirname(file2);
-      if (!fs17.existsSync(dir)) {
+      const dir = path17.dirname(file2);
+      if (!fs18.existsSync(dir)) {
         mkdir.mkdirsSync(dir);
       }
-      fs17.writeFileSync(file2, ...args);
+      fs18.writeFileSync(file2, ...args);
     }
     module2.exports = {
       outputFile: u(outputFile),
@@ -13612,8 +13612,8 @@ var require_json = __commonJS({
 var require_move = __commonJS({
   "../node_modules/fs-extra/lib/move/move.js"(exports2, module2) {
     "use strict";
-    var fs17 = require_fs();
-    var path16 = require("path");
+    var fs18 = require_fs();
+    var path17 = require("path");
     var { copy } = require_copy2();
     var { remove } = require_remove();
     var { mkdirp } = require_mkdirs();
@@ -13623,8 +13623,8 @@ var require_move = __commonJS({
       const overwrite = opts.overwrite || opts.clobber || false;
       const { srcStat, isChangingCase = false } = await stat.checkPaths(src, dest, "move", opts);
       await stat.checkParentPaths(src, srcStat, dest, "move");
-      const destParent = path16.dirname(dest);
-      const parsedParentPath = path16.parse(destParent);
+      const destParent = path17.dirname(dest);
+      const parsedParentPath = path17.parse(destParent);
       if (parsedParentPath.root !== destParent) {
         await mkdirp(destParent);
       }
@@ -13639,7 +13639,7 @@ var require_move = __commonJS({
         }
       }
       try {
-        await fs17.rename(src, dest);
+        await fs18.rename(src, dest);
       } catch (err) {
         if (err.code !== "EXDEV") {
           throw err;
@@ -13664,8 +13664,8 @@ var require_move = __commonJS({
 var require_move_sync = __commonJS({
   "../node_modules/fs-extra/lib/move/move-sync.js"(exports2, module2) {
     "use strict";
-    var fs17 = require_graceful_fs();
-    var path16 = require("path");
+    var fs18 = require_graceful_fs();
+    var path17 = require("path");
     var copySync = require_copy2().copySync;
     var removeSync = require_remove().removeSync;
     var mkdirpSync = require_mkdirs().mkdirpSync;
@@ -13675,12 +13675,12 @@ var require_move_sync = __commonJS({
       const overwrite = opts.overwrite || opts.clobber || false;
       const { srcStat, isChangingCase = false } = stat.checkPathsSync(src, dest, "move", opts);
       stat.checkParentPathsSync(src, srcStat, dest, "move");
-      if (!isParentRoot(dest)) mkdirpSync(path16.dirname(dest));
+      if (!isParentRoot(dest)) mkdirpSync(path17.dirname(dest));
       return doRename(src, dest, overwrite, isChangingCase);
     }
     function isParentRoot(dest) {
-      const parent = path16.dirname(dest);
-      const parsedPath = path16.parse(parent);
+      const parent = path17.dirname(dest);
+      const parsedPath = path17.parse(parent);
       return parsedPath.root === parent;
     }
     function doRename(src, dest, overwrite, isChangingCase) {
@@ -13689,12 +13689,12 @@ var require_move_sync = __commonJS({
         removeSync(dest);
         return rename(src, dest, overwrite);
       }
-      if (fs17.existsSync(dest)) throw new Error("dest already exists.");
+      if (fs18.existsSync(dest)) throw new Error("dest already exists.");
       return rename(src, dest, overwrite);
     }
     function rename(src, dest, overwrite) {
       try {
-        fs17.renameSync(src, dest);
+        fs18.renameSync(src, dest);
       } catch (err) {
         if (err.code !== "EXDEV") throw err;
         return moveAcrossDevice(src, dest, overwrite);
@@ -16939,8 +16939,8 @@ var require_utils3 = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path16) {
-      let input = path16;
+    function removeDotSegments(path17) {
+      let input = path17;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -17139,8 +17139,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path16, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path16 && path16 !== "/" ? path16 : void 0;
+        const [path17, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path17 && path17 !== "/" ? path17 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -20466,12 +20466,12 @@ var require_dist2 = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs17, exportName) {
+    function addFormats(ajv, list, fs18, exportName) {
       var _a2;
       var _b;
       (_a2 = (_b = ajv.opts.code).formats) !== null && _a2 !== void 0 ? _a2 : _b.formats = codegen_1._`require("ajv-formats/dist/formats").${exportName}`;
       for (const f of list)
-        ajv.addFormat(f, fs17[f]);
+        ajv.addFormat(f, fs18[f]);
     }
     module2.exports = exports2 = formatsPlugin;
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -31073,8 +31073,8 @@ var require_package = __commonJS({
 var require_main = __commonJS({
   "node_modules/dotenv/lib/main.js"(exports2, module2) {
     "use strict";
-    var fs17 = require("fs");
-    var path16 = require("path");
+    var fs18 = require("fs");
+    var path17 = require("path");
     var os7 = require("os");
     var crypto2 = require("crypto");
     var packageJson = require_package();
@@ -31182,7 +31182,7 @@ var require_main = __commonJS({
       if (options && options.path && options.path.length > 0) {
         if (Array.isArray(options.path)) {
           for (const filepath of options.path) {
-            if (fs17.existsSync(filepath)) {
+            if (fs18.existsSync(filepath)) {
               possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
             }
           }
@@ -31190,15 +31190,15 @@ var require_main = __commonJS({
           possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
         }
       } else {
-        possibleVaultPath = path16.resolve(process.cwd(), ".env.vault");
+        possibleVaultPath = path17.resolve(process.cwd(), ".env.vault");
       }
-      if (fs17.existsSync(possibleVaultPath)) {
+      if (fs18.existsSync(possibleVaultPath)) {
         return possibleVaultPath;
       }
       return null;
     }
     function _resolveHome(envPath) {
-      return envPath[0] === "~" ? path16.join(os7.homedir(), envPath.slice(1)) : envPath;
+      return envPath[0] === "~" ? path17.join(os7.homedir(), envPath.slice(1)) : envPath;
     }
     function _configVault(options) {
       const debug = Boolean(options && options.debug);
@@ -31215,7 +31215,7 @@ var require_main = __commonJS({
       return { parsed };
     }
     function configDotenv(options) {
-      const dotenvPath = path16.resolve(process.cwd(), ".env");
+      const dotenvPath = path17.resolve(process.cwd(), ".env");
       let encoding = "utf8";
       const debug = Boolean(options && options.debug);
       const quiet = options && "quiet" in options ? options.quiet : true;
@@ -31239,13 +31239,13 @@ var require_main = __commonJS({
       }
       let lastError;
       const parsedAll = {};
-      for (const path17 of optionPaths) {
+      for (const path18 of optionPaths) {
         try {
-          const parsed = DotenvModule.parse(fs17.readFileSync(path17, { encoding }));
+          const parsed = DotenvModule.parse(fs18.readFileSync(path18, { encoding }));
           DotenvModule.populate(parsedAll, parsed, options);
         } catch (e) {
           if (debug) {
-            _debug(`Failed to load ${path17} ${e.message}`);
+            _debug(`Failed to load ${path18} ${e.message}`);
           }
           lastError = e;
         }
@@ -31260,7 +31260,7 @@ var require_main = __commonJS({
         const shortPaths = [];
         for (const filePath of optionPaths) {
           try {
-            const relative = path16.relative(process.cwd(), filePath);
+            const relative = path17.relative(process.cwd(), filePath);
             shortPaths.push(relative);
           } catch (e) {
             if (debug) {
@@ -33948,7 +33948,7 @@ function init(open, close) {
 var kleur_default = $;
 
 // src/commands/install.ts
-var import_prompts2 = __toESM(require_prompts3(), 1);
+var import_prompts3 = __toESM(require_prompts3(), 1);
 
 // ../node_modules/eventemitter3/index.mjs
 var import_index2 = __toESM(require_eventemitter3(), 1);
@@ -35746,7 +35746,7 @@ var Listr = class {
 };
 
 // src/commands/install.ts
-var import_fs_extra12 = __toESM(require_lib2(), 1);
+var import_fs_extra13 = __toESM(require_lib2(), 1);
 
 // src/core/context.ts
 var import_os2 = __toESM(require("os"), 1);
@@ -35772,12 +35772,12 @@ var disallowedKeys = /* @__PURE__ */ new Set([
   "constructor"
 ]);
 var digits = new Set("0123456789");
-function getPathSegments(path16) {
+function getPathSegments(path17) {
   const parts = [];
   let currentSegment = "";
   let currentPart = "start";
   let isIgnoring = false;
-  for (const character of path16) {
+  for (const character of path17) {
     switch (character) {
       case "\\": {
         if (currentPart === "index") {
@@ -35899,11 +35899,11 @@ function assertNotStringIndex(object2, key) {
     throw new Error("Cannot use string index");
   }
 }
-function getProperty(object2, path16, value) {
-  if (!isObject(object2) || typeof path16 !== "string") {
+function getProperty(object2, path17, value) {
+  if (!isObject(object2) || typeof path17 !== "string") {
     return value === void 0 ? object2 : value;
   }
-  const pathArray = getPathSegments(path16);
+  const pathArray = getPathSegments(path17);
   if (pathArray.length === 0) {
     return value;
   }
@@ -35923,12 +35923,12 @@ function getProperty(object2, path16, value) {
   }
   return object2 === void 0 ? value : object2;
 }
-function setProperty(object2, path16, value) {
-  if (!isObject(object2) || typeof path16 !== "string") {
+function setProperty(object2, path17, value) {
+  if (!isObject(object2) || typeof path17 !== "string") {
     return object2;
   }
   const root = object2;
-  const pathArray = getPathSegments(path16);
+  const pathArray = getPathSegments(path17);
   for (let index = 0; index < pathArray.length; index++) {
     const key = pathArray[index];
     assertNotStringIndex(object2, key);
@@ -35941,11 +35941,11 @@ function setProperty(object2, path16, value) {
   }
   return root;
 }
-function deleteProperty(object2, path16) {
-  if (!isObject(object2) || typeof path16 !== "string") {
+function deleteProperty(object2, path17) {
+  if (!isObject(object2) || typeof path17 !== "string") {
     return false;
   }
-  const pathArray = getPathSegments(path16);
+  const pathArray = getPathSegments(path17);
   for (let index = 0; index < pathArray.length; index++) {
     const key = pathArray[index];
     assertNotStringIndex(object2, key);
@@ -35959,11 +35959,11 @@ function deleteProperty(object2, path16) {
     }
   }
 }
-function hasProperty(object2, path16) {
-  if (!isObject(object2) || typeof path16 !== "string") {
+function hasProperty(object2, path17) {
+  if (!isObject(object2) || typeof path17 !== "string") {
     return false;
   }
-  const pathArray = getPathSegments(path16);
+  const pathArray = getPathSegments(path17);
   if (pathArray.length === 0) {
     return false;
   }
@@ -37174,8 +37174,8 @@ function detectAdapter(systemRoot) {
 // src/core/diff.ts
 var IGNORED_ITEMS = /* @__PURE__ */ new Set(["__pycache__", ".DS_Store", "Thumbs.db", ".gitkeep", "node_modules"]);
 var PruneModeReadError = class extends Error {
-  constructor(path16) {
-    super(`Cannot read ${path16} in prune mode \u2014 aborting to prevent accidental deletion`);
+  constructor(path17) {
+    super(`Cannot read ${path17} in prune mode \u2014 aborting to prevent accidental deletion`);
     this.name = "PruneModeReadError";
   }
 };
@@ -40045,7 +40045,7 @@ async function handleMissingEnvVars(missing) {
   if (missing.length === 0) {
     return true;
   }
-  const prompts4 = (await Promise.resolve().then(() => __toESM(require_prompts3(), 1))).default;
+  const prompts5 = (await Promise.resolve().then(() => __toESM(require_prompts3(), 1))).default;
   const answers = {};
   for (const key of missing) {
     const config3 = REQUIRED_ENV_VARS[key];
@@ -40057,7 +40057,7 @@ async function handleMissingEnvVars(missing) {
       console.log(kleur_default.yellow(`
   \u26A0\uFE0F  ${key} is required by a selected MCP server`));
     }
-    const { value } = await prompts4({
+    const { value } = await prompts5({
       type: "text",
       name: "value",
       message: `Enter ${key}:`,
@@ -40346,8 +40346,8 @@ async function syncMcpServersWithCli(agent, mcpConfig, dryRun = false, prune = f
   }
   let selectedNames = toAdd.map(([name]) => name);
   if (!dryRun) {
-    const prompts4 = await Promise.resolve().then(() => __toESM(require_prompts3(), 1));
-    const { selected } = await prompts4.default({
+    const prompts5 = await Promise.resolve().then(() => __toESM(require_prompts3(), 1));
+    const { selected } = await prompts5.default({
       type: "multiselect",
       name: "selected",
       message: `Select MCP servers to install via ${agent} CLI:`,
@@ -40784,7 +40784,7 @@ var sym = {
 };
 
 // src/commands/install.ts
-var import_path12 = __toESM(require("path"), 1);
+var import_path13 = __toESM(require("path"), 1);
 
 // src/commands/install-project.ts
 var import_path11 = __toESM(require("path"), 1);
@@ -41420,6 +41420,83 @@ function createProjectCommand() {
   return projectCmd;
 }
 
+// src/commands/install-pi.ts
+var import_prompts2 = __toESM(require_prompts3(), 1);
+var import_fs_extra12 = __toESM(require_lib2(), 1);
+var import_path12 = __toESM(require("path"), 1);
+var import_node_child_process = require("child_process");
+var import_node_os4 = require("os");
+var PI_AGENT_DIR = import_path12.default.join((0, import_node_os4.homedir)(), ".pi", "agent");
+function fillTemplate(template, values) {
+  return template.replace(/\{\{(\w+)\}\}/g, (_, key) => values[key] ?? "");
+}
+function isPiInstalled() {
+  return (0, import_node_child_process.spawnSync)("pi", ["--version"], { encoding: "utf8" }).status === 0;
+}
+function createInstallPiCommand() {
+  const cmd = new Command("pi");
+  cmd.description("Install Pi coding agent with providers, extensions, and npm packages").option("-y, --yes", "Skip confirmation prompts", false).action(async (opts) => {
+    const { yes } = opts;
+    const repoRoot = await findRepoRoot();
+    const piConfigDir = import_path12.default.join(repoRoot, "config", "pi");
+    console.log(t.bold("\n  Pi Coding Agent Setup\n"));
+    if (!isPiInstalled()) {
+      console.log(kleur_default.yellow("  pi not found \u2014 installing oh-pi globally...\n"));
+      const r = (0, import_node_child_process.spawnSync)("npm", ["install", "-g", "oh-pi"], { stdio: "inherit" });
+      if (r.status !== 0) {
+        console.error(kleur_default.red("\n  Failed to install oh-pi. Run: npm install -g oh-pi\n"));
+        process.exit(1);
+      }
+      console.log(t.success("  pi installed\n"));
+    } else {
+      const v = (0, import_node_child_process.spawnSync)("pi", ["--version"], { encoding: "utf8" });
+      console.log(t.success(`  pi ${v.stdout.trim()} already installed
+`));
+    }
+    const schema = await import_fs_extra12.default.readJson(import_path12.default.join(piConfigDir, "install-schema.json"));
+    const values = {};
+    console.log(t.bold("  API Keys\n"));
+    for (const field of schema.fields) {
+      if (!field.required && !yes) {
+        const { include } = await (0, import_prompts2.default)({ type: "confirm", name: "include", message: `  Configure ${field.label}? (optional)`, initial: false });
+        if (!include) continue;
+      }
+      const { value } = await (0, import_prompts2.default)({ type: field.secret ? "password" : "text", name: "value", message: `  ${field.label}`, hint: field.hint, validate: (v) => field.required && !v ? "Required" : true });
+      if (value) values[field.key] = value;
+    }
+    await import_fs_extra12.default.ensureDir(PI_AGENT_DIR);
+    console.log(t.muted(`
+  Writing config to ${PI_AGENT_DIR}`));
+    for (const name of ["models.json", "auth.json", "settings.json"]) {
+      const destPath = import_path12.default.join(PI_AGENT_DIR, name);
+      if (name === "auth.json" && await import_fs_extra12.default.pathExists(destPath) && !yes) {
+        const { overwrite } = await (0, import_prompts2.default)({ type: "confirm", name: "overwrite", message: `  ${name} already exists \u2014 overwrite? (OAuth tokens will be lost)`, initial: false });
+        if (!overwrite) {
+          console.log(t.muted(`    skipped ${name}`));
+          continue;
+        }
+      }
+      const raw = await import_fs_extra12.default.readFile(import_path12.default.join(piConfigDir, `${name}.template`), "utf8");
+      await import_fs_extra12.default.writeFile(destPath, fillTemplate(raw, values), "utf8");
+      console.log(t.success(`    ${sym.ok} ${name}`));
+    }
+    await import_fs_extra12.default.copy(import_path12.default.join(piConfigDir, "extensions"), import_path12.default.join(PI_AGENT_DIR, "extensions"), { overwrite: true });
+    console.log(t.success(`    ${sym.ok} extensions/`));
+    console.log(t.bold("\n  npm Packages\n"));
+    for (const pkg of schema.packages) {
+      const r = (0, import_node_child_process.spawnSync)("pi", ["install", pkg], { stdio: "inherit" });
+      if (r.status === 0) console.log(t.success(`    ${sym.ok} ${pkg}`));
+      else console.log(kleur_default.yellow(`    ${pkg} \u2014 failed, run manually: pi install ${pkg}`));
+    }
+    console.log(t.bold("\n  OAuth (manual steps)\n"));
+    for (const provider of schema.oauth_providers) {
+      console.log(t.muted(`    ${provider.key}: ${provider.instruction}`));
+    }
+    console.log(t.boldGreen("\n  Pi setup complete\n"));
+  });
+  return cmd;
+}
+
 // src/commands/install.ts
 var import_child_process4 = require("child_process");
 var import_child_process5 = require("child_process");
@@ -41471,7 +41548,7 @@ function formatTargetLabel(target) {
   const normalized = target.replace(/\\/g, "/").toLowerCase();
   if (normalized.endsWith("/.agents/skills") || normalized.includes("/.agents/skills/")) return "~/.agents/skills";
   if (normalized.endsWith("/.claude") || normalized.includes("/.claude/")) return "~/.claude";
-  return import_path12.default.basename(target);
+  return import_path13.default.basename(target);
 }
 function filterBeadsFromChangeSet(changeSet) {
   return {
@@ -41504,15 +41581,15 @@ function isDoltInstalled() {
 async function needsSettingsSync(repoRoot, target) {
   const normalizedTarget = target.replace(/\\/g, "/").toLowerCase();
   if (normalizedTarget.includes(".agents/skills")) return false;
-  const hooksTemplatePath = import_path12.default.join(repoRoot, "config", "hooks.json");
-  if (!await import_fs_extra12.default.pathExists(hooksTemplatePath)) return false;
-  const requiredEvents = Object.keys((await import_fs_extra12.default.readJson(hooksTemplatePath)).hooks ?? {});
+  const hooksTemplatePath = import_path13.default.join(repoRoot, "config", "hooks.json");
+  if (!await import_fs_extra13.default.pathExists(hooksTemplatePath)) return false;
+  const requiredEvents = Object.keys((await import_fs_extra13.default.readJson(hooksTemplatePath)).hooks ?? {});
   if (requiredEvents.length === 0) return false;
-  const targetSettingsPath = import_path12.default.join(target, "settings.json");
-  if (!await import_fs_extra12.default.pathExists(targetSettingsPath)) return true;
+  const targetSettingsPath = import_path13.default.join(target, "settings.json");
+  if (!await import_fs_extra13.default.pathExists(targetSettingsPath)) return true;
   let settings = {};
   try {
-    settings = await import_fs_extra12.default.readJson(targetSettingsPath);
+    settings = await import_fs_extra13.default.readJson(targetSettingsPath);
   } catch {
     return true;
   }
@@ -41541,7 +41618,7 @@ async function runGlobalInstall(flags, installOpts = {}) {
       const missing = [!beadsOk && "bd", !doltOk && "dolt"].filter(Boolean).join(", ");
       let doInstall = effectiveYes;
       if (!effectiveYes) {
-        const { install } = await (0, import_prompts2.default)({
+        const { install } = await (0, import_prompts3.default)({
           type: "confirm",
           name: "install",
           message: `Install beads + dolt? (${missing} not found) \u2014 required for workflow enforcement hooks`,
@@ -41620,7 +41697,7 @@ async function runGlobalInstall(flags, installOpts = {}) {
   }
   if (!effectiveYes) {
     const totalChangesCount = allChanges.reduce((s, c) => s + c.totalChanges, 0);
-    const { confirm } = await (0, import_prompts2.default)({
+    const { confirm } = await (0, import_prompts3.default)({
       type: "confirm",
       name: "confirm",
       message: `Proceed with install (${totalChangesCount} total changes)?`,
@@ -41692,7 +41769,7 @@ function createInstallCommand() {
         const missing = [!beadsOk && "bd", !doltOk && "dolt"].filter(Boolean).join(", ");
         let doInstall = effectiveYes;
         if (!effectiveYes) {
-          const { install } = await (0, import_prompts2.default)({
+          const { install } = await (0, import_prompts3.default)({
             type: "confirm",
             name: "install",
             message: `Install beads + dolt? (${missing} not found) \u2014 required for workflow enforcement hooks`,
@@ -41788,7 +41865,7 @@ function createInstallCommand() {
     }
     if (!effectiveYes) {
       const totalChangesCount = allChanges.reduce((s, c) => s + c.totalChanges, 0);
-      const { confirm } = await (0, import_prompts2.default)({
+      const { confirm } = await (0, import_prompts3.default)({
         type: "confirm",
         name: "confirm",
         message: `Proceed with ${actionLabel} (${totalChangesCount} total changes)?`,
@@ -41819,14 +41896,15 @@ function createInstallCommand() {
   installCmd.addCommand(createInstallAllCommand());
   installCmd.addCommand(createInstallBasicCommand());
   installCmd.addCommand(createInstallProjectCommand());
+  installCmd.addCommand(createInstallPiCommand());
   return installCmd;
 }
 
 // src/commands/status.ts
-var import_prompts3 = __toESM(require_prompts3(), 1);
+var import_prompts4 = __toESM(require_prompts3(), 1);
 
 // src/core/manifest.ts
-var import_path13 = require("path");
+var import_path14 = require("path");
 
 // ../node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -42595,10 +42673,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path16) {
-  if (!path16)
+function getElementAtPath(obj, path17) {
+  if (!path17)
     return obj;
-  return path16.reduce((acc, key) => acc?.[key], obj);
+  return path17.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -42981,11 +43059,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path16, issues) {
+function prefixIssues(path17, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path16);
+    iss.path.unshift(path17);
     return iss;
   });
 }
@@ -43168,7 +43246,7 @@ function formatError(error49, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error49, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error50, path16 = []) => {
+  const processError = (error50, path17 = []) => {
     var _a2, _b;
     for (const issue2 of error50.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -43178,7 +43256,7 @@ function treeifyError(error49, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path16, ...issue2.path];
+        const fullpath = [...path17, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -43210,8 +43288,8 @@ function treeifyError(error49, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path16 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path16) {
+  const path17 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path17) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -55188,13 +55266,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path16 = ref.slice(1).split("/").filter(Boolean);
-  if (path16.length === 0) {
+  const path17 = ref.slice(1).split("/").filter(Boolean);
+  if (path17.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path16[0] === defsKey) {
-    const key = path16[1];
+  if (path17[0] === defsKey) {
+    const key = path17[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -55637,17 +55715,17 @@ var ManifestSchema = external_exports.object({
 // src/core/manifest.ts
 var MANIFEST_FILE = ".jaggers-sync-manifest.json";
 function getManifestPath(projectDir) {
-  return (0, import_path13.join)(projectDir, MANIFEST_FILE);
+  return (0, import_path14.join)(projectDir, MANIFEST_FILE);
 }
 
 // src/commands/status.ts
-var import_fs_extra13 = __toESM(require_lib2(), 1);
-var import_path14 = __toESM(require("path"), 1);
+var import_fs_extra14 = __toESM(require_lib2(), 1);
+var import_path15 = __toESM(require("path"), 1);
 function formatTargetLabel2(target) {
   const normalized = target.replace(/\\/g, "/").toLowerCase();
   if (normalized.endsWith("/.agents/skills") || normalized.includes("/.agents/skills/")) return "~/.agents/skills";
   if (normalized.endsWith("/.claude") || normalized.includes("/.claude/")) return "~/.claude";
-  return import_path14.default.basename(target);
+  return import_path15.default.basename(target);
 }
 function formatRelativeTime(timestamp) {
   const now = Date.now();
@@ -55667,7 +55745,7 @@ function createStatusCommand() {
     const candidates = getCandidatePaths();
     const targets = [];
     for (const c of candidates) {
-      if (await import_fs_extra13.default.pathExists(c.path)) targets.push(c.path);
+      if (await import_fs_extra14.default.pathExists(c.path)) targets.push(c.path);
     }
     if (targets.length === 0) {
       console.log(kleur_default.yellow("\n  No agent environments found (~/.claude, ~/.gemini, ~/.qwen)\n"));
@@ -55678,8 +55756,8 @@ function createStatusCommand() {
       const manifestPath = getManifestPath(target);
       let lastSync = null;
       try {
-        if (await import_fs_extra13.default.pathExists(manifestPath)) {
-          const manifest = await import_fs_extra13.default.readJson(manifestPath);
+        if (await import_fs_extra14.default.pathExists(manifestPath)) {
+          const manifest = await import_fs_extra14.default.readJson(manifestPath);
           if (manifest.lastSync) lastSync = manifest.lastSync;
         }
       } catch {
@@ -55729,7 +55807,7 @@ function createStatusCommand() {
     console.log(kleur_default.yellow(`
   \u26A0  ${totalPending} pending change${totalPending !== 1 ? "s" : ""} across ${pending.length} environment${pending.length !== 1 ? "s" : ""}
 `));
-    const { selected } = await (0, import_prompts3.default)({
+    const { selected } = await (0, import_prompts4.default)({
       type: "multiselect",
       name: "selected",
       message: "Select environments to sync:",
@@ -55771,8 +55849,8 @@ function createResetCommand() {
 }
 
 // src/commands/help.ts
-var import_path15 = __toESM(require("path"), 1);
-var import_fs_extra14 = __toESM(require_lib2(), 1);
+var import_path16 = __toESM(require("path"), 1);
+var import_fs_extra15 = __toESM(require_lib2(), 1);
 var HOOK_CATALOG = [
   { file: "main-guard.mjs", event: "PreToolUse", desc: "Blocks direct edits on protected branches" },
   { file: "main-guard-post-push.mjs", event: "PostToolUse", desc: "After feature-branch push, reminds PR/merge/sync steps" },
@@ -55788,26 +55866,26 @@ var HOOK_CATALOG = [
   { file: "beads-close-memory-prompt.mjs", event: "PostToolUse", desc: "Prompts memory save when closing a beads issue", beads: true }
 ];
 async function readSkillsFromDir(dir) {
-  if (!await import_fs_extra14.default.pathExists(dir)) return [];
-  const entries = await import_fs_extra14.default.readdir(dir);
+  if (!await import_fs_extra15.default.pathExists(dir)) return [];
+  const entries = await import_fs_extra15.default.readdir(dir);
   const skills = [];
   for (const name of entries.sort()) {
-    const skillMd = import_path15.default.join(dir, name, "SKILL.md");
-    if (!await import_fs_extra14.default.pathExists(skillMd)) continue;
-    const content = await import_fs_extra14.default.readFile(skillMd, "utf8");
+    const skillMd = import_path16.default.join(dir, name, "SKILL.md");
+    if (!await import_fs_extra15.default.pathExists(skillMd)) continue;
+    const content = await import_fs_extra15.default.readFile(skillMd, "utf8");
     const m = content.match(/^description:\s*(.+)$/m);
     skills.push({ name, desc: m ? m[1].replace(/^["']|["']$/g, "").trim() : "" });
   }
   return skills;
 }
 async function readProjectSkillsFromDir(dir) {
-  if (!await import_fs_extra14.default.pathExists(dir)) return [];
-  const entries = await import_fs_extra14.default.readdir(dir);
+  if (!await import_fs_extra15.default.pathExists(dir)) return [];
+  const entries = await import_fs_extra15.default.readdir(dir);
   const skills = [];
   for (const name of entries.sort()) {
-    const readme = import_path15.default.join(dir, name, "README.md");
-    if (!await import_fs_extra14.default.pathExists(readme)) continue;
-    const content = await import_fs_extra14.default.readFile(readme, "utf8");
+    const readme = import_path16.default.join(dir, name, "README.md");
+    if (!await import_fs_extra15.default.pathExists(readme)) continue;
+    const content = await import_fs_extra15.default.readFile(readme, "utf8");
     const descLine = content.split("\n").find((line) => {
       const trimmed = line.trim();
       return Boolean(trimmed) && !trimmed.startsWith("#") && !trimmed.startsWith("[") && !trimmed.startsWith("<");
@@ -55818,11 +55896,11 @@ async function readProjectSkillsFromDir(dir) {
 }
 function resolvePkgRootFallback() {
   const candidates = [
-    import_path15.default.resolve(__dirname, "../.."),
-    import_path15.default.resolve(__dirname, "../../..")
+    import_path16.default.resolve(__dirname, "../.."),
+    import_path16.default.resolve(__dirname, "../../..")
   ];
   const match = candidates.find(
-    (candidate) => import_fs_extra14.default.existsSync(import_path15.default.join(candidate, "skills")) || import_fs_extra14.default.existsSync(import_path15.default.join(candidate, "project-skills"))
+    (candidate) => import_fs_extra15.default.existsSync(import_path16.default.join(candidate, "skills")) || import_fs_extra15.default.existsSync(import_path16.default.join(candidate, "project-skills"))
   );
   return match || null;
 }
@@ -55840,8 +55918,8 @@ function createHelpCommand() {
     const pkgRoot = resolvePkgRootFallback();
     const skillsRoot = repoRoot || pkgRoot || "";
     const projectSkillsRoot = repoRoot || pkgRoot || "";
-    const skills = skillsRoot ? await readSkillsFromDir(import_path15.default.join(skillsRoot, "skills")) : [];
-    const projectSkills = projectSkillsRoot ? await readProjectSkillsFromDir(import_path15.default.join(projectSkillsRoot, "project-skills")) : [];
+    const skills = skillsRoot ? await readSkillsFromDir(import_path16.default.join(skillsRoot, "skills")) : [];
+    const projectSkills = projectSkillsRoot ? await readProjectSkillsFromDir(import_path16.default.join(projectSkillsRoot, "project-skills")) : [];
     const W = 80;
     const hr = kleur_default.dim("-".repeat(W));
     const section = (title) => `