npm - @meltstudio/meltctl - Versions diffs - 5.7.3 → 5.9.0 - Mend

@meltstudio/meltctl 5.7.3 → 5.9.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2) hide show

package/dist/index.js +765 -519
package/package.json +1 -1

package/dist/index.js CHANGED Viewed

@@ -1726,8 +1726,8 @@ var require_command = __commonJS({
     "use strict";
     var EventEmitter = __require("events").EventEmitter;
     var childProcess = __require("child_process");
-    var path9 = __require("path");
-    var fs6 = __require("fs");
+    var path10 = __require("path");
+    var fs7 = __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 (fs6.existsSync(executableFile)) return;
+        if (fs7.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 = path9.resolve(baseDir, baseName);
-          if (fs6.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path9.extname(baseName))) return void 0;
+          const localBin = path10.resolve(baseDir, baseName);
+          if (fs7.existsSync(localBin)) return localBin;
+          if (sourceExt.includes(path10.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs6.existsSync(`${localBin}${ext}`)
+            (ext) => fs7.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 = fs6.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs7.realpathSync(this._scriptPath);
           } catch {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path9.resolve(
-            path9.dirname(resolvedScriptPath),
+          executableDir = path10.resolve(
+            path10.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path9.basename(
+            const legacyName = path10.basename(
               this._scriptPath,
-              path9.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(path9.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 = path9.basename(filename, path9.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(path10) {
-        if (path10 === void 0) return this._executableDir;
-        this._executableDir = path10;
+      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(fs6) {
+    function patch(fs7) {
       if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-        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(path9, mode, cb) {
+        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(path10, mode, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs6.lchmodSync = function() {
+        fs7.lchmodSync = function() {
         };
       }
-      if (fs6.chown && !fs6.lchown) {
-        fs6.lchown = function(path9, uid, gid, cb) {
+      if (fs7.chown && !fs7.lchown) {
+        fs7.lchown = function(path10, uid, gid, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs6.lchownSync = function() {
+        fs7.lchownSync = function() {
         };
       }
       if (platform === "win32") {
-        fs6.rename = typeof fs6.rename !== "function" ? fs6.rename : (function(fs$rename) {
+        fs7.rename = typeof fs7.rename !== "function" ? fs7.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() {
-                  fs6.stat(to, function(stater, st) {
+                  fs7.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;
-        })(fs6.rename);
+        })(fs7.rename);
       }
-      fs6.read = typeof fs6.read !== "function" ? fs6.read : (function(fs$read) {
+      fs7.read = typeof fs7.read !== "function" ? fs7.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(fs6, fd, buffer, offset, length, position, callback);
+                return fs$read.call(fs7, fd, buffer, offset, length, position, callback);
               }
               callback_.apply(this, arguments);
             };
           }
-          return fs$read.call(fs6, fd, buffer, offset, length, position, callback);
+          return fs$read.call(fs7, fd, buffer, offset, length, position, callback);
         }
         if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
         return read;
-      })(fs6.read);
-      fs6.readSync = typeof fs6.readSync !== "function" ? fs6.readSync : /* @__PURE__ */ (function(fs$readSync) {
+      })(fs7.read);
+      fs7.readSync = typeof fs7.readSync !== "function" ? fs7.readSync : /* @__PURE__ */ (function(fs$readSync) {
         return function(fd, buffer, offset, length, position) {
           var eagCounter = 0;
           while (true) {
             try {
-              return fs$readSync.call(fs6, fd, buffer, offset, length, position);
+              return fs$readSync.call(fs7, fd, buffer, offset, length, position);
             } catch (er) {
               if (er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
@@ -4165,11 +4165,11 @@ var require_polyfills = __commonJS({
             }
           }
         };
-      })(fs6.readSync);
-      function patchLchmod(fs7) {
-        fs7.lchmod = function(path9, mode, callback) {
-          fs7.open(
-            path9,
+      })(fs7.readSync);
+      function patchLchmod(fs8) {
+        fs8.lchmod = function(path10, mode, callback) {
+          fs8.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;
               }
-              fs7.fchmod(fd, mode, function(err2) {
-                fs7.close(fd, function(err22) {
+              fs8.fchmod(fd, mode, function(err2) {
+                fs8.close(fd, function(err22) {
                   if (callback) callback(err2 || err22);
                 });
               });
             }
           );
         };
-        fs7.lchmodSync = function(path9, mode) {
-          var fd = fs7.openSync(path9, constants.O_WRONLY | constants.O_SYMLINK, mode);
+        fs8.lchmodSync = function(path10, mode) {
+          var fd = fs8.openSync(path10, constants.O_WRONLY | constants.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
-            ret = fs7.fchmodSync(fd, mode);
+            ret = fs8.fchmodSync(fd, mode);
             threw = false;
           } finally {
             if (threw) {
               try {
-                fs7.closeSync(fd);
+                fs8.closeSync(fd);
               } catch (er) {
               }
             } else {
-              fs7.closeSync(fd);
+              fs8.closeSync(fd);
             }
           }
           return ret;
         };
       }
-      function patchLutimes(fs7) {
-        if (constants.hasOwnProperty("O_SYMLINK") && fs7.futimes) {
-          fs7.lutimes = function(path9, at, mt, cb) {
-            fs7.open(path9, constants.O_SYMLINK, function(er, fd) {
+      function patchLutimes(fs8) {
+        if (constants.hasOwnProperty("O_SYMLINK") && fs8.futimes) {
+          fs8.lutimes = function(path10, at, mt, cb) {
+            fs8.open(path10, constants.O_SYMLINK, function(er, fd) {
               if (er) {
                 if (cb) cb(er);
                 return;
               }
-              fs7.futimes(fd, at, mt, function(er2) {
-                fs7.close(fd, function(er22) {
+              fs8.futimes(fd, at, mt, function(er2) {
+                fs8.close(fd, function(er22) {
                   if (cb) cb(er2 || er22);
                 });
               });
             });
           };
-          fs7.lutimesSync = function(path9, at, mt) {
-            var fd = fs7.openSync(path9, constants.O_SYMLINK);
+          fs8.lutimesSync = function(path10, at, mt) {
+            var fd = fs8.openSync(path10, constants.O_SYMLINK);
             var ret;
             var threw = true;
             try {
-              ret = fs7.futimesSync(fd, at, mt);
+              ret = fs8.futimesSync(fd, at, mt);
               threw = false;
             } finally {
               if (threw) {
                 try {
-                  fs7.closeSync(fd);
+                  fs8.closeSync(fd);
                 } catch (er) {
                 }
               } else {
-                fs7.closeSync(fd);
+                fs8.closeSync(fd);
               }
             }
             return ret;
           };
-        } else if (fs7.futimes) {
-          fs7.lutimes = function(_a2, _b, _c, cb) {
+        } else if (fs8.futimes) {
+          fs8.lutimes = function(_a2, _b, _c, cb) {
             if (cb) process.nextTick(cb);
           };
-          fs7.lutimesSync = function() {
+          fs8.lutimesSync = function() {
           };
         }
       }
       function chmodFix(orig) {
         if (!orig) return orig;
         return function(target, mode, cb) {
-          return orig.call(fs6, target, mode, function(er) {
+          return orig.call(fs7, 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(fs6, target, mode);
+            return orig.call(fs7, 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(fs6, target, uid, gid, function(er) {
+          return orig.call(fs7, 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(fs6, target, uid, gid);
+            return orig.call(fs7, 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(fs6, target, options, callback) : orig.call(fs6, target, callback);
+          return options ? orig.call(fs7, target, options, callback) : orig.call(fs7, target, callback);
         };
       }
       function statFixSync(orig) {
         if (!orig) return orig;
         return function(target, options) {
-          var stats = options ? orig.call(fs6, target, options) : orig.call(fs6, target);
+          var stats = options ? orig.call(fs7, target, options) : orig.call(fs7, 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(fs6) {
+    function legacy(fs7) {
       return {
         ReadStream,
         WriteStream
       };
-      function ReadStream(path9, options) {
-        if (!(this instanceof ReadStream)) return new ReadStream(path9, options);
+      function ReadStream(path10, options) {
+        if (!(this instanceof ReadStream)) return new ReadStream(path10, options);
         Stream.call(this);
         var self2 = this;
-        this.path = path9;
+        this.path = path10;
         this.fd = null;
         this.readable = true;
         this.paused = false;
@@ -4378,7 +4378,7 @@ var require_legacy_streams = __commonJS({
           });
           return;
         }
-        fs6.open(this.path, this.flags, this.mode, function(err, fd) {
+        fs7.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(path9, options) {
-        if (!(this instanceof WriteStream)) return new WriteStream(path9, options);
+      function WriteStream(path10, options) {
+        if (!(this instanceof WriteStream)) return new WriteStream(path10, options);
         Stream.call(this);
-        this.path = path9;
+        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 = fs6.open;
+          this._open = fs7.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 fs6 = __require("fs");
+    var fs7 = __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 (!fs6[gracefulQueue]) {
+    if (!fs7[gracefulQueue]) {
       queue = global[gracefulQueue] || [];
-      publishQueue(fs6, queue);
-      fs6.close = (function(fs$close) {
+      publishQueue(fs7, queue);
+      fs7.close = (function(fs$close) {
         function close(fd, cb) {
-          return fs$close.call(fs6, fd, function(err) {
+          return fs$close.call(fs7, fd, function(err) {
             if (!err) {
               resetQueue();
             }
@@ -4502,48 +4502,48 @@ var require_graceful_fs = __commonJS({
           value: fs$close
         });
         return close;
-      })(fs6.close);
-      fs6.closeSync = (function(fs$closeSync) {
+      })(fs7.close);
+      fs7.closeSync = (function(fs$closeSync) {
         function closeSync(fd) {
-          fs$closeSync.apply(fs6, arguments);
+          fs$closeSync.apply(fs7, arguments);
           resetQueue();
         }
         Object.defineProperty(closeSync, previousSymbol, {
           value: fs$closeSync
         });
         return closeSync;
-      })(fs6.closeSync);
+      })(fs7.closeSync);
       if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
         process.on("exit", function() {
-          debug(fs6[gracefulQueue]);
-          __require("assert").equal(fs6[gracefulQueue].length, 0);
+          debug(fs7[gracefulQueue]);
+          __require("assert").equal(fs7[gracefulQueue].length, 0);
         });
       }
     }
     var queue;
     if (!global[gracefulQueue]) {
-      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(path9, options, cb) {
+      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(path10, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$readFile(path9, options, cb);
-        function go$readFile(path10, options2, cb2, startTime) {
-          return fs$readFile(path10, 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, [path10, 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 = fs7.writeFile;
-      fs7.writeFile = writeFile;
-      function writeFile(path9, data, options, cb) {
+      var fs$writeFile = fs8.writeFile;
+      fs8.writeFile = writeFile;
+      function writeFile(path10, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$writeFile(path9, data, options, cb);
-        function go$writeFile(path10, data2, options2, cb2, startTime) {
-          return fs$writeFile(path10, 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, [path10, 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 = fs7.appendFile;
+      var fs$appendFile = fs8.appendFile;
       if (fs$appendFile)
-        fs7.appendFile = appendFile;
-      function appendFile(path9, data, options, cb) {
+        fs8.appendFile = appendFile;
+      function appendFile(path10, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$appendFile(path9, data, options, cb);
-        function go$appendFile(path10, data2, options2, cb2, startTime) {
-          return fs$appendFile(path10, 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, [path10, 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 = fs7.copyFile;
+      var fs$copyFile = fs8.copyFile;
       if (fs$copyFile)
-        fs7.copyFile = copyFile;
+        fs8.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 = fs7.readdir;
-      fs7.readdir = readdir;
+      var fs$readdir = fs8.readdir;
+      fs8.readdir = readdir;
       var noReaddirOptionVersions = /^v[0-5]\./;
-      function readdir(path9, 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(path10, options2, cb2, startTime) {
-          return fs$readdir(path10, fs$readdirCallback(
-            path10,
+        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(path10, options2, cb2, startTime) {
-          return fs$readdir(path10, options2, fs$readdirCallback(
-            path10,
+        } : function go$readdir2(path11, options2, cb2, startTime) {
+          return fs$readdir(path11, options2, fs$readdirCallback(
+            path11,
             options2,
             cb2,
             startTime
           ));
         };
-        return go$readdir(path9, options, cb);
-        function fs$readdirCallback(path10, 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,
-                [path10, 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(fs7);
+        var legStreams = legacy(fs8);
         ReadStream = legStreams.ReadStream;
         WriteStream = legStreams.WriteStream;
       }
-      var fs$ReadStream = fs7.ReadStream;
+      var fs$ReadStream = fs8.ReadStream;
       if (fs$ReadStream) {
         ReadStream.prototype = Object.create(fs$ReadStream.prototype);
         ReadStream.prototype.open = ReadStream$open;
       }
-      var fs$WriteStream = fs7.WriteStream;
+      var fs$WriteStream = fs8.WriteStream;
       if (fs$WriteStream) {
         WriteStream.prototype = Object.create(fs$WriteStream.prototype);
         WriteStream.prototype.open = WriteStream$open;
       }
-      Object.defineProperty(fs7, "ReadStream", {
+      Object.defineProperty(fs8, "ReadStream", {
         get: function() {
           return ReadStream;
         },
@@ -4672,7 +4672,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      Object.defineProperty(fs7, "WriteStream", {
+      Object.defineProperty(fs8, "WriteStream", {
         get: function() {
           return WriteStream;
         },
@@ -4683,7 +4683,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileReadStream = ReadStream;
-      Object.defineProperty(fs7, "FileReadStream", {
+      Object.defineProperty(fs8, "FileReadStream", {
         get: function() {
           return FileReadStream;
         },
@@ -4694,7 +4694,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileWriteStream = WriteStream;
-      Object.defineProperty(fs7, "FileWriteStream", {
+      Object.defineProperty(fs8, "FileWriteStream", {
         get: function() {
           return FileWriteStream;
         },
@@ -4704,7 +4704,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      function ReadStream(path9, 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(path9, 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(path9, options) {
-        return new fs7.ReadStream(path9, options);
+      function createReadStream(path10, options) {
+        return new fs8.ReadStream(path10, options);
       }
-      function createWriteStream(path9, options) {
-        return new fs7.WriteStream(path9, options);
+      function createWriteStream(path10, options) {
+        return new fs8.WriteStream(path10, options);
       }
-      var fs$open = fs7.open;
-      fs7.open = open;
-      function open(path9, flags, mode, cb) {
+      var fs$open = fs8.open;
+      fs8.open = open;
+      function open(path10, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
-        return go$open(path9, flags, mode, cb);
-        function go$open(path10, flags2, mode2, cb2, startTime) {
-          return fs$open(path10, 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, [path10, 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 fs7;
+      return fs8;
     }
     function enqueue(elem) {
       debug("ENQUEUE", elem[0].name, elem[1]);
-      fs6[gracefulQueue].push(elem);
+      fs7[gracefulQueue].push(elem);
       retry();
     }
     var retryTimer;
     function resetQueue() {
       var now = Date.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;
+      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;
         }
       }
       retry();
@@ -4786,9 +4786,9 @@ var require_graceful_fs = __commonJS({
     function retry() {
       clearTimeout(retryTimer);
       retryTimer = void 0;
-      if (fs6[gracefulQueue].length === 0)
+      if (fs7[gracefulQueue].length === 0)
         return;
-      var elem = fs6[gracefulQueue].shift();
+      var elem = fs7[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 {
-          fs6[gracefulQueue].push(elem);
+          fs7[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 fs6 = require_graceful_fs();
+    var fs7 = require_graceful_fs();
     var api = [
       "access",
       "appendFile",
@@ -4866,26 +4866,26 @@ var require_fs = __commonJS({
       "utimes",
       "writeFile"
     ].filter((key) => {
-      return typeof fs6[key] === "function";
+      return typeof fs7[key] === "function";
     });
-    Object.assign(exports, fs6);
+    Object.assign(exports, fs7);
     api.forEach((method) => {
-      exports[method] = u(fs6[method]);
+      exports[method] = u(fs7[method]);
     });
     exports.exists = function(filename, callback) {
       if (typeof callback === "function") {
-        return fs6.exists(filename, callback);
+        return fs7.exists(filename, callback);
       }
       return new Promise((resolve) => {
-        return fs6.exists(filename, resolve);
+        return fs7.exists(filename, resolve);
       });
     };
     exports.read = function(fd, buffer, offset, length, position, callback) {
       if (typeof callback === "function") {
-        return fs6.read(fd, buffer, offset, length, position, callback);
+        return fs7.read(fd, buffer, offset, length, position, callback);
       }
       return new Promise((resolve, reject) => {
-        fs6.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
+        fs7.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 fs6.write(fd, buffer, ...args);
+        return fs7.write(fd, buffer, ...args);
       }
       return new Promise((resolve, reject) => {
-        fs6.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
+        fs7.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 fs6.readv(fd, buffers, ...args);
+        return fs7.readv(fd, buffers, ...args);
       }
       return new Promise((resolve, reject) => {
-        fs6.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
+        fs7.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 fs6.writev(fd, buffers, ...args);
+        return fs7.writev(fd, buffers, ...args);
       }
       return new Promise((resolve, reject) => {
-        fs6.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
+        fs7.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
           if (err) return reject(err);
           resolve({ bytesWritten, buffers: buffers2 });
         });
       });
     };
-    if (typeof fs6.realpath.native === "function") {
-      exports.realpath.native = u(fs6.realpath.native);
+    if (typeof fs7.realpath.native === "function") {
+      exports.realpath.native = u(fs7.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 path9 = __require("path");
+    var path10 = __require("path");
     module.exports.checkPath = function checkPath(pth) {
       if (process.platform === "win32") {
-        const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path9.parse(pth).root, ""));
+        const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path10.parse(pth).root, ""));
         if (pathHasInvalidWinCharacters) {
           const error48 = new Error(`Path contains invalid characters: ${pth}`);
           error48.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 fs6 = require_fs();
+    var fs7 = 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 fs6.mkdir(dir, {
+      return fs7.mkdir(dir, {
         mode: getMode(options),
         recursive: true
       });
     };
     module.exports.makeDirSync = (dir, options) => {
       checkPath(dir);
-      return fs6.mkdirSync(dir, {
+      return fs7.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 fs6 = require_fs();
-    function pathExists(path9) {
-      return fs6.access(path9).then(() => true).catch(() => false);
+    var fs7 = require_fs();
+    function pathExists(path10) {
+      return fs7.access(path10).then(() => true).catch(() => false);
     }
     module.exports = {
       pathExists: u(pathExists),
-      pathExistsSync: fs6.existsSync
+      pathExistsSync: fs7.existsSync
     };
   }
 });
@@ -5021,16 +5021,16 @@ var require_path_exists = __commonJS({
 var require_utimes = __commonJS({
   "node_modules/fs-extra/lib/util/utimes.js"(exports, module) {
     "use strict";
-    var fs6 = require_fs();
+    var fs7 = require_fs();
     var u = require_universalify().fromPromise;
-    async function utimesMillis(path9, atime, mtime) {
-      const fd = await fs6.open(path9, "r+");
+    async function utimesMillis(path10, atime, mtime) {
+      const fd = await fs7.open(path10, "r+");
       let closeErr = null;
       try {
-        await fs6.futimes(fd, atime, mtime);
+        await fs7.futimes(fd, atime, mtime);
       } finally {
         try {
-          await fs6.close(fd);
+          await fs7.close(fd);
         } catch (e) {
           closeErr = e;
         }
@@ -5039,10 +5039,10 @@ var require_utimes = __commonJS({
         throw closeErr;
       }
     }
-    function utimesMillisSync(path9, atime, mtime) {
-      const fd = fs6.openSync(path9, "r+");
-      fs6.futimesSync(fd, atime, mtime);
-      return fs6.closeSync(fd);
+    function utimesMillisSync(path10, atime, mtime) {
+      const fd = fs7.openSync(path10, "r+");
+      fs7.futimesSync(fd, atime, mtime);
+      return fs7.closeSync(fd);
     }
     module.exports = {
       utimesMillis: u(utimesMillis),
@@ -5055,11 +5055,11 @@ var require_utimes = __commonJS({
 var require_stat = __commonJS({
   "node_modules/fs-extra/lib/util/stat.js"(exports, module) {
     "use strict";
-    var fs6 = require_fs();
-    var path9 = __require("path");
+    var fs7 = require_fs();
+    var path10 = __require("path");
     var u = require_universalify().fromPromise;
     function getStats(src, dest, opts) {
-      const statFunc = opts.dereference ? (file2) => fs6.stat(file2, { bigint: true }) : (file2) => fs6.lstat(file2, { bigint: true });
+      const statFunc = opts.dereference ? (file2) => fs7.stat(file2, { bigint: true }) : (file2) => fs7.lstat(file2, { bigint: true });
       return Promise.all([
         statFunc(src),
         statFunc(dest).catch((err) => {
@@ -5070,7 +5070,7 @@ var require_stat = __commonJS({
     }
     function getStatsSync(src, dest, opts) {
       let destStat;
-      const statFunc = opts.dereference ? (file2) => fs6.statSync(file2, { bigint: true }) : (file2) => fs6.lstatSync(file2, { bigint: true });
+      const statFunc = opts.dereference ? (file2) => fs7.statSync(file2, { bigint: true }) : (file2) => fs7.lstatSync(file2, { bigint: true });
       const srcStat = statFunc(src);
       try {
         destStat = statFunc(dest);
@@ -5084,8 +5084,8 @@ var require_stat = __commonJS({
       const { srcStat, destStat } = await getStats(src, dest, opts);
       if (destStat) {
         if (areIdentical(srcStat, destStat)) {
-          const srcBaseName = path9.basename(src);
-          const destBaseName = path9.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 };
           }
@@ -5107,8 +5107,8 @@ var require_stat = __commonJS({
       const { srcStat, destStat } = getStatsSync(src, dest, opts);
       if (destStat) {
         if (areIdentical(srcStat, destStat)) {
-          const srcBaseName = path9.basename(src);
-          const destBaseName = path9.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 };
           }
@@ -5127,12 +5127,12 @@ var require_stat = __commonJS({
       return { srcStat, destStat };
     }
     async function checkParentPaths(src, srcStat, dest, funcName) {
-      const srcParent = path9.resolve(path9.dirname(src));
-      const destParent = path9.resolve(path9.dirname(dest));
-      if (destParent === srcParent || destParent === path9.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 fs6.stat(destParent, { bigint: true });
+        destStat = await fs7.stat(destParent, { bigint: true });
       } catch (err) {
         if (err.code === "ENOENT") return;
         throw err;
@@ -5143,12 +5143,12 @@ var require_stat = __commonJS({
       return checkParentPaths(src, srcStat, destParent, funcName);
     }
     function checkParentPathsSync(src, srcStat, dest, funcName) {
-      const srcParent = path9.resolve(path9.dirname(src));
-      const destParent = path9.resolve(path9.dirname(dest));
-      if (destParent === srcParent || destParent === path9.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 = fs6.statSync(destParent, { bigint: true });
+        destStat = fs7.statSync(destParent, { bigint: true });
       } catch (err) {
         if (err.code === "ENOENT") return;
         throw err;
@@ -5162,8 +5162,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 = path9.resolve(src).split(path9.sep).filter((i) => i);
-      const destArr = path9.resolve(dest).split(path9.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) {
@@ -5215,8 +5215,8 @@ var require_async = __commonJS({
 var require_copy = __commonJS({
   "node_modules/fs-extra/lib/copy/copy.js"(exports, module) {
     "use strict";
-    var fs6 = require_fs();
-    var path9 = __require("path");
+    var fs7 = require_fs();
+    var path10 = __require("path");
     var { mkdirs } = require_mkdirs();
     var { pathExists } = require_path_exists();
     var { utimesMillis } = require_utimes();
@@ -5239,7 +5239,7 @@ var require_copy = __commonJS({
       await stat.checkParentPaths(src, srcStat, dest, "copy");
       const include = await runFilter(src, dest, opts);
       if (!include) return;
-      const destParent = path9.dirname(dest);
+      const destParent = path10.dirname(dest);
       const dirExists = await pathExists(destParent);
       if (!dirExists) {
         await mkdirs(destParent);
@@ -5251,7 +5251,7 @@ var require_copy = __commonJS({
       return opts.filter(src, dest);
     }
     async function getStatsAndPerformCopy(destStat, src, dest, opts) {
-      const statFn = opts.dereference ? fs6.stat : fs6.lstat;
+      const statFn = opts.dereference ? fs7.stat : fs7.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);
@@ -5263,7 +5263,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 fs6.unlink(dest);
+        await fs7.unlink(dest);
         return copyFile(srcStat, src, dest, opts);
       }
       if (opts.errorOnExist) {
@@ -5271,29 +5271,29 @@ var require_copy = __commonJS({
       }
     }
     async function copyFile(srcStat, src, dest, opts) {
-      await fs6.copyFile(src, dest);
+      await fs7.copyFile(src, dest);
       if (opts.preserveTimestamps) {
         if (fileIsNotWritable(srcStat.mode)) {
           await makeFileWritable(dest, srcStat.mode);
         }
-        const updatedSrcStat = await fs6.stat(src);
+        const updatedSrcStat = await fs7.stat(src);
         await utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
       }
-      return fs6.chmod(dest, srcStat.mode);
+      return fs7.chmod(dest, srcStat.mode);
     }
     function fileIsNotWritable(srcMode) {
       return (srcMode & 128) === 0;
     }
     function makeFileWritable(dest, srcMode) {
-      return fs6.chmod(dest, srcMode | 128);
+      return fs7.chmod(dest, srcMode | 128);
     }
     async function onDir(srcStat, destStat, src, dest, opts) {
       if (!destStat) {
-        await fs6.mkdir(dest);
+        await fs7.mkdir(dest);
       }
-      await asyncIteratorConcurrentProcess(await fs6.opendir(src), async (item) => {
-        const srcItem = path9.join(src, item.name);
-        const destItem = path9.join(dest, item.name);
+      await asyncIteratorConcurrentProcess(await fs7.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);
@@ -5301,26 +5301,26 @@ var require_copy = __commonJS({
         }
       });
       if (!destStat) {
-        await fs6.chmod(dest, srcStat.mode);
+        await fs7.chmod(dest, srcStat.mode);
       }
     }
     async function onLink(destStat, src, dest, opts) {
-      let resolvedSrc = await fs6.readlink(src);
+      let resolvedSrc = await fs7.readlink(src);
       if (opts.dereference) {
-        resolvedSrc = path9.resolve(process.cwd(), resolvedSrc);
+        resolvedSrc = path10.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
-        return fs6.symlink(resolvedSrc, dest);
+        return fs7.symlink(resolvedSrc, dest);
       }
       let resolvedDest = null;
       try {
-        resolvedDest = await fs6.readlink(dest);
+        resolvedDest = await fs7.readlink(dest);
       } catch (e) {
-        if (e.code === "EINVAL" || e.code === "UNKNOWN") return fs6.symlink(resolvedSrc, dest);
+        if (e.code === "EINVAL" || e.code === "UNKNOWN") return fs7.symlink(resolvedSrc, dest);
         throw e;
       }
       if (opts.dereference) {
-        resolvedDest = path9.resolve(process.cwd(), resolvedDest);
+        resolvedDest = path10.resolve(process.cwd(), resolvedDest);
       }
       if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
         throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
@@ -5328,8 +5328,8 @@ var require_copy = __commonJS({
       if (stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
         throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
       }
-      await fs6.unlink(dest);
-      return fs6.symlink(resolvedSrc, dest);
+      await fs7.unlink(dest);
+      return fs7.symlink(resolvedSrc, dest);
     }
     module.exports = copy;
   }
@@ -5339,8 +5339,8 @@ var require_copy = __commonJS({
 var require_copy_sync = __commonJS({
   "node_modules/fs-extra/lib/copy/copy-sync.js"(exports, module) {
     "use strict";
-    var fs6 = require_graceful_fs();
-    var path9 = __require("path");
+    var fs7 = require_graceful_fs();
+    var path10 = __require("path");
     var mkdirsSync = require_mkdirs().mkdirsSync;
     var utimesMillisSync = require_utimes().utimesMillisSync;
     var stat = require_stat();
@@ -5361,12 +5361,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 = path9.dirname(dest);
-      if (!fs6.existsSync(destParent)) mkdirsSync(destParent);
+      const destParent = path10.dirname(dest);
+      if (!fs7.existsSync(destParent)) mkdirsSync(destParent);
       return getStats(destStat, src, dest, opts);
     }
     function getStats(destStat, src, dest, opts) {
-      const statSync = opts.dereference ? fs6.statSync : fs6.lstatSync;
+      const statSync = opts.dereference ? fs7.statSync : fs7.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);
@@ -5381,14 +5381,14 @@ var require_copy_sync = __commonJS({
     }
     function mayCopyFile(srcStat, src, dest, opts) {
       if (opts.overwrite) {
-        fs6.unlinkSync(dest);
+        fs7.unlinkSync(dest);
         return copyFile(srcStat, src, dest, opts);
       } else if (opts.errorOnExist) {
         throw new Error(`'${dest}' already exists`);
       }
     }
     function copyFile(srcStat, src, dest, opts) {
-      fs6.copyFileSync(src, dest);
+      fs7.copyFileSync(src, dest);
       if (opts.preserveTimestamps) handleTimestamps(srcStat.mode, src, dest);
       return setDestMode(dest, srcStat.mode);
     }
@@ -5403,10 +5403,10 @@ var require_copy_sync = __commonJS({
       return setDestMode(dest, srcMode | 128);
     }
     function setDestMode(dest, srcMode) {
-      return fs6.chmodSync(dest, srcMode);
+      return fs7.chmodSync(dest, srcMode);
     }
     function setDestTimestamps(src, dest) {
-      const updatedSrcStat = fs6.statSync(src);
+      const updatedSrcStat = fs7.statSync(src);
       return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
     }
     function onDir(srcStat, destStat, src, dest, opts) {
@@ -5414,12 +5414,12 @@ var require_copy_sync = __commonJS({
       return copyDir(src, dest, opts);
     }
     function mkDirAndCopy(srcMode, src, dest, opts) {
-      fs6.mkdirSync(dest);
+      fs7.mkdirSync(dest);
       copyDir(src, dest, opts);
       return setDestMode(dest, srcMode);
     }
     function copyDir(src, dest, opts) {
-      const dir = fs6.opendirSync(src);
+      const dir = fs7.opendirSync(src);
       try {
         let dirent;
         while ((dirent = dir.readSync()) !== null) {
@@ -5430,29 +5430,29 @@ var require_copy_sync = __commonJS({
       }
     }
     function copyDirItem(item, src, dest, opts) {
-      const srcItem = path9.join(src, item);
-      const destItem = path9.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 = fs6.readlinkSync(src);
+      let resolvedSrc = fs7.readlinkSync(src);
       if (opts.dereference) {
-        resolvedSrc = path9.resolve(process.cwd(), resolvedSrc);
+        resolvedSrc = path10.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
-        return fs6.symlinkSync(resolvedSrc, dest);
+        return fs7.symlinkSync(resolvedSrc, dest);
       } else {
         let resolvedDest;
         try {
-          resolvedDest = fs6.readlinkSync(dest);
+          resolvedDest = fs7.readlinkSync(dest);
         } catch (err) {
-          if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs6.symlinkSync(resolvedSrc, dest);
+          if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs7.symlinkSync(resolvedSrc, dest);
           throw err;
         }
         if (opts.dereference) {
-          resolvedDest = path9.resolve(process.cwd(), resolvedDest);
+          resolvedDest = path10.resolve(process.cwd(), resolvedDest);
         }
         if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
           throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
@@ -5464,8 +5464,8 @@ var require_copy_sync = __commonJS({
       }
     }
     function copyLink(resolvedSrc, dest) {
-      fs6.unlinkSync(dest);
-      return fs6.symlinkSync(resolvedSrc, dest);
+      fs7.unlinkSync(dest);
+      return fs7.symlinkSync(resolvedSrc, dest);
     }
     module.exports = copySync;
   }
@@ -5487,13 +5487,13 @@ var require_copy2 = __commonJS({
 var require_remove = __commonJS({
   "node_modules/fs-extra/lib/remove/index.js"(exports, module) {
     "use strict";
-    var fs6 = require_graceful_fs();
+    var fs7 = require_graceful_fs();
     var u = require_universalify().fromCallback;
-    function remove(path9, callback) {
-      fs6.rm(path9, { recursive: true, force: true }, callback);
+    function remove(path10, callback) {
+      fs7.rm(path10, { recursive: true, force: true }, callback);
     }
-    function removeSync(path9) {
-      fs6.rmSync(path9, { recursive: true, force: true });
+    function removeSync(path10) {
+      fs7.rmSync(path10, { recursive: true, force: true });
     }
     module.exports = {
       remove: u(remove),
@@ -5507,28 +5507,28 @@ var require_empty = __commonJS({
   "node_modules/fs-extra/lib/empty/index.js"(exports, module) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs6 = require_fs();
-    var path9 = __require("path");
+    var fs7 = 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 fs6.readdir(dir);
+        items = await fs7.readdir(dir);
       } catch {
         return mkdir.mkdirs(dir);
       }
-      return Promise.all(items.map((item) => remove.remove(path9.join(dir, item))));
+      return Promise.all(items.map((item) => remove.remove(path10.join(dir, item))));
     });
     function emptyDirSync(dir) {
       let items;
       try {
-        items = fs6.readdirSync(dir);
+        items = fs7.readdirSync(dir);
       } catch {
         return mkdir.mkdirsSync(dir);
       }
       items.forEach((item) => {
-        item = path9.join(dir, item);
+        item = path10.join(dir, item);
         remove.removeSync(item);
       });
     }
@@ -5546,52 +5546,52 @@ var require_file = __commonJS({
   "node_modules/fs-extra/lib/ensure/file.js"(exports, module) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var path9 = __require("path");
-    var fs6 = require_fs();
+    var path10 = __require("path");
+    var fs7 = require_fs();
     var mkdir = require_mkdirs();
     async function createFile(file2) {
       let stats;
       try {
-        stats = await fs6.stat(file2);
+        stats = await fs7.stat(file2);
       } catch {
       }
       if (stats && stats.isFile()) return;
-      const dir = path9.dirname(file2);
+      const dir = path10.dirname(file2);
       let dirStats = null;
       try {
-        dirStats = await fs6.stat(dir);
+        dirStats = await fs7.stat(dir);
       } catch (err) {
         if (err.code === "ENOENT") {
           await mkdir.mkdirs(dir);
-          await fs6.writeFile(file2, "");
+          await fs7.writeFile(file2, "");
           return;
         } else {
           throw err;
         }
       }
       if (dirStats.isDirectory()) {
-        await fs6.writeFile(file2, "");
+        await fs7.writeFile(file2, "");
       } else {
-        await fs6.readdir(dir);
+        await fs7.readdir(dir);
       }
     }
     function createFileSync(file2) {
       let stats;
       try {
-        stats = fs6.statSync(file2);
+        stats = fs7.statSync(file2);
       } catch {
       }
       if (stats && stats.isFile()) return;
-      const dir = path9.dirname(file2);
+      const dir = path10.dirname(file2);
       try {
-        if (!fs6.statSync(dir).isDirectory()) {
-          fs6.readdirSync(dir);
+        if (!fs7.statSync(dir).isDirectory()) {
+          fs7.readdirSync(dir);
         }
       } catch (err) {
         if (err && err.code === "ENOENT") mkdir.mkdirsSync(dir);
         else throw err;
       }
-      fs6.writeFileSync(file2, "");
+      fs7.writeFileSync(file2, "");
     }
     module.exports = {
       createFile: u(createFile),
@@ -5605,50 +5605,50 @@ var require_link = __commonJS({
   "node_modules/fs-extra/lib/ensure/link.js"(exports, module) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var path9 = __require("path");
-    var fs6 = require_fs();
+    var path10 = __require("path");
+    var fs7 = 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 fs6.lstat(dstpath);
+        dstStat = await fs7.lstat(dstpath);
       } catch {
       }
       let srcStat;
       try {
-        srcStat = await fs6.lstat(srcpath);
+        srcStat = await fs7.lstat(srcpath);
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureLink");
         throw err;
       }
       if (dstStat && areIdentical(srcStat, dstStat)) return;
-      const dir = path9.dirname(dstpath);
+      const dir = path10.dirname(dstpath);
       const dirExists = await pathExists(dir);
       if (!dirExists) {
         await mkdir.mkdirs(dir);
       }
-      await fs6.link(srcpath, dstpath);
+      await fs7.link(srcpath, dstpath);
     }
     function createLinkSync(srcpath, dstpath) {
       let dstStat;
       try {
-        dstStat = fs6.lstatSync(dstpath);
+        dstStat = fs7.lstatSync(dstpath);
       } catch {
       }
       try {
-        const srcStat = fs6.lstatSync(srcpath);
+        const srcStat = fs7.lstatSync(srcpath);
         if (dstStat && areIdentical(srcStat, dstStat)) return;
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureLink");
         throw err;
       }
-      const dir = path9.dirname(dstpath);
-      const dirExists = fs6.existsSync(dir);
-      if (dirExists) return fs6.linkSync(srcpath, dstpath);
+      const dir = path10.dirname(dstpath);
+      const dirExists = fs7.existsSync(dir);
+      if (dirExists) return fs7.linkSync(srcpath, dstpath);
       mkdir.mkdirsSync(dir);
-      return fs6.linkSync(srcpath, dstpath);
+      return fs7.linkSync(srcpath, dstpath);
     }
     module.exports = {
       createLink: u(createLink),
@@ -5661,14 +5661,14 @@ var require_link = __commonJS({
 var require_symlink_paths = __commonJS({
   "node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports, module) {
     "use strict";
-    var path9 = __require("path");
-    var fs6 = require_fs();
+    var path10 = __require("path");
+    var fs7 = require_fs();
     var { pathExists } = require_path_exists();
     var u = require_universalify().fromPromise;
     async function symlinkPaths(srcpath, dstpath) {
-      if (path9.isAbsolute(srcpath)) {
+      if (path10.isAbsolute(srcpath)) {
         try {
-          await fs6.lstat(srcpath);
+          await fs7.lstat(srcpath);
         } catch (err) {
           err.message = err.message.replace("lstat", "ensureSymlink");
           throw err;
@@ -5678,8 +5678,8 @@ var require_symlink_paths = __commonJS({
           toDst: srcpath
         };
       }
-      const dstdir = path9.dirname(dstpath);
-      const relativeToDst = path9.join(dstdir, srcpath);
+      const dstdir = path10.dirname(dstpath);
+      const relativeToDst = path10.join(dstdir, srcpath);
       const exists = await pathExists(relativeToDst);
       if (exists) {
         return {
@@ -5688,39 +5688,39 @@ var require_symlink_paths = __commonJS({
         };
       }
       try {
-        await fs6.lstat(srcpath);
+        await fs7.lstat(srcpath);
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureSymlink");
         throw err;
       }
       return {
         toCwd: srcpath,
-        toDst: path9.relative(dstdir, srcpath)
+        toDst: path10.relative(dstdir, srcpath)
       };
     }
     function symlinkPathsSync(srcpath, dstpath) {
-      if (path9.isAbsolute(srcpath)) {
-        const exists2 = fs6.existsSync(srcpath);
+      if (path10.isAbsolute(srcpath)) {
+        const exists2 = fs7.existsSync(srcpath);
         if (!exists2) throw new Error("absolute srcpath does not exist");
         return {
           toCwd: srcpath,
           toDst: srcpath
         };
       }
-      const dstdir = path9.dirname(dstpath);
-      const relativeToDst = path9.join(dstdir, srcpath);
-      const exists = fs6.existsSync(relativeToDst);
+      const dstdir = path10.dirname(dstpath);
+      const relativeToDst = path10.join(dstdir, srcpath);
+      const exists = fs7.existsSync(relativeToDst);
       if (exists) {
         return {
           toCwd: relativeToDst,
           toDst: srcpath
         };
       }
-      const srcExists = fs6.existsSync(srcpath);
+      const srcExists = fs7.existsSync(srcpath);
       if (!srcExists) throw new Error("relative srcpath does not exist");
       return {
         toCwd: srcpath,
-        toDst: path9.relative(dstdir, srcpath)
+        toDst: path10.relative(dstdir, srcpath)
       };
     }
     module.exports = {
@@ -5734,13 +5734,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 fs6 = require_fs();
+    var fs7 = require_fs();
     var u = require_universalify().fromPromise;
     async function symlinkType(srcpath, type) {
       if (type) return type;
       let stats;
       try {
-        stats = await fs6.lstat(srcpath);
+        stats = await fs7.lstat(srcpath);
       } catch {
         return "file";
       }
@@ -5750,7 +5750,7 @@ var require_symlink_type = __commonJS({
       if (type) return type;
       let stats;
       try {
-        stats = fs6.lstatSync(srcpath);
+        stats = fs7.lstatSync(srcpath);
       } catch {
         return "file";
       }
@@ -5768,8 +5768,8 @@ var require_symlink = __commonJS({
   "node_modules/fs-extra/lib/ensure/symlink.js"(exports, module) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var path9 = __require("path");
-    var fs6 = require_fs();
+    var path10 = __require("path");
+    var fs7 = require_fs();
     var { mkdirs, mkdirsSync } = require_mkdirs();
     var { symlinkPaths, symlinkPathsSync } = require_symlink_paths();
     var { symlinkType, symlinkTypeSync } = require_symlink_type();
@@ -5778,44 +5778,44 @@ var require_symlink = __commonJS({
     async function createSymlink(srcpath, dstpath, type) {
       let stats;
       try {
-        stats = await fs6.lstat(dstpath);
+        stats = await fs7.lstat(dstpath);
       } catch {
       }
       if (stats && stats.isSymbolicLink()) {
         const [srcStat, dstStat] = await Promise.all([
-          fs6.stat(srcpath),
-          fs6.stat(dstpath)
+          fs7.stat(srcpath),
+          fs7.stat(dstpath)
         ]);
         if (areIdentical(srcStat, dstStat)) return;
       }
       const relative = await symlinkPaths(srcpath, dstpath);
       srcpath = relative.toDst;
       const toType = await symlinkType(relative.toCwd, type);
-      const dir = path9.dirname(dstpath);
+      const dir = path10.dirname(dstpath);
       if (!await pathExists(dir)) {
         await mkdirs(dir);
       }
-      return fs6.symlink(srcpath, dstpath, toType);
+      return fs7.symlink(srcpath, dstpath, toType);
     }
     function createSymlinkSync(srcpath, dstpath, type) {
       let stats;
       try {
-        stats = fs6.lstatSync(dstpath);
+        stats = fs7.lstatSync(dstpath);
       } catch {
       }
       if (stats && stats.isSymbolicLink()) {
-        const srcStat = fs6.statSync(srcpath);
-        const dstStat = fs6.statSync(dstpath);
+        const srcStat = fs7.statSync(srcpath);
+        const dstStat = fs7.statSync(dstpath);
         if (areIdentical(srcStat, dstStat)) return;
       }
       const relative = symlinkPathsSync(srcpath, dstpath);
       srcpath = relative.toDst;
       type = symlinkTypeSync(relative.toCwd, type);
-      const dir = path9.dirname(dstpath);
-      const exists = fs6.existsSync(dir);
-      if (exists) return fs6.symlinkSync(srcpath, dstpath, type);
+      const dir = path10.dirname(dstpath);
+      const exists = fs7.existsSync(dir);
+      if (exists) return fs7.symlinkSync(srcpath, dstpath, type);
       mkdirsSync(dir);
-      return fs6.symlinkSync(srcpath, dstpath, type);
+      return fs7.symlinkSync(srcpath, dstpath, type);
     }
     module.exports = {
       createSymlink: u(createSymlink),
@@ -5884,9 +5884,9 @@ var require_jsonfile = __commonJS({
       if (typeof options === "string") {
         options = { encoding: options };
       }
-      const fs6 = options.fs || _fs;
+      const fs7 = options.fs || _fs;
       const shouldThrow = "throws" in options ? options.throws : true;
-      let data = await universalify.fromCallback(fs6.readFile)(file2, options);
+      let data = await universalify.fromCallback(fs7.readFile)(file2, options);
       data = stripBom(data);
       let obj;
       try {
@@ -5906,10 +5906,10 @@ var require_jsonfile = __commonJS({
       if (typeof options === "string") {
         options = { encoding: options };
       }
-      const fs6 = options.fs || _fs;
+      const fs7 = options.fs || _fs;
       const shouldThrow = "throws" in options ? options.throws : true;
       try {
-        let content = fs6.readFileSync(file2, options);
+        let content = fs7.readFileSync(file2, options);
         content = stripBom(content);
         return JSON.parse(content, options.reviver);
       } catch (err) {
@@ -5922,15 +5922,15 @@ var require_jsonfile = __commonJS({
       }
     }
     async function _writeFile(file2, obj, options = {}) {
-      const fs6 = options.fs || _fs;
+      const fs7 = options.fs || _fs;
       const str = stringify(obj, options);
-      await universalify.fromCallback(fs6.writeFile)(file2, str, options);
+      await universalify.fromCallback(fs7.writeFile)(file2, str, options);
     }
     var writeFile = universalify.fromPromise(_writeFile);
     function writeFileSync2(file2, obj, options = {}) {
-      const fs6 = options.fs || _fs;
+      const fs7 = options.fs || _fs;
       const str = stringify(obj, options);
-      return fs6.writeFileSync(file2, str, options);
+      return fs7.writeFileSync(file2, str, options);
     }
     module.exports = {
       readFile: readFile2,
@@ -5961,23 +5961,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 fs6 = require_fs();
-    var path9 = __require("path");
+    var fs7 = 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 = path9.dirname(file2);
+      const dir = path10.dirname(file2);
       if (!await pathExists(dir)) {
         await mkdir.mkdirs(dir);
       }
-      return fs6.writeFile(file2, data, encoding);
+      return fs7.writeFile(file2, data, encoding);
     }
     function outputFileSync(file2, ...args) {
-      const dir = path9.dirname(file2);
-      if (!fs6.existsSync(dir)) {
+      const dir = path10.dirname(file2);
+      if (!fs7.existsSync(dir)) {
         mkdir.mkdirsSync(dir);
       }
-      fs6.writeFileSync(file2, ...args);
+      fs7.writeFileSync(file2, ...args);
     }
     module.exports = {
       outputFile: u(outputFile),
@@ -6036,8 +6036,8 @@ var require_json = __commonJS({
 var require_move = __commonJS({
   "node_modules/fs-extra/lib/move/move.js"(exports, module) {
     "use strict";
-    var fs6 = require_fs();
-    var path9 = __require("path");
+    var fs7 = require_fs();
+    var path10 = __require("path");
     var { copy } = require_copy2();
     var { remove } = require_remove();
     var { mkdirp } = require_mkdirs();
@@ -6047,8 +6047,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 = path9.dirname(dest);
-      const parsedParentPath = path9.parse(destParent);
+      const destParent = path10.dirname(dest);
+      const parsedParentPath = path10.parse(destParent);
       if (parsedParentPath.root !== destParent) {
         await mkdirp(destParent);
       }
@@ -6063,7 +6063,7 @@ var require_move = __commonJS({
         }
       }
       try {
-        await fs6.rename(src, dest);
+        await fs7.rename(src, dest);
       } catch (err) {
         if (err.code !== "EXDEV") {
           throw err;
@@ -6088,8 +6088,8 @@ var require_move = __commonJS({
 var require_move_sync = __commonJS({
   "node_modules/fs-extra/lib/move/move-sync.js"(exports, module) {
     "use strict";
-    var fs6 = require_graceful_fs();
-    var path9 = __require("path");
+    var fs7 = require_graceful_fs();
+    var path10 = __require("path");
     var copySync = require_copy2().copySync;
     var removeSync = require_remove().removeSync;
     var mkdirpSync = require_mkdirs().mkdirpSync;
@@ -6099,12 +6099,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(path9.dirname(dest));
+      if (!isParentRoot(dest)) mkdirpSync(path10.dirname(dest));
       return doRename(src, dest, overwrite, isChangingCase);
     }
     function isParentRoot(dest) {
-      const parent = path9.dirname(dest);
-      const parsedPath = path9.parse(parent);
+      const parent = path10.dirname(dest);
+      const parsedPath = path10.parse(parent);
       return parsedPath.root === parent;
     }
     function doRename(src, dest, overwrite, isChangingCase) {
@@ -6113,12 +6113,12 @@ var require_move_sync = __commonJS({
         removeSync(dest);
         return rename(src, dest, overwrite);
       }
-      if (fs6.existsSync(dest)) throw new Error("dest already exists.");
+      if (fs7.existsSync(dest)) throw new Error("dest already exists.");
       return rename(src, dest, overwrite);
     }
     function rename(src, dest, overwrite) {
       try {
-        fs6.renameSync(src, dest);
+        fs7.renameSync(src, dest);
       } catch (err) {
         if (err.code !== "EXDEV") throw err;
         return moveAcrossDevice(src, dest, overwrite);
@@ -7450,7 +7450,7 @@ var CLI_VERSION;
 var init_version = __esm({
   "src/utils/version.ts"() {
     "use strict";
-    CLI_VERSION = "5.7.3";
+    CLI_VERSION = "5.9.0";
   }
 });
@@ -14864,10 +14864,10 @@ var require_lib3 = __commonJS({
     exports.analyse = analyse;
     var detectFile = (filepath, opts = {}) => new Promise((resolve, reject) => {
       let fd;
-      const fs6 = (0, node_1.default)();
+      const fs7 = (0, node_1.default)();
       const handler = (err, buffer) => {
         if (fd) {
-          fs6.closeSync(fd);
+          fs7.closeSync(fd);
         }
         if (err) {
           reject(err);
@@ -14879,9 +14879,9 @@ var require_lib3 = __commonJS({
       };
       const sampleSize = (opts === null || opts === void 0 ? void 0 : opts.sampleSize) || 0;
       if (sampleSize > 0) {
-        fd = fs6.openSync(filepath, "r");
+        fd = fs7.openSync(filepath, "r");
         let sample = Buffer.allocUnsafe(sampleSize);
-        fs6.read(fd, sample, 0, sampleSize, opts.offset, (err, bytesRead) => {
+        fs7.read(fd, sample, 0, sampleSize, opts.offset, (err, bytesRead) => {
           if (err) {
             handler(err, null);
           } else {
@@ -14893,22 +14893,22 @@ var require_lib3 = __commonJS({
         });
         return;
       }
-      fs6.readFile(filepath, handler);
+      fs7.readFile(filepath, handler);
     });
     exports.detectFile = detectFile;
     var detectFileSync = (filepath, opts = {}) => {
-      const fs6 = (0, node_1.default)();
+      const fs7 = (0, node_1.default)();
       if (opts && opts.sampleSize) {
-        const fd = fs6.openSync(filepath, "r");
+        const fd = fs7.openSync(filepath, "r");
         let sample = Buffer.allocUnsafe(opts.sampleSize);
-        const bytesRead = fs6.readSync(fd, sample, 0, opts.sampleSize, opts.offset);
+        const bytesRead = fs7.readSync(fd, sample, 0, opts.sampleSize, opts.offset);
         if (bytesRead < opts.sampleSize) {
           sample = sample.subarray(0, bytesRead);
         }
-        fs6.closeSync(fd);
+        fs7.closeSync(fd);
         return (0, exports.detect)(sample);
       }
-      return (0, exports.detect)(fs6.readFileSync(filepath));
+      return (0, exports.detect)(fs7.readFileSync(filepath));
     };
     exports.detectFileSync = detectFileSync;
     exports.default = {
@@ -22735,8 +22735,8 @@ var require_utils4 = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path9) {
-      let input = path9;
+    function removeDotSegments(path10) {
+      let input = path10;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -22988,8 +22988,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path9, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path9 && path9 !== "/" ? path9 : void 0;
+        const [path10, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path10 && path10 !== "/" ? path10 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -26382,12 +26382,12 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs6, exportName) {
+    function addFormats(ajv, list, fs7, exportName) {
       var _a2;
       var _b;
       (_a2 = (_b = ajv.opts.code).formats) !== null && _a2 !== void 0 ? _a2 : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f of list)
-        ajv.addFormat(f, fs6[f]);
+        ajv.addFormat(f, fs7[f]);
     }
     module.exports = exports = formatsPlugin;
     Object.defineProperty(exports, "__esModule", { value: true });
@@ -26530,8 +26530,8 @@ function createAuditsResource(config2) {
       if (filters?.projectId)
         params.set("projectId", String(filters.projectId));
       const query = params.toString();
-      const path9 = `/audits${query ? `?${query}` : ""}`;
-      const { data, status } = await apiFetch(config2, path9);
+      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)
@@ -26580,8 +26580,8 @@ function createPlansResource(config2) {
       if (filters?.projectId)
         params.set("projectId", String(filters.projectId));
       const query = params.toString();
-      const path9 = `/plans${query ? `?${query}` : ""}`;
-      const { data, status } = await apiFetch(config2, path9);
+      const path10 = `/plans${query ? `?${query}` : ""}`;
+      const { data, status } = await apiFetch(config2, path10);
       if (status === 403)
         throw new Error("Access denied. Only Team Managers can list plans.");
       if (status !== 200)
@@ -26623,8 +26623,8 @@ function createPlansResource(config2) {
       if (filters?.author)
         params.set("author", filters.author);
       const query = params.toString();
-      const path9 = `/plans/stats${query ? `?${query}` : ""}`;
-      const { data, status } = await apiFetch(config2, path9);
+      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)
@@ -26663,8 +26663,8 @@ function createEventsResource(config2) {
       if (filters?.projectId)
         params.set("projectId", String(filters.projectId));
       const query = params.toString();
-      const path9 = `/events${query ? `?${query}` : ""}`;
-      const { data, status } = await apiFetch(config2, path9);
+      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)
@@ -26680,8 +26680,8 @@ function createEventsResource(config2) {
       if (filters?.projectId)
         params.set("projectId", String(filters.projectId));
       const query = params.toString();
-      const path9 = `/events/stats${query ? `?${query}` : ""}`;
-      const { data, status } = await apiFetch(config2, path9);
+      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)
@@ -26715,8 +26715,8 @@ function createStandupsResource(config2) {
       const params = new URLSearchParams();
       if (filters?.projectId)
         params.set("projectId", String(filters.projectId));
-      const path9 = `/standups/stats${params.toString() ? `?${params}` : ""}`;
-      const { data, status } = await apiFetch(config2, path9);
+      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)
@@ -26741,8 +26741,8 @@ function createStandupsResource(config2) {
       const params = new URLSearchParams();
       if (opts?.windowDays)
         params.set("windowDays", String(opts.windowDays));
-      const path9 = `/standups/per-person-stats${params.toString() ? `?${params}` : ""}`;
-      const { data, status } = await apiFetch(config2, path9);
+      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)
@@ -26800,8 +26800,8 @@ function createFeedbackResource(config2) {
       if (filters.limit !== void 0)
         params.set("limit", String(filters.limit));
       const qs = params.toString();
-      const path9 = qs ? `/feedback/dashboard?${qs}` : "/feedback/dashboard";
-      const { data, status } = await apiFetch(config2, path9);
+      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})`);
@@ -26841,6 +26841,22 @@ 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 error48 = data.error;
+        throw new Error(error48 ?? `Failed to fetch dev skills (${status})`);
+      }
+      return data;
+    }
+  };
+}
 // ../sdk/dist/resources/auth.js
 function createAuthResource(config2) {
   return {
@@ -26897,8 +26913,8 @@ function createProjectsResource(config2) {
         params.set("activeOnly", "true");
       if (opts?.includeInternal)
         params.set("includeInternal", "true");
-      const path9 = `/projects${params.toString() ? `?${params}` : ""}`;
-      const { data, status } = await apiFetch(config2, path9);
+      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)
@@ -26968,8 +26984,8 @@ function createFindingsResource(config2) {
       if (filters?.limit)
         params.set("limit", String(filters.limit));
       const query = params.toString();
-      const path9 = `/findings${query ? `?${query}` : ""}`;
-      const { data, status } = await apiFetch(config2, path9);
+      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)
@@ -26991,8 +27007,8 @@ function createFindingsResource(config2) {
       if (filters?.auditId)
         params.set("auditId", filters.auditId);
       const query = params.toString();
-      const path9 = `/findings/stats${query ? `?${query}` : ""}`;
-      const { data, status } = await apiFetch(config2, path9);
+      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)
@@ -27155,8 +27171,8 @@ function createBoardAuditsResource(config2) {
         params.set("projectId", String(filters.projectId));
       if (filters?.limit)
         params.set("limit", String(filters.limit));
-      const path9 = `/board-audits${params.toString() ? `?${params}` : ""}`;
-      const { data, status } = await apiFetch(config2, path9);
+      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)
@@ -27676,8 +27692,8 @@ function createSlackResource(config2) {
       if (opts?.limit !== void 0)
         params.set("limit", String(opts.limit));
       const qs = params.toString();
-      const path9 = `/slack/notifications${qs ? `?${qs}` : ""}`;
-      const { data, status } = await apiFetch(config2, path9);
+      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)
@@ -27723,8 +27739,8 @@ function createJobsResource(config2) {
       if (filters?.limit)
         params.set("limit", String(filters.limit));
       const query = params.toString();
-      const path9 = `/jobs${query ? `?${query}` : ""}`;
-      const { data, status } = await apiFetch(config2, path9);
+      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)
@@ -27874,8 +27890,8 @@ function createProfileAuditsResource(config2) {
       if (filters?.limit)
         params.set("limit", String(filters.limit));
       const query = params.toString();
-      const path9 = `/profile-audits${query ? `?${query}` : ""}`;
-      const { data, status } = await apiFetch(config2, path9);
+      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)
@@ -27932,7 +27948,7 @@ function buildSignal(timeoutMs, caller) {
   const anyFn = AbortSignal.any;
   return anyFn ? anyFn([caller, timeout]) : timeout;
 }
-async function apiFetch(config2, path9, 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;
@@ -27940,7 +27956,7 @@ async function apiFetch(config2, path9, options = {}) {
   let lastError;
   for (let attempt = 1; attempt <= maxAttempts; attempt++) {
     try {
-      const response = await fetch(`${config2.baseUrl}${path9}`, {
+      const response = await fetch(`${config2.baseUrl}${path10}`, {
         ...options,
         signal: buildSignal(timeoutMs, options.signal),
         headers: {
@@ -27976,6 +27992,7 @@ function createMeltClient(config2) {
     feedback: createFeedbackResource(config2),
     coins: createCoinsResource(config2),
     templates: createTemplatesResource(config2),
+    skills: createSkillsResource(config2),
     auth: createAuthResource(config2),
     people: createPeopleResource(config2),
     projects: createProjectsResource(config2),
@@ -28760,10 +28777,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path9) {
-  if (!path9)
+function getElementAtPath(obj, path10) {
+  if (!path10)
     return obj;
-  return path9.reduce((acc, key) => acc?.[key], obj);
+  return path10.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -29146,11 +29163,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path9, issues) {
+function prefixIssues(path10, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path9);
+    iss.path.unshift(path10);
     return iss;
   });
 }
@@ -29333,7 +29350,7 @@ function formatError(error48, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error48, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error49, path9 = []) => {
+  const processError = (error49, path10 = []) => {
     var _a2, _b;
     for (const issue2 of error49.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -29343,7 +29360,7 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path9, ...issue2.path];
+        const fullpath = [...path10, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -29375,8 +29392,8 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path9 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path9) {
+  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")
@@ -41353,13 +41370,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path9 = ref.slice(1).split("/").filter(Boolean);
-  if (path9.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 (path9[0] === defsKey) {
-    const key = path9[1];
+  if (path10[0] === defsKey) {
+    const key = path10[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -42498,6 +42515,253 @@ 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 path5 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() {
+  return path5.join(os5.homedir(), ".claude", "skills");
+}
+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 = path5.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(path5.join(skillsRoot, name));
+  }
+  for (const skill of manifest.skills) {
+    const dir = path5.join(skillsRoot, skill.name);
+    import_fs_extra3.default.removeSync(dir);
+    for (const [relPath, content] of Object.entries(skill.files)) {
+      import_fs_extra3.default.outputFileSync(path5.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(path5.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(path5.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 (error48) {
+    console.error(
+      source_default.red(
+        `Failed to fetch Melt dev skills: ${error48 instanceof Error ? error48.message : "Unknown error"}`
+      )
+    );
+    process.exit(1);
+  }
+  const skillsRoot = getSkillsRoot();
+  const existing = readMarker(skillsRoot);
+  if (existing && existing.version === manifest.version && !opts.force) {
+    console.log(
+      source_default.dim(
+        `
+  Melt dev skills already up to date (v${manifest.version}). Use --force to reinstall.
+`
+      )
+    );
+    return;
+  }
+  applyDevSkills(manifest, skillsRoot);
+  console.log(
+    source_default.green(
+      `
+  \u2713 Installed ${manifest.skills.length} Melt dev skills (v${manifest.version}) to ~/.claude/skills/.`
+    )
+  );
+  console.log(
+    source_default.dim(
+      "  Restart Claude Code 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;
+    const diff = applyDevSkills(manifest, skillsRoot);
+    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();
@@ -42594,39 +42858,6 @@ 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}` });
@@ -42848,12 +43079,12 @@ async function showLeaderboard() {
 // src/commands/audit.ts
 init_source();
-var import_fs_extra4 = __toESM(require_lib(), 1);
-import path6 from "path";
+var import_fs_extra5 = __toESM(require_lib(), 1);
+import path7 from "path";
 // src/utils/git.ts
-var import_fs_extra3 = __toESM(require_lib(), 1);
-import path5 from "path";
+var import_fs_extra4 = __toESM(require_lib(), 1);
+import path6 from "path";
 import { execSync as execSync4 } from "child_process";
 function getGitBranch() {
   try {
@@ -42891,34 +43122,34 @@ function getGitRepository() {
 function getProjectName() {
   const cwd = process.cwd();
   try {
-    const pkgPath = path5.join(cwd, "package.json");
-    if (import_fs_extra3.default.pathExistsSync(pkgPath)) {
-      const pkg = import_fs_extra3.default.readJsonSync(pkgPath);
+    const pkgPath = path6.join(cwd, "package.json");
+    if (import_fs_extra4.default.pathExistsSync(pkgPath)) {
+      const pkg = import_fs_extra4.default.readJsonSync(pkgPath);
       if (pkg.name) {
         return pkg.name;
       }
     }
   } catch {
   }
-  return path5.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_extra3.default.pathExists(dir)) {
+  if (!await import_fs_extra4.default.pathExists(dir)) {
     return [];
   }
   const results = [];
   async function walk(current) {
-    const entries = await import_fs_extra3.default.readdir(current, { withFileTypes: true });
+    const entries = await import_fs_extra4.default.readdir(current, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path5.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_extra3.default.stat(fullPath);
+        const stat = await import_fs_extra4.default.stat(fullPath);
         results.push({ path: fullPath, mtime: stat.mtimeMs });
       }
     }
@@ -42937,15 +43168,15 @@ function detectAuditType(filename) {
 }
 async function autoDetectAuditFile() {
   const cwd = process.cwd();
-  const auditsDir = path6.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 = path6.join(cwd, name);
-    if (await import_fs_extra4.default.pathExists(filePath)) {
+    const filePath = path7.join(cwd, name);
+    if (await import_fs_extra5.default.pathExists(filePath)) {
       return filePath;
     }
   }
@@ -42955,7 +43186,7 @@ async function auditSubmitCommand(file2) {
   const client = await getClient();
   let filePath;
   if (file2) {
-    filePath = path6.resolve(file2);
+    filePath = path7.resolve(file2);
   } else {
     const detected = await autoDetectAuditFile();
     if (!detected) {
@@ -42967,14 +43198,14 @@ async function auditSubmitCommand(file2) {
       process.exit(1);
     }
     filePath = detected;
-    console.log(source_default.dim(`Auto-detected audit file: ${path6.relative(process.cwd(), filePath)}`));
+    console.log(source_default.dim(`Auto-detected audit file: ${path7.relative(process.cwd(), filePath)}`));
   }
-  if (!await import_fs_extra4.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_extra4.default.readFile(filePath, "utf-8");
-  const filename = path6.basename(filePath);
+  const content = await import_fs_extra5.default.readFile(filePath, "utf-8");
+  const filename = path7.basename(filePath);
   const auditType = detectAuditType(filename);
   const project2 = getProjectName();
   const branch = getGitBranch();
@@ -43099,11 +43330,11 @@ async function auditViewCommand(id, options) {
   try {
     const audit2 = await client.audits.get(id);
     if (options.output) {
-      const outputPath = path6.resolve(options.output);
-      await import_fs_extra4.default.ensureDir(path6.dirname(outputPath));
-      await import_fs_extra4.default.writeFile(outputPath, audit2.content, "utf-8");
+      const outputPath = path7.resolve(options.output);
+      await import_fs_extra5.default.ensureDir(path7.dirname(outputPath));
+      await import_fs_extra5.default.writeFile(outputPath, audit2.content, "utf-8");
       console.log(source_default.green(`
-  \u2713 Audit saved to ${path6.relative(process.cwd(), outputPath)}
+  \u2713 Audit saved to ${path7.relative(process.cwd(), outputPath)}
 `));
     } else {
       const typeLabels = {
@@ -43135,8 +43366,8 @@ async function auditViewCommand(id, options) {
 // src/commands/plan.ts
 init_source();
-var import_fs_extra5 = __toESM(require_lib(), 1);
-import path7 from "path";
+var import_fs_extra6 = __toESM(require_lib(), 1);
+import path8 from "path";
 function extractFrontmatterStatus(content) {
   const match = content.match(/^---\n([\s\S]*?)\n---/);
   if (!match) return null;
@@ -43145,7 +43376,7 @@ function extractFrontmatterStatus(content) {
 }
 async function autoDetectPlanFile() {
   const cwd = process.cwd();
-  const plansDir = path7.join(cwd, ".plans");
+  const plansDir = path8.join(cwd, ".plans");
   const mdFiles = await findMdFiles(plansDir);
   if (mdFiles.length === 0) {
     return null;
@@ -43154,7 +43385,7 @@ async function autoDetectPlanFile() {
   const ticketId = extractTicketId(branch);
   if (ticketId) {
     const ticketLower = ticketId.toLowerCase();
-    const match = mdFiles.find((f) => path7.basename(f).toLowerCase().includes(ticketLower));
+    const match = mdFiles.find((f) => path8.basename(f).toLowerCase().includes(ticketLower));
     if (match) {
       return match;
     }
@@ -43165,7 +43396,7 @@ async function planSubmitCommand(file2) {
   const client = await getClient();
   let filePath;
   if (file2) {
-    filePath = path7.resolve(file2);
+    filePath = path8.resolve(file2);
   } else {
     const detected = await autoDetectPlanFile();
     if (!detected) {
@@ -43177,14 +43408,14 @@ async function planSubmitCommand(file2) {
       process.exit(1);
     }
     filePath = detected;
-    console.log(source_default.dim(`Auto-detected plan file: ${path7.relative(process.cwd(), filePath)}`));
+    console.log(source_default.dim(`Auto-detected plan file: ${path8.relative(process.cwd(), filePath)}`));
   }
-  if (!await import_fs_extra5.default.pathExists(filePath)) {
+  if (!await import_fs_extra6.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 = path7.basename(filePath);
+  const content = await import_fs_extra6.default.readFile(filePath, "utf-8");
+  const filename = path8.basename(filePath);
   const project2 = getProjectName();
   const branch = getGitBranch();
   const commit = getGitCommit();
@@ -43274,14 +43505,6 @@ 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) {
@@ -44957,8 +45180,8 @@ var StdioServerTransport = class {
 // ../meltctl-mcp/dist/index.js
 import { readFile } from "fs/promises";
-import path8 from "path";
-import os5 from "os";
+import path9 from "path";
+import os6 from "os";
 // ../../node_modules/zod/v3/helpers/util.js
 var util;
@@ -45319,8 +45542,8 @@ function getErrorMap2() {
 // ../../node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path9, errorMaps, issueData } = params;
-  const fullPath = [...path9, ...issueData.path || []];
+  const { data, path: path10, errorMaps, issueData } = params;
+  const fullPath = [...path10, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -45435,11 +45658,11 @@ var errorUtil;
 // ../../node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path9, key) {
+  constructor(parent, value, path10, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path9;
+    this._path = path10;
     this._key = key;
   }
   get path() {
@@ -53209,6 +53432,20 @@ function createTemplatesResource2(config2) {
     }
   };
 }
+function createSkillsResource2(config2) {
+  return {
+    async getDevSkills() {
+      const { data, status } = await apiFetch2(config2, "/skills/dev", {
+        method: "GET"
+      });
+      if (status !== 200) {
+        const error48 = data.error;
+        throw new Error(error48 ?? `Failed to fetch dev skills (${status})`);
+      }
+      return data;
+    }
+  };
+}
 function createAuthResource2(config2) {
   return {
     async exchangeToken(code, redirectUri) {
@@ -54315,6 +54552,7 @@ function createMeltClient2(config2) {
     feedback: createFeedbackResource2(config2),
     coins: createCoinsResource2(config2),
     templates: createTemplatesResource2(config2),
+    skills: createSkillsResource2(config2),
     auth: createAuthResource2(config2),
     people: createPeopleResource2(config2),
     projects: createProjectsResource2(config2),
@@ -54773,8 +55011,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 = path8.join(os5.homedir(), ".meltctl");
-var AUTH_FILE2 = path8.join(AUTH_DIR2, "auth.json");
+var AUTH_DIR2 = path9.join(os6.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) {
@@ -55648,7 +55886,7 @@ program2.name("meltctl").description(
 }).addHelpText(
   "after",
   `
-${source_default.bold("AI Skills")} ${source_default.dim("(run these in Claude Code, not the CLI \u2014 auto-distributed via the org Skills registry):")}
+${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.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")}
@@ -55661,6 +55899,9 @@ ${source_default.dim("  /melt-dev-ux-audit         Review UI against usability h
 ${source_default.dim("  /melt-dev-security-audit   Run a security posture audit across the platform")}
 ${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")}
 ${source_default.bold("Admin Commands")} ${source_default.dim("(used by skills and team managers):")}
 ${source_default.dim("  audit submit [file]    Submit an audit report")}
 ${source_default.dim("  audit list             List audits (managers only)")}
@@ -55675,6 +55916,7 @@ ${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 = [];
@@ -55698,6 +55940,10 @@ 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)").option("--force", "reinstall even if already up to date").action(async (options) => {
+  await skillsInstallCommand(options);
+});
 var project = program2.command("project").description("manage project configuration").addHelpText(
   "after",
   `