@atlashub/smartstack-cli 2.6.3 → 2.7.1

package/dist/index.js

@@ -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;
       }
@@ -117947,6 +117947,7 @@ var openPattern = /\\{/g;
 var closePattern = /\\}/g;
 var commaPattern = /\\,/g;
 var periodPattern = /\\./g;
+var EXPANSION_MAX = 1e5;
 function numeric(str) {
   return !isNaN(str) ? parseInt(str, 10) : str.charCodeAt(0);
 }
@@ -117977,14 +117978,15 @@ function parseCommaParts(str) {
   parts.push.apply(parts, p);
   return parts;
 }
-function expand(str) {
+function expand(str, options = {}) {
   if (!str) {
     return [];
   }
+  const { max = EXPANSION_MAX } = options;
   if (str.slice(0, 2) === "{}") {
     str = "\\{\\}" + str.slice(2);
   }
-  return expand_(escapeBraces(str), true).map(unescapeBraces);
+  return expand_(escapeBraces(str), max, true).map(unescapeBraces);
 }
 function embrace(str) {
   return "{" + str + "}";
@@ -117998,15 +118000,15 @@ function lte(i, y) {
 function gte(i, y) {
   return i >= y;
 }
-function expand_(str, isTop) {
+function expand_(str, max, isTop) {
   const expansions = [];
   const m = balanced("{", "}", str);
   if (!m)
     return [str];
   const pre = m.pre;
-  const post = m.post.length ? expand_(m.post, false) : [""];
+  const post = m.post.length ? expand_(m.post, max, false) : [""];
   if (/\$$/.test(m.pre)) {
-    for (let k = 0; k < post.length; k++) {
+    for (let k = 0; k < post.length && k < max; k++) {
       const expansion = pre + "{" + m.body + "}" + post[k];
       expansions.push(expansion);
     }
@@ -118018,7 +118020,7 @@ function expand_(str, isTop) {
     if (!isSequence && !isOptions) {
       if (m.post.match(/,(?!,).*\}/)) {
         str = m.pre + "{" + m.body + escClose + m.post;
-        return expand_(str);
+        return expand_(str, max, true);
       }
       return [str];
     }
@@ -118028,7 +118030,7 @@ function expand_(str, isTop) {
     } else {
       n = parseCommaParts(m.body);
       if (n.length === 1 && n[0] !== void 0) {
-        n = expand_(n[0], false).map(embrace);
+        n = expand_(n[0], max, false).map(embrace);
         if (n.length === 1) {
           return post.map((p) => m.pre + n[0] + p);
         }
@@ -118074,11 +118076,11 @@ function expand_(str, isTop) {
     } else {
       N = [];
       for (let j = 0; j < n.length; j++) {
-        N.push.apply(N, expand_(n[j], false));
+        N.push.apply(N, expand_(n[j], max, false));
       }
     }
     for (let j = 0; j < N.length; j++) {
-      for (let k = 0; k < post.length; k++) {
+      for (let k = 0; k < post.length && expansions.length < max; k++) {
         const expansion = pre + N[j] + post[k];
         if (!isTop || isSequence || expansion) {
           expansions.push(expansion);
@@ -122862,8 +122864,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 +123423,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 +123452,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 +123696,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 +123710,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) {
@@ -125907,7 +125909,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" }).trim();
+  return (0, import_child_process8.execSync)(cmd, { encoding: "utf-8", timeout: 15e3 }).trim();
 }
 function isLoginFailure(error) {
   const msg = error instanceof Error ? error.message : String(error);
@@ -126120,7 +126122,23 @@ adminCommand.command("reset").description("Reset the localAdmin account password
       if (nativeDriver) {
         try {
           spinner.text = "Connecting with Windows Authentication...";
-          await nativeDriver.connect(connectionString);
+          const nativeServer = connInfo.server === "(local)" ? "localhost" : connInfo.server;
+          const nativeConfig = {
+            server: nativeServer,
+            database: connInfo.database,
+            options: {
+              trustedConnection: true,
+              trustServerCertificate: true
+            },
+            connectionTimeout: 15e3,
+            requestTimeout: 15e3
+          };
+          await Promise.race([
+            nativeDriver.connect(nativeConfig),
+            new Promise(
+              (_3, reject) => setTimeout(() => reject(new Error("Connection timeout (15s)")), 15e3)
+            )
+          ]);
           nativeConnected = true;
           await resetViaMssql(nativeDriver);
         } catch (nativeError) {
@@ -126418,10 +126436,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();
@@ -126439,6 +126686,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(