routesync 1.0.1 → 1.0.3

package/dist/cli.js

@@ -983,8 +983,8 @@ var require_command = __commonJS({
     "use strict";
     var EventEmitter = require("events").EventEmitter;
     var childProcess = require("child_process");
-    var path5 = require("path");
-    var fs9 = require("fs");
+    var path11 = require("path");
+    var fs15 = require("fs");
     var process10 = require("process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -1916,11 +1916,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path5.resolve(baseDir, baseName);
-          if (fs9.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path5.extname(baseName))) return void 0;
+          const localBin = path11.resolve(baseDir, baseName);
+          if (fs15.existsSync(localBin)) return localBin;
+          if (sourceExt.includes(path11.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs9.existsSync(`${localBin}${ext}`)
+            (ext) => fs15.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -1932,21 +1932,21 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs9.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs15.realpathSync(this._scriptPath);
           } catch (err) {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path5.resolve(
-            path5.dirname(resolvedScriptPath),
+          executableDir = path11.resolve(
+            path11.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path5.basename(
+            const legacyName = path11.basename(
               this._scriptPath,
-              path5.extname(this._scriptPath)
+              path11.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -1957,7 +1957,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path5.extname(executableFile));
+        launchWithNode = sourceExt.includes(path11.extname(executableFile));
         let proc;
         if (process10.platform !== "win32") {
           if (launchWithNode) {
@@ -2797,7 +2797,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path5.basename(filename, path5.extname(filename));
+        this._name = path11.basename(filename, path11.extname(filename));
         return this;
       }
       /**
@@ -2811,9 +2811,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path6) {
-        if (path6 === void 0) return this._executableDir;
-        this._executableDir = path6;
+      executableDir(path12) {
+        if (path12 === void 0) return this._executableDir;
+        this._executableDir = path12;
         return this;
       }
       /**
@@ -4744,54 +4744,54 @@ var require_polyfills = __commonJS({
     }
     var chdir;
     module2.exports = patch;
-    function patch(fs9) {
+    function patch(fs15) {
       if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-        patchLchmod(fs9);
-      }
-      if (!fs9.lutimes) {
-        patchLutimes(fs9);
-      }
-      fs9.chown = chownFix(fs9.chown);
-      fs9.fchown = chownFix(fs9.fchown);
-      fs9.lchown = chownFix(fs9.lchown);
-      fs9.chmod = chmodFix(fs9.chmod);
-      fs9.fchmod = chmodFix(fs9.fchmod);
-      fs9.lchmod = chmodFix(fs9.lchmod);
-      fs9.chownSync = chownFixSync(fs9.chownSync);
-      fs9.fchownSync = chownFixSync(fs9.fchownSync);
-      fs9.lchownSync = chownFixSync(fs9.lchownSync);
-      fs9.chmodSync = chmodFixSync(fs9.chmodSync);
-      fs9.fchmodSync = chmodFixSync(fs9.fchmodSync);
-      fs9.lchmodSync = chmodFixSync(fs9.lchmodSync);
-      fs9.stat = statFix(fs9.stat);
-      fs9.fstat = statFix(fs9.fstat);
-      fs9.lstat = statFix(fs9.lstat);
-      fs9.statSync = statFixSync(fs9.statSync);
-      fs9.fstatSync = statFixSync(fs9.fstatSync);
-      fs9.lstatSync = statFixSync(fs9.lstatSync);
-      if (fs9.chmod && !fs9.lchmod) {
-        fs9.lchmod = function(path5, mode, cb) {
+        patchLchmod(fs15);
+      }
+      if (!fs15.lutimes) {
+        patchLutimes(fs15);
+      }
+      fs15.chown = chownFix(fs15.chown);
+      fs15.fchown = chownFix(fs15.fchown);
+      fs15.lchown = chownFix(fs15.lchown);
+      fs15.chmod = chmodFix(fs15.chmod);
+      fs15.fchmod = chmodFix(fs15.fchmod);
+      fs15.lchmod = chmodFix(fs15.lchmod);
+      fs15.chownSync = chownFixSync(fs15.chownSync);
+      fs15.fchownSync = chownFixSync(fs15.fchownSync);
+      fs15.lchownSync = chownFixSync(fs15.lchownSync);
+      fs15.chmodSync = chmodFixSync(fs15.chmodSync);
+      fs15.fchmodSync = chmodFixSync(fs15.fchmodSync);
+      fs15.lchmodSync = chmodFixSync(fs15.lchmodSync);
+      fs15.stat = statFix(fs15.stat);
+      fs15.fstat = statFix(fs15.fstat);
+      fs15.lstat = statFix(fs15.lstat);
+      fs15.statSync = statFixSync(fs15.statSync);
+      fs15.fstatSync = statFixSync(fs15.fstatSync);
+      fs15.lstatSync = statFixSync(fs15.lstatSync);
+      if (fs15.chmod && !fs15.lchmod) {
+        fs15.lchmod = function(path11, mode, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs9.lchmodSync = function() {
+        fs15.lchmodSync = function() {
         };
       }
-      if (fs9.chown && !fs9.lchown) {
-        fs9.lchown = function(path5, uid, gid, cb) {
+      if (fs15.chown && !fs15.lchown) {
+        fs15.lchown = function(path11, uid, gid, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs9.lchownSync = function() {
+        fs15.lchownSync = function() {
         };
       }
       if (platform === "win32") {
-        fs9.rename = typeof fs9.rename !== "function" ? fs9.rename : (function(fs$rename) {
+        fs15.rename = typeof fs15.rename !== "function" ? fs15.rename : (function(fs$rename) {
           function rename(from, to, cb) {
             var start = Date.now();
             var backoff = 0;
             fs$rename(from, to, function CB(er) {
               if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 6e4) {
                 setTimeout(function() {
-                  fs9.stat(to, function(stater, st) {
+                  fs15.stat(to, function(stater, st) {
                     if (stater && stater.code === "ENOENT")
                       fs$rename(from, to, CB);
                     else
@@ -4807,9 +4807,9 @@ var require_polyfills = __commonJS({
           }
           if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
           return rename;
-        })(fs9.rename);
+        })(fs15.rename);
       }
-      fs9.read = typeof fs9.read !== "function" ? fs9.read : (function(fs$read) {
+      fs15.read = typeof fs15.read !== "function" ? fs15.read : (function(fs$read) {
         function read(fd, buffer, offset, length, position, callback_) {
           var callback;
           if (callback_ && typeof callback_ === "function") {
@@ -4817,22 +4817,22 @@ var require_polyfills = __commonJS({
             callback = function(er, _, __) {
               if (er && er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
-                return fs$read.call(fs9, fd, buffer, offset, length, position, callback);
+                return fs$read.call(fs15, fd, buffer, offset, length, position, callback);
               }
               callback_.apply(this, arguments);
             };
           }
-          return fs$read.call(fs9, fd, buffer, offset, length, position, callback);
+          return fs$read.call(fs15, fd, buffer, offset, length, position, callback);
         }
         if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
         return read;
-      })(fs9.read);
-      fs9.readSync = typeof fs9.readSync !== "function" ? fs9.readSync : /* @__PURE__ */ (function(fs$readSync) {
+      })(fs15.read);
+      fs15.readSync = typeof fs15.readSync !== "function" ? fs15.readSync : /* @__PURE__ */ (function(fs$readSync) {
         return function(fd, buffer, offset, length, position) {
           var eagCounter = 0;
           while (true) {
             try {
-              return fs$readSync.call(fs9, fd, buffer, offset, length, position);
+              return fs$readSync.call(fs15, fd, buffer, offset, length, position);
             } catch (er) {
               if (er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
@@ -4842,11 +4842,11 @@ var require_polyfills = __commonJS({
             }
           }
         };
-      })(fs9.readSync);
-      function patchLchmod(fs10) {
-        fs10.lchmod = function(path5, mode, callback) {
-          fs10.open(
-            path5,
+      })(fs15.readSync);
+      function patchLchmod(fs16) {
+        fs16.lchmod = function(path11, mode, callback) {
+          fs16.open(
+            path11,
             constants.O_WRONLY | constants.O_SYMLINK,
             mode,
             function(err, fd) {
@@ -4854,80 +4854,80 @@ var require_polyfills = __commonJS({
                 if (callback) callback(err);
                 return;
               }
-              fs10.fchmod(fd, mode, function(err2) {
-                fs10.close(fd, function(err22) {
+              fs16.fchmod(fd, mode, function(err2) {
+                fs16.close(fd, function(err22) {
                   if (callback) callback(err2 || err22);
                 });
               });
             }
           );
         };
-        fs10.lchmodSync = function(path5, mode) {
-          var fd = fs10.openSync(path5, constants.O_WRONLY | constants.O_SYMLINK, mode);
+        fs16.lchmodSync = function(path11, mode) {
+          var fd = fs16.openSync(path11, constants.O_WRONLY | constants.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
-            ret = fs10.fchmodSync(fd, mode);
+            ret = fs16.fchmodSync(fd, mode);
             threw = false;
           } finally {
             if (threw) {
               try {
-                fs10.closeSync(fd);
+                fs16.closeSync(fd);
               } catch (er) {
               }
             } else {
-              fs10.closeSync(fd);
+              fs16.closeSync(fd);
             }
           }
           return ret;
         };
       }
-      function patchLutimes(fs10) {
-        if (constants.hasOwnProperty("O_SYMLINK") && fs10.futimes) {
-          fs10.lutimes = function(path5, at, mt, cb) {
-            fs10.open(path5, constants.O_SYMLINK, function(er, fd) {
+      function patchLutimes(fs16) {
+        if (constants.hasOwnProperty("O_SYMLINK") && fs16.futimes) {
+          fs16.lutimes = function(path11, at, mt, cb) {
+            fs16.open(path11, constants.O_SYMLINK, function(er, fd) {
               if (er) {
                 if (cb) cb(er);
                 return;
               }
-              fs10.futimes(fd, at, mt, function(er2) {
-                fs10.close(fd, function(er22) {
+              fs16.futimes(fd, at, mt, function(er2) {
+                fs16.close(fd, function(er22) {
                   if (cb) cb(er2 || er22);
                 });
               });
             });
           };
-          fs10.lutimesSync = function(path5, at, mt) {
-            var fd = fs10.openSync(path5, constants.O_SYMLINK);
+          fs16.lutimesSync = function(path11, at, mt) {
+            var fd = fs16.openSync(path11, constants.O_SYMLINK);
             var ret;
             var threw = true;
             try {
-              ret = fs10.futimesSync(fd, at, mt);
+              ret = fs16.futimesSync(fd, at, mt);
               threw = false;
             } finally {
               if (threw) {
                 try {
-                  fs10.closeSync(fd);
+                  fs16.closeSync(fd);
                 } catch (er) {
                 }
               } else {
-                fs10.closeSync(fd);
+                fs16.closeSync(fd);
               }
             }
             return ret;
           };
-        } else if (fs10.futimes) {
-          fs10.lutimes = function(_a, _b, _c, cb) {
+        } else if (fs16.futimes) {
+          fs16.lutimes = function(_a, _b, _c, cb) {
             if (cb) process.nextTick(cb);
           };
-          fs10.lutimesSync = function() {
+          fs16.lutimesSync = function() {
           };
         }
       }
       function chmodFix(orig) {
         if (!orig) return orig;
         return function(target, mode, cb) {
-          return orig.call(fs9, target, mode, function(er) {
+          return orig.call(fs15, target, mode, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -4937,7 +4937,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, mode) {
           try {
-            return orig.call(fs9, target, mode);
+            return orig.call(fs15, target, mode);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -4946,7 +4946,7 @@ var require_polyfills = __commonJS({
       function chownFix(orig) {
         if (!orig) return orig;
         return function(target, uid, gid, cb) {
-          return orig.call(fs9, target, uid, gid, function(er) {
+          return orig.call(fs15, target, uid, gid, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -4956,7 +4956,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, uid, gid) {
           try {
-            return orig.call(fs9, target, uid, gid);
+            return orig.call(fs15, target, uid, gid);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -4976,13 +4976,13 @@ var require_polyfills = __commonJS({
             }
             if (cb) cb.apply(this, arguments);
           }
-          return options ? orig.call(fs9, target, options, callback) : orig.call(fs9, target, callback);
+          return options ? orig.call(fs15, target, options, callback) : orig.call(fs15, target, callback);
         };
       }
       function statFixSync(orig) {
         if (!orig) return orig;
         return function(target, options) {
-          var stats = options ? orig.call(fs9, target, options) : orig.call(fs9, target);
+          var stats = options ? orig.call(fs15, target, options) : orig.call(fs15, target);
           if (stats) {
             if (stats.uid < 0) stats.uid += 4294967296;
             if (stats.gid < 0) stats.gid += 4294967296;
@@ -5012,16 +5012,16 @@ var require_legacy_streams = __commonJS({
     "use strict";
     var Stream = require("stream").Stream;
     module2.exports = legacy;
-    function legacy(fs9) {
+    function legacy(fs15) {
       return {
         ReadStream,
         WriteStream
       };
-      function ReadStream(path5, options) {
-        if (!(this instanceof ReadStream)) return new ReadStream(path5, options);
+      function ReadStream(path11, options) {
+        if (!(this instanceof ReadStream)) return new ReadStream(path11, options);
         Stream.call(this);
         var self = this;
-        this.path = path5;
+        this.path = path11;
         this.fd = null;
         this.readable = true;
         this.paused = false;
@@ -5055,7 +5055,7 @@ var require_legacy_streams = __commonJS({
           });
           return;
         }
-        fs9.open(this.path, this.flags, this.mode, function(err, fd) {
+        fs15.open(this.path, this.flags, this.mode, function(err, fd) {
           if (err) {
             self.emit("error", err);
             self.readable = false;
@@ -5066,10 +5066,10 @@ var require_legacy_streams = __commonJS({
           self._read();
         });
       }
-      function WriteStream(path5, options) {
-        if (!(this instanceof WriteStream)) return new WriteStream(path5, options);
+      function WriteStream(path11, options) {
+        if (!(this instanceof WriteStream)) return new WriteStream(path11, options);
         Stream.call(this);
-        this.path = path5;
+        this.path = path11;
         this.fd = null;
         this.writable = true;
         this.flags = "w";
@@ -5094,7 +5094,7 @@ var require_legacy_streams = __commonJS({
         this.busy = false;
         this._queue = [];
         if (this.fd === null) {
-          this._open = fs9.open;
+          this._open = fs15.open;
           this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
           this.flush();
         }
@@ -5130,7 +5130,7 @@ var require_clone = __commonJS({
 var require_graceful_fs = __commonJS({
   "node_modules/graceful-fs/graceful-fs.js"(exports2, module2) {
     "use strict";
-    var fs9 = require("fs");
+    var fs15 = require("fs");
     var polyfills = require_polyfills();
     var legacy = require_legacy_streams();
     var clone = require_clone();
@@ -5162,12 +5162,12 @@ var require_graceful_fs = __commonJS({
         m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
         console.error(m);
       };
-    if (!fs9[gracefulQueue]) {
+    if (!fs15[gracefulQueue]) {
       queue = global[gracefulQueue] || [];
-      publishQueue(fs9, queue);
-      fs9.close = (function(fs$close) {
+      publishQueue(fs15, queue);
+      fs15.close = (function(fs$close) {
         function close(fd, cb) {
-          return fs$close.call(fs9, fd, function(err) {
+          return fs$close.call(fs15, fd, function(err) {
             if (!err) {
               resetQueue();
             }
@@ -5179,48 +5179,48 @@ var require_graceful_fs = __commonJS({
           value: fs$close
         });
         return close;
-      })(fs9.close);
-      fs9.closeSync = (function(fs$closeSync) {
+      })(fs15.close);
+      fs15.closeSync = (function(fs$closeSync) {
         function closeSync(fd) {
-          fs$closeSync.apply(fs9, arguments);
+          fs$closeSync.apply(fs15, arguments);
           resetQueue();
         }
         Object.defineProperty(closeSync, previousSymbol, {
           value: fs$closeSync
         });
         return closeSync;
-      })(fs9.closeSync);
+      })(fs15.closeSync);
       if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
         process.on("exit", function() {
-          debug(fs9[gracefulQueue]);
-          require("assert").equal(fs9[gracefulQueue].length, 0);
+          debug(fs15[gracefulQueue]);
+          require("assert").equal(fs15[gracefulQueue].length, 0);
         });
       }
     }
     var queue;
     if (!global[gracefulQueue]) {
-      publishQueue(global, fs9[gracefulQueue]);
-    }
-    module2.exports = patch(clone(fs9));
-    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs9.__patched) {
-      module2.exports = patch(fs9);
-      fs9.__patched = true;
-    }
-    function patch(fs10) {
-      polyfills(fs10);
-      fs10.gracefulify = patch;
-      fs10.createReadStream = createReadStream;
-      fs10.createWriteStream = createWriteStream;
-      var fs$readFile = fs10.readFile;
-      fs10.readFile = readFile;
-      function readFile(path5, options, cb) {
+      publishQueue(global, fs15[gracefulQueue]);
+    }
+    module2.exports = patch(clone(fs15));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs15.__patched) {
+      module2.exports = patch(fs15);
+      fs15.__patched = true;
+    }
+    function patch(fs16) {
+      polyfills(fs16);
+      fs16.gracefulify = patch;
+      fs16.createReadStream = createReadStream;
+      fs16.createWriteStream = createWriteStream;
+      var fs$readFile = fs16.readFile;
+      fs16.readFile = readFile;
+      function readFile(path11, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$readFile(path5, options, cb);
-        function go$readFile(path6, options2, cb2, startTime) {
-          return fs$readFile(path6, options2, function(err) {
+        return go$readFile(path11, options, cb);
+        function go$readFile(path12, options2, cb2, startTime) {
+          return fs$readFile(path12, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$readFile, [path6, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$readFile, [path12, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -5228,16 +5228,16 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$writeFile = fs10.writeFile;
-      fs10.writeFile = writeFile;
-      function writeFile(path5, data, options, cb) {
+      var fs$writeFile = fs16.writeFile;
+      fs16.writeFile = writeFile;
+      function writeFile(path11, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$writeFile(path5, data, options, cb);
-        function go$writeFile(path6, data2, options2, cb2, startTime) {
-          return fs$writeFile(path6, data2, options2, function(err) {
+        return go$writeFile(path11, data, options, cb);
+        function go$writeFile(path12, data2, options2, cb2, startTime) {
+          return fs$writeFile(path12, data2, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$writeFile, [path6, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$writeFile, [path12, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -5245,17 +5245,17 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$appendFile = fs10.appendFile;
+      var fs$appendFile = fs16.appendFile;
       if (fs$appendFile)
-        fs10.appendFile = appendFile;
-      function appendFile(path5, data, options, cb) {
+        fs16.appendFile = appendFile;
+      function appendFile(path11, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$appendFile(path5, data, options, cb);
-        function go$appendFile(path6, data2, options2, cb2, startTime) {
-          return fs$appendFile(path6, data2, options2, function(err) {
+        return go$appendFile(path11, data, options, cb);
+        function go$appendFile(path12, data2, options2, cb2, startTime) {
+          return fs$appendFile(path12, data2, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$appendFile, [path6, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$appendFile, [path12, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -5263,9 +5263,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$copyFile = fs10.copyFile;
+      var fs$copyFile = fs16.copyFile;
       if (fs$copyFile)
-        fs10.copyFile = copyFile;
+        fs16.copyFile = copyFile;
       function copyFile(src, dest, flags, cb) {
         if (typeof flags === "function") {
           cb = flags;
@@ -5283,34 +5283,34 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$readdir = fs10.readdir;
-      fs10.readdir = readdir;
+      var fs$readdir = fs16.readdir;
+      fs16.readdir = readdir;
       var noReaddirOptionVersions = /^v[0-5]\./;
-      function readdir(path5, options, cb) {
+      function readdir(path11, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path6, options2, cb2, startTime) {
-          return fs$readdir(path6, fs$readdirCallback(
-            path6,
+        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path12, options2, cb2, startTime) {
+          return fs$readdir(path12, fs$readdirCallback(
+            path12,
             options2,
             cb2,
             startTime
           ));
-        } : function go$readdir2(path6, options2, cb2, startTime) {
-          return fs$readdir(path6, options2, fs$readdirCallback(
-            path6,
+        } : function go$readdir2(path12, options2, cb2, startTime) {
+          return fs$readdir(path12, options2, fs$readdirCallback(
+            path12,
             options2,
             cb2,
             startTime
           ));
         };
-        return go$readdir(path5, options, cb);
-        function fs$readdirCallback(path6, options2, cb2, startTime) {
+        return go$readdir(path11, options, cb);
+        function fs$readdirCallback(path12, options2, cb2, startTime) {
           return function(err, files) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
               enqueue([
                 go$readdir,
-                [path6, options2, cb2],
+                [path12, options2, cb2],
                 err,
                 startTime || Date.now(),
                 Date.now()
@@ -5325,21 +5325,21 @@ var require_graceful_fs = __commonJS({
         }
       }
       if (process.version.substr(0, 4) === "v0.8") {
-        var legStreams = legacy(fs10);
+        var legStreams = legacy(fs16);
         ReadStream = legStreams.ReadStream;
         WriteStream = legStreams.WriteStream;
       }
-      var fs$ReadStream = fs10.ReadStream;
+      var fs$ReadStream = fs16.ReadStream;
       if (fs$ReadStream) {
         ReadStream.prototype = Object.create(fs$ReadStream.prototype);
         ReadStream.prototype.open = ReadStream$open;
       }
-      var fs$WriteStream = fs10.WriteStream;
+      var fs$WriteStream = fs16.WriteStream;
       if (fs$WriteStream) {
         WriteStream.prototype = Object.create(fs$WriteStream.prototype);
         WriteStream.prototype.open = WriteStream$open;
       }
-      Object.defineProperty(fs10, "ReadStream", {
+      Object.defineProperty(fs16, "ReadStream", {
         get: function() {
           return ReadStream;
         },
@@ -5349,7 +5349,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      Object.defineProperty(fs10, "WriteStream", {
+      Object.defineProperty(fs16, "WriteStream", {
         get: function() {
           return WriteStream;
         },
@@ -5360,7 +5360,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileReadStream = ReadStream;
-      Object.defineProperty(fs10, "FileReadStream", {
+      Object.defineProperty(fs16, "FileReadStream", {
         get: function() {
           return FileReadStream;
         },
@@ -5371,7 +5371,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileWriteStream = WriteStream;
-      Object.defineProperty(fs10, "FileWriteStream", {
+      Object.defineProperty(fs16, "FileWriteStream", {
         get: function() {
           return FileWriteStream;
         },
@@ -5381,7 +5381,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      function ReadStream(path5, options) {
+      function ReadStream(path11, options) {
         if (this instanceof ReadStream)
           return fs$ReadStream.apply(this, arguments), this;
         else
@@ -5401,7 +5401,7 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function WriteStream(path5, options) {
+      function WriteStream(path11, options) {
         if (this instanceof WriteStream)
           return fs$WriteStream.apply(this, arguments), this;
         else
@@ -5419,22 +5419,22 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function createReadStream(path5, options) {
-        return new fs10.ReadStream(path5, options);
+      function createReadStream(path11, options) {
+        return new fs16.ReadStream(path11, options);
       }
-      function createWriteStream(path5, options) {
-        return new fs10.WriteStream(path5, options);
+      function createWriteStream(path11, options) {
+        return new fs16.WriteStream(path11, options);
       }
-      var fs$open = fs10.open;
-      fs10.open = open;
-      function open(path5, flags, mode, cb) {
+      var fs$open = fs16.open;
+      fs16.open = open;
+      function open(path11, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
-        return go$open(path5, flags, mode, cb);
-        function go$open(path6, flags2, mode2, cb2, startTime) {
-          return fs$open(path6, flags2, mode2, function(err, fd) {
+        return go$open(path11, flags, mode, cb);
+        function go$open(path12, flags2, mode2, cb2, startTime) {
+          return fs$open(path12, flags2, mode2, function(err, fd) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$open, [path6, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$open, [path12, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -5442,20 +5442,20 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      return fs10;
+      return fs16;
     }
     function enqueue(elem) {
       debug("ENQUEUE", elem[0].name, elem[1]);
-      fs9[gracefulQueue].push(elem);
+      fs15[gracefulQueue].push(elem);
       retry();
     }
     var retryTimer;
     function resetQueue() {
       var now = Date.now();
-      for (var i = 0; i < fs9[gracefulQueue].length; ++i) {
-        if (fs9[gracefulQueue][i].length > 2) {
-          fs9[gracefulQueue][i][3] = now;
-          fs9[gracefulQueue][i][4] = now;
+      for (var i = 0; i < fs15[gracefulQueue].length; ++i) {
+        if (fs15[gracefulQueue][i].length > 2) {
+          fs15[gracefulQueue][i][3] = now;
+          fs15[gracefulQueue][i][4] = now;
         }
       }
       retry();
@@ -5463,9 +5463,9 @@ var require_graceful_fs = __commonJS({
     function retry() {
       clearTimeout(retryTimer);
       retryTimer = void 0;
-      if (fs9[gracefulQueue].length === 0)
+      if (fs15[gracefulQueue].length === 0)
         return;
-      var elem = fs9[gracefulQueue].shift();
+      var elem = fs15[gracefulQueue].shift();
       var fn = elem[0];
       var args = elem[1];
       var err = elem[2];
@@ -5487,7 +5487,7 @@ var require_graceful_fs = __commonJS({
           debug("RETRY", fn.name, args);
           fn.apply(null, args.concat([startTime]));
         } else {
-          fs9[gracefulQueue].push(elem);
+          fs15[gracefulQueue].push(elem);
         }
       }
       if (retryTimer === void 0) {
@@ -5502,7 +5502,7 @@ var require_fs = __commonJS({
   "node_modules/fs-extra/lib/fs/index.js"(exports2) {
     "use strict";
     var u = require_universalify().fromCallback;
-    var fs9 = require_graceful_fs();
+    var fs15 = require_graceful_fs();
     var api = [
       "access",
       "appendFile",
@@ -5543,26 +5543,26 @@ var require_fs = __commonJS({
       "utimes",
       "writeFile"
     ].filter((key) => {
-      return typeof fs9[key] === "function";
+      return typeof fs15[key] === "function";
     });
-    Object.assign(exports2, fs9);
+    Object.assign(exports2, fs15);
     api.forEach((method) => {
-      exports2[method] = u(fs9[method]);
+      exports2[method] = u(fs15[method]);
     });
     exports2.exists = function(filename, callback) {
       if (typeof callback === "function") {
-        return fs9.exists(filename, callback);
+        return fs15.exists(filename, callback);
       }
       return new Promise((resolve) => {
-        return fs9.exists(filename, resolve);
+        return fs15.exists(filename, resolve);
       });
     };
     exports2.read = function(fd, buffer, offset, length, position, callback) {
       if (typeof callback === "function") {
-        return fs9.read(fd, buffer, offset, length, position, callback);
+        return fs15.read(fd, buffer, offset, length, position, callback);
       }
       return new Promise((resolve, reject) => {
-        fs9.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
+        fs15.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
           if (err) return reject(err);
           resolve({ bytesRead, buffer: buffer2 });
         });
@@ -5570,10 +5570,10 @@ var require_fs = __commonJS({
     };
     exports2.write = function(fd, buffer, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs9.write(fd, buffer, ...args);
+        return fs15.write(fd, buffer, ...args);
       }
       return new Promise((resolve, reject) => {
-        fs9.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
+        fs15.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
           if (err) return reject(err);
           resolve({ bytesWritten, buffer: buffer2 });
         });
@@ -5581,10 +5581,10 @@ var require_fs = __commonJS({
     };
     exports2.readv = function(fd, buffers, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs9.readv(fd, buffers, ...args);
+        return fs15.readv(fd, buffers, ...args);
       }
       return new Promise((resolve, reject) => {
-        fs9.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
+        fs15.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
           if (err) return reject(err);
           resolve({ bytesRead, buffers: buffers2 });
         });
@@ -5592,17 +5592,17 @@ var require_fs = __commonJS({
     };
     exports2.writev = function(fd, buffers, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs9.writev(fd, buffers, ...args);
+        return fs15.writev(fd, buffers, ...args);
       }
       return new Promise((resolve, reject) => {
-        fs9.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
+        fs15.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
           if (err) return reject(err);
           resolve({ bytesWritten, buffers: buffers2 });
         });
       });
     };
-    if (typeof fs9.realpath.native === "function") {
-      exports2.realpath.native = u(fs9.realpath.native);
+    if (typeof fs15.realpath.native === "function") {
+      exports2.realpath.native = u(fs15.realpath.native);
     } else {
       process.emitWarning(
         "fs.realpath.native is not a function. Is fs being monkey-patched?",
@@ -5617,10 +5617,10 @@ var require_fs = __commonJS({
 var require_utils = __commonJS({
   "node_modules/fs-extra/lib/mkdirs/utils.js"(exports2, module2) {
     "use strict";
-    var path5 = require("path");
+    var path11 = require("path");
     module2.exports.checkPath = function checkPath(pth) {
       if (process.platform === "win32") {
-        const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path5.parse(pth).root, ""));
+        const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path11.parse(pth).root, ""));
         if (pathHasInvalidWinCharacters) {
           const error = new Error(`Path contains invalid characters: ${pth}`);
           error.code = "EINVAL";
@@ -5635,7 +5635,7 @@ var require_utils = __commonJS({
 var require_make_dir = __commonJS({
   "node_modules/fs-extra/lib/mkdirs/make-dir.js"(exports2, module2) {
     "use strict";
-    var fs9 = require_fs();
+    var fs15 = require_fs();
     var { checkPath } = require_utils();
     var getMode = (options) => {
       const defaults = { mode: 511 };
@@ -5644,14 +5644,14 @@ var require_make_dir = __commonJS({
     };
     module2.exports.makeDir = async (dir, options) => {
       checkPath(dir);
-      return fs9.mkdir(dir, {
+      return fs15.mkdir(dir, {
         mode: getMode(options),
         recursive: true
       });
     };
     module2.exports.makeDirSync = (dir, options) => {
       checkPath(dir);
-      return fs9.mkdirSync(dir, {
+      return fs15.mkdirSync(dir, {
         mode: getMode(options),
         recursive: true
       });
@@ -5683,13 +5683,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 fs9 = require_fs();
-    function pathExists(path5) {
-      return fs9.access(path5).then(() => true).catch(() => false);
+    var fs15 = require_fs();
+    function pathExists(path11) {
+      return fs15.access(path11).then(() => true).catch(() => false);
     }
     module2.exports = {
       pathExists: u(pathExists),
-      pathExistsSync: fs9.existsSync
+      pathExistsSync: fs15.existsSync
     };
   }
 });
@@ -5698,18 +5698,18 @@ var require_path_exists = __commonJS({
 var require_utimes = __commonJS({
   "node_modules/fs-extra/lib/util/utimes.js"(exports2, module2) {
     "use strict";
-    var fs9 = require_fs();
+    var fs15 = require_fs();
     var u = require_universalify().fromPromise;
-    async function utimesMillis(path5, atime, mtime) {
-      const fd = await fs9.open(path5, "r+");
+    async function utimesMillis(path11, atime, mtime) {
+      const fd = await fs15.open(path11, "r+");
       let error = null;
       try {
-        await fs9.futimes(fd, atime, mtime);
+        await fs15.futimes(fd, atime, mtime);
       } catch (futimesErr) {
         error = futimesErr;
       } finally {
         try {
-          await fs9.close(fd);
+          await fs15.close(fd);
         } catch (closeErr) {
           if (!error) error = closeErr;
         }
@@ -5718,16 +5718,16 @@ var require_utimes = __commonJS({
         throw error;
       }
     }
-    function utimesMillisSync(path5, atime, mtime) {
-      const fd = fs9.openSync(path5, "r+");
+    function utimesMillisSync(path11, atime, mtime) {
+      const fd = fs15.openSync(path11, "r+");
       let error = null;
       try {
-        fs9.futimesSync(fd, atime, mtime);
+        fs15.futimesSync(fd, atime, mtime);
       } catch (futimesErr) {
         error = futimesErr;
       } finally {
         try {
-          fs9.closeSync(fd);
+          fs15.closeSync(fd);
         } catch (closeErr) {
           if (!error) error = closeErr;
         }
@@ -5747,11 +5747,11 @@ var require_utimes = __commonJS({
 var require_stat = __commonJS({
   "node_modules/fs-extra/lib/util/stat.js"(exports2, module2) {
     "use strict";
-    var fs9 = require_fs();
-    var path5 = require("path");
+    var fs15 = require_fs();
+    var path11 = require("path");
     var u = require_universalify().fromPromise;
     function getStats(src, dest, opts) {
-      const statFunc = opts.dereference ? (file) => fs9.stat(file, { bigint: true }) : (file) => fs9.lstat(file, { bigint: true });
+      const statFunc = opts.dereference ? (file) => fs15.stat(file, { bigint: true }) : (file) => fs15.lstat(file, { bigint: true });
       return Promise.all([
         statFunc(src),
         statFunc(dest).catch((err) => {
@@ -5762,7 +5762,7 @@ var require_stat = __commonJS({
     }
     function getStatsSync(src, dest, opts) {
       let destStat;
-      const statFunc = opts.dereference ? (file) => fs9.statSync(file, { bigint: true }) : (file) => fs9.lstatSync(file, { bigint: true });
+      const statFunc = opts.dereference ? (file) => fs15.statSync(file, { bigint: true }) : (file) => fs15.lstatSync(file, { bigint: true });
       const srcStat = statFunc(src);
       try {
         destStat = statFunc(dest);
@@ -5776,8 +5776,8 @@ var require_stat = __commonJS({
       const { srcStat, destStat } = await getStats(src, dest, opts);
       if (destStat) {
         if (areIdentical(srcStat, destStat)) {
-          const srcBaseName = path5.basename(src);
-          const destBaseName = path5.basename(dest);
+          const srcBaseName = path11.basename(src);
+          const destBaseName = path11.basename(dest);
           if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
             return { srcStat, destStat, isChangingCase: true };
           }
@@ -5799,8 +5799,8 @@ var require_stat = __commonJS({
       const { srcStat, destStat } = getStatsSync(src, dest, opts);
       if (destStat) {
         if (areIdentical(srcStat, destStat)) {
-          const srcBaseName = path5.basename(src);
-          const destBaseName = path5.basename(dest);
+          const srcBaseName = path11.basename(src);
+          const destBaseName = path11.basename(dest);
           if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
             return { srcStat, destStat, isChangingCase: true };
           }
@@ -5819,12 +5819,12 @@ var require_stat = __commonJS({
       return { srcStat, destStat };
     }
     async function checkParentPaths(src, srcStat, dest, funcName) {
-      const srcParent = path5.resolve(path5.dirname(src));
-      const destParent = path5.resolve(path5.dirname(dest));
-      if (destParent === srcParent || destParent === path5.parse(destParent).root) return;
+      const srcParent = path11.resolve(path11.dirname(src));
+      const destParent = path11.resolve(path11.dirname(dest));
+      if (destParent === srcParent || destParent === path11.parse(destParent).root) return;
       let destStat;
       try {
-        destStat = await fs9.stat(destParent, { bigint: true });
+        destStat = await fs15.stat(destParent, { bigint: true });
       } catch (err) {
         if (err.code === "ENOENT") return;
         throw err;
@@ -5835,12 +5835,12 @@ var require_stat = __commonJS({
       return checkParentPaths(src, srcStat, destParent, funcName);
     }
     function checkParentPathsSync(src, srcStat, dest, funcName) {
-      const srcParent = path5.resolve(path5.dirname(src));
-      const destParent = path5.resolve(path5.dirname(dest));
-      if (destParent === srcParent || destParent === path5.parse(destParent).root) return;
+      const srcParent = path11.resolve(path11.dirname(src));
+      const destParent = path11.resolve(path11.dirname(dest));
+      if (destParent === srcParent || destParent === path11.parse(destParent).root) return;
       let destStat;
       try {
-        destStat = fs9.statSync(destParent, { bigint: true });
+        destStat = fs15.statSync(destParent, { bigint: true });
       } catch (err) {
         if (err.code === "ENOENT") return;
         throw err;
@@ -5854,8 +5854,8 @@ var require_stat = __commonJS({
       return destStat.ino !== void 0 && destStat.dev !== void 0 && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev;
     }
     function isSrcSubdir(src, dest) {
-      const srcArr = path5.resolve(src).split(path5.sep).filter((i) => i);
-      const destArr = path5.resolve(dest).split(path5.sep).filter((i) => i);
+      const srcArr = path11.resolve(src).split(path11.sep).filter((i) => i);
+      const destArr = path11.resolve(dest).split(path11.sep).filter((i) => i);
       return srcArr.every((cur, i) => destArr[i] === cur);
     }
     function errMsg(src, dest, funcName) {
@@ -5907,8 +5907,8 @@ var require_async = __commonJS({
 var require_copy = __commonJS({
   "node_modules/fs-extra/lib/copy/copy.js"(exports2, module2) {
     "use strict";
-    var fs9 = require_fs();
-    var path5 = require("path");
+    var fs15 = require_fs();
+    var path11 = require("path");
     var { mkdirs } = require_mkdirs();
     var { pathExists } = require_path_exists();
     var { utimesMillis } = require_utimes();
@@ -5931,7 +5931,7 @@ var require_copy = __commonJS({
       await stat.checkParentPaths(src, srcStat, dest, "copy");
       const include = await runFilter(src, dest, opts);
       if (!include) return;
-      const destParent = path5.dirname(dest);
+      const destParent = path11.dirname(dest);
       const dirExists = await pathExists(destParent);
       if (!dirExists) {
         await mkdirs(destParent);
@@ -5943,7 +5943,7 @@ var require_copy = __commonJS({
       return opts.filter(src, dest);
     }
     async function getStatsAndPerformCopy(destStat, src, dest, opts) {
-      const statFn = opts.dereference ? fs9.stat : fs9.lstat;
+      const statFn = opts.dereference ? fs15.stat : fs15.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);
@@ -5955,7 +5955,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 fs9.unlink(dest);
+        await fs15.unlink(dest);
         return copyFile(srcStat, src, dest, opts);
       }
       if (opts.errorOnExist) {
@@ -5963,29 +5963,29 @@ var require_copy = __commonJS({
       }
     }
     async function copyFile(srcStat, src, dest, opts) {
-      await fs9.copyFile(src, dest);
+      await fs15.copyFile(src, dest);
       if (opts.preserveTimestamps) {
         if (fileIsNotWritable(srcStat.mode)) {
           await makeFileWritable(dest, srcStat.mode);
         }
-        const updatedSrcStat = await fs9.stat(src);
+        const updatedSrcStat = await fs15.stat(src);
         await utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
       }
-      return fs9.chmod(dest, srcStat.mode);
+      return fs15.chmod(dest, srcStat.mode);
     }
     function fileIsNotWritable(srcMode) {
       return (srcMode & 128) === 0;
     }
     function makeFileWritable(dest, srcMode) {
-      return fs9.chmod(dest, srcMode | 128);
+      return fs15.chmod(dest, srcMode | 128);
     }
     async function onDir(srcStat, destStat, src, dest, opts) {
       if (!destStat) {
-        await fs9.mkdir(dest);
+        await fs15.mkdir(dest);
       }
-      await asyncIteratorConcurrentProcess(await fs9.opendir(src), async (item) => {
-        const srcItem = path5.join(src, item.name);
-        const destItem = path5.join(dest, item.name);
+      await asyncIteratorConcurrentProcess(await fs15.opendir(src), async (item) => {
+        const srcItem = path11.join(src, item.name);
+        const destItem = path11.join(dest, item.name);
         const include = await runFilter(srcItem, destItem, opts);
         if (include) {
           const { destStat: destStat2 } = await stat.checkPaths(srcItem, destItem, "copy", opts);
@@ -5993,26 +5993,26 @@ var require_copy = __commonJS({
         }
       });
       if (!destStat) {
-        await fs9.chmod(dest, srcStat.mode);
+        await fs15.chmod(dest, srcStat.mode);
       }
     }
     async function onLink(destStat, src, dest, opts) {
-      let resolvedSrc = await fs9.readlink(src);
+      let resolvedSrc = await fs15.readlink(src);
       if (opts.dereference) {
-        resolvedSrc = path5.resolve(process.cwd(), resolvedSrc);
+        resolvedSrc = path11.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
-        return fs9.symlink(resolvedSrc, dest);
+        return fs15.symlink(resolvedSrc, dest);
       }
       let resolvedDest = null;
       try {
-        resolvedDest = await fs9.readlink(dest);
+        resolvedDest = await fs15.readlink(dest);
       } catch (e) {
-        if (e.code === "EINVAL" || e.code === "UNKNOWN") return fs9.symlink(resolvedSrc, dest);
+        if (e.code === "EINVAL" || e.code === "UNKNOWN") return fs15.symlink(resolvedSrc, dest);
         throw e;
       }
       if (opts.dereference) {
-        resolvedDest = path5.resolve(process.cwd(), resolvedDest);
+        resolvedDest = path11.resolve(process.cwd(), resolvedDest);
       }
       if (resolvedSrc !== resolvedDest) {
         if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
@@ -6022,8 +6022,8 @@ var require_copy = __commonJS({
           throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
         }
       }
-      await fs9.unlink(dest);
-      return fs9.symlink(resolvedSrc, dest);
+      await fs15.unlink(dest);
+      return fs15.symlink(resolvedSrc, dest);
     }
     module2.exports = copy;
   }
@@ -6033,8 +6033,8 @@ var require_copy = __commonJS({
 var require_copy_sync = __commonJS({
   "node_modules/fs-extra/lib/copy/copy-sync.js"(exports2, module2) {
     "use strict";
-    var fs9 = require_graceful_fs();
-    var path5 = require("path");
+    var fs15 = require_graceful_fs();
+    var path11 = require("path");
     var mkdirsSync = require_mkdirs().mkdirsSync;
     var utimesMillisSync = require_utimes().utimesMillisSync;
     var stat = require_stat();
@@ -6055,12 +6055,12 @@ var require_copy_sync = __commonJS({
       const { srcStat, destStat } = stat.checkPathsSync(src, dest, "copy", opts);
       stat.checkParentPathsSync(src, srcStat, dest, "copy");
       if (opts.filter && !opts.filter(src, dest)) return;
-      const destParent = path5.dirname(dest);
-      if (!fs9.existsSync(destParent)) mkdirsSync(destParent);
+      const destParent = path11.dirname(dest);
+      if (!fs15.existsSync(destParent)) mkdirsSync(destParent);
       return getStats(destStat, src, dest, opts);
     }
     function getStats(destStat, src, dest, opts) {
-      const statSync = opts.dereference ? fs9.statSync : fs9.lstatSync;
+      const statSync = opts.dereference ? fs15.statSync : fs15.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);
@@ -6075,14 +6075,14 @@ var require_copy_sync = __commonJS({
     }
     function mayCopyFile(srcStat, src, dest, opts) {
       if (opts.overwrite) {
-        fs9.unlinkSync(dest);
+        fs15.unlinkSync(dest);
         return copyFile(srcStat, src, dest, opts);
       } else if (opts.errorOnExist) {
         throw new Error(`'${dest}' already exists`);
       }
     }
     function copyFile(srcStat, src, dest, opts) {
-      fs9.copyFileSync(src, dest);
+      fs15.copyFileSync(src, dest);
       if (opts.preserveTimestamps) handleTimestamps(srcStat.mode, src, dest);
       return setDestMode(dest, srcStat.mode);
     }
@@ -6097,10 +6097,10 @@ var require_copy_sync = __commonJS({
       return setDestMode(dest, srcMode | 128);
     }
     function setDestMode(dest, srcMode) {
-      return fs9.chmodSync(dest, srcMode);
+      return fs15.chmodSync(dest, srcMode);
     }
     function setDestTimestamps(src, dest) {
-      const updatedSrcStat = fs9.statSync(src);
+      const updatedSrcStat = fs15.statSync(src);
       return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
     }
     function onDir(srcStat, destStat, src, dest, opts) {
@@ -6108,12 +6108,12 @@ var require_copy_sync = __commonJS({
       return copyDir(src, dest, opts);
     }
     function mkDirAndCopy(srcMode, src, dest, opts) {
-      fs9.mkdirSync(dest);
+      fs15.mkdirSync(dest);
       copyDir(src, dest, opts);
       return setDestMode(dest, srcMode);
     }
     function copyDir(src, dest, opts) {
-      const dir = fs9.opendirSync(src);
+      const dir = fs15.opendirSync(src);
       try {
         let dirent;
         while ((dirent = dir.readSync()) !== null) {
@@ -6124,29 +6124,29 @@ var require_copy_sync = __commonJS({
       }
     }
     function copyDirItem(item, src, dest, opts) {
-      const srcItem = path5.join(src, item);
-      const destItem = path5.join(dest, item);
+      const srcItem = path11.join(src, item);
+      const destItem = path11.join(dest, item);
       if (opts.filter && !opts.filter(srcItem, destItem)) return;
       const { destStat } = stat.checkPathsSync(srcItem, destItem, "copy", opts);
       return getStats(destStat, srcItem, destItem, opts);
     }
     function onLink(destStat, src, dest, opts) {
-      let resolvedSrc = fs9.readlinkSync(src);
+      let resolvedSrc = fs15.readlinkSync(src);
       if (opts.dereference) {
-        resolvedSrc = path5.resolve(process.cwd(), resolvedSrc);
+        resolvedSrc = path11.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
-        return fs9.symlinkSync(resolvedSrc, dest);
+        return fs15.symlinkSync(resolvedSrc, dest);
       } else {
         let resolvedDest;
         try {
-          resolvedDest = fs9.readlinkSync(dest);
+          resolvedDest = fs15.readlinkSync(dest);
         } catch (err) {
-          if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs9.symlinkSync(resolvedSrc, dest);
+          if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs15.symlinkSync(resolvedSrc, dest);
           throw err;
         }
         if (opts.dereference) {
-          resolvedDest = path5.resolve(process.cwd(), resolvedDest);
+          resolvedDest = path11.resolve(process.cwd(), resolvedDest);
         }
         if (resolvedSrc !== resolvedDest) {
           if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
@@ -6160,8 +6160,8 @@ var require_copy_sync = __commonJS({
       }
     }
     function copyLink(resolvedSrc, dest) {
-      fs9.unlinkSync(dest);
-      return fs9.symlinkSync(resolvedSrc, dest);
+      fs15.unlinkSync(dest);
+      return fs15.symlinkSync(resolvedSrc, dest);
     }
     module2.exports = copySync;
   }
@@ -6183,13 +6183,13 @@ var require_copy2 = __commonJS({
 var require_remove = __commonJS({
   "node_modules/fs-extra/lib/remove/index.js"(exports2, module2) {
     "use strict";
-    var fs9 = require_graceful_fs();
+    var fs15 = require_graceful_fs();
     var u = require_universalify().fromCallback;
-    function remove(path5, callback) {
-      fs9.rm(path5, { recursive: true, force: true }, callback);
+    function remove(path11, callback) {
+      fs15.rm(path11, { recursive: true, force: true }, callback);
     }
-    function removeSync(path5) {
-      fs9.rmSync(path5, { recursive: true, force: true });
+    function removeSync(path11) {
+      fs15.rmSync(path11, { recursive: true, force: true });
     }
     module2.exports = {
       remove: u(remove),
@@ -6203,28 +6203,28 @@ var require_empty = __commonJS({
   "node_modules/fs-extra/lib/empty/index.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs9 = require_fs();
-    var path5 = require("path");
+    var fs15 = require_fs();
+    var path11 = require("path");
     var mkdir = require_mkdirs();
     var remove = require_remove();
     var emptyDir = u(async function emptyDir2(dir) {
       let items;
       try {
-        items = await fs9.readdir(dir);
+        items = await fs15.readdir(dir);
       } catch {
         return mkdir.mkdirs(dir);
       }
-      return Promise.all(items.map((item) => remove.remove(path5.join(dir, item))));
+      return Promise.all(items.map((item) => remove.remove(path11.join(dir, item))));
     });
     function emptyDirSync(dir) {
       let items;
       try {
-        items = fs9.readdirSync(dir);
+        items = fs15.readdirSync(dir);
       } catch {
         return mkdir.mkdirsSync(dir);
       }
       items.forEach((item) => {
-        item = path5.join(dir, item);
+        item = path11.join(dir, item);
         remove.removeSync(item);
       });
     }
@@ -6242,52 +6242,52 @@ var require_file = __commonJS({
   "node_modules/fs-extra/lib/ensure/file.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var path5 = require("path");
-    var fs9 = require_fs();
+    var path11 = require("path");
+    var fs15 = require_fs();
     var mkdir = require_mkdirs();
     async function createFile(file) {
       let stats;
       try {
-        stats = await fs9.stat(file);
+        stats = await fs15.stat(file);
       } catch {
       }
       if (stats && stats.isFile()) return;
-      const dir = path5.dirname(file);
+      const dir = path11.dirname(file);
       let dirStats = null;
       try {
-        dirStats = await fs9.stat(dir);
+        dirStats = await fs15.stat(dir);
       } catch (err) {
         if (err.code === "ENOENT") {
           await mkdir.mkdirs(dir);
-          await fs9.writeFile(file, "");
+          await fs15.writeFile(file, "");
           return;
         } else {
           throw err;
         }
       }
       if (dirStats.isDirectory()) {
-        await fs9.writeFile(file, "");
+        await fs15.writeFile(file, "");
       } else {
-        await fs9.readdir(dir);
+        await fs15.readdir(dir);
       }
     }
     function createFileSync(file) {
       let stats;
       try {
-        stats = fs9.statSync(file);
+        stats = fs15.statSync(file);
       } catch {
       }
       if (stats && stats.isFile()) return;
-      const dir = path5.dirname(file);
+      const dir = path11.dirname(file);
       try {
-        if (!fs9.statSync(dir).isDirectory()) {
-          fs9.readdirSync(dir);
+        if (!fs15.statSync(dir).isDirectory()) {
+          fs15.readdirSync(dir);
         }
       } catch (err) {
         if (err && err.code === "ENOENT") mkdir.mkdirsSync(dir);
         else throw err;
       }
-      fs9.writeFileSync(file, "");
+      fs15.writeFileSync(file, "");
     }
     module2.exports = {
       createFile: u(createFile),
@@ -6301,50 +6301,50 @@ var require_link = __commonJS({
   "node_modules/fs-extra/lib/ensure/link.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var path5 = require("path");
-    var fs9 = require_fs();
+    var path11 = require("path");
+    var fs15 = 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 fs9.lstat(dstpath, { bigint: true });
+        dstStat = await fs15.lstat(dstpath, { bigint: true });
       } catch {
       }
       let srcStat;
       try {
-        srcStat = await fs9.lstat(srcpath, { bigint: true });
+        srcStat = await fs15.lstat(srcpath, { bigint: true });
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureLink");
         throw err;
       }
       if (dstStat && areIdentical(srcStat, dstStat)) return;
-      const dir = path5.dirname(dstpath);
+      const dir = path11.dirname(dstpath);
       const dirExists = await pathExists(dir);
       if (!dirExists) {
         await mkdir.mkdirs(dir);
       }
-      await fs9.link(srcpath, dstpath);
+      await fs15.link(srcpath, dstpath);
     }
     function createLinkSync(srcpath, dstpath) {
       let dstStat;
       try {
-        dstStat = fs9.lstatSync(dstpath, { bigint: true });
+        dstStat = fs15.lstatSync(dstpath, { bigint: true });
       } catch {
       }
       try {
-        const srcStat = fs9.lstatSync(srcpath, { bigint: true });
+        const srcStat = fs15.lstatSync(srcpath, { bigint: true });
         if (dstStat && areIdentical(srcStat, dstStat)) return;
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureLink");
         throw err;
       }
-      const dir = path5.dirname(dstpath);
-      const dirExists = fs9.existsSync(dir);
-      if (dirExists) return fs9.linkSync(srcpath, dstpath);
+      const dir = path11.dirname(dstpath);
+      const dirExists = fs15.existsSync(dir);
+      if (dirExists) return fs15.linkSync(srcpath, dstpath);
       mkdir.mkdirsSync(dir);
-      return fs9.linkSync(srcpath, dstpath);
+      return fs15.linkSync(srcpath, dstpath);
     }
     module2.exports = {
       createLink: u(createLink),
@@ -6357,14 +6357,14 @@ var require_link = __commonJS({
 var require_symlink_paths = __commonJS({
   "node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports2, module2) {
     "use strict";
-    var path5 = require("path");
-    var fs9 = require_fs();
+    var path11 = require("path");
+    var fs15 = require_fs();
     var { pathExists } = require_path_exists();
     var u = require_universalify().fromPromise;
     async function symlinkPaths(srcpath, dstpath) {
-      if (path5.isAbsolute(srcpath)) {
+      if (path11.isAbsolute(srcpath)) {
         try {
-          await fs9.lstat(srcpath);
+          await fs15.lstat(srcpath);
         } catch (err) {
           err.message = err.message.replace("lstat", "ensureSymlink");
           throw err;
@@ -6374,8 +6374,8 @@ var require_symlink_paths = __commonJS({
           toDst: srcpath
         };
       }
-      const dstdir = path5.dirname(dstpath);
-      const relativeToDst = path5.join(dstdir, srcpath);
+      const dstdir = path11.dirname(dstpath);
+      const relativeToDst = path11.join(dstdir, srcpath);
       const exists = await pathExists(relativeToDst);
       if (exists) {
         return {
@@ -6384,39 +6384,39 @@ var require_symlink_paths = __commonJS({
         };
       }
       try {
-        await fs9.lstat(srcpath);
+        await fs15.lstat(srcpath);
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureSymlink");
         throw err;
       }
       return {
         toCwd: srcpath,
-        toDst: path5.relative(dstdir, srcpath)
+        toDst: path11.relative(dstdir, srcpath)
       };
     }
     function symlinkPathsSync(srcpath, dstpath) {
-      if (path5.isAbsolute(srcpath)) {
-        const exists2 = fs9.existsSync(srcpath);
+      if (path11.isAbsolute(srcpath)) {
+        const exists2 = fs15.existsSync(srcpath);
         if (!exists2) throw new Error("absolute srcpath does not exist");
         return {
           toCwd: srcpath,
           toDst: srcpath
         };
       }
-      const dstdir = path5.dirname(dstpath);
-      const relativeToDst = path5.join(dstdir, srcpath);
-      const exists = fs9.existsSync(relativeToDst);
+      const dstdir = path11.dirname(dstpath);
+      const relativeToDst = path11.join(dstdir, srcpath);
+      const exists = fs15.existsSync(relativeToDst);
       if (exists) {
         return {
           toCwd: relativeToDst,
           toDst: srcpath
         };
       }
-      const srcExists = fs9.existsSync(srcpath);
+      const srcExists = fs15.existsSync(srcpath);
       if (!srcExists) throw new Error("relative srcpath does not exist");
       return {
         toCwd: srcpath,
-        toDst: path5.relative(dstdir, srcpath)
+        toDst: path11.relative(dstdir, srcpath)
       };
     }
     module2.exports = {
@@ -6430,13 +6430,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 fs9 = require_fs();
+    var fs15 = require_fs();
     var u = require_universalify().fromPromise;
     async function symlinkType(srcpath, type) {
       if (type) return type;
       let stats;
       try {
-        stats = await fs9.lstat(srcpath);
+        stats = await fs15.lstat(srcpath);
       } catch {
         return "file";
       }
@@ -6446,7 +6446,7 @@ var require_symlink_type = __commonJS({
       if (type) return type;
       let stats;
       try {
-        stats = fs9.lstatSync(srcpath);
+        stats = fs15.lstatSync(srcpath);
       } catch {
         return "file";
       }
@@ -6464,8 +6464,8 @@ var require_symlink = __commonJS({
   "node_modules/fs-extra/lib/ensure/symlink.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var path5 = require("path");
-    var fs9 = require_fs();
+    var path11 = require("path");
+    var fs15 = require_fs();
     var { mkdirs, mkdirsSync } = require_mkdirs();
     var { symlinkPaths, symlinkPathsSync } = require_symlink_paths();
     var { symlinkType, symlinkTypeSync } = require_symlink_type();
@@ -6474,64 +6474,64 @@ var require_symlink = __commonJS({
     async function createSymlink(srcpath, dstpath, type) {
       let stats;
       try {
-        stats = await fs9.lstat(dstpath);
+        stats = await fs15.lstat(dstpath);
       } catch {
       }
       if (stats && stats.isSymbolicLink()) {
         let srcStat;
-        if (path5.isAbsolute(srcpath)) {
-          srcStat = await fs9.stat(srcpath, { bigint: true });
+        if (path11.isAbsolute(srcpath)) {
+          srcStat = await fs15.stat(srcpath, { bigint: true });
         } else {
-          const dstdir = path5.dirname(dstpath);
-          const relativeToDst = path5.join(dstdir, srcpath);
+          const dstdir = path11.dirname(dstpath);
+          const relativeToDst = path11.join(dstdir, srcpath);
           try {
-            srcStat = await fs9.stat(relativeToDst, { bigint: true });
+            srcStat = await fs15.stat(relativeToDst, { bigint: true });
           } catch {
-            srcStat = await fs9.stat(srcpath, { bigint: true });
+            srcStat = await fs15.stat(srcpath, { bigint: true });
           }
         }
-        const dstStat = await fs9.stat(dstpath, { bigint: true });
+        const dstStat = await fs15.stat(dstpath, { bigint: true });
         if (areIdentical(srcStat, dstStat)) return;
       }
       const relative = await symlinkPaths(srcpath, dstpath);
       srcpath = relative.toDst;
       const toType = await symlinkType(relative.toCwd, type);
-      const dir = path5.dirname(dstpath);
+      const dir = path11.dirname(dstpath);
       if (!await pathExists(dir)) {
         await mkdirs(dir);
       }
-      return fs9.symlink(srcpath, dstpath, toType);
+      return fs15.symlink(srcpath, dstpath, toType);
     }
     function createSymlinkSync(srcpath, dstpath, type) {
       let stats;
       try {
-        stats = fs9.lstatSync(dstpath);
+        stats = fs15.lstatSync(dstpath);
       } catch {
       }
       if (stats && stats.isSymbolicLink()) {
         let srcStat;
-        if (path5.isAbsolute(srcpath)) {
-          srcStat = fs9.statSync(srcpath, { bigint: true });
+        if (path11.isAbsolute(srcpath)) {
+          srcStat = fs15.statSync(srcpath, { bigint: true });
         } else {
-          const dstdir = path5.dirname(dstpath);
-          const relativeToDst = path5.join(dstdir, srcpath);
+          const dstdir = path11.dirname(dstpath);
+          const relativeToDst = path11.join(dstdir, srcpath);
           try {
-            srcStat = fs9.statSync(relativeToDst, { bigint: true });
+            srcStat = fs15.statSync(relativeToDst, { bigint: true });
           } catch {
-            srcStat = fs9.statSync(srcpath, { bigint: true });
+            srcStat = fs15.statSync(srcpath, { bigint: true });
           }
         }
-        const dstStat = fs9.statSync(dstpath, { bigint: true });
+        const dstStat = fs15.statSync(dstpath, { bigint: true });
         if (areIdentical(srcStat, dstStat)) return;
       }
       const relative = symlinkPathsSync(srcpath, dstpath);
       srcpath = relative.toDst;
       type = symlinkTypeSync(relative.toCwd, type);
-      const dir = path5.dirname(dstpath);
-      const exists = fs9.existsSync(dir);
-      if (exists) return fs9.symlinkSync(srcpath, dstpath, type);
+      const dir = path11.dirname(dstpath);
+      const exists = fs15.existsSync(dir);
+      if (exists) return fs15.symlinkSync(srcpath, dstpath, type);
       mkdirsSync(dir);
-      return fs9.symlinkSync(srcpath, dstpath, type);
+      return fs15.symlinkSync(srcpath, dstpath, type);
     }
     module2.exports = {
       createSymlink: u(createSymlink),
@@ -6603,9 +6603,9 @@ var require_jsonfile = __commonJS({
       if (typeof options === "string") {
         options = { encoding: options };
       }
-      const fs9 = options.fs || _fs;
+      const fs15 = options.fs || _fs;
       const shouldThrow = "throws" in options ? options.throws : true;
-      let data = await universalify.fromCallback(fs9.readFile)(file, options);
+      let data = await universalify.fromCallback(fs15.readFile)(file, options);
       data = stripBom(data);
       let obj;
       try {
@@ -6625,10 +6625,10 @@ var require_jsonfile = __commonJS({
       if (typeof options === "string") {
         options = { encoding: options };
       }
-      const fs9 = options.fs || _fs;
+      const fs15 = options.fs || _fs;
       const shouldThrow = "throws" in options ? options.throws : true;
       try {
-        let content = fs9.readFileSync(file, options);
+        let content = fs15.readFileSync(file, options);
         content = stripBom(content);
         return JSON.parse(content, options.reviver);
       } catch (err) {
@@ -6641,15 +6641,15 @@ var require_jsonfile = __commonJS({
       }
     }
     async function _writeFile(file, obj, options = {}) {
-      const fs9 = options.fs || _fs;
+      const fs15 = options.fs || _fs;
       const str = stringify(obj, options);
-      await universalify.fromCallback(fs9.writeFile)(file, str, options);
+      await universalify.fromCallback(fs15.writeFile)(file, str, options);
     }
     var writeFile = universalify.fromPromise(_writeFile);
     function writeFileSync(file, obj, options = {}) {
-      const fs9 = options.fs || _fs;
+      const fs15 = options.fs || _fs;
       const str = stringify(obj, options);
-      return fs9.writeFileSync(file, str, options);
+      return fs15.writeFileSync(file, str, options);
     }
     module2.exports = {
       readFile,
@@ -6680,23 +6680,23 @@ var require_output_file = __commonJS({
   "node_modules/fs-extra/lib/output-file/index.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs9 = require_fs();
-    var path5 = require("path");
+    var fs15 = require_fs();
+    var path11 = require("path");
     var mkdir = require_mkdirs();
     var pathExists = require_path_exists().pathExists;
     async function outputFile(file, data, encoding = "utf-8") {
-      const dir = path5.dirname(file);
+      const dir = path11.dirname(file);
       if (!await pathExists(dir)) {
         await mkdir.mkdirs(dir);
       }
-      return fs9.writeFile(file, data, encoding);
+      return fs15.writeFile(file, data, encoding);
     }
     function outputFileSync(file, ...args) {
-      const dir = path5.dirname(file);
-      if (!fs9.existsSync(dir)) {
+      const dir = path11.dirname(file);
+      if (!fs15.existsSync(dir)) {
         mkdir.mkdirsSync(dir);
       }
-      fs9.writeFileSync(file, ...args);
+      fs15.writeFileSync(file, ...args);
     }
     module2.exports = {
       outputFile: u(outputFile),
@@ -6755,8 +6755,8 @@ var require_json = __commonJS({
 var require_move = __commonJS({
   "node_modules/fs-extra/lib/move/move.js"(exports2, module2) {
     "use strict";
-    var fs9 = require_fs();
-    var path5 = require("path");
+    var fs15 = require_fs();
+    var path11 = require("path");
     var { copy } = require_copy2();
     var { remove } = require_remove();
     var { mkdirp } = require_mkdirs();
@@ -6766,8 +6766,8 @@ var require_move = __commonJS({
       const overwrite = opts.overwrite || opts.clobber || false;
       const { srcStat, isChangingCase = false } = await stat.checkPaths(src, dest, "move", opts);
       await stat.checkParentPaths(src, srcStat, dest, "move");
-      const destParent = path5.dirname(dest);
-      const parsedParentPath = path5.parse(destParent);
+      const destParent = path11.dirname(dest);
+      const parsedParentPath = path11.parse(destParent);
       if (parsedParentPath.root !== destParent) {
         await mkdirp(destParent);
       }
@@ -6782,7 +6782,7 @@ var require_move = __commonJS({
         }
       }
       try {
-        await fs9.rename(src, dest);
+        await fs15.rename(src, dest);
       } catch (err) {
         if (err.code !== "EXDEV") {
           throw err;
@@ -6807,8 +6807,8 @@ var require_move = __commonJS({
 var require_move_sync = __commonJS({
   "node_modules/fs-extra/lib/move/move-sync.js"(exports2, module2) {
     "use strict";
-    var fs9 = require_graceful_fs();
-    var path5 = require("path");
+    var fs15 = require_graceful_fs();
+    var path11 = require("path");
     var copySync = require_copy2().copySync;
     var removeSync = require_remove().removeSync;
     var mkdirpSync = require_mkdirs().mkdirpSync;
@@ -6818,12 +6818,12 @@ var require_move_sync = __commonJS({
       const overwrite = opts.overwrite || opts.clobber || false;
       const { srcStat, isChangingCase = false } = stat.checkPathsSync(src, dest, "move", opts);
       stat.checkParentPathsSync(src, srcStat, dest, "move");
-      if (!isParentRoot(dest)) mkdirpSync(path5.dirname(dest));
+      if (!isParentRoot(dest)) mkdirpSync(path11.dirname(dest));
       return doRename(src, dest, overwrite, isChangingCase);
     }
     function isParentRoot(dest) {
-      const parent = path5.dirname(dest);
-      const parsedPath = path5.parse(parent);
+      const parent = path11.dirname(dest);
+      const parsedPath = path11.parse(parent);
       return parsedPath.root === parent;
     }
     function doRename(src, dest, overwrite, isChangingCase) {
@@ -6832,12 +6832,12 @@ var require_move_sync = __commonJS({
         removeSync(dest);
         return rename(src, dest, overwrite);
       }
-      if (fs9.existsSync(dest)) throw new Error("dest already exists.");
+      if (fs15.existsSync(dest)) throw new Error("dest already exists.");
       return rename(src, dest, overwrite);
     }
     function rename(src, dest, overwrite) {
       try {
-        fs9.renameSync(src, dest);
+        fs15.renameSync(src, dest);
       } catch (err) {
         if (err.code !== "EXDEV") throw err;
         return moveAcrossDevice(src, dest, overwrite);
@@ -8356,82 +8356,152 @@ function ora(options) {
 
 // packages/cli/src/parsers/LaravelRouteParser.ts
 var import_fs_extra = __toESM(require_lib());
+var import_child_process = require("child_process");
+var import_path = __toESM(require("path"));
 var LaravelRouteParser = class {
-  async parse(filePath) {
-    const content = await import_fs_extra.default.readFile(filePath, "utf-8");
-    return this.parseContent(content);
-  }
-  parseContent(content) {
-    const routes = [];
-    const lines = content.split("\n");
-    let currentAuth = false;
-    let currentMiddleware = [];
-    let insideAuthGroup = false;
-    let insideAdminGroup = false;
-    let braceDepth = 0;
-    let groupBraceDepth = 0;
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (trimmed.includes("middleware('auth:sanctum')")) {
-        insideAuthGroup = true;
-        currentAuth = true;
-        groupBraceDepth = braceDepth;
-      }
-      if (trimmed.includes("middleware(['auth:sanctum', 'admin'])")) {
-        insideAdminGroup = true;
-        currentMiddleware = ["auth:sanctum", "admin"];
-        groupBraceDepth = braceDepth;
-      }
-      braceDepth += (trimmed.match(/{/g) ?? []).length;
-      braceDepth -= (trimmed.match(/}/g) ?? []).length;
-      if (braceDepth <= groupBraceDepth && insideAuthGroup) {
-        insideAuthGroup = false;
-        currentAuth = false;
-      }
-      if (braceDepth <= groupBraceDepth && insideAdminGroup) {
-        insideAdminGroup = false;
-        currentMiddleware = [];
-      }
-      const routeMatch = trimmed.match(
-        /Route::(get|post|put|patch|delete|match)\(['"]([^'"]+)['"]/i
-      );
-      if (routeMatch) {
-        const method = routeMatch[1].toUpperCase();
-        const path5 = routeMatch[2];
-        routes.push({
-          name: this.inferName(method, path5),
-          method,
-          path: path5,
-          auth: insideAuthGroup || insideAdminGroup,
-          middleware: insideAdminGroup ? ["admin"] : []
-        });
+  async parse(filePath, options = {}) {
+    const projectRoot = import_path.default.resolve(import_path.default.dirname(filePath), "..");
+    const phpScript = `<?php
+require __DIR__.'/vendor/autoload.php';
+$app = require_once __DIR__.'/bootstrap/app.php';
+$kernel = $app->make(Illuminate\\Contracts\\Console\\Kernel::class);
+$kernel->bootstrap();
+
+$result = [
+    'routes' => [],
+    'models' => []
+];
+
+// Extract Routes
+$routes = app('router')->getRoutes();
+foreach ($routes as $route) {
+    if (!str_starts_with($route->uri(), 'api/')) continue;
+    
+    $methods = array_diff($route->methods(), ['HEAD']);
+    $middlewares = $route->gatherMiddleware();
+    
+    $auth = false;
+    foreach ($middlewares as $mw) {
+        if (is_string($mw) && (str_contains($mw, 'auth') || str_contains($mw, 'sanctum'))) {
+            $auth = true;
+        }
+    }
+
+    $schema = [];
+    $action = $route->getAction();
+    if (isset($action['uses']) && is_string($action['uses']) && str_contains($action['uses'], '@')) {
+        list($controller, $method) = explode('@', $action['uses']);
+        if (class_exists($controller)) {
+            try {
+                $reflector = new ReflectionMethod($controller, $method);
+                foreach ($reflector->getParameters() as $param) {
+                    $type = $param->getType();
+                    if ($type && !$type->isBuiltin()) {
+                        $className = $type->getName();
+                        if (is_subclass_of($className, 'Illuminate\\Foundation\\Http\\FormRequest')) {
+                            $request = new $className();
+                            if (method_exists($request, 'rules')) {
+                                $schema = $request->rules();
+                            }
+                        }
+                    }
+                }
+            } catch (\\Exception $e) {}
+        }
+    }
+
+    foreach ($methods as $method) {
+        $nameParts = explode('/', preg_replace('/^api\\//', '', $route->uri()));
+        $resource = preg_replace('/\\{.*\\}/', '', $nameParts[0]);
+        if (empty($resource)) $resource = 'api';
+        
+        $name = $resource . '.' . strtolower($method);
+        
+        $result['routes'][] = [
+            'name' => $route->getName() ?: $name,
+            'method' => $method,
+            'path' => '/' . preg_replace('/^api\\//', '', $route->uri()),
+            'auth' => $auth,
+            'middleware' => $middlewares,
+            'schema' => empty($schema) ? null : ['rules' => $schema]
+        ];
+    }
+}
+
+// Extract Models if requested
+$extractModels = ${options.extractModels ? "true" : "false"};
+if ($extractModels) {
+    $modelsPath = app_path('Models');
+    if (is_dir($modelsPath)) {
+        $files = \\Illuminate\\Support\\Facades\\File::allFiles($modelsPath);
+        foreach ($files as $file) {
+            $class = 'App\\\\Models\\\\' . str_replace('/', '\\\\', $file->getRelativePathname());
+            $class = preg_replace('/\\.php$/', '', $class);
+            
+            if (class_exists($class) && is_subclass_of($class, 'Illuminate\\\\Database\\\\Eloquent\\\\Model')) {
+                try {
+                    $reflection = new ReflectionClass($class);
+                    if ($reflection->isAbstract()) continue;
+                    
+                    $model = new $class();
+                    $table = $model->getTable();
+                    $columns = \\Illuminate\\Support\\Facades\\Schema::getColumns($table);
+                    
+                    $parsedColumns = [];
+                    foreach ($columns as $col) {
+                        $parsedColumns[] = [
+                            'name' => $col['name'],
+                            'type' => $col['type_name'],
+                            'nullable' => $col['nullable']
+                        ];
+                    }
+                    
+                    $result['models'][] = [
+                        'name' => class_basename($class),
+                        'table' => $table,
+                        'columns' => $parsedColumns
+                    ];
+                } catch (\\Exception $e) {}
+            }
+        }
+    }
+}
+
+echo json_encode($result);
+`;
+    const scriptPath = import_path.default.join(projectRoot, "routesync-extractor-temp.php");
+    try {
+      await import_fs_extra.default.writeFile(scriptPath, phpScript);
+      const stdout = (0, import_child_process.execSync)(`php routesync-extractor-temp.php`, {
+        cwd: projectRoot,
+        encoding: "utf-8",
+        maxBuffer: 1024 * 1024 * 10
+      });
+      await import_fs_extra.default.remove(scriptPath);
+      const parsed = JSON.parse(stdout);
+      return {
+        routes: parsed.routes || [],
+        models: parsed.models || []
+      };
+    } catch (err) {
+      if (import_fs_extra.default.existsSync(scriptPath)) {
+        await import_fs_extra.default.remove(scriptPath);
       }
+      console.error("Failed to parse Laravel routes via PHP script:", err);
+      return { routes: [], models: [] };
     }
-    return routes;
-  }
-  inferName(method, path5) {
-    const parts = path5.replace(/^\//, "").split("/");
-    const resource = parts[0] ?? "resource";
-    const hasId = parts.some((p) => p.startsWith("{"));
-    const map = {
-      GET: hasId ? `${resource}.show` : `${resource}.index`,
-      POST: `${resource}.store`,
-      PUT: `${resource}.update`,
-      PATCH: `${resource}.update`,
-      DELETE: `${resource}.destroy`
-    };
-    return map[method] ?? `${resource}.action`;
   }
 };
 
 // packages/cli/src/generators/ManifestGenerator.ts
 var import_fs_extra2 = __toESM(require_lib());
 var ManifestGenerator = class {
-  static generate(routes, baseURL) {
+  static generate(routes, baseURL, channels) {
     return {
       version: "1.0.0",
       baseURL,
       routes,
+      channels: channels || [],
       generatedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
   }
@@ -8441,15 +8511,16 @@ var ManifestGenerator = class {
 };
 
 // packages/cli/src/commands/scan.ts
-var scanCommand = new Command("scan").description("Scan Laravel/PHP routes and output a route manifest").option("-i, --input <path>", "Path to routes/api.php", "routes/api.php").option("-o, --output <path>", "Output manifest path", "routesync.manifest.json").option("-b, --baseURL <url>", "API base URL", "http://localhost/api").action(async (options) => {
+var scanCommand = new Command("scan").description("Scan Laravel/PHP routes and output a route manifest").option("-i, --input <path>", "Path to routes/api.php", "routes/api.php").option("-o, --output <path>", "Output manifest path", "routesync.manifest.json").option("-b, --baseURL <url>", "API base URL", "http://localhost/api").option("--models", "Extract Database Schema via Eloquent Models").action(async (options) => {
   const spinner = ora("Scanning routes...").start();
   try {
     const parser = new LaravelRouteParser();
-    const routes = await parser.parse(options.input);
+    const { routes, models } = await parser.parse(options.input, { extractModels: options.models });
     const manifest = ManifestGenerator.generate(routes, options.baseURL);
+    if (options.models) manifest.models = models;
     await ManifestGenerator.save(manifest, options.output);
     spinner.succeed(
-      source_default.green(`Found ${routes.length} routes \u2192 ${options.output}`)
+      source_default.green(`Found ${routes.length} routes, ${models.length} models \u2192 ${options.output}`)
     );
     routes.forEach((r) => {
       console.log(
@@ -8463,7 +8534,7 @@ var scanCommand = new Command("scan").description("Scan Laravel/PHP routes and o
 });
 
 // packages/cli/src/generators/SDKGenerator.ts
-var import_path = __toESM(require("path"));
+var import_path2 = __toESM(require("path"));
 var import_fs_extra3 = __toESM(require_lib());
 
 // packages/cli/src/generators/names.ts
@@ -8497,8 +8568,8 @@ function toIdentifier(value) {
   ].join("");
   return /^[A-Za-z_$]/.test(identifier) ? identifier : `route${toTypeName(identifier)}`;
 }
-function toRuntimePath(path5) {
-  return path5.replace(/{([^}/]+)}/g, ":$1");
+function toRuntimePath(path11) {
+  return path11.replace(/{([^}/]+)}/g, ":$1");
 }
 function toActionName(route, restSegments) {
   const method = route.method.toLowerCase();
@@ -8508,8 +8579,8 @@ function toActionName(route, restSegments) {
 function normalizeSegment(segment) {
   return segment.replace(/^{([^}/]+)}$/, "$1");
 }
-function getPathSegments(path5) {
-  return path5.replace(/^\//, "").split("/").filter(Boolean);
+function getPathSegments(path11) {
+  return path11.replace(/^\//, "").split("/").filter(Boolean);
 }
 function splitWords(value) {
   return value.replace(/^{([^}/]+)}$/, "$1").replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[^A-Za-z0-9]+/).filter(Boolean).map((word) => word.toLowerCase());
@@ -8528,6 +8599,13 @@ function uniquify(baseName, used) {
   used.add(name);
   return name;
 }
+function toMethodName(route) {
+  if (route.name) {
+    const parts = route.name.split(".");
+    return toIdentifier(parts.join(" "));
+  }
+  return toIdentifier(route.method + " " + route.path);
+}
 
 // packages/cli/src/generators/SDKGenerator.ts
 var SDKGenerator = class {
@@ -8554,18 +8632,23 @@ var SDKGenerator = class {
     lines.push(`})`);
     lines.push(``);
     lines.push(`export default api`);
-    await import_fs_extra3.default.writeFile(import_path.default.join(outputDir, "api.ts"), lines.join("\n"));
+    await import_fs_extra3.default.writeFile(import_path2.default.join(outputDir, "api.ts"), lines.join("\n"));
   }
 };
 
 // packages/cli/src/generators/TypeGenerator.ts
-var import_path2 = __toESM(require("path"));
+var import_path3 = __toESM(require("path"));
 var import_fs_extra4 = __toESM(require_lib());
 var TypeGenerator = class {
   static async generate(manifest, outputDir) {
     const lines = [];
+    const hasSchemas = manifest.routes.some((r) => r.schema && Object.keys(r.schema).length > 0);
     lines.push(`// Auto-generated by routesync. Do not edit manually.`);
     lines.push(``);
+    if (hasSchemas) {
+      lines.push(`import { z } from 'zod'`);
+      lines.push(``);
+    }
     lines.push(`export interface ApiResponse<T = any> {`);
     lines.push(`  success: boolean`);
     lines.push(`  message?: string`);
@@ -8600,12 +8683,48 @@ var TypeGenerator = class {
       lines.push(`}`);
       lines.push(``);
     }
-    await import_fs_extra4.default.writeFile(import_path2.default.join(outputDir, "types.ts"), lines.join("\n"));
+    if (hasSchemas) {
+      for (const route of manifest.routes) {
+        if (route.schema && Object.keys(route.schema).length > 0) {
+          const actionName = toMethodName(route);
+          const schemaName = actionName + "Schema";
+          lines.push(`export const ${schemaName} = z.object({`);
+          for (const [field, rules] of Object.entries(route.schema)) {
+            const ruleStr = Array.isArray(rules) ? rules.join("|") : String(rules);
+            let zodRule = "z.string()";
+            if (ruleStr.includes("numeric") || ruleStr.includes("integer")) {
+              zodRule = "z.number()";
+            } else if (ruleStr.includes("boolean")) {
+              zodRule = "z.boolean()";
+            } else if (ruleStr.includes("array")) {
+              zodRule = "z.array(z.any())";
+            }
+            if (ruleStr.includes("email")) zodRule += ".email()";
+            if (ruleStr.includes("url")) zodRule += ".url()";
+            const matchMin = ruleStr.match(/min:(\\d+)/);
+            if (matchMin) zodRule += ".min(" + matchMin[1] + ")";
+            const matchMax = ruleStr.match(/max:(\\d+)/);
+            if (matchMax) zodRule += ".max(" + matchMax[1] + ")";
+            if (!ruleStr.includes("required")) {
+              zodRule += ".optional()";
+            }
+            if (ruleStr.includes("nullable")) {
+              zodRule += ".nullable()";
+            }
+            lines.push(`  ${field}: ${zodRule},`);
+          }
+          lines.push(`})`);
+          lines.push(`export type ${toTypeName(actionName + "Payload")} = z.infer<typeof ${schemaName}>`);
+          lines.push(``);
+        }
+      }
+    }
+    await import_fs_extra4.default.writeFile(import_path3.default.join(outputDir, "types.ts"), lines.join("\\n"));
   }
 };
 
 // packages/cli/src/generators/HookGenerator.ts
-var import_path3 = __toESM(require("path"));
+var import_path4 = __toESM(require("path"));
 var import_fs_extra5 = __toESM(require_lib());
 var HookGenerator = class _HookGenerator {
   static async generate(manifest, outputDir) {
@@ -8643,25 +8762,197 @@ var HookGenerator = class _HookGenerator {
         }
       }
     }
-    await import_fs_extra5.default.writeFile(import_path3.default.join(outputDir, "hooks.ts"), lines.join("\n"));
+    await import_fs_extra5.default.writeFile(import_path4.default.join(outputDir, "hooks.ts"), lines.join("\n"));
   }
   static toHookName(group, actionName) {
     return `use${toTypeName(group)}${toTypeName(actionName)}`;
   }
 };
 
-// packages/cli/src/commands/generate.ts
+// packages/cli/src/generators/NextActionGenerator.ts
+var import_path5 = __toESM(require("path"));
 var import_fs_extra6 = __toESM(require_lib());
-var generateCommand = new Command("generate").description("Generate typed SDK, types, and hooks from route manifest").option("-m, --manifest <path>", "Path to route manifest", "routesync.manifest.json").option("-o, --output <path>", "Output directory", "src/api").option("--no-hooks", "Skip generating React hooks").action(async (options) => {
+var NextActionGenerator = class {
+  static async generate(manifest, outputDir) {
+    const lines = [];
+    lines.push(`// Auto-generated Next.js Server Actions. Do not edit manually.`);
+    lines.push(`"use server";`);
+    lines.push(``);
+    lines.push(`import { api } from './api'`);
+    lines.push(`import { cookies } from 'next/headers'`);
+    lines.push(``);
+    lines.push(`// Helper to auto-inject token from cookies if available`);
+    lines.push(`async function getAuthHeaders() {`);
+    lines.push(`  const cookieStore = await cookies()`);
+    lines.push(`  const token = cookieStore.get('token')?.value`);
+    lines.push(`  return token ? { Authorization: \`Bearer \${token}\` } : {}`);
+    lines.push(`}`);
+    lines.push(``);
+    for (const route of manifest.routes) {
+      const actionName = toMethodName(route);
+      lines.push(`export async function ${actionName}Action(payload?: any) {`);
+      const args = [];
+      if (route.method === "GET") {
+        args.push(`query: payload`);
+      } else {
+        args.push(`body: payload`);
+      }
+      if (route.auth) {
+        args.push(`headers: await getAuthHeaders()`);
+      }
+      const apiCall = `await api.${route.name.split(".")[0]}.${route.name.split(".")[1] || "action"}({ ${args.join(", ")} })`;
+      lines.push(`  try {`);
+      lines.push(`    const response = ${apiCall}`);
+      lines.push(`    return { success: true, data: response.data }`);
+      lines.push(`  } catch (error: any) {`);
+      lines.push(`    return { success: false, error: error.message }`);
+      lines.push(`  }`);
+      lines.push(`}`);
+      lines.push(``);
+    }
+    await import_fs_extra6.default.writeFile(import_path5.default.join(outputDir, "actions.ts"), lines.join("\n"));
+  }
+};
+
+// packages/cli/src/generators/MswGenerator.ts
+var import_path6 = __toESM(require("path"));
+var import_fs_extra7 = __toESM(require_lib());
+var MswGenerator = class {
+  static async generate(manifest, outputDir) {
+    const lines = [];
+    lines.push(`// Auto-generated MSW Mocks. Do not edit manually.`);
+    lines.push(`import { http, HttpResponse, delay } from 'msw'`);
+    lines.push(``);
+    lines.push(`export const handlers = [`);
+    for (const route of manifest.routes) {
+      const mswMethod = route.method.toLowerCase();
+      const mswPath = manifest.baseURL + route.path.replace(/\{([^}]+)\}/g, ":$1");
+      const actionName = toMethodName(route);
+      lines.push("  http." + mswMethod + "('" + mswPath + "', async ({ request, params }) => {");
+      lines.push(`    await delay(300) // Simulated network latency`);
+      lines.push(`    return HttpResponse.json({`);
+      lines.push(`      success: true,`);
+      lines.push(`      message: 'Mocked response for ${actionName}',`);
+      lines.push(`      data: {} // TODO: Add mock data based on your schema`);
+      lines.push(`    })`);
+      lines.push(`  }),`);
+    }
+    lines.push(`]`);
+    await import_fs_extra7.default.writeFile(import_path6.default.join(outputDir, "mocks.ts"), lines.join("\n"));
+  }
+};
+
+// packages/cli/src/generators/EchoGenerator.ts
+var import_fs_extra8 = __toESM(require_lib());
+var import_path7 = __toESM(require("path"));
+var EchoGenerator = class {
+  static async generate(channels, outputDir) {
+    if (channels.length === 0) return;
+    const lines = [];
+    lines.push(`// Auto-generated Laravel Echo Hooks. Do not edit manually.`);
+    lines.push(`import { useEffect } from 'react'`);
+    lines.push(`import Echo from 'laravel-echo'`);
+    lines.push(``);
+    lines.push(`// Ensure you have configured window.Echo somewhere in your app`);
+    lines.push(``);
+    for (const channel of channels) {
+      const nameParts = channel.name.replace(/\\{[^}]+\\}/g, "").split(".").filter(Boolean);
+      const hookName = "useListen" + toTypeName(nameParts.join(" ")) + "Channel";
+      const params = [...channel.name.matchAll(/\\{([^}]+)\\}/g)].map((m) => m[1]);
+      const paramArgs = params.length > 0 ? params.map((p) => p + ": string | number").join(", ") + ", " : "";
+      const runtimeChannelName = channel.name.replace(/\\{([^}]+)\\}/g, "${$1}");
+      lines.push("export function " + hookName + "(" + paramArgs + "eventName: string, callback: (event: any) => void) {");
+      lines.push(`  useEffect(() => {`);
+      lines.push(`    if (typeof window === 'undefined' || !(window as any).Echo) return`);
+      lines.push(`    `);
+      lines.push(`    const echo: Echo = (window as any).Echo`);
+      const channelMethod = channel.isPrivate ? "private" : "channel";
+      lines.push("    const channelInstance = echo." + channelMethod + "(`" + runtimeChannelName + "`)");
+      lines.push(`    channelInstance.listen(eventName, callback)`);
+      lines.push(`    `);
+      lines.push(`    return () => {`);
+      lines.push(`      channelInstance.stopListening(eventName, callback)`);
+      lines.push(`      // Optionally echo.leave(...)`);
+      lines.push(`    }`);
+      const deps = params.join(", ");
+      const allDeps = deps ? "[" + deps + ", eventName, callback]" : "[eventName, callback]";
+      lines.push("  }, " + allDeps + ")");
+      lines.push(`}`);
+      lines.push(``);
+    }
+    await import_fs_extra8.default.writeFile(import_path7.default.join(outputDir, "echo.ts"), lines.join("\n"));
+  }
+};
+
+// packages/cli/src/generators/IndexGenerator.ts
+var import_path8 = __toESM(require("path"));
+var import_fs_extra9 = __toESM(require_lib());
+var IndexGenerator = class {
+  static async generate(manifest, outputDir, options) {
+    const grouped = buildGeneratedRoutes(manifest.routes);
+    const rootLines = [];
+    rootLines.push(`// Auto-generated. Do not edit.`);
+    rootLines.push(`export { api } from './api'`);
+    rootLines.push(`export * from './types'`);
+    if (options.hooks !== false) rootLines.push(`export * from './hooks'`);
+    if (options.nextActions) rootLines.push(`export * from './actions'`);
+    await import_fs_extra9.default.writeFile(import_path8.default.join(outputDir, "index.ts"), rootLines.join("\n"));
+  }
+};
+
+// packages/cli/src/commands/generate.ts
+var import_fs_extra11 = __toESM(require_lib());
+
+// packages/cli/src/generators/ModelGenerator.ts
+var import_fs_extra10 = __toESM(require_lib());
+var import_path9 = __toESM(require("path"));
+var ModelGenerator = class {
+  static async generate(manifest, outputDir) {
+    if (!manifest.models || manifest.models.length === 0) return;
+    const coreDir = import_path9.default.join(outputDir, "core");
+    await import_fs_extra10.default.ensureDir(coreDir);
+    const lines = [];
+    lines.push(`// Auto-generated. Do not edit.`);
+    lines.push(``);
+    for (const model of manifest.models) {
+      lines.push(`export interface ${model.name} {`);
+      for (const col of model.columns) {
+        const tsType = this.mapSqlTypeToTs(col.type);
+        const nullable = col.nullable ? " | null" : "";
+        const isOptional = col.name === "password" || col.name === "remember_token" ? "?" : "";
+        lines.push(`  ${col.name}${isOptional}: ${tsType}${nullable}`);
+      }
+      lines.push(`}`);
+      lines.push(``);
+    }
+    await import_fs_extra10.default.writeFile(import_path9.default.join(coreDir, "models.ts"), lines.join("\n"));
+  }
+  static mapSqlTypeToTs(sqlType) {
+    const type = sqlType.toLowerCase();
+    if (type.includes("int") || type.includes("float") || type.includes("double") || type.includes("decimal") || type.includes("numeric")) {
+      return "number";
+    }
+    if (type.includes("bool") || type.includes("tinyint(1)")) {
+      return "boolean";
+    }
+    if (type.includes("json")) {
+      return "any";
+    }
+    return "string";
+  }
+};
+
+// packages/cli/src/commands/generate.ts
+var generateCommand = new Command("generate").description("Generate typed SDK, types, and hooks from route manifest").option("-m, --manifest <path>", "Path to route manifest", "routesync.manifest.json").option("-o, --output <path>", "Output directory", "src/api").option("--no-hooks", "Skip generating React hooks").option("--next-actions", "Generate Next.js Server Actions").option("--msw", "Generate MSW Mock Handlers").option("--echo", "Generate Laravel Echo Hooks").action(async (options) => {
   const spinner = ora("Generating SDK...").start();
   try {
-    if (!import_fs_extra6.default.existsSync(options.manifest)) {
+    if (!import_fs_extra11.default.existsSync(options.manifest)) {
       throw new Error(
         `Manifest not found: ${options.manifest}. Run 'routesync scan' first.`
       );
     }
-    const manifest = await import_fs_extra6.default.readJson(options.manifest);
-    await import_fs_extra6.default.ensureDir(options.output);
+    const manifest = await import_fs_extra11.default.readJson(options.manifest);
+    await import_fs_extra11.default.ensureDir(options.output);
     spinner.text = "Generating types...";
     await TypeGenerator.generate(manifest, options.output);
     spinner.text = "Generating SDK...";
@@ -8670,35 +8961,93 @@ var generateCommand = new Command("generate").description("Generate typed SDK, t
       spinner.text = "Generating hooks...";
       await HookGenerator.generate(manifest, options.output);
     }
+    if (options.nextActions) {
+      spinner.text = "Generating Server Actions...";
+      await NextActionGenerator.generate(manifest, options.output);
+    }
+    if (options.msw) {
+      spinner.text = "Generating MSW Mocks...";
+      await MswGenerator.generate(manifest, options.output);
+    }
+    if (options.echo && manifest.channels) {
+      spinner.text = "Generating Echo Hooks...";
+      await EchoGenerator.generate(manifest.channels, options.output);
+    }
+    if (manifest.models) {
+      spinner.text = "Generating DB Models...";
+      await ModelGenerator.generate(manifest, options.output);
+    }
+    spinner.text = "Generating Index Files...";
+    await IndexGenerator.generate(manifest, options.output, options);
     spinner.succeed(source_default.green(`SDK generated \u2192 ${options.output}`));
     console.log(`  ${source_default.cyan("api.ts")}     Typed API client`);
     console.log(`  ${source_default.cyan("types.ts")}   Response/request types`);
     if (options.hooks !== false) {
       console.log(`  ${source_default.cyan("hooks.ts")}   React Query hooks`);
     }
+    if (options.nextActions) {
+      console.log(`  ${source_default.cyan("actions.ts")} Next.js Server Actions`);
+    }
+    if (options.msw) {
+      console.log(`  ${source_default.cyan("mocks.ts")}   MSW Mock Handlers`);
+    }
+    if (options.echo && manifest.channels) {
+      console.log(`  ${source_default.cyan("echo.ts")}    Laravel Echo Hooks`);
+    }
+    if (manifest.models && manifest.models.length > 0) {
+      console.log(`  ${source_default.cyan("models.ts")}  Eloquent Database Models`);
+    }
   } catch (err) {
     spinner.fail(source_default.red(`Generate failed: ${err.message}`));
     process.exit(1);
   }
 });
 
+// packages/cli/src/parsers/LaravelChannelParser.ts
+var import_fs_extra12 = __toESM(require_lib());
+var LaravelChannelParser = class {
+  async parse(channelFilePath = "routes/channels.php") {
+    if (!import_fs_extra12.default.existsSync(channelFilePath)) {
+      return [];
+    }
+    const content = await import_fs_extra12.default.readFile(channelFilePath, "utf-8");
+    const channels = [];
+    const regex2 = new RegExp(`Broadcast::channel\\(\\s*['"]([^'"]+)['"]`, "g");
+    let match;
+    while ((match = regex2.exec(content)) !== null) {
+      const name = match[1];
+      channels.push({
+        name,
+        isPrivate: true,
+        // we default to private for now as most channels are authenticated
+        isPresence: false
+      });
+    }
+    return channels;
+  }
+};
+
 // packages/cli/src/commands/sync.ts
-var import_fs_extra7 = __toESM(require_lib());
-var syncCommand = new Command("sync").description("Scan routes and generate SDK in one step").option("-i, --input <path>", "Path to routes/api.php", "routes/api.php").option("-o, --output <path>", "Output directory", "src/api").option("-b, --baseURL <url>", "API base URL", "http://localhost/api").option("--no-hooks", "Skip generating React hooks").action(async (options) => {
+var import_fs_extra13 = __toESM(require_lib());
+var syncCommand = new Command("sync").description("Scan routes and generate SDK in one step").option("-i, --input <path>", "Path to routes/api.php", "routes/api.php").option("-o, --output <path>", "Output directory", "src/api").option("-b, --baseURL <url>", "API base URL", "http://localhost/api").option("--no-hooks", "Skip generating React hooks").option("--next-actions", "Generate Next.js Server Actions").option("--msw", "Generate MSW Mock Handlers").option("--echo", "Generate Laravel Echo Hooks").option("--models", "Extract Database Schema via Eloquent Models").action(async (options) => {
   console.log(source_default.bold.blue("\n  routesync sync\n"));
   const steps = [
     { text: "Scanning Laravel routes" },
     { text: "Generating types" },
     { text: "Generating SDK" },
-    { text: "Generating hooks" }
+    { text: "Generating hooks" },
+    { text: "Generating Server Actions" }
   ];
   const spinner = ora(steps[0].text).start();
   try {
     const parser = new LaravelRouteParser();
-    const routes = await parser.parse(options.input);
-    const manifest = ManifestGenerator.generate(routes, options.baseURL);
-    spinner.succeed(source_default.green(`\u2714 ${steps[0].text} (${routes.length} routes)`));
-    await import_fs_extra7.default.ensureDir(options.output);
+    const { routes, models } = await parser.parse(options.input, { extractModels: options.models });
+    const channelParser = new LaravelChannelParser();
+    const channels = options.echo ? await channelParser.parse("routes/channels.php") : [];
+    const manifest = ManifestGenerator.generate(routes, options.baseURL, channels);
+    if (options.models) manifest.models = models;
+    spinner.succeed(source_default.green(`\u2714 ${steps[0].text} (${routes.length} routes, ${channels.length} channels, ${models.length} models)`));
+    await import_fs_extra13.default.ensureDir(options.output);
     spinner.start(steps[1].text);
     await TypeGenerator.generate(manifest, options.output);
     spinner.succeed(source_default.green(`\u2714 ${steps[1].text}`));
@@ -8710,6 +9059,29 @@ var syncCommand = new Command("sync").description("Scan routes and generate SDK
       await HookGenerator.generate(manifest, options.output);
       spinner.succeed(source_default.green(`\u2714 ${steps[3].text}`));
     }
+    if (options.nextActions) {
+      spinner.start(steps[4].text);
+      await NextActionGenerator.generate(manifest, options.output);
+      spinner.succeed(source_default.green(`\u2714 ${steps[4].text}`));
+    }
+    if (options.msw) {
+      spinner.start("Generating MSW Mocks");
+      await MswGenerator.generate(manifest, options.output);
+      spinner.succeed(source_default.green(`\u2714 Generating MSW Mocks`));
+    }
+    if (options.echo && manifest.channels) {
+      spinner.start("Generating Echo Hooks");
+      await EchoGenerator.generate(manifest.channels, options.output);
+      spinner.succeed(source_default.green(`\u2714 Generating Echo Hooks`));
+    }
+    if (options.models && manifest.models) {
+      spinner.start("Generating DB Models");
+      await ModelGenerator.generate(manifest, options.output);
+      spinner.succeed(source_default.green(`\u2714 Generating DB Models`));
+    }
+    spinner.start("Generating Index Files");
+    await IndexGenerator.generate(manifest, options.output, options);
+    spinner.succeed(source_default.green(`\u2714 Generating Index Files`));
     console.log(source_default.bold.green("\n  Sync complete!\n"));
     console.log(`  Output: ${source_default.cyan(options.output)}`);
   } catch (err) {
@@ -8719,8 +9091,8 @@ var syncCommand = new Command("sync").description("Scan routes and generate SDK
 });
 
 // packages/cli/src/commands/watch.ts
-var import_fs_extra8 = __toESM(require_lib());
-var import_path4 = __toESM(require("path"));
+var import_fs_extra14 = __toESM(require_lib());
+var import_path10 = __toESM(require("path"));
 var watchCommand = new Command("watch").description("Watch routes file and re-sync on changes").option("-i, --input <path>", "Path to routes/api.php", "routes/api.php").option("-o, --output <path>", "Output directory", "src/api").option("-b, --baseURL <url>", "API base URL", "http://localhost/api").action(async (options) => {
   console.log(source_default.bold.blue("\n  routesync watch\n"));
   console.log(`  Watching: ${source_default.cyan(options.input)}`);
@@ -8731,8 +9103,8 @@ var watchCommand = new Command("watch").description("Watch routes file and re-sy
     debounceTimer = setTimeout(async () => {
       console.log(source_default.yellow(`  [${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] Routes changed, syncing...`));
       try {
-        const { execSync } = await import("child_process");
-        execSync(
+        const { execSync: execSync2 } = await import("child_process");
+        execSync2(
           `routesync sync --input ${options.input} --output ${options.output} --baseURL ${options.baseURL}`,
           { stdio: "inherit" }
         );
@@ -8741,11 +9113,11 @@ var watchCommand = new Command("watch").description("Watch routes file and re-sy
       }
     }, 300);
   };
-  if (!import_fs_extra8.default.existsSync(options.input)) {
+  if (!import_fs_extra14.default.existsSync(options.input)) {
     console.error(source_default.red(`  File not found: ${options.input}`));
     process.exit(1);
   }
-  import_fs_extra8.default.watch(import_path4.default.resolve(options.input), onChange);
+  import_fs_extra14.default.watch(import_path10.default.resolve(options.input), onChange);
 });
 
 // packages/cli/src/index.ts