@atlashub/smartstack-cli 4.25.0 → 4.27.0

package/dist/index.js

@@ -974,7 +974,7 @@ var require_command = __commonJS({
     var EventEmitter2 = require("events").EventEmitter;
     var childProcess2 = require("child_process");
     var path4 = require("path");
-    var fs20 = require("fs");
+    var fs21 = 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 = path4.resolve(baseDir, baseName);
-          if (fs20.existsSync(localBin)) return localBin;
+          if (fs21.existsSync(localBin)) return localBin;
           if (sourceExt.includes(path4.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext2) => fs20.existsSync(`${localBin}${ext2}`)
+            (ext2) => fs21.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 = fs20.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs21.realpathSync(this._scriptPath);
           } catch (err) {
             resolvedScriptPath = this._scriptPath;
           }
@@ -3042,8 +3042,8 @@ var require_universalify = __commonJS({
       return Object.defineProperty(function(...args) {
         if (typeof args[args.length - 1] === "function") fn.apply(this, args);
         else {
-          return new Promise((resolve, reject) => {
-            args.push((err, res) => err != null ? reject(err) : resolve(res));
+          return new Promise((resolve2, reject) => {
+            args.push((err, res) => err != null ? reject(err) : resolve2(res));
             fn.apply(this, args);
           });
         }
@@ -3089,54 +3089,54 @@ var require_polyfills = __commonJS({
     }
     var chdir;
     module2.exports = patch;
-    function patch(fs20) {
+    function patch(fs21) {
       if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-        patchLchmod(fs20);
-      }
-      if (!fs20.lutimes) {
-        patchLutimes(fs20);
-      }
-      fs20.chown = chownFix(fs20.chown);
-      fs20.fchown = chownFix(fs20.fchown);
-      fs20.lchown = chownFix(fs20.lchown);
-      fs20.chmod = chmodFix(fs20.chmod);
-      fs20.fchmod = chmodFix(fs20.fchmod);
-      fs20.lchmod = chmodFix(fs20.lchmod);
-      fs20.chownSync = chownFixSync(fs20.chownSync);
-      fs20.fchownSync = chownFixSync(fs20.fchownSync);
-      fs20.lchownSync = chownFixSync(fs20.lchownSync);
-      fs20.chmodSync = chmodFixSync(fs20.chmodSync);
-      fs20.fchmodSync = chmodFixSync(fs20.fchmodSync);
-      fs20.lchmodSync = chmodFixSync(fs20.lchmodSync);
-      fs20.stat = statFix(fs20.stat);
-      fs20.fstat = statFix(fs20.fstat);
-      fs20.lstat = statFix(fs20.lstat);
-      fs20.statSync = statFixSync(fs20.statSync);
-      fs20.fstatSync = statFixSync(fs20.fstatSync);
-      fs20.lstatSync = statFixSync(fs20.lstatSync);
-      if (fs20.chmod && !fs20.lchmod) {
-        fs20.lchmod = function(path4, mode, cb) {
+        patchLchmod(fs21);
+      }
+      if (!fs21.lutimes) {
+        patchLutimes(fs21);
+      }
+      fs21.chown = chownFix(fs21.chown);
+      fs21.fchown = chownFix(fs21.fchown);
+      fs21.lchown = chownFix(fs21.lchown);
+      fs21.chmod = chmodFix(fs21.chmod);
+      fs21.fchmod = chmodFix(fs21.fchmod);
+      fs21.lchmod = chmodFix(fs21.lchmod);
+      fs21.chownSync = chownFixSync(fs21.chownSync);
+      fs21.fchownSync = chownFixSync(fs21.fchownSync);
+      fs21.lchownSync = chownFixSync(fs21.lchownSync);
+      fs21.chmodSync = chmodFixSync(fs21.chmodSync);
+      fs21.fchmodSync = chmodFixSync(fs21.fchmodSync);
+      fs21.lchmodSync = chmodFixSync(fs21.lchmodSync);
+      fs21.stat = statFix(fs21.stat);
+      fs21.fstat = statFix(fs21.fstat);
+      fs21.lstat = statFix(fs21.lstat);
+      fs21.statSync = statFixSync(fs21.statSync);
+      fs21.fstatSync = statFixSync(fs21.fstatSync);
+      fs21.lstatSync = statFixSync(fs21.lstatSync);
+      if (fs21.chmod && !fs21.lchmod) {
+        fs21.lchmod = function(path4, mode, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs20.lchmodSync = function() {
+        fs21.lchmodSync = function() {
         };
       }
-      if (fs20.chown && !fs20.lchown) {
-        fs20.lchown = function(path4, uid, gid, cb) {
+      if (fs21.chown && !fs21.lchown) {
+        fs21.lchown = function(path4, uid, gid, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs20.lchownSync = function() {
+        fs21.lchownSync = function() {
         };
       }
       if (platform4 === "win32") {
-        fs20.rename = typeof fs20.rename !== "function" ? fs20.rename : (function(fs$rename) {
+        fs21.rename = typeof fs21.rename !== "function" ? fs21.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() {
-                  fs20.stat(to, function(stater, st) {
+                  fs21.stat(to, function(stater, st) {
                     if (stater && stater.code === "ENOENT")
                       fs$rename(from3, to, CB);
                     else
@@ -3152,9 +3152,9 @@ var require_polyfills = __commonJS({
           }
           if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
           return rename;
-        })(fs20.rename);
+        })(fs21.rename);
       }
-      fs20.read = typeof fs20.read !== "function" ? fs20.read : (function(fs$read) {
+      fs21.read = typeof fs21.read !== "function" ? fs21.read : (function(fs$read) {
         function read(fd, buffer, offset, length, position, callback_) {
           var callback;
           if (callback_ && typeof callback_ === "function") {
@@ -3162,22 +3162,22 @@ var require_polyfills = __commonJS({
             callback = function(er, _3, __) {
               if (er && er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
-                return fs$read.call(fs20, fd, buffer, offset, length, position, callback);
+                return fs$read.call(fs21, fd, buffer, offset, length, position, callback);
               }
               callback_.apply(this, arguments);
             };
           }
-          return fs$read.call(fs20, fd, buffer, offset, length, position, callback);
+          return fs$read.call(fs21, fd, buffer, offset, length, position, callback);
         }
         if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
         return read;
-      })(fs20.read);
-      fs20.readSync = typeof fs20.readSync !== "function" ? fs20.readSync : /* @__PURE__ */ (function(fs$readSync) {
+      })(fs21.read);
+      fs21.readSync = typeof fs21.readSync !== "function" ? fs21.readSync : /* @__PURE__ */ (function(fs$readSync) {
         return function(fd, buffer, offset, length, position) {
           var eagCounter = 0;
           while (true) {
             try {
-              return fs$readSync.call(fs20, fd, buffer, offset, length, position);
+              return fs$readSync.call(fs21, fd, buffer, offset, length, position);
             } catch (er) {
               if (er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
@@ -3187,10 +3187,10 @@ var require_polyfills = __commonJS({
             }
           }
         };
-      })(fs20.readSync);
-      function patchLchmod(fs21) {
-        fs21.lchmod = function(path4, mode, callback) {
-          fs21.open(
+      })(fs21.readSync);
+      function patchLchmod(fs22) {
+        fs22.lchmod = function(path4, mode, callback) {
+          fs22.open(
             path4,
             constants.O_WRONLY | constants.O_SYMLINK,
             mode,
@@ -3199,80 +3199,80 @@ var require_polyfills = __commonJS({
                 if (callback) callback(err);
                 return;
               }
-              fs21.fchmod(fd, mode, function(err2) {
-                fs21.close(fd, function(err22) {
+              fs22.fchmod(fd, mode, function(err2) {
+                fs22.close(fd, function(err22) {
                   if (callback) callback(err2 || err22);
                 });
               });
             }
           );
         };
-        fs21.lchmodSync = function(path4, mode) {
-          var fd = fs21.openSync(path4, constants.O_WRONLY | constants.O_SYMLINK, mode);
+        fs22.lchmodSync = function(path4, mode) {
+          var fd = fs22.openSync(path4, constants.O_WRONLY | constants.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
-            ret = fs21.fchmodSync(fd, mode);
+            ret = fs22.fchmodSync(fd, mode);
             threw = false;
           } finally {
             if (threw) {
               try {
-                fs21.closeSync(fd);
+                fs22.closeSync(fd);
               } catch (er) {
               }
             } else {
-              fs21.closeSync(fd);
+              fs22.closeSync(fd);
             }
           }
           return ret;
         };
       }
-      function patchLutimes(fs21) {
-        if (constants.hasOwnProperty("O_SYMLINK") && fs21.futimes) {
-          fs21.lutimes = function(path4, at, mt, cb) {
-            fs21.open(path4, constants.O_SYMLINK, function(er, fd) {
+      function patchLutimes(fs22) {
+        if (constants.hasOwnProperty("O_SYMLINK") && fs22.futimes) {
+          fs22.lutimes = function(path4, at, mt, cb) {
+            fs22.open(path4, constants.O_SYMLINK, function(er, fd) {
               if (er) {
                 if (cb) cb(er);
                 return;
               }
-              fs21.futimes(fd, at, mt, function(er2) {
-                fs21.close(fd, function(er22) {
+              fs22.futimes(fd, at, mt, function(er2) {
+                fs22.close(fd, function(er22) {
                   if (cb) cb(er2 || er22);
                 });
               });
             });
           };
-          fs21.lutimesSync = function(path4, at, mt) {
-            var fd = fs21.openSync(path4, constants.O_SYMLINK);
+          fs22.lutimesSync = function(path4, at, mt) {
+            var fd = fs22.openSync(path4, constants.O_SYMLINK);
             var ret;
             var threw = true;
             try {
-              ret = fs21.futimesSync(fd, at, mt);
+              ret = fs22.futimesSync(fd, at, mt);
               threw = false;
             } finally {
               if (threw) {
                 try {
-                  fs21.closeSync(fd);
+                  fs22.closeSync(fd);
                 } catch (er) {
                 }
               } else {
-                fs21.closeSync(fd);
+                fs22.closeSync(fd);
               }
             }
             return ret;
           };
-        } else if (fs21.futimes) {
-          fs21.lutimes = function(_a, _b, _c, cb) {
+        } else if (fs22.futimes) {
+          fs22.lutimes = function(_a, _b, _c, cb) {
             if (cb) process.nextTick(cb);
           };
-          fs21.lutimesSync = function() {
+          fs22.lutimesSync = function() {
           };
         }
       }
       function chmodFix(orig) {
         if (!orig) return orig;
         return function(target, mode, cb) {
-          return orig.call(fs20, target, mode, function(er) {
+          return orig.call(fs21, target, mode, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -3282,7 +3282,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, mode) {
           try {
-            return orig.call(fs20, target, mode);
+            return orig.call(fs21, target, mode);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -3291,7 +3291,7 @@ var require_polyfills = __commonJS({
       function chownFix(orig) {
         if (!orig) return orig;
         return function(target, uid, gid, cb) {
-          return orig.call(fs20, target, uid, gid, function(er) {
+          return orig.call(fs21, target, uid, gid, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -3301,7 +3301,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, uid, gid) {
           try {
-            return orig.call(fs20, target, uid, gid);
+            return orig.call(fs21, target, uid, gid);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -3321,13 +3321,13 @@ var require_polyfills = __commonJS({
             }
             if (cb) cb.apply(this, arguments);
           }
-          return options ? orig.call(fs20, target, options, callback) : orig.call(fs20, target, callback);
+          return options ? orig.call(fs21, target, options, callback) : orig.call(fs21, target, callback);
         };
       }
       function statFixSync(orig) {
         if (!orig) return orig;
         return function(target, options) {
-          var stats = options ? orig.call(fs20, target, options) : orig.call(fs20, target);
+          var stats = options ? orig.call(fs21, target, options) : orig.call(fs21, target);
           if (stats) {
             if (stats.uid < 0) stats.uid += 4294967296;
             if (stats.gid < 0) stats.gid += 4294967296;
@@ -3357,7 +3357,7 @@ var require_legacy_streams = __commonJS({
     "use strict";
     var Stream2 = require("stream").Stream;
     module2.exports = legacy;
-    function legacy(fs20) {
+    function legacy(fs21) {
       return {
         ReadStream,
         WriteStream
@@ -3400,7 +3400,7 @@ var require_legacy_streams = __commonJS({
           });
           return;
         }
-        fs20.open(this.path, this.flags, this.mode, function(err, fd) {
+        fs21.open(this.path, this.flags, this.mode, function(err, fd) {
           if (err) {
             self2.emit("error", err);
             self2.readable = false;
@@ -3439,7 +3439,7 @@ var require_legacy_streams = __commonJS({
         this.busy = false;
         this._queue = [];
         if (this.fd === null) {
-          this._open = fs20.open;
+          this._open = fs21.open;
           this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
           this.flush();
         }
@@ -3475,7 +3475,7 @@ var require_clone = __commonJS({
 var require_graceful_fs = __commonJS({
   "node_modules/graceful-fs/graceful-fs.js"(exports2, module2) {
     "use strict";
-    var fs20 = require("fs");
+    var fs21 = require("fs");
     var polyfills = require_polyfills();
     var legacy = require_legacy_streams();
     var clone = require_clone();
@@ -3507,12 +3507,12 @@ var require_graceful_fs = __commonJS({
         m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
         console.error(m);
       };
-    if (!fs20[gracefulQueue]) {
+    if (!fs21[gracefulQueue]) {
       queue = global[gracefulQueue] || [];
-      publishQueue(fs20, queue);
-      fs20.close = (function(fs$close) {
+      publishQueue(fs21, queue);
+      fs21.close = (function(fs$close) {
         function close(fd, cb) {
-          return fs$close.call(fs20, fd, function(err) {
+          return fs$close.call(fs21, fd, function(err) {
             if (!err) {
               resetQueue();
             }
@@ -3524,40 +3524,40 @@ var require_graceful_fs = __commonJS({
           value: fs$close
         });
         return close;
-      })(fs20.close);
-      fs20.closeSync = (function(fs$closeSync) {
+      })(fs21.close);
+      fs21.closeSync = (function(fs$closeSync) {
         function closeSync(fd) {
-          fs$closeSync.apply(fs20, arguments);
+          fs$closeSync.apply(fs21, arguments);
           resetQueue();
         }
         Object.defineProperty(closeSync, previousSymbol, {
           value: fs$closeSync
         });
         return closeSync;
-      })(fs20.closeSync);
+      })(fs21.closeSync);
       if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
         process.on("exit", function() {
-          debug(fs20[gracefulQueue]);
-          require("assert").equal(fs20[gracefulQueue].length, 0);
+          debug(fs21[gracefulQueue]);
+          require("assert").equal(fs21[gracefulQueue].length, 0);
         });
       }
     }
     var queue;
     if (!global[gracefulQueue]) {
-      publishQueue(global, fs20[gracefulQueue]);
-    }
-    module2.exports = patch(clone(fs20));
-    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs20.__patched) {
-      module2.exports = patch(fs20);
-      fs20.__patched = true;
-    }
-    function patch(fs21) {
-      polyfills(fs21);
-      fs21.gracefulify = patch;
-      fs21.createReadStream = createReadStream;
-      fs21.createWriteStream = createWriteStream;
-      var fs$readFile = fs21.readFile;
-      fs21.readFile = readFile;
+      publishQueue(global, fs21[gracefulQueue]);
+    }
+    module2.exports = patch(clone(fs21));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs21.__patched) {
+      module2.exports = patch(fs21);
+      fs21.__patched = true;
+    }
+    function patch(fs22) {
+      polyfills(fs22);
+      fs22.gracefulify = patch;
+      fs22.createReadStream = createReadStream;
+      fs22.createWriteStream = createWriteStream;
+      var fs$readFile = fs22.readFile;
+      fs22.readFile = readFile;
       function readFile(path4, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
@@ -3573,8 +3573,8 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$writeFile = fs21.writeFile;
-      fs21.writeFile = writeFile;
+      var fs$writeFile = fs22.writeFile;
+      fs22.writeFile = writeFile;
       function writeFile(path4, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
@@ -3590,9 +3590,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$appendFile = fs21.appendFile;
+      var fs$appendFile = fs22.appendFile;
       if (fs$appendFile)
-        fs21.appendFile = appendFile;
+        fs22.appendFile = appendFile;
       function appendFile(path4, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
@@ -3608,9 +3608,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$copyFile = fs21.copyFile;
+      var fs$copyFile = fs22.copyFile;
       if (fs$copyFile)
-        fs21.copyFile = copyFile;
+        fs22.copyFile = copyFile;
       function copyFile(src, dest, flags, cb) {
         if (typeof flags === "function") {
           cb = flags;
@@ -3628,8 +3628,8 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$readdir = fs21.readdir;
-      fs21.readdir = readdir2;
+      var fs$readdir = fs22.readdir;
+      fs22.readdir = readdir2;
       var noReaddirOptionVersions = /^v[0-5]\./;
       function readdir2(path4, options, cb) {
         if (typeof options === "function")
@@ -3670,21 +3670,21 @@ var require_graceful_fs = __commonJS({
         }
       }
       if (process.version.substr(0, 4) === "v0.8") {
-        var legStreams = legacy(fs21);
+        var legStreams = legacy(fs22);
         ReadStream = legStreams.ReadStream;
         WriteStream = legStreams.WriteStream;
       }
-      var fs$ReadStream = fs21.ReadStream;
+      var fs$ReadStream = fs22.ReadStream;
       if (fs$ReadStream) {
         ReadStream.prototype = Object.create(fs$ReadStream.prototype);
         ReadStream.prototype.open = ReadStream$open;
       }
-      var fs$WriteStream = fs21.WriteStream;
+      var fs$WriteStream = fs22.WriteStream;
       if (fs$WriteStream) {
         WriteStream.prototype = Object.create(fs$WriteStream.prototype);
         WriteStream.prototype.open = WriteStream$open;
       }
-      Object.defineProperty(fs21, "ReadStream", {
+      Object.defineProperty(fs22, "ReadStream", {
         get: function() {
           return ReadStream;
         },
@@ -3694,7 +3694,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      Object.defineProperty(fs21, "WriteStream", {
+      Object.defineProperty(fs22, "WriteStream", {
         get: function() {
           return WriteStream;
         },
@@ -3705,7 +3705,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileReadStream = ReadStream;
-      Object.defineProperty(fs21, "FileReadStream", {
+      Object.defineProperty(fs22, "FileReadStream", {
         get: function() {
           return FileReadStream;
         },
@@ -3716,7 +3716,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileWriteStream = WriteStream;
-      Object.defineProperty(fs21, "FileWriteStream", {
+      Object.defineProperty(fs22, "FileWriteStream", {
         get: function() {
           return FileWriteStream;
         },
@@ -3765,13 +3765,13 @@ var require_graceful_fs = __commonJS({
         });
       }
       function createReadStream(path4, options) {
-        return new fs21.ReadStream(path4, options);
+        return new fs22.ReadStream(path4, options);
       }
       function createWriteStream(path4, options) {
-        return new fs21.WriteStream(path4, options);
+        return new fs22.WriteStream(path4, options);
       }
-      var fs$open = fs21.open;
-      fs21.open = open2;
+      var fs$open = fs22.open;
+      fs22.open = open2;
       function open2(path4, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
@@ -3787,20 +3787,20 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      return fs21;
+      return fs22;
     }
     function enqueue(elem) {
       debug("ENQUEUE", elem[0].name, elem[1]);
-      fs20[gracefulQueue].push(elem);
+      fs21[gracefulQueue].push(elem);
       retry();
     }
     var retryTimer;
     function resetQueue() {
       var now = Date.now();
-      for (var i = 0; i < fs20[gracefulQueue].length; ++i) {
-        if (fs20[gracefulQueue][i].length > 2) {
-          fs20[gracefulQueue][i][3] = now;
-          fs20[gracefulQueue][i][4] = now;
+      for (var i = 0; i < fs21[gracefulQueue].length; ++i) {
+        if (fs21[gracefulQueue][i].length > 2) {
+          fs21[gracefulQueue][i][3] = now;
+          fs21[gracefulQueue][i][4] = now;
         }
       }
       retry();
@@ -3808,9 +3808,9 @@ var require_graceful_fs = __commonJS({
     function retry() {
       clearTimeout(retryTimer);
       retryTimer = void 0;
-      if (fs20[gracefulQueue].length === 0)
+      if (fs21[gracefulQueue].length === 0)
         return;
-      var elem = fs20[gracefulQueue].shift();
+      var elem = fs21[gracefulQueue].shift();
       var fn = elem[0];
       var args = elem[1];
       var err = elem[2];
@@ -3832,7 +3832,7 @@ var require_graceful_fs = __commonJS({
           debug("RETRY", fn.name, args);
           fn.apply(null, args.concat([startTime]));
         } else {
-          fs20[gracefulQueue].push(elem);
+          fs21[gracefulQueue].push(elem);
         }
       }
       if (retryTimer === void 0) {
@@ -3847,7 +3847,7 @@ var require_fs = __commonJS({
   "node_modules/fs-extra/lib/fs/index.js"(exports2) {
     "use strict";
     var u = require_universalify().fromCallback;
-    var fs20 = require_graceful_fs();
+    var fs21 = require_graceful_fs();
     var api = [
       "access",
       "appendFile",
@@ -3888,66 +3888,66 @@ var require_fs = __commonJS({
       "utimes",
       "writeFile"
     ].filter((key) => {
-      return typeof fs20[key] === "function";
+      return typeof fs21[key] === "function";
     });
-    Object.assign(exports2, fs20);
+    Object.assign(exports2, fs21);
     api.forEach((method) => {
-      exports2[method] = u(fs20[method]);
+      exports2[method] = u(fs21[method]);
     });
     exports2.exists = function(filename, callback) {
       if (typeof callback === "function") {
-        return fs20.exists(filename, callback);
+        return fs21.exists(filename, callback);
       }
-      return new Promise((resolve) => {
-        return fs20.exists(filename, resolve);
+      return new Promise((resolve2) => {
+        return fs21.exists(filename, resolve2);
       });
     };
     exports2.read = function(fd, buffer, offset, length, position, callback) {
       if (typeof callback === "function") {
-        return fs20.read(fd, buffer, offset, length, position, callback);
+        return fs21.read(fd, buffer, offset, length, position, callback);
       }
-      return new Promise((resolve, reject) => {
-        fs20.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
+      return new Promise((resolve2, reject) => {
+        fs21.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
           if (err) return reject(err);
-          resolve({ bytesRead, buffer: buffer2 });
+          resolve2({ bytesRead, buffer: buffer2 });
         });
       });
     };
     exports2.write = function(fd, buffer, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs20.write(fd, buffer, ...args);
+        return fs21.write(fd, buffer, ...args);
       }
-      return new Promise((resolve, reject) => {
-        fs20.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
+      return new Promise((resolve2, reject) => {
+        fs21.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
           if (err) return reject(err);
-          resolve({ bytesWritten, buffer: buffer2 });
+          resolve2({ bytesWritten, buffer: buffer2 });
         });
       });
     };
     exports2.readv = function(fd, buffers, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs20.readv(fd, buffers, ...args);
+        return fs21.readv(fd, buffers, ...args);
       }
-      return new Promise((resolve, reject) => {
-        fs20.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
+      return new Promise((resolve2, reject) => {
+        fs21.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
           if (err) return reject(err);
-          resolve({ bytesRead, buffers: buffers2 });
+          resolve2({ bytesRead, buffers: buffers2 });
         });
       });
     };
     exports2.writev = function(fd, buffers, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs20.writev(fd, buffers, ...args);
+        return fs21.writev(fd, buffers, ...args);
       }
-      return new Promise((resolve, reject) => {
-        fs20.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
+      return new Promise((resolve2, reject) => {
+        fs21.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
           if (err) return reject(err);
-          resolve({ bytesWritten, buffers: buffers2 });
+          resolve2({ bytesWritten, buffers: buffers2 });
         });
       });
     };
-    if (typeof fs20.realpath.native === "function") {
-      exports2.realpath.native = u(fs20.realpath.native);
+    if (typeof fs21.realpath.native === "function") {
+      exports2.realpath.native = u(fs21.realpath.native);
     } else {
       process.emitWarning(
         "fs.realpath.native is not a function. Is fs being monkey-patched?",
@@ -3980,7 +3980,7 @@ var require_utils = __commonJS({
 var require_make_dir = __commonJS({
   "node_modules/fs-extra/lib/mkdirs/make-dir.js"(exports2, module2) {
     "use strict";
-    var fs20 = require_fs();
+    var fs21 = require_fs();
     var { checkPath } = require_utils();
     var getMode = (options) => {
       const defaults2 = { mode: 511 };
@@ -3989,14 +3989,14 @@ var require_make_dir = __commonJS({
     };
     module2.exports.makeDir = async (dir, options) => {
       checkPath(dir);
-      return fs20.mkdir(dir, {
+      return fs21.mkdir(dir, {
         mode: getMode(options),
         recursive: true
       });
     };
     module2.exports.makeDirSync = (dir, options) => {
       checkPath(dir);
-      return fs20.mkdirSync(dir, {
+      return fs21.mkdirSync(dir, {
         mode: getMode(options),
         recursive: true
       });
@@ -4028,13 +4028,13 @@ var require_path_exists = __commonJS({
   "node_modules/fs-extra/lib/path-exists/index.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs20 = require_fs();
+    var fs21 = require_fs();
     function pathExists(path4) {
-      return fs20.access(path4).then(() => true).catch(() => false);
+      return fs21.access(path4).then(() => true).catch(() => false);
     }
     module2.exports = {
       pathExists: u(pathExists),
-      pathExistsSync: fs20.existsSync
+      pathExistsSync: fs21.existsSync
     };
   }
 });
@@ -4043,16 +4043,16 @@ var require_path_exists = __commonJS({
 var require_utimes = __commonJS({
   "node_modules/fs-extra/lib/util/utimes.js"(exports2, module2) {
     "use strict";
-    var fs20 = require_fs();
+    var fs21 = require_fs();
     var u = require_universalify().fromPromise;
     async function utimesMillis(path4, atime, mtime) {
-      const fd = await fs20.open(path4, "r+");
+      const fd = await fs21.open(path4, "r+");
       let closeErr = null;
       try {
-        await fs20.futimes(fd, atime, mtime);
+        await fs21.futimes(fd, atime, mtime);
       } finally {
         try {
-          await fs20.close(fd);
+          await fs21.close(fd);
         } catch (e) {
           closeErr = e;
         }
@@ -4062,9 +4062,9 @@ var require_utimes = __commonJS({
       }
     }
     function utimesMillisSync(path4, atime, mtime) {
-      const fd = fs20.openSync(path4, "r+");
-      fs20.futimesSync(fd, atime, mtime);
-      return fs20.closeSync(fd);
+      const fd = fs21.openSync(path4, "r+");
+      fs21.futimesSync(fd, atime, mtime);
+      return fs21.closeSync(fd);
     }
     module2.exports = {
       utimesMillis: u(utimesMillis),
@@ -4077,11 +4077,11 @@ var require_utimes = __commonJS({
 var require_stat = __commonJS({
   "node_modules/fs-extra/lib/util/stat.js"(exports2, module2) {
     "use strict";
-    var fs20 = require_fs();
+    var fs21 = require_fs();
     var path4 = require("path");
     var u = require_universalify().fromPromise;
     function getStats(src, dest, opts) {
-      const statFunc = opts.dereference ? (file) => fs20.stat(file, { bigint: true }) : (file) => fs20.lstat(file, { bigint: true });
+      const statFunc = opts.dereference ? (file) => fs21.stat(file, { bigint: true }) : (file) => fs21.lstat(file, { bigint: true });
       return Promise.all([
         statFunc(src),
         statFunc(dest).catch((err) => {
@@ -4092,7 +4092,7 @@ var require_stat = __commonJS({
     }
     function getStatsSync(src, dest, opts) {
       let destStat;
-      const statFunc = opts.dereference ? (file) => fs20.statSync(file, { bigint: true }) : (file) => fs20.lstatSync(file, { bigint: true });
+      const statFunc = opts.dereference ? (file) => fs21.statSync(file, { bigint: true }) : (file) => fs21.lstatSync(file, { bigint: true });
       const srcStat = statFunc(src);
       try {
         destStat = statFunc(dest);
@@ -4154,7 +4154,7 @@ var require_stat = __commonJS({
       if (destParent === srcParent || destParent === path4.parse(destParent).root) return;
       let destStat;
       try {
-        destStat = await fs20.stat(destParent, { bigint: true });
+        destStat = await fs21.stat(destParent, { bigint: true });
       } catch (err) {
         if (err.code === "ENOENT") return;
         throw err;
@@ -4170,7 +4170,7 @@ var require_stat = __commonJS({
       if (destParent === srcParent || destParent === path4.parse(destParent).root) return;
       let destStat;
       try {
-        destStat = fs20.statSync(destParent, { bigint: true });
+        destStat = fs21.statSync(destParent, { bigint: true });
       } catch (err) {
         if (err.code === "ENOENT") return;
         throw err;
@@ -4237,7 +4237,7 @@ var require_async = __commonJS({
 var require_copy = __commonJS({
   "node_modules/fs-extra/lib/copy/copy.js"(exports2, module2) {
     "use strict";
-    var fs20 = require_fs();
+    var fs21 = require_fs();
     var path4 = require("path");
     var { mkdirs } = require_mkdirs();
     var { pathExists } = require_path_exists();
@@ -4273,7 +4273,7 @@ var require_copy = __commonJS({
       return opts.filter(src, dest);
     }
     async function getStatsAndPerformCopy(destStat, src, dest, opts) {
-      const statFn = opts.dereference ? fs20.stat : fs20.lstat;
+      const statFn = opts.dereference ? fs21.stat : fs21.lstat;
       const srcStat = await statFn(src);
       if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts);
       if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts);
@@ -4285,7 +4285,7 @@ var require_copy = __commonJS({
     async function onFile(srcStat, destStat, src, dest, opts) {
       if (!destStat) return copyFile(srcStat, src, dest, opts);
       if (opts.overwrite) {
-        await fs20.unlink(dest);
+        await fs21.unlink(dest);
         return copyFile(srcStat, src, dest, opts);
       }
       if (opts.errorOnExist) {
@@ -4293,27 +4293,27 @@ var require_copy = __commonJS({
       }
     }
     async function copyFile(srcStat, src, dest, opts) {
-      await fs20.copyFile(src, dest);
+      await fs21.copyFile(src, dest);
       if (opts.preserveTimestamps) {
         if (fileIsNotWritable(srcStat.mode)) {
           await makeFileWritable(dest, srcStat.mode);
         }
-        const updatedSrcStat = await fs20.stat(src);
+        const updatedSrcStat = await fs21.stat(src);
         await utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
       }
-      return fs20.chmod(dest, srcStat.mode);
+      return fs21.chmod(dest, srcStat.mode);
     }
     function fileIsNotWritable(srcMode) {
       return (srcMode & 128) === 0;
     }
     function makeFileWritable(dest, srcMode) {
-      return fs20.chmod(dest, srcMode | 128);
+      return fs21.chmod(dest, srcMode | 128);
     }
     async function onDir(srcStat, destStat, src, dest, opts) {
       if (!destStat) {
-        await fs20.mkdir(dest);
+        await fs21.mkdir(dest);
       }
-      await asyncIteratorConcurrentProcess(await fs20.opendir(src), async (item) => {
+      await asyncIteratorConcurrentProcess(await fs21.opendir(src), async (item) => {
         const srcItem = path4.join(src, item.name);
         const destItem = path4.join(dest, item.name);
         const include = await runFilter(srcItem, destItem, opts);
@@ -4323,22 +4323,22 @@ var require_copy = __commonJS({
         }
       });
       if (!destStat) {
-        await fs20.chmod(dest, srcStat.mode);
+        await fs21.chmod(dest, srcStat.mode);
       }
     }
     async function onLink(destStat, src, dest, opts) {
-      let resolvedSrc = await fs20.readlink(src);
+      let resolvedSrc = await fs21.readlink(src);
       if (opts.dereference) {
         resolvedSrc = path4.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
-        return fs20.symlink(resolvedSrc, dest);
+        return fs21.symlink(resolvedSrc, dest);
       }
       let resolvedDest = null;
       try {
-        resolvedDest = await fs20.readlink(dest);
+        resolvedDest = await fs21.readlink(dest);
       } catch (e) {
-        if (e.code === "EINVAL" || e.code === "UNKNOWN") return fs20.symlink(resolvedSrc, dest);
+        if (e.code === "EINVAL" || e.code === "UNKNOWN") return fs21.symlink(resolvedSrc, dest);
         throw e;
       }
       if (opts.dereference) {
@@ -4352,8 +4352,8 @@ var require_copy = __commonJS({
           throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
         }
       }
-      await fs20.unlink(dest);
-      return fs20.symlink(resolvedSrc, dest);
+      await fs21.unlink(dest);
+      return fs21.symlink(resolvedSrc, dest);
     }
     module2.exports = copy;
   }
@@ -4363,7 +4363,7 @@ var require_copy = __commonJS({
 var require_copy_sync = __commonJS({
   "node_modules/fs-extra/lib/copy/copy-sync.js"(exports2, module2) {
     "use strict";
-    var fs20 = require_graceful_fs();
+    var fs21 = require_graceful_fs();
     var path4 = require("path");
     var mkdirsSync = require_mkdirs().mkdirsSync;
     var utimesMillisSync = require_utimes().utimesMillisSync;
@@ -4386,11 +4386,11 @@ var require_copy_sync = __commonJS({
       stat.checkParentPathsSync(src, srcStat, dest, "copy");
       if (opts.filter && !opts.filter(src, dest)) return;
       const destParent = path4.dirname(dest);
-      if (!fs20.existsSync(destParent)) mkdirsSync(destParent);
+      if (!fs21.existsSync(destParent)) mkdirsSync(destParent);
       return getStats(destStat, src, dest, opts);
     }
     function getStats(destStat, src, dest, opts) {
-      const statSync = opts.dereference ? fs20.statSync : fs20.lstatSync;
+      const statSync = opts.dereference ? fs21.statSync : fs21.lstatSync;
       const srcStat = statSync(src);
       if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts);
       else if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts);
@@ -4405,14 +4405,14 @@ var require_copy_sync = __commonJS({
     }
     function mayCopyFile(srcStat, src, dest, opts) {
       if (opts.overwrite) {
-        fs20.unlinkSync(dest);
+        fs21.unlinkSync(dest);
         return copyFile(srcStat, src, dest, opts);
       } else if (opts.errorOnExist) {
         throw new Error(`'${dest}' already exists`);
       }
     }
     function copyFile(srcStat, src, dest, opts) {
-      fs20.copyFileSync(src, dest);
+      fs21.copyFileSync(src, dest);
       if (opts.preserveTimestamps) handleTimestamps(srcStat.mode, src, dest);
       return setDestMode(dest, srcStat.mode);
     }
@@ -4427,10 +4427,10 @@ var require_copy_sync = __commonJS({
       return setDestMode(dest, srcMode | 128);
     }
     function setDestMode(dest, srcMode) {
-      return fs20.chmodSync(dest, srcMode);
+      return fs21.chmodSync(dest, srcMode);
     }
     function setDestTimestamps(src, dest) {
-      const updatedSrcStat = fs20.statSync(src);
+      const updatedSrcStat = fs21.statSync(src);
       return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
     }
     function onDir(srcStat, destStat, src, dest, opts) {
@@ -4438,12 +4438,12 @@ var require_copy_sync = __commonJS({
       return copyDir(src, dest, opts);
     }
     function mkDirAndCopy(srcMode, src, dest, opts) {
-      fs20.mkdirSync(dest);
+      fs21.mkdirSync(dest);
       copyDir(src, dest, opts);
       return setDestMode(dest, srcMode);
     }
     function copyDir(src, dest, opts) {
-      const dir = fs20.opendirSync(src);
+      const dir = fs21.opendirSync(src);
       try {
         let dirent;
         while ((dirent = dir.readSync()) !== null) {
@@ -4461,18 +4461,18 @@ var require_copy_sync = __commonJS({
       return getStats(destStat, srcItem, destItem, opts);
     }
     function onLink(destStat, src, dest, opts) {
-      let resolvedSrc = fs20.readlinkSync(src);
+      let resolvedSrc = fs21.readlinkSync(src);
       if (opts.dereference) {
         resolvedSrc = path4.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
-        return fs20.symlinkSync(resolvedSrc, dest);
+        return fs21.symlinkSync(resolvedSrc, dest);
       } else {
         let resolvedDest;
         try {
-          resolvedDest = fs20.readlinkSync(dest);
+          resolvedDest = fs21.readlinkSync(dest);
         } catch (err) {
-          if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs20.symlinkSync(resolvedSrc, dest);
+          if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs21.symlinkSync(resolvedSrc, dest);
           throw err;
         }
         if (opts.dereference) {
@@ -4490,8 +4490,8 @@ var require_copy_sync = __commonJS({
       }
     }
     function copyLink(resolvedSrc, dest) {
-      fs20.unlinkSync(dest);
-      return fs20.symlinkSync(resolvedSrc, dest);
+      fs21.unlinkSync(dest);
+      return fs21.symlinkSync(resolvedSrc, dest);
     }
     module2.exports = copySync;
   }
@@ -4513,13 +4513,13 @@ var require_copy2 = __commonJS({
 var require_remove = __commonJS({
   "node_modules/fs-extra/lib/remove/index.js"(exports2, module2) {
     "use strict";
-    var fs20 = require_graceful_fs();
+    var fs21 = require_graceful_fs();
     var u = require_universalify().fromCallback;
     function remove(path4, callback) {
-      fs20.rm(path4, { recursive: true, force: true }, callback);
+      fs21.rm(path4, { recursive: true, force: true }, callback);
     }
     function removeSync(path4) {
-      fs20.rmSync(path4, { recursive: true, force: true });
+      fs21.rmSync(path4, { recursive: true, force: true });
     }
     module2.exports = {
       remove: u(remove),
@@ -4533,14 +4533,14 @@ var require_empty = __commonJS({
   "node_modules/fs-extra/lib/empty/index.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs20 = require_fs();
+    var fs21 = require_fs();
     var path4 = require("path");
     var mkdir = require_mkdirs();
     var remove = require_remove();
     var emptyDir = u(async function emptyDir2(dir) {
       let items;
       try {
-        items = await fs20.readdir(dir);
+        items = await fs21.readdir(dir);
       } catch {
         return mkdir.mkdirs(dir);
       }
@@ -4549,7 +4549,7 @@ var require_empty = __commonJS({
     function emptyDirSync(dir) {
       let items;
       try {
-        items = fs20.readdirSync(dir);
+        items = fs21.readdirSync(dir);
       } catch {
         return mkdir.mkdirsSync(dir);
       }
@@ -4573,51 +4573,51 @@ var require_file = __commonJS({
     "use strict";
     var u = require_universalify().fromPromise;
     var path4 = require("path");
-    var fs20 = require_fs();
+    var fs21 = require_fs();
     var mkdir = require_mkdirs();
     async function createFile(file) {
       let stats;
       try {
-        stats = await fs20.stat(file);
+        stats = await fs21.stat(file);
       } catch {
       }
       if (stats && stats.isFile()) return;
       const dir = path4.dirname(file);
       let dirStats = null;
       try {
-        dirStats = await fs20.stat(dir);
+        dirStats = await fs21.stat(dir);
       } catch (err) {
         if (err.code === "ENOENT") {
           await mkdir.mkdirs(dir);
-          await fs20.writeFile(file, "");
+          await fs21.writeFile(file, "");
           return;
         } else {
           throw err;
         }
       }
       if (dirStats.isDirectory()) {
-        await fs20.writeFile(file, "");
+        await fs21.writeFile(file, "");
       } else {
-        await fs20.readdir(dir);
+        await fs21.readdir(dir);
       }
     }
     function createFileSync(file) {
       let stats;
       try {
-        stats = fs20.statSync(file);
+        stats = fs21.statSync(file);
       } catch {
       }
       if (stats && stats.isFile()) return;
       const dir = path4.dirname(file);
       try {
-        if (!fs20.statSync(dir).isDirectory()) {
-          fs20.readdirSync(dir);
+        if (!fs21.statSync(dir).isDirectory()) {
+          fs21.readdirSync(dir);
         }
       } catch (err) {
         if (err && err.code === "ENOENT") mkdir.mkdirsSync(dir);
         else throw err;
       }
-      fs20.writeFileSync(file, "");
+      fs21.writeFileSync(file, "");
     }
     module2.exports = {
       createFile: u(createFile),
@@ -4632,19 +4632,19 @@ var require_link = __commonJS({
     "use strict";
     var u = require_universalify().fromPromise;
     var path4 = require("path");
-    var fs20 = require_fs();
+    var fs21 = require_fs();
     var mkdir = require_mkdirs();
     var { pathExists } = require_path_exists();
     var { areIdentical } = require_stat();
     async function createLink(srcpath, dstpath) {
       let dstStat;
       try {
-        dstStat = await fs20.lstat(dstpath);
+        dstStat = await fs21.lstat(dstpath);
       } catch {
       }
       let srcStat;
       try {
-        srcStat = await fs20.lstat(srcpath);
+        srcStat = await fs21.lstat(srcpath);
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureLink");
         throw err;
@@ -4655,26 +4655,26 @@ var require_link = __commonJS({
       if (!dirExists) {
         await mkdir.mkdirs(dir);
       }
-      await fs20.link(srcpath, dstpath);
+      await fs21.link(srcpath, dstpath);
     }
     function createLinkSync(srcpath, dstpath) {
       let dstStat;
       try {
-        dstStat = fs20.lstatSync(dstpath);
+        dstStat = fs21.lstatSync(dstpath);
       } catch {
       }
       try {
-        const srcStat = fs20.lstatSync(srcpath);
+        const srcStat = fs21.lstatSync(srcpath);
         if (dstStat && areIdentical(srcStat, dstStat)) return;
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureLink");
         throw err;
       }
       const dir = path4.dirname(dstpath);
-      const dirExists = fs20.existsSync(dir);
-      if (dirExists) return fs20.linkSync(srcpath, dstpath);
+      const dirExists = fs21.existsSync(dir);
+      if (dirExists) return fs21.linkSync(srcpath, dstpath);
       mkdir.mkdirsSync(dir);
-      return fs20.linkSync(srcpath, dstpath);
+      return fs21.linkSync(srcpath, dstpath);
     }
     module2.exports = {
       createLink: u(createLink),
@@ -4688,13 +4688,13 @@ var require_symlink_paths = __commonJS({
   "node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports2, module2) {
     "use strict";
     var path4 = require("path");
-    var fs20 = require_fs();
+    var fs21 = require_fs();
     var { pathExists } = require_path_exists();
     var u = require_universalify().fromPromise;
     async function symlinkPaths(srcpath, dstpath) {
       if (path4.isAbsolute(srcpath)) {
         try {
-          await fs20.lstat(srcpath);
+          await fs21.lstat(srcpath);
         } catch (err) {
           err.message = err.message.replace("lstat", "ensureSymlink");
           throw err;
@@ -4714,7 +4714,7 @@ var require_symlink_paths = __commonJS({
         };
       }
       try {
-        await fs20.lstat(srcpath);
+        await fs21.lstat(srcpath);
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureSymlink");
         throw err;
@@ -4726,7 +4726,7 @@ var require_symlink_paths = __commonJS({
     }
     function symlinkPathsSync(srcpath, dstpath) {
       if (path4.isAbsolute(srcpath)) {
-        const exists2 = fs20.existsSync(srcpath);
+        const exists2 = fs21.existsSync(srcpath);
         if (!exists2) throw new Error("absolute srcpath does not exist");
         return {
           toCwd: srcpath,
@@ -4735,14 +4735,14 @@ var require_symlink_paths = __commonJS({
       }
       const dstdir = path4.dirname(dstpath);
       const relativeToDst = path4.join(dstdir, srcpath);
-      const exists = fs20.existsSync(relativeToDst);
+      const exists = fs21.existsSync(relativeToDst);
       if (exists) {
         return {
           toCwd: relativeToDst,
           toDst: srcpath
         };
       }
-      const srcExists = fs20.existsSync(srcpath);
+      const srcExists = fs21.existsSync(srcpath);
       if (!srcExists) throw new Error("relative srcpath does not exist");
       return {
         toCwd: srcpath,
@@ -4760,13 +4760,13 @@ var require_symlink_paths = __commonJS({
 var require_symlink_type = __commonJS({
   "node_modules/fs-extra/lib/ensure/symlink-type.js"(exports2, module2) {
     "use strict";
-    var fs20 = require_fs();
+    var fs21 = require_fs();
     var u = require_universalify().fromPromise;
     async function symlinkType(srcpath, type) {
       if (type) return type;
       let stats;
       try {
-        stats = await fs20.lstat(srcpath);
+        stats = await fs21.lstat(srcpath);
       } catch {
         return "file";
       }
@@ -4776,7 +4776,7 @@ var require_symlink_type = __commonJS({
       if (type) return type;
       let stats;
       try {
-        stats = fs20.lstatSync(srcpath);
+        stats = fs21.lstatSync(srcpath);
       } catch {
         return "file";
       }
@@ -4795,7 +4795,7 @@ var require_symlink = __commonJS({
     "use strict";
     var u = require_universalify().fromPromise;
     var path4 = require("path");
-    var fs20 = require_fs();
+    var fs21 = require_fs();
     var { mkdirs, mkdirsSync } = require_mkdirs();
     var { symlinkPaths, symlinkPathsSync } = require_symlink_paths();
     var { symlinkType, symlinkTypeSync } = require_symlink_type();
@@ -4804,13 +4804,13 @@ var require_symlink = __commonJS({
     async function createSymlink(srcpath, dstpath, type) {
       let stats;
       try {
-        stats = await fs20.lstat(dstpath);
+        stats = await fs21.lstat(dstpath);
       } catch {
       }
       if (stats && stats.isSymbolicLink()) {
         const [srcStat, dstStat] = await Promise.all([
-          fs20.stat(srcpath),
-          fs20.stat(dstpath)
+          fs21.stat(srcpath),
+          fs21.stat(dstpath)
         ]);
         if (areIdentical(srcStat, dstStat)) return;
       }
@@ -4821,27 +4821,27 @@ var require_symlink = __commonJS({
       if (!await pathExists(dir)) {
         await mkdirs(dir);
       }
-      return fs20.symlink(srcpath, dstpath, toType);
+      return fs21.symlink(srcpath, dstpath, toType);
     }
     function createSymlinkSync(srcpath, dstpath, type) {
       let stats;
       try {
-        stats = fs20.lstatSync(dstpath);
+        stats = fs21.lstatSync(dstpath);
       } catch {
       }
       if (stats && stats.isSymbolicLink()) {
-        const srcStat = fs20.statSync(srcpath);
-        const dstStat = fs20.statSync(dstpath);
+        const srcStat = fs21.statSync(srcpath);
+        const dstStat = fs21.statSync(dstpath);
         if (areIdentical(srcStat, dstStat)) return;
       }
       const relative2 = symlinkPathsSync(srcpath, dstpath);
       srcpath = relative2.toDst;
       type = symlinkTypeSync(relative2.toCwd, type);
       const dir = path4.dirname(dstpath);
-      const exists = fs20.existsSync(dir);
-      if (exists) return fs20.symlinkSync(srcpath, dstpath, type);
+      const exists = fs21.existsSync(dir);
+      if (exists) return fs21.symlinkSync(srcpath, dstpath, type);
       mkdirsSync(dir);
-      return fs20.symlinkSync(srcpath, dstpath, type);
+      return fs21.symlinkSync(srcpath, dstpath, type);
     }
     module2.exports = {
       createSymlink: u(createSymlink),
@@ -4910,9 +4910,9 @@ var require_jsonfile = __commonJS({
       if (typeof options === "string") {
         options = { encoding: options };
       }
-      const fs20 = options.fs || _fs;
+      const fs21 = options.fs || _fs;
       const shouldThrow = "throws" in options ? options.throws : true;
-      let data = await universalify.fromCallback(fs20.readFile)(file, options);
+      let data = await universalify.fromCallback(fs21.readFile)(file, options);
       data = stripBom(data);
       let obj;
       try {
@@ -4932,10 +4932,10 @@ var require_jsonfile = __commonJS({
       if (typeof options === "string") {
         options = { encoding: options };
       }
-      const fs20 = options.fs || _fs;
+      const fs21 = options.fs || _fs;
       const shouldThrow = "throws" in options ? options.throws : true;
       try {
-        let content = fs20.readFileSync(file, options);
+        let content = fs21.readFileSync(file, options);
         content = stripBom(content);
         return JSON.parse(content, options.reviver);
       } catch (err) {
@@ -4948,15 +4948,15 @@ var require_jsonfile = __commonJS({
       }
     }
     async function _writeFile(file, obj, options = {}) {
-      const fs20 = options.fs || _fs;
+      const fs21 = options.fs || _fs;
       const str = stringify2(obj, options);
-      await universalify.fromCallback(fs20.writeFile)(file, str, options);
+      await universalify.fromCallback(fs21.writeFile)(file, str, options);
     }
     var writeFile = universalify.fromPromise(_writeFile);
     function writeFileSync3(file, obj, options = {}) {
-      const fs20 = options.fs || _fs;
+      const fs21 = options.fs || _fs;
       const str = stringify2(obj, options);
-      return fs20.writeFileSync(file, str, options);
+      return fs21.writeFileSync(file, str, options);
     }
     module2.exports = {
       readFile,
@@ -4987,7 +4987,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 fs20 = require_fs();
+    var fs21 = require_fs();
     var path4 = require("path");
     var mkdir = require_mkdirs();
     var pathExists = require_path_exists().pathExists;
@@ -4996,14 +4996,14 @@ var require_output_file = __commonJS({
       if (!await pathExists(dir)) {
         await mkdir.mkdirs(dir);
       }
-      return fs20.writeFile(file, data, encoding);
+      return fs21.writeFile(file, data, encoding);
     }
     function outputFileSync(file, ...args) {
       const dir = path4.dirname(file);
-      if (!fs20.existsSync(dir)) {
+      if (!fs21.existsSync(dir)) {
         mkdir.mkdirsSync(dir);
       }
-      fs20.writeFileSync(file, ...args);
+      fs21.writeFileSync(file, ...args);
     }
     module2.exports = {
       outputFile: u(outputFile),
@@ -5062,7 +5062,7 @@ var require_json = __commonJS({
 var require_move = __commonJS({
   "node_modules/fs-extra/lib/move/move.js"(exports2, module2) {
     "use strict";
-    var fs20 = require_fs();
+    var fs21 = require_fs();
     var path4 = require("path");
     var { copy } = require_copy2();
     var { remove } = require_remove();
@@ -5089,7 +5089,7 @@ var require_move = __commonJS({
         }
       }
       try {
-        await fs20.rename(src, dest);
+        await fs21.rename(src, dest);
       } catch (err) {
         if (err.code !== "EXDEV") {
           throw err;
@@ -5114,7 +5114,7 @@ var require_move = __commonJS({
 var require_move_sync = __commonJS({
   "node_modules/fs-extra/lib/move/move-sync.js"(exports2, module2) {
     "use strict";
-    var fs20 = require_graceful_fs();
+    var fs21 = require_graceful_fs();
     var path4 = require("path");
     var copySync = require_copy2().copySync;
     var removeSync = require_remove().removeSync;
@@ -5139,12 +5139,12 @@ var require_move_sync = __commonJS({
         removeSync(dest);
         return rename(src, dest, overwrite);
       }
-      if (fs20.existsSync(dest)) throw new Error("dest already exists.");
+      if (fs21.existsSync(dest)) throw new Error("dest already exists.");
       return rename(src, dest, overwrite);
     }
     function rename(src, dest, overwrite) {
       try {
-        fs20.renameSync(src, dest);
+        fs21.renameSync(src, dest);
       } catch (err) {
         if (err.code !== "EXDEV") throw err;
         return moveAcrossDevice(src, dest, overwrite);
@@ -7062,14 +7062,14 @@ var require_run_async = __commonJS({
       return function() {
         var args = arguments;
         var originalThis = this;
-        var promise = new Promise(function(resolve, reject) {
+        var promise = new Promise(function(resolve2, reject) {
           var resolved = false;
           const wrappedResolve = function(value) {
             if (resolved) {
               console.warn("Run-async promise already resolved.");
             }
             resolved = true;
-            resolve(value);
+            resolve2(value);
           };
           var rejected = false;
           const wrappedReject = function(value) {
@@ -7860,7 +7860,7 @@ var require_Observable = __commonJS({
       Observable2.prototype.forEach = function(next, promiseCtor) {
         var _this = this;
         promiseCtor = getPromiseCtor(promiseCtor);
-        return new promiseCtor(function(resolve, reject) {
+        return new promiseCtor(function(resolve2, reject) {
           var subscriber = new Subscriber_1.SafeSubscriber({
             next: function(value) {
               try {
@@ -7871,7 +7871,7 @@ var require_Observable = __commonJS({
               }
             },
             error: reject,
-            complete: resolve
+            complete: resolve2
           });
           _this.subscribe(subscriber);
         });
@@ -7893,14 +7893,14 @@ var require_Observable = __commonJS({
       Observable2.prototype.toPromise = function(promiseCtor) {
         var _this = this;
         promiseCtor = getPromiseCtor(promiseCtor);
-        return new promiseCtor(function(resolve, reject) {
+        return new promiseCtor(function(resolve2, reject) {
           var value;
           _this.subscribe(function(x) {
             return value = x;
           }, function(err) {
             return reject(err);
           }, function() {
-            return resolve(value);
+            return resolve2(value);
           });
         });
       };
@@ -9996,11 +9996,11 @@ var require_innerFrom = __commonJS({
     "use strict";
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve) {
-          resolve(value);
+        return value instanceof P ? value : new P(function(resolve2) {
+          resolve2(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve, reject) {
+      return new (P || (P = Promise))(function(resolve2, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -10016,7 +10016,7 @@ var require_innerFrom = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve2(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -10098,14 +10098,14 @@ var require_innerFrom = __commonJS({
       }, i);
       function verb(n) {
         i[n] = o[n] && function(v) {
-          return new Promise(function(resolve, reject) {
-            v = o[n](v), settle(resolve, reject, v.done, v.value);
+          return new Promise(function(resolve2, reject) {
+            v = o[n](v), settle(resolve2, reject, v.done, v.value);
           });
         };
       }
-      function settle(resolve, reject, d, v) {
+      function settle(resolve2, reject, d, v) {
         Promise.resolve(v).then(function(v2) {
-          resolve({ value: v2, done: d });
+          resolve2({ value: v2, done: d });
         }, reject);
       }
     };
@@ -10724,7 +10724,7 @@ var require_lastValueFrom = __commonJS({
     var EmptyError_1 = require_EmptyError();
     function lastValueFrom(source, config) {
       var hasConfig = typeof config === "object";
-      return new Promise(function(resolve, reject) {
+      return new Promise(function(resolve2, reject) {
         var _hasValue = false;
         var _value;
         source.subscribe({
@@ -10735,9 +10735,9 @@ var require_lastValueFrom = __commonJS({
           error: reject,
           complete: function() {
             if (_hasValue) {
-              resolve(_value);
+              resolve2(_value);
             } else if (hasConfig) {
-              resolve(config.defaultValue);
+              resolve2(config.defaultValue);
             } else {
               reject(new EmptyError_1.EmptyError());
             }
@@ -10759,16 +10759,16 @@ var require_firstValueFrom = __commonJS({
     var Subscriber_1 = require_Subscriber();
     function firstValueFrom(source, config) {
       var hasConfig = typeof config === "object";
-      return new Promise(function(resolve, reject) {
+      return new Promise(function(resolve2, reject) {
         var subscriber = new Subscriber_1.SafeSubscriber({
           next: function(value) {
-            resolve(value);
+            resolve2(value);
             subscriber.unsubscribe();
           },
           error: reject,
           complete: function() {
             if (hasConfig) {
-              resolve(config.defaultValue);
+              resolve2(config.defaultValue);
             } else {
               reject(new EmptyError_1.EmptyError());
             }
@@ -19200,7 +19200,7 @@ var require_buffer_list = __commonJS({
         }
       }, {
         key: "join",
-        value: function join17(s) {
+        value: function join18(s) {
           if (this.length === 0) return "";
           var p = this.head;
           var ret = "" + p.data;
@@ -20581,14 +20581,14 @@ var require_async_iterator = __commonJS({
       };
     }
     function readAndResolve(iter) {
-      var resolve = iter[kLastResolve];
-      if (resolve !== null) {
+      var resolve2 = iter[kLastResolve];
+      if (resolve2 !== null) {
         var data = iter[kStream].read();
         if (data !== null) {
           iter[kLastPromise] = null;
           iter[kLastResolve] = null;
           iter[kLastReject] = null;
-          resolve(createIterResult(data, false));
+          resolve2(createIterResult(data, false));
         }
       }
     }
@@ -20596,13 +20596,13 @@ var require_async_iterator = __commonJS({
       process.nextTick(readAndResolve, iter);
     }
     function wrapForNext(lastPromise, iter) {
-      return function(resolve, reject) {
+      return function(resolve2, reject) {
         lastPromise.then(function() {
           if (iter[kEnded]) {
-            resolve(createIterResult(void 0, true));
+            resolve2(createIterResult(void 0, true));
             return;
           }
-          iter[kHandlePromise](resolve, reject);
+          iter[kHandlePromise](resolve2, reject);
         }, reject);
       };
     }
@@ -20622,12 +20622,12 @@ var require_async_iterator = __commonJS({
           return Promise.resolve(createIterResult(void 0, true));
         }
         if (this[kStream].destroyed) {
-          return new Promise(function(resolve, reject) {
+          return new Promise(function(resolve2, reject) {
             process.nextTick(function() {
               if (_this[kError]) {
                 reject(_this[kError]);
               } else {
-                resolve(createIterResult(void 0, true));
+                resolve2(createIterResult(void 0, true));
               }
             });
           });
@@ -20650,13 +20650,13 @@ var require_async_iterator = __commonJS({
       return this;
     }), _defineProperty(_Object$setPrototypeO, "return", function _return() {
       var _this2 = this;
-      return new Promise(function(resolve, reject) {
+      return new Promise(function(resolve2, reject) {
         _this2[kStream].destroy(null, function(err) {
           if (err) {
             reject(err);
             return;
           }
-          resolve(createIterResult(void 0, true));
+          resolve2(createIterResult(void 0, true));
         });
       });
     }), _Object$setPrototypeO), AsyncIteratorPrototype);
@@ -20678,15 +20678,15 @@ var require_async_iterator = __commonJS({
         value: stream2._readableState.endEmitted,
         writable: true
       }), _defineProperty(_Object$create, kHandlePromise, {
-        value: function value(resolve, reject) {
+        value: function value(resolve2, reject) {
           var data = iterator[kStream].read();
           if (data) {
             iterator[kLastPromise] = null;
             iterator[kLastResolve] = null;
             iterator[kLastReject] = null;
-            resolve(createIterResult(data, false));
+            resolve2(createIterResult(data, false));
           } else {
-            iterator[kLastResolve] = resolve;
+            iterator[kLastResolve] = resolve2;
             iterator[kLastReject] = reject;
           }
         },
@@ -20705,12 +20705,12 @@ var require_async_iterator = __commonJS({
           iterator[kError] = err;
           return;
         }
-        var resolve = iterator[kLastResolve];
-        if (resolve !== null) {
+        var resolve2 = iterator[kLastResolve];
+        if (resolve2 !== null) {
           iterator[kLastPromise] = null;
           iterator[kLastResolve] = null;
           iterator[kLastReject] = null;
-          resolve(createIterResult(void 0, true));
+          resolve2(createIterResult(void 0, true));
         }
         iterator[kEnded] = true;
       });
@@ -20725,7 +20725,7 @@ var require_async_iterator = __commonJS({
 var require_from2 = __commonJS({
   "node_modules/readable-stream/lib/internal/streams/from.js"(exports2, module2) {
     "use strict";
-    function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    function asyncGeneratorStep(gen, resolve2, reject, _next, _throw, key, arg) {
       try {
         var info = gen[key](arg);
         var value = info.value;
@@ -20734,7 +20734,7 @@ var require_from2 = __commonJS({
         return;
       }
       if (info.done) {
-        resolve(value);
+        resolve2(value);
       } else {
         Promise.resolve(value).then(_next, _throw);
       }
@@ -20742,13 +20742,13 @@ var require_from2 = __commonJS({
     function _asyncToGenerator(fn) {
       return function() {
         var self2 = this, args = arguments;
-        return new Promise(function(resolve, reject) {
+        return new Promise(function(resolve2, reject) {
           var gen = fn.apply(self2, args);
           function _next(value) {
-            asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            asyncGeneratorStep(gen, resolve2, reject, _next, _throw, "next", value);
           }
           function _throw(err) {
-            asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            asyncGeneratorStep(gen, resolve2, reject, _next, _throw, "throw", err);
           }
           _next(void 0);
         });
@@ -28075,26 +28075,26 @@ var require_lib2 = __commonJS({
       return matches;
     };
     exports2.analyse = analyse;
-    var detectFile = (filepath, opts = {}) => new Promise((resolve, reject) => {
+    var detectFile = (filepath, opts = {}) => new Promise((resolve2, reject) => {
       let fd;
-      const fs20 = (0, node_1.default)();
+      const fs21 = (0, node_1.default)();
       const handler = (err, buffer) => {
         if (fd) {
-          fs20.closeSync(fd);
+          fs21.closeSync(fd);
         }
         if (err) {
           reject(err);
         } else if (buffer) {
-          resolve((0, exports2.detect)(buffer));
+          resolve2((0, exports2.detect)(buffer));
         } else {
           reject(new Error("No error and no buffer received"));
         }
       };
       const sampleSize = (opts === null || opts === void 0 ? void 0 : opts.sampleSize) || 0;
       if (sampleSize > 0) {
-        fd = fs20.openSync(filepath, "r");
+        fd = fs21.openSync(filepath, "r");
         let sample = Buffer.allocUnsafe(sampleSize);
-        fs20.read(fd, sample, 0, sampleSize, opts.offset, (err, bytesRead) => {
+        fs21.read(fd, sample, 0, sampleSize, opts.offset, (err, bytesRead) => {
           if (err) {
             handler(err, null);
           } else {
@@ -28106,22 +28106,22 @@ var require_lib2 = __commonJS({
         });
         return;
       }
-      fs20.readFile(filepath, handler);
+      fs21.readFile(filepath, handler);
     });
     exports2.detectFile = detectFile;
     var detectFileSync = (filepath, opts = {}) => {
-      const fs20 = (0, node_1.default)();
+      const fs21 = (0, node_1.default)();
       if (opts && opts.sampleSize) {
-        const fd = fs20.openSync(filepath, "r");
+        const fd = fs21.openSync(filepath, "r");
         let sample = Buffer.allocUnsafe(opts.sampleSize);
-        const bytesRead = fs20.readSync(fd, sample, 0, opts.sampleSize, opts.offset);
+        const bytesRead = fs21.readSync(fd, sample, 0, opts.sampleSize, opts.offset);
         if (bytesRead < opts.sampleSize) {
           sample = sample.subarray(0, bytesRead);
         }
-        fs20.closeSync(fd);
+        fs21.closeSync(fd);
         return (0, exports2.detect)(sample);
       }
-      return (0, exports2.detect)(fs20.readFileSync(filepath));
+      return (0, exports2.detect)(fs21.readFileSync(filepath));
     };
     exports2.detectFileSync = detectFileSync;
     exports2.default = {
@@ -38678,15 +38678,15 @@ var require_utils5 = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     var PromiseInspection_1 = require_PromiseInspection();
     function defer3() {
-      let resolve = null;
+      let resolve2 = null;
       let reject = null;
       const promise = new Promise((resolver, rejecter) => {
-        resolve = resolver;
+        resolve2 = resolver;
         reject = rejecter;
       });
       return {
         promise,
-        resolve,
+        resolve: resolve2,
         reject
       };
     }
@@ -38711,7 +38711,7 @@ var require_utils5 = __commonJS({
     }
     exports2.checkRequiredTime = checkRequiredTime;
     function delay(millis) {
-      return new Promise((resolve) => setTimeout(resolve, millis));
+      return new Promise((resolve2) => setTimeout(resolve2, millis));
     }
     exports2.delay = delay;
     function reflect(promise) {
@@ -38771,11 +38771,11 @@ var require_PendingOperation = __commonJS({
     };
     exports2.PendingOperation = PendingOperation;
     function timeout(promise, time) {
-      return new Promise((resolve, reject) => {
+      return new Promise((resolve2, reject) => {
         const timeoutHandle = setTimeout(() => reject(new TimeoutError_1.TimeoutError()), time);
         promise.then((result) => {
           clearTimeout(timeoutHandle);
-          resolve(result);
+          resolve2(result);
         }).catch((err) => {
           clearTimeout(timeoutHandle);
           reject(err);
@@ -38983,15 +38983,15 @@ var require_Pool = __commonJS({
         this._stopReaping();
         this.destroyed = true;
         return utils_1.reflect(Promise.all(this.pendingCreates.map((create) => utils_1.reflect(create.promise))).then(() => {
-          return new Promise((resolve, reject) => {
+          return new Promise((resolve2, reject) => {
             if (this.numPendingValidations() === 0) {
-              resolve();
+              resolve2();
               return;
             }
             const interval = setInterval(() => {
               if (this.numPendingValidations() === 0) {
                 timers_1.clearInterval(interval);
-                resolve();
+                resolve2();
               }
             }, 100);
           });
@@ -39215,17 +39215,17 @@ var require_Pool = __commonJS({
       }
     }
     function callbackOrPromise(func) {
-      return new Promise((resolve, reject) => {
+      return new Promise((resolve2, reject) => {
         const callback = (err, resource) => {
           if (err) {
             reject(err);
           } else {
-            resolve(resource);
+            resolve2(resource);
           }
         };
         utils_1.tryPromise(() => func(callback)).then((res) => {
           if (res) {
-            resolve(res);
+            resolve2(res);
           }
         }).catch((err) => {
           reject(err);
@@ -40484,10 +40484,10 @@ var require_connection_pool = __commonJS({
           this._connect(callback);
           return this;
         }
-        return new shared.Promise((resolve, reject) => {
+        return new shared.Promise((resolve2, reject) => {
           return this._connect((err) => {
             if (err) return reject(err);
-            resolve(this);
+            resolve2(this);
           });
         });
       }
@@ -40568,10 +40568,10 @@ var require_connection_pool = __commonJS({
           this._close(callback);
           return this;
         }
-        return new shared.Promise((resolve, reject) => {
+        return new shared.Promise((resolve2, reject) => {
           this._close((err) => {
             if (err) return reject(err);
-            resolve(this);
+            resolve2(this);
           });
         });
       }
@@ -40732,8 +40732,8 @@ var require_global_connection = __commonJS({
         setImmediate(callback);
         return null;
       }
-      return new shared.Promise((resolve) => {
-        resolve(globalConnection);
+      return new shared.Promise((resolve2) => {
+        resolve2(globalConnection);
       });
     }
     function on(event, handler) {
@@ -40944,10 +40944,10 @@ var require_prepared_statement = __commonJS({
           this._prepare(statement, callback);
           return this;
         }
-        return new shared.Promise((resolve, reject) => {
+        return new shared.Promise((resolve2, reject) => {
           this._prepare(statement, (err) => {
             if (err) return reject(err);
-            resolve(this);
+            resolve2(this);
           });
         });
       }
@@ -41010,10 +41010,10 @@ var require_prepared_statement = __commonJS({
         if (this.stream || typeof callback === "function") {
           return this._execute(values, callback);
         }
-        return new shared.Promise((resolve, reject) => {
+        return new shared.Promise((resolve2, reject) => {
           this._execute(values, (err, recordset) => {
             if (err) return reject(err);
-            resolve(recordset);
+            resolve2(recordset);
           });
         });
       }
@@ -41059,10 +41059,10 @@ var require_prepared_statement = __commonJS({
           this._unprepare(callback);
           return this;
         }
-        return new shared.Promise((resolve, reject) => {
+        return new shared.Promise((resolve2, reject) => {
           this._unprepare((err) => {
             if (err) return reject(err);
-            resolve();
+            resolve2();
           });
         });
       }
@@ -41306,7 +41306,7 @@ var require_request = __commonJS({
           const strings = values.shift();
           batch = this._template(strings, values);
         }
-        return new shared.Promise((resolve, reject) => {
+        return new shared.Promise((resolve2, reject) => {
           this._batch(batch, (err, recordsets, output, rowsAffected) => {
             if (this.stream) {
               if (err) this.emit("error", err);
@@ -41317,7 +41317,7 @@ var require_request = __commonJS({
               });
             }
             if (err) return reject(err);
-            resolve({
+            resolve2({
               recordsets,
               recordset: recordsets && recordsets[0],
               output,
@@ -41373,10 +41373,10 @@ var require_request = __commonJS({
           });
           return this;
         }
-        return new shared.Promise((resolve, reject) => {
+        return new shared.Promise((resolve2, reject) => {
           this._bulk(table, options, (err, rowsAffected) => {
             if (err) return reject(err);
-            resolve({
+            resolve2({
               rowsAffected
             });
           });
@@ -41477,7 +41477,7 @@ var require_request = __commonJS({
           const strings = values.shift();
           command = this._template(strings, values);
         }
-        return new shared.Promise((resolve, reject) => {
+        return new shared.Promise((resolve2, reject) => {
           this._query(command, (err, recordsets, output, rowsAffected, columns) => {
             if (this.stream) {
               if (err) this.emit("error", err);
@@ -41495,7 +41495,7 @@ var require_request = __commonJS({
               rowsAffected
             };
             if (this.arrayRowMode) result.columns = columns;
-            resolve(result);
+            resolve2(result);
           });
         });
       }
@@ -41549,7 +41549,7 @@ var require_request = __commonJS({
           });
           return this;
         }
-        return new shared.Promise((resolve, reject) => {
+        return new shared.Promise((resolve2, reject) => {
           this._execute(command, (err, recordsets, output, returnValue, rowsAffected, columns) => {
             if (this.stream) {
               if (err) this.emit("error", err);
@@ -41569,7 +41569,7 @@ var require_request = __commonJS({
               returnValue
             };
             if (this.arrayRowMode) result.columns = columns;
-            resolve(result);
+            resolve2(result);
           });
         });
       }
@@ -41733,11 +41733,11 @@ var require_transaction = __commonJS({
           });
           return this;
         }
-        return new shared.Promise((resolve, reject) => {
+        return new shared.Promise((resolve2, reject) => {
           this._begin(isolationLevel, (err) => {
             if (err) return reject(err);
             this.emit("begin");
-            resolve(this);
+            resolve2(this);
           });
         });
       }
@@ -41780,11 +41780,11 @@ var require_transaction = __commonJS({
           });
           return this;
         }
-        return new shared.Promise((resolve, reject) => {
+        return new shared.Promise((resolve2, reject) => {
           this._commit((err) => {
             if (err) return reject(err);
             this.emit("commit");
-            resolve();
+            resolve2();
           });
         });
       }
@@ -41829,11 +41829,11 @@ var require_transaction = __commonJS({
           });
           return this;
         }
-        return new shared.Promise((resolve, reject) => {
+        return new shared.Promise((resolve2, reject) => {
           return this._rollback((err) => {
             if (err) return reject(err);
             this.emit("rollback", this._aborted);
-            resolve();
+            resolve2();
           });
         });
       }
@@ -43074,11 +43074,11 @@ function __metadata(metadataKey, metadataValue) {
 }
 function __awaiter(thisArg, _arguments, P, generator) {
   function adopt(value) {
-    return value instanceof P ? value : new P(function(resolve) {
-      resolve(value);
+    return value instanceof P ? value : new P(function(resolve2) {
+      resolve2(value);
     });
   }
-  return new (P || (P = Promise))(function(resolve, reject) {
+  return new (P || (P = Promise))(function(resolve2, reject) {
     function fulfilled(value) {
       try {
         step(generator.next(value));
@@ -43094,7 +43094,7 @@ function __awaiter(thisArg, _arguments, P, generator) {
       }
     }
     function step(result) {
-      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+      result.done ? resolve2(result.value) : adopt(result.value).then(fulfilled, rejected);
     }
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
@@ -43285,14 +43285,14 @@ function __asyncValues(o) {
   }, i);
   function verb(n) {
     i[n] = o[n] && function(v) {
-      return new Promise(function(resolve, reject) {
-        v = o[n](v), settle(resolve, reject, v.done, v.value);
+      return new Promise(function(resolve2, reject) {
+        v = o[n](v), settle(resolve2, reject, v.done, v.value);
       });
     };
   }
-  function settle(resolve, reject, d, v) {
+  function settle(resolve2, reject, d, v) {
     Promise.resolve(v).then(function(v2) {
-      resolve({ value: v2, done: d });
+      resolve2({ value: v2, done: d });
     }, reject);
   }
 }
@@ -46760,7 +46760,7 @@ var require_index_node_C6O_wJLi = __commonJS({
       return cachedAtSec > nowSeconds();
     }
     function delay(t, value) {
-      return new Promise((resolve) => setTimeout(() => resolve(value), t));
+      return new Promise((resolve2) => setTimeout(() => resolve2(value), t));
     }
     var TimeUtils = /* @__PURE__ */ Object.freeze({
       __proto__: null,
@@ -52395,7 +52395,7 @@ var require_msal_node = __commonJS({
     var crypto5 = require("crypto");
     var msalCommon = require_lib6();
     var jwt2 = require_jsonwebtoken();
-    var fs20 = require("fs");
+    var fs21 = require("fs");
     var path4 = require("path");
     var Serializer = class {
       /**
@@ -56148,7 +56148,7 @@ var require_msal_node = __commonJS({
       return cachedAtSec > nowSeconds();
     }
     function delay(t, value) {
-      return new Promise((resolve) => setTimeout(() => resolve(value), t));
+      return new Promise((resolve2) => setTimeout(() => resolve2(value), t));
     }
     function createIdTokenEntity(homeAccountId, environment, idToken, clientId, tenantId) {
       const idTokenEntity = {
@@ -58842,7 +58842,7 @@ ${body}`;
 Host: ${destinationUrl.host}\r
 Connection: close\r
 ` + postRequestStringContent + "\r\n";
-          return new Promise((resolve, reject) => {
+          return new Promise((resolve2, reject) => {
             const request = http.request(tunnelRequestOptions);
             if (timeout) {
               request.on("timeout", () => {
@@ -58891,7 +58891,7 @@ Connection: close\r
                 if (this.shouldDestroyRequest(httpStatusCode, networkResponse)) {
                   request.destroy();
                 }
-                resolve(networkResponse);
+                resolve2(networkResponse);
               });
               socket.on("error", (chunk) => {
                 request.destroy();
@@ -58933,7 +58933,7 @@ Connection: close\r
               customOptions.timeout = timeout;
             }
           }
-          return new Promise((resolve, reject) => {
+          return new Promise((resolve2, reject) => {
             let request;
             if (customOptions.protocol === "http:") {
               request = http.request(customOptions);
@@ -58966,7 +58966,7 @@ Connection: close\r
                 if (this.shouldDestroyRequest(statusCode, networkResponse)) {
                   request.destroy();
                 }
-                resolve(networkResponse);
+                resolve2(networkResponse);
               });
             });
             request.on("error", (chunk) => {
@@ -60736,7 +60736,7 @@ Headers: ${JSON.stringify(headers)}`
         if (this.server) {
           throw NodeAuthError.createLoopbackServerAlreadyExistsError();
         }
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve2, reject) => {
           this.server = http.createServer((req, res) => {
             const url = req.url;
             if (!url) {
@@ -60759,7 +60759,7 @@ Headers: ${JSON.stringify(headers)}`
             if (authCodeResponse.error) {
               res.end(errorTemplate || `Error occurred: ${authCodeResponse.error}`);
             }
-            resolve(authCodeResponse);
+            resolve2(authCodeResponse);
           });
           this.server.listen(0, "127.0.0.1");
         });
@@ -61172,7 +61172,7 @@ Headers: ${JSON.stringify(headers)}`
        * @returns
        */
       async waitForRedirectUri(loopbackClient) {
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve2, reject) => {
           let ticks = 0;
           const id = setInterval(() => {
             if (LOOPBACK_SERVER_CONSTANTS.TIMEOUT_MS / LOOPBACK_SERVER_CONSTANTS.INTERVAL_MS < ticks) {
@@ -61183,7 +61183,7 @@ Headers: ${JSON.stringify(headers)}`
             try {
               const r = loopbackClient.getRedirectUri();
               clearInterval(id);
-              resolve(r);
+              resolve2(r);
               return;
             } catch (e) {
               if (e instanceof AuthError && e.errorCode === NodeAuthErrorMessage.noLoopbackServerExists.code) {
@@ -61937,8 +61937,8 @@ Headers: ${JSON.stringify(headers)}`
         if (DEFAULT_MANAGED_IDENTITY_HTTP_STATUS_CODES_TO_RETRY_ON.includes(httpStatusCode) && currentRetry < DEFAULT_MANAGED_IDENTITY_MAX_RETRIES) {
           const retryAfterDelay = this.linearRetryStrategy.calculateDelay(retryAfterHeader, _DefaultManagedIdentityRetryPolicy.DEFAULT_MANAGED_IDENTITY_RETRY_DELAY_MS);
           logger2.verbose(`Retrying request in ${retryAfterDelay}ms (retry attempt: ${currentRetry + 1})`);
-          await new Promise((resolve) => {
-            return setTimeout(resolve, retryAfterDelay);
+          await new Promise((resolve2) => {
+            return setTimeout(resolve2, retryAfterDelay);
           });
           return true;
         }
@@ -62094,7 +62094,7 @@ Headers: ${JSON.stringify(headers)}`
         if (!identityEndpoint || !imdsEndpoint) {
           const fileDetectionPath = AZURE_ARC_FILE_DETECTION[process.platform];
           try {
-            fs20.accessSync(fileDetectionPath, fs20.constants.F_OK | fs20.constants.R_OK);
+            fs21.accessSync(fileDetectionPath, fs21.constants.F_OK | fs21.constants.R_OK);
             identityEndpoint = DEFAULT_AZURE_ARC_IDENTITY_ENDPOINT;
             imdsEndpoint = HIMDS_EXECUTABLE_HELPER_STRING;
           } catch (err) {
@@ -62206,7 +62206,7 @@ Headers: ${JSON.stringify(headers)}`
           }
           let secretFileSize;
           try {
-            secretFileSize = await fs20.statSync(secretFilePath).size;
+            secretFileSize = await fs21.statSync(secretFilePath).size;
           } catch (e) {
             throw createManagedIdentityError(unableToReadSecretFile);
           }
@@ -62215,7 +62215,7 @@ Headers: ${JSON.stringify(headers)}`
           }
           let secret;
           try {
-            secret = fs20.readFileSync(secretFilePath, EncodingTypes.UTF8);
+            secret = fs21.readFileSync(secretFilePath, EncodingTypes.UTF8);
           } catch (e) {
             throw createManagedIdentityError(unableToReadSecretFile);
           }
@@ -62392,8 +62392,8 @@ Headers: ${JSON.stringify(headers)}`
         if ((HTTP_STATUS_400_CODES_FOR_EXPONENTIAL_STRATEGY.includes(httpStatusCode) || httpStatusCode >= msalCommon.HttpStatus.SERVER_ERROR_RANGE_START && httpStatusCode <= msalCommon.HttpStatus.SERVER_ERROR_RANGE_END && currentRetry < this.maxRetries) && currentRetry < this.maxRetries) {
           const retryAfterDelay = httpStatusCode === msalCommon.HttpStatus.GONE ? _ImdsRetryPolicy.HTTP_STATUS_GONE_RETRY_AFTER_MS : this.exponentialRetryStrategy.calculateDelay(currentRetry);
           logger2.verbose(`Retrying request in ${retryAfterDelay}ms (retry attempt: ${currentRetry + 1})`);
-          await new Promise((resolve) => {
-            return setTimeout(resolve, retryAfterDelay);
+          await new Promise((resolve2) => {
+            return setTimeout(resolve2, retryAfterDelay);
           });
           return true;
         }
@@ -63292,7 +63292,7 @@ var require_createAbortablePromise = __commonJS({
     var abort_controller_1 = require_commonjs3();
     function createAbortablePromise(buildPromise, options) {
       const { cleanupBeforeAbort, abortSignal, abortErrorMsg } = options ?? {};
-      return new Promise((resolve, reject) => {
+      return new Promise((resolve2, reject) => {
         function rejectOnAbort() {
           reject(new abort_controller_1.AbortError(abortErrorMsg ?? "The operation was aborted."));
         }
@@ -63310,7 +63310,7 @@ var require_createAbortablePromise = __commonJS({
         try {
           buildPromise((x) => {
             removeListeners();
-            resolve(x);
+            resolve2(x);
           }, (x) => {
             removeListeners();
             reject(x);
@@ -63337,8 +63337,8 @@ var require_delay3 = __commonJS({
     function delay(timeInMs, options) {
       let token;
       const { abortSignal, abortErrorMsg } = options ?? {};
-      return (0, createAbortablePromise_js_1.createAbortablePromise)((resolve) => {
-        token = setTimeout(resolve, timeInMs);
+      return (0, createAbortablePromise_js_1.createAbortablePromise)((resolve2) => {
+        token = setTimeout(resolve2, timeInMs);
       }, {
         cleanupBeforeAbort: () => clearTimeout(token),
         abortSignal,
@@ -65027,9 +65027,9 @@ var require_nodeHttpClient = __commonJS({
       if (stream2.readable === false) {
         return Promise.resolve();
       }
-      return new Promise((resolve) => {
+      return new Promise((resolve2) => {
         const handler = () => {
-          resolve();
+          resolve2();
           stream2.removeListener("close", handler);
           stream2.removeListener("end", handler);
           stream2.removeListener("error", handler);
@@ -65184,8 +65184,8 @@ var require_nodeHttpClient = __commonJS({
           headers: request.headers.toJSON({ preserveCase: true }),
           ...request.requestOverrides
         };
-        return new Promise((resolve, reject) => {
-          const req = isInsecure ? node_http_1.default.request(options, resolve) : node_https_1.default.request(options, resolve);
+        return new Promise((resolve2, reject) => {
+          const req = isInsecure ? node_http_1.default.request(options, resolve2) : node_https_1.default.request(options, resolve2);
           req.once("error", (err) => {
             reject(new restError_js_1.RestError(err.message, { code: err.code ?? restError_js_1.RestError.REQUEST_SEND_ERROR, request }));
           });
@@ -65269,7 +65269,7 @@ var require_nodeHttpClient = __commonJS({
       return stream2;
     }
     function streamToText(stream2) {
-      return new Promise((resolve, reject) => {
+      return new Promise((resolve2, reject) => {
         const buffer = [];
         stream2.on("data", (chunk) => {
           if (Buffer.isBuffer(chunk)) {
@@ -65279,7 +65279,7 @@ var require_nodeHttpClient = __commonJS({
           }
         });
         stream2.on("end", () => {
-          resolve(Buffer.concat(buffer).toString("utf8"));
+          resolve2(Buffer.concat(buffer).toString("utf8"));
         });
         stream2.on("error", (e) => {
           if (e && e?.name === "AbortError") {
@@ -65526,7 +65526,7 @@ var require_helpers = __commonJS({
     var AbortError_js_1 = require_AbortError2();
     var StandardAbortMessage = "The operation was aborted.";
     function delay(delayInMs, value, options) {
-      return new Promise((resolve, reject) => {
+      return new Promise((resolve2, reject) => {
         let timer = void 0;
         let onAborted = void 0;
         const rejectOnAbort = () => {
@@ -65549,7 +65549,7 @@ var require_helpers = __commonJS({
         }
         timer = setTimeout(() => {
           removeListeners();
-          resolve(value);
+          resolve2(value);
         }, delayInMs);
         if (options?.abortSignal) {
           options.abortSignal.addEventListener("abort", onAborted);
@@ -65933,8 +65933,8 @@ var require_helpers2 = __commonJS({
     function req(url, opts = {}) {
       const href = typeof url === "string" ? url : url.href;
       const req2 = (href.startsWith("https:") ? https : http).request(url, opts);
-      const promise = new Promise((resolve, reject) => {
-        req2.once("response", resolve).once("error", reject).end();
+      const promise = new Promise((resolve2, reject) => {
+        req2.once("response", resolve2).once("error", reject).end();
       });
       req2.then = promise.then.bind(promise);
       return req2;
@@ -66111,7 +66111,7 @@ var require_parse_proxy_response = __commonJS({
     var debug_1 = __importDefault2(require_src());
     var debug = (0, debug_1.default)("https-proxy-agent:parse-proxy-response");
     function parseProxyResponse(socket) {
-      return new Promise((resolve, reject) => {
+      return new Promise((resolve2, reject) => {
         let buffersLength = 0;
         const buffers = [];
         function read() {
@@ -66177,7 +66177,7 @@ var require_parse_proxy_response = __commonJS({
           }
           debug("got proxy server response: %o %o", firstLine, headers);
           cleanup();
-          resolve({
+          resolve2({
             connect: {
               statusCode,
               statusText,
@@ -71279,14 +71279,14 @@ var init_open = __esm({
       }
       const subprocess = import_node_child_process5.default.spawn(command, cliArguments, childProcessOptions);
       if (options.wait) {
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve2, reject) => {
           subprocess.once("error", reject);
           subprocess.once("close", (exitCode) => {
             if (!options.allowNonzeroExitCode && exitCode > 0) {
               reject(new Error(`Exited with code ${exitCode}`));
               return;
             }
-            resolve(subprocess);
+            resolve2(subprocess);
           });
         });
       }
@@ -72778,7 +72778,7 @@ var require_azureDeveloperCliCredential = __commonJS({
           const encodedClaims = btoa(claims);
           claimsSections = ["--claims", encodedClaims];
         }
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve2, reject) => {
           try {
             const args = [
               "auth",
@@ -72795,7 +72795,7 @@ var require_azureDeveloperCliCredential = __commonJS({
               cwd: exports2.developerCliCredentialInternals.getSafeWorkingDir(),
               timeout
             }, (error, stdout, stderr) => {
-              resolve({ stdout, stderr, error });
+              resolve2({ stdout, stderr, error });
             });
           } catch (err) {
             reject(err);
@@ -72964,7 +72964,7 @@ var require_azureCliCredential = __commonJS({
         if (subscription) {
           subscriptionSection = ["--subscription", `"${subscription}"`];
         }
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve2, reject) => {
           try {
             const args = [
               "account",
@@ -72978,7 +72978,7 @@ var require_azureCliCredential = __commonJS({
             ];
             const command = ["az", ...args].join(" ");
             child_process_1.default.exec(command, { cwd: exports2.cliCredentialInternals.getSafeWorkingDir(), timeout }, (error, stdout, stderr) => {
-              resolve({ stdout, stderr, error });
+              resolve2({ stdout, stderr, error });
             });
           } catch (err) {
             reject(err);
@@ -73128,7 +73128,7 @@ var require_processUtils = __commonJS({
        * @internal
        */
       execFile(file, params, options) {
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve2, reject) => {
           node_child_process_1.default.execFile(file, params, options, (error, stdout, stderr) => {
             if (Buffer.isBuffer(stdout)) {
               stdout = stdout.toString("utf8");
@@ -73139,7 +73139,7 @@ var require_processUtils = __commonJS({
             if (stderr || error) {
               reject(stderr ? new Error(stderr) : error);
             } else {
-              resolve(stdout);
+              resolve2(stdout);
             }
           });
         });
@@ -74844,7 +74844,7 @@ var require_sender = __commonJS({
       if (signal.aborted) {
         throw new _abortError.default();
       }
-      return await new Promise((resolve, reject) => {
+      return await new Promise((resolve2, reject) => {
         const sockets = [];
         let errorCount = 0;
         const onError = (err) => {
@@ -74858,7 +74858,7 @@ var require_sender = __commonJS({
         const onMessage = (message) => {
           signal.removeEventListener("abort", onAbort);
           clearSockets();
-          resolve(message);
+          resolve2(message);
         };
         const onAbort = () => {
           clearSockets();
@@ -74895,7 +74895,7 @@ var require_sender = __commonJS({
           family: _net.default.isIPv6(host) ? 6 : 4
         }];
       } else {
-        addresses = await new Promise((resolve, reject) => {
+        addresses = await new Promise((resolve2, reject) => {
           const onAbort = () => {
             reject(new _abortError.default());
           };
@@ -74904,7 +74904,7 @@ var require_sender = __commonJS({
             all: true
           }, (err, addresses2) => {
             signal.removeEventListener("abort", onAbort);
-            err ? reject(err) : resolve(addresses2);
+            err ? reject(err) : resolve2(addresses2);
           });
         });
       }
@@ -78421,25 +78421,25 @@ var require_util2 = __commonJS({
         };
       },
       createDeferredPromise: function() {
-        let resolve;
+        let resolve2;
         let reject;
         const promise = new Promise((res, rej) => {
-          resolve = res;
+          resolve2 = res;
           reject = rej;
         });
         return {
           promise,
-          resolve,
+          resolve: resolve2,
           reject
         };
       },
       promisify(fn) {
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve2, reject) => {
           fn((err, ...args) => {
             if (err) {
               return reject(err);
             }
-            return resolve(...args);
+            return resolve2(...args);
           });
         });
       },
@@ -79231,7 +79231,7 @@ var require_end_of_stream2 = __commonJS({
         validateBoolean(opts.cleanup, "cleanup");
         autoCleanup = opts.cleanup;
       }
-      return new Promise2((resolve, reject) => {
+      return new Promise2((resolve2, reject) => {
         const cleanup = eos(stream2, opts, (err) => {
           if (autoCleanup) {
             cleanup();
@@ -79239,7 +79239,7 @@ var require_end_of_stream2 = __commonJS({
           if (err) {
             reject(err);
           } else {
-            resolve();
+            resolve2();
           }
         });
       });
@@ -80109,7 +80109,7 @@ var require_readable2 = __commonJS({
         error = this.readableEnded ? null : new AbortError();
         this.destroy(error);
       }
-      return new Promise2((resolve, reject) => eos(this, (err) => err && err !== error ? reject(err) : resolve(null)));
+      return new Promise2((resolve2, reject) => eos(this, (err) => err && err !== error ? reject(err) : resolve2(null)));
     };
     Readable.prototype.push = function(chunk, encoding) {
       return readableAddChunk(this, chunk, encoding, false);
@@ -80653,12 +80653,12 @@ var require_readable2 = __commonJS({
     }
     async function* createAsyncIterator(stream2, options) {
       let callback = nop;
-      function next(resolve) {
+      function next(resolve2) {
         if (this === stream2) {
           callback();
           callback = nop;
         } else {
-          callback = resolve;
+          callback = resolve2;
         }
       }
       stream2.on("readable", next);
@@ -81711,7 +81711,7 @@ var require_duplexify = __commonJS({
       );
     };
     function fromAsyncGen(fn) {
-      let { promise, resolve } = createDeferredPromise();
+      let { promise, resolve: resolve2 } = createDeferredPromise();
       const ac = new AbortController2();
       const signal = ac.signal;
       const value = fn(
@@ -81726,7 +81726,7 @@ var require_duplexify = __commonJS({
               throw new AbortError(void 0, {
                 cause: signal.reason
               });
-            ({ promise, resolve } = createDeferredPromise());
+            ({ promise, resolve: resolve2 } = createDeferredPromise());
             yield chunk;
           }
         })(),
@@ -81737,8 +81737,8 @@ var require_duplexify = __commonJS({
       return {
         value,
         write(chunk, encoding, cb) {
-          const _resolve = resolve;
-          resolve = null;
+          const _resolve = resolve2;
+          resolve2 = null;
           _resolve({
             chunk,
             done: false,
@@ -81746,8 +81746,8 @@ var require_duplexify = __commonJS({
           });
         },
         final(cb) {
-          const _resolve = resolve;
-          resolve = null;
+          const _resolve = resolve2;
+          resolve2 = null;
           _resolve({
             done: true,
             cb
@@ -82199,7 +82199,7 @@ var require_pipeline5 = __commonJS({
           callback();
         }
       };
-      const wait = () => new Promise2((resolve, reject) => {
+      const wait = () => new Promise2((resolve2, reject) => {
         if (error) {
           reject(error);
         } else {
@@ -82207,7 +82207,7 @@ var require_pipeline5 = __commonJS({
             if (error) {
               reject(error);
             } else {
-              resolve();
+              resolve2();
             }
           };
         }
@@ -82851,8 +82851,8 @@ var require_operators = __commonJS({
                 next = null;
               }
               if (!done && (queue.length >= highWaterMark || cnt >= concurrency)) {
-                await new Promise2((resolve) => {
-                  resume = resolve;
+                await new Promise2((resolve2) => {
+                  resume = resolve2;
                 });
               }
             }
@@ -82886,8 +82886,8 @@ var require_operators = __commonJS({
               queue.shift();
               maybeResume();
             }
-            await new Promise2((resolve) => {
-              next = resolve;
+            await new Promise2((resolve2) => {
+              next = resolve2;
             });
           }
         } finally {
@@ -83145,7 +83145,7 @@ var require_promises = __commonJS({
     var { finished } = require_end_of_stream2();
     require_stream2();
     function pipeline(...streams) {
-      return new Promise2((resolve, reject) => {
+      return new Promise2((resolve2, reject) => {
         let signal;
         let end;
         const lastArg = streams[streams.length - 1];
@@ -83160,7 +83160,7 @@ var require_promises = __commonJS({
             if (err) {
               reject(err);
             } else {
-              resolve(value);
+              resolve2(value);
             }
           },
           {
@@ -83986,7 +83986,7 @@ var require_message_io = __commonJS({
           credentialsDetails.maxVersion = "TLSv1.2";
         }
         const secureContext = tls.createSecureContext(credentialsDetails);
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve2, reject) => {
           const duplexpair = new _nativeDuplexpair.default();
           const securePair = this.securePair = {
             cleartext: tls.connect({
@@ -84017,7 +84017,7 @@ var require_message_io = __commonJS({
             securePair.cleartext.pipe(this.incomingMessageStream);
             this.outgoingMessageStream.pipe(securePair.cleartext);
             this.tlsNegotiationComplete = true;
-            resolve();
+            resolve2();
           };
           const onError = (err) => {
             securePair.encrypted.removeListener("readable", onReadable);
@@ -87821,7 +87821,7 @@ var init_js_joda_esm = __esm({
         this.fieldValues.put(field, value);
         return this;
       };
-      _proto.resolve = function resolve(resolverStyle, resolverFields) {
+      _proto.resolve = function resolve2(resolverStyle, resolverFields) {
         if (resolverFields != null) {
           this.fieldValues.retainAll(resolverFields);
         }
@@ -88425,7 +88425,7 @@ var init_js_joda_esm = __esm({
       _proto.displayName = function displayName() {
         return this.toString();
       };
-      _proto.resolve = function resolve() {
+      _proto.resolve = function resolve2() {
         return null;
       };
       _proto.name = function name() {
@@ -88483,7 +88483,7 @@ var init_js_joda_esm = __esm({
         this.range().checkValidValue(newValue, this);
         return temporal.with(ChronoField.DAY_OF_YEAR, temporal.getLong(ChronoField.DAY_OF_YEAR) + (newValue - curValue));
       };
-      _proto2.resolve = function resolve(fieldValues, partialTemporal, resolverStyle) {
+      _proto2.resolve = function resolve2(fieldValues, partialTemporal, resolverStyle) {
         var yearLong = fieldValues.get(ChronoField.YEAR);
         var qoyLong = fieldValues.get(QUARTER_OF_YEAR);
         if (yearLong == null || qoyLong == null) {
@@ -88594,7 +88594,7 @@ var init_js_joda_esm = __esm({
         this.range().checkValidValue(newValue, this);
         return temporal.plus(MathUtil.safeSubtract(newValue, this.getFrom(temporal)), ChronoUnit.WEEKS);
       };
-      _proto4.resolve = function resolve(fieldValues, partialTemporal, resolverStyle) {
+      _proto4.resolve = function resolve2(fieldValues, partialTemporal, resolverStyle) {
         var wbyLong = fieldValues.get(WEEK_BASED_YEAR);
         var dowLong = fieldValues.get(ChronoField.DAY_OF_WEEK);
         if (wbyLong == null || dowLong == null) {
@@ -104156,7 +104156,7 @@ var require_connector = __commonJS({
         throw new _abortError.default();
       }
       const addresses = await lookupAllAddresses(options.host, lookup, signal);
-      return await new Promise((resolve, reject) => {
+      return await new Promise((resolve2, reject) => {
         const sockets = new Array(addresses.length);
         const errors = [];
         function onError(err) {
@@ -104180,7 +104180,7 @@ var require_connector = __commonJS({
             socket.removeListener("connect", onConnect);
             socket.destroy();
           }
-          resolve(this);
+          resolve2(this);
         }
         const onAbort = () => {
           for (let j = 0; j < sockets.length; j++) {
@@ -104213,7 +104213,7 @@ var require_connector = __commonJS({
       const addresses = await lookupAllAddresses(options.host, lookup, signal);
       for (const address of addresses) {
         try {
-          return await new Promise((resolve, reject) => {
+          return await new Promise((resolve2, reject) => {
             const socket = _net.default.connect({
               ...options,
               host: address.address,
@@ -104236,7 +104236,7 @@ var require_connector = __commonJS({
               signal.removeEventListener("abort", onAbort);
               socket.removeListener("error", onError);
               socket.removeListener("connect", onConnect);
-              resolve(socket);
+              resolve2(socket);
             };
             signal.addEventListener("abort", onAbort, {
               once: true
@@ -104269,7 +104269,7 @@ var require_connector = __commonJS({
           family: 4
         }];
       } else {
-        return await new Promise((resolve, reject) => {
+        return await new Promise((resolve2, reject) => {
           const onAbort = () => {
             reject(new _abortError.default());
           };
@@ -104279,7 +104279,7 @@ var require_connector = __commonJS({
             all: true
           }, (err, addresses) => {
             signal.removeEventListener("abort", onAbort);
-            err ? reject(err) : resolve(addresses);
+            err ? reject(err) : resolve2(addresses);
           });
         });
       }
@@ -105947,7 +105947,7 @@ var require_connection = __commonJS({
       }
       wrapWithTls(socket, signal) {
         signal.throwIfAborted();
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve2, reject) => {
           const secureContext = tls.createSecureContext(this.secureContextOptions);
           const serverName = !net.isIP(this.config.server) ? this.config.server : "";
           const encryptOptions = {
@@ -105975,7 +105975,7 @@ var require_connection = __commonJS({
             signal.removeEventListener("abort", onAbort);
             encryptsocket.removeListener("error", onError);
             encryptsocket.removeListener("connect", onConnect);
-            resolve(encryptsocket);
+            resolve2(encryptsocket);
           };
           signal.addEventListener("abort", onAbort, {
             once: true
@@ -107638,15 +107638,15 @@ var require_connection_pool2 = __commonJS({
         return cfg;
       }
       _poolCreate() {
-        return new shared.Promise((resolve, reject) => {
+        return new shared.Promise((resolve2, reject) => {
           const resolveOnce = (v) => {
-            resolve(v);
-            resolve = reject = () => {
+            resolve2(v);
+            resolve2 = reject = () => {
             };
           };
           const rejectOnce = (e) => {
             reject(e);
-            resolve = reject = () => {
+            resolve2 = reject = () => {
             };
           };
           let tedious;
@@ -107690,9 +107690,9 @@ var require_connection_pool2 = __commonJS({
       }
       _poolValidate(tedious) {
         if (tedious && !tedious.closed && !tedious.hasError) {
-          return !this.config.validateConnection || new shared.Promise((resolve) => {
+          return !this.config.validateConnection || new shared.Promise((resolve2) => {
             const req = new tds.Request("SELECT 1;", (err) => {
-              resolve(!err);
+              resolve2(!err);
             });
             tedious.execSql(req);
           });
@@ -107700,19 +107700,19 @@ var require_connection_pool2 = __commonJS({
         return false;
       }
       _poolDestroy(tedious) {
-        return new shared.Promise((resolve, reject) => {
+        return new shared.Promise((resolve2, reject) => {
           if (!tedious) {
-            resolve();
+            resolve2();
             return;
           }
           debug("connection(%d): destroying", IDS.get(tedious));
           if (tedious.closed) {
             debug("connection(%d): already closed", IDS.get(tedious));
-            resolve();
+            resolve2();
           } else {
             tedious.once("end", () => {
               debug("connection(%d): destroyed", IDS.get(tedious));
-              resolve();
+              resolve2();
             });
             tedious.close();
           }
@@ -109037,13 +109037,13 @@ var require_bcrypt = __commonJS({
             throw Error("Illegal callback: " + typeof callback);
           _async(callback);
         } else
-          return new Promise(function(resolve, reject) {
+          return new Promise(function(resolve2, reject) {
             _async(function(err, res) {
               if (err) {
                 reject(err);
                 return;
               }
-              resolve(res);
+              resolve2(res);
             });
           });
       };
@@ -109072,13 +109072,13 @@ var require_bcrypt = __commonJS({
             throw Error("Illegal callback: " + typeof callback);
           _async(callback);
         } else
-          return new Promise(function(resolve, reject) {
+          return new Promise(function(resolve2, reject) {
             _async(function(err, res) {
               if (err) {
                 reject(err);
                 return;
               }
-              resolve(res);
+              resolve2(res);
             });
           });
       };
@@ -109123,13 +109123,13 @@ var require_bcrypt = __commonJS({
             throw Error("Illegal callback: " + typeof callback);
           _async(callback);
         } else
-          return new Promise(function(resolve, reject) {
+          return new Promise(function(resolve2, reject) {
             _async(function(err, res) {
               if (err) {
                 reject(err);
                 return;
               }
-              resolve(res);
+              resolve2(res);
             });
           });
       };
@@ -114266,9 +114266,9 @@ var Prompt = class {
    * @return {Promise}
    */
   run() {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       this._run(
-        (value) => resolve(value),
+        (value) => resolve2(value),
         (error) => reject(error)
       );
     });
@@ -121839,10 +121839,10 @@ var Minipass = class extends import_node_events.EventEmitter {
    * Return a void Promise that resolves once the stream ends.
    */
   async promise() {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       this.on(DESTROYED, () => reject(new Error("stream destroyed")));
       this.on("error", (er) => reject(er));
-      this.on("end", () => resolve());
+      this.on("end", () => resolve2());
     });
   }
   /**
@@ -121866,7 +121866,7 @@ var Minipass = class extends import_node_events.EventEmitter {
         return Promise.resolve({ done: false, value: res });
       if (this[EOF])
         return stop();
-      let resolve;
+      let resolve2;
       let reject;
       const onerr = (er) => {
         this.off("data", ondata);
@@ -121880,19 +121880,19 @@ var Minipass = class extends import_node_events.EventEmitter {
         this.off("end", onend);
         this.off(DESTROYED, ondestroy);
         this.pause();
-        resolve({ value, done: !!this[EOF] });
+        resolve2({ value, done: !!this[EOF] });
       };
       const onend = () => {
         this.off("error", onerr);
         this.off("data", ondata);
         this.off(DESTROYED, ondestroy);
         stop();
-        resolve({ done: true, value: void 0 });
+        resolve2({ done: true, value: void 0 });
       };
       const ondestroy = () => onerr(new Error("stream destroyed"));
       return new Promise((res2, rej) => {
         reject = rej;
-        resolve = res2;
+        resolve2 = res2;
         this.once(DESTROYED, ondestroy);
         this.once("error", onerr);
         this.once("end", onend);
@@ -122864,9 +122864,9 @@ var PathBase = class {
     if (this.#asyncReaddirInFlight) {
       await this.#asyncReaddirInFlight;
     } else {
-      let resolve = () => {
+      let resolve2 = () => {
       };
-      this.#asyncReaddirInFlight = new Promise((res) => resolve = res);
+      this.#asyncReaddirInFlight = new Promise((res) => resolve2 = res);
       try {
         for (const e of await this.#fs.promises.readdir(fullpath, {
           withFileTypes: true
@@ -122879,7 +122879,7 @@ var PathBase = class {
         children.provisional = 0;
       }
       this.#asyncReaddirInFlight = void 0;
-      resolve();
+      resolve2();
     }
     return children.slice(0, children.provisional);
   }
@@ -123109,8 +123109,8 @@ var PathScurryBase = class {
    *
    * @internal
    */
-  constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs20 = defaultFS } = {}) {
-    this.#fs = fsFromOption(fs20);
+  constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs21 = defaultFS } = {}) {
+    this.#fs = fsFromOption(fs21);
     if (cwd instanceof URL || cwd.startsWith("file://")) {
       cwd = (0, import_node_url.fileURLToPath)(cwd);
     }
@@ -123668,8 +123668,8 @@ var PathScurryWin32 = class extends PathScurryBase {
   /**
    * @internal
    */
-  newRoot(fs20) {
-    return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs20 });
+  newRoot(fs21) {
+    return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs21 });
   }
   /**
    * Return true if the provided path string is an absolute path
@@ -123697,8 +123697,8 @@ var PathScurryPosix = class extends PathScurryBase {
   /**
    * @internal
    */
-  newRoot(fs20) {
-    return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs20 });
+  newRoot(fs21) {
+    return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs21 });
   }
   /**
    * Return true if the provided path string is an absolute path
@@ -127973,8 +127973,8 @@ mcpCommand.command("remove").description("Unregister MCP servers from CLI and VS
 });
 
 // src/commands/derive-prd.ts
-var import_fs_extra14 = __toESM(require_lib());
-var import_path15 = require("path");
+var import_fs_extra15 = __toESM(require_lib());
+var import_path16 = require("path");
 
 // src/utils/task-generator.ts
 var LAYER_ORDER = [
@@ -128550,12 +128550,221 @@ function getPrdFileCounts(prd) {
   };
 }
 
+// src/utils/ba-adapter.ts
+var import_fs_extra14 = __toESM(require_lib());
+var import_path15 = require("path");
+function readBaFile(baDir, filename, defaultValue) {
+  const filePath = (0, import_path15.join)(baDir, filename);
+  if (import_fs_extra14.default.existsSync(filePath)) {
+    return import_fs_extra14.default.readJsonSync(filePath);
+  }
+  return defaultValue;
+}
+function flatFilesToModuleFeature(baDir) {
+  const index = readBaFile(baDir, "index.json", null);
+  if (!index) {
+    throw new Error(`index.json not found in ${baDir}`);
+  }
+  const entitiesData = readBaFile(baDir, "entities.json", { entities: [] });
+  const usecasesData = readBaFile(baDir, "usecases.json", { useCases: [] });
+  const rulesData = readBaFile(baDir, "rules.json", { rules: [] });
+  const permissionsData = readBaFile(baDir, "permissions.json", { roles: [], permissionPaths: [], matrix: [] });
+  const screensData = readBaFile(baDir, "screens.json", { screens: [] });
+  const handoffData = readBaFile(baDir, "handoff.json", null);
+  const meta = index.metadata;
+  const entities = (entitiesData.entities || []).map((e) => ({
+    name: e.name,
+    description: e.description,
+    type: mapEntityType(e),
+    attributes: (e.attributes || []).map((a) => ({
+      name: a.name,
+      type: a.type,
+      required: a.required ?? false,
+      unique: a.unique ?? false,
+      description: a.description,
+      businessRule: a.businessRule
+    })),
+    relationships: (e.relationships || []).map((r) => ({
+      target: r.target,
+      type: normalizeRelType(r.type),
+      description: r.description,
+      cascadeDelete: r.cascadeDelete
+    }))
+  }));
+  const businessRules = (rulesData.rules || []).map((r) => ({
+    id: r.id,
+    name: r.name,
+    category: mapRuleCategory(r.category),
+    statement: r.statement,
+    priority: mapRulePriority(r.severity),
+    entity: (r.entities || [])[0],
+    validationLogic: r.example,
+    errorMessage: r.errorMessage
+  }));
+  const useCases = (usecasesData.useCases || []).map((uc) => ({
+    id: uc.id,
+    name: uc.name,
+    description: uc.description,
+    primaryActor: uc.actor || "User",
+    permission: guessPermissionFromUc(uc, permissionsData),
+    preconditions: uc.preconditions || [],
+    mainScenario: uc.steps || [],
+    alternativeScenarios: uc.alternative ? [{ name: "Alternative", steps: [uc.alternative] }] : [],
+    postconditions: uc.result ? [uc.result] : [],
+    linkedRules: uc.businessRules || []
+  }));
+  const permissionMatrix = {
+    permissions: (permissionsData.permissionPaths || []).map((p) => ({
+      path: p,
+      description: p
+    })),
+    roleAssignments: (permissionsData.matrix || []).map((m) => ({
+      role: m.role,
+      level: mapRoleLevel(m.role),
+      permissions: (m.permissions || []).map(
+        (perm) => perm.includes(".") ? perm : `${meta.applicationCode}.${meta.moduleCode}.${perm}`
+      )
+    }))
+  };
+  const sections = (screensData.screens || []).map((s) => ({
+    code: s.sectionCode,
+    name: s.sectionLabel || s.sectionCode,
+    route: `/${toKebabCase(meta.moduleCode)}/${s.sectionCode}`,
+    permission: `${meta.applicationCode}.${meta.moduleCode}.Read`,
+    resources: (s.resources || []).map((r) => ({
+      code: r.code,
+      type: r.type,
+      entity: r.entity,
+      permission: r.permission,
+      columns: (r.columns || []).map((c) => c.field)
+    }))
+  }));
+  const moduleFeature = {
+    id: meta.featureId,
+    version: meta.version,
+    status: mapModuleStatus(meta.status),
+    scope: "module",
+    metadata: {
+      createdAt: meta.createdAt,
+      updatedAt: meta.lastModified,
+      application: meta.applicationCode,
+      module: meta.moduleCode,
+      language: "fr",
+      featureDescription: `Module ${meta.moduleCode} of ${meta.applicationCode}`,
+      permissionBase: `${meta.applicationCode}.${meta.moduleCode}`
+    },
+    analysis: {
+      entities,
+      businessRules
+    },
+    specification: {
+      useCases,
+      permissionMatrix,
+      sections
+    },
+    handoff: handoffData ? {
+      complexity: handoffData.complexity,
+      filesToCreate: handoffData.filesToCreate,
+      brToCodeMapping: handoffData.brToCodeMapping,
+      apiEndpointSummary: handoffData.apiEndpointSummary,
+      prdFile: handoffData.prdFile,
+      totalFiles: handoffData.totalFiles,
+      totalTasks: handoffData.totalTasks,
+      handedOffAt: handoffData.handedOffAt
+    } : void 0
+  };
+  return moduleFeature;
+}
+function findModuleBaDirs(appIndexPath) {
+  const appIndex = import_fs_extra14.default.readJsonSync(appIndexPath);
+  const appDir = (0, import_path15.join)(appIndexPath, "..");
+  const version2 = appIndex.metadata.version;
+  const appCode = appIndex.metadata.applicationCode;
+  const appBaseDir = (0, import_path15.join)(appDir, "..", "..");
+  const result = [];
+  for (const mod of appIndex.modules || []) {
+    const moduleDir = (0, import_path15.join)(appBaseDir, mod.code, "business-analyse", `v${version2}`);
+    if (import_fs_extra14.default.existsSync((0, import_path15.join)(moduleDir, "index.json"))) {
+      result.push({ moduleCode: mod.code, baDir: moduleDir });
+    }
+  }
+  return result;
+}
+function mapEntityType(e) {
+  if (e.type) return e.type;
+  return "root-aggregate";
+}
+function normalizeRelType(type) {
+  const map8 = {
+    "OneToMany": "one-to-many",
+    "ManyToOne": "many-to-one",
+    "ManyToMany": "many-to-many",
+    "OneToOne": "one-to-one",
+    "one-to-many": "one-to-many",
+    "many-to-one": "many-to-one",
+    "many-to-many": "many-to-many",
+    "one-to-one": "one-to-one"
+  };
+  return map8[type] || "many-to-one";
+}
+function mapRuleCategory(cat) {
+  const map8 = {
+    "validation": "VAL",
+    "VAL": "VAL",
+    "calculation": "CALC",
+    "CALC": "CALC",
+    "workflow": "WF",
+    "WF": "WF",
+    "security": "SEC",
+    "SEC": "SEC",
+    "data": "DATA",
+    "DATA": "DATA"
+  };
+  return map8[cat] || "VAL";
+}
+function mapRulePriority(severity) {
+  if (severity === "blocking" || severity === "error") return "must";
+  if (severity === "warning") return "should";
+  return "could";
+}
+function guessPermissionFromUc(uc, permissions) {
+  if (uc.preconditions) {
+    for (const pre of uc.preconditions) {
+      const match2 = pre.match(/permission\s+(\S+)/i);
+      if (match2) return match2[1];
+    }
+  }
+  return (permissions.permissionPaths || [])[0] || "Unknown";
+}
+function mapRoleLevel(role) {
+  const lower = role.toLowerCase();
+  if (lower.includes("admin")) return "admin";
+  if (lower.includes("manager")) return "manager";
+  if (lower.includes("contributor")) return "contributor";
+  return "viewer";
+}
+function mapModuleStatus(status) {
+  const map8 = {
+    "draft": "draft",
+    "analysed": "analysed",
+    "specified": "specified",
+    "approved": "approved",
+    "rejected": "rejected",
+    "consolidated": "consolidated",
+    "handed-off": "handed-off"
+  };
+  return map8[status] || "specified";
+}
+function toKebabCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+}
+
 // src/commands/derive-prd.ts
 function readSmartStackNamespace() {
   try {
-    const configPath = (0, import_path15.join)(process.cwd(), ".smartstack", "config.json");
-    if (import_fs_extra14.default.existsSync(configPath)) {
-      const config = import_fs_extra14.default.readJsonSync(configPath);
+    const configPath = (0, import_path16.join)(process.cwd(), ".smartstack", "config.json");
+    if (import_fs_extra15.default.existsSync(configPath)) {
+      const config = import_fs_extra15.default.readJsonSync(configPath);
       return config.baseNamespace;
     }
   } catch {
@@ -128563,14 +128772,14 @@ function readSmartStackNamespace() {
   return void 0;
 }
 async function findModuleFeatureFiles(masterPath) {
-  const master = await import_fs_extra14.default.readJson(masterPath);
-  const masterDir = (0, import_path15.dirname)(masterPath);
+  const master = await import_fs_extra15.default.readJson(masterPath);
+  const masterDir = (0, import_path16.dirname)(masterPath);
   const paths = [];
   if (master.modules) {
     for (const mod of master.modules) {
       if (mod.featureJsonPath) {
-        const fullPath = (0, import_path15.join)(masterDir, "..", "..", mod.featureJsonPath);
-        if (await import_fs_extra14.default.pathExists(fullPath)) {
+        const fullPath = (0, import_path16.join)(masterDir, "..", "..", mod.featureJsonPath);
+        if (await import_fs_extra15.default.pathExists(fullPath)) {
           paths.push(fullPath);
         }
       }
@@ -128578,18 +128787,57 @@ async function findModuleFeatureFiles(masterPath) {
   }
   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"));
+var derivePrdCommand = new Command("derive-prd").description("Extract prd.json programmatically from feature.json or flat BA files (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("--ba-dir <path>", "Path to a flat-file BA module directory (contains index.json, entities.json, etc.)").option("--ba-app <path>", "Path to an app-level BA index.json (discovers 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 && !options.baDir && !options.baApp) {
+    console.log(source_default.red("Error: Provide --feature, --application, --ba-dir, or --ba-app"));
     process.exit(1);
   }
   const namespace = readSmartStackNamespace();
-  const ralphDir = (0, import_path15.join)(process.cwd(), ".ralph");
-  await import_fs_extra14.default.ensureDir(ralphDir);
+  const ralphDir = (0, import_path16.join)(process.cwd(), ".ralph");
+  await import_fs_extra15.default.ensureDir(ralphDir);
   let featurePaths = [];
-  if (options.application) {
-    const appPath = (0, import_path15.join)(process.cwd(), options.application);
-    if (!await import_fs_extra14.default.pathExists(appPath)) {
+  const flatFileFeatures = /* @__PURE__ */ new Map();
+  if (options.baApp) {
+    const appIndexPath = (0, import_path16.resolve)(process.cwd(), options.baApp);
+    if (!await import_fs_extra15.default.pathExists(appIndexPath)) {
+      console.log(source_default.red(`BA app index.json not found: ${appIndexPath}`));
+      process.exit(1);
+    }
+    const moduleDirs = findModuleBaDirs(appIndexPath);
+    if (moduleDirs.length === 0) {
+      console.log(source_default.red("No module BA directories found from app index.json"));
+      process.exit(1);
+    }
+    for (const { moduleCode, baDir } of moduleDirs) {
+      try {
+        const moduleFeature = flatFilesToModuleFeature(baDir);
+        const syntheticPath = (0, import_path16.join)(baDir, "index.json");
+        flatFileFeatures.set(syntheticPath, moduleFeature);
+        featurePaths.push({ path: syntheticPath, isApplicationMode: true });
+      } catch (err) {
+        console.log(source_default.red(`Failed to load BA flat files for ${moduleCode}: ${err}`));
+        if (options.strict) process.exit(1);
+      }
+    }
+    console.log(source_default.cyan(`Found ${featurePaths.length} module(s) from BA flat files`));
+  } else if (options.baDir) {
+    const baDir = (0, import_path16.resolve)(process.cwd(), options.baDir);
+    if (!await import_fs_extra15.default.pathExists((0, import_path16.join)(baDir, "index.json"))) {
+      console.log(source_default.red(`BA index.json not found in: ${baDir}`));
+      process.exit(1);
+    }
+    try {
+      const moduleFeature = flatFilesToModuleFeature(baDir);
+      const syntheticPath = (0, import_path16.join)(baDir, "index.json");
+      flatFileFeatures.set(syntheticPath, moduleFeature);
+      featurePaths = [{ path: syntheticPath, isApplicationMode: false }];
+    } catch (err) {
+      console.log(source_default.red(`Failed to load BA flat files: ${err}`));
+      process.exit(1);
+    }
+  } else if (options.application) {
+    const appPath = (0, import_path16.join)(process.cwd(), options.application);
+    if (!await import_fs_extra15.default.pathExists(appPath)) {
       console.log(source_default.red(`Application feature.json not found: ${appPath}`));
       process.exit(1);
     }
@@ -128601,8 +128849,8 @@ var derivePrdCommand = new Command("derive-prd").description("Extract prd.json p
     featurePaths = modulePaths.map((p) => ({ path: p, isApplicationMode: true }));
     console.log(source_default.cyan(`Found ${featurePaths.length} module(s) to process`));
   } else if (options.feature) {
-    const featurePath = (0, import_path15.join)(process.cwd(), options.feature);
-    if (!await import_fs_extra14.default.pathExists(featurePath)) {
+    const featurePath = (0, import_path16.join)(process.cwd(), options.feature);
+    if (!await import_fs_extra15.default.pathExists(featurePath)) {
       console.log(source_default.red(`Feature.json not found: ${featurePath}`));
       process.exit(1);
     }
@@ -128611,7 +128859,7 @@ var derivePrdCommand = new Command("derive-prd").description("Extract prd.json p
   let totalGenerated = 0;
   let totalErrors = 0;
   for (const entry of featurePaths) {
-    const featureJson = await import_fs_extra14.default.readJson(entry.path);
+    const featureJson = flatFileFeatures.get(entry.path) ?? await import_fs_extra15.default.readJson(entry.path);
     const moduleName = featureJson.metadata?.module ?? "unknown";
     console.log(source_default.cyan(`
 Processing module: ${source_default.bold(moduleName)}`));
@@ -128629,20 +128877,20 @@ Processing module: ${source_default.bold(moduleName)}`));
     }
     let cliVersion = "unknown";
     try {
-      const pkg2 = import_fs_extra14.default.readJsonSync((0, import_path15.join)(__dirname, "..", "..", "package.json"));
+      const pkg2 = import_fs_extra15.default.readJsonSync((0, import_path16.join)(__dirname, "..", "..", "package.json"));
       cliVersion = pkg2.version ?? "unknown";
     } catch {
     }
-    const relativePath = (0, import_path15.relative)(process.cwd(), entry.path);
+    const relativePath = (0, import_path16.relative)(process.cwd(), entry.path);
     const unified = extractUnifiedPrd(featureJson, relativePath, namespace, cliVersion);
     const prd = extractPrd(featureJson, relativePath, namespace);
     let outputPath;
     if (options.output && !entry.isApplicationMode) {
-      outputPath = (0, import_path15.join)(process.cwd(), options.output);
+      outputPath = (0, import_path16.join)(process.cwd(), options.output);
     } else {
-      outputPath = (0, import_path15.join)(ralphDir, `prd-${moduleName}.json`);
+      outputPath = (0, import_path16.join)(ralphDir, `prd-${moduleName}.json`);
     }
-    await import_fs_extra14.default.writeJson(outputPath, unified, { spaces: 2 });
+    await import_fs_extra15.default.writeJson(outputPath, unified, { spaces: 2 });
     totalGenerated++;
     const completenessWarnings = validatePrdCompleteness(prd, featureJson);
     if (completenessWarnings.length > 0) {
@@ -128663,7 +128911,7 @@ Processing module: ${source_default.bold(moduleName)}`));
         console.log(source_default.yellow(`    - ${te}`));
       }
     }
-    const relOutput = (0, import_path15.relative)(process.cwd(), outputPath);
+    const relOutput = (0, import_path16.relative)(process.cwd(), outputPath);
     console.log(source_default.green(`  Generated: ${relOutput} (unified v3)`));
     console.log(source_default.gray(`    UCs: ${prd.requirements.useCases.length} | FRs: ${prd.requirements.functionalRequirements.length} | BRs: ${prd.businessRules.length}`));
     console.log(source_default.gray(`    Endpoints: ${prd.architecture.apiEndpoints.length} | Sections: ${prd.architecture.sections.length}`));
@@ -128693,7 +128941,7 @@ var import_cli_table36 = __toESM(require_cli_table3());
 // src/lib/wsl-provisioner.ts
 var import_child_process11 = require("child_process");
 var import_fs5 = require("fs");
-var import_path16 = require("path");
+var import_path17 = require("path");
 function wslExec(command, timeout = 1e4) {
   try {
     const output = (0, import_child_process11.execSync)(`wsl -e bash -c "${command.replace(/"/g, '\\"')}"`, {
@@ -129022,11 +129270,11 @@ async function installWindowsTerminal() {
 function getWtSettingsPath() {
   const localAppData = process.env.LOCALAPPDATA;
   if (!localAppData) return null;
-  const standardPath = (0, import_path16.join)(localAppData, "Packages", "Microsoft.WindowsTerminal_8wekyb3d8bbwe", "LocalState", "settings.json");
+  const standardPath = (0, import_path17.join)(localAppData, "Packages", "Microsoft.WindowsTerminal_8wekyb3d8bbwe", "LocalState", "settings.json");
   if ((0, import_fs5.existsSync)(standardPath)) return standardPath;
-  const previewPath = (0, import_path16.join)(localAppData, "Packages", "Microsoft.WindowsTerminalPreview_8wekyb3d8bbwe", "LocalState", "settings.json");
+  const previewPath = (0, import_path17.join)(localAppData, "Packages", "Microsoft.WindowsTerminalPreview_8wekyb3d8bbwe", "LocalState", "settings.json");
   if ((0, import_fs5.existsSync)(previewPath)) return previewPath;
-  const unpackagedPath = (0, import_path16.join)(localAppData, "Microsoft", "Windows Terminal", "settings.json");
+  const unpackagedPath = (0, import_path17.join)(localAppData, "Microsoft", "Windows Terminal", "settings.json");
   if ((0, import_fs5.existsSync)(unpackagedPath)) return unpackagedPath;
   return null;
 }
@@ -129339,8 +129587,8 @@ tmuxCommand.command("status").description("Show WSL development environment stat
 
 // src/index.ts
 var import_fs6 = require("fs");
-var import_path17 = require("path");
-var pkg = JSON.parse((0, import_fs6.readFileSync)((0, import_path17.join)(__dirname, "..", "package.json"), "utf-8"));
+var import_path18 = require("path");
+var pkg = JSON.parse((0, import_fs6.readFileSync)((0, import_path18.join)(__dirname, "..", "package.json"), "utf-8"));
 var LICENSE_FREE_COMMANDS = ["license", "doctor", "help", "--help", "-h", "--version", "-v"];
 async function main2() {
   const program2 = new Command();