@meltstudio/meltctl 5.21.0 → 5.22.0

package/dist/index.js

@@ -1726,8 +1726,8 @@ var require_command = __commonJS({
     "use strict";
     var EventEmitter = __require("events").EventEmitter;
     var childProcess = __require("child_process");
-    var path11 = __require("path");
-    var fs7 = __require("fs");
+    var path10 = __require("path");
+    var fs6 = __require("fs");
     var process7 = __require("process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -2722,7 +2722,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} subcommandName
        */
       _checkForMissingExecutable(executableFile, executableDir, subcommandName) {
-        if (fs7.existsSync(executableFile)) return;
+        if (fs6.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
@@ -2740,11 +2740,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path11.resolve(baseDir, baseName);
-          if (fs7.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path11.extname(baseName))) return void 0;
+          const localBin = path10.resolve(baseDir, baseName);
+          if (fs6.existsSync(localBin)) return localBin;
+          if (sourceExt.includes(path10.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs7.existsSync(`${localBin}${ext}`)
+            (ext) => fs6.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -2756,21 +2756,21 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs7.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs6.realpathSync(this._scriptPath);
           } catch {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path11.resolve(
-            path11.dirname(resolvedScriptPath),
+          executableDir = path10.resolve(
+            path10.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path11.basename(
+            const legacyName = path10.basename(
               this._scriptPath,
-              path11.extname(this._scriptPath)
+              path10.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -2781,7 +2781,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path11.extname(executableFile));
+        launchWithNode = sourceExt.includes(path10.extname(executableFile));
         let proc;
         if (process7.platform !== "win32") {
           if (launchWithNode) {
@@ -3697,7 +3697,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path11.basename(filename, path11.extname(filename));
+        this._name = path10.basename(filename, path10.extname(filename));
         return this;
       }
       /**
@@ -3711,9 +3711,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path12) {
-        if (path12 === void 0) return this._executableDir;
-        this._executableDir = path12;
+      executableDir(path11) {
+        if (path11 === void 0) return this._executableDir;
+        this._executableDir = path11;
         return this;
       }
       /**
@@ -4067,54 +4067,54 @@ var require_polyfills = __commonJS({
     }
     var chdir;
     module.exports = patch;
-    function patch(fs7) {
+    function patch(fs6) {
       if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-        patchLchmod(fs7);
-      }
-      if (!fs7.lutimes) {
-        patchLutimes(fs7);
-      }
-      fs7.chown = chownFix(fs7.chown);
-      fs7.fchown = chownFix(fs7.fchown);
-      fs7.lchown = chownFix(fs7.lchown);
-      fs7.chmod = chmodFix(fs7.chmod);
-      fs7.fchmod = chmodFix(fs7.fchmod);
-      fs7.lchmod = chmodFix(fs7.lchmod);
-      fs7.chownSync = chownFixSync(fs7.chownSync);
-      fs7.fchownSync = chownFixSync(fs7.fchownSync);
-      fs7.lchownSync = chownFixSync(fs7.lchownSync);
-      fs7.chmodSync = chmodFixSync(fs7.chmodSync);
-      fs7.fchmodSync = chmodFixSync(fs7.fchmodSync);
-      fs7.lchmodSync = chmodFixSync(fs7.lchmodSync);
-      fs7.stat = statFix(fs7.stat);
-      fs7.fstat = statFix(fs7.fstat);
-      fs7.lstat = statFix(fs7.lstat);
-      fs7.statSync = statFixSync(fs7.statSync);
-      fs7.fstatSync = statFixSync(fs7.fstatSync);
-      fs7.lstatSync = statFixSync(fs7.lstatSync);
-      if (fs7.chmod && !fs7.lchmod) {
-        fs7.lchmod = function(path11, mode, cb) {
+        patchLchmod(fs6);
+      }
+      if (!fs6.lutimes) {
+        patchLutimes(fs6);
+      }
+      fs6.chown = chownFix(fs6.chown);
+      fs6.fchown = chownFix(fs6.fchown);
+      fs6.lchown = chownFix(fs6.lchown);
+      fs6.chmod = chmodFix(fs6.chmod);
+      fs6.fchmod = chmodFix(fs6.fchmod);
+      fs6.lchmod = chmodFix(fs6.lchmod);
+      fs6.chownSync = chownFixSync(fs6.chownSync);
+      fs6.fchownSync = chownFixSync(fs6.fchownSync);
+      fs6.lchownSync = chownFixSync(fs6.lchownSync);
+      fs6.chmodSync = chmodFixSync(fs6.chmodSync);
+      fs6.fchmodSync = chmodFixSync(fs6.fchmodSync);
+      fs6.lchmodSync = chmodFixSync(fs6.lchmodSync);
+      fs6.stat = statFix(fs6.stat);
+      fs6.fstat = statFix(fs6.fstat);
+      fs6.lstat = statFix(fs6.lstat);
+      fs6.statSync = statFixSync(fs6.statSync);
+      fs6.fstatSync = statFixSync(fs6.fstatSync);
+      fs6.lstatSync = statFixSync(fs6.lstatSync);
+      if (fs6.chmod && !fs6.lchmod) {
+        fs6.lchmod = function(path10, mode, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs7.lchmodSync = function() {
+        fs6.lchmodSync = function() {
         };
       }
-      if (fs7.chown && !fs7.lchown) {
-        fs7.lchown = function(path11, uid, gid, cb) {
+      if (fs6.chown && !fs6.lchown) {
+        fs6.lchown = function(path10, uid, gid, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs7.lchownSync = function() {
+        fs6.lchownSync = function() {
         };
       }
       if (platform === "win32") {
-        fs7.rename = typeof fs7.rename !== "function" ? fs7.rename : (function(fs$rename) {
+        fs6.rename = typeof fs6.rename !== "function" ? fs6.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() {
-                  fs7.stat(to, function(stater, st) {
+                  fs6.stat(to, function(stater, st) {
                     if (stater && stater.code === "ENOENT")
                       fs$rename(from, to, CB);
                     else
@@ -4130,9 +4130,9 @@ var require_polyfills = __commonJS({
           }
           if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
           return rename;
-        })(fs7.rename);
+        })(fs6.rename);
       }
-      fs7.read = typeof fs7.read !== "function" ? fs7.read : (function(fs$read) {
+      fs6.read = typeof fs6.read !== "function" ? fs6.read : (function(fs$read) {
         function read(fd, buffer, offset, length, position, callback_) {
           var callback;
           if (callback_ && typeof callback_ === "function") {
@@ -4140,22 +4140,22 @@ var require_polyfills = __commonJS({
             callback = function(er, _, __) {
               if (er && er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
-                return fs$read.call(fs7, fd, buffer, offset, length, position, callback);
+                return fs$read.call(fs6, fd, buffer, offset, length, position, callback);
               }
               callback_.apply(this, arguments);
             };
           }
-          return fs$read.call(fs7, fd, buffer, offset, length, position, callback);
+          return fs$read.call(fs6, fd, buffer, offset, length, position, callback);
         }
         if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
         return read;
-      })(fs7.read);
-      fs7.readSync = typeof fs7.readSync !== "function" ? fs7.readSync : /* @__PURE__ */ (function(fs$readSync) {
+      })(fs6.read);
+      fs6.readSync = typeof fs6.readSync !== "function" ? fs6.readSync : /* @__PURE__ */ (function(fs$readSync) {
         return function(fd, buffer, offset, length, position) {
           var eagCounter = 0;
           while (true) {
             try {
-              return fs$readSync.call(fs7, fd, buffer, offset, length, position);
+              return fs$readSync.call(fs6, fd, buffer, offset, length, position);
             } catch (er) {
               if (er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
@@ -4165,11 +4165,11 @@ var require_polyfills = __commonJS({
             }
           }
         };
-      })(fs7.readSync);
-      function patchLchmod(fs8) {
-        fs8.lchmod = function(path11, mode, callback) {
-          fs8.open(
-            path11,
+      })(fs6.readSync);
+      function patchLchmod(fs7) {
+        fs7.lchmod = function(path10, mode, callback) {
+          fs7.open(
+            path10,
             constants.O_WRONLY | constants.O_SYMLINK,
             mode,
             function(err, fd) {
@@ -4177,80 +4177,80 @@ var require_polyfills = __commonJS({
                 if (callback) callback(err);
                 return;
               }
-              fs8.fchmod(fd, mode, function(err2) {
-                fs8.close(fd, function(err22) {
+              fs7.fchmod(fd, mode, function(err2) {
+                fs7.close(fd, function(err22) {
                   if (callback) callback(err2 || err22);
                 });
               });
             }
           );
         };
-        fs8.lchmodSync = function(path11, mode) {
-          var fd = fs8.openSync(path11, constants.O_WRONLY | constants.O_SYMLINK, mode);
+        fs7.lchmodSync = function(path10, mode) {
+          var fd = fs7.openSync(path10, constants.O_WRONLY | constants.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
-            ret = fs8.fchmodSync(fd, mode);
+            ret = fs7.fchmodSync(fd, mode);
             threw = false;
           } finally {
             if (threw) {
               try {
-                fs8.closeSync(fd);
+                fs7.closeSync(fd);
               } catch (er) {
               }
             } else {
-              fs8.closeSync(fd);
+              fs7.closeSync(fd);
             }
           }
           return ret;
         };
       }
-      function patchLutimes(fs8) {
-        if (constants.hasOwnProperty("O_SYMLINK") && fs8.futimes) {
-          fs8.lutimes = function(path11, at, mt, cb) {
-            fs8.open(path11, constants.O_SYMLINK, function(er, fd) {
+      function patchLutimes(fs7) {
+        if (constants.hasOwnProperty("O_SYMLINK") && fs7.futimes) {
+          fs7.lutimes = function(path10, at, mt, cb) {
+            fs7.open(path10, constants.O_SYMLINK, function(er, fd) {
               if (er) {
                 if (cb) cb(er);
                 return;
               }
-              fs8.futimes(fd, at, mt, function(er2) {
-                fs8.close(fd, function(er22) {
+              fs7.futimes(fd, at, mt, function(er2) {
+                fs7.close(fd, function(er22) {
                   if (cb) cb(er2 || er22);
                 });
               });
             });
           };
-          fs8.lutimesSync = function(path11, at, mt) {
-            var fd = fs8.openSync(path11, constants.O_SYMLINK);
+          fs7.lutimesSync = function(path10, at, mt) {
+            var fd = fs7.openSync(path10, constants.O_SYMLINK);
             var ret;
             var threw = true;
             try {
-              ret = fs8.futimesSync(fd, at, mt);
+              ret = fs7.futimesSync(fd, at, mt);
               threw = false;
             } finally {
               if (threw) {
                 try {
-                  fs8.closeSync(fd);
+                  fs7.closeSync(fd);
                 } catch (er) {
                 }
               } else {
-                fs8.closeSync(fd);
+                fs7.closeSync(fd);
               }
             }
             return ret;
           };
-        } else if (fs8.futimes) {
-          fs8.lutimes = function(_a3, _b, _c, cb) {
+        } else if (fs7.futimes) {
+          fs7.lutimes = function(_a3, _b, _c, cb) {
             if (cb) process.nextTick(cb);
           };
-          fs8.lutimesSync = function() {
+          fs7.lutimesSync = function() {
           };
         }
       }
       function chmodFix(orig) {
         if (!orig) return orig;
         return function(target, mode, cb) {
-          return orig.call(fs7, target, mode, function(er) {
+          return orig.call(fs6, target, mode, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -4260,7 +4260,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, mode) {
           try {
-            return orig.call(fs7, target, mode);
+            return orig.call(fs6, target, mode);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -4269,7 +4269,7 @@ var require_polyfills = __commonJS({
       function chownFix(orig) {
         if (!orig) return orig;
         return function(target, uid, gid, cb) {
-          return orig.call(fs7, target, uid, gid, function(er) {
+          return orig.call(fs6, target, uid, gid, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -4279,7 +4279,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, uid, gid) {
           try {
-            return orig.call(fs7, target, uid, gid);
+            return orig.call(fs6, target, uid, gid);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -4299,13 +4299,13 @@ var require_polyfills = __commonJS({
             }
             if (cb) cb.apply(this, arguments);
           }
-          return options ? orig.call(fs7, target, options, callback) : orig.call(fs7, target, callback);
+          return options ? orig.call(fs6, target, options, callback) : orig.call(fs6, target, callback);
         };
       }
       function statFixSync(orig) {
         if (!orig) return orig;
         return function(target, options) {
-          var stats = options ? orig.call(fs7, target, options) : orig.call(fs7, target);
+          var stats = options ? orig.call(fs6, target, options) : orig.call(fs6, target);
           if (stats) {
             if (stats.uid < 0) stats.uid += 4294967296;
             if (stats.gid < 0) stats.gid += 4294967296;
@@ -4335,16 +4335,16 @@ var require_legacy_streams = __commonJS({
     "use strict";
     var Stream = __require("stream").Stream;
     module.exports = legacy;
-    function legacy(fs7) {
+    function legacy(fs6) {
       return {
         ReadStream,
         WriteStream
       };
-      function ReadStream(path11, options) {
-        if (!(this instanceof ReadStream)) return new ReadStream(path11, options);
+      function ReadStream(path10, options) {
+        if (!(this instanceof ReadStream)) return new ReadStream(path10, options);
         Stream.call(this);
         var self2 = this;
-        this.path = path11;
+        this.path = path10;
         this.fd = null;
         this.readable = true;
         this.paused = false;
@@ -4378,7 +4378,7 @@ var require_legacy_streams = __commonJS({
           });
           return;
         }
-        fs7.open(this.path, this.flags, this.mode, function(err, fd) {
+        fs6.open(this.path, this.flags, this.mode, function(err, fd) {
           if (err) {
             self2.emit("error", err);
             self2.readable = false;
@@ -4389,10 +4389,10 @@ var require_legacy_streams = __commonJS({
           self2._read();
         });
       }
-      function WriteStream(path11, options) {
-        if (!(this instanceof WriteStream)) return new WriteStream(path11, options);
+      function WriteStream(path10, options) {
+        if (!(this instanceof WriteStream)) return new WriteStream(path10, options);
         Stream.call(this);
-        this.path = path11;
+        this.path = path10;
         this.fd = null;
         this.writable = true;
         this.flags = "w";
@@ -4417,7 +4417,7 @@ var require_legacy_streams = __commonJS({
         this.busy = false;
         this._queue = [];
         if (this.fd === null) {
-          this._open = fs7.open;
+          this._open = fs6.open;
           this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
           this.flush();
         }
@@ -4453,7 +4453,7 @@ var require_clone = __commonJS({
 var require_graceful_fs = __commonJS({
   "../../node_modules/graceful-fs/graceful-fs.js"(exports, module) {
     "use strict";
-    var fs7 = __require("fs");
+    var fs6 = __require("fs");
     var polyfills = require_polyfills();
     var legacy = require_legacy_streams();
     var clone2 = require_clone();
@@ -4485,12 +4485,12 @@ var require_graceful_fs = __commonJS({
         m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
         console.error(m);
       };
-    if (!fs7[gracefulQueue]) {
+    if (!fs6[gracefulQueue]) {
       queue = global[gracefulQueue] || [];
-      publishQueue(fs7, queue);
-      fs7.close = (function(fs$close) {
+      publishQueue(fs6, queue);
+      fs6.close = (function(fs$close) {
         function close(fd, cb) {
-          return fs$close.call(fs7, fd, function(err) {
+          return fs$close.call(fs6, fd, function(err) {
             if (!err) {
               resetQueue();
             }
@@ -4502,48 +4502,48 @@ var require_graceful_fs = __commonJS({
           value: fs$close
         });
         return close;
-      })(fs7.close);
-      fs7.closeSync = (function(fs$closeSync) {
+      })(fs6.close);
+      fs6.closeSync = (function(fs$closeSync) {
         function closeSync(fd) {
-          fs$closeSync.apply(fs7, arguments);
+          fs$closeSync.apply(fs6, arguments);
           resetQueue();
         }
         Object.defineProperty(closeSync, previousSymbol, {
           value: fs$closeSync
         });
         return closeSync;
-      })(fs7.closeSync);
+      })(fs6.closeSync);
       if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
         process.on("exit", function() {
-          debug(fs7[gracefulQueue]);
-          __require("assert").equal(fs7[gracefulQueue].length, 0);
+          debug(fs6[gracefulQueue]);
+          __require("assert").equal(fs6[gracefulQueue].length, 0);
         });
       }
     }
     var queue;
     if (!global[gracefulQueue]) {
-      publishQueue(global, fs7[gracefulQueue]);
-    }
-    module.exports = patch(clone2(fs7));
-    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs7.__patched) {
-      module.exports = patch(fs7);
-      fs7.__patched = true;
-    }
-    function patch(fs8) {
-      polyfills(fs8);
-      fs8.gracefulify = patch;
-      fs8.createReadStream = createReadStream;
-      fs8.createWriteStream = createWriteStream;
-      var fs$readFile = fs8.readFile;
-      fs8.readFile = readFile2;
-      function readFile2(path11, options, cb) {
+      publishQueue(global, fs6[gracefulQueue]);
+    }
+    module.exports = patch(clone2(fs6));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs6.__patched) {
+      module.exports = patch(fs6);
+      fs6.__patched = true;
+    }
+    function patch(fs7) {
+      polyfills(fs7);
+      fs7.gracefulify = patch;
+      fs7.createReadStream = createReadStream;
+      fs7.createWriteStream = createWriteStream;
+      var fs$readFile = fs7.readFile;
+      fs7.readFile = readFile2;
+      function readFile2(path10, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$readFile(path11, options, cb);
-        function go$readFile(path12, options2, cb2, startTime) {
-          return fs$readFile(path12, options2, function(err) {
+        return go$readFile(path10, options, cb);
+        function go$readFile(path11, options2, cb2, startTime) {
+          return fs$readFile(path11, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$readFile, [path12, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$readFile, [path11, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -4551,16 +4551,16 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$writeFile = fs8.writeFile;
-      fs8.writeFile = writeFile;
-      function writeFile(path11, data, options, cb) {
+      var fs$writeFile = fs7.writeFile;
+      fs7.writeFile = writeFile;
+      function writeFile(path10, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$writeFile(path11, data, options, cb);
-        function go$writeFile(path12, data2, options2, cb2, startTime) {
-          return fs$writeFile(path12, data2, options2, function(err) {
+        return go$writeFile(path10, data, options, cb);
+        function go$writeFile(path11, data2, options2, cb2, startTime) {
+          return fs$writeFile(path11, data2, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$writeFile, [path12, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$writeFile, [path11, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -4568,17 +4568,17 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$appendFile = fs8.appendFile;
+      var fs$appendFile = fs7.appendFile;
       if (fs$appendFile)
-        fs8.appendFile = appendFile;
-      function appendFile(path11, data, options, cb) {
+        fs7.appendFile = appendFile;
+      function appendFile(path10, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$appendFile(path11, data, options, cb);
-        function go$appendFile(path12, data2, options2, cb2, startTime) {
-          return fs$appendFile(path12, data2, options2, function(err) {
+        return go$appendFile(path10, data, options, cb);
+        function go$appendFile(path11, data2, options2, cb2, startTime) {
+          return fs$appendFile(path11, data2, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$appendFile, [path12, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$appendFile, [path11, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -4586,9 +4586,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$copyFile = fs8.copyFile;
+      var fs$copyFile = fs7.copyFile;
       if (fs$copyFile)
-        fs8.copyFile = copyFile;
+        fs7.copyFile = copyFile;
       function copyFile(src, dest, flags, cb) {
         if (typeof flags === "function") {
           cb = flags;
@@ -4606,34 +4606,34 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$readdir = fs8.readdir;
-      fs8.readdir = readdir;
+      var fs$readdir = fs7.readdir;
+      fs7.readdir = readdir;
       var noReaddirOptionVersions = /^v[0-5]\./;
-      function readdir(path11, options, cb) {
+      function readdir(path10, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path12, options2, cb2, startTime) {
-          return fs$readdir(path12, fs$readdirCallback(
-            path12,
+        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path11, options2, cb2, startTime) {
+          return fs$readdir(path11, fs$readdirCallback(
+            path11,
             options2,
             cb2,
             startTime
           ));
-        } : function go$readdir2(path12, options2, cb2, startTime) {
-          return fs$readdir(path12, options2, fs$readdirCallback(
-            path12,
+        } : function go$readdir2(path11, options2, cb2, startTime) {
+          return fs$readdir(path11, options2, fs$readdirCallback(
+            path11,
             options2,
             cb2,
             startTime
           ));
         };
-        return go$readdir(path11, options, cb);
-        function fs$readdirCallback(path12, options2, cb2, startTime) {
+        return go$readdir(path10, options, cb);
+        function fs$readdirCallback(path11, options2, cb2, startTime) {
           return function(err, files) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
               enqueue([
                 go$readdir,
-                [path12, options2, cb2],
+                [path11, options2, cb2],
                 err,
                 startTime || Date.now(),
                 Date.now()
@@ -4648,21 +4648,21 @@ var require_graceful_fs = __commonJS({
         }
       }
       if (process.version.substr(0, 4) === "v0.8") {
-        var legStreams = legacy(fs8);
+        var legStreams = legacy(fs7);
         ReadStream = legStreams.ReadStream;
         WriteStream = legStreams.WriteStream;
       }
-      var fs$ReadStream = fs8.ReadStream;
+      var fs$ReadStream = fs7.ReadStream;
       if (fs$ReadStream) {
         ReadStream.prototype = Object.create(fs$ReadStream.prototype);
         ReadStream.prototype.open = ReadStream$open;
       }
-      var fs$WriteStream = fs8.WriteStream;
+      var fs$WriteStream = fs7.WriteStream;
       if (fs$WriteStream) {
         WriteStream.prototype = Object.create(fs$WriteStream.prototype);
         WriteStream.prototype.open = WriteStream$open;
       }
-      Object.defineProperty(fs8, "ReadStream", {
+      Object.defineProperty(fs7, "ReadStream", {
         get: function() {
           return ReadStream;
         },
@@ -4672,7 +4672,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      Object.defineProperty(fs8, "WriteStream", {
+      Object.defineProperty(fs7, "WriteStream", {
         get: function() {
           return WriteStream;
         },
@@ -4683,7 +4683,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileReadStream = ReadStream;
-      Object.defineProperty(fs8, "FileReadStream", {
+      Object.defineProperty(fs7, "FileReadStream", {
         get: function() {
           return FileReadStream;
         },
@@ -4694,7 +4694,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileWriteStream = WriteStream;
-      Object.defineProperty(fs8, "FileWriteStream", {
+      Object.defineProperty(fs7, "FileWriteStream", {
         get: function() {
           return FileWriteStream;
         },
@@ -4704,7 +4704,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      function ReadStream(path11, options) {
+      function ReadStream(path10, options) {
         if (this instanceof ReadStream)
           return fs$ReadStream.apply(this, arguments), this;
         else
@@ -4724,7 +4724,7 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function WriteStream(path11, options) {
+      function WriteStream(path10, options) {
         if (this instanceof WriteStream)
           return fs$WriteStream.apply(this, arguments), this;
         else
@@ -4742,22 +4742,22 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function createReadStream(path11, options) {
-        return new fs8.ReadStream(path11, options);
+      function createReadStream(path10, options) {
+        return new fs7.ReadStream(path10, options);
       }
-      function createWriteStream(path11, options) {
-        return new fs8.WriteStream(path11, options);
+      function createWriteStream(path10, options) {
+        return new fs7.WriteStream(path10, options);
       }
-      var fs$open = fs8.open;
-      fs8.open = open;
-      function open(path11, flags, mode, cb) {
+      var fs$open = fs7.open;
+      fs7.open = open;
+      function open(path10, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
-        return go$open(path11, flags, mode, cb);
-        function go$open(path12, flags2, mode2, cb2, startTime) {
-          return fs$open(path12, flags2, mode2, function(err, fd) {
+        return go$open(path10, flags, mode, cb);
+        function go$open(path11, flags2, mode2, cb2, startTime) {
+          return fs$open(path11, flags2, mode2, function(err, fd) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$open, [path12, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$open, [path11, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -4765,20 +4765,20 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      return fs8;
+      return fs7;
     }
     function enqueue(elem) {
       debug("ENQUEUE", elem[0].name, elem[1]);
-      fs7[gracefulQueue].push(elem);
+      fs6[gracefulQueue].push(elem);
       retry();
     }
     var retryTimer;
     function resetQueue() {
       var now = Date.now();
-      for (var i = 0; i < fs7[gracefulQueue].length; ++i) {
-        if (fs7[gracefulQueue][i].length > 2) {
-          fs7[gracefulQueue][i][3] = now;
-          fs7[gracefulQueue][i][4] = now;
+      for (var i = 0; i < fs6[gracefulQueue].length; ++i) {
+        if (fs6[gracefulQueue][i].length > 2) {
+          fs6[gracefulQueue][i][3] = now;
+          fs6[gracefulQueue][i][4] = now;
         }
       }
       retry();
@@ -4786,9 +4786,9 @@ var require_graceful_fs = __commonJS({
     function retry() {
       clearTimeout(retryTimer);
       retryTimer = void 0;
-      if (fs7[gracefulQueue].length === 0)
+      if (fs6[gracefulQueue].length === 0)
         return;
-      var elem = fs7[gracefulQueue].shift();
+      var elem = fs6[gracefulQueue].shift();
       var fn = elem[0];
       var args = elem[1];
       var err = elem[2];
@@ -4810,7 +4810,7 @@ var require_graceful_fs = __commonJS({
           debug("RETRY", fn.name, args);
           fn.apply(null, args.concat([startTime]));
         } else {
-          fs7[gracefulQueue].push(elem);
+          fs6[gracefulQueue].push(elem);
         }
       }
       if (retryTimer === void 0) {
@@ -4825,7 +4825,7 @@ var require_fs = __commonJS({
   "../../node_modules/fs-extra/lib/fs/index.js"(exports) {
     "use strict";
     var u = require_universalify().fromCallback;
-    var fs7 = require_graceful_fs();
+    var fs6 = require_graceful_fs();
     var api = [
       "access",
       "appendFile",
@@ -4866,26 +4866,26 @@ var require_fs = __commonJS({
       "utimes",
       "writeFile"
     ].filter((key) => {
-      return typeof fs7[key] === "function";
+      return typeof fs6[key] === "function";
     });
-    Object.assign(exports, fs7);
+    Object.assign(exports, fs6);
     api.forEach((method) => {
-      exports[method] = u(fs7[method]);
+      exports[method] = u(fs6[method]);
     });
     exports.exists = function(filename, callback) {
       if (typeof callback === "function") {
-        return fs7.exists(filename, callback);
+        return fs6.exists(filename, callback);
       }
       return new Promise((resolve) => {
-        return fs7.exists(filename, resolve);
+        return fs6.exists(filename, resolve);
       });
     };
     exports.read = function(fd, buffer, offset, length, position, callback) {
       if (typeof callback === "function") {
-        return fs7.read(fd, buffer, offset, length, position, callback);
+        return fs6.read(fd, buffer, offset, length, position, callback);
       }
       return new Promise((resolve, reject) => {
-        fs7.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
+        fs6.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
           if (err) return reject(err);
           resolve({ bytesRead, buffer: buffer2 });
         });
@@ -4893,10 +4893,10 @@ var require_fs = __commonJS({
     };
     exports.write = function(fd, buffer, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs7.write(fd, buffer, ...args);
+        return fs6.write(fd, buffer, ...args);
       }
       return new Promise((resolve, reject) => {
-        fs7.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
+        fs6.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
           if (err) return reject(err);
           resolve({ bytesWritten, buffer: buffer2 });
         });
@@ -4904,10 +4904,10 @@ var require_fs = __commonJS({
     };
     exports.readv = function(fd, buffers, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs7.readv(fd, buffers, ...args);
+        return fs6.readv(fd, buffers, ...args);
       }
       return new Promise((resolve, reject) => {
-        fs7.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
+        fs6.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
           if (err) return reject(err);
           resolve({ bytesRead, buffers: buffers2 });
         });
@@ -4915,17 +4915,17 @@ var require_fs = __commonJS({
     };
     exports.writev = function(fd, buffers, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs7.writev(fd, buffers, ...args);
+        return fs6.writev(fd, buffers, ...args);
       }
       return new Promise((resolve, reject) => {
-        fs7.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
+        fs6.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
           if (err) return reject(err);
           resolve({ bytesWritten, buffers: buffers2 });
         });
       });
     };
-    if (typeof fs7.realpath.native === "function") {
-      exports.realpath.native = u(fs7.realpath.native);
+    if (typeof fs6.realpath.native === "function") {
+      exports.realpath.native = u(fs6.realpath.native);
     } else {
       process.emitWarning(
         "fs.realpath.native is not a function. Is fs being monkey-patched?",
@@ -4940,10 +4940,10 @@ var require_fs = __commonJS({
 var require_utils = __commonJS({
   "../../node_modules/fs-extra/lib/mkdirs/utils.js"(exports, module) {
     "use strict";
-    var path11 = __require("path");
+    var path10 = __require("path");
     module.exports.checkPath = function checkPath(pth) {
       if (process.platform === "win32") {
-        const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path11.parse(pth).root, ""));
+        const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path10.parse(pth).root, ""));
         if (pathHasInvalidWinCharacters) {
           const error51 = new Error(`Path contains invalid characters: ${pth}`);
           error51.code = "EINVAL";
@@ -4958,7 +4958,7 @@ var require_utils = __commonJS({
 var require_make_dir = __commonJS({
   "../../node_modules/fs-extra/lib/mkdirs/make-dir.js"(exports, module) {
     "use strict";
-    var fs7 = require_fs();
+    var fs6 = require_fs();
     var { checkPath } = require_utils();
     var getMode = (options) => {
       const defaults = { mode: 511 };
@@ -4967,14 +4967,14 @@ var require_make_dir = __commonJS({
     };
     module.exports.makeDir = async (dir, options) => {
       checkPath(dir);
-      return fs7.mkdir(dir, {
+      return fs6.mkdir(dir, {
         mode: getMode(options),
         recursive: true
       });
     };
     module.exports.makeDirSync = (dir, options) => {
       checkPath(dir);
-      return fs7.mkdirSync(dir, {
+      return fs6.mkdirSync(dir, {
         mode: getMode(options),
         recursive: true
       });
@@ -5006,13 +5006,13 @@ var require_path_exists = __commonJS({
   "../../node_modules/fs-extra/lib/path-exists/index.js"(exports, module) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs7 = require_fs();
-    function pathExists(path11) {
-      return fs7.access(path11).then(() => true).catch(() => false);
+    var fs6 = require_fs();
+    function pathExists(path10) {
+      return fs6.access(path10).then(() => true).catch(() => false);
     }
     module.exports = {
       pathExists: u(pathExists),
-      pathExistsSync: fs7.existsSync
+      pathExistsSync: fs6.existsSync
     };
   }
 });
@@ -5021,18 +5021,18 @@ var require_path_exists = __commonJS({
 var require_utimes = __commonJS({
   "../../node_modules/fs-extra/lib/util/utimes.js"(exports, module) {
     "use strict";
-    var fs7 = require_fs();
+    var fs6 = require_fs();
     var u = require_universalify().fromPromise;
-    async function utimesMillis(path11, atime, mtime) {
-      const fd = await fs7.open(path11, "r+");
+    async function utimesMillis(path10, atime, mtime) {
+      const fd = await fs6.open(path10, "r+");
       let error51 = null;
       try {
-        await fs7.futimes(fd, atime, mtime);
+        await fs6.futimes(fd, atime, mtime);
       } catch (futimesErr) {
         error51 = futimesErr;
       } finally {
         try {
-          await fs7.close(fd);
+          await fs6.close(fd);
         } catch (closeErr) {
           if (!error51) error51 = closeErr;
         }
@@ -5041,16 +5041,16 @@ var require_utimes = __commonJS({
         throw error51;
       }
     }
-    function utimesMillisSync(path11, atime, mtime) {
-      const fd = fs7.openSync(path11, "r+");
+    function utimesMillisSync(path10, atime, mtime) {
+      const fd = fs6.openSync(path10, "r+");
       let error51 = null;
       try {
-        fs7.futimesSync(fd, atime, mtime);
+        fs6.futimesSync(fd, atime, mtime);
       } catch (futimesErr) {
         error51 = futimesErr;
       } finally {
         try {
-          fs7.closeSync(fd);
+          fs6.closeSync(fd);
         } catch (closeErr) {
           if (!error51) error51 = closeErr;
         }
@@ -5070,11 +5070,11 @@ var require_utimes = __commonJS({
 var require_stat = __commonJS({
   "../../node_modules/fs-extra/lib/util/stat.js"(exports, module) {
     "use strict";
-    var fs7 = require_fs();
-    var path11 = __require("path");
+    var fs6 = require_fs();
+    var path10 = __require("path");
     var u = require_universalify().fromPromise;
     function getStats(src, dest, opts) {
-      const statFunc = opts.dereference ? (file2) => fs7.stat(file2, { bigint: true }) : (file2) => fs7.lstat(file2, { bigint: true });
+      const statFunc = opts.dereference ? (file2) => fs6.stat(file2, { bigint: true }) : (file2) => fs6.lstat(file2, { bigint: true });
       return Promise.all([
         statFunc(src),
         statFunc(dest).catch((err) => {
@@ -5085,7 +5085,7 @@ var require_stat = __commonJS({
     }
     function getStatsSync(src, dest, opts) {
       let destStat;
-      const statFunc = opts.dereference ? (file2) => fs7.statSync(file2, { bigint: true }) : (file2) => fs7.lstatSync(file2, { bigint: true });
+      const statFunc = opts.dereference ? (file2) => fs6.statSync(file2, { bigint: true }) : (file2) => fs6.lstatSync(file2, { bigint: true });
       const srcStat = statFunc(src);
       try {
         destStat = statFunc(dest);
@@ -5099,8 +5099,8 @@ var require_stat = __commonJS({
       const { srcStat, destStat } = await getStats(src, dest, opts);
       if (destStat) {
         if (areIdentical(srcStat, destStat)) {
-          const srcBaseName = path11.basename(src);
-          const destBaseName = path11.basename(dest);
+          const srcBaseName = path10.basename(src);
+          const destBaseName = path10.basename(dest);
           if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
             return { srcStat, destStat, isChangingCase: true };
           }
@@ -5122,8 +5122,8 @@ var require_stat = __commonJS({
       const { srcStat, destStat } = getStatsSync(src, dest, opts);
       if (destStat) {
         if (areIdentical(srcStat, destStat)) {
-          const srcBaseName = path11.basename(src);
-          const destBaseName = path11.basename(dest);
+          const srcBaseName = path10.basename(src);
+          const destBaseName = path10.basename(dest);
           if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
             return { srcStat, destStat, isChangingCase: true };
           }
@@ -5142,12 +5142,12 @@ var require_stat = __commonJS({
       return { srcStat, destStat };
     }
     async function checkParentPaths(src, srcStat, dest, funcName) {
-      const srcParent = path11.resolve(path11.dirname(src));
-      const destParent = path11.resolve(path11.dirname(dest));
-      if (destParent === srcParent || destParent === path11.parse(destParent).root) return;
+      const srcParent = path10.resolve(path10.dirname(src));
+      const destParent = path10.resolve(path10.dirname(dest));
+      if (destParent === srcParent || destParent === path10.parse(destParent).root) return;
       let destStat;
       try {
-        destStat = await fs7.stat(destParent, { bigint: true });
+        destStat = await fs6.stat(destParent, { bigint: true });
       } catch (err) {
         if (err.code === "ENOENT") return checkParentPaths(src, srcStat, destParent, funcName);
         throw err;
@@ -5158,12 +5158,12 @@ var require_stat = __commonJS({
       return checkParentPaths(src, srcStat, destParent, funcName);
     }
     function checkParentPathsSync(src, srcStat, dest, funcName) {
-      const srcParent = path11.resolve(path11.dirname(src));
-      const destParent = path11.resolve(path11.dirname(dest));
-      if (destParent === srcParent || destParent === path11.parse(destParent).root) return;
+      const srcParent = path10.resolve(path10.dirname(src));
+      const destParent = path10.resolve(path10.dirname(dest));
+      if (destParent === srcParent || destParent === path10.parse(destParent).root) return;
       let destStat;
       try {
-        destStat = fs7.statSync(destParent, { bigint: true });
+        destStat = fs6.statSync(destParent, { bigint: true });
       } catch (err) {
         if (err.code === "ENOENT") return checkParentPathsSync(src, srcStat, destParent, funcName);
         throw err;
@@ -5177,8 +5177,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 = path11.resolve(src).split(path11.sep).filter((i) => i);
-      const destArr = path11.resolve(dest).split(path11.sep).filter((i) => i);
+      const srcArr = path10.resolve(src).split(path10.sep).filter((i) => i);
+      const destArr = path10.resolve(dest).split(path10.sep).filter((i) => i);
       return srcArr.every((cur, i) => destArr[i] === cur);
     }
     function errMsg(src, dest, funcName) {
@@ -5230,8 +5230,8 @@ var require_async = __commonJS({
 var require_copy = __commonJS({
   "../../node_modules/fs-extra/lib/copy/copy.js"(exports, module) {
     "use strict";
-    var fs7 = require_fs();
-    var path11 = __require("path");
+    var fs6 = require_fs();
+    var path10 = __require("path");
     var { mkdirs } = require_mkdirs();
     var { pathExists } = require_path_exists();
     var { utimesMillis } = require_utimes();
@@ -5254,7 +5254,7 @@ var require_copy = __commonJS({
       await stat.checkParentPaths(src, srcStat, dest, "copy");
       const include = await runFilter(src, dest, opts);
       if (!include) return;
-      const destParent = path11.dirname(dest);
+      const destParent = path10.dirname(dest);
       const dirExists = await pathExists(destParent);
       if (!dirExists) {
         await mkdirs(destParent);
@@ -5266,7 +5266,7 @@ var require_copy = __commonJS({
       return opts.filter(src, dest);
     }
     async function getStatsAndPerformCopy(destStat, src, dest, opts) {
-      const statFn = opts.dereference ? fs7.stat : fs7.lstat;
+      const statFn = opts.dereference ? fs6.stat : fs6.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);
@@ -5278,7 +5278,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 fs7.unlink(dest);
+        await fs6.unlink(dest);
         return copyFile(srcStat, src, dest, opts);
       }
       if (opts.errorOnExist) {
@@ -5286,29 +5286,29 @@ var require_copy = __commonJS({
       }
     }
     async function copyFile(srcStat, src, dest, opts) {
-      await fs7.copyFile(src, dest);
+      await fs6.copyFile(src, dest);
       if (opts.preserveTimestamps) {
         if (fileIsNotWritable(srcStat.mode)) {
           await makeFileWritable(dest, srcStat.mode);
         }
-        const updatedSrcStat = await fs7.stat(src);
+        const updatedSrcStat = await fs6.stat(src);
         await utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
       }
-      return fs7.chmod(dest, srcStat.mode);
+      return fs6.chmod(dest, srcStat.mode);
     }
     function fileIsNotWritable(srcMode) {
       return (srcMode & 128) === 0;
     }
     function makeFileWritable(dest, srcMode) {
-      return fs7.chmod(dest, srcMode | 128);
+      return fs6.chmod(dest, srcMode | 128);
     }
     async function onDir(srcStat, destStat, src, dest, opts) {
       if (!destStat) {
-        await fs7.mkdir(dest);
+        await fs6.mkdir(dest);
       }
-      await asyncIteratorConcurrentProcess(await fs7.opendir(src), async (item) => {
-        const srcItem = path11.join(src, item.name);
-        const destItem = path11.join(dest, item.name);
+      await asyncIteratorConcurrentProcess(await fs6.opendir(src), async (item) => {
+        const srcItem = path10.join(src, item.name);
+        const destItem = path10.join(dest, item.name);
         const include = await runFilter(srcItem, destItem, opts);
         if (include) {
           const { destStat: destStat2 } = await stat.checkPaths(srcItem, destItem, "copy", opts);
@@ -5316,26 +5316,26 @@ var require_copy = __commonJS({
         }
       });
       if (!destStat) {
-        await fs7.chmod(dest, srcStat.mode);
+        await fs6.chmod(dest, srcStat.mode);
       }
     }
     async function onLink(destStat, src, dest, opts) {
-      let resolvedSrc = await fs7.readlink(src);
+      let resolvedSrc = await fs6.readlink(src);
       if (opts.dereference) {
-        resolvedSrc = path11.resolve(process.cwd(), resolvedSrc);
+        resolvedSrc = path10.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
-        return fs7.symlink(resolvedSrc, dest);
+        return fs6.symlink(resolvedSrc, dest);
       }
       let resolvedDest = null;
       try {
-        resolvedDest = await fs7.readlink(dest);
+        resolvedDest = await fs6.readlink(dest);
       } catch (e) {
-        if (e.code === "EINVAL" || e.code === "UNKNOWN") return fs7.symlink(resolvedSrc, dest);
+        if (e.code === "EINVAL" || e.code === "UNKNOWN") return fs6.symlink(resolvedSrc, dest);
         throw e;
       }
       if (opts.dereference) {
-        resolvedDest = path11.resolve(process.cwd(), resolvedDest);
+        resolvedDest = path10.resolve(process.cwd(), resolvedDest);
       }
       if (resolvedSrc !== resolvedDest) {
         if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
@@ -5345,8 +5345,8 @@ var require_copy = __commonJS({
           throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
         }
       }
-      await fs7.unlink(dest);
-      return fs7.symlink(resolvedSrc, dest);
+      await fs6.unlink(dest);
+      return fs6.symlink(resolvedSrc, dest);
     }
     module.exports = copy;
   }
@@ -5356,8 +5356,8 @@ var require_copy = __commonJS({
 var require_copy_sync = __commonJS({
   "../../node_modules/fs-extra/lib/copy/copy-sync.js"(exports, module) {
     "use strict";
-    var fs7 = require_graceful_fs();
-    var path11 = __require("path");
+    var fs6 = require_graceful_fs();
+    var path10 = __require("path");
     var mkdirsSync = require_mkdirs().mkdirsSync;
     var utimesMillisSync = require_utimes().utimesMillisSync;
     var stat = require_stat();
@@ -5378,12 +5378,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 = path11.dirname(dest);
-      if (!fs7.existsSync(destParent)) mkdirsSync(destParent);
+      const destParent = path10.dirname(dest);
+      if (!fs6.existsSync(destParent)) mkdirsSync(destParent);
       return getStats(destStat, src, dest, opts);
     }
     function getStats(destStat, src, dest, opts) {
-      const statSync = opts.dereference ? fs7.statSync : fs7.lstatSync;
+      const statSync = opts.dereference ? fs6.statSync : fs6.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);
@@ -5398,14 +5398,14 @@ var require_copy_sync = __commonJS({
     }
     function mayCopyFile(srcStat, src, dest, opts) {
       if (opts.overwrite) {
-        fs7.unlinkSync(dest);
+        fs6.unlinkSync(dest);
         return copyFile(srcStat, src, dest, opts);
       } else if (opts.errorOnExist) {
         throw new Error(`'${dest}' already exists`);
       }
     }
     function copyFile(srcStat, src, dest, opts) {
-      fs7.copyFileSync(src, dest);
+      fs6.copyFileSync(src, dest);
       if (opts.preserveTimestamps) handleTimestamps(srcStat.mode, src, dest);
       return setDestMode(dest, srcStat.mode);
     }
@@ -5420,10 +5420,10 @@ var require_copy_sync = __commonJS({
       return setDestMode(dest, srcMode | 128);
     }
     function setDestMode(dest, srcMode) {
-      return fs7.chmodSync(dest, srcMode);
+      return fs6.chmodSync(dest, srcMode);
     }
     function setDestTimestamps(src, dest) {
-      const updatedSrcStat = fs7.statSync(src);
+      const updatedSrcStat = fs6.statSync(src);
       return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
     }
     function onDir(srcStat, destStat, src, dest, opts) {
@@ -5431,12 +5431,12 @@ var require_copy_sync = __commonJS({
       return copyDir(src, dest, opts);
     }
     function mkDirAndCopy(srcMode, src, dest, opts) {
-      fs7.mkdirSync(dest);
+      fs6.mkdirSync(dest);
       copyDir(src, dest, opts);
       return setDestMode(dest, srcMode);
     }
     function copyDir(src, dest, opts) {
-      const dir = fs7.opendirSync(src);
+      const dir = fs6.opendirSync(src);
       try {
         let dirent;
         while ((dirent = dir.readSync()) !== null) {
@@ -5447,29 +5447,29 @@ var require_copy_sync = __commonJS({
       }
     }
     function copyDirItem(item, src, dest, opts) {
-      const srcItem = path11.join(src, item);
-      const destItem = path11.join(dest, item);
+      const srcItem = path10.join(src, item);
+      const destItem = path10.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 = fs7.readlinkSync(src);
+      let resolvedSrc = fs6.readlinkSync(src);
       if (opts.dereference) {
-        resolvedSrc = path11.resolve(process.cwd(), resolvedSrc);
+        resolvedSrc = path10.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
-        return fs7.symlinkSync(resolvedSrc, dest);
+        return fs6.symlinkSync(resolvedSrc, dest);
       } else {
         let resolvedDest;
         try {
-          resolvedDest = fs7.readlinkSync(dest);
+          resolvedDest = fs6.readlinkSync(dest);
         } catch (err) {
-          if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs7.symlinkSync(resolvedSrc, dest);
+          if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs6.symlinkSync(resolvedSrc, dest);
           throw err;
         }
         if (opts.dereference) {
-          resolvedDest = path11.resolve(process.cwd(), resolvedDest);
+          resolvedDest = path10.resolve(process.cwd(), resolvedDest);
         }
         if (resolvedSrc !== resolvedDest) {
           if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
@@ -5483,8 +5483,8 @@ var require_copy_sync = __commonJS({
       }
     }
     function copyLink(resolvedSrc, dest) {
-      fs7.unlinkSync(dest);
-      return fs7.symlinkSync(resolvedSrc, dest);
+      fs6.unlinkSync(dest);
+      return fs6.symlinkSync(resolvedSrc, dest);
     }
     module.exports = copySync;
   }
@@ -5506,13 +5506,13 @@ var require_copy2 = __commonJS({
 var require_remove = __commonJS({
   "../../node_modules/fs-extra/lib/remove/index.js"(exports, module) {
     "use strict";
-    var fs7 = require_graceful_fs();
+    var fs6 = require_graceful_fs();
     var u = require_universalify().fromCallback;
-    function remove(path11, callback) {
-      fs7.rm(path11, { recursive: true, force: true }, callback);
+    function remove(path10, callback) {
+      fs6.rm(path10, { recursive: true, force: true }, callback);
     }
-    function removeSync(path11) {
-      fs7.rmSync(path11, { recursive: true, force: true });
+    function removeSync(path10) {
+      fs6.rmSync(path10, { recursive: true, force: true });
     }
     module.exports = {
       remove: u(remove),
@@ -5526,28 +5526,28 @@ var require_empty = __commonJS({
   "../../node_modules/fs-extra/lib/empty/index.js"(exports, module) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs7 = require_fs();
-    var path11 = __require("path");
+    var fs6 = require_fs();
+    var path10 = __require("path");
     var mkdir = require_mkdirs();
     var remove = require_remove();
     var emptyDir = u(async function emptyDir2(dir) {
       let items;
       try {
-        items = await fs7.readdir(dir);
+        items = await fs6.readdir(dir);
       } catch {
         return mkdir.mkdirs(dir);
       }
-      return Promise.all(items.map((item) => remove.remove(path11.join(dir, item))));
+      return Promise.all(items.map((item) => remove.remove(path10.join(dir, item))));
     });
     function emptyDirSync(dir) {
       let items;
       try {
-        items = fs7.readdirSync(dir);
+        items = fs6.readdirSync(dir);
       } catch {
         return mkdir.mkdirsSync(dir);
       }
       items.forEach((item) => {
-        item = path11.join(dir, item);
+        item = path10.join(dir, item);
         remove.removeSync(item);
       });
     }
@@ -5565,52 +5565,52 @@ var require_file = __commonJS({
   "../../node_modules/fs-extra/lib/ensure/file.js"(exports, module) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var path11 = __require("path");
-    var fs7 = require_fs();
+    var path10 = __require("path");
+    var fs6 = require_fs();
     var mkdir = require_mkdirs();
     async function createFile(file2) {
       let stats;
       try {
-        stats = await fs7.stat(file2);
+        stats = await fs6.stat(file2);
       } catch {
       }
       if (stats && stats.isFile()) return;
-      const dir = path11.dirname(file2);
+      const dir = path10.dirname(file2);
       let dirStats = null;
       try {
-        dirStats = await fs7.stat(dir);
+        dirStats = await fs6.stat(dir);
       } catch (err) {
         if (err.code === "ENOENT") {
           await mkdir.mkdirs(dir);
-          await fs7.writeFile(file2, "");
+          await fs6.writeFile(file2, "");
           return;
         } else {
           throw err;
         }
       }
       if (dirStats.isDirectory()) {
-        await fs7.writeFile(file2, "");
+        await fs6.writeFile(file2, "");
       } else {
-        await fs7.readdir(dir);
+        await fs6.readdir(dir);
       }
     }
     function createFileSync(file2) {
       let stats;
       try {
-        stats = fs7.statSync(file2);
+        stats = fs6.statSync(file2);
       } catch {
       }
       if (stats && stats.isFile()) return;
-      const dir = path11.dirname(file2);
+      const dir = path10.dirname(file2);
       try {
-        if (!fs7.statSync(dir).isDirectory()) {
-          fs7.readdirSync(dir);
+        if (!fs6.statSync(dir).isDirectory()) {
+          fs6.readdirSync(dir);
         }
       } catch (err) {
         if (err && err.code === "ENOENT") mkdir.mkdirsSync(dir);
         else throw err;
       }
-      fs7.writeFileSync(file2, "");
+      fs6.writeFileSync(file2, "");
     }
     module.exports = {
       createFile: u(createFile),
@@ -5624,50 +5624,50 @@ var require_link = __commonJS({
   "../../node_modules/fs-extra/lib/ensure/link.js"(exports, module) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var path11 = __require("path");
-    var fs7 = require_fs();
+    var path10 = __require("path");
+    var fs6 = 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 fs7.lstat(dstpath, { bigint: true });
+        dstStat = await fs6.lstat(dstpath, { bigint: true });
       } catch {
       }
       let srcStat;
       try {
-        srcStat = await fs7.lstat(srcpath, { bigint: true });
+        srcStat = await fs6.lstat(srcpath, { bigint: true });
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureLink");
         throw err;
       }
       if (dstStat && areIdentical(srcStat, dstStat)) return;
-      const dir = path11.dirname(dstpath);
+      const dir = path10.dirname(dstpath);
       const dirExists = await pathExists(dir);
       if (!dirExists) {
         await mkdir.mkdirs(dir);
       }
-      await fs7.link(srcpath, dstpath);
+      await fs6.link(srcpath, dstpath);
     }
     function createLinkSync(srcpath, dstpath) {
       let dstStat;
       try {
-        dstStat = fs7.lstatSync(dstpath, { bigint: true });
+        dstStat = fs6.lstatSync(dstpath, { bigint: true });
       } catch {
       }
       try {
-        const srcStat = fs7.lstatSync(srcpath, { bigint: true });
+        const srcStat = fs6.lstatSync(srcpath, { bigint: true });
         if (dstStat && areIdentical(srcStat, dstStat)) return;
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureLink");
         throw err;
       }
-      const dir = path11.dirname(dstpath);
-      const dirExists = fs7.existsSync(dir);
-      if (dirExists) return fs7.linkSync(srcpath, dstpath);
+      const dir = path10.dirname(dstpath);
+      const dirExists = fs6.existsSync(dir);
+      if (dirExists) return fs6.linkSync(srcpath, dstpath);
       mkdir.mkdirsSync(dir);
-      return fs7.linkSync(srcpath, dstpath);
+      return fs6.linkSync(srcpath, dstpath);
     }
     module.exports = {
       createLink: u(createLink),
@@ -5680,14 +5680,14 @@ var require_link = __commonJS({
 var require_symlink_paths = __commonJS({
   "../../node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports, module) {
     "use strict";
-    var path11 = __require("path");
-    var fs7 = require_fs();
+    var path10 = __require("path");
+    var fs6 = require_fs();
     var { pathExists } = require_path_exists();
     var u = require_universalify().fromPromise;
     async function symlinkPaths(srcpath, dstpath) {
-      if (path11.isAbsolute(srcpath)) {
+      if (path10.isAbsolute(srcpath)) {
         try {
-          await fs7.lstat(srcpath);
+          await fs6.lstat(srcpath);
         } catch (err) {
           err.message = err.message.replace("lstat", "ensureSymlink");
           throw err;
@@ -5697,8 +5697,8 @@ var require_symlink_paths = __commonJS({
           toDst: srcpath
         };
       }
-      const dstdir = path11.dirname(dstpath);
-      const relativeToDst = path11.join(dstdir, srcpath);
+      const dstdir = path10.dirname(dstpath);
+      const relativeToDst = path10.join(dstdir, srcpath);
       const exists = await pathExists(relativeToDst);
       if (exists) {
         return {
@@ -5707,39 +5707,39 @@ var require_symlink_paths = __commonJS({
         };
       }
       try {
-        await fs7.lstat(srcpath);
+        await fs6.lstat(srcpath);
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureSymlink");
         throw err;
       }
       return {
         toCwd: srcpath,
-        toDst: path11.relative(dstdir, srcpath)
+        toDst: path10.relative(dstdir, srcpath)
       };
     }
     function symlinkPathsSync(srcpath, dstpath) {
-      if (path11.isAbsolute(srcpath)) {
-        const exists2 = fs7.existsSync(srcpath);
+      if (path10.isAbsolute(srcpath)) {
+        const exists2 = fs6.existsSync(srcpath);
         if (!exists2) throw new Error("absolute srcpath does not exist");
         return {
           toCwd: srcpath,
           toDst: srcpath
         };
       }
-      const dstdir = path11.dirname(dstpath);
-      const relativeToDst = path11.join(dstdir, srcpath);
-      const exists = fs7.existsSync(relativeToDst);
+      const dstdir = path10.dirname(dstpath);
+      const relativeToDst = path10.join(dstdir, srcpath);
+      const exists = fs6.existsSync(relativeToDst);
       if (exists) {
         return {
           toCwd: relativeToDst,
           toDst: srcpath
         };
       }
-      const srcExists = fs7.existsSync(srcpath);
+      const srcExists = fs6.existsSync(srcpath);
       if (!srcExists) throw new Error("relative srcpath does not exist");
       return {
         toCwd: srcpath,
-        toDst: path11.relative(dstdir, srcpath)
+        toDst: path10.relative(dstdir, srcpath)
       };
     }
     module.exports = {
@@ -5753,13 +5753,13 @@ var require_symlink_paths = __commonJS({
 var require_symlink_type = __commonJS({
   "../../node_modules/fs-extra/lib/ensure/symlink-type.js"(exports, module) {
     "use strict";
-    var fs7 = require_fs();
+    var fs6 = require_fs();
     var u = require_universalify().fromPromise;
     async function symlinkType(srcpath, type) {
       if (type) return type;
       let stats;
       try {
-        stats = await fs7.lstat(srcpath);
+        stats = await fs6.lstat(srcpath);
       } catch {
         return "file";
       }
@@ -5769,7 +5769,7 @@ var require_symlink_type = __commonJS({
       if (type) return type;
       let stats;
       try {
-        stats = fs7.lstatSync(srcpath);
+        stats = fs6.lstatSync(srcpath);
       } catch {
         return "file";
       }
@@ -5787,8 +5787,8 @@ var require_symlink = __commonJS({
   "../../node_modules/fs-extra/lib/ensure/symlink.js"(exports, module) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var path11 = __require("path");
-    var fs7 = require_fs();
+    var path10 = __require("path");
+    var fs6 = require_fs();
     var { mkdirs, mkdirsSync } = require_mkdirs();
     var { symlinkPaths, symlinkPathsSync } = require_symlink_paths();
     var { symlinkType, symlinkTypeSync } = require_symlink_type();
@@ -5797,25 +5797,25 @@ var require_symlink = __commonJS({
     async function createSymlink(srcpath, dstpath, type) {
       let stats;
       try {
-        stats = await fs7.lstat(dstpath);
+        stats = await fs6.lstat(dstpath);
       } catch {
       }
       if (stats && stats.isSymbolicLink()) {
         let srcStat;
-        if (path11.isAbsolute(srcpath)) {
-          srcStat = await fs7.stat(srcpath, { bigint: true });
+        if (path10.isAbsolute(srcpath)) {
+          srcStat = await fs6.stat(srcpath, { bigint: true });
         } else {
-          const dstdir = path11.dirname(dstpath);
-          const relativeToDst = path11.join(dstdir, srcpath);
+          const dstdir = path10.dirname(dstpath);
+          const relativeToDst = path10.join(dstdir, srcpath);
           try {
-            srcStat = await fs7.stat(relativeToDst, { bigint: true });
+            srcStat = await fs6.stat(relativeToDst, { bigint: true });
           } catch {
-            srcStat = await fs7.stat(srcpath, { bigint: true });
+            srcStat = await fs6.stat(srcpath, { bigint: true });
           }
         }
         let dstStat;
         try {
-          dstStat = await fs7.stat(dstpath, { bigint: true });
+          dstStat = await fs6.stat(dstpath, { bigint: true });
         } catch (err) {
           if (err.code !== "ENOENT") throw err;
         }
@@ -5824,34 +5824,34 @@ var require_symlink = __commonJS({
       const relative = await symlinkPaths(srcpath, dstpath);
       srcpath = relative.toDst;
       const toType = await symlinkType(relative.toCwd, type);
-      const dir = path11.dirname(dstpath);
+      const dir = path10.dirname(dstpath);
       if (!await pathExists(dir)) {
         await mkdirs(dir);
       }
-      return fs7.symlink(srcpath, dstpath, toType);
+      return fs6.symlink(srcpath, dstpath, toType);
     }
     function createSymlinkSync(srcpath, dstpath, type) {
       let stats;
       try {
-        stats = fs7.lstatSync(dstpath);
+        stats = fs6.lstatSync(dstpath);
       } catch {
       }
       if (stats && stats.isSymbolicLink()) {
         let srcStat;
-        if (path11.isAbsolute(srcpath)) {
-          srcStat = fs7.statSync(srcpath, { bigint: true });
+        if (path10.isAbsolute(srcpath)) {
+          srcStat = fs6.statSync(srcpath, { bigint: true });
         } else {
-          const dstdir = path11.dirname(dstpath);
-          const relativeToDst = path11.join(dstdir, srcpath);
+          const dstdir = path10.dirname(dstpath);
+          const relativeToDst = path10.join(dstdir, srcpath);
           try {
-            srcStat = fs7.statSync(relativeToDst, { bigint: true });
+            srcStat = fs6.statSync(relativeToDst, { bigint: true });
           } catch {
-            srcStat = fs7.statSync(srcpath, { bigint: true });
+            srcStat = fs6.statSync(srcpath, { bigint: true });
           }
         }
         let dstStat;
         try {
-          dstStat = fs7.statSync(dstpath, { bigint: true });
+          dstStat = fs6.statSync(dstpath, { bigint: true });
         } catch (err) {
           if (err.code !== "ENOENT") throw err;
         }
@@ -5860,11 +5860,11 @@ var require_symlink = __commonJS({
       const relative = symlinkPathsSync(srcpath, dstpath);
       srcpath = relative.toDst;
       type = symlinkTypeSync(relative.toCwd, type);
-      const dir = path11.dirname(dstpath);
-      const exists = fs7.existsSync(dir);
-      if (exists) return fs7.symlinkSync(srcpath, dstpath, type);
+      const dir = path10.dirname(dstpath);
+      const exists = fs6.existsSync(dir);
+      if (exists) return fs6.symlinkSync(srcpath, dstpath, type);
       mkdirsSync(dir);
-      return fs7.symlinkSync(srcpath, dstpath, type);
+      return fs6.symlinkSync(srcpath, dstpath, type);
     }
     module.exports = {
       createSymlink: u(createSymlink),
@@ -5933,9 +5933,9 @@ var require_jsonfile = __commonJS({
       if (typeof options === "string") {
         options = { encoding: options };
       }
-      const fs7 = options.fs || _fs;
+      const fs6 = options.fs || _fs;
       const shouldThrow = "throws" in options ? options.throws : true;
-      let data = await universalify.fromCallback(fs7.readFile)(file2, options);
+      let data = await universalify.fromCallback(fs6.readFile)(file2, options);
       data = stripBom(data);
       let obj;
       try {
@@ -5955,10 +5955,10 @@ var require_jsonfile = __commonJS({
       if (typeof options === "string") {
         options = { encoding: options };
       }
-      const fs7 = options.fs || _fs;
+      const fs6 = options.fs || _fs;
       const shouldThrow = "throws" in options ? options.throws : true;
       try {
-        let content = fs7.readFileSync(file2, options);
+        let content = fs6.readFileSync(file2, options);
         content = stripBom(content);
         return JSON.parse(content, options.reviver);
       } catch (err) {
@@ -5971,15 +5971,15 @@ var require_jsonfile = __commonJS({
       }
     }
     async function _writeFile(file2, obj, options = {}) {
-      const fs7 = options.fs || _fs;
+      const fs6 = options.fs || _fs;
       const str = stringify(obj, options);
-      await universalify.fromCallback(fs7.writeFile)(file2, str, options);
+      await universalify.fromCallback(fs6.writeFile)(file2, str, options);
     }
     var writeFile = universalify.fromPromise(_writeFile);
     function writeFileSync2(file2, obj, options = {}) {
-      const fs7 = options.fs || _fs;
+      const fs6 = options.fs || _fs;
       const str = stringify(obj, options);
-      return fs7.writeFileSync(file2, str, options);
+      return fs6.writeFileSync(file2, str, options);
     }
     module.exports = {
       readFile: readFile2,
@@ -6010,23 +6010,23 @@ var require_output_file = __commonJS({
   "../../node_modules/fs-extra/lib/output-file/index.js"(exports, module) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs7 = require_fs();
-    var path11 = __require("path");
+    var fs6 = require_fs();
+    var path10 = __require("path");
     var mkdir = require_mkdirs();
     var pathExists = require_path_exists().pathExists;
     async function outputFile(file2, data, encoding = "utf-8") {
-      const dir = path11.dirname(file2);
+      const dir = path10.dirname(file2);
       if (!await pathExists(dir)) {
         await mkdir.mkdirs(dir);
       }
-      return fs7.writeFile(file2, data, encoding);
+      return fs6.writeFile(file2, data, encoding);
     }
     function outputFileSync(file2, ...args) {
-      const dir = path11.dirname(file2);
-      if (!fs7.existsSync(dir)) {
+      const dir = path10.dirname(file2);
+      if (!fs6.existsSync(dir)) {
         mkdir.mkdirsSync(dir);
       }
-      fs7.writeFileSync(file2, ...args);
+      fs6.writeFileSync(file2, ...args);
     }
     module.exports = {
       outputFile: u(outputFile),
@@ -6085,8 +6085,8 @@ var require_json = __commonJS({
 var require_move = __commonJS({
   "../../node_modules/fs-extra/lib/move/move.js"(exports, module) {
     "use strict";
-    var fs7 = require_fs();
-    var path11 = __require("path");
+    var fs6 = require_fs();
+    var path10 = __require("path");
     var { copy } = require_copy2();
     var { remove } = require_remove();
     var { mkdirp } = require_mkdirs();
@@ -6096,8 +6096,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 = path11.dirname(dest);
-      const parsedParentPath = path11.parse(destParent);
+      const destParent = path10.dirname(dest);
+      const parsedParentPath = path10.parse(destParent);
       if (parsedParentPath.root !== destParent) {
         await mkdirp(destParent);
       }
@@ -6112,7 +6112,7 @@ var require_move = __commonJS({
         }
       }
       try {
-        await fs7.rename(src, dest);
+        await fs6.rename(src, dest);
       } catch (err) {
         if (err.code !== "EXDEV") {
           throw err;
@@ -6137,8 +6137,8 @@ var require_move = __commonJS({
 var require_move_sync = __commonJS({
   "../../node_modules/fs-extra/lib/move/move-sync.js"(exports, module) {
     "use strict";
-    var fs7 = require_graceful_fs();
-    var path11 = __require("path");
+    var fs6 = require_graceful_fs();
+    var path10 = __require("path");
     var copySync = require_copy2().copySync;
     var removeSync = require_remove().removeSync;
     var mkdirpSync = require_mkdirs().mkdirpSync;
@@ -6148,12 +6148,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(path11.dirname(dest));
+      if (!isParentRoot(dest)) mkdirpSync(path10.dirname(dest));
       return doRename(src, dest, overwrite, isChangingCase);
     }
     function isParentRoot(dest) {
-      const parent = path11.dirname(dest);
-      const parsedPath = path11.parse(parent);
+      const parent = path10.dirname(dest);
+      const parsedPath = path10.parse(parent);
       return parsedPath.root === parent;
     }
     function doRename(src, dest, overwrite, isChangingCase) {
@@ -6162,12 +6162,12 @@ var require_move_sync = __commonJS({
         removeSync(dest);
         return rename(src, dest, overwrite);
       }
-      if (fs7.existsSync(dest)) throw new Error("dest already exists.");
+      if (fs6.existsSync(dest)) throw new Error("dest already exists.");
       return rename(src, dest, overwrite);
     }
     function rename(src, dest, overwrite) {
       try {
-        fs7.renameSync(src, dest);
+        fs6.renameSync(src, dest);
       } catch (err) {
         if (err.code !== "EXDEV") throw err;
         return moveAcrossDevice(src, dest, overwrite);
@@ -7499,7 +7499,7 @@ var CLI_VERSION;
 var init_version = __esm({
   "src/utils/version.ts"() {
     "use strict";
-    CLI_VERSION = "5.21.0";
+    CLI_VERSION = "5.22.0";
   }
 });
 
@@ -14962,10 +14962,10 @@ var require_lib3 = __commonJS({
     exports.analyse = analyse;
     var detectFile = (filepath, opts = {}) => new Promise((resolve, reject) => {
       let fd;
-      const fs7 = (0, node_1.default)();
+      const fs6 = (0, node_1.default)();
       const handler = (err, buffer) => {
         if (fd) {
-          fs7.closeSync(fd);
+          fs6.closeSync(fd);
         }
         if (err) {
           reject(err);
@@ -14977,9 +14977,9 @@ var require_lib3 = __commonJS({
       };
       const sampleSize = (opts === null || opts === void 0 ? void 0 : opts.sampleSize) || 0;
       if (sampleSize > 0) {
-        fd = fs7.openSync(filepath, "r");
+        fd = fs6.openSync(filepath, "r");
         let sample = Buffer.allocUnsafe(sampleSize);
-        fs7.read(fd, sample, 0, sampleSize, opts.offset, (err, bytesRead) => {
+        fs6.read(fd, sample, 0, sampleSize, opts.offset, (err, bytesRead) => {
           if (err) {
             handler(err, null);
           } else {
@@ -14991,22 +14991,22 @@ var require_lib3 = __commonJS({
         });
         return;
       }
-      fs7.readFile(filepath, handler);
+      fs6.readFile(filepath, handler);
     });
     exports.detectFile = detectFile;
     var detectFileSync = (filepath, opts = {}) => {
-      const fs7 = (0, node_1.default)();
+      const fs6 = (0, node_1.default)();
       if (opts && opts.sampleSize) {
-        const fd = fs7.openSync(filepath, "r");
+        const fd = fs6.openSync(filepath, "r");
         let sample = Buffer.allocUnsafe(opts.sampleSize);
-        const bytesRead = fs7.readSync(fd, sample, 0, opts.sampleSize, opts.offset);
+        const bytesRead = fs6.readSync(fd, sample, 0, opts.sampleSize, opts.offset);
         if (bytesRead < opts.sampleSize) {
           sample = sample.subarray(0, bytesRead);
         }
-        fs7.closeSync(fd);
+        fs6.closeSync(fd);
         return (0, exports.detect)(sample);
       }
-      return (0, exports.detect)(fs7.readFileSync(filepath));
+      return (0, exports.detect)(fs6.readFileSync(filepath));
     };
     exports.detectFileSync = detectFileSync;
     exports.default = {
@@ -22826,8 +22826,8 @@ var require_utils4 = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path11) {
-      let input = path11;
+    function removeDotSegments(path10) {
+      let input = path10;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -23079,8 +23079,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path11, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path11 && path11 !== "/" ? path11 : void 0;
+        const [path10, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path10 && path10 !== "/" ? path10 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -26473,12 +26473,12 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs7, exportName) {
+    function addFormats(ajv, list, fs6, exportName) {
       var _a3;
       var _b;
       (_a3 = (_b = ajv.opts.code).formats) !== null && _a3 !== void 0 ? _a3 : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f of list)
-        ajv.addFormat(f, fs7[f]);
+        ajv.addFormat(f, fs6[f]);
     }
     module.exports = exports = formatsPlugin;
     Object.defineProperty(exports, "__esModule", { value: true });
@@ -26515,7 +26515,7 @@ var MIGRATION_DOC = `# Migrate this repo to Melt's current model
 
 You are reading this because \`meltctl project templates\` was run (most likely by the legacy
 \`/melt-update\` skill). The per-repo Melt skill model has been **retired company-wide** and
-replaced by org-distributed \`/melt-dev-*\` skills. **This migration is mandatory \u2014 it is not a
+replaced by the \`melt-dev\` Claude plugin (\`/melt-dev:*\` skills). **This migration is mandatory \u2014 it is not a
 content refresh.** Perform the steps below now. Do NOT do a file-by-file template sync, and do
 NOT offer to skip, abort, or keep the old files.
 
@@ -26534,12 +26534,12 @@ not just Melt boilerplate. **Never delete or "slim" their content** \u2014 not t
 standards, not their own rules. ADD what's missing:
 - A \`## Stack\` block (languages, frameworks, test runner, package manager, database, deploy)
 - A \`## Project docs\` index pointing at satellite docs (TECH_DEBT.md, ARCHITECTURE.md, \u2026)
-- One line noting Melt's universal standards also ship with the \`/melt-dev-*\` skills now
+- One line noting Melt's universal standards also ship with the \`/melt-dev:*\` skills now
 
 **One exception \u2014 replace the retired Melt skill-list.** If AGENTS.md has a \`## Workflow
 Skills\` section that is the standard Melt list (a boilerplate intro plus \`/melt-*\` bullets),
-remove that section as part of this migration: the skills are org-distributed and
-auto-discovered now, so it is obsolete and points at skills you just deleted. Preserve any
+remove that section as part of this migration: the skills ship as an org plugin and
+are auto-discovered now, so it is obsolete and points at skills you just deleted. Preserve any
 custom entries the developer added inside it. This is the ONLY Melt-authored section the
 migration removes \u2014 everything else stays untouched.
 
@@ -26568,8 +26568,9 @@ unilaterally deleting their content.
 
 ## After migrating
 
-The \`/melt-dev-*\` skills are distributed via the Anthropic org Skills registry and auto-update
-in Claude Code. If they are not available in your session, that is an org-enrollment issue \u2014
+The \`/melt-dev:*\` skills ship as the \`melt-dev\` plugin from the Melt Studio org marketplace
+and auto-update. If they are not available in your session, sign in to Claude Code with your Melt
+claude.ai account (\`/status\` shows it) and run \`/reload-plugins\`; if they still don't appear,
 raise it in #dev. It is not a reason to stay on the old model.
 `;
 async function templatesCommand() {
@@ -26581,7 +26582,7 @@ async function templatesCommand() {
     source_default.bold.yellow("\u26A0  The per-repo Melt skill model has been retired (company-wide)."),
     "This command now hands back MIGRATION INSTRUCTIONS, not a template refresh.",
     `\u2192 Follow ${source_default.cyan("MIGRATION.md")} in the directory printed below to migrate this repo now.`,
-    `  (In Claude Code with the org skills, ${source_default.cyan("/melt-dev:setup")} does the same migration.)`,
+    `  (In Claude Code with the melt-dev plugin, ${source_default.cyan("/melt-dev:setup")} does the same migration.)`,
     ""
   ].join("\n");
   console.error(notice);
@@ -26621,8 +26622,8 @@ function createAuditsResource(config2) {
       if (filters?.projectId)
         params.set("projectId", String(filters.projectId));
       const query = params.toString();
-      const path11 = `/audits${query ? `?${query}` : ""}`;
-      const { data, status } = await apiFetch(config2, path11);
+      const path10 = `/audits${query ? `?${query}` : ""}`;
+      const { data, status } = await apiFetch(config2, path10);
       if (status === 403)
         throw new Error("Access denied. Only Team Managers can list audits.");
       if (status !== 200)
@@ -26671,8 +26672,8 @@ function createPlansResource(config2) {
       if (filters?.projectId)
         params.set("projectId", String(filters.projectId));
       const query = params.toString();
-      const path11 = `/plans${query ? `?${query}` : ""}`;
-      const { data, status } = await apiFetch(config2, path11);
+      const path10 = `/plans${query ? `?${query}` : ""}`;
+      const { data, status } = await apiFetch(config2, path10);
       if (status === 403)
         throw new Error(`Access denied. ${data.error ?? ""}`.trim());
       if (status !== 200)
@@ -26714,8 +26715,8 @@ function createPlansResource(config2) {
       if (filters?.author)
         params.set("author", filters.author);
       const query = params.toString();
-      const path11 = `/plans/stats${query ? `?${query}` : ""}`;
-      const { data, status } = await apiFetch(config2, path11);
+      const path10 = `/plans/stats${query ? `?${query}` : ""}`;
+      const { data, status } = await apiFetch(config2, path10);
       if (status === 403)
         throw new Error("Access denied. Only Team Managers can view plan stats.");
       if (status !== 200)
@@ -26754,8 +26755,8 @@ function createEventsResource(config2) {
       if (filters?.projectId)
         params.set("projectId", String(filters.projectId));
       const query = params.toString();
-      const path11 = `/events${query ? `?${query}` : ""}`;
-      const { data, status } = await apiFetch(config2, path11);
+      const path10 = `/events${query ? `?${query}` : ""}`;
+      const { data, status } = await apiFetch(config2, path10);
       if (status === 403)
         throw new Error("Access denied. Only Team Managers can view analytics.");
       if (status !== 200)
@@ -26771,8 +26772,8 @@ function createEventsResource(config2) {
       if (filters?.projectId)
         params.set("projectId", String(filters.projectId));
       const query = params.toString();
-      const path11 = `/events/stats${query ? `?${query}` : ""}`;
-      const { data, status } = await apiFetch(config2, path11);
+      const path10 = `/events/stats${query ? `?${query}` : ""}`;
+      const { data, status } = await apiFetch(config2, path10);
       if (status === 403)
         throw new Error("Access denied. Only Team Managers can view analytics.");
       if (status !== 200)
@@ -26806,8 +26807,8 @@ function createStandupsResource(config2) {
       const params = new URLSearchParams();
       if (filters?.projectId)
         params.set("projectId", String(filters.projectId));
-      const path11 = `/standups/stats${params.toString() ? `?${params}` : ""}`;
-      const { data, status } = await apiFetch(config2, path11);
+      const path10 = `/standups/stats${params.toString() ? `?${params}` : ""}`;
+      const { data, status } = await apiFetch(config2, path10);
       if (status === 403)
         throw new Error("Access denied. Only Team Managers can view standup stats.");
       if (status !== 200)
@@ -26832,8 +26833,8 @@ function createStandupsResource(config2) {
       const params = new URLSearchParams();
       if (opts?.windowDays)
         params.set("windowDays", String(opts.windowDays));
-      const path11 = `/standups/per-person-stats${params.toString() ? `?${params}` : ""}`;
-      const { data, status } = await apiFetch(config2, path11);
+      const path10 = `/standups/per-person-stats${params.toString() ? `?${params}` : ""}`;
+      const { data, status } = await apiFetch(config2, path10);
       if (status === 403)
         throw new Error("Access denied. Only Team Managers can view standup stats.");
       if (status !== 200)
@@ -26891,8 +26892,8 @@ function createFeedbackResource(config2) {
       if (filters.limit !== void 0)
         params.set("limit", String(filters.limit));
       const qs = params.toString();
-      const path11 = qs ? `/feedback/dashboard?${qs}` : "/feedback/dashboard";
-      const { data, status } = await apiFetch(config2, path11);
+      const path10 = qs ? `/feedback/dashboard?${qs}` : "/feedback/dashboard";
+      const { data, status } = await apiFetch(config2, path10);
       if (status !== 200) {
         const err = data.error;
         throw new Error(err ?? `Failed to load dashboard feedback (${status})`);
@@ -26932,22 +26933,6 @@ function createTemplatesResource(config2) {
   };
 }
 
-// ../sdk/dist/resources/skills.js
-function createSkillsResource(config2) {
-  return {
-    async getDevSkills() {
-      const { data, status } = await apiFetch(config2, "/skills/dev", {
-        method: "GET"
-      });
-      if (status !== 200) {
-        const error51 = data.error;
-        throw new Error(error51 ?? `Failed to fetch dev skills (${status})`);
-      }
-      return data;
-    }
-  };
-}
-
 // ../sdk/dist/resources/auth.js
 function createAuthResource(config2) {
   return {
@@ -27004,8 +26989,8 @@ function createProjectsResource(config2) {
         params.set("activeOnly", "true");
       if (opts?.includeInternal)
         params.set("includeInternal", "true");
-      const path11 = `/projects${params.toString() ? `?${params}` : ""}`;
-      const { data, status } = await apiFetch(config2, path11);
+      const path10 = `/projects${params.toString() ? `?${params}` : ""}`;
+      const { data, status } = await apiFetch(config2, path10);
       if (status === 403)
         throw new Error("Access denied. Only Team Managers can view projects.");
       if (status !== 200)
@@ -27075,8 +27060,8 @@ function createFindingsResource(config2) {
       if (filters?.limit)
         params.set("limit", String(filters.limit));
       const query = params.toString();
-      const path11 = `/findings${query ? `?${query}` : ""}`;
-      const { data, status } = await apiFetch(config2, path11);
+      const path10 = `/findings${query ? `?${query}` : ""}`;
+      const { data, status } = await apiFetch(config2, path10);
       if (status === 403)
         throw new Error("Access denied. Only Team Managers can list findings.");
       if (status !== 200)
@@ -27098,8 +27083,8 @@ function createFindingsResource(config2) {
       if (filters?.auditId)
         params.set("auditId", filters.auditId);
       const query = params.toString();
-      const path11 = `/findings/stats${query ? `?${query}` : ""}`;
-      const { data, status } = await apiFetch(config2, path11);
+      const path10 = `/findings/stats${query ? `?${query}` : ""}`;
+      const { data, status } = await apiFetch(config2, path10);
       if (status === 403)
         throw new Error("Access denied. Only Team Managers can view findings stats.");
       if (status !== 200)
@@ -27262,8 +27247,8 @@ function createBoardAuditsResource(config2) {
         params.set("projectId", String(filters.projectId));
       if (filters?.limit)
         params.set("limit", String(filters.limit));
-      const path11 = `/board-audits${params.toString() ? `?${params}` : ""}`;
-      const { data, status } = await apiFetch(config2, path11);
+      const path10 = `/board-audits${params.toString() ? `?${params}` : ""}`;
+      const { data, status } = await apiFetch(config2, path10);
       if (status === 403)
         throw new Error("Access denied. Only Team Managers can view board audits.");
       if (status !== 200)
@@ -27790,8 +27775,8 @@ function createSlackResource(config2) {
       if (opts?.limit !== void 0)
         params.set("limit", String(opts.limit));
       const qs = params.toString();
-      const path11 = `/slack/notifications${qs ? `?${qs}` : ""}`;
-      const { data, status } = await apiFetch(config2, path11);
+      const path10 = `/slack/notifications${qs ? `?${qs}` : ""}`;
+      const { data, status } = await apiFetch(config2, path10);
       if (status === 403)
         throw new Error("Access denied. Only Team Managers can view this.");
       if (status !== 200)
@@ -27837,8 +27822,8 @@ function createJobsResource(config2) {
       if (filters?.limit)
         params.set("limit", String(filters.limit));
       const query = params.toString();
-      const path11 = `/jobs${query ? `?${query}` : ""}`;
-      const { data, status } = await apiFetch(config2, path11);
+      const path10 = `/jobs${query ? `?${query}` : ""}`;
+      const { data, status } = await apiFetch(config2, path10);
       if (status === 403)
         throw new Error("Access denied. Only Team Managers can list jobs.");
       if (status !== 200)
@@ -27988,8 +27973,8 @@ function createProfileAuditsResource(config2) {
       if (filters?.limit)
         params.set("limit", String(filters.limit));
       const query = params.toString();
-      const path11 = `/profile-audits${query ? `?${query}` : ""}`;
-      const { data, status } = await apiFetch(config2, path11);
+      const path10 = `/profile-audits${query ? `?${query}` : ""}`;
+      const { data, status } = await apiFetch(config2, path10);
       if (status === 403)
         throw new Error("Access denied. Only Team Managers can list profile audits.");
       if (status !== 200)
@@ -28046,8 +28031,8 @@ function createSupportEffortResource(config2) {
       if (opts.period)
         params.set("period", opts.period);
       const query = params.toString();
-      const path11 = query ? `/support-effort?${query}` : "/support-effort";
-      const { data, status } = await apiFetch(config2, path11);
+      const path10 = query ? `/support-effort?${query}` : "/support-effort";
+      const { data, status } = await apiFetch(config2, path10);
       if (status === 403)
         throw new Error("Access denied. Only Team Managers can view support effort.");
       if (status !== 200) {
@@ -28072,7 +28057,7 @@ function buildSignal(timeoutMs, caller) {
   const anyFn = AbortSignal.any;
   return anyFn ? anyFn([caller, timeout]) : timeout;
 }
-async function apiFetch(config2, path11, options = {}) {
+async function apiFetch(config2, path10, options = {}) {
   const method = (options.method ?? "GET").toUpperCase();
   const idempotent = method === "GET" || method === "HEAD";
   const timeoutMs = config2.timeoutMs ?? DEFAULT_TIMEOUT_MS;
@@ -28080,7 +28065,7 @@ async function apiFetch(config2, path11, options = {}) {
   let lastError;
   for (let attempt = 1; attempt <= maxAttempts; attempt++) {
     try {
-      const response = await fetch(`${config2.baseUrl}${path11}`, {
+      const response = await fetch(`${config2.baseUrl}${path10}`, {
         ...options,
         signal: buildSignal(timeoutMs, options.signal),
         headers: {
@@ -28116,7 +28101,6 @@ function createMeltClient(config2) {
     feedback: createFeedbackResource(config2),
     coins: createCoinsResource(config2),
     templates: createTemplatesResource(config2),
-    skills: createSkillsResource(config2),
     auth: createAuthResource(config2),
     people: createPeopleResource(config2),
     projects: createProjectsResource(config2),
@@ -28901,10 +28885,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path11) {
-  if (!path11)
+function getElementAtPath(obj, path10) {
+  if (!path10)
     return obj;
-  return path11.reduce((acc, key) => acc?.[key], obj);
+  return path10.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -29313,11 +29297,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path11, issues) {
+function prefixIssues(path10, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path11);
+    iss.path.unshift(path10);
     return iss;
   });
 }
@@ -29464,16 +29448,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path11 = []) => {
+  const processError = (error52, path10 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path11, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path10, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path11, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path10, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path11, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path10, ...issue2.path]);
       } else {
-        const fullpath = [...path11, ...issue2.path];
+        const fullpath = [...path10, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -29500,17 +29484,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path11 = []) => {
+  const processError = (error52, path10 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path11, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path10, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path11, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path10, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path11, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path10, ...issue2.path]);
       } else {
-        const fullpath = [...path11, ...issue2.path];
+        const fullpath = [...path10, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -29542,8 +29526,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path11 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path11) {
+  const path10 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path10) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -42235,13 +42219,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path11 = ref.slice(1).split("/").filter(Boolean);
-  if (path11.length === 0) {
+  const path10 = ref.slice(1).split("/").filter(Boolean);
+  if (path10.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path11[0] === defsKey) {
-    const key = path11[1];
+  if (path10[0] === defsKey) {
+    const key = path10[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -43413,292 +43397,6 @@ async function logoutCommand() {
 // src/index.ts
 init_version_check();
 
-// src/utils/skills-sync.ts
-init_source();
-
-// src/utils/debug.ts
-init_source();
-function debugLog(message) {
-  if (process.env["MELTCTL_DEBUG"]) {
-    console.error(source_default.dim(`[debug] ${message}`));
-  }
-}
-
-// src/commands/skills.ts
-init_source();
-var import_fs_extra3 = __toESM(require_lib(), 1);
-import { createHash } from "crypto";
-import os5 from "os";
-import path6 from "path";
-
-// src/utils/api.ts
-init_source();
-async function getToken() {
-  const envToken = process.env["MELTCTL_TOKEN"];
-  if (envToken) {
-    return envToken;
-  }
-  const auth = await getStoredAuth();
-  if (!auth) {
-    console.error(
-      source_default.red(
-        "Not authenticated. Run `npx @meltstudio/meltctl@latest login` or set MELTCTL_TOKEN for CI."
-      )
-    );
-    process.exit(1);
-  }
-  if (new Date(auth.expiresAt) <= /* @__PURE__ */ new Date()) {
-    console.error(
-      source_default.red(
-        "Session expired. Run `npx @meltstudio/meltctl@latest login` to re-authenticate, or set MELTCTL_TOKEN for CI."
-      )
-    );
-    process.exit(1);
-  }
-  return auth.token;
-}
-async function getClient() {
-  const token = await getToken();
-  return createMeltClient({ baseUrl: API_BASE, token });
-}
-
-// src/commands/skills.ts
-var MARKER_FILE = ".melt-skills.json";
-function getSkillsRoot() {
-  const configDir = process.env["CLAUDE_CONFIG_DIR"];
-  if (configDir) {
-    return path6.join(configDir, "skills");
-  }
-  return path6.join(os5.homedir(), ".claude", "skills");
-}
-function getSkillsRoots() {
-  const roots = [getSkillsRoot()];
-  if (import_fs_extra3.default.existsSync(path6.join(os5.homedir(), ".cursor"))) {
-    roots.push(path6.join(os5.homedir(), ".cursor", "skills"));
-  }
-  return roots;
-}
-function computeSkillHash(files) {
-  const hash2 = createHash("sha256");
-  for (const filePath of Object.keys(files).sort()) {
-    hash2.update(filePath);
-    hash2.update(files[filePath] ?? "");
-  }
-  return hash2.digest("hex").slice(0, 12);
-}
-function readMarker(skillsRoot) {
-  const markerPath = path6.join(skillsRoot, MARKER_FILE);
-  if (!import_fs_extra3.default.existsSync(markerPath)) return null;
-  try {
-    const raw = import_fs_extra3.default.readJsonSync(markerPath);
-    const skills2 = Array.isArray(raw.skills) ? raw.skills.map((entry) => {
-      if (typeof entry === "string") {
-        return { name: entry, hash: "" };
-      }
-      if (entry && typeof entry === "object") {
-        const e = entry;
-        return {
-          name: typeof e.name === "string" ? e.name : "",
-          hash: typeof e.hash === "string" ? e.hash : ""
-        };
-      }
-      return { name: "", hash: "" };
-    }) : [];
-    return {
-      version: typeof raw.version === "string" ? raw.version : "",
-      installedAt: typeof raw.installedAt === "string" ? raw.installedAt : "",
-      lastCheckedAt: typeof raw.lastCheckedAt === "string" ? raw.lastCheckedAt : void 0,
-      skills: skills2
-    };
-  } catch {
-    return null;
-  }
-}
-function computeDiff(previous, next) {
-  const prevByName = new Map(previous.map((s) => [s.name, s]));
-  const nextNames = new Set(next.map((s) => s.name));
-  const added = [];
-  const changed = [];
-  for (const skill of next) {
-    const prev = prevByName.get(skill.name);
-    if (!prev) {
-      added.push(skill.name);
-      continue;
-    }
-    if (prev.hash && prev.hash !== skill.hash) {
-      changed.push(skill.name);
-    }
-  }
-  const removed = previous.filter((s) => s.name && !nextNames.has(s.name)).map((s) => s.name);
-  return { added, changed, removed };
-}
-function applyDevSkills(manifest, skillsRoot) {
-  const previous = readMarker(skillsRoot)?.skills ?? [];
-  const nextEntries = manifest.skills.map((s) => ({
-    name: s.name,
-    hash: computeSkillHash(s.files)
-  }));
-  const diff = computeDiff(previous, nextEntries);
-  for (const name of diff.removed) {
-    import_fs_extra3.default.removeSync(path6.join(skillsRoot, name));
-  }
-  for (const skill of manifest.skills) {
-    const dir = path6.join(skillsRoot, skill.name);
-    import_fs_extra3.default.removeSync(dir);
-    for (const [relPath, content] of Object.entries(skill.files)) {
-      import_fs_extra3.default.outputFileSync(path6.join(dir, relPath), content);
-    }
-  }
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const marker = {
-    version: manifest.version,
-    installedAt: now,
-    lastCheckedAt: now,
-    skills: nextEntries
-  };
-  import_fs_extra3.default.outputFileSync(path6.join(skillsRoot, MARKER_FILE), `${JSON.stringify(marker, null, 2)}
-`);
-  return diff;
-}
-function touchMarkerLastChecked(skillsRoot) {
-  const marker = readMarker(skillsRoot);
-  if (!marker) return;
-  marker.lastCheckedAt = (/* @__PURE__ */ new Date()).toISOString();
-  import_fs_extra3.default.outputFileSync(path6.join(skillsRoot, MARKER_FILE), `${JSON.stringify(marker, null, 2)}
-`);
-}
-async function skillsInstallCommand(opts) {
-  const client = await getClient();
-  let manifest;
-  try {
-    manifest = await client.skills.getDevSkills();
-  } catch (error51) {
-    console.error(
-      source_default.red(
-        `Failed to fetch Melt dev skills: ${error51 instanceof Error ? error51.message : "Unknown error"}`
-      )
-    );
-    process.exit(1);
-  }
-  const roots = opts.path ? [path6.resolve(opts.path)] : getSkillsRoots();
-  if (manifest.skills.length === 0) {
-    const installed = roots.filter((root) => readMarker(root) !== null);
-    for (const root of installed) {
-      applyDevSkills(manifest, root);
-    }
-    const where2 = installed.map((root) => `${root.replace(os5.homedir(), "~")}/`).join(" and ");
-    console.log(
-      source_default.green(
-        "\n  Melt skills now come as Claude plugins (melt-dev, melt-company), installed for everyone in the Melt Studio org."
-      )
-    );
-    if (installed.length > 0) {
-      console.log(source_default.dim(`  Removed the old copies from ${where2}.`));
-    }
-    console.log(
-      source_default.dim(
-        "  Sign in to Claude Code with your Melt claude.ai account, then run /reload-plugins. Skills appear as /melt-dev:plan, /melt-dev:review, \u2026\n"
-      )
-    );
-    return;
-  }
-  const stale = opts.force ? roots : roots.filter((root) => readMarker(root)?.version !== manifest.version);
-  if (stale.length === 0) {
-    console.log(
-      source_default.dim(
-        `
-  Melt dev skills already up to date (v${manifest.version}). Use --force to reinstall.
-`
-      )
-    );
-    return;
-  }
-  for (const root of stale) {
-    applyDevSkills(manifest, root);
-  }
-  const where = stale.map((root) => `${root.replace(os5.homedir(), "~")}/`).join(" and ");
-  console.log(
-    source_default.green(
-      `
-  \u2713 Installed ${manifest.skills.length} Melt dev skills (v${manifest.version}) to ${where}.`
-    )
-  );
-  console.log(
-    source_default.dim(
-      "  Restart Claude Code / Cursor to load them (they appear as /melt-dev:plan, /melt-dev:review, \u2026).\n"
-    )
-  );
-}
-
-// src/utils/skills-sync.ts
-var TWENTY_FOUR_HOURS_MS = 24 * 60 * 60 * 1e3;
-var SKIP_SYNC_COMMANDS = /* @__PURE__ */ new Set(["skills", "login", "logout", "update", "version"]);
-function formatSyncNotice(oldVersion, newVersion, diff) {
-  const groups = [];
-  if (diff.changed.length > 0) groups.push(`changed ${diff.changed.join(", ")}`);
-  if (diff.added.length > 0) groups.push(`added ${diff.added.join(", ")}`);
-  if (diff.removed.length > 0) groups.push(`removed ${diff.removed.join(", ")}`);
-  const suffix = groups.length > 0 ? `: ${groups.join("; ")}` : "";
-  return `\u2191 Melt dev skills updated (v${oldVersion} \u2192 v${newVersion})${suffix}`;
-}
-function isCheckDue(lastCheckedAt, now) {
-  if (!lastCheckedAt) return true;
-  const last = Date.parse(lastCheckedAt);
-  if (Number.isNaN(last)) return true;
-  return now - last >= TWENTY_FOUR_HOURS_MS;
-}
-async function maybeSyncSkills(commandName) {
-  try {
-    if (process.env["MELTCTL_SKIP_SKILLS_SYNC"]) {
-      debugLog("Skills sync disabled via MELTCTL_SKIP_SKILLS_SYNC");
-      return;
-    }
-    if (commandName && SKIP_SYNC_COMMANDS.has(commandName)) {
-      debugLog(`Skills sync skipped for command "${commandName}"`);
-      return;
-    }
-    const auth = await getStoredAuth();
-    if (!auth || new Date(auth.expiresAt) <= /* @__PURE__ */ new Date()) {
-      debugLog("Skills sync skipped: not authenticated or token expired");
-      return;
-    }
-    const skillsRoot = getSkillsRoot();
-    const marker = readMarker(skillsRoot);
-    if (!marker) {
-      debugLog("Skills sync skipped: no skills marker (not installed)");
-      return;
-    }
-    if (!isCheckDue(marker.lastCheckedAt, Date.now())) {
-      debugLog("Skills sync skipped: checked within the last 24h");
-      return;
-    }
-    const client = createMeltClient({ baseUrl: API_BASE, token: auth.token });
-    let manifest;
-    try {
-      manifest = await client.skills.getDevSkills();
-    } catch (e) {
-      touchMarkerLastChecked(skillsRoot);
-      debugLog(`Skills sync fetch error: ${e instanceof Error ? e.message : e}`);
-      return;
-    }
-    if (manifest.version === marker.version) {
-      touchMarkerLastChecked(skillsRoot);
-      debugLog("Skills sync: already up to date");
-      return;
-    }
-    const oldVersion = marker.version;
-    let diff = { added: [], changed: [], removed: [] };
-    for (const root of getSkillsRoots()) {
-      const rootDiff = applyDevSkills(manifest, root);
-      if (root === skillsRoot) diff = rootDiff;
-    }
-    console.log(source_default.dim(source_default.green(formatSyncNotice(oldVersion, manifest.version, diff))));
-    debugLog(`Skills sync: updated ${oldVersion} \u2192 ${manifest.version}`);
-  } catch (e) {
-    debugLog(`Skills sync error: ${e instanceof Error ? e.message : e}`);
-  }
-}
-
 // src/commands/version.ts
 init_source();
 init_version_check();
@@ -43795,6 +43493,39 @@ async function versionCheckCommand() {
 // src/commands/standup.ts
 init_source();
 init_dist11();
+
+// src/utils/api.ts
+init_source();
+async function getToken() {
+  const envToken = process.env["MELTCTL_TOKEN"];
+  if (envToken) {
+    return envToken;
+  }
+  const auth = await getStoredAuth();
+  if (!auth) {
+    console.error(
+      source_default.red(
+        "Not authenticated. Run `npx @meltstudio/meltctl@latest login` or set MELTCTL_TOKEN for CI."
+      )
+    );
+    process.exit(1);
+  }
+  if (new Date(auth.expiresAt) <= /* @__PURE__ */ new Date()) {
+    console.error(
+      source_default.red(
+        "Session expired. Run `npx @meltstudio/meltctl@latest login` to re-authenticate, or set MELTCTL_TOKEN for CI."
+      )
+    );
+    process.exit(1);
+  }
+  return auth.token;
+}
+async function getClient() {
+  const token = await getToken();
+  return createMeltClient({ baseUrl: API_BASE, token });
+}
+
+// src/commands/standup.ts
 var EDITOR_HINT = source_default.dim("(type \\e to open your editor)");
 async function promptField(message, required2) {
   const value = await dist_default7({ message: `${message} ${EDITOR_HINT}` });
@@ -44016,12 +43747,12 @@ async function showLeaderboard() {
 
 // src/commands/audit.ts
 init_source();
-var import_fs_extra5 = __toESM(require_lib(), 1);
-import path8 from "path";
-
-// src/utils/git.ts
 var import_fs_extra4 = __toESM(require_lib(), 1);
 import path7 from "path";
+
+// src/utils/git.ts
+var import_fs_extra3 = __toESM(require_lib(), 1);
+import path6 from "path";
 import { execSync as execSync4 } from "child_process";
 function getGitBranch() {
   try {
@@ -44059,34 +43790,34 @@ function getGitRepository() {
 function getProjectName() {
   const cwd = process.cwd();
   try {
-    const pkgPath = path7.join(cwd, "package.json");
-    if (import_fs_extra4.default.pathExistsSync(pkgPath)) {
-      const pkg = import_fs_extra4.default.readJsonSync(pkgPath);
+    const pkgPath = path6.join(cwd, "package.json");
+    if (import_fs_extra3.default.pathExistsSync(pkgPath)) {
+      const pkg = import_fs_extra3.default.readJsonSync(pkgPath);
       if (pkg.name) {
         return pkg.name;
       }
     }
   } catch {
   }
-  return path7.basename(cwd);
+  return path6.basename(cwd);
 }
 function extractTicketId(branch) {
   const match = branch.match(/([A-Z]+-\d+)/i);
   return match ? match[1] : null;
 }
 async function findMdFiles(dir) {
-  if (!await import_fs_extra4.default.pathExists(dir)) {
+  if (!await import_fs_extra3.default.pathExists(dir)) {
     return [];
   }
   const results = [];
   async function walk(current) {
-    const entries = await import_fs_extra4.default.readdir(current, { withFileTypes: true });
+    const entries = await import_fs_extra3.default.readdir(current, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path7.join(current, entry.name);
+      const fullPath = path6.join(current, entry.name);
       if (entry.isDirectory()) {
         await walk(fullPath);
       } else if (entry.isFile() && entry.name.endsWith(".md")) {
-        const stat = await import_fs_extra4.default.stat(fullPath);
+        const stat = await import_fs_extra3.default.stat(fullPath);
         results.push({ path: fullPath, mtime: stat.mtimeMs });
       }
     }
@@ -44106,15 +43837,15 @@ function detectAuditType(filename) {
 }
 async function autoDetectAuditFile() {
   const cwd = process.cwd();
-  const auditsDir = path8.join(cwd, ".audits");
+  const auditsDir = path7.join(cwd, ".audits");
   const auditFiles = await findMdFiles(auditsDir);
   if (auditFiles.length > 0) {
     return auditFiles[0] ?? null;
   }
   const candidates = ["AUDIT.md", "UX-AUDIT.md", "SECURITY-AUDIT.md"];
   for (const name of candidates) {
-    const filePath = path8.join(cwd, name);
-    if (await import_fs_extra5.default.pathExists(filePath)) {
+    const filePath = path7.join(cwd, name);
+    if (await import_fs_extra4.default.pathExists(filePath)) {
       return filePath;
     }
   }
@@ -44124,7 +43855,7 @@ async function auditSubmitCommand(file2) {
   const client = await getClient();
   let filePath;
   if (file2) {
-    filePath = path8.resolve(file2);
+    filePath = path7.resolve(file2);
   } else {
     const detected = await autoDetectAuditFile();
     if (!detected) {
@@ -44136,14 +43867,14 @@ async function auditSubmitCommand(file2) {
       process.exit(1);
     }
     filePath = detected;
-    console.log(source_default.dim(`Auto-detected audit file: ${path8.relative(process.cwd(), filePath)}`));
+    console.log(source_default.dim(`Auto-detected audit file: ${path7.relative(process.cwd(), filePath)}`));
   }
-  if (!await import_fs_extra5.default.pathExists(filePath)) {
+  if (!await import_fs_extra4.default.pathExists(filePath)) {
     console.error(source_default.red(`File not found: ${filePath}`));
     process.exit(1);
   }
-  const content = await import_fs_extra5.default.readFile(filePath, "utf-8");
-  const filename = path8.basename(filePath);
+  const content = await import_fs_extra4.default.readFile(filePath, "utf-8");
+  const filename = path7.basename(filePath);
   const auditType = detectAuditType(filename);
   const project2 = getProjectName();
   const branch = getGitBranch();
@@ -44269,11 +44000,11 @@ async function auditViewCommand(id, options) {
   try {
     const audit2 = await client.audits.get(id);
     if (options.output) {
-      const outputPath = path8.resolve(options.output);
-      await import_fs_extra5.default.ensureDir(path8.dirname(outputPath));
-      await import_fs_extra5.default.writeFile(outputPath, audit2.content, "utf-8");
+      const outputPath = path7.resolve(options.output);
+      await import_fs_extra4.default.ensureDir(path7.dirname(outputPath));
+      await import_fs_extra4.default.writeFile(outputPath, audit2.content, "utf-8");
       console.log(source_default.green(`
-  \u2713 Audit saved to ${path8.relative(process.cwd(), outputPath)}
+  \u2713 Audit saved to ${path7.relative(process.cwd(), outputPath)}
 `));
     } else {
       const typeLabels = {
@@ -44306,8 +44037,8 @@ async function auditViewCommand(id, options) {
 
 // src/commands/plan.ts
 init_source();
-var import_fs_extra6 = __toESM(require_lib(), 1);
-import path9 from "path";
+var import_fs_extra5 = __toESM(require_lib(), 1);
+import path8 from "path";
 function extractFrontmatterStatus(content) {
   const match = content.match(/^---\n([\s\S]*?)\n---/);
   if (!match) return null;
@@ -44316,7 +44047,7 @@ function extractFrontmatterStatus(content) {
 }
 async function autoDetectPlanFile() {
   const cwd = process.cwd();
-  const plansDir = path9.join(cwd, ".plans");
+  const plansDir = path8.join(cwd, ".plans");
   const mdFiles = await findMdFiles(plansDir);
   if (mdFiles.length === 0) {
     return null;
@@ -44325,7 +44056,7 @@ async function autoDetectPlanFile() {
   const ticketId = extractTicketId(branch);
   if (ticketId) {
     const ticketLower = ticketId.toLowerCase();
-    const match = mdFiles.find((f) => path9.basename(f).toLowerCase().includes(ticketLower));
+    const match = mdFiles.find((f) => path8.basename(f).toLowerCase().includes(ticketLower));
     if (match) {
       return match;
     }
@@ -44336,7 +44067,7 @@ async function planSubmitCommand(file2) {
   const client = await getClient();
   let filePath;
   if (file2) {
-    filePath = path9.resolve(file2);
+    filePath = path8.resolve(file2);
   } else {
     const detected = await autoDetectPlanFile();
     if (!detected) {
@@ -44348,14 +44079,14 @@ async function planSubmitCommand(file2) {
       process.exit(1);
     }
     filePath = detected;
-    console.log(source_default.dim(`Auto-detected plan file: ${path9.relative(process.cwd(), filePath)}`));
+    console.log(source_default.dim(`Auto-detected plan file: ${path8.relative(process.cwd(), filePath)}`));
   }
-  if (!await import_fs_extra6.default.pathExists(filePath)) {
+  if (!await import_fs_extra5.default.pathExists(filePath)) {
     console.error(source_default.red(`File not found: ${filePath}`));
     process.exit(1);
   }
-  const content = await import_fs_extra6.default.readFile(filePath, "utf-8");
-  const filename = path9.basename(filePath);
+  const content = await import_fs_extra5.default.readFile(filePath, "utf-8");
+  const filename = path8.basename(filePath);
   const project2 = getProjectName();
   const branch = getGitBranch();
   const commit = getGitCommit();
@@ -44445,6 +44176,14 @@ async function planListCommand(options) {
 // src/index.ts
 init_update();
 
+// src/utils/debug.ts
+init_source();
+function debugLog(message) {
+  if (process.env["MELTCTL_DEBUG"]) {
+    console.error(source_default.dim(`[debug] ${message}`));
+  }
+}
+
 // src/utils/analytics.ts
 init_version();
 async function trackCommand(command, success2, errorMessage) {
@@ -46135,8 +45874,8 @@ var StdioServerTransport = class {
 
 // ../meltctl-mcp/dist/index.js
 import { readFile } from "fs/promises";
-import path10 from "path";
-import os6 from "os";
+import path9 from "path";
+import os5 from "os";
 
 // ../../node_modules/zod/v3/helpers/util.js
 var util;
@@ -46497,8 +46236,8 @@ function getErrorMap2() {
 
 // ../../node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path11, errorMaps, issueData } = params;
-  const fullPath = [...path11, ...issueData.path || []];
+  const { data, path: path10, errorMaps, issueData } = params;
+  const fullPath = [...path10, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -46613,11 +46352,11 @@ var errorUtil;
 
 // ../../node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path11, key) {
+  constructor(parent, value, path10, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path11;
+    this._path = path10;
     this._key = key;
   }
   get path() {
@@ -50144,11 +49883,11 @@ function normalizeObjectSchema(schema) {
   }
   return void 0;
 }
-function getDotPath(path11) {
-  if (path11.length === 0) {
+function getDotPath(path10) {
+  if (path10.length === 0) {
     return "object root";
   }
-  return path11.reduce((acc, seg, index) => {
+  return path10.reduce((acc, seg, index) => {
     if (index === 0) {
       return String(seg);
     }
@@ -54396,20 +54135,6 @@ function createTemplatesResource2(config2) {
     }
   };
 }
-function createSkillsResource2(config2) {
-  return {
-    async getDevSkills() {
-      const { data, status } = await apiFetch2(config2, "/skills/dev", {
-        method: "GET"
-      });
-      if (status !== 200) {
-        const error51 = data.error;
-        throw new Error(error51 ?? `Failed to fetch dev skills (${status})`);
-      }
-      return data;
-    }
-  };
-}
 function createAuthResource2(config2) {
   return {
     async exchangeToken(code, redirectUri) {
@@ -55547,7 +55272,6 @@ function createMeltClient2(config2) {
     feedback: createFeedbackResource2(config2),
     coins: createCoinsResource2(config2),
     templates: createTemplatesResource2(config2),
-    skills: createSkillsResource2(config2),
     auth: createAuthResource2(config2),
     people: createPeopleResource2(config2),
     projects: createProjectsResource2(config2),
@@ -56034,8 +55758,8 @@ var ISSUE_RULES2 = [
 ];
 var RULE_BY_ID2 = new Map(ISSUE_RULES2.map((r) => [r.id, r]));
 var FOURTEEN_DAYS_MS2 = 14 * 24 * 60 * 60 * 1e3;
-var AUTH_DIR2 = path10.join(os6.homedir(), ".meltctl");
-var AUTH_FILE2 = path10.join(AUTH_DIR2, "auth.json");
+var AUTH_DIR2 = path9.join(os5.homedir(), ".meltctl");
+var AUTH_FILE2 = path9.join(AUTH_DIR2, "auth.json");
 var API_BASE2 = process.env["MELTCTL_API_URL"] ?? "https://api.meltctl.meltstudio.co";
 var AuthError = class extends Error {
   constructor(message) {
@@ -56949,7 +56673,7 @@ program2.name("meltctl").description(
 }).addHelpText(
   "after",
   `
-${source_default.bold("AI Skills")} ${source_default.dim("(run these in Claude Code, not the CLI \u2014 run `meltctl skills install` to load them in the CLI):")}
+${source_default.bold("AI Skills")} ${source_default.dim("(the melt-dev Claude plugin; run these in Claude Code, not the CLI):")}
 ${source_default.dim("  /melt-dev:setup            Analyze the project and customize AGENTS.md")}
 ${source_default.dim("  /melt-dev:link             Connect and verify ticket tracker + browser testing")}
 ${source_default.dim("  /melt-dev:plan             Design an implementation approach before writing code")}
@@ -56964,7 +56688,6 @@ ${source_default.dim("  /melt-dev:cost-audit       Run an AWS cost optimization
 ${source_default.dim("  /melt-dev:help             Answer questions about the development playbook")}
 
 ${source_default.bold("Setup")}
-${source_default.dim("  skills install         Install the dev skills (/melt-dev-*) into Claude Code (+ Cursor; respects CLAUDE_CONFIG_DIR, or --path <dir>)")}
 
 ${source_default.bold("Admin Commands")} ${source_default.dim("(used by skills and team managers):")}
 ${source_default.dim("  audit submit [file]    Submit an audit report")}
@@ -56980,7 +56703,6 @@ ${source_default.dim("  event track --skill    Track skill usage (called by skil
     cmd = cmd.parent;
   }
   await checkAndEnforceUpdate(cmd.name());
-  await maybeSyncSkills(cmd.name());
 }).hook("postAction", async (_thisCommand, actionCommand) => {
   try {
     const parts = [];
@@ -57004,23 +56726,17 @@ program2.command("mcp").description(
 ).action(async () => {
   await mcpCommand();
 });
-var skills = program2.command("skills").description("install the Melt dev skills (/melt-dev-*) into Claude Code");
-skills.command("install").description(
-  "install the Melt dev skills into ~/.claude/skills/ (re-run to update; respects CLAUDE_CONFIG_DIR)"
-).option("--force", "reinstall even if already up to date").option("--path <dir>", "install into this directory only (overrides CLAUDE_CONFIG_DIR)").action(async (options) => {
-  await skillsInstallCommand(options);
-});
 var project = program2.command("project").description("manage project configuration").addHelpText(
   "after",
   `
 ${source_default.dim("Project scaffolding now lives in the Melt dev skills (run these in Claude Code,")}
-${source_default.dim("auto-distributed via the Anthropic org Skills registry):")}
+${source_default.dim("from the melt-dev Claude plugin):")}
 ${source_default.dim("  /melt-dev:setup   Analyze the project, write AGENTS.md, and propose MCP config")}
 ${source_default.dim("  /melt-dev:link    Connect and verify ticket tracker + browser testing")}
 `
 );
 project.command("templates").description(
-  "write the repo-migration playbook to a temp dir (the /melt-update \u2192 /melt-dev-* path); /melt-dev:setup does the same"
+  "write the repo-migration playbook to a temp dir (the /melt-update \u2192 /melt-dev:* path); /melt-dev:setup does the same"
 ).action(async () => {
   await templatesCommand();
 });