alchemy 0.43.4 → 0.44.0

package/bin/alchemy.mjs

@@ -2514,7 +2514,7 @@ var require_command = __commonJS({
     var EventEmitter2 = __require("node:events").EventEmitter;
     var childProcess = __require("node:child_process");
     var path11 = __require("node:path");
-    var fs9 = __require("node:fs");
+    var fs10 = __require("node:fs");
     var process12 = __require("node:process");
     var { Argument, humanReadableArgName } = require_argument();
     var { CommanderError } = require_error();
@@ -3509,7 +3509,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} subcommandName
        */
       _checkForMissingExecutable(executableFile, executableDir, subcommandName) {
-        if (fs9.existsSync(executableFile)) return;
+        if (fs10.existsSync(executableFile)) return;
         const executableDirMessage = executableDir ? `searched for local subcommand relative to directory '${executableDir}'` : "no directory for search for local subcommand, use .executableDir() to supply a custom directory";
         const executableMissing = `'${executableFile}' does not exist
  - if '${subcommandName}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead
@@ -3528,10 +3528,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
           const localBin = path11.resolve(baseDir, baseName);
-          if (fs9.existsSync(localBin)) return localBin;
+          if (fs10.existsSync(localBin)) return localBin;
           if (sourceExt.includes(path11.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs9.existsSync(`${localBin}${ext}`)
+            (ext) => fs10.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -3543,7 +3543,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs9.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs10.realpathSync(this._scriptPath);
           } catch {
             resolvedScriptPath = this._scriptPath;
           }
@@ -26025,54 +26025,54 @@ var require_polyfills = __commonJS({
     }
     var chdir;
     module2.exports = patch;
-    function patch(fs9) {
+    function patch(fs10) {
       if (constants4.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(path11, mode, cb) {
+        patchLchmod(fs10);
+      }
+      if (!fs10.lutimes) {
+        patchLutimes(fs10);
+      }
+      fs10.chown = chownFix(fs10.chown);
+      fs10.fchown = chownFix(fs10.fchown);
+      fs10.lchown = chownFix(fs10.lchown);
+      fs10.chmod = chmodFix(fs10.chmod);
+      fs10.fchmod = chmodFix(fs10.fchmod);
+      fs10.lchmod = chmodFix(fs10.lchmod);
+      fs10.chownSync = chownFixSync(fs10.chownSync);
+      fs10.fchownSync = chownFixSync(fs10.fchownSync);
+      fs10.lchownSync = chownFixSync(fs10.lchownSync);
+      fs10.chmodSync = chmodFixSync(fs10.chmodSync);
+      fs10.fchmodSync = chmodFixSync(fs10.fchmodSync);
+      fs10.lchmodSync = chmodFixSync(fs10.lchmodSync);
+      fs10.stat = statFix(fs10.stat);
+      fs10.fstat = statFix(fs10.fstat);
+      fs10.lstat = statFix(fs10.lstat);
+      fs10.statSync = statFixSync(fs10.statSync);
+      fs10.fstatSync = statFixSync(fs10.fstatSync);
+      fs10.lstatSync = statFixSync(fs10.lstatSync);
+      if (fs10.chmod && !fs10.lchmod) {
+        fs10.lchmod = function(path11, mode, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs9.lchmodSync = function() {
+        fs10.lchmodSync = function() {
         };
       }
-      if (fs9.chown && !fs9.lchown) {
-        fs9.lchown = function(path11, uid, gid, cb) {
+      if (fs10.chown && !fs10.lchown) {
+        fs10.lchown = function(path11, uid, gid, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs9.lchownSync = function() {
+        fs10.lchownSync = function() {
         };
       }
       if (platform2 === "win32") {
-        fs9.rename = typeof fs9.rename !== "function" ? fs9.rename : function(fs$rename) {
+        fs10.rename = typeof fs10.rename !== "function" ? fs10.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) {
+                  fs10.stat(to, function(stater, st) {
                     if (stater && stater.code === "ENOENT")
                       fs$rename(from, to, CB);
                     else
@@ -26088,9 +26088,9 @@ var require_polyfills = __commonJS({
           }
           if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
           return rename;
-        }(fs9.rename);
+        }(fs10.rename);
       }
-      fs9.read = typeof fs9.read !== "function" ? fs9.read : function(fs$read) {
+      fs10.read = typeof fs10.read !== "function" ? fs10.read : function(fs$read) {
         function read(fd, buffer, offset, length, position, callback_) {
           var callback;
           if (callback_ && typeof callback_ === "function") {
@@ -26098,22 +26098,22 @@ var require_polyfills = __commonJS({
             callback = function(er, _3, __) {
               if (er && er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
-                return fs$read.call(fs9, fd, buffer, offset, length, position, callback);
+                return fs$read.call(fs10, 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(fs10, 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) {
+      }(fs10.read);
+      fs10.readSync = typeof fs10.readSync !== "function" ? fs10.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(fs10, fd, buffer, offset, length, position);
             } catch (er) {
               if (er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
@@ -26123,10 +26123,10 @@ var require_polyfills = __commonJS({
             }
           }
         };
-      }(fs9.readSync);
-      function patchLchmod(fs10) {
-        fs10.lchmod = function(path11, mode, callback) {
-          fs10.open(
+      }(fs10.readSync);
+      function patchLchmod(fs11) {
+        fs11.lchmod = function(path11, mode, callback) {
+          fs11.open(
             path11,
             constants4.O_WRONLY | constants4.O_SYMLINK,
             mode,
@@ -26135,80 +26135,80 @@ var require_polyfills = __commonJS({
                 if (callback) callback(err);
                 return;
               }
-              fs10.fchmod(fd, mode, function(err2) {
-                fs10.close(fd, function(err22) {
+              fs11.fchmod(fd, mode, function(err2) {
+                fs11.close(fd, function(err22) {
                   if (callback) callback(err2 || err22);
                 });
               });
             }
           );
         };
-        fs10.lchmodSync = function(path11, mode) {
-          var fd = fs10.openSync(path11, constants4.O_WRONLY | constants4.O_SYMLINK, mode);
+        fs11.lchmodSync = function(path11, mode) {
+          var fd = fs11.openSync(path11, constants4.O_WRONLY | constants4.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
-            ret = fs10.fchmodSync(fd, mode);
+            ret = fs11.fchmodSync(fd, mode);
             threw = false;
           } finally {
             if (threw) {
               try {
-                fs10.closeSync(fd);
+                fs11.closeSync(fd);
               } catch (er) {
               }
             } else {
-              fs10.closeSync(fd);
+              fs11.closeSync(fd);
             }
           }
           return ret;
         };
       }
-      function patchLutimes(fs10) {
-        if (constants4.hasOwnProperty("O_SYMLINK") && fs10.futimes) {
-          fs10.lutimes = function(path11, at, mt, cb) {
-            fs10.open(path11, constants4.O_SYMLINK, function(er, fd) {
+      function patchLutimes(fs11) {
+        if (constants4.hasOwnProperty("O_SYMLINK") && fs11.futimes) {
+          fs11.lutimes = function(path11, at, mt, cb) {
+            fs11.open(path11, constants4.O_SYMLINK, function(er, fd) {
               if (er) {
                 if (cb) cb(er);
                 return;
               }
-              fs10.futimes(fd, at, mt, function(er2) {
-                fs10.close(fd, function(er22) {
+              fs11.futimes(fd, at, mt, function(er2) {
+                fs11.close(fd, function(er22) {
                   if (cb) cb(er2 || er22);
                 });
               });
             });
           };
-          fs10.lutimesSync = function(path11, at, mt) {
-            var fd = fs10.openSync(path11, constants4.O_SYMLINK);
+          fs11.lutimesSync = function(path11, at, mt) {
+            var fd = fs11.openSync(path11, constants4.O_SYMLINK);
             var ret;
             var threw = true;
             try {
-              ret = fs10.futimesSync(fd, at, mt);
+              ret = fs11.futimesSync(fd, at, mt);
               threw = false;
             } finally {
               if (threw) {
                 try {
-                  fs10.closeSync(fd);
+                  fs11.closeSync(fd);
                 } catch (er) {
                 }
               } else {
-                fs10.closeSync(fd);
+                fs11.closeSync(fd);
               }
             }
             return ret;
           };
-        } else if (fs10.futimes) {
-          fs10.lutimes = function(_a, _b, _c, cb) {
+        } else if (fs11.futimes) {
+          fs11.lutimes = function(_a, _b, _c, cb) {
             if (cb) process.nextTick(cb);
           };
-          fs10.lutimesSync = function() {
+          fs11.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(fs10, target, mode, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -26218,7 +26218,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, mode) {
           try {
-            return orig.call(fs9, target, mode);
+            return orig.call(fs10, target, mode);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -26227,7 +26227,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(fs10, target, uid, gid, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -26237,7 +26237,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(fs10, target, uid, gid);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -26257,13 +26257,13 @@ var require_polyfills = __commonJS({
             }
             if (cb) cb.apply(this, arguments);
           }
-          return options2 ? orig.call(fs9, target, options2, callback) : orig.call(fs9, target, callback);
+          return options2 ? orig.call(fs10, target, options2, callback) : orig.call(fs10, target, callback);
         };
       }
       function statFixSync(orig) {
         if (!orig) return orig;
         return function(target, options2) {
-          var stats = options2 ? orig.call(fs9, target, options2) : orig.call(fs9, target);
+          var stats = options2 ? orig.call(fs10, target, options2) : orig.call(fs10, target);
           if (stats) {
             if (stats.uid < 0) stats.uid += 4294967296;
             if (stats.gid < 0) stats.gid += 4294967296;
@@ -26292,7 +26292,7 @@ var require_legacy_streams = __commonJS({
   "../node_modules/graceful-fs/legacy-streams.js"(exports2, module2) {
     var Stream = __require("stream").Stream;
     module2.exports = legacy;
-    function legacy(fs9) {
+    function legacy(fs10) {
       return {
         ReadStream,
         WriteStream
@@ -26335,7 +26335,7 @@ var require_legacy_streams = __commonJS({
           });
           return;
         }
-        fs9.open(this.path, this.flags, this.mode, function(err, fd) {
+        fs10.open(this.path, this.flags, this.mode, function(err, fd) {
           if (err) {
             self.emit("error", err);
             self.readable = false;
@@ -26374,7 +26374,7 @@ var require_legacy_streams = __commonJS({
         this.busy = false;
         this._queue = [];
         if (this.fd === null) {
-          this._open = fs9.open;
+          this._open = fs10.open;
           this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
           this.flush();
         }
@@ -26409,7 +26409,7 @@ var require_clone = __commonJS({
 // ../node_modules/graceful-fs/graceful-fs.js
 var require_graceful_fs = __commonJS({
   "../node_modules/graceful-fs/graceful-fs.js"(exports2, module2) {
-    var fs9 = __require("fs");
+    var fs10 = __require("fs");
     var polyfills = require_polyfills();
     var legacy = require_legacy_streams();
     var clone = require_clone();
@@ -26441,12 +26441,12 @@ var require_graceful_fs = __commonJS({
         m2 = "GFS4: " + m2.split(/\n/).join("\nGFS4: ");
         console.error(m2);
       };
-    if (!fs9[gracefulQueue]) {
+    if (!fs10[gracefulQueue]) {
       queue = global[gracefulQueue] || [];
-      publishQueue(fs9, queue);
-      fs9.close = function(fs$close) {
+      publishQueue(fs10, queue);
+      fs10.close = function(fs$close) {
         function close(fd, cb) {
-          return fs$close.call(fs9, fd, function(err) {
+          return fs$close.call(fs10, fd, function(err) {
             if (!err) {
               resetQueue();
             }
@@ -26458,40 +26458,40 @@ var require_graceful_fs = __commonJS({
           value: fs$close
         });
         return close;
-      }(fs9.close);
-      fs9.closeSync = function(fs$closeSync) {
+      }(fs10.close);
+      fs10.closeSync = function(fs$closeSync) {
         function closeSync(fd) {
-          fs$closeSync.apply(fs9, arguments);
+          fs$closeSync.apply(fs10, arguments);
           resetQueue();
         }
         Object.defineProperty(closeSync, previousSymbol, {
           value: fs$closeSync
         });
         return closeSync;
-      }(fs9.closeSync);
+      }(fs10.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(fs10[gracefulQueue]);
+          __require("assert").equal(fs10[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 = createReadStream2;
-      fs10.createWriteStream = createWriteStream2;
-      var fs$readFile = fs10.readFile;
-      fs10.readFile = readFile;
+      publishQueue(global, fs10[gracefulQueue]);
+    }
+    module2.exports = patch(clone(fs10));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs10.__patched) {
+      module2.exports = patch(fs10);
+      fs10.__patched = true;
+    }
+    function patch(fs11) {
+      polyfills(fs11);
+      fs11.gracefulify = patch;
+      fs11.createReadStream = createReadStream2;
+      fs11.createWriteStream = createWriteStream2;
+      var fs$readFile = fs11.readFile;
+      fs11.readFile = readFile;
       function readFile(path11, options2, cb) {
         if (typeof options2 === "function")
           cb = options2, options2 = null;
@@ -26507,9 +26507,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$writeFile = fs10.writeFile;
-      fs10.writeFile = writeFile2;
-      function writeFile2(path11, data, options2, cb) {
+      var fs$writeFile = fs11.writeFile;
+      fs11.writeFile = writeFile;
+      function writeFile(path11, data, options2, cb) {
         if (typeof options2 === "function")
           cb = options2, options2 = null;
         return go$writeFile(path11, data, options2, cb);
@@ -26524,9 +26524,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$appendFile = fs10.appendFile;
+      var fs$appendFile = fs11.appendFile;
       if (fs$appendFile)
-        fs10.appendFile = appendFile;
+        fs11.appendFile = appendFile;
       function appendFile(path11, data, options2, cb) {
         if (typeof options2 === "function")
           cb = options2, options2 = null;
@@ -26542,9 +26542,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$copyFile = fs10.copyFile;
+      var fs$copyFile = fs11.copyFile;
       if (fs$copyFile)
-        fs10.copyFile = copyFile;
+        fs11.copyFile = copyFile;
       function copyFile(src, dest, flags, cb) {
         if (typeof flags === "function") {
           cb = flags;
@@ -26562,8 +26562,8 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$readdir = fs10.readdir;
-      fs10.readdir = readdir;
+      var fs$readdir = fs11.readdir;
+      fs11.readdir = readdir;
       var noReaddirOptionVersions = /^v[0-5]\./;
       function readdir(path11, options2, cb) {
         if (typeof options2 === "function")
@@ -26604,21 +26604,21 @@ var require_graceful_fs = __commonJS({
         }
       }
       if (process.version.substr(0, 4) === "v0.8") {
-        var legStreams = legacy(fs10);
+        var legStreams = legacy(fs11);
         ReadStream = legStreams.ReadStream;
         WriteStream = legStreams.WriteStream;
       }
-      var fs$ReadStream = fs10.ReadStream;
+      var fs$ReadStream = fs11.ReadStream;
       if (fs$ReadStream) {
         ReadStream.prototype = Object.create(fs$ReadStream.prototype);
         ReadStream.prototype.open = ReadStream$open;
       }
-      var fs$WriteStream = fs10.WriteStream;
+      var fs$WriteStream = fs11.WriteStream;
       if (fs$WriteStream) {
         WriteStream.prototype = Object.create(fs$WriteStream.prototype);
         WriteStream.prototype.open = WriteStream$open;
       }
-      Object.defineProperty(fs10, "ReadStream", {
+      Object.defineProperty(fs11, "ReadStream", {
         get: function() {
           return ReadStream;
         },
@@ -26628,7 +26628,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      Object.defineProperty(fs10, "WriteStream", {
+      Object.defineProperty(fs11, "WriteStream", {
         get: function() {
           return WriteStream;
         },
@@ -26639,7 +26639,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileReadStream = ReadStream;
-      Object.defineProperty(fs10, "FileReadStream", {
+      Object.defineProperty(fs11, "FileReadStream", {
         get: function() {
           return FileReadStream;
         },
@@ -26650,7 +26650,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileWriteStream = WriteStream;
-      Object.defineProperty(fs10, "FileWriteStream", {
+      Object.defineProperty(fs11, "FileWriteStream", {
         get: function() {
           return FileWriteStream;
         },
@@ -26699,13 +26699,13 @@ var require_graceful_fs = __commonJS({
         });
       }
       function createReadStream2(path11, options2) {
-        return new fs10.ReadStream(path11, options2);
+        return new fs11.ReadStream(path11, options2);
       }
       function createWriteStream2(path11, options2) {
-        return new fs10.WriteStream(path11, options2);
+        return new fs11.WriteStream(path11, options2);
       }
-      var fs$open = fs10.open;
-      fs10.open = open;
+      var fs$open = fs11.open;
+      fs11.open = open;
       function open(path11, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
@@ -26721,20 +26721,20 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      return fs10;
+      return fs11;
     }
     function enqueue(elem) {
       debug("ENQUEUE", elem[0].name, elem[1]);
-      fs9[gracefulQueue].push(elem);
+      fs10[gracefulQueue].push(elem);
       retry();
     }
     var retryTimer;
     function resetQueue() {
       var now = Date.now();
-      for (var i2 = 0; i2 < fs9[gracefulQueue].length; ++i2) {
-        if (fs9[gracefulQueue][i2].length > 2) {
-          fs9[gracefulQueue][i2][3] = now;
-          fs9[gracefulQueue][i2][4] = now;
+      for (var i2 = 0; i2 < fs10[gracefulQueue].length; ++i2) {
+        if (fs10[gracefulQueue][i2].length > 2) {
+          fs10[gracefulQueue][i2][3] = now;
+          fs10[gracefulQueue][i2][4] = now;
         }
       }
       retry();
@@ -26742,9 +26742,9 @@ var require_graceful_fs = __commonJS({
     function retry() {
       clearTimeout(retryTimer);
       retryTimer = void 0;
-      if (fs9[gracefulQueue].length === 0)
+      if (fs10[gracefulQueue].length === 0)
         return;
-      var elem = fs9[gracefulQueue].shift();
+      var elem = fs10[gracefulQueue].shift();
       var fn = elem[0];
       var args2 = elem[1];
       var err = elem[2];
@@ -26766,7 +26766,7 @@ var require_graceful_fs = __commonJS({
           debug("RETRY", fn.name, args2);
           fn.apply(null, args2.concat([startTime]));
         } else {
-          fs9[gracefulQueue].push(elem);
+          fs10[gracefulQueue].push(elem);
         }
       }
       if (retryTimer === void 0) {
@@ -26781,7 +26781,7 @@ var require_fs = __commonJS({
   "../node_modules/fs-extra/lib/fs/index.js"(exports2) {
     "use strict";
     var u3 = require_universalify().fromCallback;
-    var fs9 = require_graceful_fs();
+    var fs10 = require_graceful_fs();
     var api = [
       "access",
       "appendFile",
@@ -26822,26 +26822,26 @@ var require_fs = __commonJS({
       "utimes",
       "writeFile"
     ].filter((key) => {
-      return typeof fs9[key] === "function";
+      return typeof fs10[key] === "function";
     });
-    Object.assign(exports2, fs9);
+    Object.assign(exports2, fs10);
     api.forEach((method) => {
-      exports2[method] = u3(fs9[method]);
+      exports2[method] = u3(fs10[method]);
     });
     exports2.exists = function(filename, callback) {
       if (typeof callback === "function") {
-        return fs9.exists(filename, callback);
+        return fs10.exists(filename, callback);
       }
       return new Promise((resolve2) => {
-        return fs9.exists(filename, resolve2);
+        return fs10.exists(filename, resolve2);
       });
     };
     exports2.read = function(fd, buffer, offset, length, position, callback) {
       if (typeof callback === "function") {
-        return fs9.read(fd, buffer, offset, length, position, callback);
+        return fs10.read(fd, buffer, offset, length, position, callback);
       }
       return new Promise((resolve2, reject) => {
-        fs9.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
+        fs10.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
           if (err) return reject(err);
           resolve2({ bytesRead, buffer: buffer2 });
         });
@@ -26849,10 +26849,10 @@ var require_fs = __commonJS({
     };
     exports2.write = function(fd, buffer, ...args2) {
       if (typeof args2[args2.length - 1] === "function") {
-        return fs9.write(fd, buffer, ...args2);
+        return fs10.write(fd, buffer, ...args2);
       }
       return new Promise((resolve2, reject) => {
-        fs9.write(fd, buffer, ...args2, (err, bytesWritten, buffer2) => {
+        fs10.write(fd, buffer, ...args2, (err, bytesWritten, buffer2) => {
           if (err) return reject(err);
           resolve2({ bytesWritten, buffer: buffer2 });
         });
@@ -26860,10 +26860,10 @@ var require_fs = __commonJS({
     };
     exports2.readv = function(fd, buffers, ...args2) {
       if (typeof args2[args2.length - 1] === "function") {
-        return fs9.readv(fd, buffers, ...args2);
+        return fs10.readv(fd, buffers, ...args2);
       }
       return new Promise((resolve2, reject) => {
-        fs9.readv(fd, buffers, ...args2, (err, bytesRead, buffers2) => {
+        fs10.readv(fd, buffers, ...args2, (err, bytesRead, buffers2) => {
           if (err) return reject(err);
           resolve2({ bytesRead, buffers: buffers2 });
         });
@@ -26871,17 +26871,17 @@ var require_fs = __commonJS({
     };
     exports2.writev = function(fd, buffers, ...args2) {
       if (typeof args2[args2.length - 1] === "function") {
-        return fs9.writev(fd, buffers, ...args2);
+        return fs10.writev(fd, buffers, ...args2);
       }
       return new Promise((resolve2, reject) => {
-        fs9.writev(fd, buffers, ...args2, (err, bytesWritten, buffers2) => {
+        fs10.writev(fd, buffers, ...args2, (err, bytesWritten, buffers2) => {
           if (err) return reject(err);
           resolve2({ bytesWritten, buffers: buffers2 });
         });
       });
     };
-    if (typeof fs9.realpath.native === "function") {
-      exports2.realpath.native = u3(fs9.realpath.native);
+    if (typeof fs10.realpath.native === "function") {
+      exports2.realpath.native = u3(fs10.realpath.native);
     } else {
       process.emitWarning(
         "fs.realpath.native is not a function. Is fs being monkey-patched?",
@@ -26914,7 +26914,7 @@ var require_utils2 = __commonJS({
 var require_make_dir = __commonJS({
   "../node_modules/fs-extra/lib/mkdirs/make-dir.js"(exports2, module2) {
     "use strict";
-    var fs9 = require_fs();
+    var fs10 = require_fs();
     var { checkPath } = require_utils2();
     var getMode = (options2) => {
       const defaults = { mode: 511 };
@@ -26923,14 +26923,14 @@ var require_make_dir = __commonJS({
     };
     module2.exports.makeDir = async (dir, options2) => {
       checkPath(dir);
-      return fs9.mkdir(dir, {
+      return fs10.mkdir(dir, {
         mode: getMode(options2),
         recursive: true
       });
     };
     module2.exports.makeDirSync = (dir, options2) => {
       checkPath(dir);
-      return fs9.mkdirSync(dir, {
+      return fs10.mkdirSync(dir, {
         mode: getMode(options2),
         recursive: true
       });
@@ -26962,13 +26962,13 @@ var require_path_exists = __commonJS({
   "../node_modules/fs-extra/lib/path-exists/index.js"(exports2, module2) {
     "use strict";
     var u3 = require_universalify().fromPromise;
-    var fs9 = require_fs();
-    function pathExists(path11) {
-      return fs9.access(path11).then(() => true).catch(() => false);
+    var fs10 = require_fs();
+    function pathExists2(path11) {
+      return fs10.access(path11).then(() => true).catch(() => false);
     }
     module2.exports = {
-      pathExists: u3(pathExists),
-      pathExistsSync: fs9.existsSync
+      pathExists: u3(pathExists2),
+      pathExistsSync: fs10.existsSync
     };
   }
 });
@@ -26977,16 +26977,16 @@ 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 fs10 = require_fs();
     var u3 = require_universalify().fromPromise;
     async function utimesMillis(path11, atime, mtime) {
-      const fd = await fs9.open(path11, "r+");
+      const fd = await fs10.open(path11, "r+");
       let closeErr = null;
       try {
-        await fs9.futimes(fd, atime, mtime);
+        await fs10.futimes(fd, atime, mtime);
       } finally {
         try {
-          await fs9.close(fd);
+          await fs10.close(fd);
         } catch (e2) {
           closeErr = e2;
         }
@@ -26996,9 +26996,9 @@ var require_utimes = __commonJS({
       }
     }
     function utimesMillisSync(path11, atime, mtime) {
-      const fd = fs9.openSync(path11, "r+");
-      fs9.futimesSync(fd, atime, mtime);
-      return fs9.closeSync(fd);
+      const fd = fs10.openSync(path11, "r+");
+      fs10.futimesSync(fd, atime, mtime);
+      return fs10.closeSync(fd);
     }
     module2.exports = {
       utimesMillis: u3(utimesMillis),
@@ -27011,11 +27011,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 fs10 = require_fs();
     var path11 = __require("path");
     var u3 = 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) => fs10.stat(file, { bigint: true }) : (file) => fs10.lstat(file, { bigint: true });
       return Promise.all([
         statFunc(src),
         statFunc(dest).catch((err) => {
@@ -27026,7 +27026,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) => fs10.statSync(file, { bigint: true }) : (file) => fs10.lstatSync(file, { bigint: true });
       const srcStat = statFunc(src);
       try {
         destStat = statFunc(dest);
@@ -27088,7 +27088,7 @@ var require_stat = __commonJS({
       if (destParent === srcParent || destParent === path11.parse(destParent).root) return;
       let destStat;
       try {
-        destStat = await fs9.stat(destParent, { bigint: true });
+        destStat = await fs10.stat(destParent, { bigint: true });
       } catch (err) {
         if (err.code === "ENOENT") return;
         throw err;
@@ -27104,7 +27104,7 @@ var require_stat = __commonJS({
       if (destParent === srcParent || destParent === path11.parse(destParent).root) return;
       let destStat;
       try {
-        destStat = fs9.statSync(destParent, { bigint: true });
+        destStat = fs10.statSync(destParent, { bigint: true });
       } catch (err) {
         if (err.code === "ENOENT") return;
         throw err;
@@ -27143,10 +27143,10 @@ var require_stat = __commonJS({
 var require_copy = __commonJS({
   "../node_modules/fs-extra/lib/copy/copy.js"(exports2, module2) {
     "use strict";
-    var fs9 = require_fs();
+    var fs10 = require_fs();
     var path11 = __require("path");
     var { mkdirs } = require_mkdirs();
-    var { pathExists } = require_path_exists();
+    var { pathExists: pathExists2 } = require_path_exists();
     var { utimesMillis } = require_utimes();
     var stat = require_stat();
     async function copy2(src, dest, opts = {}) {
@@ -27167,7 +27167,7 @@ var require_copy = __commonJS({
       const include = await runFilter(src, dest, opts);
       if (!include) return;
       const destParent = path11.dirname(dest);
-      const dirExists = await pathExists(destParent);
+      const dirExists = await pathExists2(destParent);
       if (!dirExists) {
         await mkdirs(destParent);
       }
@@ -27178,7 +27178,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 ? fs10.stat : fs10.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);
@@ -27190,7 +27190,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 fs10.unlink(dest);
         return copyFile(srcStat, src, dest, opts);
       }
       if (opts.errorOnExist) {
@@ -27198,28 +27198,28 @@ var require_copy = __commonJS({
       }
     }
     async function copyFile(srcStat, src, dest, opts) {
-      await fs9.copyFile(src, dest);
+      await fs10.copyFile(src, dest);
       if (opts.preserveTimestamps) {
         if (fileIsNotWritable(srcStat.mode)) {
           await makeFileWritable(dest, srcStat.mode);
         }
-        const updatedSrcStat = await fs9.stat(src);
+        const updatedSrcStat = await fs10.stat(src);
         await utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
       }
-      return fs9.chmod(dest, srcStat.mode);
+      return fs10.chmod(dest, srcStat.mode);
     }
     function fileIsNotWritable(srcMode) {
       return (srcMode & 128) === 0;
     }
     function makeFileWritable(dest, srcMode) {
-      return fs9.chmod(dest, srcMode | 128);
+      return fs10.chmod(dest, srcMode | 128);
     }
     async function onDir(srcStat, destStat, src, dest, opts) {
       if (!destStat) {
-        await fs9.mkdir(dest);
+        await fs10.mkdir(dest);
       }
       const promises = [];
-      for await (const item of await fs9.opendir(src)) {
+      for await (const item of await fs10.opendir(src)) {
         const srcItem = path11.join(src, item.name);
         const destItem = path11.join(dest, item.name);
         promises.push(
@@ -27234,22 +27234,22 @@ var require_copy = __commonJS({
       }
       await Promise.all(promises);
       if (!destStat) {
-        await fs9.chmod(dest, srcStat.mode);
+        await fs10.chmod(dest, srcStat.mode);
       }
     }
     async function onLink(destStat, src, dest, opts) {
-      let resolvedSrc = await fs9.readlink(src);
+      let resolvedSrc = await fs10.readlink(src);
       if (opts.dereference) {
         resolvedSrc = path11.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
-        return fs9.symlink(resolvedSrc, dest);
+        return fs10.symlink(resolvedSrc, dest);
       }
       let resolvedDest = null;
       try {
-        resolvedDest = await fs9.readlink(dest);
+        resolvedDest = await fs10.readlink(dest);
       } catch (e2) {
-        if (e2.code === "EINVAL" || e2.code === "UNKNOWN") return fs9.symlink(resolvedSrc, dest);
+        if (e2.code === "EINVAL" || e2.code === "UNKNOWN") return fs10.symlink(resolvedSrc, dest);
         throw e2;
       }
       if (opts.dereference) {
@@ -27261,8 +27261,8 @@ var require_copy = __commonJS({
       if (stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
         throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
       }
-      await fs9.unlink(dest);
-      return fs9.symlink(resolvedSrc, dest);
+      await fs10.unlink(dest);
+      return fs10.symlink(resolvedSrc, dest);
     }
     module2.exports = copy2;
   }
@@ -27272,7 +27272,7 @@ 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 fs10 = require_graceful_fs();
     var path11 = __require("path");
     var mkdirsSync = require_mkdirs().mkdirsSync;
     var utimesMillisSync = require_utimes().utimesMillisSync;
@@ -27295,11 +27295,11 @@ var require_copy_sync = __commonJS({
       stat.checkParentPathsSync(src, srcStat, dest, "copy");
       if (opts.filter && !opts.filter(src, dest)) return;
       const destParent = path11.dirname(dest);
-      if (!fs9.existsSync(destParent)) mkdirsSync(destParent);
+      if (!fs10.existsSync(destParent)) mkdirsSync(destParent);
       return getStats(destStat, src, dest, opts);
     }
     function getStats(destStat, src, dest, opts) {
-      const statSync2 = opts.dereference ? fs9.statSync : fs9.lstatSync;
+      const statSync2 = opts.dereference ? fs10.statSync : fs10.lstatSync;
       const srcStat = statSync2(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);
@@ -27314,14 +27314,14 @@ var require_copy_sync = __commonJS({
     }
     function mayCopyFile(srcStat, src, dest, opts) {
       if (opts.overwrite) {
-        fs9.unlinkSync(dest);
+        fs10.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);
+      fs10.copyFileSync(src, dest);
       if (opts.preserveTimestamps) handleTimestamps(srcStat.mode, src, dest);
       return setDestMode(dest, srcStat.mode);
     }
@@ -27336,10 +27336,10 @@ var require_copy_sync = __commonJS({
       return setDestMode(dest, srcMode | 128);
     }
     function setDestMode(dest, srcMode) {
-      return fs9.chmodSync(dest, srcMode);
+      return fs10.chmodSync(dest, srcMode);
     }
     function setDestTimestamps(src, dest) {
-      const updatedSrcStat = fs9.statSync(src);
+      const updatedSrcStat = fs10.statSync(src);
       return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
     }
     function onDir(srcStat, destStat, src, dest, opts) {
@@ -27347,12 +27347,12 @@ var require_copy_sync = __commonJS({
       return copyDir(src, dest, opts);
     }
     function mkDirAndCopy(srcMode, src, dest, opts) {
-      fs9.mkdirSync(dest);
+      fs10.mkdirSync(dest);
       copyDir(src, dest, opts);
       return setDestMode(dest, srcMode);
     }
     function copyDir(src, dest, opts) {
-      const dir = fs9.opendirSync(src);
+      const dir = fs10.opendirSync(src);
       try {
         let dirent;
         while ((dirent = dir.readSync()) !== null) {
@@ -27370,18 +27370,18 @@ var require_copy_sync = __commonJS({
       return getStats(destStat, srcItem, destItem, opts);
     }
     function onLink(destStat, src, dest, opts) {
-      let resolvedSrc = fs9.readlinkSync(src);
+      let resolvedSrc = fs10.readlinkSync(src);
       if (opts.dereference) {
         resolvedSrc = path11.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
-        return fs9.symlinkSync(resolvedSrc, dest);
+        return fs10.symlinkSync(resolvedSrc, dest);
       } else {
         let resolvedDest;
         try {
-          resolvedDest = fs9.readlinkSync(dest);
+          resolvedDest = fs10.readlinkSync(dest);
         } catch (err) {
-          if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs9.symlinkSync(resolvedSrc, dest);
+          if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs10.symlinkSync(resolvedSrc, dest);
           throw err;
         }
         if (opts.dereference) {
@@ -27397,8 +27397,8 @@ var require_copy_sync = __commonJS({
       }
     }
     function copyLink(resolvedSrc, dest) {
-      fs9.unlinkSync(dest);
-      return fs9.symlinkSync(resolvedSrc, dest);
+      fs10.unlinkSync(dest);
+      return fs10.symlinkSync(resolvedSrc, dest);
     }
     module2.exports = copySync;
   }
@@ -27420,13 +27420,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 fs10 = require_graceful_fs();
     var u3 = require_universalify().fromCallback;
     function remove(path11, callback) {
-      fs9.rm(path11, { recursive: true, force: true }, callback);
+      fs10.rm(path11, { recursive: true, force: true }, callback);
     }
     function removeSync(path11) {
-      fs9.rmSync(path11, { recursive: true, force: true });
+      fs10.rmSync(path11, { recursive: true, force: true });
     }
     module2.exports = {
       remove: u3(remove),
@@ -27440,14 +27440,14 @@ var require_empty = __commonJS({
   "../node_modules/fs-extra/lib/empty/index.js"(exports2, module2) {
     "use strict";
     var u3 = require_universalify().fromPromise;
-    var fs9 = require_fs();
+    var fs10 = require_fs();
     var path11 = __require("path");
     var mkdir = require_mkdirs();
     var remove = require_remove();
     var emptyDir = u3(async function emptyDir2(dir) {
       let items;
       try {
-        items = await fs9.readdir(dir);
+        items = await fs10.readdir(dir);
       } catch {
         return mkdir.mkdirs(dir);
       }
@@ -27456,7 +27456,7 @@ var require_empty = __commonJS({
     function emptyDirSync(dir) {
       let items;
       try {
-        items = fs9.readdirSync(dir);
+        items = fs10.readdirSync(dir);
       } catch {
         return mkdir.mkdirsSync(dir);
       }
@@ -27480,51 +27480,51 @@ var require_file = __commonJS({
     "use strict";
     var u3 = require_universalify().fromPromise;
     var path11 = __require("path");
-    var fs9 = require_fs();
+    var fs10 = require_fs();
     var mkdir = require_mkdirs();
     async function createFile(file) {
       let stats;
       try {
-        stats = await fs9.stat(file);
+        stats = await fs10.stat(file);
       } catch {
       }
       if (stats && stats.isFile()) return;
       const dir = path11.dirname(file);
       let dirStats = null;
       try {
-        dirStats = await fs9.stat(dir);
+        dirStats = await fs10.stat(dir);
       } catch (err) {
         if (err.code === "ENOENT") {
           await mkdir.mkdirs(dir);
-          await fs9.writeFile(file, "");
+          await fs10.writeFile(file, "");
           return;
         } else {
           throw err;
         }
       }
       if (dirStats.isDirectory()) {
-        await fs9.writeFile(file, "");
+        await fs10.writeFile(file, "");
       } else {
-        await fs9.readdir(dir);
+        await fs10.readdir(dir);
       }
     }
     function createFileSync(file) {
       let stats;
       try {
-        stats = fs9.statSync(file);
+        stats = fs10.statSync(file);
       } catch {
       }
       if (stats && stats.isFile()) return;
       const dir = path11.dirname(file);
       try {
-        if (!fs9.statSync(dir).isDirectory()) {
-          fs9.readdirSync(dir);
+        if (!fs10.statSync(dir).isDirectory()) {
+          fs10.readdirSync(dir);
         }
       } catch (err) {
         if (err && err.code === "ENOENT") mkdir.mkdirsSync(dir);
         else throw err;
       }
-      fs9.writeFileSync(file, "");
+      fs10.writeFileSync(file, "");
     }
     module2.exports = {
       createFile: u3(createFile),
@@ -27539,49 +27539,49 @@ var require_link = __commonJS({
     "use strict";
     var u3 = require_universalify().fromPromise;
     var path11 = __require("path");
-    var fs9 = require_fs();
+    var fs10 = require_fs();
     var mkdir = require_mkdirs();
-    var { pathExists } = require_path_exists();
+    var { pathExists: pathExists2 } = require_path_exists();
     var { areIdentical } = require_stat();
     async function createLink(srcpath, dstpath) {
       let dstStat;
       try {
-        dstStat = await fs9.lstat(dstpath);
+        dstStat = await fs10.lstat(dstpath);
       } catch {
       }
       let srcStat;
       try {
-        srcStat = await fs9.lstat(srcpath);
+        srcStat = await fs10.lstat(srcpath);
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureLink");
         throw err;
       }
       if (dstStat && areIdentical(srcStat, dstStat)) return;
       const dir = path11.dirname(dstpath);
-      const dirExists = await pathExists(dir);
+      const dirExists = await pathExists2(dir);
       if (!dirExists) {
         await mkdir.mkdirs(dir);
       }
-      await fs9.link(srcpath, dstpath);
+      await fs10.link(srcpath, dstpath);
     }
     function createLinkSync(srcpath, dstpath) {
       let dstStat;
       try {
-        dstStat = fs9.lstatSync(dstpath);
+        dstStat = fs10.lstatSync(dstpath);
       } catch {
       }
       try {
-        const srcStat = fs9.lstatSync(srcpath);
+        const srcStat = fs10.lstatSync(srcpath);
         if (dstStat && areIdentical(srcStat, dstStat)) return;
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureLink");
         throw err;
       }
       const dir = path11.dirname(dstpath);
-      const dirExists = fs9.existsSync(dir);
-      if (dirExists) return fs9.linkSync(srcpath, dstpath);
+      const dirExists = fs10.existsSync(dir);
+      if (dirExists) return fs10.linkSync(srcpath, dstpath);
       mkdir.mkdirsSync(dir);
-      return fs9.linkSync(srcpath, dstpath);
+      return fs10.linkSync(srcpath, dstpath);
     }
     module2.exports = {
       createLink: u3(createLink),
@@ -27595,13 +27595,13 @@ var require_symlink_paths = __commonJS({
   "../node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports2, module2) {
     "use strict";
     var path11 = __require("path");
-    var fs9 = require_fs();
-    var { pathExists } = require_path_exists();
+    var fs10 = require_fs();
+    var { pathExists: pathExists2 } = require_path_exists();
     var u3 = require_universalify().fromPromise;
     async function symlinkPaths(srcpath, dstpath) {
       if (path11.isAbsolute(srcpath)) {
         try {
-          await fs9.lstat(srcpath);
+          await fs10.lstat(srcpath);
         } catch (err) {
           err.message = err.message.replace("lstat", "ensureSymlink");
           throw err;
@@ -27613,7 +27613,7 @@ var require_symlink_paths = __commonJS({
       }
       const dstdir = path11.dirname(dstpath);
       const relativeToDst = path11.join(dstdir, srcpath);
-      const exists = await pathExists(relativeToDst);
+      const exists = await pathExists2(relativeToDst);
       if (exists) {
         return {
           toCwd: relativeToDst,
@@ -27621,7 +27621,7 @@ var require_symlink_paths = __commonJS({
         };
       }
       try {
-        await fs9.lstat(srcpath);
+        await fs10.lstat(srcpath);
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureSymlink");
         throw err;
@@ -27633,7 +27633,7 @@ var require_symlink_paths = __commonJS({
     }
     function symlinkPathsSync(srcpath, dstpath) {
       if (path11.isAbsolute(srcpath)) {
-        const exists2 = fs9.existsSync(srcpath);
+        const exists2 = fs10.existsSync(srcpath);
         if (!exists2) throw new Error("absolute srcpath does not exist");
         return {
           toCwd: srcpath,
@@ -27642,14 +27642,14 @@ var require_symlink_paths = __commonJS({
       }
       const dstdir = path11.dirname(dstpath);
       const relativeToDst = path11.join(dstdir, srcpath);
-      const exists = fs9.existsSync(relativeToDst);
+      const exists = fs10.existsSync(relativeToDst);
       if (exists) {
         return {
           toCwd: relativeToDst,
           toDst: srcpath
         };
       }
-      const srcExists = fs9.existsSync(srcpath);
+      const srcExists = fs10.existsSync(srcpath);
       if (!srcExists) throw new Error("relative srcpath does not exist");
       return {
         toCwd: srcpath,
@@ -27667,13 +27667,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 fs10 = require_fs();
     var u3 = require_universalify().fromPromise;
     async function symlinkType(srcpath, type) {
       if (type) return type;
       let stats;
       try {
-        stats = await fs9.lstat(srcpath);
+        stats = await fs10.lstat(srcpath);
       } catch {
         return "file";
       }
@@ -27683,7 +27683,7 @@ var require_symlink_type = __commonJS({
       if (type) return type;
       let stats;
       try {
-        stats = fs9.lstatSync(srcpath);
+        stats = fs10.lstatSync(srcpath);
       } catch {
         return "file";
       }
@@ -27702,22 +27702,22 @@ var require_symlink = __commonJS({
     "use strict";
     var u3 = require_universalify().fromPromise;
     var path11 = __require("path");
-    var fs9 = require_fs();
+    var fs10 = require_fs();
     var { mkdirs, mkdirsSync } = require_mkdirs();
     var { symlinkPaths, symlinkPathsSync } = require_symlink_paths();
     var { symlinkType, symlinkTypeSync } = require_symlink_type();
-    var { pathExists } = require_path_exists();
+    var { pathExists: pathExists2 } = require_path_exists();
     var { areIdentical } = require_stat();
     async function createSymlink(srcpath, dstpath, type) {
       let stats;
       try {
-        stats = await fs9.lstat(dstpath);
+        stats = await fs10.lstat(dstpath);
       } catch {
       }
       if (stats && stats.isSymbolicLink()) {
         const [srcStat, dstStat] = await Promise.all([
-          fs9.stat(srcpath),
-          fs9.stat(dstpath)
+          fs10.stat(srcpath),
+          fs10.stat(dstpath)
         ]);
         if (areIdentical(srcStat, dstStat)) return;
       }
@@ -27725,30 +27725,30 @@ var require_symlink = __commonJS({
       srcpath = relative.toDst;
       const toType = await symlinkType(relative.toCwd, type);
       const dir = path11.dirname(dstpath);
-      if (!await pathExists(dir)) {
+      if (!await pathExists2(dir)) {
         await mkdirs(dir);
       }
-      return fs9.symlink(srcpath, dstpath, toType);
+      return fs10.symlink(srcpath, dstpath, toType);
     }
     function createSymlinkSync(srcpath, dstpath, type) {
       let stats;
       try {
-        stats = fs9.lstatSync(dstpath);
+        stats = fs10.lstatSync(dstpath);
       } catch {
       }
       if (stats && stats.isSymbolicLink()) {
-        const srcStat = fs9.statSync(srcpath);
-        const dstStat = fs9.statSync(dstpath);
+        const srcStat = fs10.statSync(srcpath);
+        const dstStat = fs10.statSync(dstpath);
         if (areIdentical(srcStat, dstStat)) return;
       }
       const relative = symlinkPathsSync(srcpath, dstpath);
       srcpath = relative.toDst;
       type = symlinkTypeSync(relative.toCwd, type);
       const dir = path11.dirname(dstpath);
-      const exists = fs9.existsSync(dir);
-      if (exists) return fs9.symlinkSync(srcpath, dstpath, type);
+      const exists = fs10.existsSync(dir);
+      if (exists) return fs10.symlinkSync(srcpath, dstpath, type);
       mkdirsSync(dir);
-      return fs9.symlinkSync(srcpath, dstpath, type);
+      return fs10.symlinkSync(srcpath, dstpath, type);
     }
     module2.exports = {
       createSymlink: u3(createSymlink),
@@ -27815,9 +27815,9 @@ var require_jsonfile = __commonJS({
       if (typeof options2 === "string") {
         options2 = { encoding: options2 };
       }
-      const fs9 = options2.fs || _fs;
+      const fs10 = options2.fs || _fs;
       const shouldThrow = "throws" in options2 ? options2.throws : true;
-      let data = await universalify.fromCallback(fs9.readFile)(file, options2);
+      let data = await universalify.fromCallback(fs10.readFile)(file, options2);
       data = stripBom(data);
       let obj;
       try {
@@ -27837,10 +27837,10 @@ var require_jsonfile = __commonJS({
       if (typeof options2 === "string") {
         options2 = { encoding: options2 };
       }
-      const fs9 = options2.fs || _fs;
+      const fs10 = options2.fs || _fs;
       const shouldThrow = "throws" in options2 ? options2.throws : true;
       try {
-        let content = fs9.readFileSync(file, options2);
+        let content = fs10.readFileSync(file, options2);
         content = stripBom(content);
         return JSON.parse(content, options2.reviver);
       } catch (err) {
@@ -27853,20 +27853,20 @@ var require_jsonfile = __commonJS({
       }
     }
     async function _writeFile(file, obj, options2 = {}) {
-      const fs9 = options2.fs || _fs;
+      const fs10 = options2.fs || _fs;
       const str = stringify(obj, options2);
-      await universalify.fromCallback(fs9.writeFile)(file, str, options2);
+      await universalify.fromCallback(fs10.writeFile)(file, str, options2);
     }
-    var writeFile2 = universalify.fromPromise(_writeFile);
+    var writeFile = universalify.fromPromise(_writeFile);
     function writeFileSync2(file, obj, options2 = {}) {
-      const fs9 = options2.fs || _fs;
+      const fs10 = options2.fs || _fs;
       const str = stringify(obj, options2);
-      return fs9.writeFileSync(file, str, options2);
+      return fs10.writeFileSync(file, str, options2);
     }
     var jsonfile = {
       readFile,
       readFileSync: readFileSync3,
-      writeFile: writeFile2,
+      writeFile,
       writeFileSync: writeFileSync2
     };
     module2.exports = jsonfile;
@@ -27893,23 +27893,23 @@ var require_output_file = __commonJS({
   "../node_modules/fs-extra/lib/output-file/index.js"(exports2, module2) {
     "use strict";
     var u3 = require_universalify().fromPromise;
-    var fs9 = require_fs();
+    var fs10 = require_fs();
     var path11 = __require("path");
     var mkdir = require_mkdirs();
-    var pathExists = require_path_exists().pathExists;
+    var pathExists2 = require_path_exists().pathExists;
     async function outputFile(file, data, encoding = "utf-8") {
       const dir = path11.dirname(file);
-      if (!await pathExists(dir)) {
+      if (!await pathExists2(dir)) {
         await mkdir.mkdirs(dir);
       }
-      return fs9.writeFile(file, data, encoding);
+      return fs10.writeFile(file, data, encoding);
     }
     function outputFileSync(file, ...args2) {
       const dir = path11.dirname(file);
-      if (!fs9.existsSync(dir)) {
+      if (!fs10.existsSync(dir)) {
         mkdir.mkdirsSync(dir);
       }
-      fs9.writeFileSync(file, ...args2);
+      fs10.writeFileSync(file, ...args2);
     }
     module2.exports = {
       outputFile: u3(outputFile),
@@ -27968,12 +27968,12 @@ var require_json2 = __commonJS({
 var require_move = __commonJS({
   "../node_modules/fs-extra/lib/move/move.js"(exports2, module2) {
     "use strict";
-    var fs9 = require_fs();
+    var fs10 = require_fs();
     var path11 = __require("path");
     var { copy: copy2 } = require_copy2();
     var { remove } = require_remove();
     var { mkdirp } = require_mkdirs();
-    var { pathExists } = require_path_exists();
+    var { pathExists: pathExists2 } = require_path_exists();
     var stat = require_stat();
     async function move(src, dest, opts = {}) {
       const overwrite = opts.overwrite || opts.clobber || false;
@@ -27990,12 +27990,12 @@ var require_move = __commonJS({
       if (!isChangingCase) {
         if (overwrite) {
           await remove(dest);
-        } else if (await pathExists(dest)) {
+        } else if (await pathExists2(dest)) {
           throw new Error("dest already exists.");
         }
       }
       try {
-        await fs9.rename(src, dest);
+        await fs10.rename(src, dest);
       } catch (err) {
         if (err.code !== "EXDEV") {
           throw err;
@@ -28020,7 +28020,7 @@ 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 fs10 = require_graceful_fs();
     var path11 = __require("path");
     var copySync = require_copy2().copySync;
     var removeSync = require_remove().removeSync;
@@ -28045,12 +28045,12 @@ var require_move_sync = __commonJS({
         removeSync(dest);
         return rename(src, dest, overwrite);
       }
-      if (fs9.existsSync(dest)) throw new Error("dest already exists.");
+      if (fs10.existsSync(dest)) throw new Error("dest already exists.");
       return rename(src, dest, overwrite);
     }
     function rename(src, dest, overwrite) {
       try {
-        fs9.renameSync(src, dest);
+        fs10.renameSync(src, dest);
       } catch (err) {
         if (err.code !== "EXDEV") throw err;
         return moveAcrossDevice(src, dest, overwrite);
@@ -28107,7 +28107,7 @@ var require_windows = __commonJS({
   "../node_modules/cross-spawn/node_modules/which/node_modules/isexe/windows.js"(exports2, module2) {
     module2.exports = isexe;
     isexe.sync = sync;
-    var fs9 = __require("fs");
+    var fs10 = __require("fs");
     function checkPathExt(path11, options2) {
       var pathext = options2.pathExt !== void 0 ? options2.pathExt : process.env.PATHEXT;
       if (!pathext) {
@@ -28132,12 +28132,12 @@ var require_windows = __commonJS({
       return checkPathExt(path11, options2);
     }
     function isexe(path11, options2, cb) {
-      fs9.stat(path11, function(er, stat) {
+      fs10.stat(path11, function(er, stat) {
         cb(er, er ? false : checkStat(stat, path11, options2));
       });
     }
     function sync(path11, options2) {
-      return checkStat(fs9.statSync(path11), path11, options2);
+      return checkStat(fs10.statSync(path11), path11, options2);
     }
   }
 });
@@ -28147,14 +28147,14 @@ var require_mode = __commonJS({
   "../node_modules/cross-spawn/node_modules/which/node_modules/isexe/mode.js"(exports2, module2) {
     module2.exports = isexe;
     isexe.sync = sync;
-    var fs9 = __require("fs");
+    var fs10 = __require("fs");
     function isexe(path11, options2, cb) {
-      fs9.stat(path11, function(er, stat) {
+      fs10.stat(path11, function(er, stat) {
         cb(er, er ? false : checkStat(stat, options2));
       });
     }
     function sync(path11, options2) {
-      return checkStat(fs9.statSync(path11), options2);
+      return checkStat(fs10.statSync(path11), options2);
     }
     function checkStat(stat, options2) {
       return stat.isFile() && checkMode(stat, options2);
@@ -28178,7 +28178,7 @@ var require_mode = __commonJS({
 // ../node_modules/cross-spawn/node_modules/which/node_modules/isexe/index.js
 var require_isexe = __commonJS({
   "../node_modules/cross-spawn/node_modules/which/node_modules/isexe/index.js"(exports2, module2) {
-    var fs9 = __require("fs");
+    var fs10 = __require("fs");
     var core;
     if (process.platform === "win32" || global.TESTING_WINDOWS) {
       core = require_windows();
@@ -28442,16 +28442,16 @@ var require_shebang_command = __commonJS({
 var require_readShebang = __commonJS({
   "../node_modules/cross-spawn/lib/util/readShebang.js"(exports2, module2) {
     "use strict";
-    var fs9 = __require("fs");
+    var fs10 = __require("fs");
     var shebangCommand = require_shebang_command();
     function readShebang(command2) {
       const size = 150;
       const buffer = Buffer.alloc(size);
       let fd;
       try {
-        fd = fs9.openSync(command2, "r");
-        fs9.readSync(fd, buffer, 0, size, 0);
-        fs9.closeSync(fd);
+        fd = fs10.openSync(command2, "r");
+        fs10.readSync(fd, buffer, 0, size, 0);
+        fs10.closeSync(fd);
       } catch (e2) {
       }
       return shebangCommand(buffer.toString());
@@ -31981,8 +31981,8 @@ var require_utils6 = __commonJS({
     exports2.array = array;
     var errno = require_errno();
     exports2.errno = errno;
-    var fs9 = require_fs2();
-    exports2.fs = fs9;
+    var fs10 = require_fs2();
+    exports2.fs = fs10;
     var path11 = require_path();
     exports2.path = path11;
     var pattern = require_pattern();
@@ -32166,12 +32166,12 @@ var require_fs3 = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.createFileSystemAdapter = exports2.FILE_SYSTEM_ADAPTER = void 0;
-    var fs9 = __require("fs");
+    var fs10 = __require("fs");
     exports2.FILE_SYSTEM_ADAPTER = {
-      lstat: fs9.lstat,
-      stat: fs9.stat,
-      lstatSync: fs9.lstatSync,
-      statSync: fs9.statSync
+      lstat: fs10.lstat,
+      stat: fs10.stat,
+      lstatSync: fs10.lstatSync,
+      statSync: fs10.statSync
     };
     function createFileSystemAdapter(fsMethods) {
       if (fsMethods === void 0) {
@@ -32188,12 +32188,12 @@ var require_settings = __commonJS({
   "../node_modules/@nodelib/fs.stat/out/settings.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    var fs9 = require_fs3();
+    var fs10 = require_fs3();
     var Settings = class {
       constructor(_options = {}) {
         this._options = _options;
         this.followSymbolicLink = this._getValue(this._options.followSymbolicLink, true);
-        this.fs = fs9.createFileSystemAdapter(this._options.fs);
+        this.fs = fs10.createFileSystemAdapter(this._options.fs);
         this.markSymbolicLink = this._getValue(this._options.markSymbolicLink, false);
         this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
       }
@@ -32348,8 +32348,8 @@ var require_utils7 = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.fs = void 0;
-    var fs9 = require_fs4();
-    exports2.fs = fs9;
+    var fs10 = require_fs4();
+    exports2.fs = fs10;
   }
 });
 
@@ -32544,14 +32544,14 @@ var require_fs5 = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.createFileSystemAdapter = exports2.FILE_SYSTEM_ADAPTER = void 0;
-    var fs9 = __require("fs");
+    var fs10 = __require("fs");
     exports2.FILE_SYSTEM_ADAPTER = {
-      lstat: fs9.lstat,
-      stat: fs9.stat,
-      lstatSync: fs9.lstatSync,
-      statSync: fs9.statSync,
-      readdir: fs9.readdir,
-      readdirSync: fs9.readdirSync
+      lstat: fs10.lstat,
+      stat: fs10.stat,
+      lstatSync: fs10.lstatSync,
+      statSync: fs10.statSync,
+      readdir: fs10.readdir,
+      readdirSync: fs10.readdirSync
     };
     function createFileSystemAdapter(fsMethods) {
       if (fsMethods === void 0) {
@@ -32570,12 +32570,12 @@ var require_settings2 = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     var path11 = __require("path");
     var fsStat = require_out();
-    var fs9 = require_fs5();
+    var fs10 = require_fs5();
     var Settings = class {
       constructor(_options = {}) {
         this._options = _options;
         this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, false);
-        this.fs = fs9.createFileSystemAdapter(this._options.fs);
+        this.fs = fs10.createFileSystemAdapter(this._options.fs);
         this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path11.sep);
         this.stats = this._getValue(this._options.stats, false);
         this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
@@ -33933,16 +33933,16 @@ var require_settings4 = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.DEFAULT_FILE_SYSTEM_ADAPTER = void 0;
-    var fs9 = __require("fs");
+    var fs10 = __require("fs");
     var os = __require("os");
     var CPU_COUNT = Math.max(os.cpus().length, 1);
     exports2.DEFAULT_FILE_SYSTEM_ADAPTER = {
-      lstat: fs9.lstat,
-      lstatSync: fs9.lstatSync,
-      stat: fs9.stat,
-      statSync: fs9.statSync,
-      readdir: fs9.readdir,
-      readdirSync: fs9.readdirSync
+      lstat: fs10.lstat,
+      lstatSync: fs10.lstatSync,
+      stat: fs10.stat,
+      statSync: fs10.statSync,
+      readdir: fs10.readdir,
+      readdirSync: fs10.readdirSync
     };
     var Settings = class {
       constructor(_options = {}) {
@@ -35171,10 +35171,9 @@ var Y2 = ({ indicator: t2 = "dots" } = {}) => {
 };
 
 // bin/commands/create.ts
-var fs8 = __toESM(require_lib(), 1);
+var fs9 = __toESM(require_lib(), 1);
 var import_picocolors4 = __toESM(require_picocolors(), 1);
-import { existsSync as existsSync2 } from "node:fs";
-import { join as join3, resolve } from "node:path";
+import { resolve } from "node:path";
 
 // bin/errors.ts
 var import_picocolors3 = __toESM(require_picocolors(), 1);
@@ -42033,9 +42032,6 @@ async function installDependencies(context, {
   const pm = context.packageManager;
   const commands = getPackageManagerCommands(pm);
   try {
-    console.log(await fs.readJson(`${targetCwd}/package.json`));
-    console.log({ dependencies: dependencies2 });
-    console.log({ devDependencies });
     if (!dependencies2 && !devDependencies) {
       await execa(commands.install, {
         cwd: targetCwd,
@@ -42574,7 +42570,6 @@ var generateGlobTasksSync = normalizeArgumentsSync(generateTasksSync);
 var { convertPathToPattern } = import_fast_glob2.default;
 
 // bin/services/template-manager.ts
-import { existsSync } from "node:fs";
 import * as path10 from "node:path";
 import { join as join2 } from "node:path";
 
@@ -42633,10 +42628,16 @@ var addPackageDependencies = async (opts) => {
 // bin/services/template-manager.ts
 async function copyTemplate(templateName, context) {
   const templatePath = path10.join(PKG_ROOT, "templates", templateName);
-  if (!existsSync(templatePath)) {
+  if (!fs7.existsSync(templatePath)) {
     throw new Error(`Template '${templateName}' not found at ${templatePath}`);
   }
-  const filesToRename = ["_gitignore", "_npmrc", "_env", "_env.example"];
+  const filesToRename = [
+    "_gitignore",
+    "_npmrc",
+    "_env",
+    "_env.example",
+    "_prettierignore"
+  ];
   try {
     const copySpinner = Y2();
     copySpinner.start("Copying template files...");
@@ -42685,7 +42686,7 @@ async function copyTemplate(templateName, context) {
 }
 async function updateTemplatePackageJson(context) {
   const packageJsonPath = join2(context.path, "package.json");
-  if (!existsSync(packageJsonPath)) {
+  if (!fs7.existsSync(packageJsonPath)) {
     return;
   }
   const packageJson = await fs7.readJson(packageJsonPath);
@@ -42720,6 +42721,40 @@ async function handleRwsdkPostInstall(context) {
   }
 }
 
+// bin/services/vibe-rules.ts
+var fs8 = __toESM(require_lib(), 1);
+import { join as join3 } from "node:path";
+async function ensureVibeRulesPostinstall(cwd, editor) {
+  try {
+    const packageJsonPath = join3(cwd, "package.json");
+    if (!await fs8.pathExists(packageJsonPath)) return;
+    const packageJson = await fs8.readJson(packageJsonPath);
+    const postinstallCmd = `vibe-rules install ${editor}`;
+    if (!packageJson.scripts) {
+      packageJson.scripts = {};
+    }
+    if (packageJson.scripts.postinstall) {
+      if (!packageJson.scripts.postinstall.includes("vibe-rules install")) {
+        packageJson.scripts.postinstall = `${packageJson.scripts.postinstall} && ${postinstallCmd}`;
+      }
+    } else {
+      packageJson.scripts.postinstall = postinstallCmd;
+    }
+    await fs8.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+  } catch (_err) {
+  }
+}
+async function installAlchemyRules(input2) {
+  const packageManager = input2.packageManager || "bun";
+  const commands = getPackageManagerCommands(packageManager);
+  const args2 = ["vibe-rules", "install", input2.editor];
+  await execa(commands.x, args2, {
+    stdio: "pipe",
+    cwd: input2.cwd
+  });
+  await ensureVibeRulesPostinstall(input2.cwd ?? process.cwd(), input2.editor);
+}
+
 // ../node_modules/zod/v3/external.js
 var external_exports = {};
 __export(external_exports, {
@@ -46788,6 +46823,19 @@ var ProjectNameSchema = external_exports.string().min(1, "Project name cannot be
   (name) => name.toLowerCase() !== "node_modules",
   "Project name is reserved"
 ).describe("Project name or path");
+var EditorSchema = external_exports.enum([
+  "cursor",
+  "windsurf",
+  "vscode",
+  "zed",
+  "claude-code",
+  "gemini",
+  "codex",
+  "amp",
+  "clinerules",
+  "roo",
+  "unified"
+]).describe("Editor for vibe-rules");
 
 // bin/commands/create.ts
 var isTest = process.env.NODE_ENV === "test";
@@ -46846,11 +46894,7 @@ async function createProjectContext(cliOptions) {
     );
   }
   const path11 = resolve(process.cwd(), name);
-  let packageManager = options2.packageManager || detectedPm;
-  if (options2.bun) packageManager = "bun";
-  else if (options2.npm) packageManager = "npm";
-  else if (options2.pnpm) packageManager = "pnpm";
-  else if (options2.yarn) packageManager = "yarn";
+  let packageManager = options2.pm || detectedPm;
   let shouldInstall = true;
   if (options2.install !== void 0) {
     shouldInstall = options2.install;
@@ -46881,7 +46925,7 @@ async function createProjectContext(cliOptions) {
   };
 }
 async function handleDirectoryOverwrite(context) {
-  if (!existsSync2(context.path)) {
+  if (!fs9.existsSync(context.path)) {
     return;
   }
   let shouldOverwrite = false;
@@ -46908,7 +46952,7 @@ async function handleDirectoryOverwrite(context) {
   const s = Y2();
   s.start(`Removing existing directory: ${import_picocolors4.default.yellow(context.path)}`);
   try {
-    await fs8.rm(context.path, { recursive: true, force: true });
+    await fs9.rm(context.path, { recursive: true, force: true });
     s.stop(`Directory ${import_picocolors4.default.yellow(context.path)} removed.`);
   } catch (error) {
     s.stop(import_picocolors4.default.red(`Failed to remove directory ${import_picocolors4.default.yellow(context.path)}.`));
@@ -46930,17 +46974,55 @@ async function initializeTemplate(context) {
       `Template initialization failed for '${context.template}'`
     );
   }
-  const gitignorePath = join3(context.path, ".gitignore");
-  if (!existsSync2(gitignorePath)) {
-    try {
-      await fs8.writeFile(
-        gitignorePath,
-        "node_modules/\n.env\n.env.local\ndist/\nlib/\n.wrangler/\nwrangler.jsonc\n*.tsbuildinfo\n"
-      );
-    } catch (error) {
-      const errorMsg = error instanceof Error ? error.message : String(error);
-      M2.warn(`Failed to create .gitignore: ${errorMsg}`);
+}
+async function setupVibeRules(context) {
+  let selectedEditor = context.options.vibeRules;
+  if (!selectedEditor && !context.isTest && !context.options.yes) {
+    const setupResult = await ye({
+      message: "Setup vibe-rules for AI development assistance?",
+      initialValue: true
+    });
+    if (pD(setupResult) || !setupResult) {
+      return;
+    }
+    const editorResult = await ve({
+      message: "Which editor would you like to configure?",
+      options: [
+        { label: "Cursor", value: "cursor" },
+        { label: "Windsurf", value: "windsurf" },
+        { label: "VSCode", value: "vscode" },
+        { label: "Zed", value: "zed" },
+        { label: "Claude Code", value: "claude-code" },
+        { label: "Gemini", value: "gemini" },
+        { label: "Codex", value: "codex" },
+        { label: "Amp", value: "amp" },
+        { label: "Cline Rules", value: "clinerules" },
+        { label: "Roo", value: "roo" },
+        { label: "Unified (.rules)", value: "unified" }
+      ]
+    });
+    if (pD(editorResult)) {
+      return;
     }
+    selectedEditor = editorResult;
+  }
+  if (!selectedEditor) {
+    return;
+  }
+  const s = Y2();
+  s.start("Configuring vibe-rules...");
+  try {
+    await installAlchemyRules({
+      editor: selectedEditor,
+      packageManager: context.packageManager,
+      cwd: context.path
+    });
+    await ensureVibeRulesPostinstall(context.path, selectedEditor);
+    await installDependencies(context);
+    s.stop("vibe-rules configured");
+  } catch (error) {
+    s.stop("Failed to configure vibe-rules");
+    throwWithContext(error, "Failed to configure vibe-rules");
   }
 }
 async function createAlchemy(cliOptions) {
@@ -46957,6 +47039,7 @@ ${import_picocolors4.default.cyan("\u{1F4E6} Install dependencies:")}
    ${context.packageManager} install
 
 ` : "";
+    await setupVibeRules(context);
     Me(
       `
 ${import_picocolors4.default.cyan("\u{1F4C1} Navigate to your project:")}
@@ -47001,14 +47084,15 @@ var router2 = t.router({
       ProjectNameSchema.optional(),
       import_trpc_cli.zod.object({
         template: TemplateSchema.optional(),
-        packageManager: PackageManagerSchema.optional(),
         yes: import_trpc_cli.zod.boolean().optional().default(false).describe("Skip prompts and use defaults"),
         overwrite: import_trpc_cli.zod.boolean().optional().default(false).describe("Overwrite existing directory"),
-        bun: import_trpc_cli.zod.boolean().optional().default(false).describe("Use Bun as the package manager"),
-        npm: import_trpc_cli.zod.boolean().optional().default(false).describe("Use npm as the package manager"),
-        pnpm: import_trpc_cli.zod.boolean().optional().default(false).describe("Use pnpm as the package manager"),
-        yarn: import_trpc_cli.zod.boolean().optional().default(false).describe("Use Yarn as the package manager"),
-        install: import_trpc_cli.zod.boolean().optional().describe("Install dependencies after scaffolding")
+        install: import_trpc_cli.zod.boolean().optional().describe("Install dependencies after scaffolding"),
+        pm: PackageManagerSchema.optional().describe(
+          "Package manager to use (bun, npm, pnpm, yarn)"
+        ),
+        vibeRules: EditorSchema.optional().describe(
+          "Setup vibe-rules for the specified editor (cursor, windsurf, vscode, zed, claude-code, gemini, codex, amp, clinerules, roo, unified)"
+        )
       }).optional().default({})
     ])
   ).mutation(async ({ input: input2 }) => {