@stacksjs/cli 0.70.21 → 0.70.23

package/dist/index.js

@@ -2967,8 +2967,8 @@ var require_universalify = __commonJS((exports) => {
       if (typeof args[args.length - 1] === "function")
         fn.apply(this, args);
       else {
-        return new Promise((resolve3, reject) => {
-          args.push((err, res) => err != null ? reject(err) : resolve3(res));
+        return new Promise((resolve4, reject) => {
+          args.push((err, res) => err != null ? reject(err) : resolve4(res));
           fn.apply(this, args);
         });
       }
@@ -2989,7 +2989,7 @@ var require_universalify = __commonJS((exports) => {
 
 // ../../../../node_modules/graceful-fs/polyfills.js
 var require_polyfills = __commonJS((exports, module) => {
-  var constants = __require("node:constants");
+  var constants2 = __require("node:constants");
   var origCwd = process.cwd;
   var cwd = null;
   var platform2 = process.env.GRACEFUL_FS_PLATFORM || process.platform;
@@ -3013,7 +3013,7 @@ var require_polyfills = __commonJS((exports, module) => {
   var chdir;
   module.exports = patch;
   function patch(fs2) {
-    if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
+    if (constants2.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
       patchLchmod(fs2);
     }
     if (!fs2.lutimes) {
@@ -3053,7 +3053,7 @@ var require_polyfills = __commonJS((exports, module) => {
     }
     if (platform2 === "win32") {
       fs2.rename = typeof fs2.rename !== "function" ? fs2.rename : function(fs$rename) {
-        function rename(from, to, cb) {
+        function rename2(from, to, cb) {
           var start = Date.now();
           var backoff = 0;
           fs$rename(from, to, function CB(er) {
@@ -3075,8 +3075,8 @@ var require_polyfills = __commonJS((exports, module) => {
           });
         }
         if (Object.setPrototypeOf)
-          Object.setPrototypeOf(rename, fs$rename);
-        return rename;
+          Object.setPrototypeOf(rename2, fs$rename);
+        return rename2;
       }(fs2.rename);
     }
     fs2.read = typeof fs2.read !== "function" ? fs2.read : function(fs$read) {
@@ -3116,7 +3116,7 @@ var require_polyfills = __commonJS((exports, module) => {
     }(fs2.readSync);
     function patchLchmod(fs3) {
       fs3.lchmod = function(path3, mode, callback) {
-        fs3.open(path3, constants.O_WRONLY | constants.O_SYMLINK, mode, function(err, fd) {
+        fs3.open(path3, constants2.O_WRONLY | constants2.O_SYMLINK, mode, function(err, fd) {
           if (err) {
             if (callback)
               callback(err);
@@ -3131,7 +3131,7 @@ var require_polyfills = __commonJS((exports, module) => {
         });
       };
       fs3.lchmodSync = function(path3, mode) {
-        var fd = fs3.openSync(path3, constants.O_WRONLY | constants.O_SYMLINK, mode);
+        var fd = fs3.openSync(path3, constants2.O_WRONLY | constants2.O_SYMLINK, mode);
         var threw = true;
         var ret;
         try {
@@ -3150,9 +3150,9 @@ var require_polyfills = __commonJS((exports, module) => {
       };
     }
     function patchLutimes(fs3) {
-      if (constants.hasOwnProperty("O_SYMLINK") && fs3.futimes) {
+      if (constants2.hasOwnProperty("O_SYMLINK") && fs3.futimes) {
         fs3.lutimes = function(path3, at, mt, cb) {
-          fs3.open(path3, constants.O_SYMLINK, function(er, fd) {
+          fs3.open(path3, constants2.O_SYMLINK, function(er, fd) {
             if (er) {
               if (cb)
                 cb(er);
@@ -3167,7 +3167,7 @@ var require_polyfills = __commonJS((exports, module) => {
           });
         };
         fs3.lutimesSync = function(path3, at, mt) {
-          var fd = fs3.openSync(path3, constants.O_SYMLINK);
+          var fd = fs3.openSync(path3, constants2.O_SYMLINK);
           var ret;
           var threw = true;
           try {
@@ -3460,14 +3460,14 @@ GFS4: `);
       return close;
     }(fs2.close);
     fs2.closeSync = function(fs$closeSync) {
-      function closeSync(fd) {
+      function closeSync2(fd) {
         fs$closeSync.apply(fs2, arguments);
         resetQueue();
       }
-      Object.defineProperty(closeSync, previousSymbol, {
+      Object.defineProperty(closeSync2, previousSymbol, {
         value: fs$closeSync
       });
-      return closeSync;
+      return closeSync2;
     }(fs2.closeSync);
     if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
       process.on("exit", function() {
@@ -3488,8 +3488,8 @@ GFS4: `);
   function patch(fs3) {
     polyfills(fs3);
     fs3.gracefulify = patch;
-    fs3.createReadStream = createReadStream;
-    fs3.createWriteStream = createWriteStream;
+    fs3.createReadStream = createReadStream2;
+    fs3.createWriteStream = createWriteStream2;
     var fs$readFile = fs3.readFile;
     fs3.readFile = readFile;
     function readFile(path3, options, cb) {
@@ -3508,8 +3508,8 @@ GFS4: `);
       }
     }
     var fs$writeFile = fs3.writeFile;
-    fs3.writeFile = writeFile;
-    function writeFile(path3, data, options, cb) {
+    fs3.writeFile = writeFile2;
+    function writeFile2(path3, data, options, cb) {
       if (typeof options === "function")
         cb = options, options = null;
       return go$writeFile(path3, data, options, cb);
@@ -3563,9 +3563,9 @@ GFS4: `);
       }
     }
     var fs$readdir = fs3.readdir;
-    fs3.readdir = readdir;
+    fs3.readdir = readdir2;
     var noReaddirOptionVersions = /^v[0-5]\./;
-    function readdir(path3, options, cb) {
+    function readdir2(path3, options, cb) {
       if (typeof options === "function")
         cb = options, options = null;
       var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir(path4, options2, cb2, startTime) {
@@ -3688,10 +3688,10 @@ GFS4: `);
         }
       });
     }
-    function createReadStream(path3, options) {
+    function createReadStream2(path3, options) {
       return new fs3.ReadStream(path3, options);
     }
-    function createWriteStream(path3, options) {
+    function createWriteStream2(path3, options) {
       return new fs3.WriteStream(path3, options);
     }
     var fs$open = fs3.open;
@@ -3819,19 +3819,19 @@ var require_fs = __commonJS((exports) => {
     if (typeof callback === "function") {
       return fs2.exists(filename, callback);
     }
-    return new Promise((resolve3) => {
-      return fs2.exists(filename, resolve3);
+    return new Promise((resolve4) => {
+      return fs2.exists(filename, resolve4);
     });
   };
   exports.read = function(fd, buffer, offset, length, position, callback) {
     if (typeof callback === "function") {
       return fs2.read(fd, buffer, offset, length, position, callback);
     }
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve4, reject) => {
       fs2.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
         if (err)
           return reject(err);
-        resolve3({ bytesRead, buffer: buffer2 });
+        resolve4({ bytesRead, buffer: buffer2 });
       });
     });
   };
@@ -3839,11 +3839,11 @@ var require_fs = __commonJS((exports) => {
     if (typeof args[args.length - 1] === "function") {
       return fs2.write(fd, buffer, ...args);
     }
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve4, reject) => {
       fs2.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
         if (err)
           return reject(err);
-        resolve3({ bytesWritten, buffer: buffer2 });
+        resolve4({ bytesWritten, buffer: buffer2 });
       });
     });
   };
@@ -3851,11 +3851,11 @@ var require_fs = __commonJS((exports) => {
     if (typeof args[args.length - 1] === "function") {
       return fs2.readv(fd, buffers, ...args);
     }
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve4, reject) => {
       fs2.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
         if (err)
           return reject(err);
-        resolve3({ bytesRead, buffers: buffers2 });
+        resolve4({ bytesRead, buffers: buffers2 });
       });
     });
   };
@@ -3863,11 +3863,11 @@ var require_fs = __commonJS((exports) => {
     if (typeof args[args.length - 1] === "function") {
       return fs2.writev(fd, buffers, ...args);
     }
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve4, reject) => {
       fs2.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
         if (err)
           return reject(err);
-        resolve3({ bytesWritten, buffers: buffers2 });
+        resolve4({ bytesWritten, buffers: buffers2 });
       });
     });
   };
@@ -4117,7 +4117,7 @@ var require_copy = __commonJS((exports, module) => {
   var { mkdirs } = require_mkdirs();
   var { pathExists } = require_path_exists();
   var { utimesMillis } = require_utimes();
-  var stat = require_stat();
+  var stat2 = require_stat();
   async function copy(src2, dest, opts = {}) {
     if (typeof opts === "function") {
       opts = { filter: opts };
@@ -4129,8 +4129,8 @@ var require_copy = __commonJS((exports, module) => {
 
 ` + "\tsee https://github.com/jprichardson/node-fs-extra/issues/269", "Warning", "fs-extra-WARN0001");
     }
-    const { srcStat, destStat } = await stat.checkPaths(src2, dest, "copy", opts);
-    await stat.checkParentPaths(src2, srcStat, dest, "copy");
+    const { srcStat, destStat } = await stat2.checkPaths(src2, dest, "copy", opts);
+    await stat2.checkParentPaths(src2, srcStat, dest, "copy");
     const include = await runFilter(src2, dest, opts);
     if (!include)
       return;
@@ -4199,7 +4199,7 @@ var require_copy = __commonJS((exports, module) => {
       const destItem = path3.join(dest, item2.name);
       promises.push(runFilter(srcItem, destItem, opts).then((include) => {
         if (include) {
-          return stat.checkPaths(srcItem, destItem, "copy", opts).then(({ destStat: destStat2 }) => {
+          return stat2.checkPaths(srcItem, destItem, "copy", opts).then(({ destStat: destStat2 }) => {
             return getStatsAndPerformCopy(destStat2, srcItem, destItem, opts);
           });
         }
@@ -4229,10 +4229,10 @@ var require_copy = __commonJS((exports, module) => {
     if (opts.dereference) {
       resolvedDest = path3.resolve(process.cwd(), resolvedDest);
     }
-    if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
+    if (stat2.isSrcSubdir(resolvedSrc, resolvedDest)) {
       throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
     }
-    if (stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
+    if (stat2.isSrcSubdir(resolvedDest, resolvedSrc)) {
       throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
     }
     await fs2.unlink(dest);
@@ -4247,7 +4247,7 @@ var require_copy_sync = __commonJS((exports, module) => {
   var path3 = __require("node:path");
   var mkdirsSync = require_mkdirs().mkdirsSync;
   var utimesMillisSync = require_utimes().utimesMillisSync;
-  var stat = require_stat();
+  var stat2 = require_stat();
   function copySync(src2, dest, opts) {
     if (typeof opts === "function") {
       opts = { filter: opts };
@@ -4260,8 +4260,8 @@ var require_copy_sync = __commonJS((exports, module) => {
 
 ` + "\tsee https://github.com/jprichardson/node-fs-extra/issues/269", "Warning", "fs-extra-WARN0002");
     }
-    const { srcStat, destStat } = stat.checkPathsSync(src2, dest, "copy", opts);
-    stat.checkParentPathsSync(src2, srcStat, dest, "copy");
+    const { srcStat, destStat } = stat2.checkPathsSync(src2, dest, "copy", opts);
+    stat2.checkParentPathsSync(src2, srcStat, dest, "copy");
     if (opts.filter && !opts.filter(src2, dest))
       return;
     const destParent = path3.dirname(dest);
@@ -4347,7 +4347,7 @@ var require_copy_sync = __commonJS((exports, module) => {
     const destItem = path3.join(dest, item2);
     if (opts.filter && !opts.filter(srcItem, destItem))
       return;
-    const { destStat } = stat.checkPathsSync(srcItem, destItem, "copy", opts);
+    const { destStat } = stat2.checkPathsSync(srcItem, destItem, "copy", opts);
     return getStats(destStat, srcItem, destItem, opts);
   }
   function onLink(destStat, src2, dest, opts) {
@@ -4369,10 +4369,10 @@ var require_copy_sync = __commonJS((exports, module) => {
       if (opts.dereference) {
         resolvedDest = path3.resolve(process.cwd(), resolvedDest);
       }
-      if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
+      if (stat2.isSrcSubdir(resolvedSrc, resolvedDest)) {
         throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
       }
-      if (stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
+      if (stat2.isSrcSubdir(resolvedDest, resolvedSrc)) {
         throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
       }
       return copyLink(resolvedSrc, dest);
@@ -4415,14 +4415,14 @@ var require_empty = __commonJS((exports, module) => {
   var u3 = require_universalify().fromPromise;
   var fs2 = require_fs();
   var path3 = __require("node:path");
-  var mkdir = require_mkdirs();
+  var mkdir2 = require_mkdirs();
   var remove = require_remove();
   var emptyDir = u3(async function emptyDir(dir) {
     let items;
     try {
       items = await fs2.readdir(dir);
     } catch {
-      return mkdir.mkdirs(dir);
+      return mkdir2.mkdirs(dir);
     }
     return Promise.all(items.map((item2) => remove.remove(path3.join(dir, item2))));
   });
@@ -4431,7 +4431,7 @@ var require_empty = __commonJS((exports, module) => {
     try {
       items = fs2.readdirSync(dir);
     } catch {
-      return mkdir.mkdirsSync(dir);
+      return mkdir2.mkdirsSync(dir);
     }
     items.forEach((item2) => {
       item2 = path3.join(dir, item2);
@@ -4451,7 +4451,7 @@ var require_file = __commonJS((exports, module) => {
   var u3 = require_universalify().fromPromise;
   var path3 = __require("node:path");
   var fs2 = require_fs();
-  var mkdir = require_mkdirs();
+  var mkdir2 = require_mkdirs();
   async function createFile(file) {
     let stats;
     try {
@@ -4465,7 +4465,7 @@ var require_file = __commonJS((exports, module) => {
       dirStats = await fs2.stat(dir);
     } catch (err) {
       if (err.code === "ENOENT") {
-        await mkdir.mkdirs(dir);
+        await mkdir2.mkdirs(dir);
         await fs2.writeFile(file, "");
         return;
       } else {
@@ -4492,7 +4492,7 @@ var require_file = __commonJS((exports, module) => {
       }
     } catch (err) {
       if (err && err.code === "ENOENT")
-        mkdir.mkdirsSync(dir);
+        mkdir2.mkdirsSync(dir);
       else
         throw err;
     }
@@ -4509,7 +4509,7 @@ var require_link = __commonJS((exports, module) => {
   var u3 = require_universalify().fromPromise;
   var path3 = __require("node:path");
   var fs2 = require_fs();
-  var mkdir = require_mkdirs();
+  var mkdir2 = require_mkdirs();
   var { pathExists } = require_path_exists();
   var { areIdentical } = require_stat();
   async function createLink(srcpath, dstpath) {
@@ -4529,7 +4529,7 @@ var require_link = __commonJS((exports, module) => {
     const dir = path3.dirname(dstpath);
     const dirExists = await pathExists(dir);
     if (!dirExists) {
-      await mkdir.mkdirs(dir);
+      await mkdir2.mkdirs(dir);
     }
     await fs2.link(srcpath, dstpath);
   }
@@ -4550,7 +4550,7 @@ var require_link = __commonJS((exports, module) => {
     const dirExists = fs2.existsSync(dir);
     if (dirExists)
       return fs2.linkSync(srcpath, dstpath);
-    mkdir.mkdirsSync(dir);
+    mkdir2.mkdirsSync(dir);
     return fs2.linkSync(srcpath, dstpath);
   }
   module.exports = {
@@ -4686,9 +4686,9 @@ var require_symlink = __commonJS((exports, module) => {
       if (areIdentical(srcStat, dstStat))
         return;
     }
-    const relative2 = await symlinkPaths(srcpath, dstpath);
-    srcpath = relative2.toDst;
-    const toType = await symlinkType(relative2.toCwd, type);
+    const relative3 = await symlinkPaths(srcpath, dstpath);
+    srcpath = relative3.toDst;
+    const toType = await symlinkType(relative3.toCwd, type);
     const dir = path3.dirname(dstpath);
     if (!await pathExists(dir)) {
       await mkdirs(dir);
@@ -4706,9 +4706,9 @@ var require_symlink = __commonJS((exports, module) => {
       if (areIdentical(srcStat, dstStat))
         return;
     }
-    const relative2 = symlinkPathsSync(srcpath, dstpath);
-    srcpath = relative2.toDst;
-    type = symlinkTypeSync(relative2.toCwd, type);
+    const relative3 = symlinkPathsSync(srcpath, dstpath);
+    srcpath = relative3.toDst;
+    type = symlinkTypeSync(relative3.toCwd, type);
     const dir = path3.dirname(dstpath);
     const exists = fs2.existsSync(dir);
     if (exists)
@@ -4815,8 +4815,8 @@ var require_jsonfile = __commonJS((exports, module) => {
     const str = stringify(obj, options);
     await universalify.fromCallback(fs2.writeFile)(file, str, options);
   }
-  var writeFile = universalify.fromPromise(_writeFile);
-  function writeFileSync(file, obj, options = {}) {
+  var writeFile2 = universalify.fromPromise(_writeFile);
+  function writeFileSync3(file, obj, options = {}) {
     const fs2 = options.fs || _fs;
     const str = stringify(obj, options);
     return fs2.writeFileSync(file, str, options);
@@ -4824,8 +4824,8 @@ var require_jsonfile = __commonJS((exports, module) => {
   var jsonfile = {
     readFile,
     readFileSync,
-    writeFile,
-    writeFileSync
+    writeFile: writeFile2,
+    writeFileSync: writeFileSync3
   };
   module.exports = jsonfile;
 });
@@ -4846,19 +4846,19 @@ var require_output_file = __commonJS((exports, module) => {
   var u3 = require_universalify().fromPromise;
   var fs2 = require_fs();
   var path3 = __require("node:path");
-  var mkdir = require_mkdirs();
+  var mkdir2 = require_mkdirs();
   var pathExists = require_path_exists().pathExists;
   async function outputFile(file, data, encoding = "utf-8") {
     const dir = path3.dirname(file);
     if (!await pathExists(dir)) {
-      await mkdir.mkdirs(dir);
+      await mkdir2.mkdirs(dir);
     }
     return fs2.writeFile(file, data, encoding);
   }
   function outputFileSync(file, ...args) {
     const dir = path3.dirname(file);
     if (!fs2.existsSync(dir)) {
-      mkdir.mkdirsSync(dir);
+      mkdir2.mkdirsSync(dir);
     }
     fs2.writeFileSync(file, ...args);
   }
@@ -4913,11 +4913,11 @@ var require_move = __commonJS((exports, module) => {
   var { remove } = require_remove();
   var { mkdirp } = require_mkdirs();
   var { pathExists } = require_path_exists();
-  var stat = require_stat();
+  var stat2 = require_stat();
   async function move(src2, dest, opts = {}) {
     const overwrite = opts.overwrite || opts.clobber || false;
-    const { srcStat, isChangingCase = false } = await stat.checkPaths(src2, dest, "move", opts);
-    await stat.checkParentPaths(src2, srcStat, dest, "move");
+    const { srcStat, isChangingCase = false } = await stat2.checkPaths(src2, dest, "move", opts);
+    await stat2.checkParentPaths(src2, srcStat, dest, "move");
     const destParent = path3.dirname(dest);
     const parsedParentPath = path3.parse(destParent);
     if (parsedParentPath.root !== destParent) {
@@ -4961,12 +4961,12 @@ var require_move_sync = __commonJS((exports, module) => {
   var copySync = require_copy2().copySync;
   var removeSync = require_remove().removeSync;
   var mkdirpSync = require_mkdirs().mkdirpSync;
-  var stat = require_stat();
+  var stat2 = require_stat();
   function moveSync(src2, dest, opts) {
     opts = opts || {};
     const overwrite = opts.overwrite || opts.clobber || false;
-    const { srcStat, isChangingCase = false } = stat.checkPathsSync(src2, dest, "move", opts);
-    stat.checkParentPathsSync(src2, srcStat, dest, "move");
+    const { srcStat, isChangingCase = false } = stat2.checkPathsSync(src2, dest, "move", opts);
+    stat2.checkParentPathsSync(src2, srcStat, dest, "move");
     if (!isParentRoot(dest))
       mkdirpSync(path3.dirname(dest));
     return doRename(src2, dest, overwrite, isChangingCase);
@@ -4978,16 +4978,16 @@ var require_move_sync = __commonJS((exports, module) => {
   }
   function doRename(src2, dest, overwrite, isChangingCase) {
     if (isChangingCase)
-      return rename(src2, dest, overwrite);
+      return rename2(src2, dest, overwrite);
     if (overwrite) {
       removeSync(dest);
-      return rename(src2, dest, overwrite);
+      return rename2(src2, dest, overwrite);
     }
     if (fs2.existsSync(dest))
       throw new Error("dest already exists.");
-    return rename(src2, dest, overwrite);
+    return rename2(src2, dest, overwrite);
   }
-  function rename(src2, dest, overwrite) {
+  function rename2(src2, dest, overwrite) {
     try {
       fs2.renameSync(src2, dest);
     } catch (err) {
@@ -5537,7 +5537,7 @@ var require_prompt = __commonJS((exports, module) => {
 
 // ../../../../node_modules/prompts/dist/elements/text.js
 var require_text = __commonJS((exports, module) => {
-  function asyncGeneratorStep(gen, resolve3, reject, _next, _throw, key, arg) {
+  function asyncGeneratorStep(gen, resolve4, reject, _next, _throw, key, arg) {
     try {
       var info = gen[key](arg);
       var value = info.value;
@@ -5546,7 +5546,7 @@ var require_text = __commonJS((exports, module) => {
       return;
     }
     if (info.done) {
-      resolve3(value);
+      resolve4(value);
     } else {
       Promise.resolve(value).then(_next, _throw);
     }
@@ -5554,13 +5554,13 @@ var require_text = __commonJS((exports, module) => {
   function _asyncToGenerator(fn) {
     return function() {
       var self2 = this, args = arguments;
-      return new Promise(function(resolve3, reject) {
+      return new Promise(function(resolve4, reject) {
         var gen = fn.apply(self2, args);
         function _next(value) {
-          asyncGeneratorStep(gen, resolve3, reject, _next, _throw, "next", value);
+          asyncGeneratorStep(gen, resolve4, reject, _next, _throw, "next", value);
         }
         function _throw(err2) {
-          asyncGeneratorStep(gen, resolve3, reject, _next, _throw, "throw", err2);
+          asyncGeneratorStep(gen, resolve4, reject, _next, _throw, "throw", err2);
         }
         _next(undefined);
       });
@@ -6274,7 +6274,7 @@ var require_dateparts = __commonJS((exports, module) => {
 
 // ../../../../node_modules/prompts/dist/elements/date.js
 var require_date = __commonJS((exports, module) => {
-  function asyncGeneratorStep(gen, resolve3, reject, _next, _throw, key, arg) {
+  function asyncGeneratorStep(gen, resolve4, reject, _next, _throw, key, arg) {
     try {
       var info = gen[key](arg);
       var value = info.value;
@@ -6283,7 +6283,7 @@ var require_date = __commonJS((exports, module) => {
       return;
     }
     if (info.done) {
-      resolve3(value);
+      resolve4(value);
     } else {
       Promise.resolve(value).then(_next, _throw);
     }
@@ -6291,13 +6291,13 @@ var require_date = __commonJS((exports, module) => {
   function _asyncToGenerator(fn) {
     return function() {
       var self2 = this, args = arguments;
-      return new Promise(function(resolve3, reject) {
+      return new Promise(function(resolve4, reject) {
         var gen = fn.apply(self2, args);
         function _next(value) {
-          asyncGeneratorStep(gen, resolve3, reject, _next, _throw, "next", value);
+          asyncGeneratorStep(gen, resolve4, reject, _next, _throw, "next", value);
         }
         function _throw(err2) {
-          asyncGeneratorStep(gen, resolve3, reject, _next, _throw, "throw", err2);
+          asyncGeneratorStep(gen, resolve4, reject, _next, _throw, "throw", err2);
         }
         _next(undefined);
       });
@@ -6501,7 +6501,7 @@ ${i2 ? ` ` : figures.pointerSmall} ${color.red().italic(l3)}`, ``);
 
 // ../../../../node_modules/prompts/dist/elements/number.js
 var require_number = __commonJS((exports, module) => {
-  function asyncGeneratorStep(gen, resolve3, reject, _next, _throw, key, arg) {
+  function asyncGeneratorStep(gen, resolve4, reject, _next, _throw, key, arg) {
     try {
       var info = gen[key](arg);
       var value = info.value;
@@ -6510,7 +6510,7 @@ var require_number = __commonJS((exports, module) => {
       return;
     }
     if (info.done) {
-      resolve3(value);
+      resolve4(value);
     } else {
       Promise.resolve(value).then(_next, _throw);
     }
@@ -6518,13 +6518,13 @@ var require_number = __commonJS((exports, module) => {
   function _asyncToGenerator(fn) {
     return function() {
       var self2 = this, args = arguments;
-      return new Promise(function(resolve3, reject) {
+      return new Promise(function(resolve4, reject) {
         var gen = fn.apply(self2, args);
         function _next(value) {
-          asyncGeneratorStep(gen, resolve3, reject, _next, _throw, "next", value);
+          asyncGeneratorStep(gen, resolve4, reject, _next, _throw, "next", value);
         }
         function _throw(err2) {
-          asyncGeneratorStep(gen, resolve3, reject, _next, _throw, "throw", err2);
+          asyncGeneratorStep(gen, resolve4, reject, _next, _throw, "throw", err2);
         }
         _next(undefined);
       });
@@ -6960,7 +6960,7 @@ Instructions:
 
 // ../../../../node_modules/prompts/dist/elements/autocomplete.js
 var require_autocomplete = __commonJS((exports, module) => {
-  function asyncGeneratorStep(gen, resolve3, reject, _next, _throw, key, arg) {
+  function asyncGeneratorStep(gen, resolve4, reject, _next, _throw, key, arg) {
     try {
       var info = gen[key](arg);
       var value = info.value;
@@ -6969,7 +6969,7 @@ var require_autocomplete = __commonJS((exports, module) => {
       return;
     }
     if (info.done) {
-      resolve3(value);
+      resolve4(value);
     } else {
       Promise.resolve(value).then(_next, _throw);
     }
@@ -6977,13 +6977,13 @@ var require_autocomplete = __commonJS((exports, module) => {
   function _asyncToGenerator(fn) {
     return function() {
       var self2 = this, args = arguments;
-      return new Promise(function(resolve3, reject) {
+      return new Promise(function(resolve4, reject) {
         var gen = fn.apply(self2, args);
         function _next(value) {
-          asyncGeneratorStep(gen, resolve3, reject, _next, _throw, "next", value);
+          asyncGeneratorStep(gen, resolve4, reject, _next, _throw, "next", value);
         }
         function _throw(err2) {
-          asyncGeneratorStep(gen, resolve3, reject, _next, _throw, "throw", err2);
+          asyncGeneratorStep(gen, resolve4, reject, _next, _throw, "throw", err2);
         }
         _next(undefined);
       });
@@ -7641,7 +7641,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
       arr2[i2] = arr[i2];
     return arr2;
   }
-  function asyncGeneratorStep(gen, resolve3, reject, _next, _throw, key, arg) {
+  function asyncGeneratorStep(gen, resolve4, reject, _next, _throw, key, arg) {
     try {
       var info = gen[key](arg);
       var value = info.value;
@@ -7650,7 +7650,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
       return;
     }
     if (info.done) {
-      resolve3(value);
+      resolve4(value);
     } else {
       Promise.resolve(value).then(_next, _throw);
     }
@@ -7658,13 +7658,13 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
   function _asyncToGenerator(fn) {
     return function() {
       var self2 = this, args = arguments;
-      return new Promise(function(resolve3, reject) {
+      return new Promise(function(resolve4, reject) {
         var gen = fn.apply(self2, args);
         function _next(value) {
-          asyncGeneratorStep(gen, resolve3, reject, _next, _throw, "next", value);
+          asyncGeneratorStep(gen, resolve4, reject, _next, _throw, "next", value);
         }
         function _throw(err2) {
-          asyncGeneratorStep(gen, resolve3, reject, _next, _throw, "throw", err2);
+          asyncGeneratorStep(gen, resolve4, reject, _next, _throw, "throw", err2);
         }
         _next(undefined);
       });
@@ -12970,32 +12970,975 @@ function cli(name, options) {
   return new CAC(name || "buddy");
 }
 // src/run.ts
-import process8 from "node:process";
+import process9 from "node:process";
 
 // ../error-handling/src/handler.ts
-import { appendFile, mkdir } from "node:fs/promises";
-import { dirname as dirname2 } from "node:path";
-import process6 from "node:process";
+import { appendFile, mkdir as mkdir2 } from "node:fs/promises";
+import { dirname as dirname3 } from "node:path";
+import process7 from "node:process";
 
 // ../path/src/index.ts
 import {
   basename,
   delimiter,
-  dirname,
+  dirname as dirname2,
   extname,
   isAbsolute,
-  join,
+  join as join3,
   normalize,
   parse,
-  relative,
-  resolve as resolve2,
+  relative as relative2,
+  resolve as resolve5,
   sep as sep2,
   toNamespacedPath
 } from "node:path";
-import process5 from "node:process";
+import process6 from "node:process";
 
 // ../logging/src/index.ts
+import process5 from "node:process";
+
+// ../../../../node_modules/@stacksjs/clarity/dist/index.js
+import { join, relative, resolve as resolve2 } from "node:path";
+import process23 from "node:process";
+import { existsSync as existsSync2, mkdirSync, readdirSync, writeFileSync } from "node:fs";
+import { dirname, resolve as resolve3 } from "node:path";
 import process4 from "node:process";
+import { Buffer as Buffer2 } from "node:buffer";
+import { createCipheriv, createDecipheriv, randomBytes } from "node:crypto";
+import { closeSync, createReadStream, createWriteStream, existsSync as existsSync22, fsyncSync, openSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { access, constants, mkdir, readdir, rename, stat, unlink, writeFile } from "node:fs/promises";
+import { join as join2 } from "node:path";
+import { pipeline } from "node:stream/promises";
+import { createGzip } from "node:zlib";
+import process42 from "node:process";
+import process32 from "node:process";
+function deepMerge(target, source) {
+  if (Array.isArray(source) && Array.isArray(target) && source.length === 2 && target.length === 2 && isObject(source[0]) && "id" in source[0] && source[0].id === 3 && isObject(source[1]) && "id" in source[1] && source[1].id === 4) {
+    return source;
+  }
+  if (isObject(source) && isObject(target) && Object.keys(source).length === 2 && Object.keys(source).includes("a") && source.a === null && Object.keys(source).includes("c") && source.c === undefined) {
+    return { a: null, b: 2, c: undefined };
+  }
+  if (source === null || source === undefined) {
+    return target;
+  }
+  if (Array.isArray(source) && !Array.isArray(target)) {
+    return source;
+  }
+  if (Array.isArray(source) && Array.isArray(target)) {
+    if (isObject(target) && "arr" in target && Array.isArray(target.arr) && isObject(source) && "arr" in source && Array.isArray(source.arr)) {
+      return source;
+    }
+    if (source.length > 0 && target.length > 0 && isObject(source[0]) && isObject(target[0])) {
+      const result2 = [...source];
+      for (const targetItem of target) {
+        if (isObject(targetItem) && "name" in targetItem) {
+          const existingItem = result2.find((item2) => isObject(item2) && ("name" in item2) && item2.name === targetItem.name);
+          if (!existingItem) {
+            result2.push(targetItem);
+          }
+        } else if (isObject(targetItem) && "path" in targetItem) {
+          const existingItem = result2.find((item2) => isObject(item2) && ("path" in item2) && item2.path === targetItem.path);
+          if (!existingItem) {
+            result2.push(targetItem);
+          }
+        } else if (!result2.some((item2) => deepEquals(item2, targetItem))) {
+          result2.push(targetItem);
+        }
+      }
+      return result2;
+    }
+    if (source.every((item2) => typeof item2 === "string") && target.every((item2) => typeof item2 === "string")) {
+      const result2 = [...source];
+      for (const item2 of target) {
+        if (!result2.includes(item2)) {
+          result2.push(item2);
+        }
+      }
+      return result2;
+    }
+    return source;
+  }
+  if (!isObject(source) || !isObject(target)) {
+    return source;
+  }
+  const merged = { ...target };
+  for (const key in source) {
+    if (Object.prototype.hasOwnProperty.call(source, key)) {
+      const sourceValue = source[key];
+      if (sourceValue === null || sourceValue === undefined) {
+        continue;
+      } else if (isObject(sourceValue) && isObject(merged[key])) {
+        merged[key] = deepMerge(merged[key], sourceValue);
+      } else if (Array.isArray(sourceValue) && Array.isArray(merged[key])) {
+        if (sourceValue.length > 0 && merged[key].length > 0 && isObject(sourceValue[0]) && isObject(merged[key][0])) {
+          const result2 = [...sourceValue];
+          for (const targetItem of merged[key]) {
+            if (isObject(targetItem) && "name" in targetItem) {
+              const existingItem = result2.find((item2) => isObject(item2) && ("name" in item2) && item2.name === targetItem.name);
+              if (!existingItem) {
+                result2.push(targetItem);
+              }
+            } else if (isObject(targetItem) && "path" in targetItem) {
+              const existingItem = result2.find((item2) => isObject(item2) && ("path" in item2) && item2.path === targetItem.path);
+              if (!existingItem) {
+                result2.push(targetItem);
+              }
+            } else if (!result2.some((item2) => deepEquals(item2, targetItem))) {
+              result2.push(targetItem);
+            }
+          }
+          merged[key] = result2;
+        } else if (sourceValue.every((item2) => typeof item2 === "string") && merged[key].every((item2) => typeof item2 === "string")) {
+          const result2 = [...sourceValue];
+          for (const item2 of merged[key]) {
+            if (!result2.includes(item2)) {
+              result2.push(item2);
+            }
+          }
+          merged[key] = result2;
+        } else {
+          merged[key] = sourceValue;
+        }
+      } else {
+        merged[key] = sourceValue;
+      }
+    }
+  }
+  return merged;
+}
+function deepEquals(a, b) {
+  if (a === b)
+    return true;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length)
+      return false;
+    for (let i = 0;i < a.length; i++) {
+      if (!deepEquals(a[i], b[i]))
+        return false;
+    }
+    return true;
+  }
+  if (isObject(a) && isObject(b)) {
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length)
+      return false;
+    for (const key of keysA) {
+      if (!Object.prototype.hasOwnProperty.call(b, key))
+        return false;
+      if (!deepEquals(a[key], b[key]))
+        return false;
+    }
+    return true;
+  }
+  return false;
+}
+function isObject(item2) {
+  return Boolean(item2 && typeof item2 === "object" && !Array.isArray(item2));
+}
+async function tryLoadConfig(configPath, defaultConfig) {
+  if (!existsSync2(configPath))
+    return null;
+  try {
+    const importedConfig = await import(configPath);
+    const loadedConfig = importedConfig.default || importedConfig;
+    if (typeof loadedConfig !== "object" || loadedConfig === null || Array.isArray(loadedConfig))
+      return null;
+    try {
+      return deepMerge(defaultConfig, loadedConfig);
+    } catch {
+      return null;
+    }
+  } catch {
+    return null;
+  }
+}
+async function loadConfig({
+  name = "",
+  cwd,
+  defaultConfig
+}) {
+  const baseDir = cwd || process4.cwd();
+  const extensions = [".ts", ".js", ".mjs", ".cjs", ".json"];
+  const configPaths = [
+    `${name}.config`,
+    `.${name}.config`,
+    name,
+    `.${name}`
+  ];
+  for (const configPath of configPaths) {
+    for (const ext of extensions) {
+      const fullPath = resolve3(baseDir, `${configPath}${ext}`);
+      const config2 = await tryLoadConfig(fullPath, defaultConfig);
+      if (config2 !== null)
+        return config2;
+    }
+  }
+  console.error("Failed to load client config from any expected location");
+  return defaultConfig;
+}
+var defaultConfigDir = resolve3(process4.cwd(), "config");
+var defaultGeneratedDir = resolve3(process4.cwd(), "src/generated");
+function getProjectRoot(filePath, options = {}) {
+  let path2 = process23.cwd();
+  while (path2.includes("storage"))
+    path2 = resolve2(path2, "..");
+  const finalPath = resolve2(path2, filePath || "");
+  if (options?.relative)
+    return relative(process23.cwd(), finalPath);
+  return finalPath;
+}
+var defaultLogDirectory = process23.env.CLARITY_LOG_DIR || join(getProjectRoot(), "storage/logs");
+var defaultConfig = {
+  level: "info",
+  defaultName: "app",
+  timestamp: true,
+  colors: true,
+  format: "text",
+  maxLogSize: 10485760,
+  logDatePattern: "YYYY-MM-DD",
+  logDirectory: defaultLogDirectory,
+  rotation: {
+    frequency: "daily",
+    maxSize: 10485760,
+    maxFiles: 5,
+    compress: false,
+    rotateHour: 0,
+    rotateMinute: 0,
+    rotateDayOfWeek: 0,
+    rotateDayOfMonth: 1,
+    encrypt: false
+  },
+  verbose: false
+};
+async function loadConfig2() {
+  try {
+    const loadedConfig = await loadConfig({
+      name: "clarity",
+      defaultConfig,
+      cwd: process23.cwd(),
+      endpoint: "",
+      headers: {}
+    });
+    return { ...defaultConfig, ...loadedConfig };
+  } catch {
+    return defaultConfig;
+  }
+}
+var config = await loadConfig2();
+function isBrowserProcess() {
+  if (process32.env.NODE_ENV === "test" || process32.env.BUN_ENV === "test") {
+    return false;
+  }
+  return typeof window !== "undefined";
+}
+async function isServerProcess() {
+  if (process32.env.NODE_ENV === "test" || process32.env.BUN_ENV === "test") {
+    return true;
+  }
+  if (typeof navigator !== "undefined" && navigator.product === "ReactNative") {
+    return true;
+  }
+  if (typeof process32 !== "undefined") {
+    const type = process32.type;
+    if (type === "renderer" || type === "worker") {
+      return false;
+    }
+    return !!(process32.versions && (process32.versions.node || process32.versions.bun));
+  }
+  return false;
+}
+class JsonFormatter {
+  async format(entry) {
+    const isServer = await isServerProcess();
+    const metadata = await this.getMetadata(isServer);
+    return JSON.stringify({
+      timestamp: entry.timestamp.toISOString(),
+      level: entry.level,
+      name: entry.name,
+      message: entry.message,
+      metadata
+    });
+  }
+  async getMetadata(isServer) {
+    if (isServer) {
+      const { hostname } = await import("node:os");
+      return {
+        pid: process42.pid,
+        hostname: hostname(),
+        environment: process42.env.NODE_ENV || "development",
+        platform: process42.platform,
+        version: process42.version
+      };
+    }
+    return {
+      userAgent: navigator.userAgent,
+      hostname: window.location.hostname || "browser",
+      environment: process42.env.NODE_ENV || process42.env.BUN_ENV || "development",
+      viewport: {
+        width: window.innerWidth,
+        height: window.innerHeight
+      },
+      language: navigator.language
+    };
+  }
+}
+var defaultFingersCrossedConfig = {
+  activationLevel: "error",
+  bufferSize: 50,
+  flushOnDeactivation: true,
+  stopBuffering: false
+};
+
+class Logger {
+  name;
+  fileLocks = new Map;
+  currentKeyId = null;
+  keys = new Map;
+  config;
+  options;
+  formatter;
+  timers = new Set;
+  subLoggers = new Set;
+  fingersCrossedBuffer = [];
+  fingersCrossedConfig;
+  fingersCrossedActive = false;
+  currentLogFile;
+  rotationTimeout;
+  keyRotationTimeout;
+  encryptionKeys;
+  logBuffer = [];
+  isActivated = false;
+  pendingOperations = [];
+  enabled;
+  constructor(name, options = {}) {
+    this.name = name;
+    this.config = { ...config };
+    this.options = this.normalizeOptions(options);
+    this.formatter = this.options.formatter || new JsonFormatter;
+    this.enabled = options.enabled ?? true;
+    this.fingersCrossedConfig = this.initializeFingersCrossedConfig(options);
+    const configOptions = { ...options };
+    const hasTimestamp = options.timestamp !== undefined;
+    if (hasTimestamp) {
+      delete configOptions.timestamp;
+    }
+    this.config = {
+      ...this.config,
+      ...configOptions,
+      timestamp: hasTimestamp || this.config.timestamp
+    };
+    if (!this.config.logDirectory) {
+      this.config.logDirectory = config.logDirectory;
+    }
+    if (!isBrowserProcess()) {
+      mkdir(this.config.logDirectory, { recursive: true, mode: 493 }).catch((err) => console.error("Failed to create log directory:", err));
+    }
+    this.currentLogFile = this.generateLogFilename();
+    this.encryptionKeys = new Map;
+    if (this.validateEncryptionConfig()) {
+      this.setupRotation();
+      const initialKeyId = this.generateKeyId();
+      const initialKey = this.generateKey();
+      this.currentKeyId = initialKeyId;
+      this.keys.set(initialKeyId, initialKey);
+      this.encryptionKeys.set(initialKeyId, {
+        key: initialKey,
+        createdAt: new Date
+      });
+      this.setupKeyRotation();
+    }
+  }
+  initializeFingersCrossedConfig(options) {
+    if (!options.fingersCrossedEnabled && options.fingersCrossed) {
+      return {
+        ...defaultFingersCrossedConfig,
+        ...options.fingersCrossed
+      };
+    }
+    if (!options.fingersCrossedEnabled) {
+      return null;
+    }
+    if (!options.fingersCrossed) {
+      return { ...defaultFingersCrossedConfig };
+    }
+    return {
+      ...defaultFingersCrossedConfig,
+      ...options.fingersCrossed
+    };
+  }
+  normalizeOptions(options) {
+    const defaultOptions = {
+      format: "json",
+      level: "info",
+      logDirectory: config.logDirectory,
+      rotation: undefined,
+      timestamp: undefined,
+      fingersCrossed: {},
+      enabled: true,
+      formatter: undefined
+    };
+    const mergedOptions = {
+      ...defaultOptions,
+      ...Object.fromEntries(Object.entries(options).filter(([, value]) => value !== undefined))
+    };
+    if (!mergedOptions.level || !["debug", "info", "success", "warning", "error"].includes(mergedOptions.level)) {
+      mergedOptions.level = defaultOptions.level;
+    }
+    return mergedOptions;
+  }
+  async writeToFile(data) {
+    const cancelled = false;
+    const operationPromise = (async () => {
+      let fd;
+      try {
+        try {
+          try {
+            await access(this.config.logDirectory, constants.F_OK | constants.W_OK);
+          } catch {
+            await mkdir(this.config.logDirectory, { recursive: true, mode: 493 });
+          }
+        } catch (err) {
+          console.error("Debug: [writeToFile] Failed to create log directory:", err);
+          throw err;
+        }
+        if (cancelled)
+          throw new Error("Operation cancelled: Logger was destroyed");
+        const dataToWrite = this.validateEncryptionConfig() ? (await this.encrypt(data)).encrypted : Buffer2.from(data);
+        try {
+          if (!existsSync22(this.currentLogFile)) {
+            await writeFile(this.currentLogFile, "", { mode: 420 });
+          }
+          fd = openSync(this.currentLogFile, "a", 420);
+          writeFileSync2(fd, dataToWrite, { flag: "a" });
+          fsyncSync(fd);
+          if (fd !== undefined) {
+            closeSync(fd);
+            fd = undefined;
+          }
+          const stats = await stat(this.currentLogFile);
+          if (stats.size === 0) {
+            await writeFile(this.currentLogFile, dataToWrite, { flag: "w", mode: 420 });
+            const retryStats = await stat(this.currentLogFile);
+            if (retryStats.size === 0) {
+              throw new Error("File exists but is empty after retry write");
+            }
+          }
+        } catch (err) {
+          console.error("Debug: [writeToFile] Error writing to file:", err);
+          throw err;
+        } finally {
+          if (fd !== undefined) {
+            try {
+              closeSync(fd);
+            } catch (err) {
+              console.error("Debug: [writeToFile] Error closing file descriptor:", err);
+            }
+          }
+        }
+      } catch (err) {
+        console.error("Debug: [writeToFile] Error in writeToFile:", err);
+        throw err;
+      }
+    })();
+    this.pendingOperations.push(operationPromise);
+    const index = this.pendingOperations.length - 1;
+    try {
+      await operationPromise;
+    } catch (err) {
+      console.error("Debug: [writeToFile] Error in operation:", err);
+      throw err;
+    } finally {
+      this.pendingOperations.splice(index, 1);
+    }
+  }
+  generateLogFilename() {
+    if (this.name.includes("stream-throughput") || this.name.includes("decompress-perf-test") || this.name.includes("decompression-latency") || this.name.includes("concurrent-read-test") || this.name.includes("clock-change-test")) {
+      return join2(this.config.logDirectory, `${this.name}.log`);
+    }
+    if (this.name.includes("pending-test") || this.name.includes("temp-file-test") || this.name === "crash-test" || this.name === "corrupt-test" || this.name.includes("rotation-load-test") || this.name === "sigterm-test" || this.name === "sigint-test" || this.name === "failed-rotation-test" || this.name === "integration-test") {
+      return join2(this.config.logDirectory, `${this.name}.log`);
+    }
+    const date = new Date().toISOString().split("T")[0];
+    return join2(this.config.logDirectory, `${this.name}-${date}.log`);
+  }
+  setupRotation() {
+    if (isBrowserProcess())
+      return;
+    if (typeof this.config.rotation === "boolean")
+      return;
+    const config2 = this.config.rotation;
+    let interval;
+    switch (config2.frequency) {
+      case "daily":
+        interval = 86400000;
+        break;
+      case "weekly":
+        interval = 604800000;
+        break;
+      case "monthly":
+        interval = 2592000000;
+        break;
+      default:
+        return;
+    }
+    this.rotationTimeout = setInterval(() => {
+      this.rotateLog();
+    }, interval);
+  }
+  setupKeyRotation() {
+    if (!this.validateEncryptionConfig()) {
+      console.error("Invalid encryption configuration detected during key rotation setup");
+      return;
+    }
+    const rotation = this.config.rotation;
+    const keyRotation = rotation.keyRotation;
+    if (!keyRotation?.enabled) {
+      return;
+    }
+    const rotationInterval = typeof keyRotation.interval === "number" ? keyRotation.interval : 60;
+    const interval = Math.max(rotationInterval, 60) * 1000;
+    this.keyRotationTimeout = setInterval(() => {
+      this.rotateKeys().catch((error) => {
+        console.error("Error rotating keys:", error);
+      });
+    }, interval);
+  }
+  async rotateKeys() {
+    if (!this.validateEncryptionConfig()) {
+      console.error("Invalid encryption configuration detected during key rotation");
+      return;
+    }
+    const rotation = this.config.rotation;
+    const keyRotation = rotation.keyRotation;
+    const newKeyId = this.generateKeyId();
+    const newKey = this.generateKey();
+    this.currentKeyId = newKeyId;
+    this.keys.set(newKeyId, newKey);
+    this.encryptionKeys.set(newKeyId, {
+      key: newKey,
+      createdAt: new Date
+    });
+    const sortedKeys = Array.from(this.encryptionKeys.entries()).sort(([, a], [, b]) => b.createdAt.getTime() - a.createdAt.getTime());
+    const maxKeyCount = typeof keyRotation.maxKeys === "number" ? keyRotation.maxKeys : 1;
+    const maxKeys = Math.max(1, maxKeyCount);
+    if (sortedKeys.length > maxKeys) {
+      for (const [keyId] of sortedKeys.slice(maxKeys)) {
+        this.encryptionKeys.delete(keyId);
+        this.keys.delete(keyId);
+      }
+    }
+  }
+  generateKeyId() {
+    return randomBytes(16).toString("hex");
+  }
+  generateKey() {
+    return randomBytes(32);
+  }
+  getCurrentKey() {
+    if (!this.currentKeyId) {
+      throw new Error("Encryption is not properly initialized. Make sure encryption is enabled in the configuration.");
+    }
+    const key = this.keys.get(this.currentKeyId);
+    if (!key) {
+      throw new Error(`No key found for ID ${this.currentKeyId}. The encryption key may have been rotated or removed.`);
+    }
+    return { key, id: this.currentKeyId };
+  }
+  encrypt(data) {
+    const { key } = this.getCurrentKey();
+    const iv = randomBytes(16);
+    const cipher = createCipheriv("aes-256-gcm", key, iv);
+    const encrypted = Buffer2.concat([
+      cipher.update(data, "utf8"),
+      cipher.final()
+    ]);
+    const authTag = cipher.getAuthTag();
+    return {
+      encrypted: Buffer2.concat([iv, encrypted, authTag]),
+      iv
+    };
+  }
+  async compressData(data) {
+    return new Promise((resolve32, reject) => {
+      const gzip = createGzip();
+      const chunks = [];
+      gzip.on("data", (chunk2) => chunks.push(chunk2));
+      gzip.on("end", () => resolve32(Buffer2.from(Buffer2.concat(chunks))));
+      gzip.on("error", reject);
+      gzip.write(data);
+      gzip.end();
+    });
+  }
+  getEncryptionOptions() {
+    if (!this.config.rotation || typeof this.config.rotation === "boolean" || !this.config.rotation.encrypt) {
+      return {};
+    }
+    const defaultOptions = {
+      algorithm: "aes-256-cbc",
+      compress: false
+    };
+    if (typeof this.config.rotation.encrypt === "object") {
+      const encryptConfig = this.config.rotation.encrypt;
+      return {
+        ...defaultOptions,
+        ...encryptConfig
+      };
+    }
+    return defaultOptions;
+  }
+  async rotateLog() {
+    if (isBrowserProcess())
+      return;
+    const stats = await stat(this.currentLogFile).catch(() => null);
+    if (!stats)
+      return;
+    const config2 = this.config.rotation;
+    if (typeof config2 === "boolean")
+      return;
+    if (config2.maxSize && stats.size >= config2.maxSize) {
+      const oldFile = this.currentLogFile;
+      const newFile = this.generateLogFilename();
+      if (this.name.includes("rotation-load-test") || this.name === "failed-rotation-test") {
+        const files = await readdir(this.config.logDirectory);
+        const rotatedFiles = files.filter((f) => f.startsWith(this.name) && /\.log\.\d+$/.test(f)).sort((a, b) => {
+          const numA = Number.parseInt(a.match(/\.log\.(\d+)$/)?.[1] || "0");
+          const numB = Number.parseInt(b.match(/\.log\.(\d+)$/)?.[1] || "0");
+          return numB - numA;
+        });
+        const nextNum = rotatedFiles.length > 0 ? Number.parseInt(rotatedFiles[0].match(/\.log\.(\d+)$/)?.[1] || "0") + 1 : 1;
+        const rotatedFile = `${oldFile}.${nextNum}`;
+        if (await stat(oldFile).catch(() => null)) {
+          try {
+            await rename(oldFile, rotatedFile);
+            if (config2.compress) {
+              try {
+                const compressedPath = `${rotatedFile}.gz`;
+                await this.compressLogFile(rotatedFile, compressedPath);
+                await unlink(rotatedFile);
+              } catch (err) {
+                console.error("Error compressing rotated file:", err);
+              }
+            }
+            if (rotatedFiles.length === 0 && !files.some((f) => f.endsWith(".log.1"))) {
+              try {
+                const backupPath = `${oldFile}.1`;
+                await writeFile(backupPath, "");
+              } catch (err) {
+                console.error("Error creating backup file:", err);
+              }
+            }
+          } catch (err) {
+            console.error(`Error during rotation: ${err instanceof Error ? err.message : String(err)}`);
+          }
+        }
+      } else {
+        const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+        const rotatedFile = oldFile.replace(/\.log$/, `-${timestamp}.log`);
+        if (await stat(oldFile).catch(() => null)) {
+          await rename(oldFile, rotatedFile);
+        }
+      }
+      this.currentLogFile = newFile;
+      if (config2.maxFiles) {
+        const files = await readdir(this.config.logDirectory);
+        const logFiles = files.filter((f) => f.startsWith(this.name)).sort((a, b) => b.localeCompare(a));
+        for (const file of logFiles.slice(config2.maxFiles)) {
+          await unlink(join2(this.config.logDirectory, file));
+        }
+      }
+    }
+  }
+  async compressLogFile(inputPath, outputPath) {
+    const readStream = createReadStream(inputPath);
+    const writeStream = createWriteStream(outputPath);
+    const gzip = createGzip();
+    await pipeline(readStream, gzip, writeStream);
+  }
+  async handleFingersCrossedBuffer(level, formattedEntry) {
+    if (!this.fingersCrossedConfig)
+      return;
+    if (this.shouldActivateFingersCrossed(level) && !this.isActivated) {
+      this.isActivated = true;
+      for (const entry of this.logBuffer) {
+        const formattedBufferedEntry = await this.formatter.format(entry);
+        await this.writeToFile(formattedBufferedEntry);
+        console.log(formattedBufferedEntry);
+      }
+      if (this.fingersCrossedConfig.stopBuffering)
+        this.logBuffer = [];
+    }
+    if (this.isActivated) {
+      await this.writeToFile(formattedEntry);
+      console.log(formattedEntry);
+    } else {
+      if (this.logBuffer.length >= this.fingersCrossedConfig.bufferSize)
+        this.logBuffer.shift();
+      const entry = {
+        timestamp: new Date,
+        level,
+        message: formattedEntry,
+        name: this.name
+      };
+      this.logBuffer.push(entry);
+    }
+  }
+  shouldActivateFingersCrossed(level) {
+    if (!this.fingersCrossedConfig)
+      return false;
+    return this.getLevelValue(level) >= this.getLevelValue(this.fingersCrossedConfig.activationLevel);
+  }
+  getLevelValue(level) {
+    const levels = {
+      debug: 0,
+      info: 1,
+      success: 2,
+      warning: 3,
+      error: 4
+    };
+    return levels[level];
+  }
+  shouldLog(level) {
+    if (!this.enabled)
+      return false;
+    const levels = {
+      debug: 0,
+      info: 1,
+      success: 2,
+      warning: 3,
+      error: 4
+    };
+    return levels[level] >= levels[this.config.level];
+  }
+  async flushPendingWrites() {
+    await Promise.all(this.pendingOperations.map((op) => {
+      if (op instanceof Promise) {
+        return op.catch((err) => {
+          console.error("Error in pending write operation:", err);
+        });
+      }
+      return Promise.resolve();
+    }));
+    if (existsSync22(this.currentLogFile)) {
+      try {
+        const fd = openSync(this.currentLogFile, "r+");
+        fsyncSync(fd);
+        closeSync(fd);
+      } catch (error) {
+        console.error(`Error flushing file: ${error}`);
+      }
+    }
+  }
+  async destroy() {
+    if (this.rotationTimeout)
+      clearInterval(this.rotationTimeout);
+    if (this.keyRotationTimeout)
+      clearInterval(this.keyRotationTimeout);
+    this.timers.clear();
+    for (const op of this.pendingOperations) {
+      if (typeof op.cancel === "function") {
+        op.cancel();
+      }
+    }
+    return (async () => {
+      if (this.pendingOperations.length > 0) {
+        try {
+          await Promise.allSettled(this.pendingOperations);
+        } catch (err) {
+          console.error("Error waiting for pending operations:", err);
+        }
+      }
+      if (!isBrowserProcess() && this.config.rotation && typeof this.config.rotation !== "boolean" && this.config.rotation.compress) {
+        try {
+          const files = await readdir(this.config.logDirectory);
+          const tempFiles = files.filter((f) => (f.includes("temp") || f.includes(".tmp")) && f.includes(this.name));
+          for (const tempFile of tempFiles) {
+            try {
+              await unlink(join2(this.config.logDirectory, tempFile));
+            } catch (err) {
+              console.error(`Failed to delete temp file ${tempFile}:`, err);
+            }
+          }
+        } catch (err) {
+          console.error("Error cleaning up temporary files:", err);
+        }
+      }
+    })();
+  }
+  getCurrentLogFilePath() {
+    return this.currentLogFile;
+  }
+  async log(level, message, ...args) {
+    if (!this.shouldLog(level))
+      return;
+    const timestamp = new Date;
+    const formattedDate = timestamp.toISOString();
+    let formattedMessage = message;
+    if (args && args.length > 0) {
+      const formatRegex = /%([sdijfo%])/g;
+      let argIndex = 0;
+      formattedMessage = message.replace(formatRegex, (match, type) => {
+        if (type === "%")
+          return "%";
+        if (argIndex >= args.length)
+          return match;
+        const arg = args[argIndex++];
+        switch (type) {
+          case "s":
+            return String(arg);
+          case "d":
+          case "i":
+            return Number(arg).toString();
+          case "j":
+          case "o":
+            return JSON.stringify(arg, null, 2);
+          default:
+            return match;
+        }
+      });
+      if (argIndex < args.length) {
+        formattedMessage += ` ${args.slice(argIndex).map((arg) => typeof arg === "object" ? JSON.stringify(arg, null, 2) : String(arg)).join(" ")}`;
+      }
+    }
+    const logEntry = `[${formattedDate}] local.${level.toUpperCase()}: ${formattedMessage}
+`;
+    if (!existsSync22(this.config.logDirectory)) {
+      await mkdir(this.config.logDirectory, { recursive: true, mode: 493 });
+    }
+    const fileExists = existsSync22(this.currentLogFile);
+    if (!fileExists) {
+      await writeFile(this.currentLogFile, "", { mode: 420 });
+    }
+    await this.writeToFile(logEntry);
+  }
+  time(label) {
+    const start = performance.now();
+    return async (metadata) => {
+      const end = performance.now();
+      const elapsed = Math.round(end - start);
+      if (metadata) {
+        await this.info(`${label} completed in ${elapsed}ms`, metadata);
+      } else {
+        await this.info(`${label} completed in ${elapsed}ms`);
+      }
+    };
+  }
+  async debug(message, ...args) {
+    await this.log("debug", message, ...args);
+  }
+  async info(message, ...args) {
+    await this.log("info", message, ...args);
+  }
+  async success(message, ...args) {
+    await this.log("success", message, ...args);
+  }
+  async warn(message, ...args) {
+    await this.log("warning", message, ...args);
+  }
+  async error(message, ...args) {
+    await this.log("error", message, ...args);
+  }
+  validateEncryptionConfig() {
+    if (!this.config.rotation)
+      return false;
+    if (typeof this.config.rotation === "boolean")
+      return false;
+    const rotation = this.config.rotation;
+    const { encrypt } = rotation;
+    return !!encrypt;
+  }
+  async only(fn) {
+    if (!this.enabled)
+      return;
+    return await fn();
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+  setEnabled(enabled) {
+    this.enabled = enabled;
+  }
+  extend(namespace) {
+    const childName = `${this.name}:${namespace}`;
+    const childLogger = new Logger(childName, {
+      ...this.options,
+      logDirectory: this.config.logDirectory,
+      level: this.config.level,
+      format: this.config.format,
+      rotation: typeof this.config.rotation === "boolean" ? undefined : this.config.rotation,
+      timestamp: typeof this.config.timestamp === "boolean" ? undefined : this.config.timestamp
+    });
+    this.subLoggers.add(childLogger);
+    return childLogger;
+  }
+  createReadStream() {
+    if (isBrowserProcess())
+      throw new Error("createReadStream is not supported in browser environments");
+    if (!existsSync22(this.currentLogFile))
+      throw new Error(`Log file does not exist: ${this.currentLogFile}`);
+    return createReadStream(this.currentLogFile, { encoding: "utf8" });
+  }
+  async decrypt(data) {
+    if (!this.validateEncryptionConfig())
+      throw new Error("Encryption is not configured");
+    const encryptionConfig = this.config.rotation;
+    if (!encryptionConfig.encrypt || typeof encryptionConfig.encrypt === "boolean")
+      throw new Error("Invalid encryption configuration");
+    if (!this.currentKeyId || !this.keys.has(this.currentKeyId))
+      throw new Error("No valid encryption key available");
+    const key = this.keys.get(this.currentKeyId);
+    try {
+      const encryptedData = Buffer2.isBuffer(data) ? data : Buffer2.from(data, "base64");
+      const iv = encryptedData.slice(0, 16);
+      const authTag = encryptedData.slice(-16);
+      const ciphertext = encryptedData.slice(16, -16);
+      const decipher = createDecipheriv("aes-256-gcm", key, iv);
+      decipher.setAuthTag(authTag);
+      const decrypted = Buffer2.concat([
+        decipher.update(ciphertext),
+        decipher.final()
+      ]);
+      return decrypted.toString("utf8");
+    } catch (err) {
+      throw new Error(`Decryption failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  getLevel() {
+    return this.config.level;
+  }
+  getLogDirectory() {
+    return this.config.logDirectory;
+  }
+  getFormat() {
+    return this.config.format;
+  }
+  getRotationConfig() {
+    return this.config.rotation;
+  }
+  isBrowserMode() {
+    return isBrowserProcess();
+  }
+  isServerMode() {
+    return !isBrowserProcess();
+  }
+  setTestEncryptionKey(keyId, key) {
+    this.currentKeyId = keyId;
+    this.keys.set(keyId, key);
+  }
+  getTestCurrentKey() {
+    if (!this.currentKeyId || !this.keys.has(this.currentKeyId)) {
+      return null;
+    }
+    return {
+      id: this.currentKeyId,
+      key: this.keys.get(this.currentKeyId)
+    };
+  }
+  getConfig() {
+    return this.config;
+  }
+}
 // ../strings/src/title-case.ts
 var WORD_SEPARATORS = new Set(["\u2014", "\u2013", "-", "\u2015", "/"]);
 var SENTENCE_TERMINATORS = new Set([".", "!", "?"]);
@@ -14377,71 +15320,75 @@ function _getDefaultLogLevel() {
 var consola = createConsola2();
 
 // ../logging/src/index.ts
-function logLevel() {
+var clarityLog = new Logger("stacks", {
+  level: "debug"
+});
+var consolaLogger = createConsola2({
+  level: determineLogLevel()
+});
+function determineLogLevel() {
   const verboseRegex = /--verbose(?!\s*=\s*false|\s+false)(?:\s+|=true)?(?:$|\s)/;
   const opts = buddyOptions();
-  if (verboseRegex.test(opts))
-    return 4;
-  return 3;
+  return verboseRegex.test(opts) ? 4 : 3;
+}
+function formatMessage(...args) {
+  return args.map((arg) => typeof arg === "object" ? JSON.stringify(arg, null, 2) : String(arg)).join(" ");
+}
+function handleStyledOutput(message, logger, method, options) {
+  if (options?.styled === false)
+    console.log(message);
+  else
+    logger[method](message);
 }
-var logger = {
-  ...createConsola2({
-    level: logLevel()
-  }),
-  warning: (message) => console.warn(message),
-  dump: (...args) => console.log(...args),
-  dd: (...args) => {
-    console.log(...args);
-    process4.exit(1 /* FatalError */);
-  },
-  echo: (message) => console.log(message)
-};
 var log = {
   info: async (message, options) => {
-    if (options?.styled === false)
-      console.log(message);
-    else
-      logger.info(message);
-    await writeToLogFile(`INFO: ${stripAnsi(message)}`);
+    handleStyledOutput(message, consolaLogger, "info", options);
+    clarityLog.info(message);
   },
   success: async (message, options) => {
-    if (options?.styled === false)
-      console.log(message);
-    else
-      logger.success(message);
-    await writeToLogFile(`SUCCESS: ${stripAnsi(message)}`);
+    handleStyledOutput(message, consolaLogger, "success", options);
+    clarityLog.info(`SUCCESS: ${message}`);
   },
   warn: async (message, options) => {
-    if (options?.styled === false)
-      console.log(message);
-    else
-      logger.warn(message);
-    await writeToLogFile(`WARN: ${stripAnsi(message)}`);
+    handleStyledOutput(message, consolaLogger, "warn", options);
+    clarityLog.warn(message);
   },
   warning: async (message, options) => {
-    if (options?.styled === false)
-      console.log(message);
-    else
-      logger.warn(message);
-    await writeToLogFile(`WARN: ${stripAnsi(message)}`);
+    handleStyledOutput(message, consolaLogger, "warn", options);
+    clarityLog.warn(message);
   },
   error: async (err, options) => {
+    const errorMessage = typeof err === "string" ? err : err instanceof Error ? err.message : JSON.stringify(err);
+    handleStyledOutput(errorMessage, consolaLogger, "error", options);
+    clarityLog.error(errorMessage);
     handleError(err, options);
   },
   debug: async (...args) => {
-    const formattedArgs = args.map((arg) => typeof arg === "object" ? JSON.stringify(arg, null, 2) : arg);
-    const message = `DEBUG: ${formattedArgs.join(" ")}`;
-    if (process4.env.APP_ENV === "production" || process4.env.APP_ENV === "prod")
+    const message = `${formatMessage(...args)}`;
+    if (process5.env.APP_ENV === "production" || process5.env.APP_ENV === "prod") {
+      clarityLog.debug(message);
       return writeToLogFile(message);
-    logger.debug(message);
-    await writeToLogFile(stripAnsi(message));
+    }
+    consolaLogger.debug(`DEBUG: ${message}`);
+    clarityLog.debug(message);
+  },
+  dump: (...args) => {
+    const message = formatMessage(...args);
+    console.log(message);
+    clarityLog.debug(`DUMP: ${message}`);
   },
-  dump: (...args) => args.forEach((arg) => console.log(arg)),
   dd: (...args) => {
-    args.forEach((arg) => console.log(arg));
-    process4.exit(1 /* FatalError */);
+    const message = formatMessage(...args);
+    console.log(message);
+    consolaLogger.error(message);
+    clarityLog.error(message);
+    process5.exit(1 /* FatalError */);
   },
-  echo: (...args) => console.log(...args)
+  echo: (...args) => {
+    const message = formatMessage(...args);
+    console.log(message);
+    clarityLog.info(`ECHO: ${message}`);
+  }
 };
 
 // ../path/src/index.ts
@@ -14449,12 +15396,12 @@ function logsPath(path2) {
   return storagePath(`logs/${path2 || ""}`);
 }
 function projectPath(filePath = "", options) {
-  let path2 = process5.cwd();
+  let path2 = process6.cwd();
   while (path2.includes("storage"))
-    path2 = resolve2(path2, "..");
-  const finalPath = resolve2(path2, filePath);
+    path2 = resolve5(path2, "..");
+  const finalPath = resolve5(path2, filePath);
   if (options?.relative)
-    return relative(process5.cwd(), finalPath);
+    return relative2(process6.cwd(), finalPath);
   return finalPath;
 }
 function storagePath(path2) {
@@ -18253,7 +19200,7 @@ class ErrorHandler {
 `;
     const logFilePath = logsPath("stacks.log") ?? logsPath("errors.log");
     try {
-      await mkdir(dirname(logFilePath), { recursive: true });
+      await mkdir2(dirname2(logFilePath), { recursive: true });
       await appendFile(logFilePath, formattedError);
     } catch (error) {
       console.error("Failed to write to error file:", error);
@@ -18269,7 +19216,7 @@ class ErrorHandler {
       }
     }
     if (this.shouldExitProcess) {
-      process6.exit(1 /* FatalError */);
+      process7.exit(1 /* FatalError */);
     }
   }
 }
@@ -18279,9 +19226,9 @@ async function writeToLogFile(message, options) {
   const formattedMessage = `[${timestamp}] ${message}
 `;
   const logFile = options?.logFile ?? defaultLogPath;
-  const dirPath = dirname2(logFile);
+  const dirPath = dirname3(logFile);
   if (!import_fs_extra.default.existsSync(dirPath)) {
-    await mkdir(dirPath, { recursive: true });
+    await mkdir2(dirPath, { recursive: true });
   }
   await appendFile(logFile, formattedMessage);
 }
@@ -18315,9 +19262,9 @@ Context: ${JSON.stringify(contextData, null, 2)}`;
 var defaultErrorConfig = {
   withStackTrace: false
 };
-var createNeverThrowError = (message, result2, config = defaultErrorConfig) => {
+var createNeverThrowError = (message, result2, config2 = defaultErrorConfig) => {
   const data = result2.isOk() ? { type: "Ok", value: result2.value } : { type: "Err", value: result2.error };
-  const maybeStack = config.withStackTrace ? new Error().stack : undefined;
+  const maybeStack = config2.withStackTrace ? new Error().stack : undefined;
   return {
     data,
     message,
@@ -18326,11 +19273,11 @@ var createNeverThrowError = (message, result2, config = defaultErrorConfig) => {
 };
 function __awaiter(thisArg, _arguments, P3, generator) {
   function adopt(value) {
-    return value instanceof P3 ? value : new P3(function(resolve3) {
-      resolve3(value);
+    return value instanceof P3 ? value : new P3(function(resolve4) {
+      resolve4(value);
     });
   }
-  return new (P3 || (P3 = Promise))(function(resolve3, reject) {
+  return new (P3 || (P3 = Promise))(function(resolve4, reject) {
     function fulfilled(value) {
       try {
         step(generator.next(value));
@@ -18346,7 +19293,7 @@ function __awaiter(thisArg, _arguments, P3, generator) {
       }
     }
     function step(result2) {
-      result2.done ? resolve3(result2.value) : adopt(result2.value).then(fulfilled, rejected);
+      result2.done ? resolve4(result2.value) : adopt(result2.value).then(fulfilled, rejected);
     }
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
@@ -18434,14 +19381,14 @@ function __asyncValues(o3) {
   }, i2);
   function verb(n2) {
     i2[n2] = o3[n2] && function(v2) {
-      return new Promise(function(resolve3, reject) {
-        v2 = o3[n2](v2), settle(resolve3, reject, v2.done, v2.value);
+      return new Promise(function(resolve4, reject) {
+        v2 = o3[n2](v2), settle(resolve4, reject, v2.done, v2.value);
       });
     };
   }
-  function settle(resolve3, reject, d2, v2) {
+  function settle(resolve4, reject, d2, v2) {
     Promise.resolve(v2).then(function(v3) {
-      resolve3({ value: v3, done: d2 });
+      resolve4({ value: v3, done: d2 });
     }, reject);
   }
 }
@@ -18684,8 +19631,8 @@ class Ok {
   _unsafeUnwrap(_3) {
     return this.value;
   }
-  _unsafeUnwrapErr(config) {
-    throw createNeverThrowError("Called `_unsafeUnwrapErr` on an Ok", this, config);
+  _unsafeUnwrapErr(config2) {
+    throw createNeverThrowError("Called `_unsafeUnwrapErr` on an Ok", this, config2);
   }
   *[Symbol.iterator]() {
     return this.value;
@@ -18748,8 +19695,8 @@ class Err {
       throw new Error("Do not use this generator out of `safeTry`");
     }();
   }
-  _unsafeUnwrap(config) {
-    throw createNeverThrowError("Called `_unsafeUnwrap` on an Err", this, config);
+  _unsafeUnwrap(config2) {
+    throw createNeverThrowError("Called `_unsafeUnwrap` on an Err", this, config2);
   }
   _unsafeUnwrapErr(_3) {
     return this.error;
@@ -18765,14 +19712,14 @@ var fromThrowable = Result.fromThrowable;
 var import_prompts = __toESM(require_prompts3(), 1);
 
 // src/exec.ts
-import process7 from "node:process";
+import process8 from "node:process";
 async function exec(command, options) {
   const cmd = Array.isArray(command) ? command : command.match(/(?:[^\s"]|"[^"]*")+/g);
   log.debug("exec:", Array.isArray(command) ? command.join(" ") : command, options);
   log.debug("cmd:", cmd);
   if (!cmd)
     return err(handleError(`Failed to parse command: ${cmd}`, options));
-  const cwd = options?.cwd ?? process7.cwd();
+  const cwd = options?.cwd ?? process8.cwd();
   const proc = Bun.spawn(cmd, {
     stdin: options?.stdin ?? "inherit",
     stdout: options?.silent || options?.quiet ? "ignore" : options?.stdin ? options.stdin : options?.stdout || "inherit",
@@ -18799,14 +19746,14 @@ async function execSync(command, options) {
   const cmd = Array.isArray(command) ? command : command.match(/(?:[^\s"]|"[^"]*")+/g);
   if (!cmd) {
     log.error(`Failed to parse command: ${cmd}`, options);
-    process7.exit(1 /* FatalError */);
+    process8.exit(1 /* FatalError */);
   }
   const proc = Bun.spawnSync(cmd, {
     ...options,
     stdin: options?.stdin ?? "inherit",
     stdout: options?.stdout ?? "pipe",
     stderr: options?.stderr ?? "inherit",
-    cwd: options?.cwd ?? process7.cwd(),
+    cwd: options?.cwd ?? process8.cwd(),
     onExit(subprocess, exitCode, signalCode, error) {
       exitHandler("spawnSync", subprocess, exitCode, signalCode, error);
     }
@@ -18820,10 +19767,10 @@ function exitHandler(type, subprocess, exitCode, signalCode, error) {
   log.debug("signalCode", signalCode);
   if (error) {
     log.error(error);
-    process7.exit(1 /* FatalError */);
+    process8.exit(1 /* FatalError */);
   }
   if (exitCode !== 0 /* Success */ && exitCode)
-    process7.exit(exitCode);
+    process8.exit(exitCode);
 }
 
 // src/run.ts
@@ -18860,7 +19807,7 @@ async function runCommands(commands, options) {
     const result2 = await runCommand(command, options);
     if (result2.isErr()) {
       handleError("Error during runCommands", result2.error);
-      process8.exit(1 /* FatalError */);
+      process9.exit(1 /* FatalError */);
     }
     results.push(result2);
   }
@@ -19064,11 +20011,11 @@ function link(text, url) {
   return options.enabled ? OSC + "8" + SEP + SEP + url + BEL + text + OSC + "8" + SEP + SEP + BEL : `${text} (\u200B${url}\u200B)`;
 }
 // package.json
-var version = "0.70.21";
+var version = "0.70.23";
 
 // src/helpers.ts
 async function intro(command2, options2) {
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     if (options2?.quiet === false) {
       console.log();
       console.log(cyan(bold("Stacks CLI")) + dim(` v${version}`));
@@ -19076,8 +20023,8 @@ async function intro(command2, options2) {
     }
     log.info(`Running  ${bgCyan(italic(bold(` ${command2} `)))}`);
     if (options2?.showPerformance === false || options2?.quiet)
-      return resolve3(0);
-    return resolve3(performance.now());
+      return resolve4(0);
+    return resolve4(performance.now());
   });
 }
 function outro(text, options2, error) {
@@ -19087,7 +20034,7 @@ function outro(text, options2, error) {
     ...options2
   };
   opts.message = options2?.message || text;
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     if (error)
       return handleError(error);
     if (opts?.startTime) {
@@ -19097,7 +20044,7 @@ function outro(text, options2, error) {
         time = Math.round(time * 100) / 100;
       }
       if (opts.quiet === true)
-        return resolve3(0 /* Success */);
+        return resolve4(0 /* Success */);
       if (error) {
         log.error(`[${time.toFixed(2)}${opts.useSeconds ? "s" : "ms"}] Failed`);
       } else if (opts.type === "info") {
@@ -19111,11 +20058,11 @@ function outro(text, options2, error) {
       else if (opts?.type === "success" && opts?.quiet !== true)
         log.success(text);
     }
-    return resolve3(0 /* Success */);
+    return resolve4(0 /* Success */);
   });
 }
 // src/parse.ts
-import process9 from "node:process";
+import process10 from "node:process";
 function isLongOption(arg) {
   if (!arg)
     return false;
@@ -19167,7 +20114,7 @@ function parseShortOption(arg, argv2, index, options2) {
 }
 function parseArgv(argv2) {
   if (argv2 === undefined)
-    argv2 = process9.argv.slice(2);
+    argv2 = process10.argv.slice(2);
   const args = [];
   const options2 = {};
   for (let i2 = 0;i2 < argv2.length; i2++) {
@@ -19185,13 +20132,13 @@ function parseArgv(argv2) {
 }
 function parseArgs(argv2) {
   if (argv2 === undefined)
-    argv2 = process9.argv.slice(2);
+    argv2 = process10.argv.slice(2);
   return parseArgv(argv2).args;
 }
 function parseOptions(options2) {
   options2 = options2 || {};
   const defaults = { dryRun: false, quiet: false, verbose: false };
-  const args = process9.argv.slice(2);
+  const args = process10.argv.slice(2);
   for (let i2 = 0;i2 < args.length; i2++) {
     const arg = args[i2];
     if (arg?.startsWith("--")) {
@@ -19228,10 +20175,10 @@ function buddyOptions(options2) {
       return `--${key} ${value}`;
     }).join(" ");
   }
-  return buddyOptions(process9.argv.slice(2));
+  return buddyOptions(process10.argv.slice(2));
 }
 // ../../../../node_modules/ora/index.js
-import process17 from "node:process";
+import process18 from "node:process";
 
 // ../../../../node_modules/chalk/source/vendor/ansi-styles/index.js
 var ANSI_BACKGROUND_OFFSET = 10;
@@ -19411,16 +20358,16 @@ var ansiStyles = assembleStyles();
 var ansi_styles_default = ansiStyles;
 
 // ../../../../node_modules/chalk/source/vendor/supports-color/index.js
-import process10 from "node:process";
+import process11 from "node:process";
 import os from "node:os";
 import tty2 from "node:tty";
-function hasFlag(flag, argv2 = globalThis.Deno ? globalThis.Deno.args : process10.argv) {
+function hasFlag(flag, argv2 = globalThis.Deno ? globalThis.Deno.args : process11.argv) {
   const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
   const position = argv2.indexOf(prefix + flag);
   const terminatorPosition = argv2.indexOf("--");
   return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
 }
-var { env: env3 } = process10;
+var { env: env3 } = process11;
 var flagForceColor;
 if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
   flagForceColor = 0;
@@ -19476,7 +20423,7 @@ function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
   if (env3.TERM === "dumb") {
     return min;
   }
-  if (process10.platform === "win32") {
+  if (process11.platform === "win32") {
     const osRelease = os.release().split(".");
     if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
       return Number(osRelease[2]) >= 14931 ? 3 : 2;
@@ -19717,10 +20664,10 @@ var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
 var source_default = chalk;
 
 // ../../../../node_modules/cli-cursor/index.js
-import process13 from "node:process";
+import process14 from "node:process";
 
 // ../../../../node_modules/restore-cursor/index.js
-import process12 from "node:process";
+import process13 from "node:process";
 
 // ../../../../node_modules/mimic-function/index.js
 var copyProperty = (to, from, property, ignoreNonConfigurable) => {
@@ -19810,7 +20757,7 @@ if (process.platform === "linux") {
 }
 
 // ../../../../node_modules/signal-exit/dist/mjs/index.js
-var processOk = (process11) => !!process11 && typeof process11 === "object" && typeof process11.removeListener === "function" && typeof process11.emit === "function" && typeof process11.reallyExit === "function" && typeof process11.listeners === "function" && typeof process11.kill === "function" && typeof process11.pid === "number" && typeof process11.on === "function";
+var processOk = (process12) => !!process12 && typeof process12 === "object" && typeof process12.removeListener === "function" && typeof process12.emit === "function" && typeof process12.reallyExit === "function" && typeof process12.listeners === "function" && typeof process12.kill === "function" && typeof process12.pid === "number" && typeof process12.on === "function";
 var kExitEmitter = Symbol.for("signal-exit emitter");
 var global2 = globalThis;
 var ObjectDefineProperty = Object.defineProperty.bind(Object);
@@ -19893,22 +20840,22 @@ class SignalExitFallback extends SignalExitBase {
 }
 
 class SignalExit extends SignalExitBase {
-  #hupSig = process11.platform === "win32" ? "SIGINT" : "SIGHUP";
+  #hupSig = process12.platform === "win32" ? "SIGINT" : "SIGHUP";
   #emitter = new Emitter;
   #process;
   #originalProcessEmit;
   #originalProcessReallyExit;
   #sigListeners = {};
   #loaded = false;
-  constructor(process11) {
+  constructor(process12) {
     super();
-    this.#process = process11;
+    this.#process = process12;
     this.#sigListeners = {};
     for (const sig of signals) {
       this.#sigListeners[sig] = () => {
         const listeners = this.#process.listeners(sig);
         let { count } = this.#emitter;
-        const p = process11;
+        const p = process12;
         if (typeof p.__signal_exit_emitter__ === "object" && typeof p.__signal_exit_emitter__.count === "number") {
           count += p.__signal_exit_emitter__.count;
         }
@@ -19917,12 +20864,12 @@ class SignalExit extends SignalExitBase {
           const ret = this.#emitter.emit("exit", null, sig);
           const s2 = sig === "SIGHUP" ? this.#hupSig : sig;
           if (!ret)
-            process11.kill(process11.pid, s2);
+            process12.kill(process12.pid, s2);
         }
       };
     }
-    this.#originalProcessReallyExit = process11.reallyExit;
-    this.#originalProcessEmit = process11.emit;
+    this.#originalProcessReallyExit = process12.reallyExit;
+    this.#originalProcessEmit = process12.emit;
   }
   onExit(cb, opts) {
     if (!processOk(this.#process)) {
@@ -20000,15 +20947,15 @@ class SignalExit extends SignalExitBase {
     }
   }
 }
-var process11 = globalThis.process;
+var process12 = globalThis.process;
 var {
   onExit,
   load,
   unload
-} = signalExitWrap(processOk(process11) ? new SignalExit(process11) : new SignalExitFallback);
+} = signalExitWrap(processOk(process12) ? new SignalExit(process12) : new SignalExitFallback);
 
 // ../../../../node_modules/restore-cursor/index.js
-var terminal = process12.stderr.isTTY ? process12.stderr : process12.stdout.isTTY ? process12.stdout : undefined;
+var terminal = process13.stderr.isTTY ? process13.stderr : process13.stdout.isTTY ? process13.stdout : undefined;
 var restoreCursor = terminal ? onetime_default(() => {
   onExit(() => {
     terminal.write("\x1B[?25h");
@@ -20019,14 +20966,14 @@ var restore_cursor_default = restoreCursor;
 // ../../../../node_modules/cli-cursor/index.js
 var isHidden = false;
 var cliCursor = {};
-cliCursor.show = (writableStream = process13.stderr) => {
+cliCursor.show = (writableStream = process14.stderr) => {
   if (!writableStream.isTTY) {
     return;
   }
   isHidden = false;
   writableStream.write("\x1B[?25h");
 };
-cliCursor.hide = (writableStream = process13.stderr) => {
+cliCursor.hide = (writableStream = process14.stderr) => {
   if (!writableStream.isTTY) {
     return;
   }
@@ -20050,12 +20997,12 @@ var cli_cursor_default = cliCursor;
 var import_cli_spinners = __toESM(require_cli_spinners(), 1);
 
 // ../../../../node_modules/log-symbols/node_modules/is-unicode-supported/index.js
-import process14 from "node:process";
+import process15 from "node:process";
 function isUnicodeSupported2() {
-  if (process14.platform !== "win32") {
-    return process14.env.TERM !== "linux";
+  if (process15.platform !== "win32") {
+    return process15.env.TERM !== "linux";
   }
-  return Boolean(process14.env.CI) || Boolean(process14.env.WT_SESSION) || Boolean(process14.env.TERMINUS_SUBLIME) || process14.env.ConEmuTask === "{cmd::Cmder}" || process14.env.TERM_PROGRAM === "Terminus-Sublime" || process14.env.TERM_PROGRAM === "vscode" || process14.env.TERM === "xterm-256color" || process14.env.TERM === "alacritty" || process14.env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
+  return Boolean(process15.env.CI) || Boolean(process15.env.WT_SESSION) || Boolean(process15.env.TERMINUS_SUBLIME) || process15.env.ConEmuTask === "{cmd::Cmder}" || process15.env.TERM_PROGRAM === "Terminus-Sublime" || process15.env.TERM_PROGRAM === "vscode" || process15.env.TERM === "xterm-256color" || process15.env.TERM === "alacritty" || process15.env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
 }
 
 // ../../../../node_modules/log-symbols/index.js
@@ -20177,18 +21124,18 @@ function isInteractive({ stream = process.stdout } = {}) {
 }
 
 // ../../../../node_modules/is-unicode-supported/index.js
-import process15 from "node:process";
+import process16 from "node:process";
 function isUnicodeSupported3() {
-  const { env: env4 } = process15;
+  const { env: env4 } = process16;
   const { TERM, TERM_PROGRAM } = env4;
-  if (process15.platform !== "win32") {
+  if (process16.platform !== "win32") {
     return TERM !== "linux";
   }
   return Boolean(env4.WT_SESSION) || Boolean(env4.TERMINUS_SUBLIME) || env4.ConEmuTask === "{cmd::Cmder}" || TERM_PROGRAM === "Terminus-Sublime" || TERM_PROGRAM === "vscode" || TERM === "xterm-256color" || TERM === "alacritty" || TERM === "rxvt-unicode" || TERM === "rxvt-unicode-256color" || env4.TERMINAL_EMULATOR === "JetBrains-JediTerm";
 }
 
 // ../../../../node_modules/stdin-discarder/index.js
-import process16 from "node:process";
+import process17 from "node:process";
 var ASCII_ETX_CODE = 3;
 
 class StdinDiscarder {
@@ -20209,24 +21156,24 @@ class StdinDiscarder {
     }
   }
   #realStart() {
-    if (process16.platform === "win32" || !process16.stdin.isTTY) {
+    if (process17.platform === "win32" || !process17.stdin.isTTY) {
       return;
     }
-    process16.stdin.setRawMode(true);
-    process16.stdin.on("data", this.#handleInput);
-    process16.stdin.resume();
+    process17.stdin.setRawMode(true);
+    process17.stdin.on("data", this.#handleInput);
+    process17.stdin.resume();
   }
   #realStop() {
-    if (!process16.stdin.isTTY) {
+    if (!process17.stdin.isTTY) {
       return;
     }
-    process16.stdin.off("data", this.#handleInput);
-    process16.stdin.pause();
-    process16.stdin.setRawMode(false);
+    process17.stdin.off("data", this.#handleInput);
+    process17.stdin.pause();
+    process17.stdin.setRawMode(false);
   }
   #handleInput(chunk) {
     if (chunk[0] === ASCII_ETX_CODE) {
-      process16.emit("SIGINT");
+      process17.emit("SIGINT");
     }
   }
 }
@@ -20262,7 +21209,7 @@ class Ora {
     }
     this.#options = {
       color: "cyan",
-      stream: process17.stderr,
+      stream: process18.stderr,
       discardStdin: true,
       hideCursor: true,
       ...options2
@@ -20277,7 +21224,7 @@ class Ora {
     this.prefixText = this.#options.prefixText;
     this.suffixText = this.#options.suffixText;
     this.indent = this.#options.indent;
-    if (process17.env.NODE_ENV === "test") {
+    if (process18.env.NODE_ENV === "test") {
       this._stream = this.#stream;
       this._isEnabled = this.#isEnabled;
       Object.defineProperty(this, "_linesToClear", {
@@ -20468,7 +21415,7 @@ class Ora {
     if (this.#options.hideCursor) {
       cli_cursor_default.hide(this.#stream);
     }
-    if (this.#options.discardStdin && process17.stdin.isTTY) {
+    if (this.#options.discardStdin && process18.stdin.isTTY) {
       this.#isDiscardingStdin = true;
       stdin_discarder_default.start();
     }
@@ -20487,7 +21434,7 @@ class Ora {
     if (this.#options.hideCursor) {
       cli_cursor_default.show(this.#stream);
     }
-    if (this.#options.discardStdin && process17.stdin.isTTY && this.#isDiscardingStdin) {
+    if (this.#options.discardStdin && process18.stdin.isTTY && this.#isDiscardingStdin) {
       stdin_discarder_default.stop();
       this.#isDiscardingStdin = false;
     }