@meistrari/tela-cli 1.9.1 → 1.9.3

package/dist/index.js

@@ -34,19 +34,1646 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// ../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/polyfills.js
+var require_polyfills = __commonJS({
+  "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/polyfills.js"(exports2, module2) {
+    var constants = require("constants");
+    var origCwd = process.cwd;
+    var cwd = null;
+    var platform2 = process.env.GRACEFUL_FS_PLATFORM || process.platform;
+    process.cwd = function() {
+      if (!cwd)
+        cwd = origCwd.call(process);
+      return cwd;
+    };
+    try {
+      process.cwd();
+    } catch (er) {
+    }
+    if (typeof process.chdir === "function") {
+      chdir = process.chdir;
+      process.chdir = function(d) {
+        cwd = null;
+        chdir.call(process, d);
+      };
+      if (Object.setPrototypeOf) Object.setPrototypeOf(process.chdir, chdir);
+    }
+    var chdir;
+    module2.exports = patch;
+    function patch(fs) {
+      if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
+        patchLchmod(fs);
+      }
+      if (!fs.lutimes) {
+        patchLutimes(fs);
+      }
+      fs.chown = chownFix(fs.chown);
+      fs.fchown = chownFix(fs.fchown);
+      fs.lchown = chownFix(fs.lchown);
+      fs.chmod = chmodFix(fs.chmod);
+      fs.fchmod = chmodFix(fs.fchmod);
+      fs.lchmod = chmodFix(fs.lchmod);
+      fs.chownSync = chownFixSync(fs.chownSync);
+      fs.fchownSync = chownFixSync(fs.fchownSync);
+      fs.lchownSync = chownFixSync(fs.lchownSync);
+      fs.chmodSync = chmodFixSync(fs.chmodSync);
+      fs.fchmodSync = chmodFixSync(fs.fchmodSync);
+      fs.lchmodSync = chmodFixSync(fs.lchmodSync);
+      fs.stat = statFix(fs.stat);
+      fs.fstat = statFix(fs.fstat);
+      fs.lstat = statFix(fs.lstat);
+      fs.statSync = statFixSync(fs.statSync);
+      fs.fstatSync = statFixSync(fs.fstatSync);
+      fs.lstatSync = statFixSync(fs.lstatSync);
+      if (fs.chmod && !fs.lchmod) {
+        fs.lchmod = function(path2, mode, cb) {
+          if (cb) process.nextTick(cb);
+        };
+        fs.lchmodSync = function() {
+        };
+      }
+      if (fs.chown && !fs.lchown) {
+        fs.lchown = function(path2, uid, gid, cb) {
+          if (cb) process.nextTick(cb);
+        };
+        fs.lchownSync = function() {
+        };
+      }
+      if (platform2 === "win32") {
+        fs.rename = typeof fs.rename !== "function" ? fs.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() {
+                  fs.stat(to, function(stater, st) {
+                    if (stater && stater.code === "ENOENT")
+                      fs$rename(from, to, CB);
+                    else
+                      cb(er);
+                  });
+                }, backoff);
+                if (backoff < 100)
+                  backoff += 10;
+                return;
+              }
+              if (cb) cb(er);
+            });
+          }
+          if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
+          return rename;
+        })(fs.rename);
+      }
+      fs.read = typeof fs.read !== "function" ? fs.read : (function(fs$read) {
+        function read(fd, buffer, offset, length, position, callback_) {
+          var callback;
+          if (callback_ && typeof callback_ === "function") {
+            var eagCounter = 0;
+            callback = function(er, _2, __) {
+              if (er && er.code === "EAGAIN" && eagCounter < 10) {
+                eagCounter++;
+                return fs$read.call(fs, fd, buffer, offset, length, position, callback);
+              }
+              callback_.apply(this, arguments);
+            };
+          }
+          return fs$read.call(fs, fd, buffer, offset, length, position, callback);
+        }
+        if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
+        return read;
+      })(fs.read);
+      fs.readSync = typeof fs.readSync !== "function" ? fs.readSync : /* @__PURE__ */ (function(fs$readSync) {
+        return function(fd, buffer, offset, length, position) {
+          var eagCounter = 0;
+          while (true) {
+            try {
+              return fs$readSync.call(fs, fd, buffer, offset, length, position);
+            } catch (er) {
+              if (er.code === "EAGAIN" && eagCounter < 10) {
+                eagCounter++;
+                continue;
+              }
+              throw er;
+            }
+          }
+        };
+      })(fs.readSync);
+      function patchLchmod(fs2) {
+        fs2.lchmod = function(path2, mode, callback) {
+          fs2.open(
+            path2,
+            constants.O_WRONLY | constants.O_SYMLINK,
+            mode,
+            function(err, fd) {
+              if (err) {
+                if (callback) callback(err);
+                return;
+              }
+              fs2.fchmod(fd, mode, function(err2) {
+                fs2.close(fd, function(err22) {
+                  if (callback) callback(err2 || err22);
+                });
+              });
+            }
+          );
+        };
+        fs2.lchmodSync = function(path2, mode) {
+          var fd = fs2.openSync(path2, constants.O_WRONLY | constants.O_SYMLINK, mode);
+          var threw = true;
+          var ret;
+          try {
+            ret = fs2.fchmodSync(fd, mode);
+            threw = false;
+          } finally {
+            if (threw) {
+              try {
+                fs2.closeSync(fd);
+              } catch (er) {
+              }
+            } else {
+              fs2.closeSync(fd);
+            }
+          }
+          return ret;
+        };
+      }
+      function patchLutimes(fs2) {
+        if (constants.hasOwnProperty("O_SYMLINK") && fs2.futimes) {
+          fs2.lutimes = function(path2, at, mt, cb) {
+            fs2.open(path2, constants.O_SYMLINK, function(er, fd) {
+              if (er) {
+                if (cb) cb(er);
+                return;
+              }
+              fs2.futimes(fd, at, mt, function(er2) {
+                fs2.close(fd, function(er22) {
+                  if (cb) cb(er2 || er22);
+                });
+              });
+            });
+          };
+          fs2.lutimesSync = function(path2, at, mt) {
+            var fd = fs2.openSync(path2, constants.O_SYMLINK);
+            var ret;
+            var threw = true;
+            try {
+              ret = fs2.futimesSync(fd, at, mt);
+              threw = false;
+            } finally {
+              if (threw) {
+                try {
+                  fs2.closeSync(fd);
+                } catch (er) {
+                }
+              } else {
+                fs2.closeSync(fd);
+              }
+            }
+            return ret;
+          };
+        } else if (fs2.futimes) {
+          fs2.lutimes = function(_a2, _b, _c, cb) {
+            if (cb) process.nextTick(cb);
+          };
+          fs2.lutimesSync = function() {
+          };
+        }
+      }
+      function chmodFix(orig) {
+        if (!orig) return orig;
+        return function(target, mode, cb) {
+          return orig.call(fs, target, mode, function(er) {
+            if (chownErOk(er)) er = null;
+            if (cb) cb.apply(this, arguments);
+          });
+        };
+      }
+      function chmodFixSync(orig) {
+        if (!orig) return orig;
+        return function(target, mode) {
+          try {
+            return orig.call(fs, target, mode);
+          } catch (er) {
+            if (!chownErOk(er)) throw er;
+          }
+        };
+      }
+      function chownFix(orig) {
+        if (!orig) return orig;
+        return function(target, uid, gid, cb) {
+          return orig.call(fs, target, uid, gid, function(er) {
+            if (chownErOk(er)) er = null;
+            if (cb) cb.apply(this, arguments);
+          });
+        };
+      }
+      function chownFixSync(orig) {
+        if (!orig) return orig;
+        return function(target, uid, gid) {
+          try {
+            return orig.call(fs, target, uid, gid);
+          } catch (er) {
+            if (!chownErOk(er)) throw er;
+          }
+        };
+      }
+      function statFix(orig) {
+        if (!orig) return orig;
+        return function(target, options2, cb) {
+          if (typeof options2 === "function") {
+            cb = options2;
+            options2 = null;
+          }
+          function callback(er, stats) {
+            if (stats) {
+              if (stats.uid < 0) stats.uid += 4294967296;
+              if (stats.gid < 0) stats.gid += 4294967296;
+            }
+            if (cb) cb.apply(this, arguments);
+          }
+          return options2 ? orig.call(fs, target, options2, callback) : orig.call(fs, target, callback);
+        };
+      }
+      function statFixSync(orig) {
+        if (!orig) return orig;
+        return function(target, options2) {
+          var stats = options2 ? orig.call(fs, target, options2) : orig.call(fs, target);
+          if (stats) {
+            if (stats.uid < 0) stats.uid += 4294967296;
+            if (stats.gid < 0) stats.gid += 4294967296;
+          }
+          return stats;
+        };
+      }
+      function chownErOk(er) {
+        if (!er)
+          return true;
+        if (er.code === "ENOSYS")
+          return true;
+        var nonroot = !process.getuid || process.getuid() !== 0;
+        if (nonroot) {
+          if (er.code === "EINVAL" || er.code === "EPERM")
+            return true;
+        }
+        return false;
+      }
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/legacy-streams.js
+var require_legacy_streams = __commonJS({
+  "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/legacy-streams.js"(exports2, module2) {
+    var Stream = require("stream").Stream;
+    module2.exports = legacy;
+    function legacy(fs) {
+      return {
+        ReadStream: ReadStream2,
+        WriteStream
+      };
+      function ReadStream2(path2, options2) {
+        if (!(this instanceof ReadStream2)) return new ReadStream2(path2, options2);
+        Stream.call(this);
+        var self2 = this;
+        this.path = path2;
+        this.fd = null;
+        this.readable = true;
+        this.paused = false;
+        this.flags = "r";
+        this.mode = 438;
+        this.bufferSize = 64 * 1024;
+        options2 = options2 || {};
+        var keys = Object.keys(options2);
+        for (var index = 0, length = keys.length; index < length; index++) {
+          var key = keys[index];
+          this[key] = options2[key];
+        }
+        if (this.encoding) this.setEncoding(this.encoding);
+        if (this.start !== void 0) {
+          if ("number" !== typeof this.start) {
+            throw TypeError("start must be a Number");
+          }
+          if (this.end === void 0) {
+            this.end = Infinity;
+          } else if ("number" !== typeof this.end) {
+            throw TypeError("end must be a Number");
+          }
+          if (this.start > this.end) {
+            throw new Error("start must be <= end");
+          }
+          this.pos = this.start;
+        }
+        if (this.fd !== null) {
+          process.nextTick(function() {
+            self2._read();
+          });
+          return;
+        }
+        fs.open(this.path, this.flags, this.mode, function(err, fd) {
+          if (err) {
+            self2.emit("error", err);
+            self2.readable = false;
+            return;
+          }
+          self2.fd = fd;
+          self2.emit("open", fd);
+          self2._read();
+        });
+      }
+      function WriteStream(path2, options2) {
+        if (!(this instanceof WriteStream)) return new WriteStream(path2, options2);
+        Stream.call(this);
+        this.path = path2;
+        this.fd = null;
+        this.writable = true;
+        this.flags = "w";
+        this.encoding = "binary";
+        this.mode = 438;
+        this.bytesWritten = 0;
+        options2 = options2 || {};
+        var keys = Object.keys(options2);
+        for (var index = 0, length = keys.length; index < length; index++) {
+          var key = keys[index];
+          this[key] = options2[key];
+        }
+        if (this.start !== void 0) {
+          if ("number" !== typeof this.start) {
+            throw TypeError("start must be a Number");
+          }
+          if (this.start < 0) {
+            throw new Error("start must be >= zero");
+          }
+          this.pos = this.start;
+        }
+        this.busy = false;
+        this._queue = [];
+        if (this.fd === null) {
+          this._open = fs.open;
+          this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
+          this.flush();
+        }
+      }
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/clone.js
+var require_clone = __commonJS({
+  "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/clone.js"(exports2, module2) {
+    "use strict";
+    module2.exports = clone2;
+    var getPrototypeOf2 = Object.getPrototypeOf || function(obj) {
+      return obj.__proto__;
+    };
+    function clone2(obj) {
+      if (obj === null || typeof obj !== "object")
+        return obj;
+      if (obj instanceof Object)
+        var copy = { __proto__: getPrototypeOf2(obj) };
+      else
+        var copy = /* @__PURE__ */ Object.create(null);
+      Object.getOwnPropertyNames(obj).forEach(function(key) {
+        Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key));
+      });
+      return copy;
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/graceful-fs.js
+var require_graceful_fs = __commonJS({
+  "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/graceful-fs.js"(exports2, module2) {
+    var fs = require("fs");
+    var polyfills = require_polyfills();
+    var legacy = require_legacy_streams();
+    var clone2 = require_clone();
+    var util4 = require("util");
+    var gracefulQueue;
+    var previousSymbol;
+    if (typeof Symbol === "function" && typeof Symbol.for === "function") {
+      gracefulQueue = /* @__PURE__ */ Symbol.for("graceful-fs.queue");
+      previousSymbol = /* @__PURE__ */ Symbol.for("graceful-fs.previous");
+    } else {
+      gracefulQueue = "___graceful-fs.queue";
+      previousSymbol = "___graceful-fs.previous";
+    }
+    function noop2() {
+    }
+    function publishQueue(context, queue2) {
+      Object.defineProperty(context, gracefulQueue, {
+        get: function() {
+          return queue2;
+        }
+      });
+    }
+    var debug = noop2;
+    if (util4.debuglog)
+      debug = util4.debuglog("gfs4");
+    else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ""))
+      debug = function() {
+        var m3 = util4.format.apply(util4, arguments);
+        m3 = "GFS4: " + m3.split(/\n/).join("\nGFS4: ");
+        console.error(m3);
+      };
+    if (!fs[gracefulQueue]) {
+      queue = global[gracefulQueue] || [];
+      publishQueue(fs, queue);
+      fs.close = (function(fs$close) {
+        function close(fd, cb) {
+          return fs$close.call(fs, fd, function(err) {
+            if (!err) {
+              resetQueue();
+            }
+            if (typeof cb === "function")
+              cb.apply(this, arguments);
+          });
+        }
+        Object.defineProperty(close, previousSymbol, {
+          value: fs$close
+        });
+        return close;
+      })(fs.close);
+      fs.closeSync = (function(fs$closeSync) {
+        function closeSync(fd) {
+          fs$closeSync.apply(fs, arguments);
+          resetQueue();
+        }
+        Object.defineProperty(closeSync, previousSymbol, {
+          value: fs$closeSync
+        });
+        return closeSync;
+      })(fs.closeSync);
+      if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
+        process.on("exit", function() {
+          debug(fs[gracefulQueue]);
+          require("assert").equal(fs[gracefulQueue].length, 0);
+        });
+      }
+    }
+    var queue;
+    if (!global[gracefulQueue]) {
+      publishQueue(global, fs[gracefulQueue]);
+    }
+    module2.exports = patch(clone2(fs));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs.__patched) {
+      module2.exports = patch(fs);
+      fs.__patched = true;
+    }
+    function patch(fs2) {
+      polyfills(fs2);
+      fs2.gracefulify = patch;
+      fs2.createReadStream = createReadStream;
+      fs2.createWriteStream = createWriteStream;
+      var fs$readFile = fs2.readFile;
+      fs2.readFile = readFile2;
+      function readFile2(path2, options2, cb) {
+        if (typeof options2 === "function")
+          cb = options2, options2 = null;
+        return go$readFile(path2, options2, cb);
+        function go$readFile(path3, options3, cb2, startTime) {
+          return fs$readFile(path3, options3, function(err) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$readFile, [path3, options3, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      var fs$writeFile = fs2.writeFile;
+      fs2.writeFile = writeFile2;
+      function writeFile2(path2, data, options2, cb) {
+        if (typeof options2 === "function")
+          cb = options2, options2 = null;
+        return go$writeFile(path2, data, options2, cb);
+        function go$writeFile(path3, data2, options3, cb2, startTime) {
+          return fs$writeFile(path3, data2, options3, function(err) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$writeFile, [path3, data2, options3, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      var fs$appendFile = fs2.appendFile;
+      if (fs$appendFile)
+        fs2.appendFile = appendFile;
+      function appendFile(path2, data, options2, cb) {
+        if (typeof options2 === "function")
+          cb = options2, options2 = null;
+        return go$appendFile(path2, data, options2, cb);
+        function go$appendFile(path3, data2, options3, cb2, startTime) {
+          return fs$appendFile(path3, data2, options3, function(err) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$appendFile, [path3, data2, options3, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      var fs$copyFile = fs2.copyFile;
+      if (fs$copyFile)
+        fs2.copyFile = copyFile;
+      function copyFile(src, dest, flags, cb) {
+        if (typeof flags === "function") {
+          cb = flags;
+          flags = 0;
+        }
+        return go$copyFile(src, dest, flags, cb);
+        function go$copyFile(src2, dest2, flags2, cb2, startTime) {
+          return fs$copyFile(src2, dest2, flags2, function(err) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$copyFile, [src2, dest2, flags2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      var fs$readdir = fs2.readdir;
+      fs2.readdir = readdir2;
+      var noReaddirOptionVersions = /^v[0-5]\./;
+      function readdir2(path2, options2, cb) {
+        if (typeof options2 === "function")
+          cb = options2, options2 = null;
+        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path3, options3, cb2, startTime) {
+          return fs$readdir(path3, fs$readdirCallback(
+            path3,
+            options3,
+            cb2,
+            startTime
+          ));
+        } : function go$readdir2(path3, options3, cb2, startTime) {
+          return fs$readdir(path3, options3, fs$readdirCallback(
+            path3,
+            options3,
+            cb2,
+            startTime
+          ));
+        };
+        return go$readdir(path2, options2, cb);
+        function fs$readdirCallback(path3, options3, cb2, startTime) {
+          return function(err, files) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([
+                go$readdir,
+                [path3, options3, cb2],
+                err,
+                startTime || Date.now(),
+                Date.now()
+              ]);
+            else {
+              if (files && files.sort)
+                files.sort();
+              if (typeof cb2 === "function")
+                cb2.call(this, err, files);
+            }
+          };
+        }
+      }
+      if (process.version.substr(0, 4) === "v0.8") {
+        var legStreams = legacy(fs2);
+        ReadStream2 = legStreams.ReadStream;
+        WriteStream = legStreams.WriteStream;
+      }
+      var fs$ReadStream = fs2.ReadStream;
+      if (fs$ReadStream) {
+        ReadStream2.prototype = Object.create(fs$ReadStream.prototype);
+        ReadStream2.prototype.open = ReadStream$open;
+      }
+      var fs$WriteStream = fs2.WriteStream;
+      if (fs$WriteStream) {
+        WriteStream.prototype = Object.create(fs$WriteStream.prototype);
+        WriteStream.prototype.open = WriteStream$open;
+      }
+      Object.defineProperty(fs2, "ReadStream", {
+        get: function() {
+          return ReadStream2;
+        },
+        set: function(val) {
+          ReadStream2 = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      Object.defineProperty(fs2, "WriteStream", {
+        get: function() {
+          return WriteStream;
+        },
+        set: function(val) {
+          WriteStream = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      var FileReadStream = ReadStream2;
+      Object.defineProperty(fs2, "FileReadStream", {
+        get: function() {
+          return FileReadStream;
+        },
+        set: function(val) {
+          FileReadStream = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      var FileWriteStream = WriteStream;
+      Object.defineProperty(fs2, "FileWriteStream", {
+        get: function() {
+          return FileWriteStream;
+        },
+        set: function(val) {
+          FileWriteStream = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      function ReadStream2(path2, options2) {
+        if (this instanceof ReadStream2)
+          return fs$ReadStream.apply(this, arguments), this;
+        else
+          return ReadStream2.apply(Object.create(ReadStream2.prototype), arguments);
+      }
+      function ReadStream$open() {
+        var that = this;
+        open(that.path, that.flags, that.mode, function(err, fd) {
+          if (err) {
+            if (that.autoClose)
+              that.destroy();
+            that.emit("error", err);
+          } else {
+            that.fd = fd;
+            that.emit("open", fd);
+            that.read();
+          }
+        });
+      }
+      function WriteStream(path2, options2) {
+        if (this instanceof WriteStream)
+          return fs$WriteStream.apply(this, arguments), this;
+        else
+          return WriteStream.apply(Object.create(WriteStream.prototype), arguments);
+      }
+      function WriteStream$open() {
+        var that = this;
+        open(that.path, that.flags, that.mode, function(err, fd) {
+          if (err) {
+            that.destroy();
+            that.emit("error", err);
+          } else {
+            that.fd = fd;
+            that.emit("open", fd);
+          }
+        });
+      }
+      function createReadStream(path2, options2) {
+        return new fs2.ReadStream(path2, options2);
+      }
+      function createWriteStream(path2, options2) {
+        return new fs2.WriteStream(path2, options2);
+      }
+      var fs$open = fs2.open;
+      fs2.open = open;
+      function open(path2, flags, mode, cb) {
+        if (typeof mode === "function")
+          cb = mode, mode = null;
+        return go$open(path2, flags, mode, cb);
+        function go$open(path3, flags2, mode2, cb2, startTime) {
+          return fs$open(path3, flags2, mode2, function(err, fd) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$open, [path3, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      return fs2;
+    }
+    function enqueue(elem) {
+      debug("ENQUEUE", elem[0].name, elem[1]);
+      fs[gracefulQueue].push(elem);
+      retry();
+    }
+    var retryTimer;
+    function resetQueue() {
+      var now3 = Date.now();
+      for (var i2 = 0; i2 < fs[gracefulQueue].length; ++i2) {
+        if (fs[gracefulQueue][i2].length > 2) {
+          fs[gracefulQueue][i2][3] = now3;
+          fs[gracefulQueue][i2][4] = now3;
+        }
+      }
+      retry();
+    }
+    function retry() {
+      clearTimeout(retryTimer);
+      retryTimer = void 0;
+      if (fs[gracefulQueue].length === 0)
+        return;
+      var elem = fs[gracefulQueue].shift();
+      var fn = elem[0];
+      var args = elem[1];
+      var err = elem[2];
+      var startTime = elem[3];
+      var lastTime = elem[4];
+      if (startTime === void 0) {
+        debug("RETRY", fn.name, args);
+        fn.apply(null, args);
+      } else if (Date.now() - startTime >= 6e4) {
+        debug("TIMEOUT", fn.name, args);
+        var cb = args.pop();
+        if (typeof cb === "function")
+          cb.call(null, err);
+      } else {
+        var sinceAttempt = Date.now() - lastTime;
+        var sinceStart = Math.max(lastTime - startTime, 1);
+        var desiredDelay = Math.min(sinceStart * 1.2, 100);
+        if (sinceAttempt >= desiredDelay) {
+          debug("RETRY", fn.name, args);
+          fn.apply(null, args.concat([startTime]));
+        } else {
+          fs[gracefulQueue].push(elem);
+        }
+      }
+      if (retryTimer === void 0) {
+        retryTimer = setTimeout(retry, 0);
+      }
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/retry@0.12.0/node_modules/retry/lib/retry_operation.js
+var require_retry_operation = __commonJS({
+  "../../node_modules/.pnpm/retry@0.12.0/node_modules/retry/lib/retry_operation.js"(exports2, module2) {
+    function RetryOperation(timeouts, options2) {
+      if (typeof options2 === "boolean") {
+        options2 = { forever: options2 };
+      }
+      this._originalTimeouts = JSON.parse(JSON.stringify(timeouts));
+      this._timeouts = timeouts;
+      this._options = options2 || {};
+      this._maxRetryTime = options2 && options2.maxRetryTime || Infinity;
+      this._fn = null;
+      this._errors = [];
+      this._attempts = 1;
+      this._operationTimeout = null;
+      this._operationTimeoutCb = null;
+      this._timeout = null;
+      this._operationStart = null;
+      if (this._options.forever) {
+        this._cachedTimeouts = this._timeouts.slice(0);
+      }
+    }
+    module2.exports = RetryOperation;
+    RetryOperation.prototype.reset = function() {
+      this._attempts = 1;
+      this._timeouts = this._originalTimeouts;
+    };
+    RetryOperation.prototype.stop = function() {
+      if (this._timeout) {
+        clearTimeout(this._timeout);
+      }
+      this._timeouts = [];
+      this._cachedTimeouts = null;
+    };
+    RetryOperation.prototype.retry = function(err) {
+      if (this._timeout) {
+        clearTimeout(this._timeout);
+      }
+      if (!err) {
+        return false;
+      }
+      var currentTime = (/* @__PURE__ */ new Date()).getTime();
+      if (err && currentTime - this._operationStart >= this._maxRetryTime) {
+        this._errors.unshift(new Error("RetryOperation timeout occurred"));
+        return false;
+      }
+      this._errors.push(err);
+      var timeout = this._timeouts.shift();
+      if (timeout === void 0) {
+        if (this._cachedTimeouts) {
+          this._errors.splice(this._errors.length - 1, this._errors.length);
+          this._timeouts = this._cachedTimeouts.slice(0);
+          timeout = this._timeouts.shift();
+        } else {
+          return false;
+        }
+      }
+      var self2 = this;
+      var timer = setTimeout(function() {
+        self2._attempts++;
+        if (self2._operationTimeoutCb) {
+          self2._timeout = setTimeout(function() {
+            self2._operationTimeoutCb(self2._attempts);
+          }, self2._operationTimeout);
+          if (self2._options.unref) {
+            self2._timeout.unref();
+          }
+        }
+        self2._fn(self2._attempts);
+      }, timeout);
+      if (this._options.unref) {
+        timer.unref();
+      }
+      return true;
+    };
+    RetryOperation.prototype.attempt = function(fn, timeoutOps) {
+      this._fn = fn;
+      if (timeoutOps) {
+        if (timeoutOps.timeout) {
+          this._operationTimeout = timeoutOps.timeout;
+        }
+        if (timeoutOps.cb) {
+          this._operationTimeoutCb = timeoutOps.cb;
+        }
+      }
+      var self2 = this;
+      if (this._operationTimeoutCb) {
+        this._timeout = setTimeout(function() {
+          self2._operationTimeoutCb();
+        }, self2._operationTimeout);
+      }
+      this._operationStart = (/* @__PURE__ */ new Date()).getTime();
+      this._fn(this._attempts);
+    };
+    RetryOperation.prototype.try = function(fn) {
+      console.log("Using RetryOperation.try() is deprecated");
+      this.attempt(fn);
+    };
+    RetryOperation.prototype.start = function(fn) {
+      console.log("Using RetryOperation.start() is deprecated");
+      this.attempt(fn);
+    };
+    RetryOperation.prototype.start = RetryOperation.prototype.try;
+    RetryOperation.prototype.errors = function() {
+      return this._errors;
+    };
+    RetryOperation.prototype.attempts = function() {
+      return this._attempts;
+    };
+    RetryOperation.prototype.mainError = function() {
+      if (this._errors.length === 0) {
+        return null;
+      }
+      var counts = {};
+      var mainError = null;
+      var mainErrorCount = 0;
+      for (var i2 = 0; i2 < this._errors.length; i2++) {
+        var error48 = this._errors[i2];
+        var message = error48.message;
+        var count = (counts[message] || 0) + 1;
+        counts[message] = count;
+        if (count >= mainErrorCount) {
+          mainError = error48;
+          mainErrorCount = count;
+        }
+      }
+      return mainError;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/retry@0.12.0/node_modules/retry/lib/retry.js
+var require_retry = __commonJS({
+  "../../node_modules/.pnpm/retry@0.12.0/node_modules/retry/lib/retry.js"(exports2) {
+    var RetryOperation = require_retry_operation();
+    exports2.operation = function(options2) {
+      var timeouts = exports2.timeouts(options2);
+      return new RetryOperation(timeouts, {
+        forever: options2 && options2.forever,
+        unref: options2 && options2.unref,
+        maxRetryTime: options2 && options2.maxRetryTime
+      });
+    };
+    exports2.timeouts = function(options2) {
+      if (options2 instanceof Array) {
+        return [].concat(options2);
+      }
+      var opts = {
+        retries: 10,
+        factor: 2,
+        minTimeout: 1 * 1e3,
+        maxTimeout: Infinity,
+        randomize: false
+      };
+      for (var key in options2) {
+        opts[key] = options2[key];
+      }
+      if (opts.minTimeout > opts.maxTimeout) {
+        throw new Error("minTimeout is greater than maxTimeout");
+      }
+      var timeouts = [];
+      for (var i2 = 0; i2 < opts.retries; i2++) {
+        timeouts.push(this.createTimeout(i2, opts));
+      }
+      if (options2 && options2.forever && !timeouts.length) {
+        timeouts.push(this.createTimeout(i2, opts));
+      }
+      timeouts.sort(function(a2, b3) {
+        return a2 - b3;
+      });
+      return timeouts;
+    };
+    exports2.createTimeout = function(attempt, opts) {
+      var random = opts.randomize ? Math.random() + 1 : 1;
+      var timeout = Math.round(random * opts.minTimeout * Math.pow(opts.factor, attempt));
+      timeout = Math.min(timeout, opts.maxTimeout);
+      return timeout;
+    };
+    exports2.wrap = function(obj, options2, methods2) {
+      if (options2 instanceof Array) {
+        methods2 = options2;
+        options2 = null;
+      }
+      if (!methods2) {
+        methods2 = [];
+        for (var key in obj) {
+          if (typeof obj[key] === "function") {
+            methods2.push(key);
+          }
+        }
+      }
+      for (var i2 = 0; i2 < methods2.length; i2++) {
+        var method = methods2[i2];
+        var original = obj[method];
+        obj[method] = function retryWrapper(original2) {
+          var op = exports2.operation(options2);
+          var args = Array.prototype.slice.call(arguments, 1);
+          var callback = args.pop();
+          args.push(function(err) {
+            if (op.retry(err)) {
+              return;
+            }
+            if (err) {
+              arguments[0] = op.mainError();
+            }
+            callback.apply(this, arguments);
+          });
+          op.attempt(function() {
+            original2.apply(obj, args);
+          });
+        }.bind(obj, original);
+        obj[method].options = options2;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/retry@0.12.0/node_modules/retry/index.js
+var require_retry2 = __commonJS({
+  "../../node_modules/.pnpm/retry@0.12.0/node_modules/retry/index.js"(exports2, module2) {
+    module2.exports = require_retry();
+  }
+});
+
+// ../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/signals.js
+var require_signals = __commonJS({
+  "../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/signals.js"(exports2, module2) {
+    module2.exports = [
+      "SIGABRT",
+      "SIGALRM",
+      "SIGHUP",
+      "SIGINT",
+      "SIGTERM"
+    ];
+    if (process.platform !== "win32") {
+      module2.exports.push(
+        "SIGVTALRM",
+        "SIGXCPU",
+        "SIGXFSZ",
+        "SIGUSR2",
+        "SIGTRAP",
+        "SIGSYS",
+        "SIGQUIT",
+        "SIGIOT"
+        // should detect profiler and enable/disable accordingly.
+        // see #21
+        // 'SIGPROF'
+      );
+    }
+    if (process.platform === "linux") {
+      module2.exports.push(
+        "SIGIO",
+        "SIGPOLL",
+        "SIGPWR",
+        "SIGSTKFLT",
+        "SIGUNUSED"
+      );
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/index.js
+var require_signal_exit = __commonJS({
+  "../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/index.js"(exports2, module2) {
+    var process7 = global.process;
+    var processOk = function(process8) {
+      return process8 && typeof process8 === "object" && typeof process8.removeListener === "function" && typeof process8.emit === "function" && typeof process8.reallyExit === "function" && typeof process8.listeners === "function" && typeof process8.kill === "function" && typeof process8.pid === "number" && typeof process8.on === "function";
+    };
+    if (!processOk(process7)) {
+      module2.exports = function() {
+        return function() {
+        };
+      };
+    } else {
+      assert2 = require("assert");
+      signals = require_signals();
+      isWin = /^win/i.test(process7.platform);
+      EE = require("events");
+      if (typeof EE !== "function") {
+        EE = EE.EventEmitter;
+      }
+      if (process7.__signal_exit_emitter__) {
+        emitter = process7.__signal_exit_emitter__;
+      } else {
+        emitter = process7.__signal_exit_emitter__ = new EE();
+        emitter.count = 0;
+        emitter.emitted = {};
+      }
+      if (!emitter.infinite) {
+        emitter.setMaxListeners(Infinity);
+        emitter.infinite = true;
+      }
+      module2.exports = function(cb, opts) {
+        if (!processOk(global.process)) {
+          return function() {
+          };
+        }
+        assert2.equal(typeof cb, "function", "a callback must be provided for exit handler");
+        if (loaded === false) {
+          load();
+        }
+        var ev = "exit";
+        if (opts && opts.alwaysLast) {
+          ev = "afterexit";
+        }
+        var remove = function() {
+          emitter.removeListener(ev, cb);
+          if (emitter.listeners("exit").length === 0 && emitter.listeners("afterexit").length === 0) {
+            unload();
+          }
+        };
+        emitter.on(ev, cb);
+        return remove;
+      };
+      unload = function unload2() {
+        if (!loaded || !processOk(global.process)) {
+          return;
+        }
+        loaded = false;
+        signals.forEach(function(sig) {
+          try {
+            process7.removeListener(sig, sigListeners[sig]);
+          } catch (er) {
+          }
+        });
+        process7.emit = originalProcessEmit;
+        process7.reallyExit = originalProcessReallyExit;
+        emitter.count -= 1;
+      };
+      module2.exports.unload = unload;
+      emit = function emit2(event, code, signal) {
+        if (emitter.emitted[event]) {
+          return;
+        }
+        emitter.emitted[event] = true;
+        emitter.emit(event, code, signal);
+      };
+      sigListeners = {};
+      signals.forEach(function(sig) {
+        sigListeners[sig] = function listener() {
+          if (!processOk(global.process)) {
+            return;
+          }
+          var listeners = process7.listeners(sig);
+          if (listeners.length === emitter.count) {
+            unload();
+            emit("exit", null, sig);
+            emit("afterexit", null, sig);
+            if (isWin && sig === "SIGHUP") {
+              sig = "SIGINT";
+            }
+            process7.kill(process7.pid, sig);
+          }
+        };
+      });
+      module2.exports.signals = function() {
+        return signals;
+      };
+      loaded = false;
+      load = function load2() {
+        if (loaded || !processOk(global.process)) {
+          return;
+        }
+        loaded = true;
+        emitter.count += 1;
+        signals = signals.filter(function(sig) {
+          try {
+            process7.on(sig, sigListeners[sig]);
+            return true;
+          } catch (er) {
+            return false;
+          }
+        });
+        process7.emit = processEmit;
+        process7.reallyExit = processReallyExit;
+      };
+      module2.exports.load = load;
+      originalProcessReallyExit = process7.reallyExit;
+      processReallyExit = function processReallyExit2(code) {
+        if (!processOk(global.process)) {
+          return;
+        }
+        process7.exitCode = code || /* istanbul ignore next */
+        0;
+        emit("exit", process7.exitCode, null);
+        emit("afterexit", process7.exitCode, null);
+        originalProcessReallyExit.call(process7, process7.exitCode);
+      };
+      originalProcessEmit = process7.emit;
+      processEmit = function processEmit2(ev, arg) {
+        if (ev === "exit" && processOk(global.process)) {
+          if (arg !== void 0) {
+            process7.exitCode = arg;
+          }
+          var ret = originalProcessEmit.apply(this, arguments);
+          emit("exit", process7.exitCode, null);
+          emit("afterexit", process7.exitCode, null);
+          return ret;
+        } else {
+          return originalProcessEmit.apply(this, arguments);
+        }
+      };
+    }
+    var assert2;
+    var signals;
+    var isWin;
+    var EE;
+    var emitter;
+    var unload;
+    var emit;
+    var sigListeners;
+    var loaded;
+    var load;
+    var originalProcessReallyExit;
+    var processReallyExit;
+    var originalProcessEmit;
+    var processEmit;
+  }
+});
+
+// ../../node_modules/.pnpm/proper-lockfile@4.1.2/node_modules/proper-lockfile/lib/mtime-precision.js
+var require_mtime_precision = __commonJS({
+  "../../node_modules/.pnpm/proper-lockfile@4.1.2/node_modules/proper-lockfile/lib/mtime-precision.js"(exports2, module2) {
+    "use strict";
+    var cacheSymbol = /* @__PURE__ */ Symbol();
+    function probe(file2, fs, callback) {
+      const cachedPrecision = fs[cacheSymbol];
+      if (cachedPrecision) {
+        return fs.stat(file2, (err, stat) => {
+          if (err) {
+            return callback(err);
+          }
+          callback(null, stat.mtime, cachedPrecision);
+        });
+      }
+      const mtime = new Date(Math.ceil(Date.now() / 1e3) * 1e3 + 5);
+      fs.utimes(file2, mtime, mtime, (err) => {
+        if (err) {
+          return callback(err);
+        }
+        fs.stat(file2, (err2, stat) => {
+          if (err2) {
+            return callback(err2);
+          }
+          const precision = stat.mtime.getTime() % 1e3 === 0 ? "s" : "ms";
+          Object.defineProperty(fs, cacheSymbol, { value: precision });
+          callback(null, stat.mtime, precision);
+        });
+      });
+    }
+    function getMtime(precision) {
+      let now3 = Date.now();
+      if (precision === "s") {
+        now3 = Math.ceil(now3 / 1e3) * 1e3;
+      }
+      return new Date(now3);
+    }
+    module2.exports.probe = probe;
+    module2.exports.getMtime = getMtime;
+  }
+});
+
+// ../../node_modules/.pnpm/proper-lockfile@4.1.2/node_modules/proper-lockfile/lib/lockfile.js
+var require_lockfile = __commonJS({
+  "../../node_modules/.pnpm/proper-lockfile@4.1.2/node_modules/proper-lockfile/lib/lockfile.js"(exports2, module2) {
+    "use strict";
+    var path2 = require("path");
+    var fs = require_graceful_fs();
+    var retry = require_retry2();
+    var onExit = require_signal_exit();
+    var mtimePrecision = require_mtime_precision();
+    var locks = {};
+    function getLockFile(file2, options2) {
+      return options2.lockfilePath || `${file2}.lock`;
+    }
+    function resolveCanonicalPath(file2, options2, callback) {
+      if (!options2.realpath) {
+        return callback(null, path2.resolve(file2));
+      }
+      options2.fs.realpath(file2, callback);
+    }
+    function acquireLock(file2, options2, callback) {
+      const lockfilePath = getLockFile(file2, options2);
+      options2.fs.mkdir(lockfilePath, (err) => {
+        if (!err) {
+          return mtimePrecision.probe(lockfilePath, options2.fs, (err2, mtime, mtimePrecision2) => {
+            if (err2) {
+              options2.fs.rmdir(lockfilePath, () => {
+              });
+              return callback(err2);
+            }
+            callback(null, mtime, mtimePrecision2);
+          });
+        }
+        if (err.code !== "EEXIST") {
+          return callback(err);
+        }
+        if (options2.stale <= 0) {
+          return callback(Object.assign(new Error("Lock file is already being held"), { code: "ELOCKED", file: file2 }));
+        }
+        options2.fs.stat(lockfilePath, (err2, stat) => {
+          if (err2) {
+            if (err2.code === "ENOENT") {
+              return acquireLock(file2, { ...options2, stale: 0 }, callback);
+            }
+            return callback(err2);
+          }
+          if (!isLockStale(stat, options2)) {
+            return callback(Object.assign(new Error("Lock file is already being held"), { code: "ELOCKED", file: file2 }));
+          }
+          removeLock(file2, options2, (err3) => {
+            if (err3) {
+              return callback(err3);
+            }
+            acquireLock(file2, { ...options2, stale: 0 }, callback);
+          });
+        });
+      });
+    }
+    function isLockStale(stat, options2) {
+      return stat.mtime.getTime() < Date.now() - options2.stale;
+    }
+    function removeLock(file2, options2, callback) {
+      options2.fs.rmdir(getLockFile(file2, options2), (err) => {
+        if (err && err.code !== "ENOENT") {
+          return callback(err);
+        }
+        callback();
+      });
+    }
+    function updateLock(file2, options2) {
+      const lock2 = locks[file2];
+      if (lock2.updateTimeout) {
+        return;
+      }
+      lock2.updateDelay = lock2.updateDelay || options2.update;
+      lock2.updateTimeout = setTimeout(() => {
+        lock2.updateTimeout = null;
+        options2.fs.stat(lock2.lockfilePath, (err, stat) => {
+          const isOverThreshold = lock2.lastUpdate + options2.stale < Date.now();
+          if (err) {
+            if (err.code === "ENOENT" || isOverThreshold) {
+              return setLockAsCompromised(file2, lock2, Object.assign(err, { code: "ECOMPROMISED" }));
+            }
+            lock2.updateDelay = 1e3;
+            return updateLock(file2, options2);
+          }
+          const isMtimeOurs = lock2.mtime.getTime() === stat.mtime.getTime();
+          if (!isMtimeOurs) {
+            return setLockAsCompromised(
+              file2,
+              lock2,
+              Object.assign(
+                new Error("Unable to update lock within the stale threshold"),
+                { code: "ECOMPROMISED" }
+              )
+            );
+          }
+          const mtime = mtimePrecision.getMtime(lock2.mtimePrecision);
+          options2.fs.utimes(lock2.lockfilePath, mtime, mtime, (err2) => {
+            const isOverThreshold2 = lock2.lastUpdate + options2.stale < Date.now();
+            if (lock2.released) {
+              return;
+            }
+            if (err2) {
+              if (err2.code === "ENOENT" || isOverThreshold2) {
+                return setLockAsCompromised(file2, lock2, Object.assign(err2, { code: "ECOMPROMISED" }));
+              }
+              lock2.updateDelay = 1e3;
+              return updateLock(file2, options2);
+            }
+            lock2.mtime = mtime;
+            lock2.lastUpdate = Date.now();
+            lock2.updateDelay = null;
+            updateLock(file2, options2);
+          });
+        });
+      }, lock2.updateDelay);
+      if (lock2.updateTimeout.unref) {
+        lock2.updateTimeout.unref();
+      }
+    }
+    function setLockAsCompromised(file2, lock2, err) {
+      lock2.released = true;
+      if (lock2.updateTimeout) {
+        clearTimeout(lock2.updateTimeout);
+      }
+      if (locks[file2] === lock2) {
+        delete locks[file2];
+      }
+      lock2.options.onCompromised(err);
+    }
+    function lock(file2, options2, callback) {
+      options2 = {
+        stale: 1e4,
+        update: null,
+        realpath: true,
+        retries: 0,
+        fs,
+        onCompromised: (err) => {
+          throw err;
+        },
+        ...options2
+      };
+      options2.retries = options2.retries || 0;
+      options2.retries = typeof options2.retries === "number" ? { retries: options2.retries } : options2.retries;
+      options2.stale = Math.max(options2.stale || 0, 2e3);
+      options2.update = options2.update == null ? options2.stale / 2 : options2.update || 0;
+      options2.update = Math.max(Math.min(options2.update, options2.stale / 2), 1e3);
+      resolveCanonicalPath(file2, options2, (err, file3) => {
+        if (err) {
+          return callback(err);
+        }
+        const operation = retry.operation(options2.retries);
+        operation.attempt(() => {
+          acquireLock(file3, options2, (err2, mtime, mtimePrecision2) => {
+            if (operation.retry(err2)) {
+              return;
+            }
+            if (err2) {
+              return callback(operation.mainError());
+            }
+            const lock2 = locks[file3] = {
+              lockfilePath: getLockFile(file3, options2),
+              mtime,
+              mtimePrecision: mtimePrecision2,
+              options: options2,
+              lastUpdate: Date.now()
+            };
+            updateLock(file3, options2);
+            callback(null, (releasedCallback) => {
+              if (lock2.released) {
+                return releasedCallback && releasedCallback(Object.assign(new Error("Lock is already released"), { code: "ERELEASED" }));
+              }
+              unlock(file3, { ...options2, realpath: false }, releasedCallback);
+            });
+          });
+        });
+      });
+    }
+    function unlock(file2, options2, callback) {
+      options2 = {
+        fs,
+        realpath: true,
+        ...options2
+      };
+      resolveCanonicalPath(file2, options2, (err, file3) => {
+        if (err) {
+          return callback(err);
+        }
+        const lock2 = locks[file3];
+        if (!lock2) {
+          return callback(Object.assign(new Error("Lock is not acquired/owned by you"), { code: "ENOTACQUIRED" }));
+        }
+        lock2.updateTimeout && clearTimeout(lock2.updateTimeout);
+        lock2.released = true;
+        delete locks[file3];
+        removeLock(file3, options2, callback);
+      });
+    }
+    function check2(file2, options2, callback) {
+      options2 = {
+        stale: 1e4,
+        realpath: true,
+        fs,
+        ...options2
+      };
+      options2.stale = Math.max(options2.stale || 0, 2e3);
+      resolveCanonicalPath(file2, options2, (err, file3) => {
+        if (err) {
+          return callback(err);
+        }
+        options2.fs.stat(getLockFile(file3, options2), (err2, stat) => {
+          if (err2) {
+            return err2.code === "ENOENT" ? callback(null, false) : callback(err2);
+          }
+          return callback(null, !isLockStale(stat, options2));
+        });
+      });
+    }
+    function getLocks() {
+      return locks;
+    }
+    onExit(() => {
+      for (const file2 in locks) {
+        const options2 = locks[file2].options;
+        try {
+          options2.fs.rmdirSync(getLockFile(file2, options2));
+        } catch (e) {
+        }
+      }
+    });
+    module2.exports.lock = lock;
+    module2.exports.unlock = unlock;
+    module2.exports.check = check2;
+    module2.exports.getLocks = getLocks;
+  }
+});
+
+// ../../node_modules/.pnpm/proper-lockfile@4.1.2/node_modules/proper-lockfile/lib/adapter.js
+var require_adapter = __commonJS({
+  "../../node_modules/.pnpm/proper-lockfile@4.1.2/node_modules/proper-lockfile/lib/adapter.js"(exports2, module2) {
+    "use strict";
+    var fs = require_graceful_fs();
+    function createSyncFs(fs2) {
+      const methods2 = ["mkdir", "realpath", "stat", "rmdir", "utimes"];
+      const newFs = { ...fs2 };
+      methods2.forEach((method) => {
+        newFs[method] = (...args) => {
+          const callback = args.pop();
+          let ret;
+          try {
+            ret = fs2[`${method}Sync`](...args);
+          } catch (err) {
+            return callback(err);
+          }
+          callback(null, ret);
+        };
+      });
+      return newFs;
+    }
+    function toPromise(method) {
+      return (...args) => new Promise((resolve, reject) => {
+        args.push((err, result) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve(result);
+          }
+        });
+        method(...args);
+      });
+    }
+    function toSync(method) {
+      return (...args) => {
+        let err;
+        let result;
+        args.push((_err, _result) => {
+          err = _err;
+          result = _result;
+        });
+        method(...args);
+        if (err) {
+          throw err;
+        }
+        return result;
+      };
+    }
+    function toSyncOptions(options2) {
+      options2 = { ...options2 };
+      options2.fs = createSyncFs(options2.fs || fs);
+      if (typeof options2.retries === "number" && options2.retries > 0 || options2.retries && typeof options2.retries.retries === "number" && options2.retries.retries > 0) {
+        throw Object.assign(new Error("Cannot use retries with the sync api"), { code: "ESYNC" });
+      }
+      return options2;
+    }
+    module2.exports = {
+      toPromise,
+      toSync,
+      toSyncOptions
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/proper-lockfile@4.1.2/node_modules/proper-lockfile/index.js
+var require_proper_lockfile = __commonJS({
+  "../../node_modules/.pnpm/proper-lockfile@4.1.2/node_modules/proper-lockfile/index.js"(exports2, module2) {
+    "use strict";
+    var lockfile = require_lockfile();
+    var { toPromise, toSync, toSyncOptions } = require_adapter();
+    async function lock(file2, options2) {
+      const release = await toPromise(lockfile.lock)(file2, options2);
+      return toPromise(release);
+    }
+    function lockSync(file2, options2) {
+      const release = toSync(lockfile.lock)(file2, toSyncOptions(options2));
+      return toSync(release);
+    }
+    function unlock(file2, options2) {
+      return toPromise(lockfile.unlock)(file2, options2);
+    }
+    function unlockSync(file2, options2) {
+      return toSync(lockfile.unlock)(file2, toSyncOptions(options2));
+    }
+    function check2(file2, options2) {
+      return toPromise(lockfile.check)(file2, options2);
+    }
+    function checkSync(file2, options2) {
+      return toSync(lockfile.check)(file2, toSyncOptions(options2));
+    }
+    module2.exports = lock;
+    module2.exports.lock = lock;
+    module2.exports.unlock = unlock;
+    module2.exports.lockSync = lockSync;
+    module2.exports.unlockSync = unlockSync;
+    module2.exports.check = check2;
+    module2.exports.checkSync = checkSync;
+  }
+});
+
+// ../../packages/local-config/dist/credential-mutations.js
+var require_credential_mutations = __commonJS({
+  "../../packages/local-config/dist/credential-mutations.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.withCredentialMutation = withCredentialMutation;
+    exports2.coordinateCredentialMutations = coordinateCredentialMutations;
+    var node_async_hooks_1 = require("node:async_hooks");
+    var node_crypto_1 = require("node:crypto");
+    var promises_1 = require("node:fs/promises");
+    var node_os_1 = require("node:os");
+    var node_path_1 = require("node:path");
+    var proper_lockfile_1 = require_proper_lockfile();
+    var held = new node_async_hooks_1.AsyncLocalStorage();
+    async function withCredentialMutation(ref, operation) {
+      if (ref.provider !== "keychain")
+        return await operation();
+      const key = (0, node_crypto_1.createHash)("sha256").update(JSON.stringify([ref.provider, ref.service, ref.account])).digest("hex");
+      const inherited = held.getStore();
+      if (inherited?.get(key)?.active)
+        return await operation();
+      const directory = (0, node_path_1.join)((0, node_os_1.homedir)(), ".tela", "credential-locks");
+      await (0, promises_1.mkdir)(directory, { recursive: true, mode: 448 });
+      const info = await (0, promises_1.lstat)(directory);
+      if (!info.isDirectory() || info.uid !== process.getuid?.() || (info.mode & 63) !== 0)
+        throw new Error("Unsafe credential lock directory");
+      const release = await (0, proper_lockfile_1.lock)((0, node_path_1.join)(directory, key), {
+        realpath: false,
+        stale: 6e4,
+        update: 5e3,
+        retries: { retries: 40, factor: 1, minTimeout: 250, maxTimeout: 250 }
+      });
+      const owner = { active: true };
+      try {
+        return await held.run(new Map([...inherited ?? [], [key, owner]]), operation);
+      } finally {
+        owner.active = false;
+        await release();
+      }
+    }
+    function coordinateCredentialMutations(adapter2) {
+      return {
+        ...adapter2,
+        set: async (ref, credential) => await withCredentialMutation(ref, async () => await adapter2.set(ref, credential)),
+        delete: async (ref) => await withCredentialMutation(ref, async () => await adapter2.delete(ref))
+      };
+    }
+  }
+});
+
 // ../../packages/local-config/dist/credentials.js
 var require_credentials = __commonJS({
   "../../packages/local-config/dist/credentials.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.isExpired = isExpired;
+    exports2.isExpired = isExpired2;
     exports2.diagnoseStoredCredential = diagnoseStoredCredential;
     exports2.createEnvCredentialAdapter = createEnvCredentialAdapter;
     exports2.createMemoryCredentialAdapter = createMemoryCredentialAdapter;
     exports2.refKey = refKey;
     exports2.projectCredentialUser = projectCredentialUser;
     exports2.projectCredentialOrganization = projectCredentialOrganization;
-    function isExpired(credential, now3 = /* @__PURE__ */ new Date()) {
+    function isExpired2(credential, now3 = /* @__PURE__ */ new Date()) {
       if (!credential.expiresAt)
         return false;
       return new Date(credential.expiresAt).getTime() <= now3.getTime();
@@ -63,7 +1690,7 @@ var require_credentials = __commonJS({
         };
       }
       const refreshable = credential.kind === "user-session" && Boolean(credential.refreshToken);
-      const expired = isExpired(credential, now3);
+      const expired = isExpired2(credential, now3);
       return {
         ok: !expired || refreshable,
         provider: ref.provider,
@@ -159,26 +1786,64 @@ var require_auth = __commonJS({
   "../../packages/local-config/dist/auth.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.shouldRefreshUserSession = shouldRefreshUserSession;
-    exports2.refreshUserSessionCredential = refreshUserSessionCredential3;
+    exports2.shouldRefreshUserSession = shouldRefreshUserSession2;
+    exports2.refreshUserSessionCredential = refreshUserSessionCredential2;
     exports2.createStoredUserSession = createStoredUserSession;
     exports2.getJwtExpiresAt = getJwtExpiresAt;
     var node_buffer_1 = require("node:buffer");
+    var credential_mutations_1 = require_credential_mutations();
     var credentials_1 = require_credentials();
-    function shouldRefreshUserSession(credential, now3 = refreshSkewDate()) {
+    function shouldRefreshUserSession2(credential, now3 = refreshSkewDate()) {
       return credential.kind === "user-session" && Boolean(credential.refreshToken) && (0, credentials_1.isExpired)(credential, now3);
     }
-    async function refreshUserSessionCredential3(environment, credentialRef, credential, credentials, options2 = {}) {
-      if (!shouldRefreshUserSession(credential, options2.now ?? refreshSkewDate())) {
-        return credential;
-      }
-      if (!credential.refreshToken) {
+    var refreshQueues = /* @__PURE__ */ new Map();
+    var pendingWrites = /* @__PURE__ */ new Map();
+    async function refreshUserSessionCredential2(environment, credentialRef, credential, credentials, options2 = {}) {
+      if (!shouldRefreshUserSession2(credential, options2.now ?? refreshSkewDate()))
         return credential;
+      const key = JSON.stringify([credentialRef.provider, credentialRef.service, credentialRef.account, credentialRef.kind]);
+      const previous = refreshQueues.get(key) ?? Promise.resolve();
+      const operation = previous.catch(() => void 0).then(async () => {
+        let current = await credentials.get(credentialRef);
+        if (!current) {
+          pendingWrites.delete(key);
+          throw new Error("Session was removed. Sign in again.");
+        }
+        const pending = pendingWrites.get(key);
+        if (pending && pending.previousToken === current.refreshToken) {
+          current = await persist(current.refreshToken, pending.credential);
+        }
+        pendingWrites.delete(key);
+        if (!shouldRefreshUserSession2(current, options2.now ?? refreshSkewDate()) || !current.refreshToken)
+          return current;
+        const tokens = await refreshApplicationToken(environment.authApiUrl, current.refreshToken);
+        const refreshed = createStoredUserSession(tokens, current);
+        pendingWrites.set(key, { previousToken: current.refreshToken, credential: refreshed });
+        return await persist(current.refreshToken, refreshed);
+        async function persist(expectedToken, candidate) {
+          return await (0, credential_mutations_1.withCredentialMutation)(credentialRef, async () => {
+            const latest = await credentials.get(credentialRef);
+            if (!latest) {
+              pendingWrites.delete(key);
+              throw new Error("Session was removed. Sign in again.");
+            }
+            if (latest.refreshToken !== expectedToken) {
+              pendingWrites.delete(key);
+              return latest;
+            }
+            await credentials.set(credentialRef, candidate);
+            pendingWrites.delete(key);
+            return candidate;
+          });
+        }
+      });
+      refreshQueues.set(key, operation);
+      try {
+        return await operation;
+      } finally {
+        if (refreshQueues.get(key) === operation)
+          refreshQueues.delete(key);
       }
-      const tokens = await refreshApplicationToken(environment.authApiUrl, credential.refreshToken);
-      const refreshed = createStoredUserSession(tokens, credential);
-      await credentials.set(credentialRef, refreshed);
-      return refreshed;
     }
     function createStoredUserSession(tokens, previousCredential = {}) {
       const previousRaw = sanitizeCredentialRaw(previousCredential.raw);
@@ -222,6 +1887,7 @@ var require_auth = __commonJS({
     async function authApiRequest(authApiUrl, routePath, { method = "GET", body, headers = {} } = {}) {
       const response = await fetch(`${authApiUrl.replace(/\/+$/, "")}${authApiRoute(routePath)}`, {
         method,
+        signal: AbortSignal.timeout(2e4),
         headers: {
           accept: "application/json",
           ...body === void 0 ? {} : { "content-type": "application/json" },
@@ -16914,6 +18580,7 @@ var require_keychain = __commonJS({
     exports2.createLinuxKeychainAdapter = createLinuxKeychainAdapter;
     exports2.runSecretToolProcess = runSecretToolProcess;
     exports2.createKeychainAdapter = createKeychainAdapter;
+    var credential_mutations_1 = require_credential_mutations();
     var node_buffer_1 = require("node:buffer");
     var node_child_process_1 = require("node:child_process");
     var node_util_1 = require("node:util");
@@ -16937,7 +18604,7 @@ var require_keychain = __commonJS({
           throw error48;
         }
       }
-      return {
+      return (0, credential_mutations_1.coordinateCredentialMutations)({
         get: get2,
         async set(ref, credential) {
           await run("security", [
@@ -16976,7 +18643,7 @@ var require_keychain = __commonJS({
             return diagnostic(ref, "unreadable");
           }
         }
-      };
+      });
     }
     async function runCommand(command, args) {
       return await execFileAsync(command, args, { encoding: "utf8" });
@@ -17059,7 +18726,7 @@ var require_keychain = __commonJS({
           return null;
         return parseStoredCredential(raw, ref);
       }
-      return {
+      return (0, credential_mutations_1.coordinateCredentialMutations)({
         get: get2,
         async set(ref, credential) {
           const payload = JSON.stringify(credential);
@@ -17089,7 +18756,7 @@ var require_keychain = __commonJS({
             return diagnostic(ref, "unreadable");
           }
         }
-      };
+      });
     }
     async function runSecretTool(args, input) {
       return await runSecretToolProcess("secret-tool", args, input);
@@ -17665,6 +19332,102 @@ var require_public = __commonJS({
   }
 });
 
+// ../../packages/local-config/dist/session-broker.js
+var require_session_broker = __commonJS({
+  "../../packages/local-config/dist/session-broker.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.SessionBrokerUnavailableError = exports2.SESSION_BROKER_MAX_BYTES = exports2.SESSION_BROKER_ROUTE = exports2.sessionBrokerRequestSchema = exports2.sessionBrokerDescriptorSchema = void 0;
+    exports2.sessionBrokerPaths = sessionBrokerPaths;
+    exports2.requestDockSessionRefresh = requestDockSessionRefresh2;
+    exports2.isDockSessionBrokerAvailable = isDockSessionBrokerAvailable2;
+    var node_buffer_1 = require("node:buffer");
+    var node_fs_1 = require("node:fs");
+    var promises_1 = require("node:fs/promises");
+    var node_http_1 = require("node:http");
+    var node_path_1 = require("node:path");
+    var zod_1 = require_zod();
+    var paths_1 = require_paths();
+    exports2.sessionBrokerDescriptorSchema = zod_1.z.object({
+      version: zod_1.z.literal(1),
+      port: zod_1.z.number().int().min(1).max(65535),
+      secret: zod_1.z.string().regex(/^[a-f0-9]{64}$/)
+    }).strict();
+    exports2.sessionBrokerRequestSchema = zod_1.z.object({
+      contextId: zod_1.z.string().min(1).max(256)
+    }).strict();
+    exports2.SESSION_BROKER_ROUTE = "/v1/session/refresh";
+    exports2.SESSION_BROKER_MAX_BYTES = 4096;
+    function sessionBrokerPaths(rootDir = (0, paths_1.getTelaLocalPaths)().rootDir) {
+      const directory = (0, node_path_1.join)(rootDir, "session-broker");
+      return { directory, descriptor: (0, node_path_1.join)(directory, "endpoint.json") };
+    }
+    var SessionBrokerUnavailableError2 = class extends Error {
+      constructor() {
+        super("Tela Dock session renewal is unavailable. Open or update Tela Dock, then retry. No local refresh was attempted.");
+        this.name = "SessionBrokerUnavailableError";
+      }
+    };
+    exports2.SessionBrokerUnavailableError = SessionBrokerUnavailableError2;
+    async function requestDockSessionRefresh2(contextId, rootDir) {
+      await callBroker(JSON.stringify(exports2.sessionBrokerRequestSchema.parse({ contextId })), rootDir);
+    }
+    async function isDockSessionBrokerAvailable2(rootDir) {
+      try {
+        await callBroker(void 0, rootDir);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    async function callBroker(body, rootDir) {
+      const paths = sessionBrokerPaths(rootDir);
+      let endpoint;
+      try {
+        const directory = await (0, promises_1.lstat)(paths.directory);
+        if (!directory.isDirectory() || directory.uid !== process.getuid?.() || (directory.mode & 63) !== 0)
+          throw new Error("Unsafe broker directory");
+        const file2 = await (0, promises_1.open)(paths.descriptor, node_fs_1.constants.O_RDONLY | node_fs_1.constants.O_NOFOLLOW);
+        try {
+          const stat = await file2.stat();
+          if (!stat.isFile() || stat.uid !== process.getuid?.() || (stat.mode & 63) !== 0 || stat.size > exports2.SESSION_BROKER_MAX_BYTES)
+            throw new Error("Unsafe broker descriptor");
+          endpoint = exports2.sessionBrokerDescriptorSchema.parse(JSON.parse(await file2.readFile("utf8")));
+        } finally {
+          await file2.close();
+        }
+      } catch {
+        throw new SessionBrokerUnavailableError2();
+      }
+      await new Promise((resolve, reject) => {
+        const req = (0, node_http_1.request)({
+          hostname: "127.0.0.1",
+          port: endpoint.port,
+          method: body ? "POST" : "GET",
+          path: body ? exports2.SESSION_BROKER_ROUTE : "/v1/health",
+          agent: false,
+          headers: {
+            "authorization": `Bearer ${endpoint.secret}`,
+            "content-type": "application/json",
+            "content-length": node_buffer_1.Buffer.byteLength(body ?? "")
+          }
+        }, (res) => {
+          res.resume();
+          if (res.statusCode === 204)
+            resolve();
+          else if (res.statusCode === 401 || res.statusCode === 404)
+            reject(new SessionBrokerUnavailableError2());
+          else
+            reject(new Error("Tela Dock could not renew and save this session. Check the selected context in Dock and sign in again if needed."));
+        });
+        req.on("error", () => reject(new SessionBrokerUnavailableError2()));
+        req.setTimeout(body ? 3e4 : 1e3, () => req.destroy(new Error("Session renewal timed out")));
+        req.end(body);
+      });
+    }
+  }
+});
+
 // ../../packages/local-config/dist/types.js
 var require_types = __commonJS({
   "../../packages/local-config/dist/types.js"(exports2) {
@@ -17707,6 +19470,7 @@ var require_dist = __commonJS({
     __exportStar(require_paths(), exports2);
     __exportStar(require_public(), exports2);
     __exportStar(require_schema(), exports2);
+    __exportStar(require_session_broker(), exports2);
     __exportStar(require_types(), exports2);
   }
 });
@@ -19590,11 +21354,11 @@ var init_dist = __esm({
         return Promise.resolve(attempt < this.options.attempts);
       }
       getDelay(attempt) {
-        const delay = Math.min(
+        const delay2 = Math.min(
           this.options.maxDelay,
           this.options.baseDelay * 2 ** attempt
         );
-        return delay;
+        return delay2;
       }
     };
     getAuthHeader = async (options2) => {
@@ -19872,8 +21636,8 @@ var init_dist = __esm({
               await onRetry(responseContext);
             }
           }
-          const delay = retryStrategy.getDelay(_retryAttempt);
-          await new Promise((resolve) => setTimeout(resolve, delay));
+          const delay2 = retryStrategy.getDelay(_retryAttempt);
+          await new Promise((resolve) => setTimeout(resolve, delay2));
           return await betterFetch(url3, __spreadProps(__spreadValues({}, options2), {
             retryAttempt: _retryAttempt + 1
           }));
@@ -38129,14 +39893,14 @@ __export(dist_exports, {
 function isNotFound(err) {
   return typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT";
 }
-var import_promises, import_promises2, import_node_path, DeviceFlowAbortedError, DEFAULT_POLL_INTERVAL, DeviceFlow, JsonFileStorage;
+var import_promises2, import_promises3, import_node_path, DeviceFlowAbortedError, DEFAULT_POLL_INTERVAL, DeviceFlow, JsonFileStorage;
 var init_dist3 = __esm({
   "../../node_modules/.pnpm/@meistrari+auth-cli@1.6.0_@better-auth+core@1.6.26_@better-auth+utils@0.4.2_@better-fet_0bf65f4b8ffb95a65428638518b6161c/node_modules/@meistrari/auth-cli/dist/index.mjs"() {
-    import_promises = require("node:timers/promises");
+    import_promises2 = require("node:timers/promises");
     init_dist2();
     init_dist2();
     init_emittery();
-    import_promises2 = require("node:fs/promises");
+    import_promises3 = require("node:fs/promises");
     import_node_path = require("node:path");
     DeviceFlowAbortedError = class extends Error {
       /**
@@ -38446,7 +40210,7 @@ var init_dist3 = __esm({
        */
       async #sleep(ms) {
         try {
-          await (0, import_promises.setTimeout)(ms, void 0, { signal: this.#signal });
+          await (0, import_promises2.setTimeout)(ms, void 0, { signal: this.#signal });
         } catch (err) {
           if (this.#signal?.aborted) {
             await this.#emitAbortedOnce();
@@ -38477,7 +40241,7 @@ var init_dist3 = __esm({
        */
       async load() {
         try {
-          const content = await (0, import_promises2.readFile)(this.path, "utf-8");
+          const content = await (0, import_promises3.readFile)(this.path, "utf-8");
           return JSON.parse(content);
         } catch (err) {
           if (isNotFound(err))
@@ -38490,8 +40254,8 @@ var init_dist3 = __esm({
        * directories as needed and applying the configured file mode.
        */
       async save(tokens) {
-        await (0, import_promises2.mkdir)((0, import_node_path.dirname)(this.path), { recursive: true });
-        await (0, import_promises2.writeFile)(this.path, JSON.stringify(tokens, null, this.#indent), {
+        await (0, import_promises3.mkdir)((0, import_node_path.dirname)(this.path), { recursive: true });
+        await (0, import_promises3.writeFile)(this.path, JSON.stringify(tokens, null, this.#indent), {
           mode: this.#mode
         });
       }
@@ -38501,7 +40265,7 @@ var init_dist3 = __esm({
        */
       async clear() {
         try {
-          await (0, import_promises2.unlink)(this.path);
+          await (0, import_promises3.unlink)(this.path);
         } catch (err) {
           if (isNotFound(err))
             return;
@@ -137307,10 +139071,10 @@ function T3(r2, t2, i2, s) {
     max: e && t2.year === e.year && t2.month === e.month ? e.day : c(t2.year, t2.month)
   };
 }
-var import_node_util, import_node_process5, l2, import_node_readline, import_sisteransi, import_node_tty2, a$1, t, settings, R2, CANCEL_SYMBOL, getColumns, getRows, V, T$1, r, _, U, u$2, o, h, a, u$1, n$1, u4, n2;
+var import_node_util2, import_node_process5, l2, import_node_readline, import_sisteransi, import_node_tty2, a$1, t, settings, R2, CANCEL_SYMBOL, getColumns, getRows, V, T$1, r, _, U, u$2, o, h, a, u$1, n$1, u4, n2;
 var init_dist7 = __esm({
   "../../node_modules/.pnpm/@clack+core@1.4.3/node_modules/@clack/core/dist/index.mjs"() {
-    import_node_util = require("node:util");
+    import_node_util2 = require("node:util");
     import_node_process5 = require("node:process");
     l2 = __toESM(require("node:readline"), 1);
     import_node_readline = __toESM(require("node:readline"), 1);
@@ -137545,11 +139309,11 @@ var init_dist7 = __esm({
       }
       get userInputWithCursor() {
         if (!this.userInput)
-          return (0, import_node_util.styleText)(["inverse", "hidden"], "_");
+          return (0, import_node_util2.styleText)(["inverse", "hidden"], "_");
         if (this._cursor >= this.userInput.length)
           return `${this.userInput}\u2588`;
         const e = this.userInput.slice(0, this.cursor), t2 = this.userInput.slice(this.cursor, this.cursor + 1), i2 = this.userInput.slice(this.cursor + 1);
-        return `${e}${(0, import_node_util.styleText)("inverse", t2)}${i2}`;
+        return `${e}${(0, import_node_util2.styleText)("inverse", t2)}${i2}`;
       }
       get options() {
         return typeof this.#i == "function" ? this.#i() : this.#i;
@@ -137854,7 +139618,7 @@ var init_dist7 = __esm({
         const s = t2.slice(0, this.cursor), r2 = t2.slice(this.cursor, this.cursor + 1), i2 = t2.slice(this.cursor + 1);
         return r2 === `
 ` ? `${s}\u2588
-${i2}` : `${s}${(0, import_node_util.styleText)("inverse", r2)}${i2}`;
+${i2}` : `${s}${(0, import_node_util2.styleText)("inverse", r2)}${i2}`;
       }
       get cursor() {
         return this._cursor;
@@ -137998,9 +139762,9 @@ ${i2}` : `${s}${(0, import_node_util.styleText)("inverse", r2)}${i2}`;
           return this.masked;
         const t2 = this.userInput;
         if (this.cursor >= t2.length)
-          return `${this.masked}${(0, import_node_util.styleText)(["inverse", "hidden"], "_")}`;
+          return `${this.masked}${(0, import_node_util2.styleText)(["inverse", "hidden"], "_")}`;
         const s = this.masked, r2 = s.slice(0, this.cursor), i2 = s.slice(this.cursor, this.cursor + 1), o2 = s.slice(this.cursor + 1);
-        return `${r2}${(0, import_node_util.styleText)("inverse", i2)}${o2}`;
+        return `${r2}${(0, import_node_util2.styleText)("inverse", i2)}${o2}`;
       }
       clear() {
         this._clearUserInput();
@@ -138066,7 +139830,7 @@ ${i2}` : `${s}${(0, import_node_util.styleText)("inverse", r2)}${i2}`;
         if (this.cursor >= t2.length)
           return `${this.userInput}\u2588`;
         const r2 = t2.slice(0, this.cursor), s = t2.slice(this.cursor, this.cursor + 1), e = t2.slice(this.cursor + 1);
-        return `${r2}${(0, import_node_util.styleText)("inverse", s)}${e}`;
+        return `${r2}${(0, import_node_util2.styleText)("inverse", s)}${e}`;
       }
       get cursor() {
         return this._cursor;
@@ -138158,8 +139922,8 @@ function isUnicodeSupported() {
   return Boolean(import_node_process6.default.env.CI) || Boolean(import_node_process6.default.env.WT_SESSION) || Boolean(import_node_process6.default.env.TERMINUS_SUBLIME) || import_node_process6.default.env.ConEmuTask === "{cmd::Cmder}" || import_node_process6.default.env.TERM_PROGRAM === "Terminus-Sublime" || import_node_process6.default.env.TERM_PROGRAM === "vscode" || import_node_process6.default.env.TERM === "xterm-256color" || import_node_process6.default.env.TERM === "alacritty" || import_node_process6.default.env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
 }
 function formatInstructionFooter(o2, e) {
-  const r2 = [`${e ? `${(0, import_node_util2.styleText)("cyan", S_BAR)}  ` : ""}${o2.join(" \u2022 ")}`];
-  return e && r2.push((0, import_node_util2.styleText)("cyan", S_BAR_END)), r2;
+  const r2 = [`${e ? `${(0, import_node_util3.styleText)("cyan", S_BAR)}  ` : ""}${o2.join(" \u2022 ")}`];
+  return e && r2.push((0, import_node_util3.styleText)("cyan", S_BAR_END)), r2;
 }
 function P3(t2) {
   return t2.label ?? String(t2.value ?? "");
@@ -138184,7 +139948,7 @@ function b2(e, r2) {
   const t2 = e.segmentValues, o2 = e.segmentCursor;
   if (r2 === "submit" || r2 === "cancel")
     return e.formattedValue;
-  const i2 = (0, import_node_util2.styleText)("gray", e.separator);
+  const i2 = (0, import_node_util3.styleText)("gray", e.separator);
   return e.segments.map((l3, d) => {
     const c3 = d === o2.segmentIndex && !["submit", "cancel"].includes(r2), a2 = p2[l3.type];
     return x(t2[l3.type], { isActive: c3, label: a2 });
@@ -138192,7 +139956,7 @@ function b2(e, r2) {
 }
 function x(e, r2) {
   const t2 = !e || e.replace(/_/g, "") === "";
-  return r2.isActive ? (0, import_node_util2.styleText)("inverse", t2 ? r2.label : e.replace(/_/g, " ")) : t2 ? (0, import_node_util2.styleText)("dim", r2.label) : e.replace(/_/g, (0, import_node_util2.styleText)("dim", " "));
+  return r2.isActive ? (0, import_node_util3.styleText)("inverse", t2 ? r2.label : e.replace(/_/g, " ")) : t2 ? (0, import_node_util3.styleText)("dim", r2.label) : e.replace(/_/g, (0, import_node_util3.styleText)("dim", " "));
 }
 function progress({
   style: o2 = "heavy",
@@ -138206,18 +139970,18 @@ function progress({
     switch (t2) {
       case "initial":
       case "active":
-        return (e) => (0, import_node_util2.styleText)("magenta", e);
+        return (e) => (0, import_node_util3.styleText)("magenta", e);
       case "error":
       case "cancel":
-        return (e) => (0, import_node_util2.styleText)("red", e);
+        return (e) => (0, import_node_util3.styleText)("red", e);
       case "submit":
-        return (e) => (0, import_node_util2.styleText)("green", e);
+        return (e) => (0, import_node_util3.styleText)("green", e);
       default:
-        return (e) => (0, import_node_util2.styleText)("magenta", e);
+        return (e) => (0, import_node_util3.styleText)("magenta", e);
     }
   }, p3 = (t2, e) => {
     const m3 = Math.floor(a2 / c3 * l3);
-    return `${S2(t2)(u5[o2].repeat(m3))}${(0, import_node_util2.styleText)("dim", u5[o2].repeat(l3 - m3))} ${e}`;
+    return `${S2(t2)(u5[o2].repeat(m3))}${(0, import_node_util3.styleText)("dim", u5[o2].repeat(l3 - m3))} ${e}`;
   }, h2 = (t2 = "") => {
     n3 = t2, r2.start(p3("initial", t2));
   }, g2 = (t2 = 1, e) => {
@@ -138234,12 +139998,12 @@ function progress({
     message: (t2) => g2(0, t2)
   };
 }
-var import_node_util2, import_node_process6, import_node_fs, import_node_path3, import_sisteransi2, unicode, isCI, isTTY, unicodeOr, S_STEP_ACTIVE, S_STEP_CANCEL, S_STEP_ERROR, S_STEP_SUBMIT, S_BAR_START, S_BAR, S_BAR_END, S_BAR_START_RIGHT, S_BAR_END_RIGHT, S_RADIO_ACTIVE, S_RADIO_INACTIVE, S_CHECKBOX_ACTIVE, S_CHECKBOX_SELECTED, S_CHECKBOX_INACTIVE, S_PASSWORD_MASK, S_BAR_H, S_CORNER_TOP_RIGHT, S_CONNECT_LEFT, S_CORNER_BOTTOM_RIGHT, S_CORNER_BOTTOM_LEFT, S_CORNER_TOP_LEFT, S_INFO, S_SUCCESS, S_WARN, S_ERROR, symbol2, symbolBar, I2, limitOptions, autocomplete, autocompleteMultiselect, J, K, Q, box, confirm, date5, p2, group, MULTISELECT_INSTRUCTIONS, m2, multiselect, groupMultiselect, log, cancel, intro, outro, multiline, W$1, C3, note, password, path, W, spinner, u5, SELECT_INSTRUCTIONS, c2, select, selectKey, i, stream4, tasks, A, taskLog, text;
+var import_node_util3, import_node_process6, import_node_fs, import_node_path3, import_sisteransi2, unicode, isCI, isTTY, unicodeOr, S_STEP_ACTIVE, S_STEP_CANCEL, S_STEP_ERROR, S_STEP_SUBMIT, S_BAR_START, S_BAR, S_BAR_END, S_BAR_START_RIGHT, S_BAR_END_RIGHT, S_RADIO_ACTIVE, S_RADIO_INACTIVE, S_CHECKBOX_ACTIVE, S_CHECKBOX_SELECTED, S_CHECKBOX_INACTIVE, S_PASSWORD_MASK, S_BAR_H, S_CORNER_TOP_RIGHT, S_CONNECT_LEFT, S_CORNER_BOTTOM_RIGHT, S_CORNER_BOTTOM_LEFT, S_CORNER_TOP_LEFT, S_INFO, S_SUCCESS, S_WARN, S_ERROR, symbol2, symbolBar, I2, limitOptions, autocomplete, autocompleteMultiselect, J, K, Q, box, confirm, date5, p2, group, MULTISELECT_INSTRUCTIONS, m2, multiselect, groupMultiselect, log, cancel, intro, outro, multiline, W$1, C3, note, password, path, W, spinner, u5, SELECT_INSTRUCTIONS, c2, select, selectKey, i, stream4, tasks, A, taskLog, text;
 var init_dist8 = __esm({
   "../../node_modules/.pnpm/@clack+prompts@1.7.0/node_modules/@clack/prompts/dist/index.mjs"() {
     init_dist7();
     init_dist7();
-    import_node_util2 = require("node:util");
+    import_node_util3 = require("node:util");
     import_node_process6 = __toESM(require("node:process"), 1);
     init_main();
     init_dist6();
@@ -138279,26 +140043,26 @@ var init_dist8 = __esm({
       switch (o2) {
         case "initial":
         case "active":
-          return (0, import_node_util2.styleText)("cyan", S_STEP_ACTIVE);
+          return (0, import_node_util3.styleText)("cyan", S_STEP_ACTIVE);
         case "cancel":
-          return (0, import_node_util2.styleText)("red", S_STEP_CANCEL);
+          return (0, import_node_util3.styleText)("red", S_STEP_CANCEL);
         case "error":
-          return (0, import_node_util2.styleText)("yellow", S_STEP_ERROR);
+          return (0, import_node_util3.styleText)("yellow", S_STEP_ERROR);
         case "submit":
-          return (0, import_node_util2.styleText)("green", S_STEP_SUBMIT);
+          return (0, import_node_util3.styleText)("green", S_STEP_SUBMIT);
       }
     };
     symbolBar = (o2) => {
       switch (o2) {
         case "initial":
         case "active":
-          return (0, import_node_util2.styleText)("cyan", S_BAR);
+          return (0, import_node_util3.styleText)("cyan", S_BAR);
         case "cancel":
-          return (0, import_node_util2.styleText)("red", S_BAR);
+          return (0, import_node_util3.styleText)("red", S_BAR);
         case "error":
-          return (0, import_node_util2.styleText)("yellow", S_BAR);
+          return (0, import_node_util3.styleText)("yellow", S_BAR);
         case "submit":
-          return (0, import_node_util2.styleText)("green", S_BAR);
+          return (0, import_node_util3.styleText)("green", S_BAR);
       }
     };
     I2 = (l3, e, w2, p3, b3, C4 = false) => {
@@ -138324,7 +140088,7 @@ var init_dist8 = __esm({
       columnPadding: C4 = 0,
       rowPadding: r2 = 4
     }) => {
-      const i2 = getColumns(p3) - C4, m3 = getRows(p3), M3 = (0, import_node_util2.styleText)("dim", "..."), v = Math.max(m3 - r2, 0), a2 = Math.max(Math.min(b3, v), 5);
+      const i2 = getColumns(p3) - C4, m3 = getRows(p3), M3 = (0, import_node_util3.styleText)("dim", "..."), v = Math.max(m3 - r2, 0), a2 = Math.max(Math.min(b3, v), 5);
       let f2 = 0;
       l3 >= a2 - 3 && (f2 = Math.max(
         Math.min(l3 - a2 + 3, e.length - a2),
@@ -138378,51 +140142,51 @@ var init_dist8 = __esm({
       output: t2.output,
       validate: t2.validate,
       render() {
-        const n3 = t2.withGuide ?? settings.withGuide, i2 = n3 ? [`${(0, import_node_util2.styleText)("gray", S_BAR)}`, `${symbol2(this.state)}  ${t2.message}`] : [`${symbol2(this.state)}  ${t2.message}`], l3 = this.userInput, o2 = this.options, m3 = t2.placeholder, p3 = l3 === "" && m3 !== void 0, $2 = (r2, s) => {
-          const a2 = P3(r2), u6 = r2.hint && r2.value === this.focusedValue ? (0, import_node_util2.styleText)("dim", ` (${r2.hint})`) : "";
+        const n3 = t2.withGuide ?? settings.withGuide, i2 = n3 ? [`${(0, import_node_util3.styleText)("gray", S_BAR)}`, `${symbol2(this.state)}  ${t2.message}`] : [`${symbol2(this.state)}  ${t2.message}`], l3 = this.userInput, o2 = this.options, m3 = t2.placeholder, p3 = l3 === "" && m3 !== void 0, $2 = (r2, s) => {
+          const a2 = P3(r2), u6 = r2.hint && r2.value === this.focusedValue ? (0, import_node_util3.styleText)("dim", ` (${r2.hint})`) : "";
           switch (s) {
             case "active":
-              return `${(0, import_node_util2.styleText)("green", S_RADIO_ACTIVE)} ${a2}${u6}`;
+              return `${(0, import_node_util3.styleText)("green", S_RADIO_ACTIVE)} ${a2}${u6}`;
             case "inactive":
-              return `${(0, import_node_util2.styleText)("dim", S_RADIO_INACTIVE)} ${(0, import_node_util2.styleText)("dim", a2)}`;
+              return `${(0, import_node_util3.styleText)("dim", S_RADIO_INACTIVE)} ${(0, import_node_util3.styleText)("dim", a2)}`;
             case "disabled":
-              return `${(0, import_node_util2.styleText)("gray", S_RADIO_INACTIVE)} ${(0, import_node_util2.styleText)(["strikethrough", "gray"], a2)}`;
+              return `${(0, import_node_util3.styleText)("gray", S_RADIO_INACTIVE)} ${(0, import_node_util3.styleText)(["strikethrough", "gray"], a2)}`;
           }
         };
         switch (this.state) {
           case "submit": {
-            const r2 = N(this.selectedValues, o2), s = r2.length > 0 ? `  ${(0, import_node_util2.styleText)("dim", r2.map(P3).join(", "))}` : "", a2 = n3 ? (0, import_node_util2.styleText)("gray", S_BAR) : "";
+            const r2 = N(this.selectedValues, o2), s = r2.length > 0 ? `  ${(0, import_node_util3.styleText)("dim", r2.map(P3).join(", "))}` : "", a2 = n3 ? (0, import_node_util3.styleText)("gray", S_BAR) : "";
             return `${i2.join(`
 `)}
 ${a2}${s}`;
           }
           case "cancel": {
-            const r2 = l3 ? `  ${(0, import_node_util2.styleText)(["strikethrough", "dim"], l3)}` : "", s = n3 ? (0, import_node_util2.styleText)("gray", S_BAR) : "";
+            const r2 = l3 ? `  ${(0, import_node_util3.styleText)(["strikethrough", "dim"], l3)}` : "", s = n3 ? (0, import_node_util3.styleText)("gray", S_BAR) : "";
             return `${i2.join(`
 `)}
 ${s}${r2}`;
           }
           default: {
-            const r2 = this.state === "error" ? "yellow" : "cyan", s = n3 ? `${(0, import_node_util2.styleText)(r2, S_BAR)}  ` : "", a2 = n3 ? (0, import_node_util2.styleText)(r2, S_BAR_END) : "";
+            const r2 = this.state === "error" ? "yellow" : "cyan", s = n3 ? `${(0, import_node_util3.styleText)(r2, S_BAR)}  ` : "", a2 = n3 ? (0, import_node_util3.styleText)(r2, S_BAR_END) : "";
             let u6 = "";
             if (this.isNavigating || p3) {
               const d = p3 ? m3 : l3;
-              u6 = d !== "" ? ` ${(0, import_node_util2.styleText)("dim", d)}` : "";
+              u6 = d !== "" ? ` ${(0, import_node_util3.styleText)("dim", d)}` : "";
             } else
               u6 = ` ${this.userInputWithCursor}`;
-            const V2 = this.filteredOptions.length !== o2.length ? (0, import_node_util2.styleText)(
+            const V2 = this.filteredOptions.length !== o2.length ? (0, import_node_util3.styleText)(
               "dim",
               ` (${this.filteredOptions.length} match${this.filteredOptions.length === 1 ? "" : "es"})`
-            ) : "", y2 = this.filteredOptions.length === 0 && l3 ? [`${s}${(0, import_node_util2.styleText)("yellow", "No matches found")}`] : [], b3 = this.state === "error" ? [`${s}${(0, import_node_util2.styleText)("yellow", this.error)}`] : [];
+            ) : "", y2 = this.filteredOptions.length === 0 && l3 ? [`${s}${(0, import_node_util3.styleText)("yellow", "No matches found")}`] : [], b3 = this.state === "error" ? [`${s}${(0, import_node_util3.styleText)("yellow", this.error)}`] : [];
             n3 && i2.push(`${s.trimEnd()}`), i2.push(
-              `${s}${(0, import_node_util2.styleText)("dim", "Search:")}${u6}${V2}`,
+              `${s}${(0, import_node_util3.styleText)("dim", "Search:")}${u6}${V2}`,
               ...y2,
               ...b3
             );
             const v = [
-              `${(0, import_node_util2.styleText)("dim", "\u2191/\u2193")} to select`,
-              `${(0, import_node_util2.styleText)("dim", "Enter:")} confirm`,
-              `${(0, import_node_util2.styleText)("dim", "Type:")} to search`
+              `${(0, import_node_util3.styleText)("dim", "\u2191/\u2193")} to select`,
+              `${(0, import_node_util3.styleText)("dim", "Enter:")} confirm`,
+              `${(0, import_node_util3.styleText)("dim", "Type:")} to search`
             ], g2 = [`${s}${v.join(" \u2022 ")}`, a2], O = this.filteredOptions.length === 0 ? [] : limitOptions({
               cursor: this.cursor,
               options: this.filteredOptions,
@@ -138448,8 +140212,8 @@ ${s}${r2}`;
     }).prompt();
     autocompleteMultiselect = (t2) => {
       const c3 = (i2, l3, o2, m3) => {
-        const p3 = o2.includes(i2.value), $2 = i2.label ?? String(i2.value ?? ""), r2 = i2.hint && m3 !== void 0 && i2.value === m3 ? (0, import_node_util2.styleText)("dim", ` (${i2.hint})`) : "", s = p3 ? (0, import_node_util2.styleText)("green", S_CHECKBOX_SELECTED) : (0, import_node_util2.styleText)("dim", S_CHECKBOX_INACTIVE);
-        return i2.disabled ? `${(0, import_node_util2.styleText)("gray", S_CHECKBOX_INACTIVE)} ${(0, import_node_util2.styleText)(["strikethrough", "gray"], $2)}` : l3 ? `${s} ${$2}${r2}` : `${s} ${(0, import_node_util2.styleText)("dim", $2)}`;
+        const p3 = o2.includes(i2.value), $2 = i2.label ?? String(i2.value ?? ""), r2 = i2.hint && m3 !== void 0 && i2.value === m3 ? (0, import_node_util3.styleText)("dim", ` (${i2.hint})`) : "", s = p3 ? (0, import_node_util3.styleText)("green", S_CHECKBOX_SELECTED) : (0, import_node_util3.styleText)("dim", S_CHECKBOX_INACTIVE);
+        return i2.disabled ? `${(0, import_node_util3.styleText)("gray", S_CHECKBOX_INACTIVE)} ${(0, import_node_util3.styleText)(["strikethrough", "gray"], $2)}` : l3 ? `${s} ${$2}${r2}` : `${s} ${(0, import_node_util3.styleText)("dim", $2)}`;
       }, n3 = new T$1({
         options: t2.options,
         multiple: true,
@@ -138464,33 +140228,33 @@ ${s}${r2}`;
         input: t2.input,
         output: t2.output,
         render() {
-          const i2 = t2.withGuide ?? settings.withGuide, l3 = `${i2 ? `${(0, import_node_util2.styleText)("gray", S_BAR)}
+          const i2 = t2.withGuide ?? settings.withGuide, l3 = `${i2 ? `${(0, import_node_util3.styleText)("gray", S_BAR)}
 ` : ""}${symbol2(this.state)}  ${t2.message}
-`, o2 = this.userInput, m3 = t2.placeholder, p3 = o2 === "" && m3 !== void 0, $2 = this.isNavigating || p3 ? (0, import_node_util2.styleText)("dim", p3 ? m3 : o2) : this.userInputWithCursor, r2 = this.options, s = this.filteredOptions.length !== r2.length ? (0, import_node_util2.styleText)(
+`, o2 = this.userInput, m3 = t2.placeholder, p3 = o2 === "" && m3 !== void 0, $2 = this.isNavigating || p3 ? (0, import_node_util3.styleText)("dim", p3 ? m3 : o2) : this.userInputWithCursor, r2 = this.options, s = this.filteredOptions.length !== r2.length ? (0, import_node_util3.styleText)(
             "dim",
             ` (${this.filteredOptions.length} match${this.filteredOptions.length === 1 ? "" : "es"})`
           ) : "";
           switch (this.state) {
             case "submit":
-              return `${l3}${i2 ? `${(0, import_node_util2.styleText)("gray", S_BAR)}  ` : ""}${(0, import_node_util2.styleText)(
+              return `${l3}${i2 ? `${(0, import_node_util3.styleText)("gray", S_BAR)}  ` : ""}${(0, import_node_util3.styleText)(
                 "dim",
                 `${this.selectedValues.length} items selected`
               )}`;
             case "cancel":
-              return `${l3}${i2 ? `${(0, import_node_util2.styleText)("gray", S_BAR)}  ` : ""}${(0, import_node_util2.styleText)(
+              return `${l3}${i2 ? `${(0, import_node_util3.styleText)("gray", S_BAR)}  ` : ""}${(0, import_node_util3.styleText)(
                 ["strikethrough", "dim"],
                 o2
               )}`;
             default: {
-              const a2 = this.state === "error" ? "yellow" : "cyan", u6 = i2 ? `${(0, import_node_util2.styleText)(a2, S_BAR)}  ` : "", V2 = i2 ? (0, import_node_util2.styleText)(a2, S_BAR_END) : "", y2 = [
-                `${(0, import_node_util2.styleText)("dim", "\u2191/\u2193")} to navigate`,
-                `${(0, import_node_util2.styleText)("dim", this.isNavigating ? "Space/Tab:" : "Tab:")} select`,
-                `${(0, import_node_util2.styleText)("dim", "Enter:")} confirm`,
-                `${(0, import_node_util2.styleText)("dim", "Type:")} to search`
-              ], b3 = this.filteredOptions.length === 0 && o2 ? [`${u6}${(0, import_node_util2.styleText)("yellow", "No matches found")}`] : [], v = this.state === "error" ? [`${u6}${(0, import_node_util2.styleText)("yellow", this.error)}`] : [], g2 = [
-                ...`${l3}${i2 ? (0, import_node_util2.styleText)(a2, S_BAR) : ""}`.split(`
+              const a2 = this.state === "error" ? "yellow" : "cyan", u6 = i2 ? `${(0, import_node_util3.styleText)(a2, S_BAR)}  ` : "", V2 = i2 ? (0, import_node_util3.styleText)(a2, S_BAR_END) : "", y2 = [
+                `${(0, import_node_util3.styleText)("dim", "\u2191/\u2193")} to navigate`,
+                `${(0, import_node_util3.styleText)("dim", this.isNavigating ? "Space/Tab:" : "Tab:")} select`,
+                `${(0, import_node_util3.styleText)("dim", "Enter:")} confirm`,
+                `${(0, import_node_util3.styleText)("dim", "Type:")} to search`
+              ], b3 = this.filteredOptions.length === 0 && o2 ? [`${u6}${(0, import_node_util3.styleText)("yellow", "No matches found")}`] : [], v = this.state === "error" ? [`${u6}${(0, import_node_util3.styleText)("yellow", this.error)}`] : [], g2 = [
+                ...`${l3}${i2 ? (0, import_node_util3.styleText)(a2, S_BAR) : ""}`.split(`
 `),
-                `${u6}${(0, import_node_util2.styleText)("dim", "Search:")} ${$2}${s}`,
+                `${u6}${(0, import_node_util3.styleText)("dim", "Search:")} ${$2}${s}`,
                 ...b3,
                 ...v
               ], O = [`${u6}${y2.join(" \u2022 ")}`, V2], d = limitOptions({
@@ -138576,29 +140340,29 @@ ${s}${r2}`;
         output: i2.output,
         initialValue: i2.initialValue ?? true,
         render() {
-          const e = i2.withGuide ?? settings.withGuide, u6 = `${symbol2(this.state)}  `, l3 = e ? `${(0, import_node_util2.styleText)("gray", S_BAR)}  ` : "", f2 = wrapTextWithPrefix(
+          const e = i2.withGuide ?? settings.withGuide, u6 = `${symbol2(this.state)}  `, l3 = e ? `${(0, import_node_util3.styleText)("gray", S_BAR)}  ` : "", f2 = wrapTextWithPrefix(
             i2.output,
             i2.message,
             l3,
             u6
-          ), o2 = `${e ? `${(0, import_node_util2.styleText)("gray", S_BAR)}
+          ), o2 = `${e ? `${(0, import_node_util3.styleText)("gray", S_BAR)}
 ` : ""}${f2}
 `, c3 = this.value ? a2 : s;
           switch (this.state) {
             case "submit": {
-              const r2 = e ? `${(0, import_node_util2.styleText)("gray", S_BAR)}  ` : "";
-              return `${o2}${r2}${(0, import_node_util2.styleText)("dim", c3)}`;
+              const r2 = e ? `${(0, import_node_util3.styleText)("gray", S_BAR)}  ` : "";
+              return `${o2}${r2}${(0, import_node_util3.styleText)("dim", c3)}`;
             }
             case "cancel": {
-              const r2 = e ? `${(0, import_node_util2.styleText)("gray", S_BAR)}  ` : "";
-              return `${o2}${r2}${(0, import_node_util2.styleText)(["strikethrough", "dim"], c3)}${e ? `
-${(0, import_node_util2.styleText)("gray", S_BAR)}` : ""}`;
+              const r2 = e ? `${(0, import_node_util3.styleText)("gray", S_BAR)}  ` : "";
+              return `${o2}${r2}${(0, import_node_util3.styleText)(["strikethrough", "dim"], c3)}${e ? `
+${(0, import_node_util3.styleText)("gray", S_BAR)}` : ""}`;
             }
             default: {
-              const r2 = e ? `${(0, import_node_util2.styleText)("cyan", S_BAR)}  ` : "", g2 = e ? (0, import_node_util2.styleText)("cyan", S_BAR_END) : "";
-              return `${o2}${r2}${this.value ? `${(0, import_node_util2.styleText)("green", S_RADIO_ACTIVE)} ${a2}` : `${(0, import_node_util2.styleText)("dim", S_RADIO_INACTIVE)} ${(0, import_node_util2.styleText)("dim", a2)}`}${i2.vertical ? e ? `
-${(0, import_node_util2.styleText)("cyan", S_BAR)}  ` : `
-` : ` ${(0, import_node_util2.styleText)("dim", "/")} `}${this.value ? `${(0, import_node_util2.styleText)("dim", S_RADIO_INACTIVE)} ${(0, import_node_util2.styleText)("dim", s)}` : `${(0, import_node_util2.styleText)("green", S_RADIO_ACTIVE)} ${s}`}
+              const r2 = e ? `${(0, import_node_util3.styleText)("cyan", S_BAR)}  ` : "", g2 = e ? (0, import_node_util3.styleText)("cyan", S_BAR_END) : "";
+              return `${o2}${r2}${this.value ? `${(0, import_node_util3.styleText)("green", S_RADIO_ACTIVE)} ${a2}` : `${(0, import_node_util3.styleText)("dim", S_RADIO_INACTIVE)} ${(0, import_node_util3.styleText)("dim", a2)}`}${i2.vertical ? e ? `
+${(0, import_node_util3.styleText)("cyan", S_BAR)}  ` : `
+` : ` ${(0, import_node_util3.styleText)("dim", "/")} `}${this.value ? `${(0, import_node_util3.styleText)("dim", S_RADIO_INACTIVE)} ${(0, import_node_util3.styleText)("dim", s)}` : `${(0, import_node_util3.styleText)("green", S_RADIO_ACTIVE)} ${s}`}
 ${g2}
 `;
             }
@@ -138621,29 +140385,29 @@ ${g2}
           if (r2) return runValidation(r2, t2);
         },
         render() {
-          const t2 = (e?.withGuide ?? settings.withGuide) !== false, i2 = `${`${t2 ? `${(0, import_node_util2.styleText)("gray", S_BAR)}
+          const t2 = (e?.withGuide ?? settings.withGuide) !== false, i2 = `${`${t2 ? `${(0, import_node_util3.styleText)("gray", S_BAR)}
 ` : ""}${symbol2(this.state)}  `}${e.message}
 `, l3 = this.state !== "initial" ? this.state : "active", d = b2(this, l3), c3 = this.value instanceof Date ? this.formattedValue : "";
           switch (this.state) {
             case "error": {
-              const a2 = this.error ? `  ${(0, import_node_util2.styleText)("yellow", this.error)}` : "", s = t2 ? `${(0, import_node_util2.styleText)("yellow", S_BAR)}  ` : "", f2 = t2 ? (0, import_node_util2.styleText)("yellow", S_BAR_END) : "";
+              const a2 = this.error ? `  ${(0, import_node_util3.styleText)("yellow", this.error)}` : "", s = t2 ? `${(0, import_node_util3.styleText)("yellow", S_BAR)}  ` : "", f2 = t2 ? (0, import_node_util3.styleText)("yellow", S_BAR_END) : "";
               return `${i2.trim()}
 ${s}${d}
 ${f2}${a2}
 `;
             }
             case "submit": {
-              const a2 = c3 ? `  ${(0, import_node_util2.styleText)("dim", c3)}` : "", s = t2 ? (0, import_node_util2.styleText)("gray", S_BAR) : "";
+              const a2 = c3 ? `  ${(0, import_node_util3.styleText)("dim", c3)}` : "", s = t2 ? (0, import_node_util3.styleText)("gray", S_BAR) : "";
               return `${i2}${s}${a2}`;
             }
             case "cancel": {
-              const a2 = c3 ? `  ${(0, import_node_util2.styleText)(["strikethrough", "dim"], c3)}` : "", s = t2 ? (0, import_node_util2.styleText)("gray", S_BAR) : "";
+              const a2 = c3 ? `  ${(0, import_node_util3.styleText)(["strikethrough", "dim"], c3)}` : "", s = t2 ? (0, import_node_util3.styleText)("gray", S_BAR) : "";
               return `${i2}${s}${a2}${c3.trim() ? `
 ${s}` : ""}`;
             }
             default: {
-              const a2 = t2 ? `${(0, import_node_util2.styleText)("cyan", S_BAR)}  ` : "", s = t2 ? (0, import_node_util2.styleText)("cyan", S_BAR_END) : "", f2 = t2 ? `${(0, import_node_util2.styleText)("cyan", S_BAR)}  ` : "", g2 = this.inlineError ? `
-${f2}${(0, import_node_util2.styleText)("yellow", this.inlineError)}` : "";
+              const a2 = t2 ? `${(0, import_node_util3.styleText)("cyan", S_BAR)}  ` : "", s = t2 ? (0, import_node_util3.styleText)("cyan", S_BAR_END) : "", f2 = t2 ? `${(0, import_node_util3.styleText)("cyan", S_BAR)}  ` : "", g2 = this.inlineError ? `
+${f2}${(0, import_node_util3.styleText)("yellow", this.inlineError)}` : "";
               return `${i2}${a2}${d}${g2}
 ${s}
 `;
@@ -138672,9 +140436,9 @@ ${s}
       return t2;
     };
     MULTISELECT_INSTRUCTIONS = [
-      `${(0, import_node_util2.styleText)("dim", "\u2191/\u2193")} to navigate`,
-      `${(0, import_node_util2.styleText)("dim", "Space:")} select`,
-      `${(0, import_node_util2.styleText)("dim", "Enter:")} confirm`
+      `${(0, import_node_util3.styleText)("dim", "\u2191/\u2193")} to navigate`,
+      `${(0, import_node_util3.styleText)("dim", "Space:")} select`,
+      `${(0, import_node_util3.styleText)("dim", "Enter:")} confirm`
     ];
     m2 = (i2, u6) => i2.split(`
 `).map((d) => u6(d)).join(`
@@ -138682,7 +140446,7 @@ ${s}
     multiselect = (i2) => {
       const u6 = (t2, a2) => {
         const r2 = t2.label ?? String(t2.value);
-        return a2 === "disabled" ? `${(0, import_node_util2.styleText)("gray", S_CHECKBOX_INACTIVE)} ${m2(r2, (o2) => (0, import_node_util2.styleText)(["strikethrough", "gray"], o2))}${t2.hint ? ` ${(0, import_node_util2.styleText)("dim", `(${t2.hint ?? "disabled"})`)}` : ""}` : a2 === "active" ? `${(0, import_node_util2.styleText)("cyan", S_CHECKBOX_ACTIVE)} ${r2}${t2.hint ? ` ${(0, import_node_util2.styleText)("dim", `(${t2.hint})`)}` : ""}` : a2 === "selected" ? `${(0, import_node_util2.styleText)("green", S_CHECKBOX_SELECTED)} ${m2(r2, (o2) => (0, import_node_util2.styleText)("dim", o2))}${t2.hint ? ` ${(0, import_node_util2.styleText)("dim", `(${t2.hint})`)}` : ""}` : a2 === "cancelled" ? `${m2(r2, (o2) => (0, import_node_util2.styleText)(["strikethrough", "dim"], o2))}` : a2 === "active-selected" ? `${(0, import_node_util2.styleText)("green", S_CHECKBOX_SELECTED)} ${r2}${t2.hint ? ` ${(0, import_node_util2.styleText)("dim", `(${t2.hint})`)}` : ""}` : a2 === "submitted" ? `${m2(r2, (o2) => (0, import_node_util2.styleText)("dim", o2))}` : `${(0, import_node_util2.styleText)("dim", S_CHECKBOX_INACTIVE)} ${m2(r2, (o2) => (0, import_node_util2.styleText)("dim", o2))}`;
+        return a2 === "disabled" ? `${(0, import_node_util3.styleText)("gray", S_CHECKBOX_INACTIVE)} ${m2(r2, (o2) => (0, import_node_util3.styleText)(["strikethrough", "gray"], o2))}${t2.hint ? ` ${(0, import_node_util3.styleText)("dim", `(${t2.hint ?? "disabled"})`)}` : ""}` : a2 === "active" ? `${(0, import_node_util3.styleText)("cyan", S_CHECKBOX_ACTIVE)} ${r2}${t2.hint ? ` ${(0, import_node_util3.styleText)("dim", `(${t2.hint})`)}` : ""}` : a2 === "selected" ? `${(0, import_node_util3.styleText)("green", S_CHECKBOX_SELECTED)} ${m2(r2, (o2) => (0, import_node_util3.styleText)("dim", o2))}${t2.hint ? ` ${(0, import_node_util3.styleText)("dim", `(${t2.hint})`)}` : ""}` : a2 === "cancelled" ? `${m2(r2, (o2) => (0, import_node_util3.styleText)(["strikethrough", "dim"], o2))}` : a2 === "active-selected" ? `${(0, import_node_util3.styleText)("green", S_CHECKBOX_SELECTED)} ${r2}${t2.hint ? ` ${(0, import_node_util3.styleText)("dim", `(${t2.hint})`)}` : ""}` : a2 === "submitted" ? `${m2(r2, (o2) => (0, import_node_util3.styleText)("dim", o2))}` : `${(0, import_node_util3.styleText)("dim", S_CHECKBOX_INACTIVE)} ${m2(r2, (o2) => (0, import_node_util3.styleText)("dim", o2))}`;
       }, d = i2.required ?? true, v = i2.showInstructions ?? true;
       return new a({
         options: i2.options,
@@ -138695,13 +140459,13 @@ ${s}
         validate(t2) {
           if (d && (t2 === void 0 || t2.length === 0))
             return `Please select at least one option.
-${(0, import_node_util2.styleText)(
+${(0, import_node_util3.styleText)(
               "reset",
-              (0, import_node_util2.styleText)(
+              (0, import_node_util3.styleText)(
                 "dim",
-                `Press ${(0, import_node_util2.styleText)(["gray", "bgWhite", "inverse"], " space ")} to select, ${(0, import_node_util2.styleText)(
+                `Press ${(0, import_node_util3.styleText)(["gray", "bgWhite", "inverse"], " space ")} to select, ${(0, import_node_util3.styleText)(
                   "gray",
-                  (0, import_node_util2.styleText)("bgWhite", (0, import_node_util2.styleText)("inverse", " enter "))
+                  (0, import_node_util3.styleText)("bgWhite", (0, import_node_util3.styleText)("inverse", " enter "))
                 )} to submit`
               )
             )}`;
@@ -138712,7 +140476,7 @@ ${(0, import_node_util2.styleText)(
             i2.message,
             t2 ? `${symbolBar(this.state)}  ` : "",
             `${symbol2(this.state)}  `
-          ), r2 = `${t2 ? `${(0, import_node_util2.styleText)("gray", S_BAR)}
+          ), r2 = `${t2 ? `${(0, import_node_util3.styleText)("gray", S_BAR)}
 ` : ""}${a2}
 `, o2 = this.value ?? [], p3 = (n3, l3) => {
             if (n3.disabled)
@@ -138722,29 +140486,29 @@ ${(0, import_node_util2.styleText)(
           };
           switch (this.state) {
             case "submit": {
-              const n3 = this.options.filter(({ value: s }) => o2.includes(s)).map((s) => u6(s, "submitted")).join((0, import_node_util2.styleText)("dim", ", ")) || (0, import_node_util2.styleText)("dim", "none"), l3 = wrapTextWithPrefix(
+              const n3 = this.options.filter(({ value: s }) => o2.includes(s)).map((s) => u6(s, "submitted")).join((0, import_node_util3.styleText)("dim", ", ")) || (0, import_node_util3.styleText)("dim", "none"), l3 = wrapTextWithPrefix(
                 i2.output,
                 n3,
-                t2 ? `${(0, import_node_util2.styleText)("gray", S_BAR)}  ` : ""
+                t2 ? `${(0, import_node_util3.styleText)("gray", S_BAR)}  ` : ""
               );
               return `${r2}${l3}`;
             }
             case "cancel": {
-              const n3 = this.options.filter(({ value: s }) => o2.includes(s)).map((s) => u6(s, "cancelled")).join((0, import_node_util2.styleText)("dim", ", "));
+              const n3 = this.options.filter(({ value: s }) => o2.includes(s)).map((s) => u6(s, "cancelled")).join((0, import_node_util3.styleText)("dim", ", "));
               if (n3.trim() === "")
-                return `${r2}${(0, import_node_util2.styleText)("gray", S_BAR)}`;
+                return `${r2}${(0, import_node_util3.styleText)("gray", S_BAR)}`;
               const l3 = wrapTextWithPrefix(
                 i2.output,
                 n3,
-                t2 ? `${(0, import_node_util2.styleText)("gray", S_BAR)}  ` : ""
+                t2 ? `${(0, import_node_util3.styleText)("gray", S_BAR)}  ` : ""
               );
               return `${r2}${l3}${t2 ? `
-${(0, import_node_util2.styleText)("gray", S_BAR)}` : ""}`;
+${(0, import_node_util3.styleText)("gray", S_BAR)}` : ""}`;
             }
             case "error": {
-              const n3 = t2 ? `${(0, import_node_util2.styleText)("yellow", S_BAR)}  ` : "", l3 = this.error.split(`
+              const n3 = t2 ? `${(0, import_node_util3.styleText)("yellow", S_BAR)}  ` : "", l3 = this.error.split(`
 `).map(
-                ($2, C4) => C4 === 0 ? `${t2 ? `${(0, import_node_util2.styleText)("yellow", S_BAR_END)}  ` : ""}${(0, import_node_util2.styleText)("yellow", $2)}` : `   ${$2}`
+                ($2, C4) => C4 === 0 ? `${t2 ? `${(0, import_node_util3.styleText)("yellow", S_BAR_END)}  ` : ""}${(0, import_node_util3.styleText)("yellow", $2)}` : `   ${$2}`
               ).join(`
 `), s = r2.split(`
 `).length, h2 = l3.split(`
@@ -138763,8 +140527,8 @@ ${l3}
 `;
             }
             default: {
-              const n3 = t2 ? `${(0, import_node_util2.styleText)("cyan", S_BAR)}  ` : "", l3 = r2.split(`
-`).length, s = v ? formatInstructionFooter(MULTISELECT_INSTRUCTIONS, t2) : t2 ? [(0, import_node_util2.styleText)("cyan", S_BAR_END)] : [], h2 = s.join(`
+              const n3 = t2 ? `${(0, import_node_util3.styleText)("cyan", S_BAR)}  ` : "", l3 = r2.split(`
+`).length, s = v ? formatInstructionFooter(MULTISELECT_INSTRUCTIONS, t2) : t2 ? [(0, import_node_util3.styleText)("cyan", S_BAR_END)] : [], h2 = s.join(`
 `), $2 = s.length + 1;
               return `${r2}${n3}${limitOptions({
                 output: i2.output,
@@ -138793,60 +140557,60 @@ ${h2}
 `.repeat(x2)), l3 === "active")
           return wrapTextWithPrefix(
             o2.output,
-            `${a2}${n3.hint ? ` ${(0, import_node_util2.styleText)("dim", `(${n3.hint})`)}` : ""}`,
-            `${i2}${(0, import_node_util2.styleText)("dim", r2)} `,
-            `${i2}${(0, import_node_util2.styleText)("dim", r2)}${(0, import_node_util2.styleText)("cyan", S_CHECKBOX_ACTIVE)} `,
-            `${i2}${(0, import_node_util2.styleText)("dim", c3)} `
+            `${a2}${n3.hint ? ` ${(0, import_node_util3.styleText)("dim", `(${n3.hint})`)}` : ""}`,
+            `${i2}${(0, import_node_util3.styleText)("dim", r2)} `,
+            `${i2}${(0, import_node_util3.styleText)("dim", r2)}${(0, import_node_util3.styleText)("cyan", S_CHECKBOX_ACTIVE)} `,
+            `${i2}${(0, import_node_util3.styleText)("dim", c3)} `
           );
         if (l3 === "group-active")
           return wrapTextWithPrefix(
             o2.output,
             a2,
             `${i2}${r2} `,
-            `${i2}${r2}${(0, import_node_util2.styleText)("cyan", S_CHECKBOX_ACTIVE)} `,
+            `${i2}${r2}${(0, import_node_util3.styleText)("cyan", S_CHECKBOX_ACTIVE)} `,
             `${i2}${c3} `,
-            (d) => (0, import_node_util2.styleText)("dim", d)
+            (d) => (0, import_node_util3.styleText)("dim", d)
           );
         if (l3 === "group-active-selected")
           return wrapTextWithPrefix(
             o2.output,
             a2,
             `${i2}${r2} `,
-            `${i2}${r2}${(0, import_node_util2.styleText)("green", S_CHECKBOX_SELECTED)} `,
+            `${i2}${r2}${(0, import_node_util3.styleText)("green", S_CHECKBOX_SELECTED)} `,
             `${i2}${c3} `,
-            (d) => (0, import_node_util2.styleText)("dim", d)
+            (d) => (0, import_node_util3.styleText)("dim", d)
           );
         if (l3 === "selected") {
-          const d = t2 || h2 ? (0, import_node_util2.styleText)("green", S_CHECKBOX_SELECTED) : "";
+          const d = t2 || h2 ? (0, import_node_util3.styleText)("green", S_CHECKBOX_SELECTED) : "";
           return wrapTextWithPrefix(
             o2.output,
             `${a2}${n3.hint ? ` (${n3.hint})` : ""}`,
-            `${i2}${(0, import_node_util2.styleText)("dim", r2)} `,
-            `${i2}${(0, import_node_util2.styleText)("dim", r2)}${d} `,
-            `${i2}${(0, import_node_util2.styleText)("dim", c3)} `,
-            (S2) => (0, import_node_util2.styleText)("dim", S2)
+            `${i2}${(0, import_node_util3.styleText)("dim", r2)} `,
+            `${i2}${(0, import_node_util3.styleText)("dim", r2)}${d} `,
+            `${i2}${(0, import_node_util3.styleText)("dim", c3)} `,
+            (S2) => (0, import_node_util3.styleText)("dim", S2)
           );
         }
         if (l3 === "cancelled")
-          return `${(0, import_node_util2.styleText)(["strikethrough", "dim"], a2)}`;
+          return `${(0, import_node_util3.styleText)(["strikethrough", "dim"], a2)}`;
         if (l3 === "active-selected")
           return wrapTextWithPrefix(
             o2.output,
-            `${a2}${n3.hint ? ` ${(0, import_node_util2.styleText)("dim", `(${n3.hint})`)}` : ""}`,
-            `${i2}${(0, import_node_util2.styleText)("dim", r2)} `,
-            `${i2}${(0, import_node_util2.styleText)("dim", r2)}${(0, import_node_util2.styleText)("green", S_CHECKBOX_SELECTED)} `,
-            `${i2}${(0, import_node_util2.styleText)("dim", c3)} `
+            `${a2}${n3.hint ? ` ${(0, import_node_util3.styleText)("dim", `(${n3.hint})`)}` : ""}`,
+            `${i2}${(0, import_node_util3.styleText)("dim", r2)} `,
+            `${i2}${(0, import_node_util3.styleText)("dim", r2)}${(0, import_node_util3.styleText)("green", S_CHECKBOX_SELECTED)} `,
+            `${i2}${(0, import_node_util3.styleText)("dim", c3)} `
           );
         if (l3 === "submitted")
-          return `${(0, import_node_util2.styleText)("dim", a2)}`;
-        const f2 = t2 || h2 ? (0, import_node_util2.styleText)("dim", S_CHECKBOX_INACTIVE) : "";
+          return `${(0, import_node_util3.styleText)("dim", a2)}`;
+        const f2 = t2 || h2 ? (0, import_node_util3.styleText)("dim", S_CHECKBOX_INACTIVE) : "";
         return wrapTextWithPrefix(
           o2.output,
           a2,
-          `${i2}${(0, import_node_util2.styleText)("dim", r2)} `,
-          `${i2}${(0, import_node_util2.styleText)("dim", r2)}${f2} `,
-          `${i2}${(0, import_node_util2.styleText)("dim", c3)} `,
-          (d) => (0, import_node_util2.styleText)("dim", d)
+          `${i2}${(0, import_node_util3.styleText)("dim", r2)} `,
+          `${i2}${(0, import_node_util3.styleText)("dim", r2)}${f2} `,
+          `${i2}${(0, import_node_util3.styleText)("dim", c3)} `,
+          (d) => (0, import_node_util3.styleText)("dim", d)
         );
       }, y2 = o2.required ?? true, I3 = o2.showInstructions ?? true;
       return new u$2({
@@ -138861,19 +140625,19 @@ ${h2}
         validate(n3) {
           if (y2 && (n3 === void 0 || n3.length === 0))
             return `Please select at least one option.
-${(0, import_node_util2.styleText)(
+${(0, import_node_util3.styleText)(
               "reset",
-              (0, import_node_util2.styleText)(
+              (0, import_node_util3.styleText)(
                 "dim",
-                `Press ${(0, import_node_util2.styleText)(["gray", "bgWhite", "inverse"], " space ")} to select, ${(0, import_node_util2.styleText)(
+                `Press ${(0, import_node_util3.styleText)(["gray", "bgWhite", "inverse"], " space ")} to select, ${(0, import_node_util3.styleText)(
                   "gray",
-                  (0, import_node_util2.styleText)(["bgWhite", "inverse"], " enter ")
+                  (0, import_node_util3.styleText)(["bgWhite", "inverse"], " enter ")
                 )} to submit`
               )
             )}`;
         },
         render() {
-          const n3 = o2.withGuide ?? settings.withGuide, l3 = `${n3 ? `${(0, import_node_util2.styleText)("gray", S_BAR)}
+          const n3 = o2.withGuide ?? settings.withGuide, l3 = `${n3 ? `${(0, import_node_util3.styleText)("gray", S_BAR)}
 ` : ""}${symbol2(this.state)}  ${o2.message}
 `, g2 = this.value ?? [], a2 = (t2, s) => {
             const u6 = this.options, r2 = g2.includes(t2.value) || t2.group === true && this.isGroupSelected(`${t2.value}`);
@@ -138881,18 +140645,18 @@ ${(0, import_node_util2.styleText)(
           };
           switch (this.state) {
             case "submit": {
-              const t2 = this.options.filter(({ value: u6 }) => g2.includes(u6)).map((u6) => m3(u6, "submitted")), s = t2.length === 0 ? "" : `  ${t2.join((0, import_node_util2.styleText)("dim", ", "))}`;
-              return `${l3}${n3 ? (0, import_node_util2.styleText)("gray", S_BAR) : ""}${s}`;
+              const t2 = this.options.filter(({ value: u6 }) => g2.includes(u6)).map((u6) => m3(u6, "submitted")), s = t2.length === 0 ? "" : `  ${t2.join((0, import_node_util3.styleText)("dim", ", "))}`;
+              return `${l3}${n3 ? (0, import_node_util3.styleText)("gray", S_BAR) : ""}${s}`;
             }
             case "cancel": {
-              const t2 = this.options.filter(({ value: s }) => g2.includes(s)).map((s) => m3(s, "cancelled")).join((0, import_node_util2.styleText)("dim", ", "));
-              return `${l3}${n3 ? `${(0, import_node_util2.styleText)("gray", S_BAR)}  ` : ""}${t2.trim() ? `${t2}${n3 ? `
-${(0, import_node_util2.styleText)("gray", S_BAR)}` : ""}` : ""}`;
+              const t2 = this.options.filter(({ value: s }) => g2.includes(s)).map((s) => m3(s, "cancelled")).join((0, import_node_util3.styleText)("dim", ", "));
+              return `${l3}${n3 ? `${(0, import_node_util3.styleText)("gray", S_BAR)}  ` : ""}${t2.trim() ? `${t2}${n3 ? `
+${(0, import_node_util3.styleText)("gray", S_BAR)}` : ""}` : ""}`;
             }
             case "error": {
-              const t2 = n3 ? `${(0, import_node_util2.styleText)("yellow", S_BAR)}  ` : "", s = this.error.split(`
+              const t2 = n3 ? `${(0, import_node_util3.styleText)("yellow", S_BAR)}  ` : "", s = this.error.split(`
 `).map(
-                (i2, f2) => f2 === 0 ? `${n3 ? `${(0, import_node_util2.styleText)("yellow", S_BAR_END)}  ` : ""}${(0, import_node_util2.styleText)("yellow", i2)}` : `   ${i2}`
+                (i2, f2) => f2 === 0 ? `${n3 ? `${(0, import_node_util3.styleText)("yellow", S_BAR_END)}  ` : ""}${(0, import_node_util3.styleText)("yellow", i2)}` : `   ${i2}`
               ).join(`
 `), u6 = l3.split(`
 `).length, r2 = s.split(`
@@ -138911,8 +140675,8 @@ ${s}
 `;
             }
             default: {
-              const t2 = n3 ? `${(0, import_node_util2.styleText)("cyan", S_BAR)}  ` : "", s = l3.split(`
-`).length, u6 = I3 ? formatInstructionFooter(MULTISELECT_INSTRUCTIONS, n3) : n3 ? [(0, import_node_util2.styleText)("cyan", S_BAR_END)] : [], r2 = u6.join(`
+              const t2 = n3 ? `${(0, import_node_util3.styleText)("cyan", S_BAR)}  ` : "", s = l3.split(`
+`).length, u6 = I3 ? formatInstructionFooter(MULTISELECT_INSTRUCTIONS, n3) : n3 ? [(0, import_node_util3.styleText)("cyan", S_BAR_END)] : [], r2 = u6.join(`
 `), c3 = u6.length + 1, i2 = limitOptions({
                 output: o2.output,
                 options: this.options,
@@ -138933,8 +140697,8 @@ ${r2}
     };
     log = {
       message: (s = [], {
-        symbol: e = (0, import_node_util2.styleText)("gray", S_BAR),
-        secondarySymbol: r2 = (0, import_node_util2.styleText)("gray", S_BAR),
+        symbol: e = (0, import_node_util3.styleText)("gray", S_BAR),
+        secondarySymbol: r2 = (0, import_node_util3.styleText)("gray", S_BAR),
         output: m3 = process.stdout,
         spacing: l3 = 1,
         withGuide: c3
@@ -138955,39 +140719,39 @@ ${r2}
 `);
       },
       info: (s, e) => {
-        log.message(s, { ...e, symbol: (0, import_node_util2.styleText)("blue", S_INFO) });
+        log.message(s, { ...e, symbol: (0, import_node_util3.styleText)("blue", S_INFO) });
       },
       success: (s, e) => {
-        log.message(s, { ...e, symbol: (0, import_node_util2.styleText)("green", S_SUCCESS) });
+        log.message(s, { ...e, symbol: (0, import_node_util3.styleText)("green", S_SUCCESS) });
       },
       step: (s, e) => {
-        log.message(s, { ...e, symbol: (0, import_node_util2.styleText)("green", S_STEP_SUBMIT) });
+        log.message(s, { ...e, symbol: (0, import_node_util3.styleText)("green", S_STEP_SUBMIT) });
       },
       warn: (s, e) => {
-        log.message(s, { ...e, symbol: (0, import_node_util2.styleText)("yellow", S_WARN) });
+        log.message(s, { ...e, symbol: (0, import_node_util3.styleText)("yellow", S_WARN) });
       },
       /** alias for `log.warn()`. */
       warning: (s, e) => {
         log.warn(s, e);
       },
       error: (s, e) => {
-        log.message(s, { ...e, symbol: (0, import_node_util2.styleText)("red", S_ERROR) });
+        log.message(s, { ...e, symbol: (0, import_node_util3.styleText)("red", S_ERROR) });
       }
     };
     cancel = (o2 = "", t2) => {
-      const i2 = t2?.output ?? process.stdout, e = t2?.withGuide ?? settings.withGuide ? `${(0, import_node_util2.styleText)("gray", S_BAR_END)}  ` : "";
-      i2.write(`${e}${(0, import_node_util2.styleText)("red", o2)}
+      const i2 = t2?.output ?? process.stdout, e = t2?.withGuide ?? settings.withGuide ? `${(0, import_node_util3.styleText)("gray", S_BAR_END)}  ` : "";
+      i2.write(`${e}${(0, import_node_util3.styleText)("red", o2)}
 
 `);
     };
     intro = (o2 = "", t2) => {
-      const i2 = t2?.output ?? process.stdout, e = t2?.withGuide ?? settings.withGuide ? `${(0, import_node_util2.styleText)("gray", S_BAR_START)}  ` : "";
+      const i2 = t2?.output ?? process.stdout, e = t2?.withGuide ?? settings.withGuide ? `${(0, import_node_util3.styleText)("gray", S_BAR_START)}  ` : "";
       i2.write(`${e}${o2}
 `);
     };
     outro = (o2 = "", t2) => {
-      const i2 = t2?.output ?? process.stdout, e = t2?.withGuide ?? settings.withGuide ? `${(0, import_node_util2.styleText)("gray", S_BAR)}
-${(0, import_node_util2.styleText)("gray", S_BAR_END)}  ` : "";
+      const i2 = t2?.output ?? process.stdout, e = t2?.withGuide ?? settings.withGuide ? `${(0, import_node_util3.styleText)("gray", S_BAR)}
+${(0, import_node_util3.styleText)("gray", S_BAR_END)}  ` : "";
       i2.write(`${e}${o2}
 
 `);
@@ -139002,44 +140766,44 @@ ${(0, import_node_util2.styleText)("gray", S_BAR_END)}  ` : "";
       signal: e.signal,
       input: e.input,
       render() {
-        const i2 = e?.withGuide ?? settings.withGuide, o2 = `${`${i2 ? `${(0, import_node_util2.styleText)("gray", S_BAR)}
+        const i2 = e?.withGuide ?? settings.withGuide, o2 = `${`${i2 ? `${(0, import_node_util3.styleText)("gray", S_BAR)}
 ` : ""}${symbol2(this.state)}  `}${e.message}
 `, m3 = e.placeholder && e.placeholder.length > 0 ? (
           // biome-ignore lint/style/noNonNullAssertion: guarded by placeholder.length > 0
-          (0, import_node_util2.styleText)("inverse", e.placeholder[0]) + (0, import_node_util2.styleText)("dim", e.placeholder.slice(1))
-        ) : (0, import_node_util2.styleText)(["inverse", "hidden"], "_"), a2 = this.userInput ? this.userInputWithCursor : m3, l3 = this.value ?? "", c3 = e.showSubmit ? `
-  ${(0, import_node_util2.styleText)(this.focused === "submit" ? "cyan" : "dim", "[ submit ]")}` : "";
+          (0, import_node_util3.styleText)("inverse", e.placeholder[0]) + (0, import_node_util3.styleText)("dim", e.placeholder.slice(1))
+        ) : (0, import_node_util3.styleText)(["inverse", "hidden"], "_"), a2 = this.userInput ? this.userInputWithCursor : m3, l3 = this.value ?? "", c3 = e.showSubmit ? `
+  ${(0, import_node_util3.styleText)(this.focused === "submit" ? "cyan" : "dim", "[ submit ]")}` : "";
         switch (this.state) {
           case "error": {
-            const n3 = `${(0, import_node_util2.styleText)("yellow", S_BAR)}  `, r2 = i2 ? wrapTextWithPrefix(e.output, a2, n3, void 0) : a2, u6 = (0, import_node_util2.styleText)("yellow", S_BAR_END);
+            const n3 = `${(0, import_node_util3.styleText)("yellow", S_BAR)}  `, r2 = i2 ? wrapTextWithPrefix(e.output, a2, n3, void 0) : a2, u6 = (0, import_node_util3.styleText)("yellow", S_BAR_END);
             return `${o2}${r2}
-${u6}  ${(0, import_node_util2.styleText)("yellow", this.error)}${c3}
+${u6}  ${(0, import_node_util3.styleText)("yellow", this.error)}${c3}
 `;
           }
           case "submit": {
-            const n3 = `${(0, import_node_util2.styleText)("gray", S_BAR)}  `, r2 = i2 ? wrapTextWithPrefix(
+            const n3 = `${(0, import_node_util3.styleText)("gray", S_BAR)}  `, r2 = i2 ? wrapTextWithPrefix(
               e.output,
               l3,
               n3,
               void 0,
               void 0,
-              (u6) => (0, import_node_util2.styleText)("dim", u6)
-            ) : l3 ? (0, import_node_util2.styleText)("dim", l3) : "";
+              (u6) => (0, import_node_util3.styleText)("dim", u6)
+            ) : l3 ? (0, import_node_util3.styleText)("dim", l3) : "";
             return `${o2}${r2}`;
           }
           case "cancel": {
-            const n3 = `${(0, import_node_util2.styleText)("gray", S_BAR)}  `, r2 = i2 ? wrapTextWithPrefix(
+            const n3 = `${(0, import_node_util3.styleText)("gray", S_BAR)}  `, r2 = i2 ? wrapTextWithPrefix(
               e.output,
               l3,
               n3,
               void 0,
               void 0,
-              (u6) => (0, import_node_util2.styleText)(["strikethrough", "dim"], u6)
-            ) : l3 ? (0, import_node_util2.styleText)(["strikethrough", "dim"], l3) : "";
+              (u6) => (0, import_node_util3.styleText)(["strikethrough", "dim"], u6)
+            ) : l3 ? (0, import_node_util3.styleText)(["strikethrough", "dim"], l3) : "";
             return `${o2}${r2}`;
           }
           default: {
-            const n3 = i2 ? `${(0, import_node_util2.styleText)("cyan", S_BAR)}  ` : "", r2 = i2 ? (0, import_node_util2.styleText)("cyan", S_BAR_END) : "", u6 = i2 ? wrapTextWithPrefix(e.output, a2, n3) : a2;
+            const n3 = i2 ? `${(0, import_node_util3.styleText)("cyan", S_BAR)}  ` : "", r2 = i2 ? (0, import_node_util3.styleText)("cyan", S_BAR_END) : "", u6 = i2 ? wrapTextWithPrefix(e.output, a2, n3) : a2;
             return `${o2}${u6}
 ${r2}${c3}
 `;
@@ -139065,17 +140829,17 @@ ${r2}${c3}
         }, 0),
         n3
       ) + 2, h2 = g2.map(
-        (m3) => `${(0, import_node_util2.styleText)("gray", S_BAR)}  ${m3}${" ".repeat(t2 - dist_default2(m3))}${(0, import_node_util2.styleText)("gray", S_BAR)}`
+        (m3) => `${(0, import_node_util3.styleText)("gray", S_BAR)}  ${m3}${" ".repeat(t2 - dist_default2(m3))}${(0, import_node_util3.styleText)("gray", S_BAR)}`
       ).join(`
-`), T4 = i2 ? `${(0, import_node_util2.styleText)("gray", S_BAR)}
+`), T4 = i2 ? `${(0, import_node_util3.styleText)("gray", S_BAR)}
 ` : "", l$1 = i2 ? S_CONNECT_LEFT : S_CORNER_BOTTOM_LEFT;
       a2.write(
-        `${T4}${(0, import_node_util2.styleText)("green", S_STEP_SUBMIT)}  ${(0, import_node_util2.styleText)("reset", e)} ${(0, import_node_util2.styleText)(
+        `${T4}${(0, import_node_util3.styleText)("green", S_STEP_SUBMIT)}  ${(0, import_node_util3.styleText)("reset", e)} ${(0, import_node_util3.styleText)(
           "gray",
           S_BAR_H.repeat(Math.max(t2 - n3 - 1, 1)) + S_CORNER_TOP_RIGHT
         )}
 ${h2}
-${(0, import_node_util2.styleText)("gray", l$1 + S_BAR_H.repeat(t2 + 2) + S_CORNER_BOTTOM_RIGHT)}
+${(0, import_node_util3.styleText)("gray", l$1 + S_BAR_H.repeat(t2 + 2) + S_CORNER_BOTTOM_RIGHT)}
 `
       );
     };
@@ -139086,28 +140850,28 @@ ${(0, import_node_util2.styleText)("gray", l$1 + S_BAR_H.repeat(t2 + 2) + S_CORN
       input: r2.input,
       output: r2.output,
       render() {
-        const e = r2.withGuide ?? settings.withGuide, o2 = `${e ? `${(0, import_node_util2.styleText)("gray", S_BAR)}
+        const e = r2.withGuide ?? settings.withGuide, o2 = `${e ? `${(0, import_node_util3.styleText)("gray", S_BAR)}
 ` : ""}${symbol2(this.state)}  ${r2.message}
 `, c3 = this.userInputWithCursor, i2 = this.masked;
         switch (this.state) {
           case "error": {
-            const s = e ? `${(0, import_node_util2.styleText)("yellow", S_BAR)}  ` : "", n3 = e ? `${(0, import_node_util2.styleText)("yellow", S_BAR_END)}  ` : "", l3 = i2 ?? "";
+            const s = e ? `${(0, import_node_util3.styleText)("yellow", S_BAR)}  ` : "", n3 = e ? `${(0, import_node_util3.styleText)("yellow", S_BAR_END)}  ` : "", l3 = i2 ?? "";
             return r2.clearOnError && this.clear(), `${o2.trim()}
 ${s}${l3}
-${n3}${(0, import_node_util2.styleText)("yellow", this.error)}
+${n3}${(0, import_node_util3.styleText)("yellow", this.error)}
 `;
           }
           case "submit": {
-            const s = e ? `${(0, import_node_util2.styleText)("gray", S_BAR)}  ` : "", n3 = i2 ? (0, import_node_util2.styleText)("dim", i2) : "";
+            const s = e ? `${(0, import_node_util3.styleText)("gray", S_BAR)}  ` : "", n3 = i2 ? (0, import_node_util3.styleText)("dim", i2) : "";
             return `${o2}${s}${n3}`;
           }
           case "cancel": {
-            const s = e ? `${(0, import_node_util2.styleText)("gray", S_BAR)}  ` : "", n3 = i2 ? (0, import_node_util2.styleText)(["strikethrough", "dim"], i2) : "";
+            const s = e ? `${(0, import_node_util3.styleText)("gray", S_BAR)}  ` : "", n3 = i2 ? (0, import_node_util3.styleText)(["strikethrough", "dim"], i2) : "";
             return `${o2}${s}${n3}${i2 && e ? `
-${(0, import_node_util2.styleText)("gray", S_BAR)}` : ""}`;
+${(0, import_node_util3.styleText)("gray", S_BAR)}` : ""}`;
           }
           default: {
-            const s = e ? `${(0, import_node_util2.styleText)("cyan", S_BAR)}  ` : "", n3 = e ? (0, import_node_util2.styleText)("cyan", S_BAR_END) : "";
+            const s = e ? `${(0, import_node_util3.styleText)("cyan", S_BAR)}  ` : "", n3 = e ? (0, import_node_util3.styleText)("cyan", S_BAR_END) : "";
             return `${o2}${s}${c3}
 ${n3}
 `;
@@ -139155,7 +140919,7 @@ ${n3}
         }
       });
     };
-    W = (l3) => (0, import_node_util2.styleText)("magenta", l3);
+    W = (l3) => (0, import_node_util3.styleText)("magenta", l3);
     spinner = ({
       indicator: l3 = "dots",
       onCancel: h2,
@@ -139190,7 +140954,7 @@ ${n3}
         const r2 = (performance.now() - e) / 1e3, t2 = Math.floor(r2 / 60), o2 = Math.floor(r2 % 60);
         return t2 > 0 ? `[${t2}m ${o2}s]` : `[${o2}s]`;
       }, N2 = I3.withGuide ?? settings.withGuide, P4 = (e = "") => {
-        d = true, M3 = block2({ output: n3 }), s = C4(e), w2 = performance.now(), N2 && n3.write(`${(0, import_node_util2.styleText)("gray", S_BAR)}
+        d = true, M3 = block2({ output: n3 }), s = C4(e), w2 = performance.now(), N2 && n3.write(`${(0, import_node_util3.styleText)("gray", S_BAR)}
 `);
         let r2 = 0, t2 = 0;
         A2(), T4 = setInterval(() => {
@@ -139216,7 +140980,7 @@ ${n3}
       }, a2 = (e = "", r2 = 0, t2 = false) => {
         if (!d) return;
         d = false, clearInterval(T4), y2();
-        const o2 = r2 === 0 ? (0, import_node_util2.styleText)("green", S_STEP_SUBMIT) : r2 === 1 ? (0, import_node_util2.styleText)("red", S_STEP_CANCEL) : (0, import_node_util2.styleText)("red", S_STEP_ERROR);
+        const o2 = r2 === 0 ? (0, import_node_util3.styleText)("green", S_STEP_SUBMIT) : r2 === 1 ? (0, import_node_util3.styleText)("red", S_STEP_CANCEL) : (0, import_node_util3.styleText)("red", S_STEP_ERROR);
         s = e ?? s, t2 || (l3 === "timer" ? n3.write(`${o2}  ${s} ${_2(w2)}
 `) : n3.write(`${o2}  ${s}
 `)), H2(), M3();
@@ -139241,8 +141005,8 @@ ${n3}
       block: unicodeOr("\u2588", "#")
     };
     SELECT_INSTRUCTIONS = [
-      `${(0, import_node_util2.styleText)("dim", "\u2191/\u2193")} to navigate`,
-      `${(0, import_node_util2.styleText)("dim", "Enter:")} confirm`
+      `${(0, import_node_util3.styleText)("dim", "\u2191/\u2193")} to navigate`,
+      `${(0, import_node_util3.styleText)("dim", "Enter:")} confirm`
     ];
     c2 = (t2, o2) => t2.includes(`
 `) ? t2.split(`
@@ -139255,15 +141019,15 @@ ${n3}
         const s = n3.label ?? String(n3.value);
         switch (m3) {
           case "disabled":
-            return `${(0, import_node_util2.styleText)("gray", S_RADIO_INACTIVE)} ${c2(s, (i2) => (0, import_node_util2.styleText)("gray", i2))}${n3.hint ? ` ${(0, import_node_util2.styleText)("dim", `(${n3.hint ?? "disabled"})`)}` : ""}`;
+            return `${(0, import_node_util3.styleText)("gray", S_RADIO_INACTIVE)} ${c2(s, (i2) => (0, import_node_util3.styleText)("gray", i2))}${n3.hint ? ` ${(0, import_node_util3.styleText)("dim", `(${n3.hint ?? "disabled"})`)}` : ""}`;
           case "selected":
-            return `${c2(s, (i2) => (0, import_node_util2.styleText)("dim", i2))}`;
+            return `${c2(s, (i2) => (0, import_node_util3.styleText)("dim", i2))}`;
           case "active":
-            return `${(0, import_node_util2.styleText)("green", S_RADIO_ACTIVE)} ${s}${n3.hint ? ` ${(0, import_node_util2.styleText)("dim", `(${n3.hint})`)}` : ""}`;
+            return `${(0, import_node_util3.styleText)("green", S_RADIO_ACTIVE)} ${s}${n3.hint ? ` ${(0, import_node_util3.styleText)("dim", `(${n3.hint})`)}` : ""}`;
           case "cancelled":
-            return `${c2(s, (i2) => (0, import_node_util2.styleText)(["strikethrough", "dim"], i2))}`;
+            return `${c2(s, (i2) => (0, import_node_util3.styleText)(["strikethrough", "dim"], i2))}`;
           default:
-            return `${(0, import_node_util2.styleText)("dim", S_RADIO_INACTIVE)} ${c2(s, (i2) => (0, import_node_util2.styleText)("dim", i2))}`;
+            return `${(0, import_node_util3.styleText)("dim", S_RADIO_INACTIVE)} ${c2(s, (i2) => (0, import_node_util3.styleText)("dim", i2))}`;
         }
       }, d = t2.showInstructions ?? true;
       return new n$1({
@@ -139278,12 +141042,12 @@ ${n3}
             t2.message,
             s,
             m3
-          ), u6 = `${n3 ? `${(0, import_node_util2.styleText)("gray", S_BAR)}
+          ), u6 = `${n3 ? `${(0, import_node_util3.styleText)("gray", S_BAR)}
 ` : ""}${i2}
 `;
           switch (this.state) {
             case "submit": {
-              const r2 = n3 ? `${(0, import_node_util2.styleText)("gray", S_BAR)}  ` : "", a2 = wrapTextWithPrefix(
+              const r2 = n3 ? `${(0, import_node_util3.styleText)("gray", S_BAR)}  ` : "", a2 = wrapTextWithPrefix(
                 t2.output,
                 o2(this.options[this.cursor], "selected"),
                 r2
@@ -139291,17 +141055,17 @@ ${n3}
               return `${u6}${a2}`;
             }
             case "cancel": {
-              const r2 = n3 ? `${(0, import_node_util2.styleText)("gray", S_BAR)}  ` : "", a2 = wrapTextWithPrefix(
+              const r2 = n3 ? `${(0, import_node_util3.styleText)("gray", S_BAR)}  ` : "", a2 = wrapTextWithPrefix(
                 t2.output,
                 o2(this.options[this.cursor], "cancelled"),
                 r2
               );
               return `${u6}${a2}${n3 ? `
-${(0, import_node_util2.styleText)("gray", S_BAR)}` : ""}`;
+${(0, import_node_util3.styleText)("gray", S_BAR)}` : ""}`;
             }
             default: {
-              const r2 = n3 ? `${(0, import_node_util2.styleText)("cyan", S_BAR)}  ` : "", a2 = u6.split(`
-`).length, p3 = d ? formatInstructionFooter(SELECT_INSTRUCTIONS, n3) : n3 ? [(0, import_node_util2.styleText)("cyan", S_BAR_END)] : [], b3 = p3.join(`
+              const r2 = n3 ? `${(0, import_node_util3.styleText)("cyan", S_BAR)}  ` : "", a2 = u6.split(`
+`).length, p3 = d ? formatInstructionFooter(SELECT_INSTRUCTIONS, n3) : n3 ? [(0, import_node_util3.styleText)("cyan", S_BAR_END)] : [], b3 = p3.join(`
 `), f2 = p3.length + 1;
               return `${u6}${r2}${limitOptions({
                 output: t2.output,
@@ -139325,7 +141089,7 @@ ${b3}
         if (e === void 0)
           return "";
         const n3 = e.label ?? String(e.value);
-        return a2 === "selected" ? `${(0, import_node_util2.styleText)("dim", n3)}` : a2 === "cancelled" ? `${(0, import_node_util2.styleText)(["strikethrough", "dim"], n3)}` : a2 === "active" ? `${(0, import_node_util2.styleText)(["bgCyan", "gray"], ` ${e.value} `)} ${n3}${e.hint ? ` ${(0, import_node_util2.styleText)("dim", `(${e.hint})`)}` : ""}` : `${(0, import_node_util2.styleText)(["gray", "bgWhite", "inverse"], ` ${e.value} `)} ${n3}${e.hint ? ` ${(0, import_node_util2.styleText)("dim", `(${e.hint})`)}` : ""}`;
+        return a2 === "selected" ? `${(0, import_node_util3.styleText)("dim", n3)}` : a2 === "cancelled" ? `${(0, import_node_util3.styleText)(["strikethrough", "dim"], n3)}` : a2 === "active" ? `${(0, import_node_util3.styleText)(["bgCyan", "gray"], ` ${e.value} `)} ${n3}${e.hint ? ` ${(0, import_node_util3.styleText)("dim", `(${e.hint})`)}` : ""}` : `${(0, import_node_util3.styleText)(["gray", "bgWhite", "inverse"], ` ${e.value} `)} ${n3}${e.hint ? ` ${(0, import_node_util3.styleText)("dim", `(${e.hint})`)}` : ""}`;
       };
       return new u4({
         options: t2.options,
@@ -139335,12 +141099,12 @@ ${b3}
         initialValue: t2.initialValue,
         caseSensitive: t2.caseSensitive,
         render() {
-          const e = t2.withGuide ?? settings.withGuide, a2 = `${e ? `${(0, import_node_util2.styleText)("gray", S_BAR)}
+          const e = t2.withGuide ?? settings.withGuide, a2 = `${e ? `${(0, import_node_util3.styleText)("gray", S_BAR)}
 ` : ""}${symbol2(this.state)}  ${t2.message}
 `;
           switch (this.state) {
             case "submit": {
-              const n3 = e ? `${(0, import_node_util2.styleText)("gray", S_BAR)}  ` : "", s = this.options.find((u6) => u6.value === this.value) ?? t2.options[0], c3 = wrapTextWithPrefix(
+              const n3 = e ? `${(0, import_node_util3.styleText)("gray", S_BAR)}  ` : "", s = this.options.find((u6) => u6.value === this.value) ?? t2.options[0], c3 = wrapTextWithPrefix(
                 t2.output,
                 l3(s, "selected"),
                 n3
@@ -139348,16 +141112,16 @@ ${b3}
               return `${a2}${c3}`;
             }
             case "cancel": {
-              const n3 = e ? `${(0, import_node_util2.styleText)("gray", S_BAR)}  ` : "", s = wrapTextWithPrefix(
+              const n3 = e ? `${(0, import_node_util3.styleText)("gray", S_BAR)}  ` : "", s = wrapTextWithPrefix(
                 t2.output,
                 l3(this.options[0], "cancelled"),
                 n3
               );
               return `${a2}${s}${e ? `
-${(0, import_node_util2.styleText)("gray", S_BAR)}` : ""}`;
+${(0, import_node_util3.styleText)("gray", S_BAR)}` : ""}`;
             }
             default: {
-              const n3 = e ? `${(0, import_node_util2.styleText)("cyan", S_BAR)}  ` : "", s = e ? (0, import_node_util2.styleText)("cyan", S_BAR_END) : "", c3 = this.options.map(
+              const n3 = e ? `${(0, import_node_util3.styleText)("cyan", S_BAR)}  ` : "", s = e ? (0, import_node_util3.styleText)("cyan", S_BAR_END) : "", c3 = this.options.map(
                 (u6, d) => wrapTextWithPrefix(
                   t2.output,
                   l3(u6, d === this.cursor ? "active" : "inactive"),
@@ -139373,31 +141137,31 @@ ${s}
         }
       }).prompt();
     };
-    i = `${(0, import_node_util2.styleText)("gray", S_BAR)}  `;
+    i = `${(0, import_node_util3.styleText)("gray", S_BAR)}  `;
     stream4 = {
-      message: async (e, { symbol: l3 = (0, import_node_util2.styleText)("gray", S_BAR) } = {}) => {
-        process.stdout.write(`${(0, import_node_util2.styleText)("gray", S_BAR)}
+      message: async (e, { symbol: l3 = (0, import_node_util3.styleText)("gray", S_BAR) } = {}) => {
+        process.stdout.write(`${(0, import_node_util3.styleText)("gray", S_BAR)}
 ${l3}  `);
         let s = 3;
         for await (let r2 of e) {
           r2 = r2.replace(/\n/g, `
 ${i}`), r2.includes(`
-`) && (s = 3 + (0, import_node_util2.stripVTControlCharacters)(r2.slice(r2.lastIndexOf(`
+`) && (s = 3 + (0, import_node_util3.stripVTControlCharacters)(r2.slice(r2.lastIndexOf(`
 `))).length);
-          const o2 = (0, import_node_util2.stripVTControlCharacters)(r2).length;
+          const o2 = (0, import_node_util3.stripVTControlCharacters)(r2).length;
           s + o2 < process.stdout.columns ? (s += o2, process.stdout.write(r2)) : (process.stdout.write(`
-${i}${r2.trimStart()}`), s = 3 + (0, import_node_util2.stripVTControlCharacters)(r2.trimStart()).length);
+${i}${r2.trimStart()}`), s = 3 + (0, import_node_util3.stripVTControlCharacters)(r2.trimStart()).length);
         }
         process.stdout.write(`
 `);
       },
-      info: (e) => stream4.message(e, { symbol: (0, import_node_util2.styleText)("blue", S_INFO) }),
-      success: (e) => stream4.message(e, { symbol: (0, import_node_util2.styleText)("green", S_SUCCESS) }),
-      step: (e) => stream4.message(e, { symbol: (0, import_node_util2.styleText)("green", S_STEP_SUBMIT) }),
-      warn: (e) => stream4.message(e, { symbol: (0, import_node_util2.styleText)("yellow", S_WARN) }),
+      info: (e) => stream4.message(e, { symbol: (0, import_node_util3.styleText)("blue", S_INFO) }),
+      success: (e) => stream4.message(e, { symbol: (0, import_node_util3.styleText)("green", S_SUCCESS) }),
+      step: (e) => stream4.message(e, { symbol: (0, import_node_util3.styleText)("green", S_STEP_SUBMIT) }),
+      warn: (e) => stream4.message(e, { symbol: (0, import_node_util3.styleText)("yellow", S_WARN) }),
       /** alias for `log.warn()`. */
       warning: (e) => stream4.warn(e),
-      error: (e) => stream4.message(e, { symbol: (0, import_node_util2.styleText)("red", S_ERROR) })
+      error: (e) => stream4.message(e, { symbol: (0, import_node_util3.styleText)("red", S_ERROR) })
     };
     tasks = async (o2, e) => {
       for (const t2 of o2) {
@@ -139410,9 +141174,9 @@ ${i}${r2.trimStart()}`), s = 3 + (0, import_node_util2.stripVTControlCharacters)
     };
     A = (l3) => l3.replace(/\x1b\[(?:\d+;)*\d*[ABCDEFGHfJKSTsu]|\x1b\[(s|u)/g, "");
     taskLog = (l3) => {
-      const r2 = l3.output ?? process.stdout, O = getColumns(r2), i2 = (0, import_node_util2.styleText)("gray", S_BAR), p3 = l3.spacing ?? 1, k = 3, m3 = l3.retainLog === true, d = !isCI() && isTTY(r2);
+      const r2 = l3.output ?? process.stdout, O = getColumns(r2), i2 = (0, import_node_util3.styleText)("gray", S_BAR), p3 = l3.spacing ?? 1, k = 3, m3 = l3.retainLog === true, d = !isCI() && isTTY(r2);
       r2.write(`${i2}
-`), r2.write(`${(0, import_node_util2.styleText)("green", S_STEP_SUBMIT)}  ${l3.title}
+`), r2.write(`${(0, import_node_util3.styleText)("green", S_STEP_SUBMIT)}  ${l3.title}
 `);
       for (let e = 0; e < p3; e++)
         r2.write(`${i2}
@@ -139446,7 +141210,7 @@ ${t2.header}`);
 ${e.value}` : e.value;
         e.header !== void 0 && e.header !== "" && log.message(
           e.header.split(`
-`).map((a2) => (0, import_node_util2.styleText)("bold", a2)),
+`).map((a2) => (0, import_node_util3.styleText)("bold", a2)),
           {
             output: r2,
             secondarySymbol: i2,
@@ -139455,7 +141219,7 @@ ${e.value}` : e.value;
           }
         ), log.message(
           o2.split(`
-`).map((a2) => (0, import_node_util2.styleText)("dim", a2)),
+`).map((a2) => (0, import_node_util3.styleText)("dim", a2)),
           {
             output: r2,
             secondarySymbol: i2,
@@ -139534,31 +141298,31 @@ ${e.value}` : e.value;
       signal: e.signal,
       input: e.input,
       render() {
-        const i2 = e?.withGuide ?? settings.withGuide, s = `${`${i2 ? `${(0, import_node_util2.styleText)("gray", S_BAR)}
+        const i2 = e?.withGuide ?? settings.withGuide, s = `${`${i2 ? `${(0, import_node_util3.styleText)("gray", S_BAR)}
 ` : ""}${symbol2(this.state)}  `}${e.message}
 `, c3 = e.placeholder && e.placeholder.length > 0 ? (
           // biome-ignore lint/style/noNonNullAssertion: guarded by placeholder.length > 0
-          (0, import_node_util2.styleText)("inverse", e.placeholder[0]) + (0, import_node_util2.styleText)("dim", e.placeholder.slice(1))
-        ) : (0, import_node_util2.styleText)(["inverse", "hidden"], "_"), o2 = this.userInput ? this.userInputWithCursor : c3, l3 = this.value ?? "";
+          (0, import_node_util3.styleText)("inverse", e.placeholder[0]) + (0, import_node_util3.styleText)("dim", e.placeholder.slice(1))
+        ) : (0, import_node_util3.styleText)(["inverse", "hidden"], "_"), o2 = this.userInput ? this.userInputWithCursor : c3, l3 = this.value ?? "";
         switch (this.state) {
           case "error": {
-            const n3 = this.error ? `  ${(0, import_node_util2.styleText)("yellow", this.error)}` : "", r2 = i2 ? `${(0, import_node_util2.styleText)("yellow", S_BAR)}  ` : "", d = i2 ? (0, import_node_util2.styleText)("yellow", S_BAR_END) : "";
+            const n3 = this.error ? `  ${(0, import_node_util3.styleText)("yellow", this.error)}` : "", r2 = i2 ? `${(0, import_node_util3.styleText)("yellow", S_BAR)}  ` : "", d = i2 ? (0, import_node_util3.styleText)("yellow", S_BAR_END) : "";
             return `${s.trim()}
 ${r2}${o2}
 ${d}${n3}
 `;
           }
           case "submit": {
-            const n3 = l3 ? `  ${(0, import_node_util2.styleText)("dim", l3)}` : "", r2 = i2 ? (0, import_node_util2.styleText)("gray", S_BAR) : "";
+            const n3 = l3 ? `  ${(0, import_node_util3.styleText)("dim", l3)}` : "", r2 = i2 ? (0, import_node_util3.styleText)("gray", S_BAR) : "";
             return `${s}${r2}${n3}`;
           }
           case "cancel": {
-            const n3 = l3 ? `  ${(0, import_node_util2.styleText)(["strikethrough", "dim"], l3)}` : "", r2 = i2 ? (0, import_node_util2.styleText)("gray", S_BAR) : "";
+            const n3 = l3 ? `  ${(0, import_node_util3.styleText)(["strikethrough", "dim"], l3)}` : "", r2 = i2 ? (0, import_node_util3.styleText)("gray", S_BAR) : "";
             return `${s}${r2}${n3}${l3.trim() ? `
 ${r2}` : ""}`;
           }
           default: {
-            const n3 = i2 ? `${(0, import_node_util2.styleText)("cyan", S_BAR)}  ` : "", r2 = i2 ? (0, import_node_util2.styleText)("cyan", S_BAR_END) : "";
+            const n3 = i2 ? `${(0, import_node_util3.styleText)("cyan", S_BAR)}  ` : "", r2 = i2 ? (0, import_node_util3.styleText)("cyan", S_BAR_END) : "";
             return `${s}${n3}${o2}
 ${r2}
 `;
@@ -141482,7 +143246,7 @@ var require_type2 = __commonJS({
 });
 
 // ../../node_modules/.pnpm/@sinclair+typebox@0.34.28/node_modules/@sinclair/typebox/build/cjs/type/clone/index.js
-var require_clone = __commonJS({
+var require_clone2 = __commonJS({
   "../../node_modules/.pnpm/@sinclair+typebox@0.34.28/node_modules/@sinclair/typebox/build/cjs/type/clone/index.js"(exports2) {
     "use strict";
     var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o2, m3, k, k2) {
@@ -146694,7 +148458,7 @@ var require_compute = __commonJS({
     exports2.ComputeType = ComputeType;
     exports2.ComputeModuleProperties = ComputeModuleProperties;
     var index_1 = require_create();
-    var index_2 = require_clone();
+    var index_2 = require_clone2();
     var index_3 = require_discard2();
     var index_4 = require_array2();
     var index_5 = require_awaited2();
@@ -147977,7 +149741,7 @@ var require_cjs = __commonJS({
       for (var p3 in m3) if (p3 !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p3)) __createBinding(exports3, m3, p3);
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
-    __exportStar(require_clone(), exports2);
+    __exportStar(require_clone2(), exports2);
     __exportStar(require_create(), exports2);
     __exportStar(require_error2(), exports2);
     __exportStar(require_guard3(), exports2);
@@ -350435,12 +352199,12 @@ ${options2.prefix}` : "\n" : options2.prefix
          * of the new one.  (Note that the amount of time the canceled operation had been
          * waiting does not affect the amount of time that the new operation waits.)
          */
-        schedule(operationId, delay, cb) {
+        schedule(operationId, delay2, cb) {
           const pendingTimeout = this.pendingTimeouts.get(operationId);
           if (pendingTimeout) {
             this.host.clearTimeout(pendingTimeout);
           }
-          this.pendingTimeouts.set(operationId, this.host.setTimeout(_ThrottledOperations.run, delay, operationId, this, cb));
+          this.pendingTimeouts.set(operationId, this.host.setTimeout(_ThrottledOperations.run, delay2, operationId, this, cb));
           if (this.logger) {
             this.logger.info(`Scheduled: ${operationId}${pendingTimeout ? ", Cancelled earlier one" : ""}`);
           }
@@ -350460,9 +352224,9 @@ ${options2.prefix}` : "\n" : options2.prefix
         }
       };
       var GcTimer = class _GcTimer {
-        constructor(host, delay, logger) {
+        constructor(host, delay2, logger) {
           this.host = host;
-          this.delay = delay;
+          this.delay = delay2;
           this.logger = logger;
         }
         scheduleCollect() {
@@ -360811,12 +362575,12 @@ Project '${project.projectName}' (${ProjectKind[project.projectKind]}) ${counter
           const project = this.projectService.tryGetDefaultProjectForFile(fileName);
           return project && { fileName, project };
         }
-        getDiagnostics(next, delay, fileArgs) {
+        getDiagnostics(next, delay2, fileArgs) {
           if (this.suppressDiagnosticEvents) {
             return;
           }
           if (fileArgs.length > 0) {
-            this.updateErrorCheck(next, fileArgs, delay);
+            this.updateErrorCheck(next, fileArgs, delay2);
           }
         }
         change(args) {
@@ -361216,7 +362980,7 @@ Additional information: BADCLIENT: Bad error code, ${badCode} not found in range
           const spans = languageService.getBraceMatchingAtPosition(file2, position);
           return !spans ? void 0 : simplifiedResult ? spans.map((span) => toProtocolTextSpan(span, scriptInfo)) : spans;
         }
-        getDiagnosticsForProject(next, delay, fileName) {
+        getDiagnosticsForProject(next, delay2, fileName) {
           if (this.suppressDiagnosticEvents) {
             return;
           }
@@ -361261,7 +363025,7 @@ Additional information: BADCLIENT: Bad error code, ${badCode} not found in range
           this.updateErrorCheck(
             next,
             checkList,
-            delay,
+            delay2,
             /*requireOpen*/
             false
           );
@@ -370418,7 +372182,7 @@ var require_load_source = __commonJS({
 });
 
 // ../../packages/workflow-code/dist/cli/state/lockfile.js
-var require_lockfile = __commonJS({
+var require_lockfile2 = __commonJS({
   "../../packages/workflow-code/dist/cli/state/lockfile.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -370821,7 +372585,7 @@ var require_planning = __commonJS({
     exports2.planRemoteSnapshotWrite = planRemoteSnapshotWrite;
     exports2.planSyncResultWrite = planSyncResultWrite;
     var diagnostics_1 = require_diagnostics();
-    var lockfile_1 = require_lockfile();
+    var lockfile_1 = require_lockfile2();
     function validateLockfileIdentity(lockfile, facts, path2 = "<lockfile>") {
       const mismatches = [];
       pushMismatch(mismatches, "targetName", lockfile.targetName, facts.targetName);
@@ -371149,7 +372913,7 @@ var require_state2 = __commonJS({
       for (var p3 in m3) if (p3 !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p3)) __createBinding(exports3, m3, p3);
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
-    __exportStar(require_lockfile(), exports2);
+    __exportStar(require_lockfile2(), exports2);
     __exportStar(require_planning(), exports2);
     __exportStar(require_types3(), exports2);
     __exportStar(require_write(), exports2);
@@ -380750,6 +382514,8 @@ var require_commit_message = __commonJS({
   "../../packages/agent/dist/commit-message.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.normalizeClaudeCommitFallbackReason = normalizeClaudeCommitFallbackReason;
+    exports2.getClaudeCommitFallbackReason = getClaudeCommitFallbackReason;
     exports2.isConventionalCommitMessage = isConventionalCommitMessage;
     exports2.normalizeConventionalCommitMessage = normalizeConventionalCommitMessage;
     exports2.generateCommitMessageWithClaude = generateCommitMessageWithClaude;
@@ -380757,6 +382523,40 @@ var require_commit_message = __commonJS({
     var node_path_1 = require("node:path");
     var process_1 = require_process();
     var conventionalCommitPattern = /^(?:build|chore|ci|docs|feat|fix|perf|refactor|revert|style|test)(?:\([^)]+\))?!?:\s+\S/;
+    var claudeCommitFallbackReasons = {
+      unavailable: "Claude Code is not available. Set it up or review the fallback commit message.",
+      empty: "Claude returned an empty commit message. Review the fallback message or retry.",
+      unsupported: "Claude Code does not support the selected model. Update Claude Code, then retry.",
+      authentication: "Claude authentication failed. Sign in to Claude Code, then retry.",
+      limit: "Claude usage limit reached. Review the fallback message or retry after the limit resets.",
+      timeout: "Claude took too long to generate a commit message. Review the fallback message or retry.",
+      failed: "Claude could not generate the commit message. Review the fallback message or retry."
+    };
+    function normalizeClaudeCommitFallbackReason(reason) {
+      if (Object.values(claudeCommitFallbackReasons).includes(reason))
+        return reason;
+      if (["Claude CLI is not available", "Claude unavailable"].includes(reason))
+        return claudeCommitFallbackReasons.unavailable;
+      if (/^Claude returned an empty commit message\.?$/.test(reason))
+        return claudeCommitFallbackReasons.empty;
+      return claudeCommitFallbackReasons.failed;
+    }
+    function getClaudeCommitFallbackReason(error48) {
+      if (error48 instanceof process_1.CommandError) {
+        const output = `${error48.result.stderr}
+${error48.result.stdout}`;
+        if (/does not support this model|unsupported model/i.test(output))
+          return claudeCommitFallbackReasons.unsupported;
+        if (/not logged in|authentication failed|invalid api key|login required/i.test(output))
+          return claudeCommitFallbackReasons.authentication;
+        if (/rate limit|usage limit|limit reached/i.test(output))
+          return claudeCommitFallbackReasons.limit;
+        if (/timed out/i.test(output))
+          return claudeCommitFallbackReasons.timeout;
+        return claudeCommitFallbackReasons.failed;
+      }
+      return normalizeClaudeCommitFallbackReason(error48 instanceof Error ? error48.message : "");
+    }
     function firstNonEmptyLine(input) {
       return input.split(/\r?\n/).map((line) => line.trim()).find(Boolean) ?? "";
     }
@@ -380896,13 +382696,13 @@ var require_push = __commonJS({
         return {
           message: fallbackMessage,
           source: "fallback",
-          fallbackReason: error48 instanceof Error ? error48.message : String(error48)
+          fallbackReason: (0, commit_message_1.getClaudeCommitFallbackReason)(error48)
         };
       }
       return {
         message: (0, commit_message_1.fallbackCommitMessageFromFiles)(files) || (0, git_1.buildFallbackCommitMessage)(files),
         source: "fallback",
-        fallbackReason: "Claude returned an empty commit message."
+        fallbackReason: (0, commit_message_1.normalizeClaudeCommitFallbackReason)("Claude returned an empty commit message.")
       };
     }
     function isDetachedHeadError(error48) {
@@ -385527,18 +387327,60 @@ function writeError(io, message) {
 `);
 }
 
-// src/commands/auth.ts
+// src/refresh-session.ts
 var import_node_child_process = require("node:child_process");
-var import_promises3 = require("node:fs/promises");
+var import_promises = require("node:timers/promises");
+var import_node_util = require("node:util");
+var import_tela_local_config = __toESM(require_dist());
+async function refreshCliSession(resolved, original, credentials, options2 = {}) {
+  if (!(0, import_tela_local_config.shouldRefreshUserSession)(original))
+    return original;
+  const ref = resolved.context.credentialRef;
+  if ((options2.platform ?? process.platform) !== "darwin" || ref.provider !== "keychain")
+    return await (0, import_tela_local_config.refreshUserSessionCredential)(resolved.environment, ref, original, credentials);
+  await (options2.requestRefresh ?? renewThroughDock)(resolved.id);
+  const credential = await credentials.get(ref);
+  if (!credential || credential.kind !== "user-session" || !credential.accessToken || (0, import_tela_local_config.isExpired)(credential))
+    throw new Error("Tela Dock did not save a valid session. Check the context in Dock and sign in again.");
+  return credential;
+}
+async function renewThroughDock(contextId, dependencies = {}) {
+  const available = dependencies.available ?? import_tela_local_config.isDockSessionBrokerAvailable;
+  if (!await available()) {
+    try {
+      await (dependencies.launch ?? launchDock)();
+    } catch {
+      throw new import_tela_local_config.SessionBrokerUnavailableError();
+    }
+    let ready = false;
+    for (let attempt = 0; attempt < 20; attempt++) {
+      if (await available()) {
+        ready = true;
+        break;
+      }
+      await (dependencies.wait ?? (async () => await (0, import_promises.setTimeout)(250)))();
+    }
+    if (!ready)
+      throw new import_tela_local_config.SessionBrokerUnavailableError();
+  }
+  await (dependencies.refresh ?? import_tela_local_config.requestDockSessionRefresh)(contextId);
+}
+async function launchDock() {
+  await (0, import_node_util.promisify)(import_node_child_process.execFile)("/usr/bin/open", ["-g", "-b", "com.tela.dock"], { timeout: 5e3 });
+}
+
+// src/commands/auth.ts
+var import_node_child_process2 = require("node:child_process");
+var import_promises4 = require("node:fs/promises");
 var import_node_os = require("node:os");
 var import_node_path2 = require("node:path");
 var import_node_process = __toESM(require("node:process"));
-var import_tela_local_config2 = __toESM(require_dist());
+var import_tela_local_config3 = __toESM(require_dist());
 
 // src/credentials.ts
-var import_tela_local_config = __toESM(require_dist());
+var import_tela_local_config2 = __toESM(require_dist());
 function createCliCredentialAdapter(env3 = process.env) {
-  return (0, import_tela_local_config.createLocalCredentialAdapter)(env3);
+  return (0, import_tela_local_config2.createLocalCredentialAdapter)(env3);
 }
 
 // src/commands/auth.ts
@@ -385570,8 +387412,8 @@ async function authLogin(args, options2, io) {
     return 1;
   }
   try {
-    const config2 = await (0, import_tela_local_config2.loadConfig)();
-    const context = parsed.contextId ? (0, import_tela_local_config2.resolveContext)(config2, { contextId: parsed.contextId }) : null;
+    const config2 = await (0, import_tela_local_config3.loadConfig)();
+    const context = parsed.contextId ? (0, import_tela_local_config3.resolveContext)(config2, { contextId: parsed.contextId }) : null;
     const environmentId = context?.context.environmentId ?? parsed.environmentId ?? "production";
     const environment = config2.environments[environmentId];
     if (!environment)
@@ -385584,7 +387426,7 @@ async function authLogin(args, options2, io) {
       );
     }
     const { DeviceFlow: DeviceFlow2 } = await Promise.resolve().then(() => (init_dist3(), dist_exports));
-    const storage = (0, import_tela_local_config2.createTelaTokenStorage)();
+    const storage = (0, import_tela_local_config3.createTelaTokenStorage)();
     const flowOptions = {
       apiUrl: parsed.authUrl ?? environment.authApiUrl,
       requesterApplicationId,
@@ -385669,8 +387511,8 @@ async function authLogout(args, options2, io) {
     return 1;
   }
   try {
-    const config2 = await (0, import_tela_local_config2.loadConfig)();
-    const targets = all3 ? Object.entries(config2.contexts) : [[(0, import_tela_local_config2.resolveContext)(config2, { contextId }).id, (0, import_tela_local_config2.resolveContext)(config2, { contextId }).context]];
+    const config2 = await (0, import_tela_local_config3.loadConfig)();
+    const targets = all3 ? Object.entries(config2.contexts) : [[(0, import_tela_local_config3.resolveContext)(config2, { contextId }).id, (0, import_tela_local_config3.resolveContext)(config2, { contextId }).context]];
     const credentials = createCliCredentialAdapter();
     for (const [, context] of targets)
       await credentials.delete(context.credentialRef);
@@ -385690,8 +387532,8 @@ async function authWhoami(args, options2, io) {
     return 1;
   }
   try {
-    const config2 = await (0, import_tela_local_config2.loadConfig)();
-    const resolved = (0, import_tela_local_config2.resolveContext)(config2, selector);
+    const config2 = await (0, import_tela_local_config3.loadConfig)();
+    const resolved = (0, import_tela_local_config3.resolveContext)(config2, selector);
     const credential = await createCliCredentialAdapter().get(resolved.context.credentialRef);
     if (!credential)
       throw new Error(`Missing credential for Tela context ${resolved.id}`);
@@ -385718,8 +387560,8 @@ async function authWhoami(args, options2, io) {
   }
 }
 async function authTokenList(options2, io) {
-  const config2 = await (0, import_tela_local_config2.loadConfig)();
-  const publicConfig = await (0, import_tela_local_config2.toPublicConfig)(config2, createCliCredentialAdapter());
+  const config2 = await (0, import_tela_local_config3.loadConfig)();
+  const publicConfig = await (0, import_tela_local_config3.toPublicConfig)(config2, createCliCredentialAdapter());
   const tokens = Object.values(publicConfig.contexts).map((context) => ({
     contextId: context.id,
     environmentId: context.environmentId,
@@ -385742,7 +387584,7 @@ async function authTokenList(options2, io) {
 async function discoverLegacyTelactlCredentials() {
   const root = (0, import_node_path2.join)((0, import_node_os.homedir)(), ".telactl");
   try {
-    const names = await (0, import_promises3.readdir)(root);
+    const names = await (0, import_promises4.readdir)(root);
     return names.filter((name) => name.startsWith("credentials.") && name.endsWith(".json")).map((name) => ({
       environmentId: name.slice("credentials.".length, -".json".length),
       path: (0, import_node_path2.join)(root, name)
@@ -385796,8 +387638,8 @@ async function authToken(args, options2, io) {
   }
 }
 async function resolveToken(options2) {
-  const config2 = await (0, import_tela_local_config2.loadConfig)();
-  const resolved = (0, import_tela_local_config2.resolveContext)(config2, {
+  const config2 = await (0, import_tela_local_config3.loadConfig)();
+  const resolved = (0, import_tela_local_config3.resolveContext)(config2, {
     contextId: options2.contextId,
     environmentId: options2.environmentId
   });
@@ -385807,7 +387649,7 @@ async function resolveToken(options2) {
   if (!originalCredential) {
     throw new Error(`Missing credential for Tela context ${resolved.id}`);
   }
-  const credential = originalCredential.kind === "user-session" ? await (0, import_tela_local_config2.refreshUserSessionCredential)(resolved.environment, credentialRef, originalCredential, credentials) : originalCredential;
+  const credential = originalCredential.kind === "user-session" ? await refreshCliSession(resolved, originalCredential, credentials) : originalCredential;
   const refreshed = credential !== originalCredential;
   if (options2.kind === "access-token") {
     if (credential.kind !== "user-session" || !credential.accessToken) {
@@ -385953,7 +387795,7 @@ function formatDeviceFlowInstructions(input) {
 function openExternal(url3) {
   const command = import_node_process.default.platform === "darwin" ? "open" : import_node_process.default.platform === "win32" ? "rundll32" : "xdg-open";
   const args = import_node_process.default.platform === "win32" ? ["url.dll,FileProtocolHandler", url3] : [url3];
-  const child = (0, import_node_child_process.spawn)(command, args, { detached: true, stdio: "ignore" });
+  const child = (0, import_node_child_process2.spawn)(command, args, { detached: true, stdio: "ignore" });
   child.unref();
 }
 function resolveSafeVerificationUrl(rawUrl, { allowLoopbackHttp = false } = {}) {
@@ -385996,7 +387838,7 @@ function writeAuthHelp(io) {
 }
 
 // src/commands/context.ts
-var import_tela_local_config3 = __toESM(require_dist());
+var import_tela_local_config4 = __toESM(require_dist());
 async function runContextCommand(args, options2, io) {
   const [action, ...rest] = args;
   if (!action || action === "help" || action === "--help" || action === "-h") {
@@ -386015,7 +387857,7 @@ async function runContextCommand(args, options2, io) {
   return 1;
 }
 async function currentContext(options2, io) {
-  const config2 = await (0, import_tela_local_config3.loadConfig)();
+  const config2 = await (0, import_tela_local_config4.loadConfig)();
   const credentials = createCliCredentialAdapter();
   const activeContextId = config2.activeContextId;
   const activeContext = activeContextId ? config2.contexts[activeContextId] : void 0;
@@ -386025,7 +387867,7 @@ async function currentContext(options2, io) {
     else writeLine(io, "No active Tela context.");
     return 0;
   }
-  const summary = await (0, import_tela_local_config3.toContextSummary)(activeContextId, activeContext, config2, credentials);
+  const summary = await (0, import_tela_local_config4.toContextSummary)(activeContextId, activeContext, config2, credentials);
   if (options2.json) {
     writeJson(io, { activeContext: summary });
     return 0;
@@ -386034,9 +387876,9 @@ async function currentContext(options2, io) {
   return 0;
 }
 async function listContexts(options2, io) {
-  const config2 = await (0, import_tela_local_config3.loadConfig)();
+  const config2 = await (0, import_tela_local_config4.loadConfig)();
   const credentials = createCliCredentialAdapter();
-  const publicConfig = await (0, import_tela_local_config3.toPublicConfig)(config2, credentials);
+  const publicConfig = await (0, import_tela_local_config4.toPublicConfig)(config2, credentials);
   const contexts = Object.values(publicConfig.contexts);
   if (options2.json) {
     writeJson(io, { contexts });
@@ -386059,13 +387901,13 @@ async function showContext(contextId, options2, io) {
     writeError(io, "Usage: tela context show <context-id>");
     return 1;
   }
-  const config2 = await (0, import_tela_local_config3.loadConfig)();
+  const config2 = await (0, import_tela_local_config4.loadConfig)();
   const context = config2.contexts[contextId];
   if (!context) {
     writeError(io, `Unknown Tela context: ${contextId}`);
     return 1;
   }
-  const summary = await (0, import_tela_local_config3.toContextSummary)(contextId, context, config2, createCliCredentialAdapter());
+  const summary = await (0, import_tela_local_config4.toContextSummary)(contextId, context, config2, createCliCredentialAdapter());
   if (options2.json) {
     writeJson(io, { context: summary });
     return 0;
@@ -386078,11 +387920,11 @@ async function useContext(contextId, options2, io) {
     writeError(io, "Usage: tela context use <context-id>");
     return 1;
   }
-  const config2 = await (0, import_tela_local_config3.updateConfig)((current) => (0, import_tela_local_config3.setActiveContext)(current, contextId));
+  const config2 = await (0, import_tela_local_config4.updateConfig)((current) => (0, import_tela_local_config4.setActiveContext)(current, contextId));
   const context = config2.contexts[contextId];
   if (!context)
     throw new Error(`Unknown context: ${contextId}`);
-  const summary = await (0, import_tela_local_config3.toContextSummary)(contextId, context, config2, createCliCredentialAdapter());
+  const summary = await (0, import_tela_local_config4.toContextSummary)(contextId, context, config2, createCliCredentialAdapter());
   if (options2.json) {
     writeJson(io, { activeContext: summary });
     return 0;
@@ -386110,7 +387952,7 @@ function writeContextHelp(io) {
 }
 
 // src/commands/doctor-auth.ts
-var import_tela_local_config4 = __toESM(require_dist());
+var import_tela_local_config5 = __toESM(require_dist());
 async function runDoctorCommand(args, options2, io) {
   const [action] = args;
   if (!action || action === "help" || action === "--help" || action === "-h") {
@@ -386123,8 +387965,8 @@ async function runDoctorCommand(args, options2, io) {
   return 1;
 }
 async function doctorAuth(options2, io) {
-  const config2 = await (0, import_tela_local_config4.loadConfig)();
-  const publicConfig = await (0, import_tela_local_config4.toPublicConfig)(config2, createCliCredentialAdapter());
+  const config2 = await (0, import_tela_local_config5.loadConfig)();
+  const publicConfig = await (0, import_tela_local_config5.toPublicConfig)(config2, createCliCredentialAdapter());
   const contexts = Object.values(publicConfig.contexts);
   const ok = contexts.every((context) => context.credential.ok);
   if (options2.json) {
@@ -386146,11 +387988,11 @@ function writeDoctorHelp(io) {
 }
 
 // src/commands/env.ts
-var import_tela_local_config7 = __toESM(require_dist());
+var import_tela_local_config8 = __toESM(require_dist());
 
 // src/commands/ingredients.ts
 var import_node_buffer = require("node:buffer");
-var import_tela_local_config6 = __toESM(require_dist());
+var import_tela_local_config7 = __toESM(require_dist());
 var import_tela_pantry2 = __toESM(require_dist2());
 
 // src/markdown.ts
@@ -386219,7 +388061,7 @@ function terminalWidth(target) {
 }
 
 // src/session.ts
-var import_tela_local_config5 = __toESM(require_dist());
+var import_tela_local_config6 = __toESM(require_dist());
 var import_tela_pantry = __toESM(require_dist2());
 var ENV_ACCESS_TOKEN_REF = {
   provider: "env",
@@ -386228,15 +388070,15 @@ var ENV_ACCESS_TOKEN_REF = {
   kind: "user-session"
 };
 async function loadPantry(flags) {
-  const config2 = await (0, import_tela_local_config5.loadConfig)();
-  const resolved = (0, import_tela_local_config5.resolveContext)(config2, {
+  const config2 = await (0, import_tela_local_config6.loadConfig)();
+  const resolved = (0, import_tela_local_config6.resolveContext)(config2, {
     contextId: flags.contextId,
     environmentId: flags.environmentId
   });
   return await loadPantryForContext(resolved, config2);
 }
 async function loadPantryForContext(resolved, config2) {
-  const loadedConfig = config2 ?? await (0, import_tela_local_config5.loadConfig)();
+  const loadedConfig = config2 ?? await (0, import_tela_local_config6.loadConfig)();
   const baseUrl = resolvePantryBaseUrl(resolved);
   const credential = await loadPantryCredential(loadedConfig, resolved);
   return { client: (0, import_tela_pantry.createPantryClient)(baseUrl, credential), baseUrl };
@@ -386248,7 +388090,8 @@ async function loadPantryCredential(config2, selected) {
     const originalCredential = await credentials.get(candidate.credentialRef);
     if (!originalCredential)
       continue;
-    const credential = originalCredential.kind === "user-session" ? await (0, import_tela_local_config5.refreshUserSessionCredential)(candidate.resolved.environment, candidate.credentialRef, originalCredential, credentials) : originalCredential;
+    const sessionContext = { ...candidate.resolved, context: { ...candidate.resolved.context, credentialRef: candidate.credentialRef } };
+    const credential = originalCredential.kind === "user-session" ? await refreshCliSession(sessionContext, originalCredential, credentials) : originalCredential;
     if (credential.accessToken)
       return credential;
   }
@@ -386289,14 +388132,14 @@ function pantryCredentialCandidates(config2, selected) {
   return candidates;
 }
 async function loadSession(contextId, environmentId) {
-  const config2 = await (0, import_tela_local_config5.loadConfig)();
-  const resolved = (0, import_tela_local_config5.resolveContext)(config2, { contextId, environmentId });
+  const config2 = await (0, import_tela_local_config6.loadConfig)();
+  const resolved = (0, import_tela_local_config6.resolveContext)(config2, { contextId, environmentId });
   const credentials = createCliCredentialAdapter();
   const credentialRef = resolved.context.credentialRef;
   const originalCredential = await credentials.get(credentialRef);
   if (!originalCredential)
     throw new Error(`Missing credential for Tela context ${resolved.id}`);
-  const credential = originalCredential.kind === "user-session" ? await (0, import_tela_local_config5.refreshUserSessionCredential)(resolved.environment, credentialRef, originalCredential, credentials) : originalCredential;
+  const credential = originalCredential.kind === "user-session" ? await refreshCliSession(resolved, originalCredential, credentials) : originalCredential;
   return {
     resolved,
     credentialRef,
@@ -386428,7 +388271,7 @@ async function callIngredientApi(args, _options, io) {
   const targetSession = await loadSession(flags.contextId, flags.environmentId);
   const { client, baseUrl } = await loadPantryForContext(targetSession.resolved);
   const ingredient = (0, import_tela_pantry2.assertIngredientType)(await (0, import_tela_pantry2.fetchServiceIngredient)(client, slug, baseUrl), "api");
-  const { inventory } = await (0, import_tela_local_config6.loadInventory)((0, import_tela_local_config6.getTelaLocalPaths)().inventoryFile);
+  const { inventory } = await (0, import_tela_local_config7.loadInventory)((0, import_tela_local_config7.getTelaLocalPaths)().inventoryFile);
   const environment = (0, import_tela_pantry2.resolveServiceEnvironment)(
     ingredient,
     inventory.services.environmentDefaults,
@@ -386609,7 +388452,7 @@ async function setServiceEnvironment(args, io) {
     const available = ingredient.environments.map((candidate) => candidate.slug).join(", ") || "(none)";
     return usageError(`Environment '${environment}' not found for '${slug}'. Available: ${available}`, io);
   }
-  await (0, import_tela_local_config6.updateInventory)((inventory) => {
+  await (0, import_tela_local_config7.updateInventory)((inventory) => {
     inventory.services.environmentDefaults[slug] = environment;
   });
   writeLine(io, `Set default environment for '${slug}' to '${environment}'`);
@@ -386786,8 +388629,8 @@ async function runEnvCommand(args, options2, io) {
   return 1;
 }
 async function listEnvironments(options2, io) {
-  const config2 = await (0, import_tela_local_config7.loadConfig)();
-  const publicConfig = await (0, import_tela_local_config7.toPublicConfig)(config2, createCliCredentialAdapter());
+  const config2 = await (0, import_tela_local_config8.loadConfig)();
+  const publicConfig = await (0, import_tela_local_config8.toPublicConfig)(config2, createCliCredentialAdapter());
   const environments = Object.values(publicConfig.environments);
   if (options2.json) {
     writeJson(io, { environments });
@@ -386807,7 +388650,7 @@ function writeEnvHelp(io) {
 
 // src/commands/skills.ts
 var import_tela_pantry3 = __toESM(require_dist2());
-var import_tela_local_config8 = __toESM(require_dist());
+var import_tela_local_config9 = __toESM(require_dist());
 async function runSkillsCommand(args, options2, io) {
   const [command, ...rest] = args;
   if (!command || command === "help" || command === "--help" || command === "-h") {
@@ -386858,7 +388701,7 @@ async function writeCatalog(flags, options2, io, filters) {
   const { client } = await loadPantry(flags);
   const [skills, installed] = await Promise.all([
     (0, import_tela_pantry3.fetchSkillCatalog)(client, filters),
-    (0, import_tela_local_config8.listInstalledSkills)()
+    (0, import_tela_local_config9.listInstalledSkills)()
   ]);
   const entries = annotateInstalled(skills, installed);
   if (options2.json) {