@atlashub/smartstack-cli 3.53.0 → 4.0.0

package/dist/index.js

@@ -973,8 +973,8 @@ var require_command = __commonJS({
     "use strict";
     var EventEmitter2 = require("events").EventEmitter;
     var childProcess2 = require("child_process");
-    var path5 = require("path");
-    var fs17 = require("fs");
+    var path4 = require("path");
+    var fs20 = require("fs");
     var process17 = require("process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -1906,11 +1906,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path5.resolve(baseDir, baseName);
-          if (fs17.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path5.extname(baseName))) return void 0;
+          const localBin = path4.resolve(baseDir, baseName);
+          if (fs20.existsSync(localBin)) return localBin;
+          if (sourceExt.includes(path4.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext2) => fs17.existsSync(`${localBin}${ext2}`)
+            (ext2) => fs20.existsSync(`${localBin}${ext2}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -1922,21 +1922,21 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs17.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs20.realpathSync(this._scriptPath);
           } catch (err) {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path5.resolve(
-            path5.dirname(resolvedScriptPath),
+          executableDir = path4.resolve(
+            path4.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path5.basename(
+            const legacyName = path4.basename(
               this._scriptPath,
-              path5.extname(this._scriptPath)
+              path4.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -1947,7 +1947,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path5.extname(executableFile));
+        launchWithNode = sourceExt.includes(path4.extname(executableFile));
         let proc2;
         if (process17.platform !== "win32") {
           if (launchWithNode) {
@@ -2787,7 +2787,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path5.basename(filename, path5.extname(filename));
+        this._name = path4.basename(filename, path4.extname(filename));
         return this;
       }
       /**
@@ -2801,9 +2801,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path6) {
-        if (path6 === void 0) return this._executableDir;
-        this._executableDir = path6;
+      executableDir(path5) {
+        if (path5 === void 0) return this._executableDir;
+        this._executableDir = path5;
         return this;
       }
       /**
@@ -3069,7 +3069,7 @@ var require_polyfills = __commonJS({
     var constants = require("constants");
     var origCwd = process.cwd;
     var cwd = null;
-    var platform3 = process.env.GRACEFUL_FS_PLATFORM || process.platform;
+    var platform4 = process.env.GRACEFUL_FS_PLATFORM || process.platform;
     process.cwd = function() {
       if (!cwd)
         cwd = origCwd.call(process);
@@ -3089,54 +3089,54 @@ var require_polyfills = __commonJS({
     }
     var chdir;
     module2.exports = patch;
-    function patch(fs17) {
+    function patch(fs20) {
       if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-        patchLchmod(fs17);
-      }
-      if (!fs17.lutimes) {
-        patchLutimes(fs17);
-      }
-      fs17.chown = chownFix(fs17.chown);
-      fs17.fchown = chownFix(fs17.fchown);
-      fs17.lchown = chownFix(fs17.lchown);
-      fs17.chmod = chmodFix(fs17.chmod);
-      fs17.fchmod = chmodFix(fs17.fchmod);
-      fs17.lchmod = chmodFix(fs17.lchmod);
-      fs17.chownSync = chownFixSync(fs17.chownSync);
-      fs17.fchownSync = chownFixSync(fs17.fchownSync);
-      fs17.lchownSync = chownFixSync(fs17.lchownSync);
-      fs17.chmodSync = chmodFixSync(fs17.chmodSync);
-      fs17.fchmodSync = chmodFixSync(fs17.fchmodSync);
-      fs17.lchmodSync = chmodFixSync(fs17.lchmodSync);
-      fs17.stat = statFix(fs17.stat);
-      fs17.fstat = statFix(fs17.fstat);
-      fs17.lstat = statFix(fs17.lstat);
-      fs17.statSync = statFixSync(fs17.statSync);
-      fs17.fstatSync = statFixSync(fs17.fstatSync);
-      fs17.lstatSync = statFixSync(fs17.lstatSync);
-      if (fs17.chmod && !fs17.lchmod) {
-        fs17.lchmod = function(path5, mode, cb) {
+        patchLchmod(fs20);
+      }
+      if (!fs20.lutimes) {
+        patchLutimes(fs20);
+      }
+      fs20.chown = chownFix(fs20.chown);
+      fs20.fchown = chownFix(fs20.fchown);
+      fs20.lchown = chownFix(fs20.lchown);
+      fs20.chmod = chmodFix(fs20.chmod);
+      fs20.fchmod = chmodFix(fs20.fchmod);
+      fs20.lchmod = chmodFix(fs20.lchmod);
+      fs20.chownSync = chownFixSync(fs20.chownSync);
+      fs20.fchownSync = chownFixSync(fs20.fchownSync);
+      fs20.lchownSync = chownFixSync(fs20.lchownSync);
+      fs20.chmodSync = chmodFixSync(fs20.chmodSync);
+      fs20.fchmodSync = chmodFixSync(fs20.fchmodSync);
+      fs20.lchmodSync = chmodFixSync(fs20.lchmodSync);
+      fs20.stat = statFix(fs20.stat);
+      fs20.fstat = statFix(fs20.fstat);
+      fs20.lstat = statFix(fs20.lstat);
+      fs20.statSync = statFixSync(fs20.statSync);
+      fs20.fstatSync = statFixSync(fs20.fstatSync);
+      fs20.lstatSync = statFixSync(fs20.lstatSync);
+      if (fs20.chmod && !fs20.lchmod) {
+        fs20.lchmod = function(path4, mode, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs17.lchmodSync = function() {
+        fs20.lchmodSync = function() {
         };
       }
-      if (fs17.chown && !fs17.lchown) {
-        fs17.lchown = function(path5, uid, gid, cb) {
+      if (fs20.chown && !fs20.lchown) {
+        fs20.lchown = function(path4, uid, gid, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs17.lchownSync = function() {
+        fs20.lchownSync = function() {
         };
       }
-      if (platform3 === "win32") {
-        fs17.rename = typeof fs17.rename !== "function" ? fs17.rename : (function(fs$rename) {
+      if (platform4 === "win32") {
+        fs20.rename = typeof fs20.rename !== "function" ? fs20.rename : (function(fs$rename) {
           function rename(from3, to, cb) {
             var start = Date.now();
             var backoff = 0;
             fs$rename(from3, to, function CB(er) {
               if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 6e4) {
                 setTimeout(function() {
-                  fs17.stat(to, function(stater, st) {
+                  fs20.stat(to, function(stater, st) {
                     if (stater && stater.code === "ENOENT")
                       fs$rename(from3, to, CB);
                     else
@@ -3152,9 +3152,9 @@ var require_polyfills = __commonJS({
           }
           if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
           return rename;
-        })(fs17.rename);
+        })(fs20.rename);
       }
-      fs17.read = typeof fs17.read !== "function" ? fs17.read : (function(fs$read) {
+      fs20.read = typeof fs20.read !== "function" ? fs20.read : (function(fs$read) {
         function read(fd, buffer, offset, length, position, callback_) {
           var callback;
           if (callback_ && typeof callback_ === "function") {
@@ -3162,22 +3162,22 @@ var require_polyfills = __commonJS({
             callback = function(er, _3, __) {
               if (er && er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
-                return fs$read.call(fs17, fd, buffer, offset, length, position, callback);
+                return fs$read.call(fs20, fd, buffer, offset, length, position, callback);
               }
               callback_.apply(this, arguments);
             };
           }
-          return fs$read.call(fs17, fd, buffer, offset, length, position, callback);
+          return fs$read.call(fs20, fd, buffer, offset, length, position, callback);
         }
         if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
         return read;
-      })(fs17.read);
-      fs17.readSync = typeof fs17.readSync !== "function" ? fs17.readSync : /* @__PURE__ */ (function(fs$readSync) {
+      })(fs20.read);
+      fs20.readSync = typeof fs20.readSync !== "function" ? fs20.readSync : /* @__PURE__ */ (function(fs$readSync) {
         return function(fd, buffer, offset, length, position) {
           var eagCounter = 0;
           while (true) {
             try {
-              return fs$readSync.call(fs17, fd, buffer, offset, length, position);
+              return fs$readSync.call(fs20, fd, buffer, offset, length, position);
             } catch (er) {
               if (er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
@@ -3187,11 +3187,11 @@ var require_polyfills = __commonJS({
             }
           }
         };
-      })(fs17.readSync);
-      function patchLchmod(fs18) {
-        fs18.lchmod = function(path5, mode, callback) {
-          fs18.open(
-            path5,
+      })(fs20.readSync);
+      function patchLchmod(fs21) {
+        fs21.lchmod = function(path4, mode, callback) {
+          fs21.open(
+            path4,
             constants.O_WRONLY | constants.O_SYMLINK,
             mode,
             function(err, fd) {
@@ -3199,80 +3199,80 @@ var require_polyfills = __commonJS({
                 if (callback) callback(err);
                 return;
               }
-              fs18.fchmod(fd, mode, function(err2) {
-                fs18.close(fd, function(err22) {
+              fs21.fchmod(fd, mode, function(err2) {
+                fs21.close(fd, function(err22) {
                   if (callback) callback(err2 || err22);
                 });
               });
             }
           );
         };
-        fs18.lchmodSync = function(path5, mode) {
-          var fd = fs18.openSync(path5, constants.O_WRONLY | constants.O_SYMLINK, mode);
+        fs21.lchmodSync = function(path4, mode) {
+          var fd = fs21.openSync(path4, constants.O_WRONLY | constants.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
-            ret = fs18.fchmodSync(fd, mode);
+            ret = fs21.fchmodSync(fd, mode);
             threw = false;
           } finally {
             if (threw) {
               try {
-                fs18.closeSync(fd);
+                fs21.closeSync(fd);
               } catch (er) {
               }
             } else {
-              fs18.closeSync(fd);
+              fs21.closeSync(fd);
             }
           }
           return ret;
         };
       }
-      function patchLutimes(fs18) {
-        if (constants.hasOwnProperty("O_SYMLINK") && fs18.futimes) {
-          fs18.lutimes = function(path5, at, mt, cb) {
-            fs18.open(path5, constants.O_SYMLINK, function(er, fd) {
+      function patchLutimes(fs21) {
+        if (constants.hasOwnProperty("O_SYMLINK") && fs21.futimes) {
+          fs21.lutimes = function(path4, at, mt, cb) {
+            fs21.open(path4, constants.O_SYMLINK, function(er, fd) {
               if (er) {
                 if (cb) cb(er);
                 return;
               }
-              fs18.futimes(fd, at, mt, function(er2) {
-                fs18.close(fd, function(er22) {
+              fs21.futimes(fd, at, mt, function(er2) {
+                fs21.close(fd, function(er22) {
                   if (cb) cb(er2 || er22);
                 });
               });
             });
           };
-          fs18.lutimesSync = function(path5, at, mt) {
-            var fd = fs18.openSync(path5, constants.O_SYMLINK);
+          fs21.lutimesSync = function(path4, at, mt) {
+            var fd = fs21.openSync(path4, constants.O_SYMLINK);
             var ret;
             var threw = true;
             try {
-              ret = fs18.futimesSync(fd, at, mt);
+              ret = fs21.futimesSync(fd, at, mt);
               threw = false;
             } finally {
               if (threw) {
                 try {
-                  fs18.closeSync(fd);
+                  fs21.closeSync(fd);
                 } catch (er) {
                 }
               } else {
-                fs18.closeSync(fd);
+                fs21.closeSync(fd);
               }
             }
             return ret;
           };
-        } else if (fs18.futimes) {
-          fs18.lutimes = function(_a, _b, _c, cb) {
+        } else if (fs21.futimes) {
+          fs21.lutimes = function(_a, _b, _c, cb) {
             if (cb) process.nextTick(cb);
           };
-          fs18.lutimesSync = function() {
+          fs21.lutimesSync = function() {
           };
         }
       }
       function chmodFix(orig) {
         if (!orig) return orig;
         return function(target, mode, cb) {
-          return orig.call(fs17, target, mode, function(er) {
+          return orig.call(fs20, target, mode, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -3282,7 +3282,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, mode) {
           try {
-            return orig.call(fs17, target, mode);
+            return orig.call(fs20, target, mode);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -3291,7 +3291,7 @@ var require_polyfills = __commonJS({
       function chownFix(orig) {
         if (!orig) return orig;
         return function(target, uid, gid, cb) {
-          return orig.call(fs17, target, uid, gid, function(er) {
+          return orig.call(fs20, target, uid, gid, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -3301,7 +3301,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, uid, gid) {
           try {
-            return orig.call(fs17, target, uid, gid);
+            return orig.call(fs20, target, uid, gid);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -3321,13 +3321,13 @@ var require_polyfills = __commonJS({
             }
             if (cb) cb.apply(this, arguments);
           }
-          return options ? orig.call(fs17, target, options, callback) : orig.call(fs17, target, callback);
+          return options ? orig.call(fs20, target, options, callback) : orig.call(fs20, target, callback);
         };
       }
       function statFixSync(orig) {
         if (!orig) return orig;
         return function(target, options) {
-          var stats = options ? orig.call(fs17, target, options) : orig.call(fs17, target);
+          var stats = options ? orig.call(fs20, target, options) : orig.call(fs20, target);
           if (stats) {
             if (stats.uid < 0) stats.uid += 4294967296;
             if (stats.gid < 0) stats.gid += 4294967296;
@@ -3357,16 +3357,16 @@ var require_legacy_streams = __commonJS({
     "use strict";
     var Stream2 = require("stream").Stream;
     module2.exports = legacy;
-    function legacy(fs17) {
+    function legacy(fs20) {
       return {
         ReadStream,
         WriteStream
       };
-      function ReadStream(path5, options) {
-        if (!(this instanceof ReadStream)) return new ReadStream(path5, options);
+      function ReadStream(path4, options) {
+        if (!(this instanceof ReadStream)) return new ReadStream(path4, options);
         Stream2.call(this);
         var self2 = this;
-        this.path = path5;
+        this.path = path4;
         this.fd = null;
         this.readable = true;
         this.paused = false;
@@ -3400,7 +3400,7 @@ var require_legacy_streams = __commonJS({
           });
           return;
         }
-        fs17.open(this.path, this.flags, this.mode, function(err, fd) {
+        fs20.open(this.path, this.flags, this.mode, function(err, fd) {
           if (err) {
             self2.emit("error", err);
             self2.readable = false;
@@ -3411,10 +3411,10 @@ var require_legacy_streams = __commonJS({
           self2._read();
         });
       }
-      function WriteStream(path5, options) {
-        if (!(this instanceof WriteStream)) return new WriteStream(path5, options);
+      function WriteStream(path4, options) {
+        if (!(this instanceof WriteStream)) return new WriteStream(path4, options);
         Stream2.call(this);
-        this.path = path5;
+        this.path = path4;
         this.fd = null;
         this.writable = true;
         this.flags = "w";
@@ -3439,7 +3439,7 @@ var require_legacy_streams = __commonJS({
         this.busy = false;
         this._queue = [];
         if (this.fd === null) {
-          this._open = fs17.open;
+          this._open = fs20.open;
           this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
           this.flush();
         }
@@ -3475,7 +3475,7 @@ var require_clone = __commonJS({
 var require_graceful_fs = __commonJS({
   "node_modules/graceful-fs/graceful-fs.js"(exports2, module2) {
     "use strict";
-    var fs17 = require("fs");
+    var fs20 = require("fs");
     var polyfills = require_polyfills();
     var legacy = require_legacy_streams();
     var clone = require_clone();
@@ -3507,12 +3507,12 @@ var require_graceful_fs = __commonJS({
         m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
         console.error(m);
       };
-    if (!fs17[gracefulQueue]) {
+    if (!fs20[gracefulQueue]) {
       queue = global[gracefulQueue] || [];
-      publishQueue(fs17, queue);
-      fs17.close = (function(fs$close) {
+      publishQueue(fs20, queue);
+      fs20.close = (function(fs$close) {
         function close(fd, cb) {
-          return fs$close.call(fs17, fd, function(err) {
+          return fs$close.call(fs20, fd, function(err) {
             if (!err) {
               resetQueue();
             }
@@ -3524,48 +3524,48 @@ var require_graceful_fs = __commonJS({
           value: fs$close
         });
         return close;
-      })(fs17.close);
-      fs17.closeSync = (function(fs$closeSync) {
+      })(fs20.close);
+      fs20.closeSync = (function(fs$closeSync) {
         function closeSync(fd) {
-          fs$closeSync.apply(fs17, arguments);
+          fs$closeSync.apply(fs20, arguments);
           resetQueue();
         }
         Object.defineProperty(closeSync, previousSymbol, {
           value: fs$closeSync
         });
         return closeSync;
-      })(fs17.closeSync);
+      })(fs20.closeSync);
       if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
         process.on("exit", function() {
-          debug(fs17[gracefulQueue]);
-          require("assert").equal(fs17[gracefulQueue].length, 0);
+          debug(fs20[gracefulQueue]);
+          require("assert").equal(fs20[gracefulQueue].length, 0);
         });
       }
     }
     var queue;
     if (!global[gracefulQueue]) {
-      publishQueue(global, fs17[gracefulQueue]);
-    }
-    module2.exports = patch(clone(fs17));
-    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs17.__patched) {
-      module2.exports = patch(fs17);
-      fs17.__patched = true;
-    }
-    function patch(fs18) {
-      polyfills(fs18);
-      fs18.gracefulify = patch;
-      fs18.createReadStream = createReadStream;
-      fs18.createWriteStream = createWriteStream;
-      var fs$readFile = fs18.readFile;
-      fs18.readFile = readFile2;
-      function readFile2(path5, options, cb) {
+      publishQueue(global, fs20[gracefulQueue]);
+    }
+    module2.exports = patch(clone(fs20));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs20.__patched) {
+      module2.exports = patch(fs20);
+      fs20.__patched = true;
+    }
+    function patch(fs21) {
+      polyfills(fs21);
+      fs21.gracefulify = patch;
+      fs21.createReadStream = createReadStream;
+      fs21.createWriteStream = createWriteStream;
+      var fs$readFile = fs21.readFile;
+      fs21.readFile = readFile;
+      function readFile(path4, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$readFile(path5, options, cb);
-        function go$readFile(path6, options2, cb2, startTime) {
-          return fs$readFile(path6, options2, function(err) {
+        return go$readFile(path4, options, cb);
+        function go$readFile(path5, options2, cb2, startTime) {
+          return fs$readFile(path5, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$readFile, [path6, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$readFile, [path5, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -3573,16 +3573,16 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$writeFile = fs18.writeFile;
-      fs18.writeFile = writeFile2;
-      function writeFile2(path5, data, options, cb) {
+      var fs$writeFile = fs21.writeFile;
+      fs21.writeFile = writeFile;
+      function writeFile(path4, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$writeFile(path5, data, options, cb);
-        function go$writeFile(path6, data2, options2, cb2, startTime) {
-          return fs$writeFile(path6, data2, options2, function(err) {
+        return go$writeFile(path4, data, options, cb);
+        function go$writeFile(path5, data2, options2, cb2, startTime) {
+          return fs$writeFile(path5, data2, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$writeFile, [path6, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$writeFile, [path5, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -3590,17 +3590,17 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$appendFile = fs18.appendFile;
+      var fs$appendFile = fs21.appendFile;
       if (fs$appendFile)
-        fs18.appendFile = appendFile;
-      function appendFile(path5, data, options, cb) {
+        fs21.appendFile = appendFile;
+      function appendFile(path4, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$appendFile(path5, data, options, cb);
-        function go$appendFile(path6, data2, options2, cb2, startTime) {
-          return fs$appendFile(path6, data2, options2, function(err) {
+        return go$appendFile(path4, data, options, cb);
+        function go$appendFile(path5, data2, options2, cb2, startTime) {
+          return fs$appendFile(path5, data2, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$appendFile, [path6, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$appendFile, [path5, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -3608,9 +3608,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$copyFile = fs18.copyFile;
+      var fs$copyFile = fs21.copyFile;
       if (fs$copyFile)
-        fs18.copyFile = copyFile;
+        fs21.copyFile = copyFile;
       function copyFile(src, dest, flags, cb) {
         if (typeof flags === "function") {
           cb = flags;
@@ -3628,34 +3628,34 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$readdir = fs18.readdir;
-      fs18.readdir = readdir2;
+      var fs$readdir = fs21.readdir;
+      fs21.readdir = readdir2;
       var noReaddirOptionVersions = /^v[0-5]\./;
-      function readdir2(path5, options, cb) {
+      function readdir2(path4, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path6, options2, cb2, startTime) {
-          return fs$readdir(path6, fs$readdirCallback(
-            path6,
+        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path5, options2, cb2, startTime) {
+          return fs$readdir(path5, fs$readdirCallback(
+            path5,
             options2,
             cb2,
             startTime
           ));
-        } : function go$readdir2(path6, options2, cb2, startTime) {
-          return fs$readdir(path6, options2, fs$readdirCallback(
-            path6,
+        } : function go$readdir2(path5, options2, cb2, startTime) {
+          return fs$readdir(path5, options2, fs$readdirCallback(
+            path5,
             options2,
             cb2,
             startTime
           ));
         };
-        return go$readdir(path5, options, cb);
-        function fs$readdirCallback(path6, options2, cb2, startTime) {
+        return go$readdir(path4, options, cb);
+        function fs$readdirCallback(path5, options2, cb2, startTime) {
           return function(err, files) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
               enqueue([
                 go$readdir,
-                [path6, options2, cb2],
+                [path5, options2, cb2],
                 err,
                 startTime || Date.now(),
                 Date.now()
@@ -3670,21 +3670,21 @@ var require_graceful_fs = __commonJS({
         }
       }
       if (process.version.substr(0, 4) === "v0.8") {
-        var legStreams = legacy(fs18);
+        var legStreams = legacy(fs21);
         ReadStream = legStreams.ReadStream;
         WriteStream = legStreams.WriteStream;
       }
-      var fs$ReadStream = fs18.ReadStream;
+      var fs$ReadStream = fs21.ReadStream;
       if (fs$ReadStream) {
         ReadStream.prototype = Object.create(fs$ReadStream.prototype);
         ReadStream.prototype.open = ReadStream$open;
       }
-      var fs$WriteStream = fs18.WriteStream;
+      var fs$WriteStream = fs21.WriteStream;
       if (fs$WriteStream) {
         WriteStream.prototype = Object.create(fs$WriteStream.prototype);
         WriteStream.prototype.open = WriteStream$open;
       }
-      Object.defineProperty(fs18, "ReadStream", {
+      Object.defineProperty(fs21, "ReadStream", {
         get: function() {
           return ReadStream;
         },
@@ -3694,7 +3694,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      Object.defineProperty(fs18, "WriteStream", {
+      Object.defineProperty(fs21, "WriteStream", {
         get: function() {
           return WriteStream;
         },
@@ -3705,7 +3705,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileReadStream = ReadStream;
-      Object.defineProperty(fs18, "FileReadStream", {
+      Object.defineProperty(fs21, "FileReadStream", {
         get: function() {
           return FileReadStream;
         },
@@ -3716,7 +3716,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileWriteStream = WriteStream;
-      Object.defineProperty(fs18, "FileWriteStream", {
+      Object.defineProperty(fs21, "FileWriteStream", {
         get: function() {
           return FileWriteStream;
         },
@@ -3726,7 +3726,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      function ReadStream(path5, options) {
+      function ReadStream(path4, options) {
         if (this instanceof ReadStream)
           return fs$ReadStream.apply(this, arguments), this;
         else
@@ -3746,7 +3746,7 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function WriteStream(path5, options) {
+      function WriteStream(path4, options) {
         if (this instanceof WriteStream)
           return fs$WriteStream.apply(this, arguments), this;
         else
@@ -3764,22 +3764,22 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function createReadStream(path5, options) {
-        return new fs18.ReadStream(path5, options);
+      function createReadStream(path4, options) {
+        return new fs21.ReadStream(path4, options);
       }
-      function createWriteStream(path5, options) {
-        return new fs18.WriteStream(path5, options);
+      function createWriteStream(path4, options) {
+        return new fs21.WriteStream(path4, options);
       }
-      var fs$open = fs18.open;
-      fs18.open = open2;
-      function open2(path5, flags, mode, cb) {
+      var fs$open = fs21.open;
+      fs21.open = open2;
+      function open2(path4, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
-        return go$open(path5, flags, mode, cb);
-        function go$open(path6, flags2, mode2, cb2, startTime) {
-          return fs$open(path6, flags2, mode2, function(err, fd) {
+        return go$open(path4, flags, mode, cb);
+        function go$open(path5, flags2, mode2, cb2, startTime) {
+          return fs$open(path5, flags2, mode2, function(err, fd) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$open, [path6, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$open, [path5, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -3787,20 +3787,20 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      return fs18;
+      return fs21;
     }
     function enqueue(elem) {
       debug("ENQUEUE", elem[0].name, elem[1]);
-      fs17[gracefulQueue].push(elem);
+      fs20[gracefulQueue].push(elem);
       retry();
     }
     var retryTimer;
     function resetQueue() {
       var now = Date.now();
-      for (var i = 0; i < fs17[gracefulQueue].length; ++i) {
-        if (fs17[gracefulQueue][i].length > 2) {
-          fs17[gracefulQueue][i][3] = now;
-          fs17[gracefulQueue][i][4] = now;
+      for (var i = 0; i < fs20[gracefulQueue].length; ++i) {
+        if (fs20[gracefulQueue][i].length > 2) {
+          fs20[gracefulQueue][i][3] = now;
+          fs20[gracefulQueue][i][4] = now;
         }
       }
       retry();
@@ -3808,9 +3808,9 @@ var require_graceful_fs = __commonJS({
     function retry() {
       clearTimeout(retryTimer);
       retryTimer = void 0;
-      if (fs17[gracefulQueue].length === 0)
+      if (fs20[gracefulQueue].length === 0)
         return;
-      var elem = fs17[gracefulQueue].shift();
+      var elem = fs20[gracefulQueue].shift();
       var fn = elem[0];
       var args = elem[1];
       var err = elem[2];
@@ -3832,7 +3832,7 @@ var require_graceful_fs = __commonJS({
           debug("RETRY", fn.name, args);
           fn.apply(null, args.concat([startTime]));
         } else {
-          fs17[gracefulQueue].push(elem);
+          fs20[gracefulQueue].push(elem);
         }
       }
       if (retryTimer === void 0) {
@@ -3847,7 +3847,7 @@ var require_fs = __commonJS({
   "node_modules/fs-extra/lib/fs/index.js"(exports2) {
     "use strict";
     var u = require_universalify().fromCallback;
-    var fs17 = require_graceful_fs();
+    var fs20 = require_graceful_fs();
     var api = [
       "access",
       "appendFile",
@@ -3888,26 +3888,26 @@ var require_fs = __commonJS({
       "utimes",
       "writeFile"
     ].filter((key) => {
-      return typeof fs17[key] === "function";
+      return typeof fs20[key] === "function";
     });
-    Object.assign(exports2, fs17);
+    Object.assign(exports2, fs20);
     api.forEach((method) => {
-      exports2[method] = u(fs17[method]);
+      exports2[method] = u(fs20[method]);
     });
     exports2.exists = function(filename, callback) {
       if (typeof callback === "function") {
-        return fs17.exists(filename, callback);
+        return fs20.exists(filename, callback);
       }
       return new Promise((resolve) => {
-        return fs17.exists(filename, resolve);
+        return fs20.exists(filename, resolve);
       });
     };
     exports2.read = function(fd, buffer, offset, length, position, callback) {
       if (typeof callback === "function") {
-        return fs17.read(fd, buffer, offset, length, position, callback);
+        return fs20.read(fd, buffer, offset, length, position, callback);
       }
       return new Promise((resolve, reject) => {
-        fs17.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
+        fs20.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
           if (err) return reject(err);
           resolve({ bytesRead, buffer: buffer2 });
         });
@@ -3915,10 +3915,10 @@ var require_fs = __commonJS({
     };
     exports2.write = function(fd, buffer, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs17.write(fd, buffer, ...args);
+        return fs20.write(fd, buffer, ...args);
       }
       return new Promise((resolve, reject) => {
-        fs17.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
+        fs20.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
           if (err) return reject(err);
           resolve({ bytesWritten, buffer: buffer2 });
         });
@@ -3926,10 +3926,10 @@ var require_fs = __commonJS({
     };
     exports2.readv = function(fd, buffers, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs17.readv(fd, buffers, ...args);
+        return fs20.readv(fd, buffers, ...args);
       }
       return new Promise((resolve, reject) => {
-        fs17.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
+        fs20.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
           if (err) return reject(err);
           resolve({ bytesRead, buffers: buffers2 });
         });
@@ -3937,17 +3937,17 @@ var require_fs = __commonJS({
     };
     exports2.writev = function(fd, buffers, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs17.writev(fd, buffers, ...args);
+        return fs20.writev(fd, buffers, ...args);
       }
       return new Promise((resolve, reject) => {
-        fs17.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
+        fs20.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
           if (err) return reject(err);
           resolve({ bytesWritten, buffers: buffers2 });
         });
       });
     };
-    if (typeof fs17.realpath.native === "function") {
-      exports2.realpath.native = u(fs17.realpath.native);
+    if (typeof fs20.realpath.native === "function") {
+      exports2.realpath.native = u(fs20.realpath.native);
     } else {
       process.emitWarning(
         "fs.realpath.native is not a function. Is fs being monkey-patched?",
@@ -3962,10 +3962,10 @@ var require_fs = __commonJS({
 var require_utils = __commonJS({
   "node_modules/fs-extra/lib/mkdirs/utils.js"(exports2, module2) {
     "use strict";
-    var path5 = require("path");
+    var path4 = require("path");
     module2.exports.checkPath = function checkPath(pth) {
       if (process.platform === "win32") {
-        const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path5.parse(pth).root, ""));
+        const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path4.parse(pth).root, ""));
         if (pathHasInvalidWinCharacters) {
           const error = new Error(`Path contains invalid characters: ${pth}`);
           error.code = "EINVAL";
@@ -3980,7 +3980,7 @@ var require_utils = __commonJS({
 var require_make_dir = __commonJS({
   "node_modules/fs-extra/lib/mkdirs/make-dir.js"(exports2, module2) {
     "use strict";
-    var fs17 = require_fs();
+    var fs20 = require_fs();
     var { checkPath } = require_utils();
     var getMode = (options) => {
       const defaults2 = { mode: 511 };
@@ -3989,14 +3989,14 @@ var require_make_dir = __commonJS({
     };
     module2.exports.makeDir = async (dir, options) => {
       checkPath(dir);
-      return fs17.mkdir(dir, {
+      return fs20.mkdir(dir, {
         mode: getMode(options),
         recursive: true
       });
     };
     module2.exports.makeDirSync = (dir, options) => {
       checkPath(dir);
-      return fs17.mkdirSync(dir, {
+      return fs20.mkdirSync(dir, {
         mode: getMode(options),
         recursive: true
       });
@@ -4028,13 +4028,13 @@ var require_path_exists = __commonJS({
   "node_modules/fs-extra/lib/path-exists/index.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs17 = require_fs();
-    function pathExists2(path5) {
-      return fs17.access(path5).then(() => true).catch(() => false);
+    var fs20 = require_fs();
+    function pathExists(path4) {
+      return fs20.access(path4).then(() => true).catch(() => false);
     }
     module2.exports = {
-      pathExists: u(pathExists2),
-      pathExistsSync: fs17.existsSync
+      pathExists: u(pathExists),
+      pathExistsSync: fs20.existsSync
     };
   }
 });
@@ -4043,16 +4043,16 @@ var require_path_exists = __commonJS({
 var require_utimes = __commonJS({
   "node_modules/fs-extra/lib/util/utimes.js"(exports2, module2) {
     "use strict";
-    var fs17 = require_fs();
+    var fs20 = require_fs();
     var u = require_universalify().fromPromise;
-    async function utimesMillis(path5, atime, mtime) {
-      const fd = await fs17.open(path5, "r+");
+    async function utimesMillis(path4, atime, mtime) {
+      const fd = await fs20.open(path4, "r+");
       let closeErr = null;
       try {
-        await fs17.futimes(fd, atime, mtime);
+        await fs20.futimes(fd, atime, mtime);
       } finally {
         try {
-          await fs17.close(fd);
+          await fs20.close(fd);
         } catch (e) {
           closeErr = e;
         }
@@ -4061,10 +4061,10 @@ var require_utimes = __commonJS({
         throw closeErr;
       }
     }
-    function utimesMillisSync(path5, atime, mtime) {
-      const fd = fs17.openSync(path5, "r+");
-      fs17.futimesSync(fd, atime, mtime);
-      return fs17.closeSync(fd);
+    function utimesMillisSync(path4, atime, mtime) {
+      const fd = fs20.openSync(path4, "r+");
+      fs20.futimesSync(fd, atime, mtime);
+      return fs20.closeSync(fd);
     }
     module2.exports = {
       utimesMillis: u(utimesMillis),
@@ -4077,11 +4077,11 @@ var require_utimes = __commonJS({
 var require_stat = __commonJS({
   "node_modules/fs-extra/lib/util/stat.js"(exports2, module2) {
     "use strict";
-    var fs17 = require_fs();
-    var path5 = require("path");
+    var fs20 = require_fs();
+    var path4 = require("path");
     var u = require_universalify().fromPromise;
     function getStats(src, dest, opts) {
-      const statFunc = opts.dereference ? (file) => fs17.stat(file, { bigint: true }) : (file) => fs17.lstat(file, { bigint: true });
+      const statFunc = opts.dereference ? (file) => fs20.stat(file, { bigint: true }) : (file) => fs20.lstat(file, { bigint: true });
       return Promise.all([
         statFunc(src),
         statFunc(dest).catch((err) => {
@@ -4092,7 +4092,7 @@ var require_stat = __commonJS({
     }
     function getStatsSync(src, dest, opts) {
       let destStat;
-      const statFunc = opts.dereference ? (file) => fs17.statSync(file, { bigint: true }) : (file) => fs17.lstatSync(file, { bigint: true });
+      const statFunc = opts.dereference ? (file) => fs20.statSync(file, { bigint: true }) : (file) => fs20.lstatSync(file, { bigint: true });
       const srcStat = statFunc(src);
       try {
         destStat = statFunc(dest);
@@ -4106,8 +4106,8 @@ var require_stat = __commonJS({
       const { srcStat, destStat } = await getStats(src, dest, opts);
       if (destStat) {
         if (areIdentical(srcStat, destStat)) {
-          const srcBaseName = path5.basename(src);
-          const destBaseName = path5.basename(dest);
+          const srcBaseName = path4.basename(src);
+          const destBaseName = path4.basename(dest);
           if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
             return { srcStat, destStat, isChangingCase: true };
           }
@@ -4129,8 +4129,8 @@ var require_stat = __commonJS({
       const { srcStat, destStat } = getStatsSync(src, dest, opts);
       if (destStat) {
         if (areIdentical(srcStat, destStat)) {
-          const srcBaseName = path5.basename(src);
-          const destBaseName = path5.basename(dest);
+          const srcBaseName = path4.basename(src);
+          const destBaseName = path4.basename(dest);
           if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
             return { srcStat, destStat, isChangingCase: true };
           }
@@ -4149,12 +4149,12 @@ var require_stat = __commonJS({
       return { srcStat, destStat };
     }
     async function checkParentPaths(src, srcStat, dest, funcName) {
-      const srcParent = path5.resolve(path5.dirname(src));
-      const destParent = path5.resolve(path5.dirname(dest));
-      if (destParent === srcParent || destParent === path5.parse(destParent).root) return;
+      const srcParent = path4.resolve(path4.dirname(src));
+      const destParent = path4.resolve(path4.dirname(dest));
+      if (destParent === srcParent || destParent === path4.parse(destParent).root) return;
       let destStat;
       try {
-        destStat = await fs17.stat(destParent, { bigint: true });
+        destStat = await fs20.stat(destParent, { bigint: true });
       } catch (err) {
         if (err.code === "ENOENT") return;
         throw err;
@@ -4165,12 +4165,12 @@ var require_stat = __commonJS({
       return checkParentPaths(src, srcStat, destParent, funcName);
     }
     function checkParentPathsSync(src, srcStat, dest, funcName) {
-      const srcParent = path5.resolve(path5.dirname(src));
-      const destParent = path5.resolve(path5.dirname(dest));
-      if (destParent === srcParent || destParent === path5.parse(destParent).root) return;
+      const srcParent = path4.resolve(path4.dirname(src));
+      const destParent = path4.resolve(path4.dirname(dest));
+      if (destParent === srcParent || destParent === path4.parse(destParent).root) return;
       let destStat;
       try {
-        destStat = fs17.statSync(destParent, { bigint: true });
+        destStat = fs20.statSync(destParent, { bigint: true });
       } catch (err) {
         if (err.code === "ENOENT") return;
         throw err;
@@ -4184,8 +4184,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 = path5.resolve(src).split(path5.sep).filter((i) => i);
-      const destArr = path5.resolve(dest).split(path5.sep).filter((i) => i);
+      const srcArr = path4.resolve(src).split(path4.sep).filter((i) => i);
+      const destArr = path4.resolve(dest).split(path4.sep).filter((i) => i);
       return srcArr.every((cur, i) => destArr[i] === cur);
     }
     function errMsg(src, dest, funcName) {
@@ -4237,10 +4237,10 @@ var require_async = __commonJS({
 var require_copy = __commonJS({
   "node_modules/fs-extra/lib/copy/copy.js"(exports2, module2) {
     "use strict";
-    var fs17 = require_fs();
-    var path5 = require("path");
+    var fs20 = require_fs();
+    var path4 = require("path");
     var { mkdirs } = require_mkdirs();
-    var { pathExists: pathExists2 } = require_path_exists();
+    var { pathExists } = require_path_exists();
     var { utimesMillis } = require_utimes();
     var stat = require_stat();
     var { asyncIteratorConcurrentProcess } = require_async();
@@ -4261,8 +4261,8 @@ var require_copy = __commonJS({
       await stat.checkParentPaths(src, srcStat, dest, "copy");
       const include = await runFilter(src, dest, opts);
       if (!include) return;
-      const destParent = path5.dirname(dest);
-      const dirExists = await pathExists2(destParent);
+      const destParent = path4.dirname(dest);
+      const dirExists = await pathExists(destParent);
       if (!dirExists) {
         await mkdirs(destParent);
       }
@@ -4273,7 +4273,7 @@ var require_copy = __commonJS({
       return opts.filter(src, dest);
     }
     async function getStatsAndPerformCopy(destStat, src, dest, opts) {
-      const statFn = opts.dereference ? fs17.stat : fs17.lstat;
+      const statFn = opts.dereference ? fs20.stat : fs20.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);
@@ -4285,7 +4285,7 @@ var require_copy = __commonJS({
     async function onFile(srcStat, destStat, src, dest, opts) {
       if (!destStat) return copyFile(srcStat, src, dest, opts);
       if (opts.overwrite) {
-        await fs17.unlink(dest);
+        await fs20.unlink(dest);
         return copyFile(srcStat, src, dest, opts);
       }
       if (opts.errorOnExist) {
@@ -4293,29 +4293,29 @@ var require_copy = __commonJS({
       }
     }
     async function copyFile(srcStat, src, dest, opts) {
-      await fs17.copyFile(src, dest);
+      await fs20.copyFile(src, dest);
       if (opts.preserveTimestamps) {
         if (fileIsNotWritable(srcStat.mode)) {
           await makeFileWritable(dest, srcStat.mode);
         }
-        const updatedSrcStat = await fs17.stat(src);
+        const updatedSrcStat = await fs20.stat(src);
         await utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
       }
-      return fs17.chmod(dest, srcStat.mode);
+      return fs20.chmod(dest, srcStat.mode);
     }
     function fileIsNotWritable(srcMode) {
       return (srcMode & 128) === 0;
     }
     function makeFileWritable(dest, srcMode) {
-      return fs17.chmod(dest, srcMode | 128);
+      return fs20.chmod(dest, srcMode | 128);
     }
     async function onDir(srcStat, destStat, src, dest, opts) {
       if (!destStat) {
-        await fs17.mkdir(dest);
+        await fs20.mkdir(dest);
       }
-      await asyncIteratorConcurrentProcess(await fs17.opendir(src), async (item) => {
-        const srcItem = path5.join(src, item.name);
-        const destItem = path5.join(dest, item.name);
+      await asyncIteratorConcurrentProcess(await fs20.opendir(src), async (item) => {
+        const srcItem = path4.join(src, item.name);
+        const destItem = path4.join(dest, item.name);
         const include = await runFilter(srcItem, destItem, opts);
         if (include) {
           const { destStat: destStat2 } = await stat.checkPaths(srcItem, destItem, "copy", opts);
@@ -4323,26 +4323,26 @@ var require_copy = __commonJS({
         }
       });
       if (!destStat) {
-        await fs17.chmod(dest, srcStat.mode);
+        await fs20.chmod(dest, srcStat.mode);
       }
     }
     async function onLink(destStat, src, dest, opts) {
-      let resolvedSrc = await fs17.readlink(src);
+      let resolvedSrc = await fs20.readlink(src);
       if (opts.dereference) {
-        resolvedSrc = path5.resolve(process.cwd(), resolvedSrc);
+        resolvedSrc = path4.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
-        return fs17.symlink(resolvedSrc, dest);
+        return fs20.symlink(resolvedSrc, dest);
       }
       let resolvedDest = null;
       try {
-        resolvedDest = await fs17.readlink(dest);
+        resolvedDest = await fs20.readlink(dest);
       } catch (e) {
-        if (e.code === "EINVAL" || e.code === "UNKNOWN") return fs17.symlink(resolvedSrc, dest);
+        if (e.code === "EINVAL" || e.code === "UNKNOWN") return fs20.symlink(resolvedSrc, dest);
         throw e;
       }
       if (opts.dereference) {
-        resolvedDest = path5.resolve(process.cwd(), resolvedDest);
+        resolvedDest = path4.resolve(process.cwd(), resolvedDest);
       }
       if (resolvedSrc !== resolvedDest) {
         if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
@@ -4352,8 +4352,8 @@ var require_copy = __commonJS({
           throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
         }
       }
-      await fs17.unlink(dest);
-      return fs17.symlink(resolvedSrc, dest);
+      await fs20.unlink(dest);
+      return fs20.symlink(resolvedSrc, dest);
     }
     module2.exports = copy;
   }
@@ -4363,8 +4363,8 @@ var require_copy = __commonJS({
 var require_copy_sync = __commonJS({
   "node_modules/fs-extra/lib/copy/copy-sync.js"(exports2, module2) {
     "use strict";
-    var fs17 = require_graceful_fs();
-    var path5 = require("path");
+    var fs20 = require_graceful_fs();
+    var path4 = require("path");
     var mkdirsSync = require_mkdirs().mkdirsSync;
     var utimesMillisSync = require_utimes().utimesMillisSync;
     var stat = require_stat();
@@ -4385,12 +4385,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 = path5.dirname(dest);
-      if (!fs17.existsSync(destParent)) mkdirsSync(destParent);
+      const destParent = path4.dirname(dest);
+      if (!fs20.existsSync(destParent)) mkdirsSync(destParent);
       return getStats(destStat, src, dest, opts);
     }
     function getStats(destStat, src, dest, opts) {
-      const statSync = opts.dereference ? fs17.statSync : fs17.lstatSync;
+      const statSync = opts.dereference ? fs20.statSync : fs20.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);
@@ -4405,14 +4405,14 @@ var require_copy_sync = __commonJS({
     }
     function mayCopyFile(srcStat, src, dest, opts) {
       if (opts.overwrite) {
-        fs17.unlinkSync(dest);
+        fs20.unlinkSync(dest);
         return copyFile(srcStat, src, dest, opts);
       } else if (opts.errorOnExist) {
         throw new Error(`'${dest}' already exists`);
       }
     }
     function copyFile(srcStat, src, dest, opts) {
-      fs17.copyFileSync(src, dest);
+      fs20.copyFileSync(src, dest);
       if (opts.preserveTimestamps) handleTimestamps(srcStat.mode, src, dest);
       return setDestMode(dest, srcStat.mode);
     }
@@ -4427,10 +4427,10 @@ var require_copy_sync = __commonJS({
       return setDestMode(dest, srcMode | 128);
     }
     function setDestMode(dest, srcMode) {
-      return fs17.chmodSync(dest, srcMode);
+      return fs20.chmodSync(dest, srcMode);
     }
     function setDestTimestamps(src, dest) {
-      const updatedSrcStat = fs17.statSync(src);
+      const updatedSrcStat = fs20.statSync(src);
       return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
     }
     function onDir(srcStat, destStat, src, dest, opts) {
@@ -4438,12 +4438,12 @@ var require_copy_sync = __commonJS({
       return copyDir(src, dest, opts);
     }
     function mkDirAndCopy(srcMode, src, dest, opts) {
-      fs17.mkdirSync(dest);
+      fs20.mkdirSync(dest);
       copyDir(src, dest, opts);
       return setDestMode(dest, srcMode);
     }
     function copyDir(src, dest, opts) {
-      const dir = fs17.opendirSync(src);
+      const dir = fs20.opendirSync(src);
       try {
         let dirent;
         while ((dirent = dir.readSync()) !== null) {
@@ -4454,29 +4454,29 @@ var require_copy_sync = __commonJS({
       }
     }
     function copyDirItem(item, src, dest, opts) {
-      const srcItem = path5.join(src, item);
-      const destItem = path5.join(dest, item);
+      const srcItem = path4.join(src, item);
+      const destItem = path4.join(dest, item);
       if (opts.filter && !opts.filter(srcItem, destItem)) return;
       const { destStat } = stat.checkPathsSync(srcItem, destItem, "copy", opts);
       return getStats(destStat, srcItem, destItem, opts);
     }
     function onLink(destStat, src, dest, opts) {
-      let resolvedSrc = fs17.readlinkSync(src);
+      let resolvedSrc = fs20.readlinkSync(src);
       if (opts.dereference) {
-        resolvedSrc = path5.resolve(process.cwd(), resolvedSrc);
+        resolvedSrc = path4.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
-        return fs17.symlinkSync(resolvedSrc, dest);
+        return fs20.symlinkSync(resolvedSrc, dest);
       } else {
         let resolvedDest;
         try {
-          resolvedDest = fs17.readlinkSync(dest);
+          resolvedDest = fs20.readlinkSync(dest);
         } catch (err) {
-          if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs17.symlinkSync(resolvedSrc, dest);
+          if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs20.symlinkSync(resolvedSrc, dest);
           throw err;
         }
         if (opts.dereference) {
-          resolvedDest = path5.resolve(process.cwd(), resolvedDest);
+          resolvedDest = path4.resolve(process.cwd(), resolvedDest);
         }
         if (resolvedSrc !== resolvedDest) {
           if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
@@ -4490,8 +4490,8 @@ var require_copy_sync = __commonJS({
       }
     }
     function copyLink(resolvedSrc, dest) {
-      fs17.unlinkSync(dest);
-      return fs17.symlinkSync(resolvedSrc, dest);
+      fs20.unlinkSync(dest);
+      return fs20.symlinkSync(resolvedSrc, dest);
     }
     module2.exports = copySync;
   }
@@ -4513,16 +4513,16 @@ var require_copy2 = __commonJS({
 var require_remove = __commonJS({
   "node_modules/fs-extra/lib/remove/index.js"(exports2, module2) {
     "use strict";
-    var fs17 = require_graceful_fs();
+    var fs20 = require_graceful_fs();
     var u = require_universalify().fromCallback;
-    function remove2(path5, callback) {
-      fs17.rm(path5, { recursive: true, force: true }, callback);
+    function remove(path4, callback) {
+      fs20.rm(path4, { recursive: true, force: true }, callback);
     }
-    function removeSync(path5) {
-      fs17.rmSync(path5, { recursive: true, force: true });
+    function removeSync(path4) {
+      fs20.rmSync(path4, { recursive: true, force: true });
     }
     module2.exports = {
-      remove: u(remove2),
+      remove: u(remove),
       removeSync
     };
   }
@@ -4533,29 +4533,29 @@ var require_empty = __commonJS({
   "node_modules/fs-extra/lib/empty/index.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs17 = require_fs();
-    var path5 = require("path");
+    var fs20 = require_fs();
+    var path4 = require("path");
     var mkdir = require_mkdirs();
-    var remove2 = require_remove();
+    var remove = require_remove();
     var emptyDir = u(async function emptyDir2(dir) {
       let items;
       try {
-        items = await fs17.readdir(dir);
+        items = await fs20.readdir(dir);
       } catch {
         return mkdir.mkdirs(dir);
       }
-      return Promise.all(items.map((item) => remove2.remove(path5.join(dir, item))));
+      return Promise.all(items.map((item) => remove.remove(path4.join(dir, item))));
     });
     function emptyDirSync(dir) {
       let items;
       try {
-        items = fs17.readdirSync(dir);
+        items = fs20.readdirSync(dir);
       } catch {
         return mkdir.mkdirsSync(dir);
       }
       items.forEach((item) => {
-        item = path5.join(dir, item);
-        remove2.removeSync(item);
+        item = path4.join(dir, item);
+        remove.removeSync(item);
       });
     }
     module2.exports = {
@@ -4572,52 +4572,52 @@ var require_file = __commonJS({
   "node_modules/fs-extra/lib/ensure/file.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var path5 = require("path");
-    var fs17 = require_fs();
+    var path4 = require("path");
+    var fs20 = require_fs();
     var mkdir = require_mkdirs();
     async function createFile(file) {
       let stats;
       try {
-        stats = await fs17.stat(file);
+        stats = await fs20.stat(file);
       } catch {
       }
       if (stats && stats.isFile()) return;
-      const dir = path5.dirname(file);
+      const dir = path4.dirname(file);
       let dirStats = null;
       try {
-        dirStats = await fs17.stat(dir);
+        dirStats = await fs20.stat(dir);
       } catch (err) {
         if (err.code === "ENOENT") {
           await mkdir.mkdirs(dir);
-          await fs17.writeFile(file, "");
+          await fs20.writeFile(file, "");
           return;
         } else {
           throw err;
         }
       }
       if (dirStats.isDirectory()) {
-        await fs17.writeFile(file, "");
+        await fs20.writeFile(file, "");
       } else {
-        await fs17.readdir(dir);
+        await fs20.readdir(dir);
       }
     }
     function createFileSync(file) {
       let stats;
       try {
-        stats = fs17.statSync(file);
+        stats = fs20.statSync(file);
       } catch {
       }
       if (stats && stats.isFile()) return;
-      const dir = path5.dirname(file);
+      const dir = path4.dirname(file);
       try {
-        if (!fs17.statSync(dir).isDirectory()) {
-          fs17.readdirSync(dir);
+        if (!fs20.statSync(dir).isDirectory()) {
+          fs20.readdirSync(dir);
         }
       } catch (err) {
         if (err && err.code === "ENOENT") mkdir.mkdirsSync(dir);
         else throw err;
       }
-      fs17.writeFileSync(file, "");
+      fs20.writeFileSync(file, "");
     }
     module2.exports = {
       createFile: u(createFile),
@@ -4631,50 +4631,50 @@ var require_link = __commonJS({
   "node_modules/fs-extra/lib/ensure/link.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var path5 = require("path");
-    var fs17 = require_fs();
+    var path4 = require("path");
+    var fs20 = require_fs();
     var mkdir = require_mkdirs();
-    var { pathExists: pathExists2 } = require_path_exists();
+    var { pathExists } = require_path_exists();
     var { areIdentical } = require_stat();
     async function createLink(srcpath, dstpath) {
       let dstStat;
       try {
-        dstStat = await fs17.lstat(dstpath);
+        dstStat = await fs20.lstat(dstpath);
       } catch {
       }
       let srcStat;
       try {
-        srcStat = await fs17.lstat(srcpath);
+        srcStat = await fs20.lstat(srcpath);
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureLink");
         throw err;
       }
       if (dstStat && areIdentical(srcStat, dstStat)) return;
-      const dir = path5.dirname(dstpath);
-      const dirExists = await pathExists2(dir);
+      const dir = path4.dirname(dstpath);
+      const dirExists = await pathExists(dir);
       if (!dirExists) {
         await mkdir.mkdirs(dir);
       }
-      await fs17.link(srcpath, dstpath);
+      await fs20.link(srcpath, dstpath);
     }
     function createLinkSync(srcpath, dstpath) {
       let dstStat;
       try {
-        dstStat = fs17.lstatSync(dstpath);
+        dstStat = fs20.lstatSync(dstpath);
       } catch {
       }
       try {
-        const srcStat = fs17.lstatSync(srcpath);
+        const srcStat = fs20.lstatSync(srcpath);
         if (dstStat && areIdentical(srcStat, dstStat)) return;
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureLink");
         throw err;
       }
-      const dir = path5.dirname(dstpath);
-      const dirExists = fs17.existsSync(dir);
-      if (dirExists) return fs17.linkSync(srcpath, dstpath);
+      const dir = path4.dirname(dstpath);
+      const dirExists = fs20.existsSync(dir);
+      if (dirExists) return fs20.linkSync(srcpath, dstpath);
       mkdir.mkdirsSync(dir);
-      return fs17.linkSync(srcpath, dstpath);
+      return fs20.linkSync(srcpath, dstpath);
     }
     module2.exports = {
       createLink: u(createLink),
@@ -4687,14 +4687,14 @@ var require_link = __commonJS({
 var require_symlink_paths = __commonJS({
   "node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports2, module2) {
     "use strict";
-    var path5 = require("path");
-    var fs17 = require_fs();
-    var { pathExists: pathExists2 } = require_path_exists();
+    var path4 = require("path");
+    var fs20 = require_fs();
+    var { pathExists } = require_path_exists();
     var u = require_universalify().fromPromise;
     async function symlinkPaths(srcpath, dstpath) {
-      if (path5.isAbsolute(srcpath)) {
+      if (path4.isAbsolute(srcpath)) {
         try {
-          await fs17.lstat(srcpath);
+          await fs20.lstat(srcpath);
         } catch (err) {
           err.message = err.message.replace("lstat", "ensureSymlink");
           throw err;
@@ -4704,9 +4704,9 @@ var require_symlink_paths = __commonJS({
           toDst: srcpath
         };
       }
-      const dstdir = path5.dirname(dstpath);
-      const relativeToDst = path5.join(dstdir, srcpath);
-      const exists = await pathExists2(relativeToDst);
+      const dstdir = path4.dirname(dstpath);
+      const relativeToDst = path4.join(dstdir, srcpath);
+      const exists = await pathExists(relativeToDst);
       if (exists) {
         return {
           toCwd: relativeToDst,
@@ -4714,39 +4714,39 @@ var require_symlink_paths = __commonJS({
         };
       }
       try {
-        await fs17.lstat(srcpath);
+        await fs20.lstat(srcpath);
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureSymlink");
         throw err;
       }
       return {
         toCwd: srcpath,
-        toDst: path5.relative(dstdir, srcpath)
+        toDst: path4.relative(dstdir, srcpath)
       };
     }
     function symlinkPathsSync(srcpath, dstpath) {
-      if (path5.isAbsolute(srcpath)) {
-        const exists2 = fs17.existsSync(srcpath);
+      if (path4.isAbsolute(srcpath)) {
+        const exists2 = fs20.existsSync(srcpath);
         if (!exists2) throw new Error("absolute srcpath does not exist");
         return {
           toCwd: srcpath,
           toDst: srcpath
         };
       }
-      const dstdir = path5.dirname(dstpath);
-      const relativeToDst = path5.join(dstdir, srcpath);
-      const exists = fs17.existsSync(relativeToDst);
+      const dstdir = path4.dirname(dstpath);
+      const relativeToDst = path4.join(dstdir, srcpath);
+      const exists = fs20.existsSync(relativeToDst);
       if (exists) {
         return {
           toCwd: relativeToDst,
           toDst: srcpath
         };
       }
-      const srcExists = fs17.existsSync(srcpath);
+      const srcExists = fs20.existsSync(srcpath);
       if (!srcExists) throw new Error("relative srcpath does not exist");
       return {
         toCwd: srcpath,
-        toDst: path5.relative(dstdir, srcpath)
+        toDst: path4.relative(dstdir, srcpath)
       };
     }
     module2.exports = {
@@ -4760,13 +4760,13 @@ var require_symlink_paths = __commonJS({
 var require_symlink_type = __commonJS({
   "node_modules/fs-extra/lib/ensure/symlink-type.js"(exports2, module2) {
     "use strict";
-    var fs17 = require_fs();
+    var fs20 = require_fs();
     var u = require_universalify().fromPromise;
     async function symlinkType(srcpath, type) {
       if (type) return type;
       let stats;
       try {
-        stats = await fs17.lstat(srcpath);
+        stats = await fs20.lstat(srcpath);
       } catch {
         return "file";
       }
@@ -4776,7 +4776,7 @@ var require_symlink_type = __commonJS({
       if (type) return type;
       let stats;
       try {
-        stats = fs17.lstatSync(srcpath);
+        stats = fs20.lstatSync(srcpath);
       } catch {
         return "file";
       }
@@ -4794,54 +4794,54 @@ var require_symlink = __commonJS({
   "node_modules/fs-extra/lib/ensure/symlink.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var path5 = require("path");
-    var fs17 = require_fs();
+    var path4 = require("path");
+    var fs20 = require_fs();
     var { mkdirs, mkdirsSync } = require_mkdirs();
     var { symlinkPaths, symlinkPathsSync } = require_symlink_paths();
     var { symlinkType, symlinkTypeSync } = require_symlink_type();
-    var { pathExists: pathExists2 } = require_path_exists();
+    var { pathExists } = require_path_exists();
     var { areIdentical } = require_stat();
     async function createSymlink(srcpath, dstpath, type) {
       let stats;
       try {
-        stats = await fs17.lstat(dstpath);
+        stats = await fs20.lstat(dstpath);
       } catch {
       }
       if (stats && stats.isSymbolicLink()) {
         const [srcStat, dstStat] = await Promise.all([
-          fs17.stat(srcpath),
-          fs17.stat(dstpath)
+          fs20.stat(srcpath),
+          fs20.stat(dstpath)
         ]);
         if (areIdentical(srcStat, dstStat)) return;
       }
       const relative2 = await symlinkPaths(srcpath, dstpath);
       srcpath = relative2.toDst;
       const toType = await symlinkType(relative2.toCwd, type);
-      const dir = path5.dirname(dstpath);
-      if (!await pathExists2(dir)) {
+      const dir = path4.dirname(dstpath);
+      if (!await pathExists(dir)) {
         await mkdirs(dir);
       }
-      return fs17.symlink(srcpath, dstpath, toType);
+      return fs20.symlink(srcpath, dstpath, toType);
     }
     function createSymlinkSync(srcpath, dstpath, type) {
       let stats;
       try {
-        stats = fs17.lstatSync(dstpath);
+        stats = fs20.lstatSync(dstpath);
       } catch {
       }
       if (stats && stats.isSymbolicLink()) {
-        const srcStat = fs17.statSync(srcpath);
-        const dstStat = fs17.statSync(dstpath);
+        const srcStat = fs20.statSync(srcpath);
+        const dstStat = fs20.statSync(dstpath);
         if (areIdentical(srcStat, dstStat)) return;
       }
       const relative2 = symlinkPathsSync(srcpath, dstpath);
       srcpath = relative2.toDst;
       type = symlinkTypeSync(relative2.toCwd, type);
-      const dir = path5.dirname(dstpath);
-      const exists = fs17.existsSync(dir);
-      if (exists) return fs17.symlinkSync(srcpath, dstpath, type);
+      const dir = path4.dirname(dstpath);
+      const exists = fs20.existsSync(dir);
+      if (exists) return fs20.symlinkSync(srcpath, dstpath, type);
       mkdirsSync(dir);
-      return fs17.symlinkSync(srcpath, dstpath, type);
+      return fs20.symlinkSync(srcpath, dstpath, type);
     }
     module2.exports = {
       createSymlink: u(createSymlink),
@@ -4910,9 +4910,9 @@ var require_jsonfile = __commonJS({
       if (typeof options === "string") {
         options = { encoding: options };
       }
-      const fs17 = options.fs || _fs;
+      const fs20 = options.fs || _fs;
       const shouldThrow = "throws" in options ? options.throws : true;
-      let data = await universalify.fromCallback(fs17.readFile)(file, options);
+      let data = await universalify.fromCallback(fs20.readFile)(file, options);
       data = stripBom(data);
       let obj;
       try {
@@ -4927,15 +4927,15 @@ var require_jsonfile = __commonJS({
       }
       return obj;
     }
-    var readFile2 = universalify.fromPromise(_readFile);
+    var readFile = universalify.fromPromise(_readFile);
     function readFileSync5(file, options = {}) {
       if (typeof options === "string") {
         options = { encoding: options };
       }
-      const fs17 = options.fs || _fs;
+      const fs20 = options.fs || _fs;
       const shouldThrow = "throws" in options ? options.throws : true;
       try {
-        let content = fs17.readFileSync(file, options);
+        let content = fs20.readFileSync(file, options);
         content = stripBom(content);
         return JSON.parse(content, options.reviver);
       } catch (err) {
@@ -4948,20 +4948,20 @@ var require_jsonfile = __commonJS({
       }
     }
     async function _writeFile(file, obj, options = {}) {
-      const fs17 = options.fs || _fs;
+      const fs20 = options.fs || _fs;
       const str = stringify2(obj, options);
-      await universalify.fromCallback(fs17.writeFile)(file, str, options);
+      await universalify.fromCallback(fs20.writeFile)(file, str, options);
     }
-    var writeFile2 = universalify.fromPromise(_writeFile);
+    var writeFile = universalify.fromPromise(_writeFile);
     function writeFileSync3(file, obj, options = {}) {
-      const fs17 = options.fs || _fs;
+      const fs20 = options.fs || _fs;
       const str = stringify2(obj, options);
-      return fs17.writeFileSync(file, str, options);
+      return fs20.writeFileSync(file, str, options);
     }
     module2.exports = {
-      readFile: readFile2,
+      readFile,
       readFileSync: readFileSync5,
-      writeFile: writeFile2,
+      writeFile,
       writeFileSync: writeFileSync3
     };
   }
@@ -4987,23 +4987,23 @@ var require_output_file = __commonJS({
   "node_modules/fs-extra/lib/output-file/index.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs17 = require_fs();
-    var path5 = require("path");
+    var fs20 = require_fs();
+    var path4 = require("path");
     var mkdir = require_mkdirs();
-    var pathExists2 = require_path_exists().pathExists;
+    var pathExists = require_path_exists().pathExists;
     async function outputFile(file, data, encoding = "utf-8") {
-      const dir = path5.dirname(file);
-      if (!await pathExists2(dir)) {
+      const dir = path4.dirname(file);
+      if (!await pathExists(dir)) {
         await mkdir.mkdirs(dir);
       }
-      return fs17.writeFile(file, data, encoding);
+      return fs20.writeFile(file, data, encoding);
     }
     function outputFileSync(file, ...args) {
-      const dir = path5.dirname(file);
-      if (!fs17.existsSync(dir)) {
+      const dir = path4.dirname(file);
+      if (!fs20.existsSync(dir)) {
         mkdir.mkdirsSync(dir);
       }
-      fs17.writeFileSync(file, ...args);
+      fs20.writeFileSync(file, ...args);
     }
     module2.exports = {
       outputFile: u(outputFile),
@@ -5062,19 +5062,19 @@ var require_json = __commonJS({
 var require_move = __commonJS({
   "node_modules/fs-extra/lib/move/move.js"(exports2, module2) {
     "use strict";
-    var fs17 = require_fs();
-    var path5 = require("path");
+    var fs20 = require_fs();
+    var path4 = require("path");
     var { copy } = require_copy2();
-    var { remove: remove2 } = require_remove();
+    var { remove } = require_remove();
     var { mkdirp } = require_mkdirs();
-    var { pathExists: pathExists2 } = require_path_exists();
+    var { pathExists } = require_path_exists();
     var stat = require_stat();
     async function move(src, dest, opts = {}) {
       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 = path5.dirname(dest);
-      const parsedParentPath = path5.parse(destParent);
+      const destParent = path4.dirname(dest);
+      const parsedParentPath = path4.parse(destParent);
       if (parsedParentPath.root !== destParent) {
         await mkdirp(destParent);
       }
@@ -5083,13 +5083,13 @@ var require_move = __commonJS({
     async function doRename(src, dest, overwrite, isChangingCase) {
       if (!isChangingCase) {
         if (overwrite) {
-          await remove2(dest);
-        } else if (await pathExists2(dest)) {
+          await remove(dest);
+        } else if (await pathExists(dest)) {
           throw new Error("dest already exists.");
         }
       }
       try {
-        await fs17.rename(src, dest);
+        await fs20.rename(src, dest);
       } catch (err) {
         if (err.code !== "EXDEV") {
           throw err;
@@ -5104,7 +5104,7 @@ var require_move = __commonJS({
         preserveTimestamps: true
       };
       await copy(src, dest, opts);
-      return remove2(src);
+      return remove(src);
     }
     module2.exports = move;
   }
@@ -5114,8 +5114,8 @@ var require_move = __commonJS({
 var require_move_sync = __commonJS({
   "node_modules/fs-extra/lib/move/move-sync.js"(exports2, module2) {
     "use strict";
-    var fs17 = require_graceful_fs();
-    var path5 = require("path");
+    var fs20 = require_graceful_fs();
+    var path4 = require("path");
     var copySync = require_copy2().copySync;
     var removeSync = require_remove().removeSync;
     var mkdirpSync = require_mkdirs().mkdirpSync;
@@ -5125,12 +5125,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(path5.dirname(dest));
+      if (!isParentRoot(dest)) mkdirpSync(path4.dirname(dest));
       return doRename(src, dest, overwrite, isChangingCase);
     }
     function isParentRoot(dest) {
-      const parent = path5.dirname(dest);
-      const parsedPath = path5.parse(parent);
+      const parent = path4.dirname(dest);
+      const parsedPath = path4.parse(parent);
       return parsedPath.root === parent;
     }
     function doRename(src, dest, overwrite, isChangingCase) {
@@ -5139,12 +5139,12 @@ var require_move_sync = __commonJS({
         removeSync(dest);
         return rename(src, dest, overwrite);
       }
-      if (fs17.existsSync(dest)) throw new Error("dest already exists.");
+      if (fs20.existsSync(dest)) throw new Error("dest already exists.");
       return rename(src, dest, overwrite);
     }
     function rename(src, dest, overwrite) {
       try {
-        fs17.renameSync(src, dest);
+        fs20.renameSync(src, dest);
       } catch (err) {
         if (err.code !== "EXDEV") throw err;
         return moveAcrossDevice(src, dest, overwrite);
@@ -11555,7 +11555,7 @@ var require_fromEvent = __commonJS({
         return function(handler) {
           return target[methodName](eventName, handler, options);
         };
-      }) : isNodeStyleEventEmitter(target) ? nodeEventEmitterMethods.map(toCommonHandlerRegistry(target, eventName)) : isJQueryStyleEventEmitter(target) ? jqueryMethods.map(toCommonHandlerRegistry(target, eventName)) : [], 2), add = _a[0], remove2 = _a[1];
+      }) : isNodeStyleEventEmitter(target) ? nodeEventEmitterMethods.map(toCommonHandlerRegistry(target, eventName)) : isJQueryStyleEventEmitter(target) ? jqueryMethods.map(toCommonHandlerRegistry(target, eventName)) : [], 2), add = _a[0], remove = _a[1];
       if (!add) {
         if (isArrayLike_1.isArrayLike(target)) {
           return mergeMap_1.mergeMap(function(subTarget) {
@@ -11576,7 +11576,7 @@ var require_fromEvent = __commonJS({
         };
         add(handler);
         return function() {
-          return remove2(handler);
+          return remove(handler);
         };
       });
     }
@@ -17562,15 +17562,15 @@ var require_route = __commonJS({
       };
     }
     function wrapConversion(toModel, graph) {
-      const path5 = [graph[toModel].parent, toModel];
+      const path4 = [graph[toModel].parent, toModel];
       let fn = conversions[graph[toModel].parent][toModel];
       let cur = graph[toModel].parent;
       while (graph[cur].parent) {
-        path5.unshift(graph[cur].parent);
+        path4.unshift(graph[cur].parent);
         fn = link(conversions[graph[cur].parent][cur], fn);
         cur = graph[cur].parent;
       }
-      fn.conversion = path5;
+      fn.conversion = path4;
       return fn;
     }
     module2.exports = function(fromModel) {
@@ -17944,7 +17944,7 @@ var require_has_flag = __commonJS({
 var require_supports_color = __commonJS({
   "node_modules/supports-color/index.js"(exports2, module2) {
     "use strict";
-    var os5 = require("os");
+    var os4 = require("os");
     var tty2 = require("tty");
     var hasFlag2 = require_has_flag();
     var { env: env2 } = process;
@@ -17992,7 +17992,7 @@ var require_supports_color = __commonJS({
         return min;
       }
       if (process.platform === "win32") {
-        const osRelease = os5.release().split(".");
+        const osRelease = os4.release().split(".");
         if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
           return Number(osRelease[2]) >= 14931 ? 3 : 2;
         }
@@ -18509,14 +18509,14 @@ var require_signal_exit = __commonJS({
         if (opts && opts.alwaysLast) {
           ev = "afterexit";
         }
-        var remove2 = function() {
+        var remove = function() {
           emitter.removeListener(ev, cb);
           if (emitter.listeners("exit").length === 0 && emitter.listeners("afterexit").length === 0) {
             unload2();
           }
         };
         emitter.on(ev, cb);
-        return remove2;
+        return remove;
       };
       unload2 = function unload3() {
         if (!loaded || !processOk2(global.process)) {
@@ -19200,7 +19200,7 @@ var require_buffer_list = __commonJS({
         }
       }, {
         key: "join",
-        value: function join16(s) {
+        value: function join17(s) {
           if (this.length === 0) return "";
           var p = this.head;
           var ret = "" + p.data;
@@ -28077,10 +28077,10 @@ var require_lib2 = __commonJS({
     exports2.analyse = analyse;
     var detectFile = (filepath, opts = {}) => new Promise((resolve, reject) => {
       let fd;
-      const fs17 = (0, node_1.default)();
+      const fs20 = (0, node_1.default)();
       const handler = (err, buffer) => {
         if (fd) {
-          fs17.closeSync(fd);
+          fs20.closeSync(fd);
         }
         if (err) {
           reject(err);
@@ -28092,9 +28092,9 @@ var require_lib2 = __commonJS({
       };
       const sampleSize = (opts === null || opts === void 0 ? void 0 : opts.sampleSize) || 0;
       if (sampleSize > 0) {
-        fd = fs17.openSync(filepath, "r");
+        fd = fs20.openSync(filepath, "r");
         let sample = Buffer.allocUnsafe(sampleSize);
-        fs17.read(fd, sample, 0, sampleSize, opts.offset, (err, bytesRead) => {
+        fs20.read(fd, sample, 0, sampleSize, opts.offset, (err, bytesRead) => {
           if (err) {
             handler(err, null);
           } else {
@@ -28106,22 +28106,22 @@ var require_lib2 = __commonJS({
         });
         return;
       }
-      fs17.readFile(filepath, handler);
+      fs20.readFile(filepath, handler);
     });
     exports2.detectFile = detectFile;
     var detectFileSync = (filepath, opts = {}) => {
-      const fs17 = (0, node_1.default)();
+      const fs20 = (0, node_1.default)();
       if (opts && opts.sampleSize) {
-        const fd = fs17.openSync(filepath, "r");
+        const fd = fs20.openSync(filepath, "r");
         let sample = Buffer.allocUnsafe(opts.sampleSize);
-        const bytesRead = fs17.readSync(fd, sample, 0, opts.sampleSize, opts.offset);
+        const bytesRead = fs20.readSync(fd, sample, 0, opts.sampleSize, opts.offset);
         if (bytesRead < opts.sampleSize) {
           sample = sample.subarray(0, bytesRead);
         }
-        fs17.closeSync(fd);
+        fs20.closeSync(fd);
         return (0, exports2.detect)(sample);
       }
-      return (0, exports2.detect)(fs17.readFileSync(filepath));
+      return (0, exports2.detect)(fs20.readFileSync(filepath));
     };
     exports2.detectFileSync = detectFileSync;
     exports2.default = {
@@ -31800,7 +31800,7 @@ var require_lib3 = __commonJS({
       var trail = encoder.end();
       return trail && trail.length > 0 ? Buffer3.concat([res, trail]) : res;
     };
-    module2.exports.decode = function decode(buf, encoding, options) {
+    module2.exports.decode = function decode2(buf, encoding, options) {
       if (typeof buf === "string") {
         if (!module2.exports.skipDecodeWarning) {
           console.error("Iconv-lite warning: decode()-ing strings is deprecated. Refer to https://github.com/ashtuchkin/iconv-lite/wiki/Use-Buffers-when-decoding");
@@ -32455,7 +32455,7 @@ var require_has_flag2 = __commonJS({
 var require_supports_colors = __commonJS({
   "node_modules/@colors/colors/lib/system/supports-colors.js"(exports2, module2) {
     "use strict";
-    var os5 = require("os");
+    var os4 = require("os");
     var hasFlag2 = require_has_flag2();
     var env2 = process.env;
     var forceColor = void 0;
@@ -32493,7 +32493,7 @@ var require_supports_colors = __commonJS({
       }
       var min = forceColor ? 1 : 0;
       if (process.platform === "win32") {
-        var osRelease = os5.release().split(".");
+        var osRelease = os4.release().split(".");
         if (Number(process.versions.node.split(".")[0]) >= 8 && Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
           return Number(osRelease[2]) >= 14931 ? 3 : 2;
         }
@@ -36709,7 +36709,7 @@ var require_verify = __commonJS({
     var JsonWebTokenError2 = require_JsonWebTokenError();
     var NotBeforeError = require_NotBeforeError();
     var TokenExpiredError2 = require_TokenExpiredError();
-    var decode = require_decode();
+    var decode2 = require_decode();
     var timespan = require_timespan();
     var validateAsymmetricKey = require_validateAsymmetricKey();
     var PS_SUPPORTED = require_psSupported();
@@ -36763,7 +36763,7 @@ var require_verify = __commonJS({
       }
       let decodedToken;
       try {
-        decodedToken = decode(jwtString, { complete: true });
+        decodedToken = decode2(jwtString, { complete: true });
       } catch (err) {
         return done(err);
       }
@@ -38927,7 +38927,7 @@ var require_Pool = __commonJS({
           return resource;
         }).catch((err) => {
           this._executeEventHandlers("acquireFail", eventId, err);
-          remove2(this.pendingAcquires, pendingAcquire);
+          remove(this.pendingAcquires, pendingAcquire);
           return Promise.reject(err);
         });
         this._tryAcquireOrCreate();
@@ -39070,7 +39070,7 @@ var require_Pool = __commonJS({
                 this._startReaping();
                 pendingAcquire.resolve(free.resource);
               } else {
-                remove2(this.used, free);
+                remove(this.used, free);
                 if (!validationSuccess) {
                   this._destroy(free.resource);
                   setTimeout(() => {
@@ -39084,7 +39084,7 @@ var require_Pool = __commonJS({
                 }
               }
             } finally {
-              remove2(this.pendingValidations, pendingAcquire);
+              remove(this.pendingValidations, pendingAcquire);
             }
           });
           this._validateResource(free.resource).then((validationSuccess) => {
@@ -39128,7 +39128,7 @@ var require_Pool = __commonJS({
         this._executeEventHandlers("createRequest", eventId);
         const pendingCreate = new PendingOperation_1.PendingOperation(this.createTimeoutMillis);
         pendingCreate.promise = pendingCreate.promise.catch((err) => {
-          if (remove2(this.pendingCreates, pendingCreate)) {
+          if (remove(this.pendingCreates, pendingCreate)) {
             this._executeEventHandlers("createFail", eventId, err);
           }
           throw err;
@@ -39139,7 +39139,7 @@ var require_Pool = __commonJS({
             this.destroyer(resource);
             return null;
           }
-          remove2(this.pendingCreates, pendingCreate);
+          remove(this.pendingCreates, pendingCreate);
           this.free.push(new Resource_1.Resource(resource));
           pendingCreate.resolve(resource);
           this._executeEventHandlers("createSuccess", eventId, resource);
@@ -39148,7 +39148,7 @@ var require_Pool = __commonJS({
           if (pendingCreate.isRejected) {
             return null;
           }
-          if (remove2(this.pendingCreates, pendingCreate)) {
+          if (remove(this.pendingCreates, pendingCreate)) {
             this._executeEventHandlers("createFail", eventId, err);
           }
           pendingCreate.reject(err);
@@ -39205,7 +39205,7 @@ var require_Pool = __commonJS({
       }
     };
     exports2.Pool = Pool;
-    function remove2(arr, item) {
+    function remove(arr, item) {
       const idx = arr.indexOf(item);
       if (idx === -1) {
         return false;
@@ -39654,7 +39654,7 @@ var require_table2 = __commonJS({
       let cursor = -1;
       let buffer = "";
       let escaped = false;
-      const path5 = [];
+      const path4 = [];
       while (++cursor < length) {
         const char = name.charAt(cursor);
         if (char === "[") {
@@ -39673,7 +39673,7 @@ var require_table2 = __commonJS({
           if (escaped) {
             buffer += char;
           } else {
-            path5.push(buffer);
+            path4.push(buffer);
             buffer = "";
           }
         } else {
@@ -39681,26 +39681,26 @@ var require_table2 = __commonJS({
         }
       }
       if (buffer) {
-        path5.push(buffer);
+        path4.push(buffer);
       }
-      switch (path5.length) {
+      switch (path4.length) {
         case 1:
           return {
-            name: path5[0],
+            name: path4[0],
             schema: null,
             database: null
           };
         case 2:
           return {
-            name: path5[1],
-            schema: path5[0],
+            name: path4[1],
+            schema: path4[0],
             database: null
           };
         case 3:
           return {
-            name: path5[2],
-            schema: path5[1],
-            database: path5[0]
+            name: path4[2],
+            schema: path4[1],
+            database: path4[0]
           };
         default:
           throw new Error("Invalid table name.");
@@ -43384,13 +43384,13 @@ function __disposeResources(env2) {
   }
   return next();
 }
-function __rewriteRelativeImportExtension(path5, preserveJsx) {
-  if (typeof path5 === "string" && /^\.\.?\//.test(path5)) {
-    return path5.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function(m, tsx, d, ext2, cm) {
+function __rewriteRelativeImportExtension(path4, preserveJsx) {
+  if (typeof path4 === "string" && /^\.\.?\//.test(path4)) {
+    return path4.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function(m, tsx, d, ext2, cm) {
       return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext2 || !cm) ? m : d + ext2 + "." + cm.toLowerCase() + "js";
     });
   }
-  return path5;
+  return path4;
 }
 var extendStatics, __assign, __createBinding, __setModuleDefault, ownKeys, _SuppressedError, tslib_es6_default;
 var init_tslib_es6 = __esm({
@@ -43538,8 +43538,8 @@ var require_msalPlugins = __commonJS({
       }
     };
     exports2.msalNodeFlowVSCodeCredentialControl = {
-      setVSCodeAuthRecordPath(path5) {
-        exports2.vsCodeAuthRecordPath = path5;
+      setVSCodeAuthRecordPath(path4) {
+        exports2.vsCodeAuthRecordPath = path4;
       },
       setVSCodeBroker(broker) {
         exports2.vsCodeBrokerInfo = {
@@ -44463,16 +44463,16 @@ var require_chainedTokenCredential = __commonJS({
 // node_modules/uuid/dist/esm-node/rng.js
 function rng() {
   if (poolPtr > rnds8Pool.length - 16) {
-    import_crypto4.default.randomFillSync(rnds8Pool);
+    import_crypto5.default.randomFillSync(rnds8Pool);
     poolPtr = 0;
   }
   return rnds8Pool.slice(poolPtr, poolPtr += 16);
 }
-var import_crypto4, rnds8Pool, poolPtr;
+var import_crypto5, rnds8Pool, poolPtr;
 var init_rng = __esm({
   "node_modules/uuid/dist/esm-node/rng.js"() {
     "use strict";
-    import_crypto4 = __toESM(require("crypto"));
+    import_crypto5 = __toESM(require("crypto"));
     rnds8Pool = new Uint8Array(256);
     poolPtr = rnds8Pool.length;
   }
@@ -44677,13 +44677,13 @@ function md5(bytes) {
   } else if (typeof bytes === "string") {
     bytes = Buffer.from(bytes, "utf8");
   }
-  return import_crypto5.default.createHash("md5").update(bytes).digest();
+  return import_crypto6.default.createHash("md5").update(bytes).digest();
 }
-var import_crypto5, md5_default;
+var import_crypto6, md5_default;
 var init_md5 = __esm({
   "node_modules/uuid/dist/esm-node/md5.js"() {
     "use strict";
-    import_crypto5 = __toESM(require("crypto"));
+    import_crypto6 = __toESM(require("crypto"));
     md5_default = md5;
   }
 });
@@ -44732,13 +44732,13 @@ function sha1(bytes) {
   } else if (typeof bytes === "string") {
     bytes = Buffer.from(bytes, "utf8");
   }
-  return import_crypto6.default.createHash("sha1").update(bytes).digest();
+  return import_crypto7.default.createHash("sha1").update(bytes).digest();
 }
-var import_crypto6, sha1_default;
+var import_crypto7, sha1_default;
 var init_sha1 = __esm({
   "node_modules/uuid/dist/esm-node/sha1.js"() {
     "use strict";
-    import_crypto6 = __toESM(require("crypto"));
+    import_crypto7 = __toESM(require("crypto"));
     sha1_default = sha1;
   }
 });
@@ -45694,12 +45694,12 @@ var require_index_node_C6O_wJLi = __commonJS({
       static queryStringToObject(query) {
         const obj = {};
         const params = query.split("&");
-        const decode = (s) => decodeURIComponent(s.replace(/\+/g, " "));
+        const decode2 = (s) => decodeURIComponent(s.replace(/\+/g, " "));
         params.forEach((pair) => {
           if (pair.trim()) {
             const [key, value] = pair.split(/=(.+)/g, 2);
             if (key && value) {
-              obj[decode(key)] = decode(value);
+              obj[decode2(key)] = decode2(value);
             }
           }
         });
@@ -52395,8 +52395,8 @@ var require_msal_node = __commonJS({
     var crypto5 = require("crypto");
     var msalCommon = require_lib6();
     var jwt2 = require_jsonwebtoken();
-    var fs17 = require("fs");
-    var path5 = require("path");
+    var fs20 = require("fs");
+    var path4 = require("path");
     var Serializer = class {
       /**
        * serialize the JSON blob
@@ -53546,12 +53546,12 @@ var require_msal_node = __commonJS({
       static queryStringToObject(query) {
         const obj = {};
         const params = query.split("&");
-        const decode = (s) => decodeURIComponent(s.replace(/\+/g, " "));
+        const decode2 = (s) => decodeURIComponent(s.replace(/\+/g, " "));
         params.forEach((pair) => {
           if (pair.trim()) {
             const [key, value] = pair.split(/=(.+)/g, 2);
             if (key && value) {
-              obj[decode(key)] = decode(value);
+              obj[decode2(key)] = decode2(value);
             }
           }
         });
@@ -62094,7 +62094,7 @@ Headers: ${JSON.stringify(headers)}`
         if (!identityEndpoint || !imdsEndpoint) {
           const fileDetectionPath = AZURE_ARC_FILE_DETECTION[process.platform];
           try {
-            fs17.accessSync(fileDetectionPath, fs17.constants.F_OK | fs17.constants.R_OK);
+            fs20.accessSync(fileDetectionPath, fs20.constants.F_OK | fs20.constants.R_OK);
             identityEndpoint = DEFAULT_AZURE_ARC_IDENTITY_ENDPOINT;
             imdsEndpoint = HIMDS_EXECUTABLE_HELPER_STRING;
           } catch (err) {
@@ -62197,7 +62197,7 @@ Headers: ${JSON.stringify(headers)}`
             throw createManagedIdentityError(platformNotSupported);
           }
           const expectedSecretFilePath = SUPPORTED_AZURE_ARC_PLATFORMS[process.platform];
-          const fileName = path5.basename(secretFilePath);
+          const fileName = path4.basename(secretFilePath);
           if (!fileName.endsWith(".key")) {
             throw createManagedIdentityError(invalidFileExtension);
           }
@@ -62206,7 +62206,7 @@ Headers: ${JSON.stringify(headers)}`
           }
           let secretFileSize;
           try {
-            secretFileSize = await fs17.statSync(secretFilePath).size;
+            secretFileSize = await fs20.statSync(secretFilePath).size;
           } catch (e) {
             throw createManagedIdentityError(unableToReadSecretFile);
           }
@@ -62215,7 +62215,7 @@ Headers: ${JSON.stringify(headers)}`
           }
           let secret;
           try {
-            secret = fs17.readFileSync(secretFilePath, EncodingTypes.UTF8);
+            secret = fs20.readFileSync(secretFilePath, EncodingTypes.UTF8);
           } catch (e) {
             throw createManagedIdentityError(unableToReadSecretFile);
           }
@@ -62979,8 +62979,8 @@ var require_uuidUtils = __commonJS({
   "node_modules/@typespec/ts-http-runtime/dist/commonjs/util/uuidUtils.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.randomUUID = randomUUID2;
-    function randomUUID2() {
+    exports2.randomUUID = randomUUID3;
+    function randomUUID3() {
       return crypto.randomUUID();
     }
   }
@@ -63421,7 +63421,7 @@ var require_commonjs4 = __commonJS({
     exports2.getRandomIntegerInclusive = getRandomIntegerInclusive;
     exports2.isError = isError;
     exports2.isObject = isObject;
-    exports2.randomUUID = randomUUID2;
+    exports2.randomUUID = randomUUID3;
     exports2.uint8ArrayToString = uint8ArrayToString;
     exports2.stringToUint8Array = stringToUint8Array;
     var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports));
@@ -63470,7 +63470,7 @@ var require_commonjs4 = __commonJS({
     function isObject(input) {
       return tspRuntime.isObject(input);
     }
-    function randomUUID2() {
+    function randomUUID3() {
       return tspRuntime.randomUUID();
     }
     exports2.isBrowser = tspRuntime.isBrowser;
@@ -63513,7 +63513,7 @@ var require_utils7 = __commonJS({
     exports2.getAuthority = getAuthority;
     exports2.getKnownAuthorities = getKnownAuthorities;
     exports2.getMSALLogLevel = getMSALLogLevel;
-    exports2.randomUUID = randomUUID2;
+    exports2.randomUUID = randomUUID3;
     exports2.handleMsalError = handleMsalError;
     exports2.publicToMsal = publicToMsal;
     exports2.msalToPublic = msalToPublic;
@@ -63572,22 +63572,22 @@ var require_utils7 = __commonJS({
       }
       return [];
     }
-    var defaultLoggerCallback = (credLogger, platform3 = core_util_1.isNode ? "Node" : "Browser") => (level, message, containsPii) => {
+    var defaultLoggerCallback = (credLogger, platform4 = core_util_1.isNode ? "Node" : "Browser") => (level, message, containsPii) => {
       if (containsPii) {
         return;
       }
       switch (level) {
         case msal_js_1.msalCommon.LogLevel.Error:
-          credLogger.info(`MSAL ${platform3} V2 error: ${message}`);
+          credLogger.info(`MSAL ${platform4} V2 error: ${message}`);
           return;
         case msal_js_1.msalCommon.LogLevel.Info:
-          credLogger.info(`MSAL ${platform3} V2 info message: ${message}`);
+          credLogger.info(`MSAL ${platform4} V2 info message: ${message}`);
           return;
         case msal_js_1.msalCommon.LogLevel.Verbose:
-          credLogger.info(`MSAL ${platform3} V2 verbose message: ${message}`);
+          credLogger.info(`MSAL ${platform4} V2 verbose message: ${message}`);
           return;
         case msal_js_1.msalCommon.LogLevel.Warning:
-          credLogger.info(`MSAL ${platform3} V2 warning: ${message}`);
+          credLogger.info(`MSAL ${platform4} V2 warning: ${message}`);
           return;
       }
     };
@@ -63606,7 +63606,7 @@ var require_utils7 = __commonJS({
           return msal_js_1.msalCommon.LogLevel.Info;
       }
     }
-    function randomUUID2() {
+    function randomUUID3() {
       return (0, core_util_1.randomUUID)();
     }
     function handleMsalError(scopes, error, getTokenOptions) {
@@ -66410,8 +66410,8 @@ var require_dist3 = __commonJS({
       setRequestProps(req, opts) {
         const { proxy } = this;
         const protocol = opts.secureEndpoint ? "https:" : "http:";
-        const hostname = req.getHeader("host") || "localhost";
-        const base = `${protocol}//${hostname}`;
+        const hostname2 = req.getHeader("host") || "localhost";
+        const base = `${protocol}//${hostname2}`;
         const url = new url_1.URL(req.path, base);
         if (opts.port !== 80) {
           url.port = String(opts.port);
@@ -67559,8 +67559,8 @@ var require_getClient = __commonJS({
       }
       const { allowInsecureConnection, httpClient } = clientOptions;
       const endpointUrl = clientOptions.endpoint ?? endpoint;
-      const client = (path5, ...args) => {
-        const getUrl = (requestOptions) => (0, urlHelpers_js_1.buildRequestUrl)(endpointUrl, path5, args, { allowInsecureConnection, ...requestOptions });
+      const client = (path4, ...args) => {
+        const getUrl = (requestOptions) => (0, urlHelpers_js_1.buildRequestUrl)(endpointUrl, path4, args, { allowInsecureConnection, ...requestOptions });
         return {
           get: (requestOptions = {}) => {
             return buildOperation("GET", getUrl(requestOptions), pipeline, requestOptions, allowInsecureConnection, httpClient);
@@ -69742,15 +69742,15 @@ var require_urlHelpers2 = __commonJS({
       let isAbsolutePath = false;
       let requestUrl = replaceAll(baseUri, urlReplacements);
       if (operationSpec.path) {
-        let path5 = replaceAll(operationSpec.path, urlReplacements);
-        if (operationSpec.path === "/{nextLink}" && path5.startsWith("/")) {
-          path5 = path5.substring(1);
+        let path4 = replaceAll(operationSpec.path, urlReplacements);
+        if (operationSpec.path === "/{nextLink}" && path4.startsWith("/")) {
+          path4 = path4.substring(1);
         }
-        if (isAbsoluteUrl(path5)) {
-          requestUrl = path5;
+        if (isAbsoluteUrl(path4)) {
+          requestUrl = path4;
           isAbsolutePath = true;
         } else {
-          requestUrl = appendPath(requestUrl, path5);
+          requestUrl = appendPath(requestUrl, path4);
         }
       }
       const { queryParams, sequenceParams } = calculateQueryParameters(operationSpec, operationArguments, fallbackObject);
@@ -69796,9 +69796,9 @@ var require_urlHelpers2 = __commonJS({
       }
       const searchStart = pathToAppend.indexOf("?");
       if (searchStart !== -1) {
-        const path5 = pathToAppend.substring(0, searchStart);
+        const path4 = pathToAppend.substring(0, searchStart);
         const search = pathToAppend.substring(searchStart + 1);
-        newPath = newPath + path5;
+        newPath = newPath + path4;
         if (search) {
           parsedUrl.search = parsedUrl.search ? `${parsedUrl.search}&${search}` : search;
         }
@@ -71098,22 +71098,22 @@ function detectArchBinary(binary) {
   if (typeof binary === "string" || Array.isArray(binary)) {
     return binary;
   }
-  const { [arch]: archBinary } = binary;
+  const { [arch2]: archBinary } = binary;
   if (!archBinary) {
-    throw new Error(`${arch} is not supported`);
+    throw new Error(`${arch2} is not supported`);
   }
   return archBinary;
 }
-function detectPlatformBinary({ [platform2]: platformBinary }, { wsl }) {
+function detectPlatformBinary({ [platform3]: platformBinary }, { wsl }) {
   if (wsl && is_wsl_default) {
     return detectArchBinary(wsl);
   }
   if (!platformBinary) {
-    throw new Error(`${platform2} is not supported`);
+    throw new Error(`${platform3} is not supported`);
   }
   return detectArchBinary(platformBinary);
 }
-var import_node_process14, import_node_buffer, import_node_path3, import_node_url3, import_node_util5, import_node_child_process5, import_promises3, import_meta, execFile5, __dirname2, localXdgOpenPath, platform2, arch, pTryEach, baseOpen, open, openApp, apps, open_default;
+var import_node_process14, import_node_buffer, import_node_path3, import_node_url3, import_node_util5, import_node_child_process5, import_promises3, import_meta, execFile5, __dirname2, localXdgOpenPath, platform3, arch2, pTryEach, baseOpen, open, openApp, apps, open_default;
 var init_open = __esm({
   "node_modules/open/index.js"() {
     "use strict";
@@ -71132,7 +71132,7 @@ var init_open = __esm({
     execFile5 = (0, import_node_util5.promisify)(import_node_child_process5.default.execFile);
     __dirname2 = import_node_path3.default.dirname((0, import_node_url3.fileURLToPath)(import_meta.url));
     localXdgOpenPath = import_node_path3.default.join(__dirname2, "xdg-open");
-    ({ platform: platform2, arch } = import_node_process14.default);
+    ({ platform: platform3, arch: arch2 } = import_node_process14.default);
     pTryEach = async (array, mapper) => {
       let latestError;
       for (const item of array) {
@@ -71206,7 +71206,7 @@ var init_open = __esm({
       let command;
       const cliArguments = [];
       const childProcessOptions = {};
-      if (platform2 === "darwin") {
+      if (platform3 === "darwin") {
         command = "open";
         if (options.wait) {
           cliArguments.push("--wait-apps");
@@ -71220,7 +71220,7 @@ var init_open = __esm({
         if (app) {
           cliArguments.push("-a", app);
         }
-      } else if (platform2 === "win32" || is_wsl_default && !isInsideContainer() && !app) {
+      } else if (platform3 === "win32" || is_wsl_default && !isInsideContainer() && !app) {
         command = await powerShellPath();
         cliArguments.push(
           "-NoProfile",
@@ -71260,7 +71260,7 @@ var init_open = __esm({
             exeLocalXdgOpen = true;
           } catch {
           }
-          const useSystemXdgOpen = import_node_process14.default.versions.electron ?? (platform2 === "android" || isBundled || !exeLocalXdgOpen);
+          const useSystemXdgOpen = import_node_process14.default.versions.electron ?? (platform3 === "android" || isBundled || !exeLocalXdgOpen);
           command = useSystemXdgOpen ? "xdg-open" : localXdgOpenPath;
         }
         if (appArguments.length > 0) {
@@ -71271,7 +71271,7 @@ var init_open = __esm({
           childProcessOptions.detached = true;
         }
       }
-      if (platform2 === "darwin" && appArguments.length > 0) {
+      if (platform3 === "darwin" && appArguments.length > 0) {
         cliArguments.push("--args", ...appArguments);
       }
       if (options.target) {
@@ -78307,7 +78307,7 @@ var require_abort_controller = __commonJS({
       }
     };
     eventTargetShim.defineEventAttribute(AbortSignal2.prototype, "abort");
-    function createAbortSignal() {
+    function createAbortSignal2() {
       const signal = Object.create(AbortSignal2.prototype);
       eventTargetShim.EventTarget.call(signal);
       abortedFlags.set(signal, false);
@@ -78335,7 +78335,7 @@ var require_abort_controller = __commonJS({
        * Initialize this controller.
        */
       constructor() {
-        signals2.set(this, createAbortSignal());
+        signals2.set(this, createAbortSignal2());
       }
       /**
        * Returns the `AbortSignal` object associated with this object.
@@ -83981,7 +83981,7 @@ var require_message_io = __commonJS({
         return this.outgoingMessageStream.packetSize;
       }
       // Negotiate TLS encryption.
-      startTls(credentialsDetails, hostname, trustServerCertificate) {
+      startTls(credentialsDetails, hostname2, trustServerCertificate) {
         if (!credentialsDetails.maxVersion || !["TLSv1.2", "TLSv1.1", "TLSv1"].includes(credentialsDetails.maxVersion)) {
           credentialsDetails.maxVersion = "TLSv1.2";
         }
@@ -83991,7 +83991,7 @@ var require_message_io = __commonJS({
           const securePair = this.securePair = {
             cleartext: tls.connect({
               socket: duplexpair.socket1,
-              servername: hostname,
+              servername: hostname2,
               secureContext,
               rejectUnauthorized: !trustServerCertificate
             }),
@@ -87253,7 +87253,7 @@ var init_js_joda_esm = __esm({
         this._map = map8;
         return this;
       };
-      _proto.remove = function remove2(key) {
+      _proto.remove = function remove(key) {
         var keyName = key.name();
         var val = this._map[keyName];
         this._map[keyName] = void 0;
@@ -99457,7 +99457,7 @@ var require_lib7 = __commonJS({
       var trail = encoder.end();
       return trail && trail.length > 0 ? Buffer3.concat([res, trail]) : res;
     };
-    iconv2.decode = function decode(buf, encoding, options) {
+    iconv2.decode = function decode2(buf, encoding, options) {
       if (typeof buf === "string") {
         if (!iconv2.skipDecodeWarning) {
           console.error("Iconv-lite warning: decode()-ing strings is deprecated. Refer to https://github.com/ashtuchkin/iconv-lite/wiki/Use-Buffers-when-decoding");
@@ -112208,14 +112208,14 @@ var import_fs_extra = __toESM(require_lib());
 function getVsCodeSettingsPaths() {
   const paths = [];
   const home = (0, import_os.homedir)();
-  const os5 = (0, import_os.platform)();
-  if (os5 === "win32") {
+  const os4 = (0, import_os.platform)();
+  if (os4 === "win32") {
     const appdata = process.env.APPDATA || (0, import_path.join)(home, "AppData", "Roaming");
     paths.push(
       { path: (0, import_path.join)(appdata, "Code", "User", "settings.json"), variant: "Code" },
       { path: (0, import_path.join)(appdata, "Code - Insiders", "User", "settings.json"), variant: "Code - Insiders" }
     );
-  } else if (os5 === "darwin") {
+  } else if (os4 === "darwin") {
     paths.push(
       { path: (0, import_path.join)(home, "Library", "Application Support", "Code", "User", "settings.json"), variant: "Code" },
       { path: (0, import_path.join)(home, "Library", "Application Support", "Code - Insiders", "User", "settings.json"), variant: "Code - Insiders" }
@@ -112787,8 +112787,8 @@ async function installCommands(options = {}) {
     version: getPackageVersion(),
     installedAt: now,
     updatedAt: now,
-    files: result.installedFiles.map((path5) => ({
-      path: path5,
+    files: result.installedFiles.map((path4) => ({
+      path: path4,
       installedAt: now
     }))
   };
@@ -115625,9 +115625,9 @@ var fetchAsyncQuestionProperty = function(question, prop, answers) {
 
 // node_modules/inquirer/lib/ui/prompt.js
 var _ = {
-  set: (obj, path5 = "", value) => {
+  set: (obj, path4 = "", value) => {
     let pointer = obj;
-    path5.split(".").forEach((key, index, arr) => {
+    path4.split(".").forEach((key, index, arr) => {
       if (key === "__proto__" || key === "constructor") return;
       if (index === arr.length - 1) {
         pointer[key] = value;
@@ -115637,8 +115637,8 @@ var _ = {
       pointer = pointer[key];
     });
   },
-  get: (obj, path5 = "", defaultValue) => {
-    const travel = (regexp) => String.prototype.split.call(path5, regexp).filter(Boolean).reduce(
+  get: (obj, path4 = "", defaultValue) => {
+    const travel = (regexp) => String.prototype.split.call(path4, regexp).filter(Boolean).reduce(
       // @ts-expect-error implicit any on res[key]
       (res, key) => res !== null && res !== void 0 ? res[key] : res,
       obj
@@ -116825,12 +116825,12 @@ EndGlobal
     appSettingsContent = appSettingsContent.replace(/\{\{ProjectName\}\}/g, projectName).replace(/\{\{ProjectDomain\}\}/g, `${projectName.toLowerCase()}.app`).replace(/\{\{ProjectNameLower\}\}/g, projectName.toLowerCase()).replace(/\{\{JwtSecret\}\}/g, jwtSecret);
     const appSettings = JSON.parse(appSettingsContent);
     appSettings.MultiTenant = {
-      Enabled: config.multiTenant.enabled,
-      EnableB2B: config.multiTenant.enableB2B,
-      EnableB2C: config.multiTenant.enableB2C,
-      SystemTenantSlug: config.multiTenant.systemTenantSlug,
-      SystemTenantName: config.multiTenant.systemTenantName,
-      AutoAssignUsersToSystemTenant: config.multiTenant.autoAssignUsersToSystemTenant
+      Enabled: true,
+      EnableB2B: true,
+      EnableB2C: true,
+      SystemTenantSlug: "default",
+      SystemTenantName: "Default Workspace",
+      AutoAssignUsersToSystemTenant: true
     };
     appSettings.Email.Provider = config.email.provider;
     if (config.email.provider === "Disabled") {
@@ -117601,7 +117601,7 @@ async function initializeGit(config, dryRun) {
     execCommand('git commit -m "chore: initial SmartStack project setup"', projectDir, dryRun);
   }
 }
-var initCommand = new Command("init").description("Initialize a new SmartStack project").argument("[name]", "Project name (optional, uses current folder if not provided)").option("--dry-run", "Show what would be created without actually creating").option("-y, --yes", "Skip prompts and use defaults").option("--skip-mcp-check", "Skip MCP servers verification").option("--multi-tenant", "Enable multi-tenant mode").option("--b2b", "Enable B2B (organisation management)").option("--b2c", "Enable B2C (user tenant management)").option("--preview", "Use preview/prerelease versions (NuGet --prerelease + npm @next)").option("--here", "Initialize in current directory (use folder name as project name)").action(async (name, options) => {
+var initCommand = new Command("init").description("Initialize a new SmartStack project").argument("[name]", "Project name (optional, uses current folder if not provided)").option("--dry-run", "Show what would be created without actually creating").option("-y, --yes", "Skip prompts and use defaults").option("--skip-mcp-check", "Skip MCP servers verification").option("--preview", "Use preview/prerelease versions (NuGet --prerelease + npm @next)").option("--here", "Initialize in current directory (use folder name as project name)").action(async (name, options) => {
   logger.header("SmartStack Project Initialization");
   if (!options.skipMcpCheck) {
     logger.info("Checking MCP servers...");
@@ -117839,56 +117839,12 @@ var initCommand = new Command("init").description("Initialize a new SmartStack p
       database: "sqlserver",
       preview: options.preview ?? false,
       projectDir: finalProjectDir,
-      multiTenant: {
-        enabled: options.multiTenant ?? true,
-        enableB2B: options.b2b ?? true,
-        enableB2C: options.b2c ?? true,
-        systemTenantSlug: "default",
-        systemTenantName: "Default Workspace",
-        autoAssignUsersToSystemTenant: true
-      },
       email: {
         provider: "Development",
         setupMailPit: false
       }
     };
   } else {
-    const answers = await lib_default.prompt([
-      {
-        type: "confirm",
-        name: "multiTenantEnabled",
-        message: "Enable multi-tenant mode?",
-        default: true
-      },
-      {
-        type: "confirm",
-        name: "enableB2B",
-        message: "Enable B2B (organisation management)?",
-        default: true,
-        when: (answers2) => answers2.multiTenantEnabled
-      },
-      {
-        type: "confirm",
-        name: "enableB2C",
-        message: "Enable B2C (user tenant management)?",
-        default: true,
-        when: (answers2) => answers2.multiTenantEnabled
-      },
-      {
-        type: "input",
-        name: "systemTenantSlug",
-        message: "System tenant slug:",
-        default: "default",
-        when: (answers2) => answers2.multiTenantEnabled
-      },
-      {
-        type: "input",
-        name: "systemTenantName",
-        message: "System tenant name:",
-        default: "Default Workspace",
-        when: (answers2) => answers2.multiTenantEnabled
-      }
-    ]);
     const emailAnswers = await lib_default.prompt([
       {
         type: "list",
@@ -117916,14 +117872,6 @@ var initCommand = new Command("init").description("Initialize a new SmartStack p
       database: "sqlserver",
       preview: options.preview ?? false,
       projectDir: finalProjectDir,
-      multiTenant: {
-        enabled: answers.multiTenantEnabled ?? true,
-        enableB2B: answers.enableB2B ?? true,
-        enableB2C: answers.enableB2C ?? true,
-        systemTenantSlug: answers.systemTenantSlug || "default",
-        systemTenantName: answers.systemTenantName || "Default Workspace",
-        autoAssignUsersToSystemTenant: true
-      },
       email: {
         provider: emailAnswers.emailProvider || "Development",
         setupMailPit: emailAnswers.setupMailPit ?? false
@@ -117938,12 +117886,7 @@ var initCommand = new Command("init").description("Initialize a new SmartStack p
   logger.info(`Project: ${source_default.cyan(config.name)}`);
   logger.info(`Database: ${source_default.cyan("SQL Server")}`);
   logger.info(`Preview mode: ${config.preview ? source_default.yellow("Enabled (prerelease)") : source_default.gray("Disabled (stable)")}`);
-  logger.info(`Multi-Tenant: ${config.multiTenant.enabled ? source_default.green("Enabled") : source_default.gray("Disabled")}`);
-  if (config.multiTenant.enabled) {
-    logger.info(`  B2B (Organisations): ${config.multiTenant.enableB2B ? source_default.green("Enabled") : source_default.gray("Disabled")}`);
-    logger.info(`  B2C (User Tenants): ${config.multiTenant.enableB2C ? source_default.green("Enabled") : source_default.gray("Disabled")}`);
-    logger.info(`  System Tenant: ${source_default.cyan(config.multiTenant.systemTenantSlug)} (${config.multiTenant.systemTenantName})`);
-  }
+  logger.info(`Multi-Tenant: ${source_default.green("Enabled")} (personal tenant)`);
   const emailLabel = config.email.provider === "Development" ? `${source_default.green("Development")} (MailPit - SMTP :1025, Web :8025)` : config.email.provider === "Disabled" ? source_default.gray("Disabled") : source_default.cyan(config.email.provider);
   logger.info(`Email: ${emailLabel}`);
   console.log();
@@ -122248,12 +122191,12 @@ var PathBase = class {
   /**
    * Get the Path object referenced by the string path, resolved from this Path
    */
-  resolve(path5) {
-    if (!path5) {
+  resolve(path4) {
+    if (!path4) {
       return this;
     }
-    const rootPath = this.getRootString(path5);
-    const dir = path5.substring(rootPath.length);
+    const rootPath = this.getRootString(path4);
+    const dir = path4.substring(rootPath.length);
     const dirParts = dir.split(this.splitSep);
     const result = rootPath ? this.getRoot(rootPath).#resolveParts(dirParts) : this.#resolveParts(dirParts);
     return result;
@@ -123005,8 +122948,8 @@ var PathWin32 = class _PathWin32 extends PathBase {
   /**
    * @internal
    */
-  getRootString(path5) {
-    return import_node_path2.win32.parse(path5).root;
+  getRootString(path4) {
+    return import_node_path2.win32.parse(path4).root;
   }
   /**
    * @internal
@@ -123052,8 +122995,8 @@ var PathPosix = class _PathPosix extends PathBase {
   /**
    * @internal
    */
-  getRootString(path5) {
-    return path5.startsWith("/") ? "/" : "";
+  getRootString(path4) {
+    return path4.startsWith("/") ? "/" : "";
   }
   /**
    * @internal
@@ -123102,8 +123045,8 @@ var PathScurryBase = class {
    *
    * @internal
    */
-  constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs17 = defaultFS } = {}) {
-    this.#fs = fsFromOption(fs17);
+  constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs20 = defaultFS } = {}) {
+    this.#fs = fsFromOption(fs20);
     if (cwd instanceof URL || cwd.startsWith("file://")) {
       cwd = (0, import_node_url.fileURLToPath)(cwd);
     }
@@ -123142,11 +123085,11 @@ var PathScurryBase = class {
   /**
    * Get the depth of a provided path, string, or the cwd
    */
-  depth(path5 = this.cwd) {
-    if (typeof path5 === "string") {
-      path5 = this.cwd.resolve(path5);
+  depth(path4 = this.cwd) {
+    if (typeof path4 === "string") {
+      path4 = this.cwd.resolve(path4);
     }
-    return path5.depth();
+    return path4.depth();
   }
   /**
    * Return the cache of child entries.  Exposed so subclasses can create
@@ -123633,9 +123576,9 @@ var PathScurryBase = class {
     process17();
     return results;
   }
-  chdir(path5 = this.cwd) {
+  chdir(path4 = this.cwd) {
     const oldCwd = this.cwd;
-    this.cwd = typeof path5 === "string" ? this.cwd.resolve(path5) : path5;
+    this.cwd = typeof path4 === "string" ? this.cwd.resolve(path4) : path4;
     this.cwd[setAsCwd](oldCwd);
   }
 };
@@ -123661,8 +123604,8 @@ var PathScurryWin32 = class extends PathScurryBase {
   /**
    * @internal
    */
-  newRoot(fs17) {
-    return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs17 });
+  newRoot(fs20) {
+    return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs20 });
   }
   /**
    * Return true if the provided path string is an absolute path
@@ -123690,8 +123633,8 @@ var PathScurryPosix = class extends PathScurryBase {
   /**
    * @internal
    */
-  newRoot(fs17) {
-    return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs17 });
+  newRoot(fs20) {
+    return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs20 });
   }
   /**
    * Return true if the provided path string is an absolute path
@@ -123724,7 +123667,7 @@ var Pattern = class _Pattern {
   #isUNC;
   #isAbsolute;
   #followGlobstar = true;
-  constructor(patternList, globList, index, platform3) {
+  constructor(patternList, globList, index, platform4) {
     if (!isPatternList(patternList)) {
       throw new TypeError("empty pattern list");
     }
@@ -123741,7 +123684,7 @@ var Pattern = class _Pattern {
     this.#patternList = patternList;
     this.#globList = globList;
     this.#index = index;
-    this.#platform = platform3;
+    this.#platform = platform4;
     if (this.#index === 0) {
       if (this.isUNC()) {
         const [p0, p1, p2, p3, ...prest] = this.#patternList;
@@ -123883,12 +123826,12 @@ var Ignore = class {
   absoluteChildren;
   platform;
   mmopts;
-  constructor(ignored, { nobrace, nocase, noext, noglobstar, platform: platform3 = defaultPlatform2 }) {
+  constructor(ignored, { nobrace, nocase, noext, noglobstar, platform: platform4 = defaultPlatform2 }) {
     this.relative = [];
     this.absolute = [];
     this.relativeChildren = [];
     this.absoluteChildren = [];
-    this.platform = platform3;
+    this.platform = platform4;
     this.mmopts = {
       dot: true,
       nobrace,
@@ -123896,7 +123839,7 @@ var Ignore = class {
       noext,
       noglobstar,
       optimizationLevel: 2,
-      platform: platform3,
+      platform: platform4,
       nocomment: true,
       nonegate: true
     };
@@ -123991,8 +123934,8 @@ var MatchRecord = class {
   }
   // match, absolute, ifdir
   entries() {
-    return [...this.store.entries()].map(([path5, n]) => [
-      path5,
+    return [...this.store.entries()].map(([path4, n]) => [
+      path4,
       !!(n & 2),
       !!(n & 1)
     ]);
@@ -124197,9 +124140,9 @@ var GlobUtil = class {
   signal;
   maxDepth;
   includeChildMatches;
-  constructor(patterns, path5, opts) {
+  constructor(patterns, path4, opts) {
     this.patterns = patterns;
-    this.path = path5;
+    this.path = path4;
     this.opts = opts;
     this.#sep = !opts.posix && opts.platform === "win32" ? "\\" : "/";
     this.includeChildMatches = opts.includeChildMatches !== false;
@@ -124218,11 +124161,11 @@ var GlobUtil = class {
       });
     }
   }
-  #ignored(path5) {
-    return this.seen.has(path5) || !!this.#ignore?.ignored?.(path5);
+  #ignored(path4) {
+    return this.seen.has(path4) || !!this.#ignore?.ignored?.(path4);
   }
-  #childrenIgnored(path5) {
-    return !!this.#ignore?.childrenIgnored?.(path5);
+  #childrenIgnored(path4) {
+    return !!this.#ignore?.childrenIgnored?.(path4);
   }
   // backpressure mechanism
   pause() {
@@ -124437,8 +124380,8 @@ var GlobUtil = class {
 };
 var GlobWalker = class extends GlobUtil {
   matches = /* @__PURE__ */ new Set();
-  constructor(patterns, path5, opts) {
-    super(patterns, path5, opts);
+  constructor(patterns, path4, opts) {
+    super(patterns, path4, opts);
   }
   matchEmit(e) {
     this.matches.add(e);
@@ -124475,8 +124418,8 @@ var GlobWalker = class extends GlobUtil {
 };
 var GlobStream = class extends GlobUtil {
   results;
-  constructor(patterns, path5, opts) {
-    super(patterns, path5, opts);
+  constructor(patterns, path4, opts) {
+    super(patterns, path4, opts);
     this.results = new Minipass({
       signal: this.signal,
       objectMode: true
@@ -124774,15 +124717,15 @@ var import_crypto3 = require("crypto");
 function addMissingKeys(target, template, prefix = "") {
   const added = [];
   for (const key of Object.keys(template)) {
-    const path5 = prefix ? `${prefix}.${key}` : key;
+    const path4 = prefix ? `${prefix}.${key}` : key;
     if (!(key in target)) {
       target[key] = template[key];
-      added.push(path5);
+      added.push(path4);
     } else if (isPlainObject(target[key]) && isPlainObject(template[key])) {
       const nested = addMissingKeys(
         target[key],
         template[key],
-        path5
+        path4
       );
       added.push(...nested);
     }
@@ -125502,10 +125445,378 @@ var upgradeCommand = new Command("upgrade").description("Upgrade SmartStack pack
 
 // src/lib/license.ts
 var jwt = __toESM(require_jsonwebtoken());
-var fs8 = __toESM(require_lib());
-var path3 = __toESM(require("path"));
-var os3 = __toESM(require("os"));
-var PUBLIC_KEY = `-----BEGIN PUBLIC KEY-----
+var import_fs_extra11 = __toESM(require_lib());
+
+// src/lib/license-paths.ts
+var import_path9 = require("path");
+var import_os4 = require("os");
+var SMARTSTACK_DIR2 = ".smartstack";
+function getSmartStackDir() {
+  return (0, import_path9.join)((0, import_os4.homedir)(), SMARTSTACK_DIR2);
+}
+function getLicenseFilePath() {
+  return (0, import_path9.join)(getSmartStackDir(), "license.key");
+}
+function getLicenseCachePath() {
+  return (0, import_path9.join)(getSmartStackDir(), "license-cache.json");
+}
+function getApiKeyFilePath() {
+  return (0, import_path9.join)(getSmartStackDir(), "api-key");
+}
+function getConfigFilePath() {
+  return (0, import_path9.join)(getSmartStackDir(), "config.json");
+}
+
+// src/lib/device-id.ts
+var import_crypto4 = require("crypto");
+var import_child_process7 = require("child_process");
+var import_os5 = require("os");
+var import_path10 = require("path");
+var import_fs_extra8 = __toESM(require_lib());
+function getStableMacAddresses() {
+  const interfaces = (0, import_os5.networkInterfaces)();
+  const macs = [];
+  for (const [name, addrs] of Object.entries(interfaces)) {
+    if (!addrs) continue;
+    if (/^(veth|docker|br-|virbr|lo|vEthernet|isatap|Teredo)/i.test(name)) continue;
+    for (const addr of addrs) {
+      if (addr.mac && addr.mac !== "00:00:00:00:00:00" && !addr.internal) {
+        macs.push(addr.mac);
+      }
+    }
+  }
+  return macs.sort();
+}
+function getPlatformId() {
+  const os4 = (0, import_os5.platform)();
+  try {
+    if (os4 === "win32") {
+      const output = (0, import_child_process7.execSync)("wmic csproduct get uuid", {
+        encoding: "utf-8",
+        timeout: 5e3,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      const uuid = output.split("\n").map((l) => l.trim()).filter((l) => l && l !== "UUID")[0];
+      if (uuid) return uuid;
+    } else if (os4 === "linux") {
+      const machineId = import_fs_extra8.default.readFileSync("/etc/machine-id", "utf-8").trim();
+      if (machineId) return machineId;
+    } else if (os4 === "darwin") {
+      const output = (0, import_child_process7.execSync)(
+        "ioreg -rd1 -c IOPlatformExpertDevice | awk '/IOPlatformUUID/ { print $3 }'",
+        { encoding: "utf-8", timeout: 5e3, stdio: ["pipe", "pipe", "pipe"] }
+      );
+      const uuid = output.trim().replace(/"/g, "");
+      if (uuid) return uuid;
+    }
+  } catch {
+  }
+  return "";
+}
+function generateMachineFingerprint() {
+  const cpu = (0, import_os5.cpus)()[0];
+  const components = [
+    (0, import_os5.platform)(),
+    (0, import_os5.arch)(),
+    cpu?.model || "unknown-cpu",
+    String((0, import_os5.totalmem)()),
+    ...getStableMacAddresses(),
+    getPlatformId()
+  ];
+  return (0, import_crypto4.createHash)("sha256").update(components.join("|")).digest("hex");
+}
+async function getOrCreateInstanceId() {
+  const deviceFile = (0, import_path10.join)(getSmartStackDir(), "device.json");
+  if (await import_fs_extra8.default.pathExists(deviceFile)) {
+    try {
+      const data = await import_fs_extra8.default.readJSON(deviceFile);
+      if (data?.instanceId) return data.instanceId;
+    } catch {
+    }
+  }
+  const instanceId = (0, import_crypto4.randomUUID)();
+  await import_fs_extra8.default.ensureDir(getSmartStackDir());
+  await import_fs_extra8.default.writeJSON(deviceFile, { instanceId, createdAt: (/* @__PURE__ */ new Date()).toISOString() }, { spaces: 2 });
+  return instanceId;
+}
+async function getMachineIdentity() {
+  const [fingerprint, instanceId] = await Promise.all([
+    Promise.resolve(generateMachineFingerprint()),
+    getOrCreateInstanceId()
+  ]);
+  return {
+    fingerprint,
+    machineName: (0, import_os5.hostname)(),
+    instanceId
+  };
+}
+
+// src/lib/license-cache.ts
+var import_fs_extra9 = __toESM(require_lib());
+function createEmptyCache() {
+  return {
+    version: 1,
+    lastValidation: null,
+    lastHeartbeat: null,
+    lastValidationResult: null,
+    activation: null,
+    signingKey: null
+  };
+}
+async function loadCache() {
+  const cachePath = getLicenseCachePath();
+  if (!await import_fs_extra9.default.pathExists(cachePath)) {
+    return createEmptyCache();
+  }
+  try {
+    const data = await import_fs_extra9.default.readJSON(cachePath);
+    if (data?.version === 1) return data;
+    return createEmptyCache();
+  } catch {
+    return createEmptyCache();
+  }
+}
+async function saveCache(cache) {
+  await import_fs_extra9.default.ensureDir(getSmartStackDir());
+  await import_fs_extra9.default.writeJSON(getLicenseCachePath(), cache, { spaces: 2 });
+}
+async function clearCache() {
+  const cachePath = getLicenseCachePath();
+  if (await import_fs_extra9.default.pathExists(cachePath)) {
+    await import_fs_extra9.default.remove(cachePath);
+  }
+}
+function isCacheValid(cache, maxAgeMinutes = 60) {
+  if (!cache.lastValidation || !cache.lastValidationResult) return false;
+  const lastValidation = new Date(cache.lastValidation);
+  const ageMs = Date.now() - lastValidation.getTime();
+  return ageMs < maxAgeMinutes * 60 * 1e3;
+}
+function isHeartbeatDue(cache) {
+  if (!cache.activation) return false;
+  if (!cache.lastHeartbeat) return true;
+  const lastHeartbeat = new Date(cache.lastHeartbeat);
+  const intervalMs = (cache.activation.heartbeatIntervalHours || 168) * 60 * 60 * 1e3;
+  return Date.now() - lastHeartbeat.getTime() >= intervalMs;
+}
+function isInGracePeriod(expiresAt, gracePeriodDays) {
+  const expiry = new Date(expiresAt);
+  const now = Date.now();
+  const graceEndMs = expiry.getTime() + gracePeriodDays * 24 * 60 * 60 * 1e3;
+  if (now <= expiry.getTime()) {
+    return { inGrace: false, daysLeft: gracePeriodDays };
+  }
+  if (now <= graceEndMs) {
+    const daysLeft = Math.ceil((graceEndMs - now) / (24 * 60 * 60 * 1e3));
+    return { inGrace: true, daysLeft };
+  }
+  return { inGrace: false, daysLeft: 0 };
+}
+function isGraceExpired(expiresAt, gracePeriodDays) {
+  const expiry = new Date(expiresAt);
+  const graceEndMs = expiry.getTime() + gracePeriodDays * 24 * 60 * 60 * 1e3;
+  return Date.now() > graceEndMs;
+}
+function isSigningKeyCacheValid(cache) {
+  if (!cache.signingKey?.pem || !cache.signingKey?.fetchedAt) return false;
+  const fetchedAt = new Date(cache.signingKey.fetchedAt);
+  const ageMs = Date.now() - fetchedAt.getTime();
+  return ageMs < 24 * 60 * 60 * 1e3;
+}
+
+// src/lib/license-client.ts
+var import_path11 = require("path");
+var import_fs_extra10 = __toESM(require_lib());
+var DEFAULT_LICENSE_URL = "https://license.atlashub.ch";
+var REQUEST_TIMEOUT_MS = 1e4;
+async function getLicenseServerUrl() {
+  const envUrl = process.env.SMARTSTACK_LICENSE_URL;
+  if (envUrl) return envUrl.replace(/\/+$/, "");
+  try {
+    const configPath = getConfigFilePath();
+    if (await import_fs_extra10.default.pathExists(configPath)) {
+      const config = await import_fs_extra10.default.readJSON(configPath);
+      if (config?.licenseServerUrl) return config.licenseServerUrl.replace(/\/+$/, "");
+    }
+  } catch {
+  }
+  return DEFAULT_LICENSE_URL;
+}
+async function getApiKey() {
+  const envKey = process.env.SMARTSTACK_API_KEY;
+  if (envKey) return envKey.trim();
+  try {
+    const keyPath = getApiKeyFilePath();
+    if (await import_fs_extra10.default.pathExists(keyPath)) {
+      return (await import_fs_extra10.default.readFile(keyPath, "utf-8")).trim();
+    }
+  } catch {
+  }
+  return null;
+}
+async function saveApiKey(apiKey) {
+  const keyPath = getApiKeyFilePath();
+  await import_fs_extra10.default.ensureDir((0, import_path11.dirname)(keyPath));
+  await import_fs_extra10.default.writeFile(keyPath, apiKey.trim(), "utf-8");
+}
+async function removeApiKey() {
+  const keyPath = getApiKeyFilePath();
+  if (await import_fs_extra10.default.pathExists(keyPath)) {
+    await import_fs_extra10.default.remove(keyPath);
+  }
+}
+function createAbortSignal() {
+  return AbortSignal.timeout(REQUEST_TIMEOUT_MS);
+}
+async function handleResponse(response) {
+  if (response.ok) {
+    return await response.json();
+  }
+  let message;
+  try {
+    const body = await response.json();
+    message = body.message || body.detail || response.statusText;
+  } catch {
+    message = response.statusText;
+  }
+  const error = { status: response.status, message };
+  switch (response.status) {
+    case 404:
+      error.message = `License not found: ${message}`;
+      break;
+    case 409:
+      error.message = `Conflict: ${message}`;
+      break;
+    case 410:
+      error.message = `License revoked or expired: ${message}`;
+      break;
+    case 429:
+      error.message = `Rate limited: ${message}`;
+      break;
+  }
+  throw error;
+}
+var LicenseClient = class {
+  constructor(baseUrl) {
+    this.baseUrl = baseUrl;
+  }
+  /**
+   * GET /api/v1/public/signing-key — fetch the RSA public key (PEM)
+   */
+  async fetchSigningKey() {
+    const response = await fetch(`${this.baseUrl}/api/v1/public/signing-key`, {
+      signal: createAbortSignal()
+    });
+    if (!response.ok) {
+      throw { status: response.status, message: "Failed to fetch signing key" };
+    }
+    const contentType = response.headers.get("content-type") || "";
+    if (contentType.includes("application/json")) {
+      const body = await response.json();
+      return body.publicKey;
+    }
+    return response.text();
+  }
+  /**
+   * GET /api/v1/public/health — check server availability
+   */
+  async healthCheck() {
+    try {
+      const response = await fetch(`${this.baseUrl}/api/v1/public/health`, {
+        signal: createAbortSignal()
+      });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * POST /api/v1/public/trial — self-service trial registration
+   */
+  async registerTrial(data) {
+    const response = await fetch(`${this.baseUrl}/api/v1/public/trial`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(data),
+      signal: createAbortSignal()
+    });
+    return handleResponse(response);
+  }
+  /**
+   * POST /api/v1/machine/activate — activate a machine (Bearer JWT auth)
+   */
+  async activate(jwt2, data) {
+    const response = await fetch(`${this.baseUrl}/api/v1/machine/activate`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${jwt2}`
+      },
+      body: JSON.stringify(data),
+      signal: createAbortSignal()
+    });
+    return handleResponse(response);
+  }
+  /**
+   * POST /api/v1/machine/heartbeat — send heartbeat (Bearer JWT auth)
+   */
+  async heartbeat(jwt2, data) {
+    const response = await fetch(`${this.baseUrl}/api/v1/machine/heartbeat`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${jwt2}`
+      },
+      body: JSON.stringify(data),
+      signal: createAbortSignal()
+    });
+    return handleResponse(response);
+  }
+  /**
+   * GET /api/v1/machine/validate — validate license status (Bearer JWT auth)
+   */
+  async validate(jwt2) {
+    const response = await fetch(`${this.baseUrl}/api/v1/machine/validate`, {
+      headers: { Authorization: `Bearer ${jwt2}` },
+      signal: createAbortSignal()
+    });
+    return handleResponse(response);
+  }
+  // ── API Key variants (for CI/CD) ───────────────────────────────────────
+  /**
+   * POST /api/v1/machine/activate/key — activate via API key
+   */
+  async activateWithApiKey(apiKey, licenseJwt, data) {
+    const response = await fetch(`${this.baseUrl}/api/v1/machine/activate/key`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Api-Key": apiKey
+      },
+      body: JSON.stringify({ licenseJwt, ...data }),
+      signal: createAbortSignal()
+    });
+    return handleResponse(response);
+  }
+  /**
+   * POST /api/v1/machine/heartbeat/key — heartbeat via API key
+   */
+  async heartbeatWithApiKey(apiKey, licenseJwt, data) {
+    const response = await fetch(`${this.baseUrl}/api/v1/machine/heartbeat/key`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Api-Key": apiKey
+      },
+      body: JSON.stringify({ licenseJwt, ...data }),
+      signal: createAbortSignal()
+    });
+    return handleResponse(response);
+  }
+};
+
+// src/lib/license.ts
+var LEGACY_PUBLIC_KEY = `-----BEGIN PUBLIC KEY-----
 MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA3Rgy76bx4SPse6vSnduR
 OSv8YOk/8lGSK6/a+1cxyppsymCR8p/+yxzLl+phbCtm4qPhrp4K8BFVyyCw0uhG
 xWyHzXvlbVfEO0YG5Ug5B3NVFr9/QaAHV1lVHgahxVFCglJZj7yVbFOY4uSpWNNg
@@ -125514,86 +125825,251 @@ csxveQKoRdG8wCb3BY4//8F0qLz21lqwPIM+cGZhUM1+ycYvC7HEke5xMxy6cCAS
 6Xwvxno/Ml8D2sXTBLNMt8JVFwoAuDohz3xdpxjfJDvzgwSH0bCLF7TOzEGRJF+s
 GwIDAQAB
 -----END PUBLIC KEY-----`;
-var ISSUER = "atlashub.io";
-var PRODUCT_ID = "smartstack-cli";
-function getLicenseFilePath() {
-  const configDir = path3.join(os3.homedir(), ".smartstack");
-  return path3.join(configDir, "license.key");
+var LEGACY_ISSUER = "atlashub.io";
+var NEW_ISSUER = "license.smartstack.com";
+var LEGACY_PRODUCT_IDS = ["smartstack-cli", "smartstackcli"];
+var NEW_PRODUCT_TIERS = ["standard", "plus", "premium"];
+function detectJwtFormat(token) {
+  try {
+    const headerB64 = token.split(".")[0];
+    const header = JSON.parse(Buffer.from(headerB64, "base64url").toString());
+    if (header.alg === "RS512") return "new";
+  } catch {
+  }
+  return "legacy";
 }
 async function saveLicenseKey(licenseKey) {
   const licensePath = getLicenseFilePath();
-  await fs8.ensureDir(path3.dirname(licensePath));
-  await fs8.writeFile(licensePath, licenseKey.trim(), "utf-8");
+  await import_fs_extra11.default.ensureDir(getSmartStackDir());
+  await import_fs_extra11.default.writeFile(licensePath, licenseKey.trim(), "utf-8");
 }
 async function loadLicenseKey() {
   const licensePath = getLicenseFilePath();
-  if (await fs8.pathExists(licensePath)) {
-    return (await fs8.readFile(licensePath, "utf-8")).trim();
+  if (await import_fs_extra11.default.pathExists(licensePath)) {
+    return (await import_fs_extra11.default.readFile(licensePath, "utf-8")).trim();
   }
   return null;
 }
 async function removeLicenseKey() {
   const licensePath = getLicenseFilePath();
-  if (await fs8.pathExists(licensePath)) {
-    await fs8.remove(licensePath);
+  if (await import_fs_extra11.default.pathExists(licensePath)) {
+    await import_fs_extra11.default.remove(licensePath);
   }
 }
-function validateLicenseKey(licenseKey) {
-  if (!licenseKey || licenseKey.trim().length === 0) {
-    return { valid: false, error: "License key is empty" };
+function normalizeFeatures(decoded) {
+  if (decoded.ft && Array.isArray(decoded.ft)) {
+    const features = decoded.ft.map((scope) => ({
+      applicationId: scope.aid || null,
+      applicationCode: scope.app || "*",
+      modules: (scope.modules || []).map((m) => ({
+        moduleId: m.mid || "",
+        moduleCode: m.mod || ""
+      }))
+    }));
+    return { features };
+  }
+  if (decoded.features) {
+    const raw = typeof decoded.features === "string" ? JSON.parse(decoded.features) : decoded.features;
+    if (Array.isArray(raw) && raw.length > 0 && typeof raw[0] === "string") {
+      return {
+        features: [{ applicationId: null, applicationCode: "*", modules: [] }],
+        legacyFeatures: raw
+      };
+    }
+  }
+  return {
+    features: [{ applicationId: null, applicationCode: "*", modules: [] }],
+    legacyFeatures: ["*"]
+  };
+}
+function extractLicenseInfo(decoded) {
+  const now = /* @__PURE__ */ new Date();
+  const expiresAt = decoded.exp ? new Date(decoded.exp * 1e3) : new Date(now.getTime() + 365 * 24 * 60 * 60 * 1e3);
+  const issuedAt = decoded.iat ? new Date(decoded.iat * 1e3) : now;
+  const isPerpetual = (decoded.perp ?? decoded.perpetual) === true;
+  const isExpired = !isPerpetual && expiresAt < now;
+  const daysRemaining = isPerpetual ? Infinity : Math.max(0, Math.ceil((expiresAt.getTime() - now.getTime()) / (24 * 60 * 60 * 1e3)));
+  const { features, legacyFeatures } = normalizeFeatures(decoded);
+  const bnd = decoded.bnd || decoded.bind;
+  const bind = bnd ? {
+    machineHash: bnd.mh ?? bnd.machine_hash,
+    offline: bnd.ofl ?? bnd.offline
+  } : void 0;
+  return {
+    companyId: decoded.sub || "unknown",
+    clientName: decoded.cn ?? decoded.client_name,
+    edition: decoded.prd ?? decoded.edition ?? "standard",
+    product: decoded.prd ?? decoded.product ?? decoded.aud,
+    jti: decoded.jti,
+    environment: decoded.env ?? decoded.environment,
+    features,
+    legacyFeatures,
+    maxInstances: decoded.mi ?? decoded.max_instances,
+    maxUsers: decoded.mu ?? decoded.max_users,
+    issuedAt,
+    expiresAt,
+    renewalDate: decoded.rnd ?? decoded.renewal_date,
+    daysRemaining,
+    isValid: !isExpired,
+    isExpired,
+    isPerpetual,
+    gracePeriodDays: decoded.gp ?? decoded.grace_period_days ?? 15,
+    bind
+  };
+}
+function validateLegacyLicenseKey(licenseKey) {
+  if (!licenseKey?.trim()) {
+    return { valid: false, error: "License key is empty", warnings: [], source: "legacy" };
   }
   try {
-    const decoded = jwt.verify(licenseKey, PUBLIC_KEY, {
+    const decoded = jwt.verify(licenseKey, LEGACY_PUBLIC_KEY, {
       algorithms: ["RS256"],
-      issuer: ISSUER
+      issuer: LEGACY_ISSUER
     });
-    const productId = decoded.product_id || decoded.aud;
-    if (productId !== PRODUCT_ID) {
+    const productId = decoded.product_id || decoded.product || decoded.aud;
+    if (!LEGACY_PRODUCT_IDS.includes(productId)) {
       return {
         valid: false,
-        error: `Invalid license: This license is for "${productId}", not "${PRODUCT_ID}"`
-      };
-    }
-    const now = /* @__PURE__ */ new Date();
-    const expiresAt = decoded.exp ? new Date(decoded.exp * 1e3) : new Date(now.getTime() + 365 * 24 * 60 * 60 * 1e3);
-    const issuedAt = decoded.iat ? new Date(decoded.iat * 1e3) : now;
-    const isExpired = expiresAt < now;
-    const daysRemaining = Math.max(0, Math.ceil((expiresAt.getTime() - now.getTime()) / (24 * 60 * 60 * 1e3)));
-    let features = ["*"];
-    if (decoded.features) {
-      features = typeof decoded.features === "string" ? JSON.parse(decoded.features) : decoded.features;
-    }
-    let limits = {};
-    if (decoded.limits) {
-      limits = typeof decoded.limits === "string" ? JSON.parse(decoded.limits) : decoded.limits;
-    }
-    const license = {
-      companyId: decoded.sub || "unknown",
-      edition: decoded.edition || "starter",
-      features,
-      limits,
-      issuedAt,
-      expiresAt,
-      daysRemaining,
-      isValid: !isExpired,
-      isExpired
-    };
-    if (isExpired) {
+        error: `Invalid license: This license is for "${productId}", not "smartstack-cli"`,
+        warnings: [],
+        source: "legacy"
+      };
+    }
+    const license = extractLicenseInfo(decoded);
+    const warnings = [
+      "This license uses the legacy format (RS256). It will continue to work but please upgrade to a new license for enhanced features."
+    ];
+    if (license.isExpired) {
       return {
         valid: false,
-        error: `License expired on ${expiresAt.toISOString().split("T")[0]}`,
-        license
+        error: `License expired on ${license.expiresAt.toISOString().split("T")[0]}`,
+        license,
+        warnings,
+        source: "legacy"
       };
     }
-    return { valid: true, license };
+    return { valid: true, license, warnings, source: "legacy" };
   } catch (error) {
     if (error instanceof jwt.JsonWebTokenError) {
-      return { valid: false, error: `Invalid license signature: ${error.message}` };
+      return { valid: false, error: `Invalid license signature: ${error.message}`, warnings: [], source: "legacy" };
     }
     if (error instanceof jwt.TokenExpiredError) {
-      return { valid: false, error: "License has expired" };
+      return { valid: false, error: "License has expired", warnings: [], source: "legacy" };
     }
-    return { valid: false, error: `License validation failed: ${error.message}` };
+    return { valid: false, error: `License validation failed: ${error.message}`, warnings: [], source: "legacy" };
+  }
+}
+function validateNewLicenseKey(licenseKey, signingKeyPem) {
+  if (!licenseKey?.trim()) {
+    return { valid: false, error: "License key is empty", warnings: [], source: "offline" };
+  }
+  try {
+    const decoded = jwt.verify(licenseKey, signingKeyPem, {
+      algorithms: ["RS512"],
+      issuer: NEW_ISSUER
+    });
+    const productId = decoded.prd || decoded.product || decoded.aud;
+    const allValid = [...NEW_PRODUCT_TIERS, ...LEGACY_PRODUCT_IDS];
+    if (!allValid.includes(productId)) {
+      return {
+        valid: false,
+        error: `Invalid license: unrecognized product "${productId}"`,
+        warnings: [],
+        source: "offline"
+      };
+    }
+    const license = extractLicenseInfo(decoded);
+    if (license.isExpired && !license.isPerpetual) {
+      const graceDays = license.gracePeriodDays ?? 15;
+      if (isGraceExpired(license.expiresAt.toISOString(), graceDays)) {
+        return {
+          valid: false,
+          error: `License expired on ${license.expiresAt.toISOString().split("T")[0]} (grace period ended)`,
+          license,
+          warnings: [],
+          source: "offline"
+        };
+      }
+      const grace = isInGracePeriod(license.expiresAt.toISOString(), graceDays);
+      if (grace.inGrace) {
+        return {
+          valid: true,
+          license,
+          warnings: [`License expired but within grace period (${grace.daysLeft} day(s) remaining)`],
+          source: "offline"
+        };
+      }
+    }
+    return { valid: true, license, warnings: [], source: "offline" };
+  } catch (error) {
+    if (error instanceof jwt.JsonWebTokenError) {
+      return { valid: false, error: `Invalid license signature: ${error.message}`, warnings: [], source: "offline" };
+    }
+    if (error instanceof jwt.TokenExpiredError) {
+      return { valid: false, error: "License has expired", warnings: [], source: "offline" };
+    }
+    return { valid: false, error: `License validation failed: ${error.message}`, warnings: [], source: "offline" };
+  }
+}
+function validateOfflineLicense(licenseKey, signingKeyPem, fingerprint) {
+  const result = validateNewLicenseKey(licenseKey, signingKeyPem);
+  if (!result.valid) return result;
+  const bind = result.license?.bind;
+  if (bind?.machineHash && bind.machineHash !== fingerprint) {
+    return {
+      valid: false,
+      error: "Machine fingerprint mismatch. This license is bound to a different machine.",
+      warnings: [],
+      source: "offline"
+    };
+  }
+  return result;
+}
+function validateLicenseKey(licenseKey) {
+  if (!licenseKey?.trim()) {
+    return { valid: false, error: "License key is empty", warnings: [], source: "legacy" };
+  }
+  const format = detectJwtFormat(licenseKey);
+  if (format === "legacy") {
+    return validateLegacyLicenseKey(licenseKey);
+  }
+  try {
+    const decoded = jwt.decode(licenseKey);
+    if (!decoded) {
+      return { valid: false, error: "Invalid JWT token", warnings: [], source: "offline" };
+    }
+    const productId = decoded.prd || decoded.product || decoded.aud;
+    const allValid = [...NEW_PRODUCT_TIERS, ...LEGACY_PRODUCT_IDS];
+    if (!allValid.includes(productId)) {
+      return {
+        valid: false,
+        error: `Invalid license: unrecognized product "${productId}"`,
+        warnings: [],
+        source: "offline"
+      };
+    }
+    const license = extractLicenseInfo(decoded);
+    return {
+      valid: true,
+      license,
+      warnings: ["License signature not verified (signing key unavailable). Run a command to trigger online validation."],
+      source: "offline"
+    };
+  } catch {
+    return { valid: false, error: "Invalid JWT token", warnings: [], source: "offline" };
+  }
+}
+async function getSigningKey(cache, client) {
+  if (isSigningKeyCacheValid(cache)) {
+    return cache.signingKey.pem;
+  }
+  try {
+    const pem = await client.fetchSigningKey();
+    cache.signingKey = { pem, fetchedAt: (/* @__PURE__ */ new Date()).toISOString() };
+    await saveCache(cache);
+    return pem;
+  } catch {
+    return cache.signingKey?.pem || null;
   }
 }
 async function validateCurrentLicense() {
@@ -125601,44 +126077,359 @@ async function validateCurrentLicense() {
   if (!licenseKey) {
     return {
       valid: false,
-      error: "No license found. Please activate with: smartstack license activate <key>"
+      error: "No license found. Please activate with: smartstack license activate <key>",
+      warnings: [],
+      source: "offline"
+    };
+  }
+  const format = detectJwtFormat(licenseKey);
+  if (format === "legacy") {
+    return validateLegacyLicenseKey(licenseKey);
+  }
+  const cache = await loadCache();
+  const baseUrl = await getLicenseServerUrl();
+  const client = new LicenseClient(baseUrl);
+  const decoded = jwt.decode(licenseKey);
+  const bndClaim = decoded?.bnd || decoded?.bind;
+  if (bndClaim?.ofl === true || bndClaim?.offline === true) {
+    const signingKey = await getSigningKey(cache, client);
+    if (!signingKey) {
+      return {
+        valid: false,
+        error: "Cannot validate offline license: signing key unavailable. Connect to the internet at least once.",
+        warnings: [],
+        source: "offline"
+      };
+    }
+    const fingerprint = generateMachineFingerprint();
+    return validateOfflineLicense(licenseKey, signingKey, fingerprint);
+  }
+  if (isCacheValid(cache)) {
+    const cached = cache.lastValidationResult;
+    const warnings = [];
+    if (cached.revoked) {
+      return { valid: false, error: "License has been revoked", warnings: [], source: "cache" };
+    }
+    if (!cached.isPerpetual && isGraceExpired(cached.expiresAt, cached.gracePeriodDays)) {
+      return { valid: false, error: "License expired (grace period ended)", warnings: [], source: "cache" };
+    }
+    if (!cached.isPerpetual) {
+      const grace = isInGracePeriod(cached.expiresAt, cached.gracePeriodDays);
+      if (grace.inGrace) {
+        warnings.push(`License expired but within grace period (${grace.daysLeft} day(s) remaining)`);
+      }
+    }
+    if (isHeartbeatDue(cache)) {
+      await performHeartbeat(licenseKey, cache, client);
+    }
+    const license = buildLicenseInfoFromCache(cached, decoded);
+    return { valid: true, license, warnings, source: "cache" };
+  }
+  try {
+    const serverResult = await client.validate(licenseKey);
+    return await handleOnlineValidation(serverResult, licenseKey, cache, client, decoded);
+  } catch (err) {
+    if (cache.lastValidationResult) {
+      const cached = cache.lastValidationResult;
+      const warnings = ["License server unreachable. Using cached validation result."];
+      if (cached.revoked) {
+        return { valid: false, error: "License has been revoked (cached)", warnings, source: "cache" };
+      }
+      if (!cached.isPerpetual && isGraceExpired(cached.expiresAt, cached.gracePeriodDays)) {
+        return { valid: false, error: "License expired (cached, grace period ended)", warnings, source: "cache" };
+      }
+      const license = buildLicenseInfoFromCache(cached, decoded);
+      return { valid: true, license, warnings, source: "cache" };
+    }
+    const signingKey = await getSigningKey(cache, client);
+    if (signingKey) {
+      const result = validateNewLicenseKey(licenseKey, signingKey);
+      result.warnings.push("License server unreachable. Validated offline with cached signing key.");
+      return result;
+    }
+    const apiErr = err;
+    return {
+      valid: false,
+      error: apiErr?.message || "Unable to validate license: server unreachable and no cached data.",
+      warnings: [],
+      source: "offline"
     };
   }
-  return validateLicenseKey(licenseKey);
+}
+async function handleOnlineValidation(serverResult, licenseKey, cache, client, decoded) {
+  const warnings = [];
+  cache.lastValidation = (/* @__PURE__ */ new Date()).toISOString();
+  const normalizedFeatures = Array.isArray(serverResult.features) ? serverResult.features.map((f) => ({
+    applicationId: f.application_id || null,
+    applicationCode: f.application_code || "*",
+    modules: (f.modules || []).map((m) => ({
+      moduleId: m.module_id || "",
+      moduleCode: m.module_code || ""
+    }))
+  })) : [{ applicationId: null, applicationCode: "*", modules: [] }];
+  cache.lastValidationResult = {
+    valid: serverResult.valid,
+    revoked: serverResult.revoked,
+    environment: serverResult.environment,
+    features: normalizedFeatures,
+    maxInstances: serverResult.maxInstances,
+    maxUsers: serverResult.maxUsers,
+    expiresAt: serverResult.expiresAt,
+    gracePeriodDays: serverResult.gracePeriodDays,
+    isPerpetual: serverResult.isPerpetual,
+    renewalDate: serverResult.renewalDate || null
+  };
+  await saveCache(cache);
+  if (serverResult.revoked) {
+    return { valid: false, error: "License has been revoked", warnings: [], source: "online" };
+  }
+  if (!serverResult.valid && !serverResult.isPerpetual) {
+    const graceDays = serverResult.gracePeriodDays ?? 15;
+    if (isGraceExpired(serverResult.expiresAt, graceDays)) {
+      return {
+        valid: false,
+        error: `License expired on ${serverResult.expiresAt.split("T")[0]} (grace period ended)`,
+        warnings: [],
+        source: "online"
+      };
+    }
+    const grace = isInGracePeriod(serverResult.expiresAt, graceDays);
+    if (grace.inGrace) {
+      warnings.push(`License expired but within grace period (${grace.daysLeft} day(s) remaining)`);
+    }
+  }
+  if (isHeartbeatDue(cache)) {
+    await performHeartbeat(licenseKey, cache, client);
+  }
+  const license = buildLicenseInfoFromValidateResponse(serverResult, decoded);
+  return { valid: true, license, warnings, source: "online" };
+}
+async function performHeartbeat(licenseKey, cache, client) {
+  try {
+    const identity = await getMachineIdentity();
+    const apiKey = await getApiKey();
+    let response;
+    if (apiKey) {
+      response = await client.heartbeatWithApiKey(apiKey, licenseKey, {
+        machineFingerprint: identity.fingerprint,
+        instanceId: identity.instanceId
+      });
+    } else {
+      response = await client.heartbeat(licenseKey, {
+        machineFingerprint: identity.fingerprint,
+        instanceId: identity.instanceId
+      });
+    }
+    cache.lastHeartbeat = (/* @__PURE__ */ new Date()).toISOString();
+    await saveCache(cache);
+    if (response.newJwtToken) {
+      await saveLicenseKey(response.newJwtToken);
+      logger.debug("License JWT updated from heartbeat response");
+    }
+  } catch {
+    logger.debug("Heartbeat failed (will retry later)");
+  }
+}
+async function activateLicense(licenseKey) {
+  if (!licenseKey?.trim()) {
+    return { valid: false, error: "License key is empty", warnings: [], source: "offline" };
+  }
+  const format = detectJwtFormat(licenseKey);
+  if (format === "legacy") {
+    const result = validateLegacyLicenseKey(licenseKey);
+    if (result.valid) {
+      await saveLicenseKey(licenseKey);
+    }
+    return result;
+  }
+  const baseUrl = await getLicenseServerUrl();
+  const client = new LicenseClient(baseUrl);
+  const cache = await loadCache();
+  const identity = await getMachineIdentity();
+  const signingKey = await getSigningKey(cache, client);
+  try {
+    const apiKey = await getApiKey();
+    let activation;
+    if (apiKey) {
+      activation = await client.activateWithApiKey(apiKey, licenseKey, {
+        machineFingerprint: identity.fingerprint,
+        machineName: identity.machineName,
+        instanceId: identity.instanceId
+      });
+    } else {
+      activation = await client.activate(licenseKey, {
+        machineFingerprint: identity.fingerprint,
+        machineName: identity.machineName,
+        instanceId: identity.instanceId
+      });
+    }
+    await saveLicenseKey(licenseKey);
+    cache.activation = {
+      activated: activation.activated,
+      activatedAt: activation.activatedAt || (/* @__PURE__ */ new Date()).toISOString(),
+      machineFingerprint: identity.fingerprint,
+      instanceId: identity.instanceId,
+      heartbeatIntervalHours: activation.heartbeatIntervalHours,
+      gracePeriodDays: activation.gracePeriodDays
+    };
+    cache.lastHeartbeat = (/* @__PURE__ */ new Date()).toISOString();
+    await saveCache(cache);
+    if (signingKey) {
+      const result = validateNewLicenseKey(licenseKey, signingKey);
+      result.source = "online";
+      return result;
+    }
+    const decoded = jwt.decode(licenseKey);
+    if (decoded) {
+      return {
+        valid: true,
+        license: extractLicenseInfo(decoded),
+        warnings: [],
+        source: "online"
+      };
+    }
+    return { valid: true, warnings: ["Activated but could not decode license details"], source: "online" };
+  } catch (err) {
+    const apiErr = err;
+    let error = apiErr?.message || "Activation failed";
+    if (apiErr?.status === 409) {
+      error = "Maximum number of machine activations reached. Deactivate another machine first.";
+    } else if (apiErr?.status === 410) {
+      error = "This license has been revoked or has expired.";
+    } else if (apiErr?.status === 404) {
+      error = "License not found on the server.";
+    }
+    return { valid: false, error, warnings: [], source: "online" };
+  }
+}
+async function deactivateLicense() {
+  try {
+    const cache = await loadCache();
+    if (cache.activation) {
+      logger.debug("Clearing local license activation");
+    }
+  } catch {
+  }
+  await removeLicenseKey();
+  await clearCache();
+}
+function buildLicenseInfoFromCache(cached, decoded) {
+  const expiresAt = new Date(cached.expiresAt);
+  const now = /* @__PURE__ */ new Date();
+  const daysRemaining = cached.isPerpetual ? Infinity : Math.max(0, Math.ceil((expiresAt.getTime() - now.getTime()) / (24 * 60 * 60 * 1e3)));
+  return {
+    companyId: decoded?.sub || "unknown",
+    clientName: decoded?.cn ?? decoded?.client_name,
+    edition: decoded?.prd ?? decoded?.edition ?? "standard",
+    product: decoded?.prd ?? decoded?.product,
+    jti: decoded?.jti,
+    environment: cached.environment,
+    features: cached.features,
+    maxInstances: cached.maxInstances,
+    maxUsers: cached.maxUsers,
+    issuedAt: decoded?.iat ? new Date(decoded.iat * 1e3) : now,
+    expiresAt,
+    renewalDate: cached.renewalDate ?? void 0,
+    daysRemaining,
+    isValid: cached.valid && !cached.revoked,
+    isExpired: !cached.isPerpetual && expiresAt < now,
+    isPerpetual: cached.isPerpetual,
+    gracePeriodDays: cached.gracePeriodDays
+  };
+}
+function buildLicenseInfoFromValidateResponse(response, decoded) {
+  const expiresAt = new Date(response.expiresAt);
+  const now = /* @__PURE__ */ new Date();
+  const daysRemaining = response.isPerpetual ? Infinity : Math.max(0, Math.ceil((expiresAt.getTime() - now.getTime()) / (24 * 60 * 60 * 1e3)));
+  const features = Array.isArray(response.features) ? response.features.map((f) => ({
+    applicationId: f.application_id || null,
+    applicationCode: f.application_code || "*",
+    modules: (f.modules || []).map((m) => ({
+      moduleId: m.module_id || "",
+      moduleCode: m.module_code || ""
+    }))
+  })) : [{ applicationId: null, applicationCode: "*", modules: [] }];
+  return {
+    companyId: response.clientId,
+    clientName: response.clientName,
+    edition: response.product || decoded?.prd || "standard",
+    product: response.product,
+    jti: decoded?.jti,
+    environment: response.environment,
+    features,
+    maxInstances: response.maxInstances,
+    maxUsers: response.maxUsers,
+    issuedAt: decoded?.iat ? new Date(decoded.iat * 1e3) : now,
+    expiresAt,
+    renewalDate: response.renewalDate ?? void 0,
+    daysRemaining,
+    isValid: response.valid && !response.revoked,
+    isExpired: !response.isPerpetual && expiresAt < now,
+    isPerpetual: response.isPerpetual,
+    gracePeriodDays: response.gracePeriodDays
+  };
 }
 async function getLicenseInfo() {
   const result = await validateCurrentLicense();
   return result.valid ? result.license : null;
 }
-function formatLicenseInfo(license) {
-  const status = license.isExpired ? "\u{1F534} EXPIRED" : license.daysRemaining <= 30 ? `\u{1F7E1} ${license.daysRemaining} days remaining` : `\u{1F7E2} Valid (${license.daysRemaining} days)`;
+function formatLicenseInfo(license, source) {
+  const status = license.isExpired ? "\u{1F534} EXPIRED" : license.daysRemaining <= 30 ? `\u{1F7E1} ${license.daysRemaining} days remaining` : license.isPerpetual ? "\u{1F7E2} Perpetual" : `\u{1F7E2} Valid (${license.daysRemaining} days)`;
+  const edition = license.edition.toUpperCase();
+  const env2 = license.environment ? ` (${license.environment})` : "";
+  const sourceLabel = source ? ` [${source}]` : "";
+  let featuresDisplay;
+  if (license.legacyFeatures) {
+    featuresDisplay = license.legacyFeatures.join(", ");
+  } else {
+    const parts = [];
+    for (const scope of license.features) {
+      if (scope.applicationCode === "*") {
+        parts.push("All applications");
+      } else if (scope.modules.length > 0) {
+        const mods = scope.modules.map((m) => m.moduleCode).join(", ");
+        parts.push(`${scope.applicationCode} (${mods})`);
+      } else {
+        parts.push(scope.applicationCode);
+      }
+    }
+    featuresDisplay = parts.join(", ") || "N/A";
+  }
+  const limitsLine = license.maxInstances || license.maxUsers ? `\u2551  Limits:      ${`${license.maxInstances ?? "\u221E"} instances, ${license.maxUsers ?? "\u221E"} users`.padEnd(45)}\u2551
+` : "";
   return `
 \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
 \u2551                    SMARTSTACK CLI LICENSE                     \u2551
 \u2560\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2563
-\u2551  Status:      ${status.padEnd(45)}\u2551
-\u2551  Company:     ${license.companyId.padEnd(45)}\u2551
-\u2551  Edition:     ${license.edition.toUpperCase().padEnd(45)}\u2551
-\u2551  Expires:     ${license.expiresAt.toISOString().split("T")[0].padEnd(45)}\u2551
+\u2551  Status:      ${(status + sourceLabel).padEnd(45)}\u2551
+\u2551  Company:     ${(license.clientName || license.companyId).padEnd(45)}\u2551
+\u2551  Edition:     ${(edition + env2).padEnd(45)}\u2551
+\u2551  Expires:     ${(license.isPerpetual ? "Never" : license.expiresAt.toISOString().split("T")[0]).padEnd(45)}\u2551
 \u2560\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2563
-\u2551  Features:    ${license.features.join(", ").padEnd(45)}\u2551
-\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
+\u2551  Features:    ${featuresDisplay.padEnd(45)}\u2551
+${limitsLine}\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
 `;
 }
 
 // src/commands/license.ts
 function createLicenseCommand() {
   const license = new Command("license").description("Manage SmartStack CLI license");
-  license.command("activate <key>").description("Activate a license key").action(async (key) => {
-    logger.info("Validating license key...\n");
-    const result = validateLicenseKey(key);
+  license.command("activate <key>").description("Activate a license key on this machine").action(async (key) => {
+    logger.info("Activating license...\n");
+    const result = await activateLicense(key);
     if (!result.valid) {
-      logger.error(`License Activation Failed: ${result.error || "Invalid license"}`);
+      logger.error(`Activation Failed: ${result.error || "Invalid license"}`);
       process.exit(1);
     }
-    await saveLicenseKey(key);
     logger.success("License activated successfully!");
-    console.log(formatLicenseInfo(result.license));
+    console.log(formatLicenseInfo(result.license, result.source));
+    const identity = await getMachineIdentity();
+    console.log(source_default.gray(`  Machine:     ${identity.machineName}`));
+    console.log(source_default.gray(`  Fingerprint: ${identity.fingerprint.substring(0, 12)}...`));
+    console.log(source_default.gray(`  Instance:    ${identity.instanceId}`));
+    for (const warning of result.warnings) {
+      logger.warning(warning);
+    }
   });
   license.command("status").description("Show current license status").action(async () => {
     const result = await validateCurrentLicense();
@@ -125646,34 +126437,162 @@ function createLicenseCommand() {
       logger.error(`No Valid License: ${result.error || "License not found"}`);
       logger.info("\nTo activate a license:");
       logger.info("  smartstack license activate <your-license-key>");
+      logger.info("\nTo request a trial:");
+      logger.info("  smartstack license trial");
       logger.info("\nTo purchase a license:");
       logger.info("  https://atlashub.io/products/smartstack-cli");
       process.exit(1);
     }
-    console.log(formatLicenseInfo(result.license));
-    if (result.license.daysRemaining <= 30) {
+    console.log(formatLicenseInfo(result.license, result.source));
+    const licenseKey = await loadLicenseKey();
+    const format = licenseKey ? detectJwtFormat(licenseKey) : "unknown";
+    const cache = await loadCache();
+    console.log(source_default.cyan("  Extended Info:"));
+    console.log(source_default.gray(`  Format:       ${format === "legacy" ? "Legacy (RS256)" : "New (RS512)"}`));
+    console.log(source_default.gray(`  Environment:  ${result.license.environment || "N/A"}`));
+    console.log(source_default.gray(`  Source:       ${result.source}`));
+    if (cache.activation) {
+      console.log(source_default.gray(`  Activated:    ${cache.activation.activatedAt?.split("T")[0] || "N/A"}`));
+      console.log(source_default.gray(`  Heartbeat:    every ${cache.activation.heartbeatIntervalHours}h`));
+      console.log(source_default.gray(`  Grace Period: ${cache.activation.gracePeriodDays} days`));
+    }
+    if (cache.lastHeartbeat) {
+      console.log(source_default.gray(`  Last Beat:    ${cache.lastHeartbeat}`));
+    }
+    console.log();
+    for (const warning of result.warnings) {
+      logger.warning(warning);
+    }
+    if (result.license.daysRemaining <= 30 && !result.license.isPerpetual) {
       logger.warning(`License expires in ${result.license.daysRemaining} days`);
       logger.info("Renew at: https://atlashub.io/products/smartstack-cli");
     }
   });
-  license.command("deactivate").description("Remove the current license").action(async () => {
+  license.command("deactivate").description("Remove the current license from this machine").action(async () => {
     const key = await loadLicenseKey();
     if (!key) {
       logger.warning("No license is currently active");
       return;
     }
-    await removeLicenseKey();
+    const { confirm } = await lib_default.prompt([
+      {
+        type: "confirm",
+        name: "confirm",
+        message: "Are you sure you want to deactivate the license on this machine?",
+        default: false
+      }
+    ]);
+    if (!confirm) {
+      logger.info("Deactivation cancelled");
+      return;
+    }
+    await deactivateLicense();
     logger.success("License deactivated successfully");
   });
   license.command("verify <key>").description("Verify a license key without activating it").action(async (key) => {
     logger.info("Verifying license key...\n");
+    const format = detectJwtFormat(key);
     const result = validateLicenseKey(key);
     if (!result.valid) {
       logger.error(`License Invalid: ${result.error || "Unknown error"}`);
       process.exit(1);
     }
-    logger.success("License is valid!");
-    console.log(formatLicenseInfo(result.license));
+    logger.success(`License is valid! (format: ${format === "legacy" ? "Legacy RS256" : "New RS512"})`);
+    console.log(formatLicenseInfo(result.license, result.source));
+    for (const warning of result.warnings) {
+      logger.warning(warning);
+    }
+  });
+  license.command("trial").description("Request a free trial license").action(async () => {
+    logger.info("SmartStack CLI Trial Registration\n");
+    const answers = await lib_default.prompt([
+      {
+        type: "input",
+        name: "fullName",
+        message: "Your full name:",
+        validate: (v) => v.trim().length > 0 || "Name is required"
+      },
+      {
+        type: "input",
+        name: "email",
+        message: "Your email address:",
+        validate: (v) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(v) || "Valid email required"
+      },
+      {
+        type: "input",
+        name: "company",
+        message: "Company name:",
+        validate: (v) => v.trim().length > 0 || "Company is required"
+      },
+      {
+        type: "list",
+        name: "teamSize",
+        message: "Team size:",
+        choices: ["1-5", "6-20", "21-50", "51-200", "200+"]
+      }
+    ]);
+    const spinner = logger.spinner("Registering trial...");
+    try {
+      const baseUrl = await getLicenseServerUrl();
+      const client = new LicenseClient(baseUrl);
+      const response = await client.registerTrial(answers);
+      spinner.succeed("Trial registered!");
+      const cliLicense = response.licenses.find(
+        (l) => ["smartstack-cli", "smartstackcli", "SmartStackCli", "standard", "Standard"].includes(l.product)
+      );
+      if (!cliLicense) {
+        logger.error("No CLI license found in trial response");
+        process.exit(1);
+      }
+      logger.info("\nActivating trial license...");
+      const activationResult = await activateLicense(cliLicense.token);
+      if (activationResult.valid) {
+        logger.success("Trial license activated!");
+        console.log(formatLicenseInfo(activationResult.license, activationResult.source));
+        console.log(source_default.gray(`  Trial expires: ${response.expiresAt.split("T")[0]}`));
+      } else {
+        await saveLicenseKey(cliLicense.token);
+        logger.warning(`Trial created but activation failed: ${activationResult.error}`);
+        logger.info("The license key has been saved. Try running any command to trigger online validation.");
+      }
+    } catch (err) {
+      spinner.fail("Trial registration failed");
+      const apiErr = err;
+      if (apiErr?.status === 429) {
+        logger.error("Rate limited. A trial has already been created for this email or IP.");
+      } else {
+        logger.error(apiErr?.message || "Unknown error");
+      }
+      process.exit(1);
+    }
+  });
+  const apiKeyCmd = license.command("api-key").description("Manage API key for CI/CD authentication");
+  apiKeyCmd.command("set <key>").description("Configure an API key for machine-to-machine authentication").action(async (key) => {
+    if (!key.startsWith("sk_")) {
+      logger.error('Invalid API key format. Keys should start with "sk_"');
+      process.exit(1);
+    }
+    await saveApiKey(key);
+    logger.success("API key configured successfully");
+    console.log(source_default.gray(`  Key prefix: ${key.substring(0, 10)}...`));
+  });
+  apiKeyCmd.command("remove").description("Remove the stored API key").action(async () => {
+    const existing = await getApiKey();
+    if (!existing) {
+      logger.warning("No API key is currently configured");
+      return;
+    }
+    await removeApiKey();
+    logger.success("API key removed");
+  });
+  apiKeyCmd.command("status").description("Check if an API key is configured").action(async () => {
+    const existing = await getApiKey();
+    if (existing) {
+      logger.success(`API key configured: ${existing.substring(0, 10)}...`);
+    } else {
+      logger.info("No API key configured");
+      logger.info("  Set one with: smartstack license api-key set <key>");
+    }
   });
   return license;
 }
@@ -125784,24 +126703,24 @@ var checkMcpCommand = new Command("check-mcp").description("Check MCP servers st
 
 // src/commands/ralph.ts
 var import_cli_table33 = __toESM(require_cli_table3());
-var import_fs_extra8 = __toESM(require_lib());
-var import_path9 = require("path");
+var import_fs_extra12 = __toESM(require_lib());
+var import_path12 = require("path");
 function getRalphDir() {
-  return (0, import_path9.join)(process.cwd(), ".ralph");
+  return (0, import_path12.join)(process.cwd(), ".ralph");
 }
 async function readRalphLogs(limit = 50) {
-  const logsDir = (0, import_path9.join)(getRalphDir(), "logs");
-  if (!await import_fs_extra8.default.pathExists(logsDir)) {
+  const logsDir = (0, import_path12.join)(getRalphDir(), "logs");
+  if (!await import_fs_extra12.default.pathExists(logsDir)) {
     return [];
   }
   try {
-    const files = await import_fs_extra8.default.readdir(logsDir);
+    const files = await import_fs_extra12.default.readdir(logsDir);
     const logFiles = files.filter((f) => f.endsWith(".log")).sort().reverse();
     if (logFiles.length === 0) {
       return [];
     }
-    const latestLog = (0, import_path9.join)(logsDir, logFiles[0]);
-    const content = await import_fs_extra8.default.readFile(latestLog, "utf-8");
+    const latestLog = (0, import_path12.join)(logsDir, logFiles[0]);
+    const content = await import_fs_extra12.default.readFile(latestLog, "utf-8");
     const lines = content.split("\n");
     return lines.slice(-limit);
   } catch {
@@ -125809,17 +126728,17 @@ async function readRalphLogs(limit = 50) {
   }
 }
 async function listReports() {
-  const reportsDir = (0, import_path9.join)(getRalphDir(), "reports");
-  if (!await import_fs_extra8.default.pathExists(reportsDir)) {
+  const reportsDir = (0, import_path12.join)(getRalphDir(), "reports");
+  if (!await import_fs_extra12.default.pathExists(reportsDir)) {
     return [];
   }
   try {
-    const files = await import_fs_extra8.default.readdir(reportsDir);
+    const files = await import_fs_extra12.default.readdir(reportsDir);
     const reports = [];
     for (const file of files) {
       if (file.endsWith(".md") || file.endsWith(".json")) {
-        const filePath = (0, import_path9.join)(reportsDir, file);
-        const stat = await import_fs_extra8.default.stat(filePath);
+        const filePath = (0, import_path12.join)(reportsDir, file);
+        const stat = await import_fs_extra12.default.stat(filePath);
         reports.push({
           name: file,
           date: stat.mtime,
@@ -125904,19 +126823,19 @@ ralphCommand.command("start").description("Verify prerequisites and prepare Ralp
     }
   }
   logger.step(4, 5, "Checking logs directory...");
-  const logsDir = (0, import_path9.join)(getRalphDir(), "logs");
-  if (await import_fs_extra8.default.pathExists(logsDir)) {
+  const logsDir = (0, import_path12.join)(getRalphDir(), "logs");
+  if (await import_fs_extra12.default.pathExists(logsDir)) {
     logger.success("Logs directory ready");
   } else {
-    await import_fs_extra8.default.ensureDir(logsDir);
+    await import_fs_extra12.default.ensureDir(logsDir);
     logger.success("Logs directory created");
   }
   logger.step(5, 5, "Checking reports directory...");
-  const reportsDir = (0, import_path9.join)(getRalphDir(), "reports");
-  if (await import_fs_extra8.default.pathExists(reportsDir)) {
+  const reportsDir = (0, import_path12.join)(getRalphDir(), "reports");
+  if (await import_fs_extra12.default.pathExists(reportsDir)) {
     logger.success("Reports directory ready");
   } else {
-    await import_fs_extra8.default.ensureDir(reportsDir);
+    await import_fs_extra12.default.ensureDir(reportsDir);
     logger.success("Reports directory created");
   }
   console.log();
@@ -125972,9 +126891,9 @@ ralphCommand.command("status").description("Show Ralph status and configuration"
     }
     console.log();
   }
-  const logsDir = (0, import_path9.join)(getRalphDir(), "logs");
-  if (await import_fs_extra8.default.pathExists(logsDir)) {
-    const logFiles = (await import_fs_extra8.default.readdir(logsDir)).filter((f) => f.endsWith(".log"));
+  const logsDir = (0, import_path12.join)(getRalphDir(), "logs");
+  if (await import_fs_extra12.default.pathExists(logsDir)) {
+    const logFiles = (await import_fs_extra12.default.readdir(logsDir)).filter((f) => f.endsWith(".log"));
     if (logFiles.length > 0) {
       console.log(source_default.bold("Logs:"));
       console.log(`  ${logFiles.length} log file(s)`);
@@ -126051,7 +126970,7 @@ ralphCommand.command("report").description("List or view feature reports").optio
   logger.header(`Report: ${reportToShow.name}`);
   console.log(source_default.gray(`Date: ${reportToShow.date.toLocaleString()}`));
   console.log(source_default.gray("\u2500".repeat(60)));
-  const content = await import_fs_extra8.default.readFile(reportToShow.path, "utf-8");
+  const content = await import_fs_extra12.default.readFile(reportToShow.path, "utf-8");
   console.log(content);
 });
 ralphCommand.command("init").description("Initialize Ralph in the current project").option("-f, --force", "Overwrite existing configuration").action(async (options) => {
@@ -126083,15 +127002,15 @@ ralphCommand.command("init").description("Initialize Ralph in the current projec
 
 // src/commands/doctor.ts
 var import_cli_table34 = __toESM(require_cli_table3());
-var import_child_process7 = require("child_process");
-var import_fs_extra9 = __toESM(require_lib());
-var import_path10 = require("path");
+var import_child_process8 = require("child_process");
+var import_fs_extra13 = __toESM(require_lib());
+var import_path13 = require("path");
 function getNodeVersion() {
   return process.version;
 }
 function getDotNetVersion() {
   try {
-    const output = (0, import_child_process7.execSync)("dotnet --version", {
+    const output = (0, import_child_process8.execSync)("dotnet --version", {
       encoding: "utf-8",
       timeout: 5e3,
       stdio: ["pipe", "pipe", "pipe"]
@@ -126103,7 +127022,7 @@ function getDotNetVersion() {
 }
 function getGitVersion() {
   try {
-    const output = (0, import_child_process7.execSync)("git --version", {
+    const output = (0, import_child_process8.execSync)("git --version", {
       encoding: "utf-8",
       timeout: 5e3,
       stdio: ["pipe", "pipe", "pipe"]
@@ -126115,7 +127034,7 @@ function getGitVersion() {
 }
 function getNpmVersion() {
   try {
-    const output = (0, import_child_process7.execSync)("npm --version", {
+    const output = (0, import_child_process8.execSync)("npm --version", {
       encoding: "utf-8",
       timeout: 5e3,
       stdio: ["pipe", "pipe", "pipe"]
@@ -126127,7 +127046,7 @@ function getNpmVersion() {
 }
 var doctorCommand = new Command("doctor").description("Run diagnostics and check SmartStack health").option("--json", "Output as JSON").option("-v, --verbose", "Show detailed information").action(async (options) => {
   const diagnostics = [];
-  const pkg2 = JSON.parse(await import_fs_extra9.default.readFile((0, import_path10.join)(__dirname, "..", "package.json"), "utf-8"));
+  const pkg2 = JSON.parse(await import_fs_extra13.default.readFile((0, import_path13.join)(__dirname, "..", "package.json"), "utf-8"));
   if (!options.json) {
     console.log(source_default.cyan(`
 \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
@@ -126155,6 +127074,47 @@ var doctorCommand = new Command("doctor").description("Run diagnostics and check
       fix: "smartstack license activate <key>"
     });
   }
+  try {
+    const baseUrl = await getLicenseServerUrl();
+    const client = new LicenseClient(baseUrl);
+    const healthy = await client.healthCheck();
+    diagnostics.push({
+      name: "License Server",
+      status: healthy ? "ok" : "warning",
+      message: healthy ? `Reachable (${baseUrl})` : "Unreachable",
+      details: !healthy ? "License server is not responding. Online validation will use cache." : void 0
+    });
+  } catch {
+    diagnostics.push({
+      name: "License Server",
+      status: "warning",
+      message: "Could not check server health"
+    });
+  }
+  const cache = await loadCache();
+  if (cache.activation) {
+    diagnostics.push({
+      name: "Activation",
+      status: "ok",
+      message: `Active since ${cache.activation.activatedAt?.split("T")[0] || "unknown"}`,
+      details: `Fingerprint: ${cache.activation.machineFingerprint?.substring(0, 12)}...`
+    });
+    const heartbeatDue = isHeartbeatDue(cache);
+    diagnostics.push({
+      name: "Heartbeat",
+      status: heartbeatDue ? "warning" : "ok",
+      message: heartbeatDue ? `Overdue (last: ${cache.lastHeartbeat || "never"})` : `OK (last: ${cache.lastHeartbeat?.split("T")[0] || "N/A"})`,
+      details: `Interval: ${cache.activation.heartbeatIntervalHours}h`,
+      fix: heartbeatDue ? "Run any command to trigger a heartbeat" : void 0
+    });
+  } else {
+    diagnostics.push({
+      name: "Activation",
+      status: licenseResult.valid ? "warning" : "info",
+      message: "Not activated on this machine",
+      fix: "smartstack license activate <key>"
+    });
+  }
   const nodeVersion = getNodeVersion();
   const nodeVersionNum = parseInt(nodeVersion.replace("v", "").split(".")[0], 10);
   diagnostics.push({
@@ -126233,8 +127193,8 @@ var doctorCommand = new Command("doctor").description("Run diagnostics and check
     status: installation.gitflow.configExists ? "ok" : "info",
     message: installation.gitflow.configExists ? "Configured" : "Not configured"
   });
-  const ralphSkillPath = (0, import_path10.join)(installation.location, "skills", "ralph-loop", "SKILL.md");
-  const ralphSkillExists = await import_fs_extra9.default.pathExists(ralphSkillPath);
+  const ralphSkillPath = (0, import_path13.join)(installation.location, "skills", "ralph-loop", "SKILL.md");
+  const ralphSkillExists = await import_fs_extra13.default.pathExists(ralphSkillPath);
   diagnostics.push({
     name: "Ralph Skill",
     status: ralphSkillExists ? "ok" : "warning",
@@ -126243,7 +127203,7 @@ var doctorCommand = new Command("doctor").description("Run diagnostics and check
     fix: !ralphSkillExists ? "smartstack install" : void 0
   });
   const ralphStatus = await checkRalphInstallation();
-  const isSmartStackProject = await import_fs_extra9.default.pathExists((0, import_path10.join)(process.cwd(), ".smartstack", "config.json"));
+  const isSmartStackProject = await import_fs_extra13.default.pathExists((0, import_path13.join)(process.cwd(), ".smartstack", "config.json"));
   const ralphConfigStatus = ralphStatus.configExists ? "ok" : isSmartStackProject ? "warning" : "info";
   diagnostics.push({
     name: "Ralph Config",
@@ -126345,8 +127305,8 @@ ${source_default.gray(item.details)}`;
 var import_mssql = __toESM(require_mssql());
 var import_bcryptjs = __toESM(require_bcryptjs());
 var import_fs4 = require("fs");
-var import_path11 = require("path");
-var import_child_process8 = require("child_process");
+var import_path14 = require("path");
+var import_child_process9 = require("child_process");
 function tryLoadNativeDriver() {
   try {
     return require("mssql/msnodesqlv8");
@@ -126373,7 +127333,7 @@ function findAppSettings(apiFolder) {
     return [];
   }
   const files = (0, import_fs4.readdirSync)(apiFolder);
-  return files.filter((f) => f.startsWith("appsettings") && f.endsWith(".json")).map((f) => (0, import_path11.join)(apiFolder, f));
+  return files.filter((f) => f.startsWith("appsettings") && f.endsWith(".json")).map((f) => (0, import_path14.join)(apiFolder, f));
 }
 function extractConnectionString(filePath) {
   try {
@@ -126402,7 +127362,7 @@ function executeSqlCmd(server, database, query, sqlAuth) {
   const sqlServer = server === "(local)" ? "." : server;
   const authFlag = sqlAuth ? `-U "${sqlAuth.user}" -P "${sqlAuth.password}"` : "-E";
   const cmd = `sqlcmd -S "${sqlServer}" -d "${database}" ${authFlag} -I -C -Q "${query.replace(/"/g, '\\"')}" -h -1 -W`;
-  return (0, import_child_process8.execSync)(cmd, { encoding: "utf-8", timeout: 15e3 }).trim();
+  return (0, import_child_process9.execSync)(cmd, { encoding: "utf-8", timeout: 15e3 }).trim();
 }
 function isLoginFailure(error) {
   const msg = error instanceof Error ? error.message : String(error);
@@ -126442,12 +127402,12 @@ async function promptSqlCredentials() {
 }
 function detectSmartStackApp() {
   const cwd = process.cwd();
-  const srcDir = (0, import_path11.join)(cwd, "src");
+  const srcDir = (0, import_path14.join)(cwd, "src");
   if ((0, import_fs4.existsSync)(srcDir)) {
     const folders = (0, import_fs4.readdirSync)(srcDir);
     const apiFolder = folders.find((f) => f.endsWith(".Api"));
     if (apiFolder) {
-      return (0, import_path11.join)(srcDir, apiFolder);
+      return (0, import_path14.join)(srcDir, apiFolder);
     }
   }
   const possiblePaths = [
@@ -126482,14 +127442,14 @@ adminCommand.command("reset").description("Reset the localAdmin account password
       process.exit(1);
     }
     let selectedFile;
-    const localFile = appSettingsFiles.find((f) => (0, import_path11.basename)(f) === "appsettings.Local.json");
+    const localFile = appSettingsFiles.find((f) => (0, import_path14.basename)(f) === "appsettings.Local.json");
     if (localFile && extractConnectionString(localFile)) {
       selectedFile = localFile;
     } else if (appSettingsFiles.length === 1) {
       selectedFile = appSettingsFiles[0];
     } else {
       const choices = appSettingsFiles.map((f) => ({
-        name: (0, import_path11.basename)(f),
+        name: (0, import_path14.basename)(f),
         value: f
       }));
       const { file } = await lib_default.prompt([
@@ -126505,7 +127465,7 @@ adminCommand.command("reset").description("Reset the localAdmin account password
     }
     connectionString = extractConnectionString(selectedFile);
     if (!connectionString) {
-      logger.error(`No connection string found in ${(0, import_path11.basename)(selectedFile)}`);
+      logger.error(`No connection string found in ${(0, import_path14.basename)(selectedFile)}`);
       process.exit(1);
     }
   }
@@ -126681,8 +127641,8 @@ adminCommand.command("reset").description("Reset the localAdmin account password
 
 // src/commands/mcp.ts
 var import_cli_table35 = __toESM(require_cli_table3());
-var import_child_process9 = require("child_process");
-var import_os4 = require("os");
+var import_child_process10 = require("child_process");
+var import_os6 = require("os");
 var mcpCommand = new Command("mcp").description("MCP server management (CLI + VS Code)").action(() => {
   console.log(source_default.cyan(`
 \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
@@ -126712,7 +127672,7 @@ mcpCommand.command("install").description("Register MCP servers in Claude Code C
   }));
   currentStep++;
   logger.step(currentStep, totalSteps, "Registering in ~/.claude/settings.json...");
-  logger.debug(`Home directory: ${(0, import_os4.homedir)()}`);
+  logger.debug(`Home directory: ${(0, import_os6.homedir)()}`);
   logger.debug(`Target: ${getClaudeSettingsPath()}`);
   const claudeResult = await registerMcpInClaudeSettings(servers);
   if (claudeResult.success) {
@@ -126746,7 +127706,7 @@ mcpCommand.command("install").description("Register MCP servers in Claude Code C
         const serversToInstall = options.force ? REQUIRED_MCP_SERVERS : REQUIRED_MCP_SERVERS.filter((s) => cliResult.missingServers.includes(s.name));
         for (const server of serversToInstall) {
           const spinner = logger.spinner(`Registering ${server.name} in CLI...`);
-          const result = (0, import_child_process9.spawnSync)(
+          const result = (0, import_child_process10.spawnSync)(
             "claude",
             ["mcp", "add", "--scope", "user", server.name, "--", server.command, ...server.args],
             { encoding: "utf-8", shell: true, timeout: 15e3 }
@@ -126904,7 +127864,7 @@ mcpCommand.command("remove").description("Unregister MCP servers from CLI and VS
   if (!options.vscodeOnly) {
     logger.info("Removing from Claude Code CLI...");
     for (const server of REQUIRED_MCP_SERVERS) {
-      const result = (0, import_child_process9.spawnSync)("claude", ["mcp", "remove", server.name], {
+      const result = (0, import_child_process10.spawnSync)("claude", ["mcp", "remove", server.name], {
         encoding: "utf-8",
         shell: true,
         timeout: 1e4
@@ -126936,8 +127896,8 @@ mcpCommand.command("remove").description("Unregister MCP servers from CLI and VS
 });
 
 // src/commands/derive-prd.ts
-var import_fs_extra10 = __toESM(require_lib());
-var import_path12 = require("path");
+var import_fs_extra14 = __toESM(require_lib());
+var import_path15 = require("path");
 
 // src/utils/task-generator.ts
 var LAYER_ORDER = [
@@ -127516,9 +128476,9 @@ function getPrdFileCounts(prd) {
 // src/commands/derive-prd.ts
 function readSmartStackNamespace() {
   try {
-    const configPath = (0, import_path12.join)(process.cwd(), ".smartstack", "config.json");
-    if (import_fs_extra10.default.existsSync(configPath)) {
-      const config = import_fs_extra10.default.readJsonSync(configPath);
+    const configPath = (0, import_path15.join)(process.cwd(), ".smartstack", "config.json");
+    if (import_fs_extra14.default.existsSync(configPath)) {
+      const config = import_fs_extra14.default.readJsonSync(configPath);
       return config.baseNamespace;
     }
   } catch {
@@ -127526,14 +128486,14 @@ function readSmartStackNamespace() {
   return void 0;
 }
 async function findModuleFeatureFiles(masterPath) {
-  const master = await import_fs_extra10.default.readJson(masterPath);
-  const masterDir = (0, import_path12.dirname)(masterPath);
+  const master = await import_fs_extra14.default.readJson(masterPath);
+  const masterDir = (0, import_path15.dirname)(masterPath);
   const paths = [];
   if (master.modules) {
     for (const mod of master.modules) {
       if (mod.featureJsonPath) {
-        const fullPath = (0, import_path12.join)(masterDir, "..", "..", mod.featureJsonPath);
-        if (await import_fs_extra10.default.pathExists(fullPath)) {
+        const fullPath = (0, import_path15.join)(masterDir, "..", "..", mod.featureJsonPath);
+        if (await import_fs_extra14.default.pathExists(fullPath)) {
           paths.push(fullPath);
         }
       }
@@ -127547,12 +128507,12 @@ var derivePrdCommand = new Command("derive-prd").description("Extract prd.json p
     process.exit(1);
   }
   const namespace = readSmartStackNamespace();
-  const ralphDir = (0, import_path12.join)(process.cwd(), ".ralph");
-  await import_fs_extra10.default.ensureDir(ralphDir);
+  const ralphDir = (0, import_path15.join)(process.cwd(), ".ralph");
+  await import_fs_extra14.default.ensureDir(ralphDir);
   let featurePaths = [];
   if (options.application) {
-    const appPath = (0, import_path12.join)(process.cwd(), options.application);
-    if (!await import_fs_extra10.default.pathExists(appPath)) {
+    const appPath = (0, import_path15.join)(process.cwd(), options.application);
+    if (!await import_fs_extra14.default.pathExists(appPath)) {
       console.log(source_default.red(`Application feature.json not found: ${appPath}`));
       process.exit(1);
     }
@@ -127564,8 +128524,8 @@ var derivePrdCommand = new Command("derive-prd").description("Extract prd.json p
     featurePaths = modulePaths.map((p) => ({ path: p, isApplicationMode: true }));
     console.log(source_default.cyan(`Found ${featurePaths.length} module(s) to process`));
   } else if (options.feature) {
-    const featurePath = (0, import_path12.join)(process.cwd(), options.feature);
-    if (!await import_fs_extra10.default.pathExists(featurePath)) {
+    const featurePath = (0, import_path15.join)(process.cwd(), options.feature);
+    if (!await import_fs_extra14.default.pathExists(featurePath)) {
       console.log(source_default.red(`Feature.json not found: ${featurePath}`));
       process.exit(1);
     }
@@ -127574,7 +128534,7 @@ var derivePrdCommand = new Command("derive-prd").description("Extract prd.json p
   let totalGenerated = 0;
   let totalErrors = 0;
   for (const entry of featurePaths) {
-    const featureJson = await import_fs_extra10.default.readJson(entry.path);
+    const featureJson = await import_fs_extra14.default.readJson(entry.path);
     const moduleName = featureJson.metadata?.module ?? "unknown";
     console.log(source_default.cyan(`
 Processing module: ${source_default.bold(moduleName)}`));
@@ -127592,20 +128552,20 @@ Processing module: ${source_default.bold(moduleName)}`));
     }
     let cliVersion = "unknown";
     try {
-      const pkg2 = import_fs_extra10.default.readJsonSync((0, import_path12.join)(__dirname, "..", "..", "package.json"));
+      const pkg2 = import_fs_extra14.default.readJsonSync((0, import_path15.join)(__dirname, "..", "..", "package.json"));
       cliVersion = pkg2.version ?? "unknown";
     } catch {
     }
-    const relativePath = (0, import_path12.relative)(process.cwd(), entry.path);
+    const relativePath = (0, import_path15.relative)(process.cwd(), entry.path);
     const unified = extractUnifiedPrd(featureJson, relativePath, namespace, cliVersion);
     const prd = extractPrd(featureJson, relativePath, namespace);
     let outputPath;
     if (options.output && !entry.isApplicationMode) {
-      outputPath = (0, import_path12.join)(process.cwd(), options.output);
+      outputPath = (0, import_path15.join)(process.cwd(), options.output);
     } else {
-      outputPath = (0, import_path12.join)(ralphDir, `prd-${moduleName}.json`);
+      outputPath = (0, import_path15.join)(ralphDir, `prd-${moduleName}.json`);
     }
-    await import_fs_extra10.default.writeJson(outputPath, unified, { spaces: 2 });
+    await import_fs_extra14.default.writeJson(outputPath, unified, { spaces: 2 });
     totalGenerated++;
     const completenessWarnings = validatePrdCompleteness(prd, featureJson);
     if (completenessWarnings.length > 0) {
@@ -127626,7 +128586,7 @@ Processing module: ${source_default.bold(moduleName)}`));
         console.log(source_default.yellow(`    - ${te}`));
       }
     }
-    const relOutput = (0, import_path12.relative)(process.cwd(), outputPath);
+    const relOutput = (0, import_path15.relative)(process.cwd(), outputPath);
     console.log(source_default.green(`  Generated: ${relOutput} (unified v3)`));
     console.log(source_default.gray(`    UCs: ${prd.requirements.useCases.length} | FRs: ${prd.requirements.functionalRequirements.length} | BRs: ${prd.businessRules.length}`));
     console.log(source_default.gray(`    Endpoints: ${prd.architecture.apiEndpoints.length} | Sections: ${prd.architecture.sections.length}`));
@@ -127654,12 +128614,12 @@ Processing module: ${source_default.bold(moduleName)}`));
 var import_cli_table36 = __toESM(require_cli_table3());
 
 // src/lib/wsl-provisioner.ts
-var import_child_process10 = require("child_process");
+var import_child_process11 = require("child_process");
 var import_fs5 = require("fs");
-var import_path13 = require("path");
+var import_path16 = require("path");
 function wslExec(command, timeout = 1e4) {
   try {
-    const output = (0, import_child_process10.execSync)(`wsl -e bash -c "${command.replace(/"/g, '\\"')}"`, {
+    const output = (0, import_child_process11.execSync)(`wsl -e bash -c "${command.replace(/"/g, '\\"')}"`, {
       encoding: "utf-8",
       timeout,
       stdio: ["pipe", "pipe", "pipe"]
@@ -127671,7 +128631,7 @@ function wslExec(command, timeout = 1e4) {
 }
 function wslInstall(command, timeout = 12e4) {
   try {
-    const output = (0, import_child_process10.execSync)(`wsl -e bash -c "${command.replace(/"/g, '\\"')}"`, {
+    const output = (0, import_child_process11.execSync)(`wsl -e bash -c "${command.replace(/"/g, '\\"')}"`, {
       encoding: "utf-8",
       timeout,
       stdio: ["pipe", "pipe", "pipe"]
@@ -127688,7 +128648,7 @@ function parseWslList(raw) {
 }
 function checkWsl() {
   try {
-    const statusRaw = (0, import_child_process10.execSync)("wsl --status", {
+    const statusRaw = (0, import_child_process11.execSync)("wsl --status", {
       encoding: "utf-8",
       timeout: 1e4,
       stdio: ["pipe", "pipe", "pipe"]
@@ -127698,7 +128658,7 @@ function checkWsl() {
     if (versionMatch) version2 = parseInt(versionMatch[1], 10);
     let defaultDistro = null;
     try {
-      const listRaw = (0, import_child_process10.execSync)("wsl --list --verbose", {
+      const listRaw = (0, import_child_process11.execSync)("wsl --list --verbose", {
         encoding: "utf-8",
         timeout: 1e4,
         stdio: ["pipe", "pipe", "pipe"]
@@ -127949,7 +128909,7 @@ var SMARTSTACK_PROFILE_NAME = "SmartStack Dev";
 var SMARTSTACK_PROFILE_GUID = "{17ce5bfe-17ed-5f3a-ab15-5cd5baafed5b}";
 function checkWindowsTerminal() {
   try {
-    (0, import_child_process10.execSync)("where wt", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], timeout: 5e3 });
+    (0, import_child_process11.execSync)("where wt", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], timeout: 5e3 });
     return { installed: true, version: "installed" };
   } catch {
     return { installed: false, version: null };
@@ -127960,7 +128920,7 @@ async function installWindowsTerminal() {
   if (status.installed) return { success: true, version: "installed", skipped: true };
   const spinner = logger.spinner("Installing Windows Terminal via winget...");
   try {
-    (0, import_child_process10.execSync)("winget install Microsoft.WindowsTerminal --accept-source-agreements --accept-package-agreements", {
+    (0, import_child_process11.execSync)("winget install Microsoft.WindowsTerminal --accept-source-agreements --accept-package-agreements", {
       encoding: "utf-8",
       timeout: 12e4,
       stdio: ["pipe", "pipe", "pipe"]
@@ -127985,11 +128945,11 @@ async function installWindowsTerminal() {
 function getWtSettingsPath() {
   const localAppData = process.env.LOCALAPPDATA;
   if (!localAppData) return null;
-  const standardPath = (0, import_path13.join)(localAppData, "Packages", "Microsoft.WindowsTerminal_8wekyb3d8bbwe", "LocalState", "settings.json");
+  const standardPath = (0, import_path16.join)(localAppData, "Packages", "Microsoft.WindowsTerminal_8wekyb3d8bbwe", "LocalState", "settings.json");
   if ((0, import_fs5.existsSync)(standardPath)) return standardPath;
-  const previewPath = (0, import_path13.join)(localAppData, "Packages", "Microsoft.WindowsTerminalPreview_8wekyb3d8bbwe", "LocalState", "settings.json");
+  const previewPath = (0, import_path16.join)(localAppData, "Packages", "Microsoft.WindowsTerminalPreview_8wekyb3d8bbwe", "LocalState", "settings.json");
   if ((0, import_fs5.existsSync)(previewPath)) return previewPath;
-  const unpackagedPath = (0, import_path13.join)(localAppData, "Microsoft", "Windows Terminal", "settings.json");
+  const unpackagedPath = (0, import_path16.join)(localAppData, "Microsoft", "Windows Terminal", "settings.json");
   if ((0, import_fs5.existsSync)(unpackagedPath)) return unpackagedPath;
   return null;
 }
@@ -128030,7 +128990,7 @@ function configureWindowsTerminal() {
 }
 function launchWindowsTerminal() {
   try {
-    (0, import_child_process10.spawn)("wt", ["-p", SMARTSTACK_PROFILE_NAME], {
+    (0, import_child_process11.spawn)("wt", ["-p", SMARTSTACK_PROFILE_NAME], {
       detached: true,
       stdio: "ignore"
     }).unref();
@@ -128302,9 +129262,9 @@ tmuxCommand.command("status").description("Show WSL development environment stat
 
 // src/index.ts
 var import_fs6 = require("fs");
-var import_path14 = require("path");
-var pkg = JSON.parse((0, import_fs6.readFileSync)((0, import_path14.join)(__dirname, "..", "package.json"), "utf-8"));
-var LICENSE_FREE_COMMANDS = ["license", "help", "--help", "-h", "--version", "-v"];
+var import_path17 = require("path");
+var pkg = JSON.parse((0, import_fs6.readFileSync)((0, import_path17.join)(__dirname, "..", "package.json"), "utf-8"));
+var LICENSE_FREE_COMMANDS = ["license", "doctor", "help", "--help", "-h", "--version", "-v"];
 async function main2() {
   const program2 = new Command();
   program2.name("smartstack").description(source_default.cyan("SmartStack Claude Code automation toolkit")).version(pkg.version, "-v, --version");
@@ -128341,6 +129301,9 @@ async function main2() {
 \u2551   To activate a license:                                  \u2551
 \u2551   ${source_default.cyan("smartstack license activate <your-key>")}             \u2551
 \u2551                                                           \u2551
+\u2551   To request a free trial:                                \u2551
+\u2551   ${source_default.cyan("smartstack license trial")}                           \u2551
+\u2551                                                           \u2551
 \u2551   To purchase a license:                                  \u2551
 \u2551   ${source_default.cyan("https://atlashub.io/products/smartstack-cli")}        \u2551
 \u2551                                                           \u2551
@@ -128348,6 +129311,11 @@ async function main2() {
 `));
       process.exit(1);
     }
+    if (result.warnings?.length) {
+      for (const warning of result.warnings) {
+        console.log(source_default.yellow(`\u26A0 ${warning}`));
+      }
+    }
   }
   program2.action(() => {
     console.log(source_default.cyan(`