npm - @atlashub/smartstack-cli - Versions diffs - 2.6.2 → 2.7.0 - Mend

@atlashub/smartstack-cli 2.6.2 → 2.7.0

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

Files changed (37) hide show

package/dist/index.js CHANGED Viewed

@@ -974,7 +974,7 @@ var require_command = __commonJS({
     var EventEmitter2 = require("events").EventEmitter;
     var childProcess2 = require("child_process");
     var path5 = require("path");
-    var fs15 = require("fs");
+    var fs16 = require("fs");
     var process17 = require("process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -1907,10 +1907,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
           const localBin = path5.resolve(baseDir, baseName);
-          if (fs15.existsSync(localBin)) return localBin;
+          if (fs16.existsSync(localBin)) return localBin;
           if (sourceExt.includes(path5.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext2) => fs15.existsSync(`${localBin}${ext2}`)
+            (ext2) => fs16.existsSync(`${localBin}${ext2}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -1922,7 +1922,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs15.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs16.realpathSync(this._scriptPath);
           } catch (err) {
             resolvedScriptPath = this._scriptPath;
           }
@@ -4734,54 +4734,54 @@ var require_polyfills = __commonJS({
     }
     var chdir;
     module2.exports = patch;
-    function patch(fs15) {
+    function patch(fs16) {
       if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-        patchLchmod(fs15);
-      }
-      if (!fs15.lutimes) {
-        patchLutimes(fs15);
-      }
-      fs15.chown = chownFix(fs15.chown);
-      fs15.fchown = chownFix(fs15.fchown);
-      fs15.lchown = chownFix(fs15.lchown);
-      fs15.chmod = chmodFix(fs15.chmod);
-      fs15.fchmod = chmodFix(fs15.fchmod);
-      fs15.lchmod = chmodFix(fs15.lchmod);
-      fs15.chownSync = chownFixSync(fs15.chownSync);
-      fs15.fchownSync = chownFixSync(fs15.fchownSync);
-      fs15.lchownSync = chownFixSync(fs15.lchownSync);
-      fs15.chmodSync = chmodFixSync(fs15.chmodSync);
-      fs15.fchmodSync = chmodFixSync(fs15.fchmodSync);
-      fs15.lchmodSync = chmodFixSync(fs15.lchmodSync);
-      fs15.stat = statFix(fs15.stat);
-      fs15.fstat = statFix(fs15.fstat);
-      fs15.lstat = statFix(fs15.lstat);
-      fs15.statSync = statFixSync(fs15.statSync);
-      fs15.fstatSync = statFixSync(fs15.fstatSync);
-      fs15.lstatSync = statFixSync(fs15.lstatSync);
-      if (fs15.chmod && !fs15.lchmod) {
-        fs15.lchmod = function(path5, mode, cb) {
+        patchLchmod(fs16);
+      }
+      if (!fs16.lutimes) {
+        patchLutimes(fs16);
+      }
+      fs16.chown = chownFix(fs16.chown);
+      fs16.fchown = chownFix(fs16.fchown);
+      fs16.lchown = chownFix(fs16.lchown);
+      fs16.chmod = chmodFix(fs16.chmod);
+      fs16.fchmod = chmodFix(fs16.fchmod);
+      fs16.lchmod = chmodFix(fs16.lchmod);
+      fs16.chownSync = chownFixSync(fs16.chownSync);
+      fs16.fchownSync = chownFixSync(fs16.fchownSync);
+      fs16.lchownSync = chownFixSync(fs16.lchownSync);
+      fs16.chmodSync = chmodFixSync(fs16.chmodSync);
+      fs16.fchmodSync = chmodFixSync(fs16.fchmodSync);
+      fs16.lchmodSync = chmodFixSync(fs16.lchmodSync);
+      fs16.stat = statFix(fs16.stat);
+      fs16.fstat = statFix(fs16.fstat);
+      fs16.lstat = statFix(fs16.lstat);
+      fs16.statSync = statFixSync(fs16.statSync);
+      fs16.fstatSync = statFixSync(fs16.fstatSync);
+      fs16.lstatSync = statFixSync(fs16.lstatSync);
+      if (fs16.chmod && !fs16.lchmod) {
+        fs16.lchmod = function(path5, mode, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs15.lchmodSync = function() {
+        fs16.lchmodSync = function() {
         };
       }
-      if (fs15.chown && !fs15.lchown) {
-        fs15.lchown = function(path5, uid, gid, cb) {
+      if (fs16.chown && !fs16.lchown) {
+        fs16.lchown = function(path5, uid, gid, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs15.lchownSync = function() {
+        fs16.lchownSync = function() {
         };
       }
       if (platform3 === "win32") {
-        fs15.rename = typeof fs15.rename !== "function" ? fs15.rename : (function(fs$rename) {
+        fs16.rename = typeof fs16.rename !== "function" ? fs16.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() {
-                  fs15.stat(to, function(stater, st) {
+                  fs16.stat(to, function(stater, st) {
                     if (stater && stater.code === "ENOENT")
                       fs$rename(from3, to, CB);
                     else
@@ -4797,9 +4797,9 @@ var require_polyfills = __commonJS({
           }
           if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
           return rename;
-        })(fs15.rename);
+        })(fs16.rename);
       }
-      fs15.read = typeof fs15.read !== "function" ? fs15.read : (function(fs$read) {
+      fs16.read = typeof fs16.read !== "function" ? fs16.read : (function(fs$read) {
         function read(fd, buffer, offset, length, position, callback_) {
           var callback;
           if (callback_ && typeof callback_ === "function") {
@@ -4807,22 +4807,22 @@ var require_polyfills = __commonJS({
             callback = function(er, _3, __) {
               if (er && er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
-                return fs$read.call(fs15, fd, buffer, offset, length, position, callback);
+                return fs$read.call(fs16, fd, buffer, offset, length, position, callback);
               }
               callback_.apply(this, arguments);
             };
           }
-          return fs$read.call(fs15, fd, buffer, offset, length, position, callback);
+          return fs$read.call(fs16, fd, buffer, offset, length, position, callback);
         }
         if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
         return read;
-      })(fs15.read);
-      fs15.readSync = typeof fs15.readSync !== "function" ? fs15.readSync : /* @__PURE__ */ (function(fs$readSync) {
+      })(fs16.read);
+      fs16.readSync = typeof fs16.readSync !== "function" ? fs16.readSync : /* @__PURE__ */ (function(fs$readSync) {
         return function(fd, buffer, offset, length, position) {
           var eagCounter = 0;
           while (true) {
             try {
-              return fs$readSync.call(fs15, fd, buffer, offset, length, position);
+              return fs$readSync.call(fs16, fd, buffer, offset, length, position);
             } catch (er) {
               if (er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
@@ -4832,10 +4832,10 @@ var require_polyfills = __commonJS({
             }
           }
         };
-      })(fs15.readSync);
-      function patchLchmod(fs16) {
-        fs16.lchmod = function(path5, mode, callback) {
-          fs16.open(
+      })(fs16.readSync);
+      function patchLchmod(fs17) {
+        fs17.lchmod = function(path5, mode, callback) {
+          fs17.open(
             path5,
             constants.O_WRONLY | constants.O_SYMLINK,
             mode,
@@ -4844,80 +4844,80 @@ var require_polyfills = __commonJS({
                 if (callback) callback(err);
                 return;
               }
-              fs16.fchmod(fd, mode, function(err2) {
-                fs16.close(fd, function(err22) {
+              fs17.fchmod(fd, mode, function(err2) {
+                fs17.close(fd, function(err22) {
                   if (callback) callback(err2 || err22);
                 });
               });
             }
           );
         };
-        fs16.lchmodSync = function(path5, mode) {
-          var fd = fs16.openSync(path5, constants.O_WRONLY | constants.O_SYMLINK, mode);
+        fs17.lchmodSync = function(path5, mode) {
+          var fd = fs17.openSync(path5, constants.O_WRONLY | constants.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
-            ret = fs16.fchmodSync(fd, mode);
+            ret = fs17.fchmodSync(fd, mode);
             threw = false;
           } finally {
             if (threw) {
               try {
-                fs16.closeSync(fd);
+                fs17.closeSync(fd);
               } catch (er) {
               }
             } else {
-              fs16.closeSync(fd);
+              fs17.closeSync(fd);
             }
           }
           return ret;
         };
       }
-      function patchLutimes(fs16) {
-        if (constants.hasOwnProperty("O_SYMLINK") && fs16.futimes) {
-          fs16.lutimes = function(path5, at, mt, cb) {
-            fs16.open(path5, constants.O_SYMLINK, function(er, fd) {
+      function patchLutimes(fs17) {
+        if (constants.hasOwnProperty("O_SYMLINK") && fs17.futimes) {
+          fs17.lutimes = function(path5, at, mt, cb) {
+            fs17.open(path5, constants.O_SYMLINK, function(er, fd) {
               if (er) {
                 if (cb) cb(er);
                 return;
               }
-              fs16.futimes(fd, at, mt, function(er2) {
-                fs16.close(fd, function(er22) {
+              fs17.futimes(fd, at, mt, function(er2) {
+                fs17.close(fd, function(er22) {
                   if (cb) cb(er2 || er22);
                 });
               });
             });
           };
-          fs16.lutimesSync = function(path5, at, mt) {
-            var fd = fs16.openSync(path5, constants.O_SYMLINK);
+          fs17.lutimesSync = function(path5, at, mt) {
+            var fd = fs17.openSync(path5, constants.O_SYMLINK);
             var ret;
             var threw = true;
             try {
-              ret = fs16.futimesSync(fd, at, mt);
+              ret = fs17.futimesSync(fd, at, mt);
               threw = false;
             } finally {
               if (threw) {
                 try {
-                  fs16.closeSync(fd);
+                  fs17.closeSync(fd);
                 } catch (er) {
                 }
               } else {
-                fs16.closeSync(fd);
+                fs17.closeSync(fd);
               }
             }
             return ret;
           };
-        } else if (fs16.futimes) {
-          fs16.lutimes = function(_a, _b, _c, cb) {
+        } else if (fs17.futimes) {
+          fs17.lutimes = function(_a, _b, _c, cb) {
             if (cb) process.nextTick(cb);
           };
-          fs16.lutimesSync = function() {
+          fs17.lutimesSync = function() {
           };
         }
       }
       function chmodFix(orig) {
         if (!orig) return orig;
         return function(target, mode, cb) {
-          return orig.call(fs15, target, mode, function(er) {
+          return orig.call(fs16, target, mode, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -4927,7 +4927,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, mode) {
           try {
-            return orig.call(fs15, target, mode);
+            return orig.call(fs16, target, mode);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -4936,7 +4936,7 @@ var require_polyfills = __commonJS({
       function chownFix(orig) {
         if (!orig) return orig;
         return function(target, uid, gid, cb) {
-          return orig.call(fs15, target, uid, gid, function(er) {
+          return orig.call(fs16, target, uid, gid, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -4946,7 +4946,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, uid, gid) {
           try {
-            return orig.call(fs15, target, uid, gid);
+            return orig.call(fs16, target, uid, gid);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -4966,13 +4966,13 @@ var require_polyfills = __commonJS({
             }
             if (cb) cb.apply(this, arguments);
           }
-          return options ? orig.call(fs15, target, options, callback) : orig.call(fs15, target, callback);
+          return options ? orig.call(fs16, target, options, callback) : orig.call(fs16, target, callback);
         };
       }
       function statFixSync(orig) {
         if (!orig) return orig;
         return function(target, options) {
-          var stats = options ? orig.call(fs15, target, options) : orig.call(fs15, target);
+          var stats = options ? orig.call(fs16, target, options) : orig.call(fs16, target);
           if (stats) {
             if (stats.uid < 0) stats.uid += 4294967296;
             if (stats.gid < 0) stats.gid += 4294967296;
@@ -5002,7 +5002,7 @@ var require_legacy_streams = __commonJS({
     "use strict";
     var Stream2 = require("stream").Stream;
     module2.exports = legacy;
-    function legacy(fs15) {
+    function legacy(fs16) {
       return {
         ReadStream,
         WriteStream
@@ -5045,7 +5045,7 @@ var require_legacy_streams = __commonJS({
           });
           return;
         }
-        fs15.open(this.path, this.flags, this.mode, function(err, fd) {
+        fs16.open(this.path, this.flags, this.mode, function(err, fd) {
           if (err) {
             self2.emit("error", err);
             self2.readable = false;
@@ -5084,7 +5084,7 @@ var require_legacy_streams = __commonJS({
         this.busy = false;
         this._queue = [];
         if (this.fd === null) {
-          this._open = fs15.open;
+          this._open = fs16.open;
           this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
           this.flush();
         }
@@ -5120,7 +5120,7 @@ var require_clone = __commonJS({
 var require_graceful_fs = __commonJS({
   "node_modules/graceful-fs/graceful-fs.js"(exports2, module2) {
     "use strict";
-    var fs15 = require("fs");
+    var fs16 = require("fs");
     var polyfills = require_polyfills();
     var legacy = require_legacy_streams();
     var clone = require_clone();
@@ -5152,12 +5152,12 @@ var require_graceful_fs = __commonJS({
         m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
         console.error(m);
       };
-    if (!fs15[gracefulQueue]) {
+    if (!fs16[gracefulQueue]) {
       queue = global[gracefulQueue] || [];
-      publishQueue(fs15, queue);
-      fs15.close = (function(fs$close) {
+      publishQueue(fs16, queue);
+      fs16.close = (function(fs$close) {
         function close(fd, cb) {
-          return fs$close.call(fs15, fd, function(err) {
+          return fs$close.call(fs16, fd, function(err) {
             if (!err) {
               resetQueue();
             }
@@ -5169,40 +5169,40 @@ var require_graceful_fs = __commonJS({
           value: fs$close
         });
         return close;
-      })(fs15.close);
-      fs15.closeSync = (function(fs$closeSync) {
+      })(fs16.close);
+      fs16.closeSync = (function(fs$closeSync) {
         function closeSync(fd) {
-          fs$closeSync.apply(fs15, arguments);
+          fs$closeSync.apply(fs16, arguments);
           resetQueue();
         }
         Object.defineProperty(closeSync, previousSymbol, {
           value: fs$closeSync
         });
         return closeSync;
-      })(fs15.closeSync);
+      })(fs16.closeSync);
       if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
         process.on("exit", function() {
-          debug(fs15[gracefulQueue]);
-          require("assert").equal(fs15[gracefulQueue].length, 0);
+          debug(fs16[gracefulQueue]);
+          require("assert").equal(fs16[gracefulQueue].length, 0);
         });
       }
     }
     var queue;
     if (!global[gracefulQueue]) {
-      publishQueue(global, fs15[gracefulQueue]);
-    }
-    module2.exports = patch(clone(fs15));
-    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs15.__patched) {
-      module2.exports = patch(fs15);
-      fs15.__patched = true;
-    }
-    function patch(fs16) {
-      polyfills(fs16);
-      fs16.gracefulify = patch;
-      fs16.createReadStream = createReadStream;
-      fs16.createWriteStream = createWriteStream;
-      var fs$readFile = fs16.readFile;
-      fs16.readFile = readFile2;
+      publishQueue(global, fs16[gracefulQueue]);
+    }
+    module2.exports = patch(clone(fs16));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs16.__patched) {
+      module2.exports = patch(fs16);
+      fs16.__patched = true;
+    }
+    function patch(fs17) {
+      polyfills(fs17);
+      fs17.gracefulify = patch;
+      fs17.createReadStream = createReadStream;
+      fs17.createWriteStream = createWriteStream;
+      var fs$readFile = fs17.readFile;
+      fs17.readFile = readFile2;
       function readFile2(path5, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
@@ -5218,8 +5218,8 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$writeFile = fs16.writeFile;
-      fs16.writeFile = writeFile2;
+      var fs$writeFile = fs17.writeFile;
+      fs17.writeFile = writeFile2;
       function writeFile2(path5, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
@@ -5235,9 +5235,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$appendFile = fs16.appendFile;
+      var fs$appendFile = fs17.appendFile;
       if (fs$appendFile)
-        fs16.appendFile = appendFile;
+        fs17.appendFile = appendFile;
       function appendFile(path5, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
@@ -5253,9 +5253,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$copyFile = fs16.copyFile;
+      var fs$copyFile = fs17.copyFile;
       if (fs$copyFile)
-        fs16.copyFile = copyFile;
+        fs17.copyFile = copyFile;
       function copyFile(src, dest, flags, cb) {
         if (typeof flags === "function") {
           cb = flags;
@@ -5273,8 +5273,8 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$readdir = fs16.readdir;
-      fs16.readdir = readdir2;
+      var fs$readdir = fs17.readdir;
+      fs17.readdir = readdir2;
       var noReaddirOptionVersions = /^v[0-5]\./;
       function readdir2(path5, options, cb) {
         if (typeof options === "function")
@@ -5315,21 +5315,21 @@ var require_graceful_fs = __commonJS({
         }
       }
       if (process.version.substr(0, 4) === "v0.8") {
-        var legStreams = legacy(fs16);
+        var legStreams = legacy(fs17);
         ReadStream = legStreams.ReadStream;
         WriteStream = legStreams.WriteStream;
       }
-      var fs$ReadStream = fs16.ReadStream;
+      var fs$ReadStream = fs17.ReadStream;
       if (fs$ReadStream) {
         ReadStream.prototype = Object.create(fs$ReadStream.prototype);
         ReadStream.prototype.open = ReadStream$open;
       }
-      var fs$WriteStream = fs16.WriteStream;
+      var fs$WriteStream = fs17.WriteStream;
       if (fs$WriteStream) {
         WriteStream.prototype = Object.create(fs$WriteStream.prototype);
         WriteStream.prototype.open = WriteStream$open;
       }
-      Object.defineProperty(fs16, "ReadStream", {
+      Object.defineProperty(fs17, "ReadStream", {
         get: function() {
           return ReadStream;
         },
@@ -5339,7 +5339,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      Object.defineProperty(fs16, "WriteStream", {
+      Object.defineProperty(fs17, "WriteStream", {
         get: function() {
           return WriteStream;
         },
@@ -5350,7 +5350,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileReadStream = ReadStream;
-      Object.defineProperty(fs16, "FileReadStream", {
+      Object.defineProperty(fs17, "FileReadStream", {
         get: function() {
           return FileReadStream;
         },
@@ -5361,7 +5361,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileWriteStream = WriteStream;
-      Object.defineProperty(fs16, "FileWriteStream", {
+      Object.defineProperty(fs17, "FileWriteStream", {
         get: function() {
           return FileWriteStream;
         },
@@ -5410,13 +5410,13 @@ var require_graceful_fs = __commonJS({
         });
       }
       function createReadStream(path5, options) {
-        return new fs16.ReadStream(path5, options);
+        return new fs17.ReadStream(path5, options);
       }
       function createWriteStream(path5, options) {
-        return new fs16.WriteStream(path5, options);
+        return new fs17.WriteStream(path5, options);
       }
-      var fs$open = fs16.open;
-      fs16.open = open2;
+      var fs$open = fs17.open;
+      fs17.open = open2;
       function open2(path5, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
@@ -5432,20 +5432,20 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      return fs16;
+      return fs17;
     }
     function enqueue(elem) {
       debug("ENQUEUE", elem[0].name, elem[1]);
-      fs15[gracefulQueue].push(elem);
+      fs16[gracefulQueue].push(elem);
       retry();
     }
     var retryTimer;
     function resetQueue() {
       var now = Date.now();
-      for (var i = 0; i < fs15[gracefulQueue].length; ++i) {
-        if (fs15[gracefulQueue][i].length > 2) {
-          fs15[gracefulQueue][i][3] = now;
-          fs15[gracefulQueue][i][4] = now;
+      for (var i = 0; i < fs16[gracefulQueue].length; ++i) {
+        if (fs16[gracefulQueue][i].length > 2) {
+          fs16[gracefulQueue][i][3] = now;
+          fs16[gracefulQueue][i][4] = now;
         }
       }
       retry();
@@ -5453,9 +5453,9 @@ var require_graceful_fs = __commonJS({
     function retry() {
       clearTimeout(retryTimer);
       retryTimer = void 0;
-      if (fs15[gracefulQueue].length === 0)
+      if (fs16[gracefulQueue].length === 0)
         return;
-      var elem = fs15[gracefulQueue].shift();
+      var elem = fs16[gracefulQueue].shift();
       var fn = elem[0];
       var args = elem[1];
       var err = elem[2];
@@ -5477,7 +5477,7 @@ var require_graceful_fs = __commonJS({
           debug("RETRY", fn.name, args);
           fn.apply(null, args.concat([startTime]));
         } else {
-          fs15[gracefulQueue].push(elem);
+          fs16[gracefulQueue].push(elem);
         }
       }
       if (retryTimer === void 0) {
@@ -5492,7 +5492,7 @@ var require_fs = __commonJS({
   "node_modules/fs-extra/lib/fs/index.js"(exports2) {
     "use strict";
     var u = require_universalify().fromCallback;
-    var fs15 = require_graceful_fs();
+    var fs16 = require_graceful_fs();
     var api = [
       "access",
       "appendFile",
@@ -5533,26 +5533,26 @@ var require_fs = __commonJS({
       "utimes",
       "writeFile"
     ].filter((key) => {
-      return typeof fs15[key] === "function";
+      return typeof fs16[key] === "function";
     });
-    Object.assign(exports2, fs15);
+    Object.assign(exports2, fs16);
     api.forEach((method) => {
-      exports2[method] = u(fs15[method]);
+      exports2[method] = u(fs16[method]);
     });
     exports2.exists = function(filename, callback) {
       if (typeof callback === "function") {
-        return fs15.exists(filename, callback);
+        return fs16.exists(filename, callback);
       }
       return new Promise((resolve) => {
-        return fs15.exists(filename, resolve);
+        return fs16.exists(filename, resolve);
       });
     };
     exports2.read = function(fd, buffer, offset, length, position, callback) {
       if (typeof callback === "function") {
-        return fs15.read(fd, buffer, offset, length, position, callback);
+        return fs16.read(fd, buffer, offset, length, position, callback);
       }
       return new Promise((resolve, reject) => {
-        fs15.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
+        fs16.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
           if (err) return reject(err);
           resolve({ bytesRead, buffer: buffer2 });
         });
@@ -5560,10 +5560,10 @@ var require_fs = __commonJS({
     };
     exports2.write = function(fd, buffer, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs15.write(fd, buffer, ...args);
+        return fs16.write(fd, buffer, ...args);
       }
       return new Promise((resolve, reject) => {
-        fs15.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
+        fs16.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
           if (err) return reject(err);
           resolve({ bytesWritten, buffer: buffer2 });
         });
@@ -5571,10 +5571,10 @@ var require_fs = __commonJS({
     };
     exports2.readv = function(fd, buffers, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs15.readv(fd, buffers, ...args);
+        return fs16.readv(fd, buffers, ...args);
       }
       return new Promise((resolve, reject) => {
-        fs15.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
+        fs16.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
           if (err) return reject(err);
           resolve({ bytesRead, buffers: buffers2 });
         });
@@ -5582,17 +5582,17 @@ var require_fs = __commonJS({
     };
     exports2.writev = function(fd, buffers, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs15.writev(fd, buffers, ...args);
+        return fs16.writev(fd, buffers, ...args);
       }
       return new Promise((resolve, reject) => {
-        fs15.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
+        fs16.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
           if (err) return reject(err);
           resolve({ bytesWritten, buffers: buffers2 });
         });
       });
     };
-    if (typeof fs15.realpath.native === "function") {
-      exports2.realpath.native = u(fs15.realpath.native);
+    if (typeof fs16.realpath.native === "function") {
+      exports2.realpath.native = u(fs16.realpath.native);
     } else {
       process.emitWarning(
         "fs.realpath.native is not a function. Is fs being monkey-patched?",
@@ -5625,7 +5625,7 @@ var require_utils = __commonJS({
 var require_make_dir = __commonJS({
   "node_modules/fs-extra/lib/mkdirs/make-dir.js"(exports2, module2) {
     "use strict";
-    var fs15 = require_fs();
+    var fs16 = require_fs();
     var { checkPath } = require_utils();
     var getMode = (options) => {
       const defaults2 = { mode: 511 };
@@ -5634,14 +5634,14 @@ var require_make_dir = __commonJS({
     };
     module2.exports.makeDir = async (dir, options) => {
       checkPath(dir);
-      return fs15.mkdir(dir, {
+      return fs16.mkdir(dir, {
         mode: getMode(options),
         recursive: true
       });
     };
     module2.exports.makeDirSync = (dir, options) => {
       checkPath(dir);
-      return fs15.mkdirSync(dir, {
+      return fs16.mkdirSync(dir, {
         mode: getMode(options),
         recursive: true
       });
@@ -5673,13 +5673,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 fs15 = require_fs();
+    var fs16 = require_fs();
     function pathExists2(path5) {
-      return fs15.access(path5).then(() => true).catch(() => false);
+      return fs16.access(path5).then(() => true).catch(() => false);
     }
     module2.exports = {
       pathExists: u(pathExists2),
-      pathExistsSync: fs15.existsSync
+      pathExistsSync: fs16.existsSync
     };
   }
 });
@@ -5688,16 +5688,16 @@ var require_path_exists = __commonJS({
 var require_utimes = __commonJS({
   "node_modules/fs-extra/lib/util/utimes.js"(exports2, module2) {
     "use strict";
-    var fs15 = require_fs();
+    var fs16 = require_fs();
     var u = require_universalify().fromPromise;
     async function utimesMillis(path5, atime, mtime) {
-      const fd = await fs15.open(path5, "r+");
+      const fd = await fs16.open(path5, "r+");
       let closeErr = null;
       try {
-        await fs15.futimes(fd, atime, mtime);
+        await fs16.futimes(fd, atime, mtime);
       } finally {
         try {
-          await fs15.close(fd);
+          await fs16.close(fd);
         } catch (e) {
           closeErr = e;
         }
@@ -5707,9 +5707,9 @@ var require_utimes = __commonJS({
       }
     }
     function utimesMillisSync(path5, atime, mtime) {
-      const fd = fs15.openSync(path5, "r+");
-      fs15.futimesSync(fd, atime, mtime);
-      return fs15.closeSync(fd);
+      const fd = fs16.openSync(path5, "r+");
+      fs16.futimesSync(fd, atime, mtime);
+      return fs16.closeSync(fd);
     }
     module2.exports = {
       utimesMillis: u(utimesMillis),
@@ -5722,11 +5722,11 @@ var require_utimes = __commonJS({
 var require_stat = __commonJS({
   "node_modules/fs-extra/lib/util/stat.js"(exports2, module2) {
     "use strict";
-    var fs15 = require_fs();
+    var fs16 = require_fs();
     var path5 = require("path");
     var u = require_universalify().fromPromise;
     function getStats(src, dest, opts) {
-      const statFunc = opts.dereference ? (file) => fs15.stat(file, { bigint: true }) : (file) => fs15.lstat(file, { bigint: true });
+      const statFunc = opts.dereference ? (file) => fs16.stat(file, { bigint: true }) : (file) => fs16.lstat(file, { bigint: true });
       return Promise.all([
         statFunc(src),
         statFunc(dest).catch((err) => {
@@ -5737,7 +5737,7 @@ var require_stat = __commonJS({
     }
     function getStatsSync(src, dest, opts) {
       let destStat;
-      const statFunc = opts.dereference ? (file) => fs15.statSync(file, { bigint: true }) : (file) => fs15.lstatSync(file, { bigint: true });
+      const statFunc = opts.dereference ? (file) => fs16.statSync(file, { bigint: true }) : (file) => fs16.lstatSync(file, { bigint: true });
       const srcStat = statFunc(src);
       try {
         destStat = statFunc(dest);
@@ -5799,7 +5799,7 @@ var require_stat = __commonJS({
       if (destParent === srcParent || destParent === path5.parse(destParent).root) return;
       let destStat;
       try {
-        destStat = await fs15.stat(destParent, { bigint: true });
+        destStat = await fs16.stat(destParent, { bigint: true });
       } catch (err) {
         if (err.code === "ENOENT") return;
         throw err;
@@ -5815,7 +5815,7 @@ var require_stat = __commonJS({
       if (destParent === srcParent || destParent === path5.parse(destParent).root) return;
       let destStat;
       try {
-        destStat = fs15.statSync(destParent, { bigint: true });
+        destStat = fs16.statSync(destParent, { bigint: true });
       } catch (err) {
         if (err.code === "ENOENT") return;
         throw err;
@@ -5882,7 +5882,7 @@ var require_async = __commonJS({
 var require_copy = __commonJS({
   "node_modules/fs-extra/lib/copy/copy.js"(exports2, module2) {
     "use strict";
-    var fs15 = require_fs();
+    var fs16 = require_fs();
     var path5 = require("path");
     var { mkdirs } = require_mkdirs();
     var { pathExists: pathExists2 } = require_path_exists();
@@ -5918,7 +5918,7 @@ var require_copy = __commonJS({
       return opts.filter(src, dest);
     }
     async function getStatsAndPerformCopy(destStat, src, dest, opts) {
-      const statFn = opts.dereference ? fs15.stat : fs15.lstat;
+      const statFn = opts.dereference ? fs16.stat : fs16.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);
@@ -5930,7 +5930,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 fs15.unlink(dest);
+        await fs16.unlink(dest);
         return copyFile(srcStat, src, dest, opts);
       }
       if (opts.errorOnExist) {
@@ -5938,27 +5938,27 @@ var require_copy = __commonJS({
       }
     }
     async function copyFile(srcStat, src, dest, opts) {
-      await fs15.copyFile(src, dest);
+      await fs16.copyFile(src, dest);
       if (opts.preserveTimestamps) {
         if (fileIsNotWritable(srcStat.mode)) {
           await makeFileWritable(dest, srcStat.mode);
         }
-        const updatedSrcStat = await fs15.stat(src);
+        const updatedSrcStat = await fs16.stat(src);
         await utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
       }
-      return fs15.chmod(dest, srcStat.mode);
+      return fs16.chmod(dest, srcStat.mode);
     }
     function fileIsNotWritable(srcMode) {
       return (srcMode & 128) === 0;
     }
     function makeFileWritable(dest, srcMode) {
-      return fs15.chmod(dest, srcMode | 128);
+      return fs16.chmod(dest, srcMode | 128);
     }
     async function onDir(srcStat, destStat, src, dest, opts) {
       if (!destStat) {
-        await fs15.mkdir(dest);
+        await fs16.mkdir(dest);
       }
-      await asyncIteratorConcurrentProcess(await fs15.opendir(src), async (item) => {
+      await asyncIteratorConcurrentProcess(await fs16.opendir(src), async (item) => {
         const srcItem = path5.join(src, item.name);
         const destItem = path5.join(dest, item.name);
         const include = await runFilter(srcItem, destItem, opts);
@@ -5968,22 +5968,22 @@ var require_copy = __commonJS({
         }
       });
       if (!destStat) {
-        await fs15.chmod(dest, srcStat.mode);
+        await fs16.chmod(dest, srcStat.mode);
       }
     }
     async function onLink(destStat, src, dest, opts) {
-      let resolvedSrc = await fs15.readlink(src);
+      let resolvedSrc = await fs16.readlink(src);
       if (opts.dereference) {
         resolvedSrc = path5.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
-        return fs15.symlink(resolvedSrc, dest);
+        return fs16.symlink(resolvedSrc, dest);
       }
       let resolvedDest = null;
       try {
-        resolvedDest = await fs15.readlink(dest);
+        resolvedDest = await fs16.readlink(dest);
       } catch (e) {
-        if (e.code === "EINVAL" || e.code === "UNKNOWN") return fs15.symlink(resolvedSrc, dest);
+        if (e.code === "EINVAL" || e.code === "UNKNOWN") return fs16.symlink(resolvedSrc, dest);
         throw e;
       }
       if (opts.dereference) {
@@ -5997,8 +5997,8 @@ var require_copy = __commonJS({
           throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
         }
       }
-      await fs15.unlink(dest);
-      return fs15.symlink(resolvedSrc, dest);
+      await fs16.unlink(dest);
+      return fs16.symlink(resolvedSrc, dest);
     }
     module2.exports = copy;
   }
@@ -6008,7 +6008,7 @@ var require_copy = __commonJS({
 var require_copy_sync = __commonJS({
   "node_modules/fs-extra/lib/copy/copy-sync.js"(exports2, module2) {
     "use strict";
-    var fs15 = require_graceful_fs();
+    var fs16 = require_graceful_fs();
     var path5 = require("path");
     var mkdirsSync = require_mkdirs().mkdirsSync;
     var utimesMillisSync = require_utimes().utimesMillisSync;
@@ -6031,11 +6031,11 @@ var require_copy_sync = __commonJS({
       stat.checkParentPathsSync(src, srcStat, dest, "copy");
       if (opts.filter && !opts.filter(src, dest)) return;
       const destParent = path5.dirname(dest);
-      if (!fs15.existsSync(destParent)) mkdirsSync(destParent);
+      if (!fs16.existsSync(destParent)) mkdirsSync(destParent);
       return getStats(destStat, src, dest, opts);
     }
     function getStats(destStat, src, dest, opts) {
-      const statSync = opts.dereference ? fs15.statSync : fs15.lstatSync;
+      const statSync = opts.dereference ? fs16.statSync : fs16.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);
@@ -6050,14 +6050,14 @@ var require_copy_sync = __commonJS({
     }
     function mayCopyFile(srcStat, src, dest, opts) {
       if (opts.overwrite) {
-        fs15.unlinkSync(dest);
+        fs16.unlinkSync(dest);
         return copyFile(srcStat, src, dest, opts);
       } else if (opts.errorOnExist) {
         throw new Error(`'${dest}' already exists`);
       }
     }
     function copyFile(srcStat, src, dest, opts) {
-      fs15.copyFileSync(src, dest);
+      fs16.copyFileSync(src, dest);
       if (opts.preserveTimestamps) handleTimestamps(srcStat.mode, src, dest);
       return setDestMode(dest, srcStat.mode);
     }
@@ -6072,10 +6072,10 @@ var require_copy_sync = __commonJS({
       return setDestMode(dest, srcMode | 128);
     }
     function setDestMode(dest, srcMode) {
-      return fs15.chmodSync(dest, srcMode);
+      return fs16.chmodSync(dest, srcMode);
     }
     function setDestTimestamps(src, dest) {
-      const updatedSrcStat = fs15.statSync(src);
+      const updatedSrcStat = fs16.statSync(src);
       return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
     }
     function onDir(srcStat, destStat, src, dest, opts) {
@@ -6083,12 +6083,12 @@ var require_copy_sync = __commonJS({
       return copyDir(src, dest, opts);
     }
     function mkDirAndCopy(srcMode, src, dest, opts) {
-      fs15.mkdirSync(dest);
+      fs16.mkdirSync(dest);
       copyDir(src, dest, opts);
       return setDestMode(dest, srcMode);
     }
     function copyDir(src, dest, opts) {
-      const dir = fs15.opendirSync(src);
+      const dir = fs16.opendirSync(src);
       try {
         let dirent;
         while ((dirent = dir.readSync()) !== null) {
@@ -6106,18 +6106,18 @@ var require_copy_sync = __commonJS({
       return getStats(destStat, srcItem, destItem, opts);
     }
     function onLink(destStat, src, dest, opts) {
-      let resolvedSrc = fs15.readlinkSync(src);
+      let resolvedSrc = fs16.readlinkSync(src);
       if (opts.dereference) {
         resolvedSrc = path5.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
-        return fs15.symlinkSync(resolvedSrc, dest);
+        return fs16.symlinkSync(resolvedSrc, dest);
       } else {
         let resolvedDest;
         try {
-          resolvedDest = fs15.readlinkSync(dest);
+          resolvedDest = fs16.readlinkSync(dest);
         } catch (err) {
-          if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs15.symlinkSync(resolvedSrc, dest);
+          if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs16.symlinkSync(resolvedSrc, dest);
           throw err;
         }
         if (opts.dereference) {
@@ -6135,8 +6135,8 @@ var require_copy_sync = __commonJS({
       }
     }
     function copyLink(resolvedSrc, dest) {
-      fs15.unlinkSync(dest);
-      return fs15.symlinkSync(resolvedSrc, dest);
+      fs16.unlinkSync(dest);
+      return fs16.symlinkSync(resolvedSrc, dest);
     }
     module2.exports = copySync;
   }
@@ -6158,13 +6158,13 @@ var require_copy2 = __commonJS({
 var require_remove = __commonJS({
   "node_modules/fs-extra/lib/remove/index.js"(exports2, module2) {
     "use strict";
-    var fs15 = require_graceful_fs();
+    var fs16 = require_graceful_fs();
     var u = require_universalify().fromCallback;
     function remove2(path5, callback) {
-      fs15.rm(path5, { recursive: true, force: true }, callback);
+      fs16.rm(path5, { recursive: true, force: true }, callback);
     }
     function removeSync(path5) {
-      fs15.rmSync(path5, { recursive: true, force: true });
+      fs16.rmSync(path5, { recursive: true, force: true });
     }
     module2.exports = {
       remove: u(remove2),
@@ -6178,14 +6178,14 @@ var require_empty = __commonJS({
   "node_modules/fs-extra/lib/empty/index.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs15 = require_fs();
+    var fs16 = require_fs();
     var path5 = require("path");
     var mkdir = require_mkdirs();
     var remove2 = require_remove();
     var emptyDir = u(async function emptyDir2(dir) {
       let items;
       try {
-        items = await fs15.readdir(dir);
+        items = await fs16.readdir(dir);
       } catch {
         return mkdir.mkdirs(dir);
       }
@@ -6194,7 +6194,7 @@ var require_empty = __commonJS({
     function emptyDirSync(dir) {
       let items;
       try {
-        items = fs15.readdirSync(dir);
+        items = fs16.readdirSync(dir);
       } catch {
         return mkdir.mkdirsSync(dir);
       }
@@ -6218,51 +6218,51 @@ var require_file = __commonJS({
     "use strict";
     var u = require_universalify().fromPromise;
     var path5 = require("path");
-    var fs15 = require_fs();
+    var fs16 = require_fs();
     var mkdir = require_mkdirs();
     async function createFile(file) {
       let stats;
       try {
-        stats = await fs15.stat(file);
+        stats = await fs16.stat(file);
       } catch {
       }
       if (stats && stats.isFile()) return;
       const dir = path5.dirname(file);
       let dirStats = null;
       try {
-        dirStats = await fs15.stat(dir);
+        dirStats = await fs16.stat(dir);
       } catch (err) {
         if (err.code === "ENOENT") {
           await mkdir.mkdirs(dir);
-          await fs15.writeFile(file, "");
+          await fs16.writeFile(file, "");
           return;
         } else {
           throw err;
         }
       }
       if (dirStats.isDirectory()) {
-        await fs15.writeFile(file, "");
+        await fs16.writeFile(file, "");
       } else {
-        await fs15.readdir(dir);
+        await fs16.readdir(dir);
       }
     }
     function createFileSync(file) {
       let stats;
       try {
-        stats = fs15.statSync(file);
+        stats = fs16.statSync(file);
       } catch {
       }
       if (stats && stats.isFile()) return;
       const dir = path5.dirname(file);
       try {
-        if (!fs15.statSync(dir).isDirectory()) {
-          fs15.readdirSync(dir);
+        if (!fs16.statSync(dir).isDirectory()) {
+          fs16.readdirSync(dir);
         }
       } catch (err) {
         if (err && err.code === "ENOENT") mkdir.mkdirsSync(dir);
         else throw err;
       }
-      fs15.writeFileSync(file, "");
+      fs16.writeFileSync(file, "");
     }
     module2.exports = {
       createFile: u(createFile),
@@ -6277,19 +6277,19 @@ var require_link = __commonJS({
     "use strict";
     var u = require_universalify().fromPromise;
     var path5 = require("path");
-    var fs15 = require_fs();
+    var fs16 = require_fs();
     var mkdir = require_mkdirs();
     var { pathExists: pathExists2 } = require_path_exists();
     var { areIdentical } = require_stat();
     async function createLink(srcpath, dstpath) {
       let dstStat;
       try {
-        dstStat = await fs15.lstat(dstpath);
+        dstStat = await fs16.lstat(dstpath);
       } catch {
       }
       let srcStat;
       try {
-        srcStat = await fs15.lstat(srcpath);
+        srcStat = await fs16.lstat(srcpath);
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureLink");
         throw err;
@@ -6300,26 +6300,26 @@ var require_link = __commonJS({
       if (!dirExists) {
         await mkdir.mkdirs(dir);
       }
-      await fs15.link(srcpath, dstpath);
+      await fs16.link(srcpath, dstpath);
     }
     function createLinkSync(srcpath, dstpath) {
       let dstStat;
       try {
-        dstStat = fs15.lstatSync(dstpath);
+        dstStat = fs16.lstatSync(dstpath);
       } catch {
       }
       try {
-        const srcStat = fs15.lstatSync(srcpath);
+        const srcStat = fs16.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 = fs15.existsSync(dir);
-      if (dirExists) return fs15.linkSync(srcpath, dstpath);
+      const dirExists = fs16.existsSync(dir);
+      if (dirExists) return fs16.linkSync(srcpath, dstpath);
       mkdir.mkdirsSync(dir);
-      return fs15.linkSync(srcpath, dstpath);
+      return fs16.linkSync(srcpath, dstpath);
     }
     module2.exports = {
       createLink: u(createLink),
@@ -6333,13 +6333,13 @@ var require_symlink_paths = __commonJS({
   "node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports2, module2) {
     "use strict";
     var path5 = require("path");
-    var fs15 = require_fs();
+    var fs16 = require_fs();
     var { pathExists: pathExists2 } = require_path_exists();
     var u = require_universalify().fromPromise;
     async function symlinkPaths(srcpath, dstpath) {
       if (path5.isAbsolute(srcpath)) {
         try {
-          await fs15.lstat(srcpath);
+          await fs16.lstat(srcpath);
         } catch (err) {
           err.message = err.message.replace("lstat", "ensureSymlink");
           throw err;
@@ -6359,7 +6359,7 @@ var require_symlink_paths = __commonJS({
         };
       }
       try {
-        await fs15.lstat(srcpath);
+        await fs16.lstat(srcpath);
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureSymlink");
         throw err;
@@ -6371,7 +6371,7 @@ var require_symlink_paths = __commonJS({
     }
     function symlinkPathsSync(srcpath, dstpath) {
       if (path5.isAbsolute(srcpath)) {
-        const exists2 = fs15.existsSync(srcpath);
+        const exists2 = fs16.existsSync(srcpath);
         if (!exists2) throw new Error("absolute srcpath does not exist");
         return {
           toCwd: srcpath,
@@ -6380,14 +6380,14 @@ var require_symlink_paths = __commonJS({
       }
       const dstdir = path5.dirname(dstpath);
       const relativeToDst = path5.join(dstdir, srcpath);
-      const exists = fs15.existsSync(relativeToDst);
+      const exists = fs16.existsSync(relativeToDst);
       if (exists) {
         return {
           toCwd: relativeToDst,
           toDst: srcpath
         };
       }
-      const srcExists = fs15.existsSync(srcpath);
+      const srcExists = fs16.existsSync(srcpath);
       if (!srcExists) throw new Error("relative srcpath does not exist");
       return {
         toCwd: srcpath,
@@ -6405,13 +6405,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 fs15 = require_fs();
+    var fs16 = require_fs();
     var u = require_universalify().fromPromise;
     async function symlinkType(srcpath, type) {
       if (type) return type;
       let stats;
       try {
-        stats = await fs15.lstat(srcpath);
+        stats = await fs16.lstat(srcpath);
       } catch {
         return "file";
       }
@@ -6421,7 +6421,7 @@ var require_symlink_type = __commonJS({
       if (type) return type;
       let stats;
       try {
-        stats = fs15.lstatSync(srcpath);
+        stats = fs16.lstatSync(srcpath);
       } catch {
         return "file";
       }
@@ -6440,7 +6440,7 @@ var require_symlink = __commonJS({
     "use strict";
     var u = require_universalify().fromPromise;
     var path5 = require("path");
-    var fs15 = require_fs();
+    var fs16 = require_fs();
     var { mkdirs, mkdirsSync } = require_mkdirs();
     var { symlinkPaths, symlinkPathsSync } = require_symlink_paths();
     var { symlinkType, symlinkTypeSync } = require_symlink_type();
@@ -6449,44 +6449,44 @@ var require_symlink = __commonJS({
     async function createSymlink(srcpath, dstpath, type) {
       let stats;
       try {
-        stats = await fs15.lstat(dstpath);
+        stats = await fs16.lstat(dstpath);
       } catch {
       }
       if (stats && stats.isSymbolicLink()) {
         const [srcStat, dstStat] = await Promise.all([
-          fs15.stat(srcpath),
-          fs15.stat(dstpath)
+          fs16.stat(srcpath),
+          fs16.stat(dstpath)
         ]);
         if (areIdentical(srcStat, dstStat)) return;
       }
-      const relative = await symlinkPaths(srcpath, dstpath);
-      srcpath = relative.toDst;
-      const toType = await symlinkType(relative.toCwd, type);
+      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)) {
         await mkdirs(dir);
       }
-      return fs15.symlink(srcpath, dstpath, toType);
+      return fs16.symlink(srcpath, dstpath, toType);
     }
     function createSymlinkSync(srcpath, dstpath, type) {
       let stats;
       try {
-        stats = fs15.lstatSync(dstpath);
+        stats = fs16.lstatSync(dstpath);
       } catch {
       }
       if (stats && stats.isSymbolicLink()) {
-        const srcStat = fs15.statSync(srcpath);
-        const dstStat = fs15.statSync(dstpath);
+        const srcStat = fs16.statSync(srcpath);
+        const dstStat = fs16.statSync(dstpath);
         if (areIdentical(srcStat, dstStat)) return;
       }
-      const relative = symlinkPathsSync(srcpath, dstpath);
-      srcpath = relative.toDst;
-      type = symlinkTypeSync(relative.toCwd, type);
+      const relative2 = symlinkPathsSync(srcpath, dstpath);
+      srcpath = relative2.toDst;
+      type = symlinkTypeSync(relative2.toCwd, type);
       const dir = path5.dirname(dstpath);
-      const exists = fs15.existsSync(dir);
-      if (exists) return fs15.symlinkSync(srcpath, dstpath, type);
+      const exists = fs16.existsSync(dir);
+      if (exists) return fs16.symlinkSync(srcpath, dstpath, type);
       mkdirsSync(dir);
-      return fs15.symlinkSync(srcpath, dstpath, type);
+      return fs16.symlinkSync(srcpath, dstpath, type);
     }
     module2.exports = {
       createSymlink: u(createSymlink),
@@ -6555,9 +6555,9 @@ var require_jsonfile = __commonJS({
       if (typeof options === "string") {
         options = { encoding: options };
       }
-      const fs15 = options.fs || _fs;
+      const fs16 = options.fs || _fs;
       const shouldThrow = "throws" in options ? options.throws : true;
-      let data = await universalify.fromCallback(fs15.readFile)(file, options);
+      let data = await universalify.fromCallback(fs16.readFile)(file, options);
       data = stripBom(data);
       let obj;
       try {
@@ -6577,10 +6577,10 @@ var require_jsonfile = __commonJS({
       if (typeof options === "string") {
         options = { encoding: options };
       }
-      const fs15 = options.fs || _fs;
+      const fs16 = options.fs || _fs;
       const shouldThrow = "throws" in options ? options.throws : true;
       try {
-        let content = fs15.readFileSync(file, options);
+        let content = fs16.readFileSync(file, options);
         content = stripBom(content);
         return JSON.parse(content, options.reviver);
       } catch (err) {
@@ -6593,15 +6593,15 @@ var require_jsonfile = __commonJS({
       }
     }
     async function _writeFile(file, obj, options = {}) {
-      const fs15 = options.fs || _fs;
+      const fs16 = options.fs || _fs;
       const str = stringify2(obj, options);
-      await universalify.fromCallback(fs15.writeFile)(file, str, options);
+      await universalify.fromCallback(fs16.writeFile)(file, str, options);
     }
     var writeFile2 = universalify.fromPromise(_writeFile);
     function writeFileSync2(file, obj, options = {}) {
-      const fs15 = options.fs || _fs;
+      const fs16 = options.fs || _fs;
       const str = stringify2(obj, options);
-      return fs15.writeFileSync(file, str, options);
+      return fs16.writeFileSync(file, str, options);
     }
     module2.exports = {
       readFile: readFile2,
@@ -6632,7 +6632,7 @@ var require_output_file = __commonJS({
   "node_modules/fs-extra/lib/output-file/index.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs15 = require_fs();
+    var fs16 = require_fs();
     var path5 = require("path");
     var mkdir = require_mkdirs();
     var pathExists2 = require_path_exists().pathExists;
@@ -6641,14 +6641,14 @@ var require_output_file = __commonJS({
       if (!await pathExists2(dir)) {
         await mkdir.mkdirs(dir);
       }
-      return fs15.writeFile(file, data, encoding);
+      return fs16.writeFile(file, data, encoding);
     }
     function outputFileSync(file, ...args) {
       const dir = path5.dirname(file);
-      if (!fs15.existsSync(dir)) {
+      if (!fs16.existsSync(dir)) {
         mkdir.mkdirsSync(dir);
       }
-      fs15.writeFileSync(file, ...args);
+      fs16.writeFileSync(file, ...args);
     }
     module2.exports = {
       outputFile: u(outputFile),
@@ -6707,7 +6707,7 @@ var require_json = __commonJS({
 var require_move = __commonJS({
   "node_modules/fs-extra/lib/move/move.js"(exports2, module2) {
     "use strict";
-    var fs15 = require_fs();
+    var fs16 = require_fs();
     var path5 = require("path");
     var { copy } = require_copy2();
     var { remove: remove2 } = require_remove();
@@ -6734,7 +6734,7 @@ var require_move = __commonJS({
         }
       }
       try {
-        await fs15.rename(src, dest);
+        await fs16.rename(src, dest);
       } catch (err) {
         if (err.code !== "EXDEV") {
           throw err;
@@ -6759,7 +6759,7 @@ var require_move = __commonJS({
 var require_move_sync = __commonJS({
   "node_modules/fs-extra/lib/move/move-sync.js"(exports2, module2) {
     "use strict";
-    var fs15 = require_graceful_fs();
+    var fs16 = require_graceful_fs();
     var path5 = require("path");
     var copySync = require_copy2().copySync;
     var removeSync = require_remove().removeSync;
@@ -6784,12 +6784,12 @@ var require_move_sync = __commonJS({
         removeSync(dest);
         return rename(src, dest, overwrite);
       }
-      if (fs15.existsSync(dest)) throw new Error("dest already exists.");
+      if (fs16.existsSync(dest)) throw new Error("dest already exists.");
       return rename(src, dest, overwrite);
     }
     function rename(src, dest, overwrite) {
       try {
-        fs15.renameSync(src, dest);
+        fs16.renameSync(src, dest);
       } catch (err) {
         if (err.code !== "EXDEV") throw err;
         return moveAcrossDevice(src, dest, overwrite);
@@ -19200,7 +19200,7 @@ var require_buffer_list = __commonJS({
         }
       }, {
         key: "join",
-        value: function join13(s) {
+        value: function join14(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 fs15 = (0, node_1.default)();
+      const fs16 = (0, node_1.default)();
       const handler = (err, buffer) => {
         if (fd) {
-          fs15.closeSync(fd);
+          fs16.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 = fs15.openSync(filepath, "r");
+        fd = fs16.openSync(filepath, "r");
         let sample = Buffer.allocUnsafe(sampleSize);
-        fs15.read(fd, sample, 0, sampleSize, opts.offset, (err, bytesRead) => {
+        fs16.read(fd, sample, 0, sampleSize, opts.offset, (err, bytesRead) => {
           if (err) {
             handler(err, null);
           } else {
@@ -28106,22 +28106,22 @@ var require_lib2 = __commonJS({
         });
         return;
       }
-      fs15.readFile(filepath, handler);
+      fs16.readFile(filepath, handler);
     });
     exports2.detectFile = detectFile;
     var detectFileSync = (filepath, opts = {}) => {
-      const fs15 = (0, node_1.default)();
+      const fs16 = (0, node_1.default)();
       if (opts && opts.sampleSize) {
-        const fd = fs15.openSync(filepath, "r");
+        const fd = fs16.openSync(filepath, "r");
         let sample = Buffer.allocUnsafe(opts.sampleSize);
-        const bytesRead = fs15.readSync(fd, sample, 0, opts.sampleSize, opts.offset);
+        const bytesRead = fs16.readSync(fd, sample, 0, opts.sampleSize, opts.offset);
         if (bytesRead < opts.sampleSize) {
           sample = sample.subarray(0, bytesRead);
         }
-        fs15.closeSync(fd);
+        fs16.closeSync(fd);
         return (0, exports2.detect)(sample);
       }
-      return (0, exports2.detect)(fs15.readFileSync(filepath));
+      return (0, exports2.detect)(fs16.readFileSync(filepath));
     };
     exports2.detectFileSync = detectFileSync;
     exports2.default = {
@@ -52396,7 +52396,7 @@ var require_msal_node = __commonJS({
     var crypto5 = require("crypto");
     var msalCommon = require_lib6();
     var jwt2 = require_jsonwebtoken();
-    var fs15 = require("fs");
+    var fs16 = require("fs");
     var path5 = require("path");
     var Serializer = class {
       /**
@@ -62095,7 +62095,7 @@ Headers: ${JSON.stringify(headers)}`
         if (!identityEndpoint || !imdsEndpoint) {
           const fileDetectionPath = AZURE_ARC_FILE_DETECTION[process.platform];
           try {
-            fs15.accessSync(fileDetectionPath, fs15.constants.F_OK | fs15.constants.R_OK);
+            fs16.accessSync(fileDetectionPath, fs16.constants.F_OK | fs16.constants.R_OK);
             identityEndpoint = DEFAULT_AZURE_ARC_IDENTITY_ENDPOINT;
             imdsEndpoint = HIMDS_EXECUTABLE_HELPER_STRING;
           } catch (err) {
@@ -62207,7 +62207,7 @@ Headers: ${JSON.stringify(headers)}`
           }
           let secretFileSize;
           try {
-            secretFileSize = await fs15.statSync(secretFilePath).size;
+            secretFileSize = await fs16.statSync(secretFilePath).size;
           } catch (e) {
             throw createManagedIdentityError(unableToReadSecretFile);
           }
@@ -62216,7 +62216,7 @@ Headers: ${JSON.stringify(headers)}`
           }
           let secret;
           try {
-            secret = fs15.readFileSync(secretFilePath, EncodingTypes.UTF8);
+            secret = fs16.readFileSync(secretFilePath, EncodingTypes.UTF8);
           } catch (e) {
             throw createManagedIdentityError(unableToReadSecretFile);
           }
@@ -91571,11 +91571,11 @@ var init_js_joda_esm = __esm({
     })(TemporalAdjuster);
     RelativeDayOfWeek = (function(_TemporalAdjuster3) {
       _inheritsLoose(RelativeDayOfWeek2, _TemporalAdjuster3);
-      function RelativeDayOfWeek2(relative, dayOfWeek) {
+      function RelativeDayOfWeek2(relative2, dayOfWeek) {
         var _this3;
         _this3 = _TemporalAdjuster3.call(this) || this;
         requireNonNull(dayOfWeek, "dayOfWeek");
-        _this3._relative = relative;
+        _this3._relative = relative2;
         _this3._dowValue = dayOfWeek.value();
         return _this3;
       }
@@ -122862,8 +122862,8 @@ var PathScurryBase = class {
    *
    * @internal
    */
-  constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs15 = defaultFS } = {}) {
-    this.#fs = fsFromOption(fs15);
+  constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs16 = defaultFS } = {}) {
+    this.#fs = fsFromOption(fs16);
     if (cwd instanceof URL || cwd.startsWith("file://")) {
       cwd = (0, import_node_url.fileURLToPath)(cwd);
     }
@@ -123421,8 +123421,8 @@ var PathScurryWin32 = class extends PathScurryBase {
   /**
    * @internal
    */
-  newRoot(fs15) {
-    return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs15 });
+  newRoot(fs16) {
+    return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs16 });
   }
   /**
    * Return true if the provided path string is an absolute path
@@ -123450,8 +123450,8 @@ var PathScurryPosix = class extends PathScurryBase {
   /**
    * @internal
    */
-  newRoot(fs15) {
-    return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs15 });
+  newRoot(fs16) {
+    return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs16 });
   }
   /**
    * Return true if the provided path string is an absolute path
@@ -123694,10 +123694,10 @@ var Ignore = class {
   ignored(p) {
     const fullpath = p.fullpath();
     const fullpaths = `${fullpath}/`;
-    const relative = p.relative() || ".";
-    const relatives = `${relative}/`;
+    const relative2 = p.relative() || ".";
+    const relatives = `${relative2}/`;
     for (const m of this.relative) {
-      if (m.match(relative) || m.match(relatives))
+      if (m.match(relative2) || m.match(relatives))
         return true;
     }
     for (const m of this.absolute) {
@@ -123708,9 +123708,9 @@ var Ignore = class {
   }
   childrenIgnored(p) {
     const fullpath = p.fullpath() + "/";
-    const relative = (p.relative() || ".") + "/";
+    const relative2 = (p.relative() || ".") + "/";
     for (const m of this.relativeChildren) {
-      if (m.match(relative))
+      if (m.match(relative2))
         return true;
     }
     for (const m of this.absoluteChildren) {
@@ -124629,7 +124629,7 @@ function readAllPackageReferences(csprojContent) {
   }
   return packages;
 }
-async function findProjectsWithSmartStack(projectDir) {
+async function findAllProjects(projectDir) {
   const srcDir = (0, import_path7.join)(projectDir, "src");
   if (!await import_fs_extra6.default.pathExists(srcDir)) {
     return [];
@@ -124645,13 +124645,11 @@ async function findProjectsWithSmartStack(projectDir) {
         const csprojPath = (0, import_path7.join)(folderPath, csproj);
         const content = await import_fs_extra6.default.readFile(csprojPath, "utf-8");
         const currentVersion = readPackageVersion(content, "SmartStack");
-        if (currentVersion !== null) {
-          projects.push({
-            csprojPath,
-            relPath: csprojPath.replace(projectDir, "").replace(/^[/\\]/, ""),
-            currentVersion
-          });
-        }
+        projects.push({
+          csprojPath,
+          relPath: csprojPath.replace(projectDir, "").replace(/^[/\\]/, ""),
+          currentVersion
+        });
       }
     }
   }
@@ -124833,51 +124831,62 @@ var upgradeCommand = new Command("upgrade").description("Upgrade SmartStack pack
     logger.success(`Latest npm version: ${source_default.cyan(npmVersion)}`);
   }
   console.log();
-  logger.info("Scanning for SmartStack projects...");
-  const projects = await findProjectsWithSmartStack(projectDir);
-  if (projects.length === 0) {
-    logger.warning("No .NET projects found with SmartStack PackageReference.");
-    logger.info('Tip: Ensure your .csproj files contain <PackageReference Include="SmartStack" Version="..." />');
+  logger.info("Scanning for .NET projects...");
+  const allProjects = await findAllProjects(projectDir);
+  if (allProjects.length === 0) {
+    logger.warning("No .NET projects found in src/ directory.");
   } else {
-    logger.info(`Found ${source_default.cyan(projects.length)} project(s):`);
-    for (const p of projects) {
-      const versionInfo = p.currentVersion ? `${source_default.yellow(p.currentVersion)} \u2192 ${source_default.cyan(nugetVersion)}` : source_default.gray("version unknown");
-      const upToDate = p.currentVersion === nugetVersion;
-      const statusIcon = upToDate ? source_default.green("\u2713") : source_default.yellow("\u2191");
-      logger.info(`  ${statusIcon} ${p.relPath} (${upToDate ? source_default.green("up to date") : versionInfo})`);
+    const smartStackProjects = allProjects.filter((p) => p.currentVersion !== null);
+    const otherProjects = allProjects.filter((p) => p.currentVersion === null);
+    if (smartStackProjects.length > 0) {
+      logger.info(`Found ${source_default.cyan(smartStackProjects.length)} project(s) with SmartStack:`);
+      for (const p of smartStackProjects) {
+        const versionInfo = `${source_default.yellow(p.currentVersion)} \u2192 ${source_default.cyan(nugetVersion)}`;
+        const upToDate = p.currentVersion === nugetVersion;
+        const statusIcon = upToDate ? source_default.green("\u2713") : source_default.yellow("\u2191");
+        logger.info(`  ${statusIcon} ${p.relPath} (${upToDate ? source_default.green("up to date") : versionInfo})`);
+      }
+    }
+    if (otherProjects.length > 0) {
+      logger.info(`Found ${source_default.cyan(otherProjects.length)} other project(s):`);
+      for (const p of otherProjects) {
+        logger.info(`  ${source_default.gray("\u25CB")} ${p.relPath}`);
+      }
     }
     console.log();
-    const projectsToUpgrade = projects.filter((p) => p.currentVersion !== nugetVersion);
-    result.nugetSkipped = projects.length - projectsToUpgrade.length;
-    if (projectsToUpgrade.length === 0) {
-      logger.success(`All ${projects.length} project(s) already at ${source_default.cyan(nugetVersion)}`);
-    } else {
-      logger.info(`Upgrading ${projectsToUpgrade.length} project(s)...`);
-      for (const project of projectsToUpgrade) {
-        logger.info(`Upgrading ${source_default.cyan(project.relPath)}...`);
-        try {
-          execCommand2(`dotnet add "${project.csprojPath}" package SmartStack --version ${nugetVersion}`, void 0, dryRun);
-          result.nugetUpgraded++;
-        } catch (error) {
-          result.nugetFailed++;
-          logger.error(`Failed to upgrade ${project.relPath}: ${error instanceof Error ? error.message : error}`);
+    if (smartStackProjects.length > 0) {
+      const projectsToUpgrade = smartStackProjects.filter((p) => p.currentVersion !== nugetVersion);
+      result.nugetSkipped = smartStackProjects.length - projectsToUpgrade.length;
+      if (projectsToUpgrade.length === 0) {
+        logger.success(`All ${smartStackProjects.length} SmartStack project(s) already at ${source_default.cyan(nugetVersion)}`);
+      } else {
+        logger.info(`Upgrading SmartStack in ${projectsToUpgrade.length} project(s)...`);
+        for (const project of projectsToUpgrade) {
+          logger.info(`Upgrading ${source_default.cyan(project.relPath)}...`);
+          try {
+            execCommand2(`dotnet add "${project.csprojPath}" package SmartStack --version ${nugetVersion}`, void 0, dryRun);
+            result.nugetUpgraded++;
+          } catch (error) {
+            result.nugetFailed++;
+            logger.error(`Failed to upgrade ${project.relPath}: ${error instanceof Error ? error.message : error}`);
+          }
+        }
+        if (result.nugetUpgraded > 0) {
+          logger.success(`${result.nugetUpgraded} project(s) upgraded to ${source_default.cyan(nugetVersion)}`);
+        }
+        if (result.nugetFailed > 0) {
+          logger.error(`${result.nugetFailed} project(s) failed to upgrade`);
         }
       }
-      if (result.nugetUpgraded > 0) {
-        logger.success(`${result.nugetUpgraded} project(s) upgraded to ${source_default.cyan(nugetVersion)}`);
-      }
-      if (result.nugetFailed > 0) {
-        logger.error(`${result.nugetFailed} project(s) failed to upgrade`);
-      }
+      console.log();
     }
-    console.log();
     logger.info("Checking other NuGet packages...");
-    for (const project of projects) {
+    for (const project of allProjects) {
       const content = await import_fs_extra6.default.readFile(project.csprojPath, "utf-8");
       const allPackages = readAllPackageReferences(content);
       const otherPackages = allPackages.filter((p) => p.name !== "SmartStack");
       if (otherPackages.length === 0) continue;
-      const relPath = project.relPath;
+      logger.info(`  ${source_default.cyan(project.relPath)}:`);
       for (const pkg2 of otherPackages) {
         try {
           const output = dryRun ? `[DRY RUN] dotnet add "${project.csprojPath}" package ${pkg2.name}` : (0, import_child_process6.execSync)(
@@ -124885,21 +124894,21 @@ var upgradeCommand = new Command("upgrade").description("Upgrade SmartStack pack
             { shell: true, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
           );
           if (dryRun) {
-            logger.info(`  [DRY RUN] ${pkg2.name} ${source_default.yellow(pkg2.currentVersion)} \u2192 latest`);
+            logger.info(`    [DRY RUN] ${pkg2.name} ${source_default.yellow(pkg2.currentVersion)} \u2192 latest`);
             result.otherPkgUpdated++;
             continue;
           }
           const newContent = await import_fs_extra6.default.readFile(project.csprojPath, "utf-8");
           const newVersion = readPackageVersion(newContent, pkg2.name);
           if (newVersion && newVersion !== pkg2.currentVersion) {
-            logger.success(`  ${source_default.green("\u2713")} ${pkg2.name} ${source_default.yellow(pkg2.currentVersion)} \u2192 ${source_default.cyan(newVersion)}`);
+            logger.success(`    ${source_default.green("\u2713")} ${pkg2.name} ${source_default.yellow(pkg2.currentVersion)} \u2192 ${source_default.cyan(newVersion)}`);
             result.otherPkgUpdated++;
           } else {
             result.otherPkgSkipped++;
           }
         } catch (error) {
           result.otherPkgFailed++;
-          logger.error(`  ${source_default.red("\u2717")} ${pkg2.name}: ${error instanceof Error ? error.message : error}`);
+          logger.error(`    ${source_default.red("\u2717")} ${pkg2.name}: ${error instanceof Error ? error.message : error}`);
         }
       }
     }
@@ -126111,7 +126120,17 @@ adminCommand.command("reset").description("Reset the localAdmin account password
       if (nativeDriver) {
         try {
           spinner.text = "Connecting with Windows Authentication...";
-          await nativeDriver.connect(connectionString);
+          const nativeConfig = {
+            server: connInfo.server,
+            database: connInfo.database,
+            options: {
+              trustedConnection: true,
+              trustServerCertificate: true
+            },
+            connectionTimeout: 15e3,
+            requestTimeout: 15e3
+          };
+          await nativeDriver.connect(nativeConfig);
           nativeConnected = true;
           await resetViaMssql(nativeDriver);
         } catch (nativeError) {
@@ -126409,10 +126428,239 @@ mcpCommand.command("remove").description("Unregister MCP servers from CLI and VS
   logger.box(["MCP servers unregistered.", "", "Re-register with: ss mcp install"], "info");
 });
+// src/commands/derive-prd.ts
+var import_fs_extra9 = __toESM(require_lib());
+var import_path11 = require("path");
+// src/utils/prd-extractor.ts
+function extractPrd(moduleFeature, featureJsonPath, namespace) {
+  const { metadata, analysis, specification, handoff } = moduleFeature;
+  return {
+    version: "2.0.0",
+    source: {
+      type: "ba-handoff-programmatic",
+      featureJson: featureJsonPath,
+      extractedAt: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    project: {
+      application: metadata.application,
+      module: metadata.module,
+      ...namespace ? { namespace } : {}
+    },
+    requirements: {
+      useCases: (specification?.useCases ?? []).map((uc) => ({
+        id: uc.id,
+        name: uc.name,
+        actor: uc.primaryActor,
+        permission: uc.permission,
+        steps: uc.mainScenario ?? [],
+        linkedRules: uc.linkedRules ?? []
+      })),
+      functionalRequirements: (specification?.functionalRequirements ?? []).map((fr) => ({
+        id: fr.id,
+        statement: fr.statement,
+        priority: fr.priority,
+        linkedUCs: fr.linkedUseCases ?? []
+      }))
+    },
+    businessRules: (analysis?.businessRules ?? []).map((br) => ({
+      id: br.id,
+      name: br.name,
+      category: br.category,
+      statement: br.statement,
+      priority: br.priority
+    })),
+    architecture: {
+      entities: (analysis?.entities ?? []).map((e) => ({
+        name: e.name,
+        description: e.description,
+        type: e.type,
+        attributes: e.attributes,
+        relationships: e.relationships
+      })),
+      apiEndpoints: (specification?.apiEndpoints ?? []).map((ep) => ({
+        method: ep.method,
+        route: ep.route,
+        operation: ep.operation,
+        permission: ep.permission,
+        requestSchema: ep.requestSchema,
+        responseSchema: ep.responseSchema,
+        errorCodes: ep.errorCodes,
+        linkedUC: ep.linkedUC,
+        module: ep.module
+      })),
+      permissionMatrix: specification?.permissionMatrix ?? { permissions: [], roleAssignments: [] },
+      sections: (specification?.sections ?? []).map((s) => ({
+        code: s.code,
+        name: s.name,
+        description: s.description,
+        route: s.route,
+        permission: s.permission,
+        resources: s.resources?.map((r) => ({
+          code: r.code,
+          type: r.type,
+          entity: r.entity,
+          permission: r.permission,
+          columns: r.columns,
+          actions: r.actions
+        }))
+      }))
+    },
+    implementation: {
+      strategy: handoff?.implementationStrategy ?? "module-by-module",
+      filesToCreate: handoff?.filesToCreate ?? {},
+      brToCodeMapping: (handoff?.brToCodeMapping ?? []).map((m) => ({
+        ruleId: m.ruleId,
+        ruleName: m.ruleName,
+        targetFile: m.targetFile,
+        targetMethod: m.targetMethod,
+        implementationType: m.implementationType
+      }))
+    },
+    seedData: {
+      core: specification?.seedDataCore,
+      business: specification?.seedDataBusiness
+    }
+  };
+}
+function validateForPrdExtraction(feature) {
+  const errors = [];
+  if (!feature.id) {
+    errors.push("Missing feature ID");
+  }
+  if (!feature.metadata?.application) {
+    errors.push("Missing metadata.application");
+  }
+  if (!feature.metadata?.module) {
+    errors.push("Missing metadata.module");
+  }
+  if (feature.status !== "handed-off" && feature.status !== "approved" && feature.status !== "consolidated") {
+    errors.push(`Feature status is "${feature.status}" \u2014 expected "handed-off", "approved", or "consolidated"`);
+  }
+  if (!feature.specification?.useCases?.length) {
+    errors.push("No use cases found in specification");
+  }
+  if (!feature.analysis?.businessRules?.length) {
+    errors.push("No business rules found in analysis");
+  }
+  if (!feature.handoff?.filesToCreate) {
+    errors.push("No filesToCreate found in handoff");
+  }
+  return errors;
+}
+// src/commands/derive-prd.ts
+function readSmartStackNamespace() {
+  try {
+    const configPath = (0, import_path11.join)(process.cwd(), ".smartstack", "config.json");
+    if (import_fs_extra9.default.existsSync(configPath)) {
+      const config = import_fs_extra9.default.readJsonSync(configPath);
+      return config.baseNamespace;
+    }
+  } catch {
+  }
+  return void 0;
+}
+async function findModuleFeatureFiles(masterPath) {
+  const master = await import_fs_extra9.default.readJson(masterPath);
+  const masterDir = (0, import_path11.dirname)(masterPath);
+  const paths = [];
+  if (master.modules) {
+    for (const mod of master.modules) {
+      if (mod.featureJsonPath) {
+        const fullPath = (0, import_path11.join)(masterDir, "..", "..", mod.featureJsonPath);
+        if (await import_fs_extra9.default.pathExists(fullPath)) {
+          paths.push(fullPath);
+        }
+      }
+    }
+  }
+  return paths;
+}
+var derivePrdCommand = new Command("derive-prd").description("Extract prd.json programmatically from feature.json (no LLM)").option("-f, --feature <path>", "Path to a module-level feature.json").option("-a, --application <path>", "Path to a master application-level feature.json (processes all modules)").option("-o, --output <path>", "Output path for prd.json (default: .ralph/prd-{module}.json)").option("--strict", "Fail on validation warnings").action(async (options) => {
+  if (!options.feature && !options.application) {
+    console.log(source_default.red("Error: Provide either --feature or --application path"));
+    process.exit(1);
+  }
+  const namespace = readSmartStackNamespace();
+  const ralphDir = (0, import_path11.join)(process.cwd(), ".ralph");
+  await import_fs_extra9.default.ensureDir(ralphDir);
+  let featurePaths = [];
+  if (options.application) {
+    const appPath = (0, import_path11.join)(process.cwd(), options.application);
+    if (!await import_fs_extra9.default.pathExists(appPath)) {
+      console.log(source_default.red(`Application feature.json not found: ${appPath}`));
+      process.exit(1);
+    }
+    const modulePaths = await findModuleFeatureFiles(appPath);
+    if (modulePaths.length === 0) {
+      console.log(source_default.red("No module feature.json files found referenced in application master"));
+      process.exit(1);
+    }
+    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_path11.join)(process.cwd(), options.feature);
+    if (!await import_fs_extra9.default.pathExists(featurePath)) {
+      console.log(source_default.red(`Feature.json not found: ${featurePath}`));
+      process.exit(1);
+    }
+    featurePaths = [{ path: featurePath, isApplicationMode: false }];
+  }
+  let totalGenerated = 0;
+  let totalErrors = 0;
+  for (const entry of featurePaths) {
+    const featureJson = await import_fs_extra9.default.readJson(entry.path);
+    const moduleName = featureJson.metadata?.module ?? "unknown";
+    console.log(source_default.cyan(`
+Processing module: ${source_default.bold(moduleName)}`));
+    const errors = validateForPrdExtraction(featureJson);
+    if (errors.length > 0) {
+      console.log(source_default.yellow(`  Validation warnings:`));
+      for (const err of errors) {
+        console.log(source_default.yellow(`    - ${err}`));
+      }
+      if (options.strict) {
+        console.log(source_default.red(`  Skipping ${moduleName} (--strict mode)`));
+        totalErrors++;
+        continue;
+      }
+    }
+    const relativePath = (0, import_path11.relative)(process.cwd(), entry.path);
+    const prd = extractPrd(featureJson, relativePath, namespace);
+    let outputPath;
+    if (options.output && !entry.isApplicationMode) {
+      outputPath = (0, import_path11.join)(process.cwd(), options.output);
+    } else {
+      outputPath = (0, import_path11.join)(ralphDir, `prd-${moduleName}.json`);
+    }
+    await import_fs_extra9.default.writeJson(outputPath, prd, { spaces: 2 });
+    totalGenerated++;
+    const relOutput = (0, import_path11.relative)(process.cwd(), outputPath);
+    console.log(source_default.green(`  Generated: ${relOutput}`));
+    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}`));
+    const fileCount = Object.values(prd.implementation.filesToCreate).reduce((sum, files) => sum + (files?.length ?? 0), 0);
+    console.log(source_default.gray(`    Files to create: ${fileCount} | BR mappings: ${prd.implementation.brToCodeMapping.length}`));
+  }
+  console.log();
+  if (totalErrors > 0) {
+    logger.box([
+      `PRD extraction completed with ${totalErrors} error(s)`,
+      `${totalGenerated} prd.json file(s) generated`
+    ], "warning");
+  } else {
+    logger.box([
+      `PRD extraction complete`,
+      `${totalGenerated} prd.json file(s) generated in .ralph/`
+    ], "success");
+  }
+});
 // src/index.ts
 var import_fs5 = require("fs");
-var import_path11 = require("path");
-var pkg = JSON.parse((0, import_fs5.readFileSync)((0, import_path11.join)(__dirname, "..", "package.json"), "utf-8"));
+var import_path12 = require("path");
+var pkg = JSON.parse((0, import_fs5.readFileSync)((0, import_path12.join)(__dirname, "..", "package.json"), "utf-8"));
 var LICENSE_FREE_COMMANDS = ["license", "help", "--help", "-h", "--version", "-v"];
 async function main2() {
   const program2 = new Command();
@@ -126430,6 +126678,7 @@ async function main2() {
   program2.addCommand(doctorCommand);
   program2.addCommand(adminCommand);
   program2.addCommand(mcpCommand);
+  program2.addCommand(derivePrdCommand);
   const args = process.argv.slice(2);
   const commandName = args[0] || "";
   const requiresLicense = !LICENSE_FREE_COMMANDS.some(