maxsimcli 2.5.6 → 3.0.0

package/dist/install.cjs

@@ -46,7 +46,1933 @@ let node_async_hooks = require("node:async_hooks");
 let node_readline = require("node:readline");
 node_readline = __toESM(node_readline);
 
-//#region ../../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/vendor/ansi-styles/index.js
+//#region ../../node_modules/universalify/index.js
+var require_universalify = /* @__PURE__ */ __commonJSMin(((exports) => {
+	exports.fromCallback = function(fn) {
+		return Object.defineProperty(function(...args) {
+			if (typeof args[args.length - 1] === "function") fn.apply(this, args);
+			else return new Promise((resolve, reject) => {
+				args.push((err, res) => err != null ? reject(err) : resolve(res));
+				fn.apply(this, args);
+			});
+		}, "name", { value: fn.name });
+	};
+	exports.fromPromise = function(fn) {
+		return Object.defineProperty(function(...args) {
+			const cb = args[args.length - 1];
+			if (typeof cb !== "function") return fn.apply(this, args);
+			else {
+				args.pop();
+				fn.apply(this, args).then((r) => cb(null, r), cb);
+			}
+		}, "name", { value: fn.name });
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/graceful-fs/polyfills.js
+var require_polyfills = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var constants = require("constants");
+	var origCwd = process.cwd;
+	var cwd = null;
+	var platform = 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") {
+		var chdir = process.chdir;
+		process.chdir = function(d) {
+			cwd = null;
+			chdir.call(process, d);
+		};
+		if (Object.setPrototypeOf) Object.setPrototypeOf(process.chdir, chdir);
+	}
+	module.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(path, mode, cb) {
+				if (cb) process.nextTick(cb);
+			};
+			fs.lchmodSync = function() {};
+		}
+		if (fs.chown && !fs.lchown) {
+			fs.lchown = function(path, uid, gid, cb) {
+				if (cb) process.nextTick(cb);
+			};
+			fs.lchownSync = function() {};
+		}
+		if (platform === "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, _, __) {
+						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 : (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(fs) {
+			fs.lchmod = function(path, mode, callback) {
+				fs.open(path, constants.O_WRONLY | constants.O_SYMLINK, mode, function(err, fd) {
+					if (err) {
+						if (callback) callback(err);
+						return;
+					}
+					fs.fchmod(fd, mode, function(err) {
+						fs.close(fd, function(err2) {
+							if (callback) callback(err || err2);
+						});
+					});
+				});
+			};
+			fs.lchmodSync = function(path, mode) {
+				var fd = fs.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode);
+				var threw = true;
+				var ret;
+				try {
+					ret = fs.fchmodSync(fd, mode);
+					threw = false;
+				} finally {
+					if (threw) try {
+						fs.closeSync(fd);
+					} catch (er) {}
+					else fs.closeSync(fd);
+				}
+				return ret;
+			};
+		}
+		function patchLutimes(fs) {
+			if (constants.hasOwnProperty("O_SYMLINK") && fs.futimes) {
+				fs.lutimes = function(path, at, mt, cb) {
+					fs.open(path, constants.O_SYMLINK, function(er, fd) {
+						if (er) {
+							if (cb) cb(er);
+							return;
+						}
+						fs.futimes(fd, at, mt, function(er) {
+							fs.close(fd, function(er2) {
+								if (cb) cb(er || er2);
+							});
+						});
+					});
+				};
+				fs.lutimesSync = function(path, at, mt) {
+					var fd = fs.openSync(path, constants.O_SYMLINK);
+					var ret;
+					var threw = true;
+					try {
+						ret = fs.futimesSync(fd, at, mt);
+						threw = false;
+					} finally {
+						if (threw) try {
+							fs.closeSync(fd);
+						} catch (er) {}
+						else fs.closeSync(fd);
+					}
+					return ret;
+				};
+			} else if (fs.futimes) {
+				fs.lutimes = function(_a, _b, _c, cb) {
+					if (cb) process.nextTick(cb);
+				};
+				fs.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, options, cb) {
+				if (typeof options === "function") {
+					cb = options;
+					options = 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 options ? orig.call(fs, target, options, callback) : orig.call(fs, target, callback);
+			};
+		}
+		function statFixSync(orig) {
+			if (!orig) return orig;
+			return function(target, options) {
+				var stats = options ? orig.call(fs, target, options) : 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;
+			if (!process.getuid || process.getuid() !== 0) {
+				if (er.code === "EINVAL" || er.code === "EPERM") return true;
+			}
+			return false;
+		}
+	}
+}));
+
+//#endregion
+//#region ../../node_modules/graceful-fs/legacy-streams.js
+var require_legacy_streams = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Stream$1 = require("stream").Stream;
+	module.exports = legacy;
+	function legacy(fs) {
+		return {
+			ReadStream,
+			WriteStream
+		};
+		function ReadStream(path, options) {
+			if (!(this instanceof ReadStream)) return new ReadStream(path, options);
+			Stream$1.call(this);
+			var self = this;
+			this.path = path;
+			this.fd = null;
+			this.readable = true;
+			this.paused = false;
+			this.flags = "r";
+			this.mode = 438;
+			this.bufferSize = 64 * 1024;
+			options = options || {};
+			var keys = Object.keys(options);
+			for (var index = 0, length = keys.length; index < length; index++) {
+				var key = keys[index];
+				this[key] = options[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() {
+					self._read();
+				});
+				return;
+			}
+			fs.open(this.path, this.flags, this.mode, function(err, fd) {
+				if (err) {
+					self.emit("error", err);
+					self.readable = false;
+					return;
+				}
+				self.fd = fd;
+				self.emit("open", fd);
+				self._read();
+			});
+		}
+		function WriteStream(path, options) {
+			if (!(this instanceof WriteStream)) return new WriteStream(path, options);
+			Stream$1.call(this);
+			this.path = path;
+			this.fd = null;
+			this.writable = true;
+			this.flags = "w";
+			this.encoding = "binary";
+			this.mode = 438;
+			this.bytesWritten = 0;
+			options = options || {};
+			var keys = Object.keys(options);
+			for (var index = 0, length = keys.length; index < length; index++) {
+				var key = keys[index];
+				this[key] = options[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();
+			}
+		}
+	}
+}));
+
+//#endregion
+//#region ../../node_modules/graceful-fs/clone.js
+var require_clone = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = clone;
+	var getPrototypeOf = Object.getPrototypeOf || function(obj) {
+		return obj.__proto__;
+	};
+	function clone(obj) {
+		if (obj === null || typeof obj !== "object") return obj;
+		if (obj instanceof Object) var copy = { __proto__: getPrototypeOf(obj) };
+		else var copy = Object.create(null);
+		Object.getOwnPropertyNames(obj).forEach(function(key) {
+			Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key));
+		});
+		return copy;
+	}
+}));
+
+//#endregion
+//#region ../../node_modules/graceful-fs/graceful-fs.js
+var require_graceful_fs = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var fs = require("fs");
+	var polyfills = require_polyfills();
+	var legacy = require_legacy_streams();
+	var clone = require_clone();
+	var util = require("util");
+	/* istanbul ignore next - node 0.x polyfill */
+	var gracefulQueue;
+	var previousSymbol;
+	/* istanbul ignore else - node 0.x polyfill */
+	if (typeof Symbol === "function" && typeof Symbol.for === "function") {
+		gracefulQueue = Symbol.for("graceful-fs.queue");
+		previousSymbol = Symbol.for("graceful-fs.previous");
+	} else {
+		gracefulQueue = "___graceful-fs.queue";
+		previousSymbol = "___graceful-fs.previous";
+	}
+	function noop() {}
+	function publishQueue(context, queue) {
+		Object.defineProperty(context, gracefulQueue, { get: function() {
+			return queue;
+		} });
+	}
+	var debug = noop;
+	if (util.debuglog) debug = util.debuglog("gfs4");
+	else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) debug = function() {
+		var m = util.format.apply(util, arguments);
+		m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
+		console.error(m);
+	};
+	if (!fs[gracefulQueue]) {
+		publishQueue(fs, global[gracefulQueue] || []);
+		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);
+		});
+	}
+	if (!global[gracefulQueue]) publishQueue(global, fs[gracefulQueue]);
+	module.exports = patch(clone(fs));
+	if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs.__patched) {
+		module.exports = patch(fs);
+		fs.__patched = true;
+	}
+	function patch(fs) {
+		polyfills(fs);
+		fs.gracefulify = patch;
+		fs.createReadStream = createReadStream;
+		fs.createWriteStream = createWriteStream;
+		var fs$readFile = fs.readFile;
+		fs.readFile = readFile;
+		function readFile(path, options, cb) {
+			if (typeof options === "function") cb = options, options = null;
+			return go$readFile(path, options, cb);
+			function go$readFile(path, options, cb, startTime) {
+				return fs$readFile(path, options, function(err) {
+					if (err && (err.code === "EMFILE" || err.code === "ENFILE")) enqueue([
+						go$readFile,
+						[
+							path,
+							options,
+							cb
+						],
+						err,
+						startTime || Date.now(),
+						Date.now()
+					]);
+					else if (typeof cb === "function") cb.apply(this, arguments);
+				});
+			}
+		}
+		var fs$writeFile = fs.writeFile;
+		fs.writeFile = writeFile;
+		function writeFile(path, data, options, cb) {
+			if (typeof options === "function") cb = options, options = null;
+			return go$writeFile(path, data, options, cb);
+			function go$writeFile(path, data, options, cb, startTime) {
+				return fs$writeFile(path, data, options, function(err) {
+					if (err && (err.code === "EMFILE" || err.code === "ENFILE")) enqueue([
+						go$writeFile,
+						[
+							path,
+							data,
+							options,
+							cb
+						],
+						err,
+						startTime || Date.now(),
+						Date.now()
+					]);
+					else if (typeof cb === "function") cb.apply(this, arguments);
+				});
+			}
+		}
+		var fs$appendFile = fs.appendFile;
+		if (fs$appendFile) fs.appendFile = appendFile;
+		function appendFile(path, data, options, cb) {
+			if (typeof options === "function") cb = options, options = null;
+			return go$appendFile(path, data, options, cb);
+			function go$appendFile(path, data, options, cb, startTime) {
+				return fs$appendFile(path, data, options, function(err) {
+					if (err && (err.code === "EMFILE" || err.code === "ENFILE")) enqueue([
+						go$appendFile,
+						[
+							path,
+							data,
+							options,
+							cb
+						],
+						err,
+						startTime || Date.now(),
+						Date.now()
+					]);
+					else if (typeof cb === "function") cb.apply(this, arguments);
+				});
+			}
+		}
+		var fs$copyFile = fs.copyFile;
+		if (fs$copyFile) fs.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(src, dest, flags, cb, startTime) {
+				return fs$copyFile(src, dest, flags, function(err) {
+					if (err && (err.code === "EMFILE" || err.code === "ENFILE")) enqueue([
+						go$copyFile,
+						[
+							src,
+							dest,
+							flags,
+							cb
+						],
+						err,
+						startTime || Date.now(),
+						Date.now()
+					]);
+					else if (typeof cb === "function") cb.apply(this, arguments);
+				});
+			}
+		}
+		var fs$readdir = fs.readdir;
+		fs.readdir = readdir;
+		var noReaddirOptionVersions = /^v[0-5]\./;
+		function readdir(path, options, cb) {
+			if (typeof options === "function") cb = options, options = null;
+			var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir(path, options, cb, startTime) {
+				return fs$readdir(path, fs$readdirCallback(path, options, cb, startTime));
+			} : function go$readdir(path, options, cb, startTime) {
+				return fs$readdir(path, options, fs$readdirCallback(path, options, cb, startTime));
+			};
+			return go$readdir(path, options, cb);
+			function fs$readdirCallback(path, options, cb, startTime) {
+				return function(err, files) {
+					if (err && (err.code === "EMFILE" || err.code === "ENFILE")) enqueue([
+						go$readdir,
+						[
+							path,
+							options,
+							cb
+						],
+						err,
+						startTime || Date.now(),
+						Date.now()
+					]);
+					else {
+						if (files && files.sort) files.sort();
+						if (typeof cb === "function") cb.call(this, err, files);
+					}
+				};
+			}
+		}
+		if (process.version.substr(0, 4) === "v0.8") {
+			var legStreams = legacy(fs);
+			ReadStream = legStreams.ReadStream;
+			WriteStream = legStreams.WriteStream;
+		}
+		var fs$ReadStream = fs.ReadStream;
+		if (fs$ReadStream) {
+			ReadStream.prototype = Object.create(fs$ReadStream.prototype);
+			ReadStream.prototype.open = ReadStream$open;
+		}
+		var fs$WriteStream = fs.WriteStream;
+		if (fs$WriteStream) {
+			WriteStream.prototype = Object.create(fs$WriteStream.prototype);
+			WriteStream.prototype.open = WriteStream$open;
+		}
+		Object.defineProperty(fs, "ReadStream", {
+			get: function() {
+				return ReadStream;
+			},
+			set: function(val) {
+				ReadStream = val;
+			},
+			enumerable: true,
+			configurable: true
+		});
+		Object.defineProperty(fs, "WriteStream", {
+			get: function() {
+				return WriteStream;
+			},
+			set: function(val) {
+				WriteStream = val;
+			},
+			enumerable: true,
+			configurable: true
+		});
+		var FileReadStream = ReadStream;
+		Object.defineProperty(fs, "FileReadStream", {
+			get: function() {
+				return FileReadStream;
+			},
+			set: function(val) {
+				FileReadStream = val;
+			},
+			enumerable: true,
+			configurable: true
+		});
+		var FileWriteStream = WriteStream;
+		Object.defineProperty(fs, "FileWriteStream", {
+			get: function() {
+				return FileWriteStream;
+			},
+			set: function(val) {
+				FileWriteStream = val;
+			},
+			enumerable: true,
+			configurable: true
+		});
+		function ReadStream(path, options) {
+			if (this instanceof ReadStream) return fs$ReadStream.apply(this, arguments), this;
+			else return ReadStream.apply(Object.create(ReadStream.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(path, options) {
+			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(path, options) {
+			return new fs.ReadStream(path, options);
+		}
+		function createWriteStream(path, options) {
+			return new fs.WriteStream(path, options);
+		}
+		var fs$open = fs.open;
+		fs.open = open;
+		function open(path, flags, mode, cb) {
+			if (typeof mode === "function") cb = mode, mode = null;
+			return go$open(path, flags, mode, cb);
+			function go$open(path, flags, mode, cb, startTime) {
+				return fs$open(path, flags, mode, function(err, fd) {
+					if (err && (err.code === "EMFILE" || err.code === "ENFILE")) enqueue([
+						go$open,
+						[
+							path,
+							flags,
+							mode,
+							cb
+						],
+						err,
+						startTime || Date.now(),
+						Date.now()
+					]);
+					else if (typeof cb === "function") cb.apply(this, arguments);
+				});
+			}
+		}
+		return fs;
+	}
+	function enqueue(elem) {
+		debug("ENQUEUE", elem[0].name, elem[1]);
+		fs[gracefulQueue].push(elem);
+		retry();
+	}
+	var retryTimer;
+	function resetQueue() {
+		var now = Date.now();
+		for (var i = 0; i < fs[gracefulQueue].length; ++i) if (fs[gracefulQueue][i].length > 2) {
+			fs[gracefulQueue][i][3] = now;
+			fs[gracefulQueue][i][4] = now;
+		}
+		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);
+			if (sinceAttempt >= Math.min(sinceStart * 1.2, 100)) {
+				debug("RETRY", fn.name, args);
+				fn.apply(null, args.concat([startTime]));
+			} else fs[gracefulQueue].push(elem);
+		}
+		if (retryTimer === void 0) retryTimer = setTimeout(retry, 0);
+	}
+}));
+
+//#endregion
+//#region ../../node_modules/fs-extra/lib/fs/index.js
+var require_fs = /* @__PURE__ */ __commonJSMin(((exports) => {
+	const u = require_universalify().fromCallback;
+	const fs = require_graceful_fs();
+	const api = [
+		"access",
+		"appendFile",
+		"chmod",
+		"chown",
+		"close",
+		"copyFile",
+		"cp",
+		"fchmod",
+		"fchown",
+		"fdatasync",
+		"fstat",
+		"fsync",
+		"ftruncate",
+		"futimes",
+		"glob",
+		"lchmod",
+		"lchown",
+		"lutimes",
+		"link",
+		"lstat",
+		"mkdir",
+		"mkdtemp",
+		"open",
+		"opendir",
+		"readdir",
+		"readFile",
+		"readlink",
+		"realpath",
+		"rename",
+		"rm",
+		"rmdir",
+		"stat",
+		"statfs",
+		"symlink",
+		"truncate",
+		"unlink",
+		"utimes",
+		"writeFile"
+	].filter((key) => {
+		return typeof fs[key] === "function";
+	});
+	Object.assign(exports, fs);
+	api.forEach((method) => {
+		exports[method] = u(fs[method]);
+	});
+	exports.exists = function(filename, callback) {
+		if (typeof callback === "function") return fs.exists(filename, callback);
+		return new Promise((resolve) => {
+			return fs.exists(filename, resolve);
+		});
+	};
+	exports.read = function(fd, buffer, offset, length, position, callback) {
+		if (typeof callback === "function") return fs.read(fd, buffer, offset, length, position, callback);
+		return new Promise((resolve, reject) => {
+			fs.read(fd, buffer, offset, length, position, (err, bytesRead, buffer) => {
+				if (err) return reject(err);
+				resolve({
+					bytesRead,
+					buffer
+				});
+			});
+		});
+	};
+	exports.write = function(fd, buffer, ...args) {
+		if (typeof args[args.length - 1] === "function") return fs.write(fd, buffer, ...args);
+		return new Promise((resolve, reject) => {
+			fs.write(fd, buffer, ...args, (err, bytesWritten, buffer) => {
+				if (err) return reject(err);
+				resolve({
+					bytesWritten,
+					buffer
+				});
+			});
+		});
+	};
+	exports.readv = function(fd, buffers, ...args) {
+		if (typeof args[args.length - 1] === "function") return fs.readv(fd, buffers, ...args);
+		return new Promise((resolve, reject) => {
+			fs.readv(fd, buffers, ...args, (err, bytesRead, buffers) => {
+				if (err) return reject(err);
+				resolve({
+					bytesRead,
+					buffers
+				});
+			});
+		});
+	};
+	exports.writev = function(fd, buffers, ...args) {
+		if (typeof args[args.length - 1] === "function") return fs.writev(fd, buffers, ...args);
+		return new Promise((resolve, reject) => {
+			fs.writev(fd, buffers, ...args, (err, bytesWritten, buffers) => {
+				if (err) return reject(err);
+				resolve({
+					bytesWritten,
+					buffers
+				});
+			});
+		});
+	};
+	if (typeof fs.realpath.native === "function") exports.realpath.native = u(fs.realpath.native);
+	else process.emitWarning("fs.realpath.native is not a function. Is fs being monkey-patched?", "Warning", "fs-extra-WARN0003");
+}));
+
+//#endregion
+//#region ../../node_modules/fs-extra/lib/mkdirs/utils.js
+var require_utils$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const path$11 = require("path");
+	module.exports.checkPath = function checkPath(pth) {
+		if (process.platform === "win32") {
+			if (/[<>:"|?*]/.test(pth.replace(path$11.parse(pth).root, ""))) {
+				const error = /* @__PURE__ */ new Error(`Path contains invalid characters: ${pth}`);
+				error.code = "EINVAL";
+				throw error;
+			}
+		}
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/fs-extra/lib/mkdirs/make-dir.js
+var require_make_dir = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fs = require_fs();
+	const { checkPath } = require_utils$1();
+	const getMode = (options) => {
+		const defaults = { mode: 511 };
+		if (typeof options === "number") return options;
+		return {
+			...defaults,
+			...options
+		}.mode;
+	};
+	module.exports.makeDir = async (dir, options) => {
+		checkPath(dir);
+		return fs.mkdir(dir, {
+			mode: getMode(options),
+			recursive: true
+		});
+	};
+	module.exports.makeDirSync = (dir, options) => {
+		checkPath(dir);
+		return fs.mkdirSync(dir, {
+			mode: getMode(options),
+			recursive: true
+		});
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/fs-extra/lib/mkdirs/index.js
+var require_mkdirs = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const u = require_universalify().fromPromise;
+	const { makeDir: _makeDir, makeDirSync } = require_make_dir();
+	const makeDir = u(_makeDir);
+	module.exports = {
+		mkdirs: makeDir,
+		mkdirsSync: makeDirSync,
+		mkdirp: makeDir,
+		mkdirpSync: makeDirSync,
+		ensureDir: makeDir,
+		ensureDirSync: makeDirSync
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/fs-extra/lib/path-exists/index.js
+var require_path_exists = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const u = require_universalify().fromPromise;
+	const fs = require_fs();
+	function pathExists(path) {
+		return fs.access(path).then(() => true).catch(() => false);
+	}
+	module.exports = {
+		pathExists: u(pathExists),
+		pathExistsSync: fs.existsSync
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/fs-extra/lib/util/utimes.js
+var require_utimes = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fs = require_fs();
+	const u = require_universalify().fromPromise;
+	async function utimesMillis(path, atime, mtime) {
+		const fd = await fs.open(path, "r+");
+		let closeErr = null;
+		try {
+			await fs.futimes(fd, atime, mtime);
+		} finally {
+			try {
+				await fs.close(fd);
+			} catch (e) {
+				closeErr = e;
+			}
+		}
+		if (closeErr) throw closeErr;
+	}
+	function utimesMillisSync(path, atime, mtime) {
+		const fd = fs.openSync(path, "r+");
+		fs.futimesSync(fd, atime, mtime);
+		return fs.closeSync(fd);
+	}
+	module.exports = {
+		utimesMillis: u(utimesMillis),
+		utimesMillisSync
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/fs-extra/lib/util/stat.js
+var require_stat = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fs = require_fs();
+	const path$10 = require("path");
+	const u = require_universalify().fromPromise;
+	function getStats(src, dest, opts) {
+		const statFunc = opts.dereference ? (file) => fs.stat(file, { bigint: true }) : (file) => fs.lstat(file, { bigint: true });
+		return Promise.all([statFunc(src), statFunc(dest).catch((err) => {
+			if (err.code === "ENOENT") return null;
+			throw err;
+		})]).then(([srcStat, destStat]) => ({
+			srcStat,
+			destStat
+		}));
+	}
+	function getStatsSync(src, dest, opts) {
+		let destStat;
+		const statFunc = opts.dereference ? (file) => fs.statSync(file, { bigint: true }) : (file) => fs.lstatSync(file, { bigint: true });
+		const srcStat = statFunc(src);
+		try {
+			destStat = statFunc(dest);
+		} catch (err) {
+			if (err.code === "ENOENT") return {
+				srcStat,
+				destStat: null
+			};
+			throw err;
+		}
+		return {
+			srcStat,
+			destStat
+		};
+	}
+	async function checkPaths(src, dest, funcName, opts) {
+		const { srcStat, destStat } = await getStats(src, dest, opts);
+		if (destStat) {
+			if (areIdentical(srcStat, destStat)) {
+				const srcBaseName = path$10.basename(src);
+				const destBaseName = path$10.basename(dest);
+				if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) return {
+					srcStat,
+					destStat,
+					isChangingCase: true
+				};
+				throw new Error("Source and destination must not be the same.");
+			}
+			if (srcStat.isDirectory() && !destStat.isDirectory()) throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`);
+			if (!srcStat.isDirectory() && destStat.isDirectory()) throw new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`);
+		}
+		if (srcStat.isDirectory() && isSrcSubdir(src, dest)) throw new Error(errMsg(src, dest, funcName));
+		return {
+			srcStat,
+			destStat
+		};
+	}
+	function checkPathsSync(src, dest, funcName, opts) {
+		const { srcStat, destStat } = getStatsSync(src, dest, opts);
+		if (destStat) {
+			if (areIdentical(srcStat, destStat)) {
+				const srcBaseName = path$10.basename(src);
+				const destBaseName = path$10.basename(dest);
+				if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) return {
+					srcStat,
+					destStat,
+					isChangingCase: true
+				};
+				throw new Error("Source and destination must not be the same.");
+			}
+			if (srcStat.isDirectory() && !destStat.isDirectory()) throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`);
+			if (!srcStat.isDirectory() && destStat.isDirectory()) throw new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`);
+		}
+		if (srcStat.isDirectory() && isSrcSubdir(src, dest)) throw new Error(errMsg(src, dest, funcName));
+		return {
+			srcStat,
+			destStat
+		};
+	}
+	async function checkParentPaths(src, srcStat, dest, funcName) {
+		const srcParent = path$10.resolve(path$10.dirname(src));
+		const destParent = path$10.resolve(path$10.dirname(dest));
+		if (destParent === srcParent || destParent === path$10.parse(destParent).root) return;
+		let destStat;
+		try {
+			destStat = await fs.stat(destParent, { bigint: true });
+		} catch (err) {
+			if (err.code === "ENOENT") return;
+			throw err;
+		}
+		if (areIdentical(srcStat, destStat)) throw new Error(errMsg(src, dest, funcName));
+		return checkParentPaths(src, srcStat, destParent, funcName);
+	}
+	function checkParentPathsSync(src, srcStat, dest, funcName) {
+		const srcParent = path$10.resolve(path$10.dirname(src));
+		const destParent = path$10.resolve(path$10.dirname(dest));
+		if (destParent === srcParent || destParent === path$10.parse(destParent).root) return;
+		let destStat;
+		try {
+			destStat = fs.statSync(destParent, { bigint: true });
+		} catch (err) {
+			if (err.code === "ENOENT") return;
+			throw err;
+		}
+		if (areIdentical(srcStat, destStat)) throw new Error(errMsg(src, dest, funcName));
+		return checkParentPathsSync(src, srcStat, destParent, funcName);
+	}
+	function areIdentical(srcStat, destStat) {
+		return destStat.ino !== void 0 && destStat.dev !== void 0 && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev;
+	}
+	function isSrcSubdir(src, dest) {
+		const srcArr = path$10.resolve(src).split(path$10.sep).filter((i) => i);
+		const destArr = path$10.resolve(dest).split(path$10.sep).filter((i) => i);
+		return srcArr.every((cur, i) => destArr[i] === cur);
+	}
+	function errMsg(src, dest, funcName) {
+		return `Cannot ${funcName} '${src}' to a subdirectory of itself, '${dest}'.`;
+	}
+	module.exports = {
+		checkPaths: u(checkPaths),
+		checkPathsSync,
+		checkParentPaths: u(checkParentPaths),
+		checkParentPathsSync,
+		isSrcSubdir,
+		areIdentical
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/fs-extra/lib/util/async.js
+var require_async = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	async function asyncIteratorConcurrentProcess(iterator, fn) {
+		const promises = [];
+		for await (const item of iterator) promises.push(fn(item).then(() => null, (err) => err ?? /* @__PURE__ */ new Error("unknown error")));
+		await Promise.all(promises.map((promise) => promise.then((possibleErr) => {
+			if (possibleErr !== null) throw possibleErr;
+		})));
+	}
+	module.exports = { asyncIteratorConcurrentProcess };
+}));
+
+//#endregion
+//#region ../../node_modules/fs-extra/lib/copy/copy.js
+var require_copy$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fs = require_fs();
+	const path$9 = require("path");
+	const { mkdirs } = require_mkdirs();
+	const { pathExists } = require_path_exists();
+	const { utimesMillis } = require_utimes();
+	const stat = require_stat();
+	const { asyncIteratorConcurrentProcess } = require_async();
+	async function copy(src, dest, opts = {}) {
+		if (typeof opts === "function") opts = { filter: opts };
+		opts.clobber = "clobber" in opts ? !!opts.clobber : true;
+		opts.overwrite = "overwrite" in opts ? !!opts.overwrite : opts.clobber;
+		if (opts.preserveTimestamps && process.arch === "ia32") process.emitWarning("Using the preserveTimestamps option in 32-bit node is not recommended;\n\n	see https://github.com/jprichardson/node-fs-extra/issues/269", "Warning", "fs-extra-WARN0001");
+		const { srcStat, destStat } = await stat.checkPaths(src, dest, "copy", opts);
+		await stat.checkParentPaths(src, srcStat, dest, "copy");
+		if (!await runFilter(src, dest, opts)) return;
+		const destParent = path$9.dirname(dest);
+		if (!await pathExists(destParent)) await mkdirs(destParent);
+		await getStatsAndPerformCopy(destStat, src, dest, opts);
+	}
+	async function runFilter(src, dest, opts) {
+		if (!opts.filter) return true;
+		return opts.filter(src, dest);
+	}
+	async function getStatsAndPerformCopy(destStat, src, dest, opts) {
+		const srcStat = await (opts.dereference ? fs.stat : fs.lstat)(src);
+		if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts);
+		if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts);
+		if (srcStat.isSymbolicLink()) return onLink(destStat, src, dest, opts);
+		if (srcStat.isSocket()) throw new Error(`Cannot copy a socket file: ${src}`);
+		if (srcStat.isFIFO()) throw new Error(`Cannot copy a FIFO pipe: ${src}`);
+		throw new Error(`Unknown file: ${src}`);
+	}
+	async function onFile(srcStat, destStat, src, dest, opts) {
+		if (!destStat) return copyFile(srcStat, src, dest, opts);
+		if (opts.overwrite) {
+			await fs.unlink(dest);
+			return copyFile(srcStat, src, dest, opts);
+		}
+		if (opts.errorOnExist) throw new Error(`'${dest}' already exists`);
+	}
+	async function copyFile(srcStat, src, dest, opts) {
+		await fs.copyFile(src, dest);
+		if (opts.preserveTimestamps) {
+			if (fileIsNotWritable(srcStat.mode)) await makeFileWritable(dest, srcStat.mode);
+			const updatedSrcStat = await fs.stat(src);
+			await utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
+		}
+		return fs.chmod(dest, srcStat.mode);
+	}
+	function fileIsNotWritable(srcMode) {
+		return (srcMode & 128) === 0;
+	}
+	function makeFileWritable(dest, srcMode) {
+		return fs.chmod(dest, srcMode | 128);
+	}
+	async function onDir(srcStat, destStat, src, dest, opts) {
+		if (!destStat) await fs.mkdir(dest);
+		await asyncIteratorConcurrentProcess(await fs.opendir(src), async (item) => {
+			const srcItem = path$9.join(src, item.name);
+			const destItem = path$9.join(dest, item.name);
+			if (await runFilter(srcItem, destItem, opts)) {
+				const { destStat } = await stat.checkPaths(srcItem, destItem, "copy", opts);
+				await getStatsAndPerformCopy(destStat, srcItem, destItem, opts);
+			}
+		});
+		if (!destStat) await fs.chmod(dest, srcStat.mode);
+	}
+	async function onLink(destStat, src, dest, opts) {
+		let resolvedSrc = await fs.readlink(src);
+		if (opts.dereference) resolvedSrc = path$9.resolve(process.cwd(), resolvedSrc);
+		if (!destStat) return fs.symlink(resolvedSrc, dest);
+		let resolvedDest = null;
+		try {
+			resolvedDest = await fs.readlink(dest);
+		} catch (e) {
+			if (e.code === "EINVAL" || e.code === "UNKNOWN") return fs.symlink(resolvedSrc, dest);
+			throw e;
+		}
+		if (opts.dereference) resolvedDest = path$9.resolve(process.cwd(), resolvedDest);
+		if (resolvedSrc !== resolvedDest) {
+			if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
+			if (stat.isSrcSubdir(resolvedDest, resolvedSrc)) throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
+		}
+		await fs.unlink(dest);
+		return fs.symlink(resolvedSrc, dest);
+	}
+	module.exports = copy;
+}));
+
+//#endregion
+//#region ../../node_modules/fs-extra/lib/copy/copy-sync.js
+var require_copy_sync = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fs = require_graceful_fs();
+	const path$8 = require("path");
+	const mkdirsSync = require_mkdirs().mkdirsSync;
+	const utimesMillisSync = require_utimes().utimesMillisSync;
+	const stat = require_stat();
+	function copySync(src, dest, opts) {
+		if (typeof opts === "function") opts = { filter: opts };
+		opts = opts || {};
+		opts.clobber = "clobber" in opts ? !!opts.clobber : true;
+		opts.overwrite = "overwrite" in opts ? !!opts.overwrite : opts.clobber;
+		if (opts.preserveTimestamps && process.arch === "ia32") process.emitWarning("Using the preserveTimestamps option in 32-bit node is not recommended;\n\n	see https://github.com/jprichardson/node-fs-extra/issues/269", "Warning", "fs-extra-WARN0002");
+		const { srcStat, destStat } = stat.checkPathsSync(src, dest, "copy", opts);
+		stat.checkParentPathsSync(src, srcStat, dest, "copy");
+		if (opts.filter && !opts.filter(src, dest)) return;
+		const destParent = path$8.dirname(dest);
+		if (!fs.existsSync(destParent)) mkdirsSync(destParent);
+		return getStats(destStat, src, dest, opts);
+	}
+	function getStats(destStat, src, dest, opts) {
+		const srcStat = (opts.dereference ? fs.statSync : fs.lstatSync)(src);
+		if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts);
+		else if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts);
+		else if (srcStat.isSymbolicLink()) return onLink(destStat, src, dest, opts);
+		else if (srcStat.isSocket()) throw new Error(`Cannot copy a socket file: ${src}`);
+		else if (srcStat.isFIFO()) throw new Error(`Cannot copy a FIFO pipe: ${src}`);
+		throw new Error(`Unknown file: ${src}`);
+	}
+	function onFile(srcStat, destStat, src, dest, opts) {
+		if (!destStat) return copyFile(srcStat, src, dest, opts);
+		return mayCopyFile(srcStat, src, dest, opts);
+	}
+	function mayCopyFile(srcStat, src, dest, opts) {
+		if (opts.overwrite) {
+			fs.unlinkSync(dest);
+			return copyFile(srcStat, src, dest, opts);
+		} else if (opts.errorOnExist) throw new Error(`'${dest}' already exists`);
+	}
+	function copyFile(srcStat, src, dest, opts) {
+		fs.copyFileSync(src, dest);
+		if (opts.preserveTimestamps) handleTimestamps(srcStat.mode, src, dest);
+		return setDestMode(dest, srcStat.mode);
+	}
+	function handleTimestamps(srcMode, src, dest) {
+		if (fileIsNotWritable(srcMode)) makeFileWritable(dest, srcMode);
+		return setDestTimestamps(src, dest);
+	}
+	function fileIsNotWritable(srcMode) {
+		return (srcMode & 128) === 0;
+	}
+	function makeFileWritable(dest, srcMode) {
+		return setDestMode(dest, srcMode | 128);
+	}
+	function setDestMode(dest, srcMode) {
+		return fs.chmodSync(dest, srcMode);
+	}
+	function setDestTimestamps(src, dest) {
+		const updatedSrcStat = fs.statSync(src);
+		return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
+	}
+	function onDir(srcStat, destStat, src, dest, opts) {
+		if (!destStat) return mkDirAndCopy(srcStat.mode, src, dest, opts);
+		return copyDir(src, dest, opts);
+	}
+	function mkDirAndCopy(srcMode, src, dest, opts) {
+		fs.mkdirSync(dest);
+		copyDir(src, dest, opts);
+		return setDestMode(dest, srcMode);
+	}
+	function copyDir(src, dest, opts) {
+		const dir = fs.opendirSync(src);
+		try {
+			let dirent;
+			while ((dirent = dir.readSync()) !== null) copyDirItem(dirent.name, src, dest, opts);
+		} finally {
+			dir.closeSync();
+		}
+	}
+	function copyDirItem(item, src, dest, opts) {
+		const srcItem = path$8.join(src, item);
+		const destItem = path$8.join(dest, item);
+		if (opts.filter && !opts.filter(srcItem, destItem)) return;
+		const { destStat } = stat.checkPathsSync(srcItem, destItem, "copy", opts);
+		return getStats(destStat, srcItem, destItem, opts);
+	}
+	function onLink(destStat, src, dest, opts) {
+		let resolvedSrc = fs.readlinkSync(src);
+		if (opts.dereference) resolvedSrc = path$8.resolve(process.cwd(), resolvedSrc);
+		if (!destStat) return fs.symlinkSync(resolvedSrc, dest);
+		else {
+			let resolvedDest;
+			try {
+				resolvedDest = fs.readlinkSync(dest);
+			} catch (err) {
+				if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs.symlinkSync(resolvedSrc, dest);
+				throw err;
+			}
+			if (opts.dereference) resolvedDest = path$8.resolve(process.cwd(), resolvedDest);
+			if (resolvedSrc !== resolvedDest) {
+				if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
+				if (stat.isSrcSubdir(resolvedDest, resolvedSrc)) throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
+			}
+			return copyLink(resolvedSrc, dest);
+		}
+	}
+	function copyLink(resolvedSrc, dest) {
+		fs.unlinkSync(dest);
+		return fs.symlinkSync(resolvedSrc, dest);
+	}
+	module.exports = copySync;
+}));
+
+//#endregion
+//#region ../../node_modules/fs-extra/lib/copy/index.js
+var require_copy = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const u = require_universalify().fromPromise;
+	module.exports = {
+		copy: u(require_copy$1()),
+		copySync: require_copy_sync()
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/fs-extra/lib/remove/index.js
+var require_remove = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fs = require_graceful_fs();
+	const u = require_universalify().fromCallback;
+	function remove(path, callback) {
+		fs.rm(path, {
+			recursive: true,
+			force: true
+		}, callback);
+	}
+	function removeSync(path) {
+		fs.rmSync(path, {
+			recursive: true,
+			force: true
+		});
+	}
+	module.exports = {
+		remove: u(remove),
+		removeSync
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/fs-extra/lib/empty/index.js
+var require_empty = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const u = require_universalify().fromPromise;
+	const fs = require_fs();
+	const path$7 = require("path");
+	const mkdir = require_mkdirs();
+	const remove = require_remove();
+	const emptyDir = u(async function emptyDir(dir) {
+		let items;
+		try {
+			items = await fs.readdir(dir);
+		} catch {
+			return mkdir.mkdirs(dir);
+		}
+		return Promise.all(items.map((item) => remove.remove(path$7.join(dir, item))));
+	});
+	function emptyDirSync(dir) {
+		let items;
+		try {
+			items = fs.readdirSync(dir);
+		} catch {
+			return mkdir.mkdirsSync(dir);
+		}
+		items.forEach((item) => {
+			item = path$7.join(dir, item);
+			remove.removeSync(item);
+		});
+	}
+	module.exports = {
+		emptyDirSync,
+		emptydirSync: emptyDirSync,
+		emptyDir,
+		emptydir: emptyDir
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/fs-extra/lib/ensure/file.js
+var require_file = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const u = require_universalify().fromPromise;
+	const path$6 = require("path");
+	const fs = require_fs();
+	const mkdir = require_mkdirs();
+	async function createFile(file) {
+		let stats;
+		try {
+			stats = await fs.stat(file);
+		} catch {}
+		if (stats && stats.isFile()) return;
+		const dir = path$6.dirname(file);
+		let dirStats = null;
+		try {
+			dirStats = await fs.stat(dir);
+		} catch (err) {
+			if (err.code === "ENOENT") {
+				await mkdir.mkdirs(dir);
+				await fs.writeFile(file, "");
+				return;
+			} else throw err;
+		}
+		if (dirStats.isDirectory()) await fs.writeFile(file, "");
+		else await fs.readdir(dir);
+	}
+	function createFileSync(file) {
+		let stats;
+		try {
+			stats = fs.statSync(file);
+		} catch {}
+		if (stats && stats.isFile()) return;
+		const dir = path$6.dirname(file);
+		try {
+			if (!fs.statSync(dir).isDirectory()) fs.readdirSync(dir);
+		} catch (err) {
+			if (err && err.code === "ENOENT") mkdir.mkdirsSync(dir);
+			else throw err;
+		}
+		fs.writeFileSync(file, "");
+	}
+	module.exports = {
+		createFile: u(createFile),
+		createFileSync
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/fs-extra/lib/ensure/link.js
+var require_link = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const u = require_universalify().fromPromise;
+	const path$5 = require("path");
+	const fs = require_fs();
+	const mkdir = require_mkdirs();
+	const { pathExists } = require_path_exists();
+	const { areIdentical } = require_stat();
+	async function createLink(srcpath, dstpath) {
+		let dstStat;
+		try {
+			dstStat = await fs.lstat(dstpath);
+		} catch {}
+		let srcStat;
+		try {
+			srcStat = await fs.lstat(srcpath);
+		} catch (err) {
+			err.message = err.message.replace("lstat", "ensureLink");
+			throw err;
+		}
+		if (dstStat && areIdentical(srcStat, dstStat)) return;
+		const dir = path$5.dirname(dstpath);
+		if (!await pathExists(dir)) await mkdir.mkdirs(dir);
+		await fs.link(srcpath, dstpath);
+	}
+	function createLinkSync(srcpath, dstpath) {
+		let dstStat;
+		try {
+			dstStat = fs.lstatSync(dstpath);
+		} catch {}
+		try {
+			const srcStat = fs.lstatSync(srcpath);
+			if (dstStat && areIdentical(srcStat, dstStat)) return;
+		} catch (err) {
+			err.message = err.message.replace("lstat", "ensureLink");
+			throw err;
+		}
+		const dir = path$5.dirname(dstpath);
+		if (fs.existsSync(dir)) return fs.linkSync(srcpath, dstpath);
+		mkdir.mkdirsSync(dir);
+		return fs.linkSync(srcpath, dstpath);
+	}
+	module.exports = {
+		createLink: u(createLink),
+		createLinkSync
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/fs-extra/lib/ensure/symlink-paths.js
+var require_symlink_paths = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const path$4 = require("path");
+	const fs = require_fs();
+	const { pathExists } = require_path_exists();
+	const u = require_universalify().fromPromise;
+	/**
+	* Function that returns two types of paths, one relative to symlink, and one
+	* relative to the current working directory. Checks if path is absolute or
+	* relative. If the path is relative, this function checks if the path is
+	* relative to symlink or relative to current working directory. This is an
+	* initiative to find a smarter `srcpath` to supply when building symlinks.
+	* This allows you to determine which path to use out of one of three possible
+	* types of source paths. The first is an absolute path. This is detected by
+	* `path.isAbsolute()`. When an absolute path is provided, it is checked to
+	* see if it exists. If it does it's used, if not an error is returned
+	* (callback)/ thrown (sync). The other two options for `srcpath` are a
+	* relative url. By default Node's `fs.symlink` works by creating a symlink
+	* using `dstpath` and expects the `srcpath` to be relative to the newly
+	* created symlink. If you provide a `srcpath` that does not exist on the file
+	* system it results in a broken symlink. To minimize this, the function
+	* checks to see if the 'relative to symlink' source file exists, and if it
+	* does it will use it. If it does not, it checks if there's a file that
+	* exists that is relative to the current working directory, if does its used.
+	* This preserves the expectations of the original fs.symlink spec and adds
+	* the ability to pass in `relative to current working direcotry` paths.
+	*/
+	async function symlinkPaths(srcpath, dstpath) {
+		if (path$4.isAbsolute(srcpath)) {
+			try {
+				await fs.lstat(srcpath);
+			} catch (err) {
+				err.message = err.message.replace("lstat", "ensureSymlink");
+				throw err;
+			}
+			return {
+				toCwd: srcpath,
+				toDst: srcpath
+			};
+		}
+		const dstdir = path$4.dirname(dstpath);
+		const relativeToDst = path$4.join(dstdir, srcpath);
+		if (await pathExists(relativeToDst)) return {
+			toCwd: relativeToDst,
+			toDst: srcpath
+		};
+		try {
+			await fs.lstat(srcpath);
+		} catch (err) {
+			err.message = err.message.replace("lstat", "ensureSymlink");
+			throw err;
+		}
+		return {
+			toCwd: srcpath,
+			toDst: path$4.relative(dstdir, srcpath)
+		};
+	}
+	function symlinkPathsSync(srcpath, dstpath) {
+		if (path$4.isAbsolute(srcpath)) {
+			if (!fs.existsSync(srcpath)) throw new Error("absolute srcpath does not exist");
+			return {
+				toCwd: srcpath,
+				toDst: srcpath
+			};
+		}
+		const dstdir = path$4.dirname(dstpath);
+		const relativeToDst = path$4.join(dstdir, srcpath);
+		if (fs.existsSync(relativeToDst)) return {
+			toCwd: relativeToDst,
+			toDst: srcpath
+		};
+		if (!fs.existsSync(srcpath)) throw new Error("relative srcpath does not exist");
+		return {
+			toCwd: srcpath,
+			toDst: path$4.relative(dstdir, srcpath)
+		};
+	}
+	module.exports = {
+		symlinkPaths: u(symlinkPaths),
+		symlinkPathsSync
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/fs-extra/lib/ensure/symlink-type.js
+var require_symlink_type = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fs = require_fs();
+	const u = require_universalify().fromPromise;
+	async function symlinkType(srcpath, type) {
+		if (type) return type;
+		let stats;
+		try {
+			stats = await fs.lstat(srcpath);
+		} catch {
+			return "file";
+		}
+		return stats && stats.isDirectory() ? "dir" : "file";
+	}
+	function symlinkTypeSync(srcpath, type) {
+		if (type) return type;
+		let stats;
+		try {
+			stats = fs.lstatSync(srcpath);
+		} catch {
+			return "file";
+		}
+		return stats && stats.isDirectory() ? "dir" : "file";
+	}
+	module.exports = {
+		symlinkType: u(symlinkType),
+		symlinkTypeSync
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/fs-extra/lib/ensure/symlink.js
+var require_symlink = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const u = require_universalify().fromPromise;
+	const path$3 = require("path");
+	const fs = require_fs();
+	const { mkdirs, mkdirsSync } = require_mkdirs();
+	const { symlinkPaths, symlinkPathsSync } = require_symlink_paths();
+	const { symlinkType, symlinkTypeSync } = require_symlink_type();
+	const { pathExists } = require_path_exists();
+	const { areIdentical } = require_stat();
+	async function createSymlink(srcpath, dstpath, type) {
+		let stats;
+		try {
+			stats = await fs.lstat(dstpath);
+		} catch {}
+		if (stats && stats.isSymbolicLink()) {
+			const [srcStat, dstStat] = await Promise.all([fs.stat(srcpath), fs.stat(dstpath)]);
+			if (areIdentical(srcStat, dstStat)) return;
+		}
+		const relative = await symlinkPaths(srcpath, dstpath);
+		srcpath = relative.toDst;
+		const toType = await symlinkType(relative.toCwd, type);
+		const dir = path$3.dirname(dstpath);
+		if (!await pathExists(dir)) await mkdirs(dir);
+		return fs.symlink(srcpath, dstpath, toType);
+	}
+	function createSymlinkSync(srcpath, dstpath, type) {
+		let stats;
+		try {
+			stats = fs.lstatSync(dstpath);
+		} catch {}
+		if (stats && stats.isSymbolicLink()) {
+			if (areIdentical(fs.statSync(srcpath), fs.statSync(dstpath))) return;
+		}
+		const relative = symlinkPathsSync(srcpath, dstpath);
+		srcpath = relative.toDst;
+		type = symlinkTypeSync(relative.toCwd, type);
+		const dir = path$3.dirname(dstpath);
+		if (fs.existsSync(dir)) return fs.symlinkSync(srcpath, dstpath, type);
+		mkdirsSync(dir);
+		return fs.symlinkSync(srcpath, dstpath, type);
+	}
+	module.exports = {
+		createSymlink: u(createSymlink),
+		createSymlinkSync
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/fs-extra/lib/ensure/index.js
+var require_ensure = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const { createFile, createFileSync } = require_file();
+	const { createLink, createLinkSync } = require_link();
+	const { createSymlink, createSymlinkSync } = require_symlink();
+	module.exports = {
+		createFile,
+		createFileSync,
+		ensureFile: createFile,
+		ensureFileSync: createFileSync,
+		createLink,
+		createLinkSync,
+		ensureLink: createLink,
+		ensureLinkSync: createLinkSync,
+		createSymlink,
+		createSymlinkSync,
+		ensureSymlink: createSymlink,
+		ensureSymlinkSync: createSymlinkSync
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/jsonfile/utils.js
+var require_utils = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function stringify(obj, { EOL = "\n", finalEOL = true, replacer = null, spaces } = {}) {
+		const EOF = finalEOL ? EOL : "";
+		return JSON.stringify(obj, replacer, spaces).replace(/\n/g, EOL) + EOF;
+	}
+	function stripBom(content) {
+		if (Buffer.isBuffer(content)) content = content.toString("utf8");
+		return content.replace(/^\uFEFF/, "");
+	}
+	module.exports = {
+		stringify,
+		stripBom
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/jsonfile/index.js
+var require_jsonfile$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	let _fs;
+	try {
+		_fs = require_graceful_fs();
+	} catch (_) {
+		_fs = require("fs");
+	}
+	const universalify = require_universalify();
+	const { stringify, stripBom } = require_utils();
+	async function _readFile(file, options = {}) {
+		if (typeof options === "string") options = { encoding: options };
+		const fs = options.fs || _fs;
+		const shouldThrow = "throws" in options ? options.throws : true;
+		let data = await universalify.fromCallback(fs.readFile)(file, options);
+		data = stripBom(data);
+		let obj;
+		try {
+			obj = JSON.parse(data, options ? options.reviver : null);
+		} catch (err) {
+			if (shouldThrow) {
+				err.message = `${file}: ${err.message}`;
+				throw err;
+			} else return null;
+		}
+		return obj;
+	}
+	const readFile = universalify.fromPromise(_readFile);
+	function readFileSync(file, options = {}) {
+		if (typeof options === "string") options = { encoding: options };
+		const fs = options.fs || _fs;
+		const shouldThrow = "throws" in options ? options.throws : true;
+		try {
+			let content = fs.readFileSync(file, options);
+			content = stripBom(content);
+			return JSON.parse(content, options.reviver);
+		} catch (err) {
+			if (shouldThrow) {
+				err.message = `${file}: ${err.message}`;
+				throw err;
+			} else return null;
+		}
+	}
+	async function _writeFile(file, obj, options = {}) {
+		const fs = options.fs || _fs;
+		const str = stringify(obj, options);
+		await universalify.fromCallback(fs.writeFile)(file, str, options);
+	}
+	const writeFile = universalify.fromPromise(_writeFile);
+	function writeFileSync(file, obj, options = {}) {
+		const fs = options.fs || _fs;
+		const str = stringify(obj, options);
+		return fs.writeFileSync(file, str, options);
+	}
+	module.exports = {
+		readFile,
+		readFileSync,
+		writeFile,
+		writeFileSync
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/fs-extra/lib/json/jsonfile.js
+var require_jsonfile = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const jsonFile = require_jsonfile$1();
+	module.exports = {
+		readJson: jsonFile.readFile,
+		readJsonSync: jsonFile.readFileSync,
+		writeJson: jsonFile.writeFile,
+		writeJsonSync: jsonFile.writeFileSync
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/fs-extra/lib/output-file/index.js
+var require_output_file = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const u = require_universalify().fromPromise;
+	const fs = require_fs();
+	const path$2 = require("path");
+	const mkdir = require_mkdirs();
+	const pathExists = require_path_exists().pathExists;
+	async function outputFile(file, data, encoding = "utf-8") {
+		const dir = path$2.dirname(file);
+		if (!await pathExists(dir)) await mkdir.mkdirs(dir);
+		return fs.writeFile(file, data, encoding);
+	}
+	function outputFileSync(file, ...args) {
+		const dir = path$2.dirname(file);
+		if (!fs.existsSync(dir)) mkdir.mkdirsSync(dir);
+		fs.writeFileSync(file, ...args);
+	}
+	module.exports = {
+		outputFile: u(outputFile),
+		outputFileSync
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/fs-extra/lib/json/output-json.js
+var require_output_json = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const { stringify } = require_utils();
+	const { outputFile } = require_output_file();
+	async function outputJson(file, data, options = {}) {
+		await outputFile(file, stringify(data, options), options);
+	}
+	module.exports = outputJson;
+}));
+
+//#endregion
+//#region ../../node_modules/fs-extra/lib/json/output-json-sync.js
+var require_output_json_sync = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const { stringify } = require_utils();
+	const { outputFileSync } = require_output_file();
+	function outputJsonSync(file, data, options) {
+		outputFileSync(file, stringify(data, options), options);
+	}
+	module.exports = outputJsonSync;
+}));
+
+//#endregion
+//#region ../../node_modules/fs-extra/lib/json/index.js
+var require_json = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const u = require_universalify().fromPromise;
+	const jsonFile = require_jsonfile();
+	jsonFile.outputJson = u(require_output_json());
+	jsonFile.outputJsonSync = require_output_json_sync();
+	jsonFile.outputJSON = jsonFile.outputJson;
+	jsonFile.outputJSONSync = jsonFile.outputJsonSync;
+	jsonFile.writeJSON = jsonFile.writeJson;
+	jsonFile.writeJSONSync = jsonFile.writeJsonSync;
+	jsonFile.readJSON = jsonFile.readJson;
+	jsonFile.readJSONSync = jsonFile.readJsonSync;
+	module.exports = jsonFile;
+}));
+
+//#endregion
+//#region ../../node_modules/fs-extra/lib/move/move.js
+var require_move$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fs = require_fs();
+	const path$1 = require("path");
+	const { copy } = require_copy();
+	const { remove } = require_remove();
+	const { mkdirp } = require_mkdirs();
+	const { pathExists } = require_path_exists();
+	const stat = require_stat();
+	async function move(src, dest, opts = {}) {
+		const overwrite = opts.overwrite || opts.clobber || false;
+		const { srcStat, isChangingCase = false } = await stat.checkPaths(src, dest, "move", opts);
+		await stat.checkParentPaths(src, srcStat, dest, "move");
+		const destParent = path$1.dirname(dest);
+		if (path$1.parse(destParent).root !== destParent) await mkdirp(destParent);
+		return doRename(src, dest, overwrite, isChangingCase);
+	}
+	async function doRename(src, dest, overwrite, isChangingCase) {
+		if (!isChangingCase) {
+			if (overwrite) await remove(dest);
+			else if (await pathExists(dest)) throw new Error("dest already exists.");
+		}
+		try {
+			await fs.rename(src, dest);
+		} catch (err) {
+			if (err.code !== "EXDEV") throw err;
+			await moveAcrossDevice(src, dest, overwrite);
+		}
+	}
+	async function moveAcrossDevice(src, dest, overwrite) {
+		await copy(src, dest, {
+			overwrite,
+			errorOnExist: true,
+			preserveTimestamps: true
+		});
+		return remove(src);
+	}
+	module.exports = move;
+}));
+
+//#endregion
+//#region ../../node_modules/fs-extra/lib/move/move-sync.js
+var require_move_sync = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fs = require_graceful_fs();
+	const path = require("path");
+	const copySync = require_copy().copySync;
+	const removeSync = require_remove().removeSync;
+	const mkdirpSync = require_mkdirs().mkdirpSync;
+	const stat = require_stat();
+	function moveSync(src, dest, opts) {
+		opts = opts || {};
+		const overwrite = opts.overwrite || opts.clobber || false;
+		const { srcStat, isChangingCase = false } = stat.checkPathsSync(src, dest, "move", opts);
+		stat.checkParentPathsSync(src, srcStat, dest, "move");
+		if (!isParentRoot(dest)) mkdirpSync(path.dirname(dest));
+		return doRename(src, dest, overwrite, isChangingCase);
+	}
+	function isParentRoot(dest) {
+		const parent = path.dirname(dest);
+		return path.parse(parent).root === parent;
+	}
+	function doRename(src, dest, overwrite, isChangingCase) {
+		if (isChangingCase) return rename(src, dest, overwrite);
+		if (overwrite) {
+			removeSync(dest);
+			return rename(src, dest, overwrite);
+		}
+		if (fs.existsSync(dest)) throw new Error("dest already exists.");
+		return rename(src, dest, overwrite);
+	}
+	function rename(src, dest, overwrite) {
+		try {
+			fs.renameSync(src, dest);
+		} catch (err) {
+			if (err.code !== "EXDEV") throw err;
+			return moveAcrossDevice(src, dest, overwrite);
+		}
+	}
+	function moveAcrossDevice(src, dest, overwrite) {
+		copySync(src, dest, {
+			overwrite,
+			errorOnExist: true,
+			preserveTimestamps: true
+		});
+		return removeSync(src);
+	}
+	module.exports = moveSync;
+}));
+
+//#endregion
+//#region ../../node_modules/fs-extra/lib/move/index.js
+var require_move = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const u = require_universalify().fromPromise;
+	module.exports = {
+		move: u(require_move$1()),
+		moveSync: require_move_sync()
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/fs-extra/lib/index.js
+var require_lib$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = {
+		...require_fs(),
+		...require_copy(),
+		...require_empty(),
+		...require_ensure(),
+		...require_json(),
+		...require_mkdirs(),
+		...require_move(),
+		...require_output_file(),
+		...require_path_exists(),
+		...require_remove()
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/chalk/source/vendor/ansi-styles/index.js
+var import_lib = /* @__PURE__ */ __toESM(require_lib$1());
 const ANSI_BACKGROUND_OFFSET = 10;
 const wrapAnsi16 = (offset = 0) => (code) => `\u001B[${code + offset}m`;
 const wrapAnsi256 = (offset = 0) => (code) => `\u001B[${38 + offset};5;${code}m`;
@@ -211,7 +2137,7 @@ function assembleStyles() {
 const ansiStyles = assembleStyles();
 
 //#endregion
-//#region ../../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/vendor/supports-color/index.js
+//#region ../../node_modules/chalk/source/vendor/supports-color/index.js
 function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : node_process.default.argv) {
 	const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
 	const position = argv.indexOf(prefix + flag);
@@ -300,7 +2226,7 @@ const supportsColor = {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/utilities.js
+//#region ../../node_modules/chalk/source/utilities.js
 function stringReplaceAll(string, substring, replacer) {
 	let index = string.indexOf(substring);
 	if (index === -1) return string;
@@ -329,7 +2255,7 @@ function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/index.js
+//#region ../../node_modules/chalk/source/index.js
 const { stdout: stdoutColor, stderr: stderrColor } = supportsColor;
 const GENERATOR = Symbol("GENERATOR");
 const STYLER = Symbol("STYLER");
@@ -452,7 +2378,7 @@ const chalk = createChalk();
 const chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
 
 //#endregion
-//#region ../../node_modules/.pnpm/mimic-function@5.0.1/node_modules/mimic-function/index.js
+//#region ../../node_modules/mimic-function/index.js
 const copyProperty = (to, from, property, ignoreNonConfigurable) => {
 	if (property === "length" || property === "prototype") return;
 	if (property === "arguments" || property === "caller") return;
@@ -493,7 +2419,7 @@ function mimicFunction(to, from, { ignoreNonConfigurable = false } = {}) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/onetime@7.0.0/node_modules/onetime/index.js
+//#region ../../node_modules/restore-cursor/node_modules/onetime/index.js
 const calledFunctions = /* @__PURE__ */ new WeakMap();
 const onetime = (function_, options = {}) => {
 	if (typeof function_ !== "function") throw new TypeError("Expected a function");
@@ -518,7 +2444,7 @@ onetime.callCount = (function_) => {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/signal-exit@4.1.0/node_modules/signal-exit/dist/mjs/signals.js
+//#region ../../node_modules/restore-cursor/node_modules/signal-exit/dist/mjs/signals.js
 /**
 * This is not the set of all possible signals.
 *
@@ -545,18 +2471,18 @@ onetime.callCount = (function_) => {
 * state from which it is not safe to try and enter JS
 * listeners.
 */
-const signals = [];
-signals.push("SIGHUP", "SIGINT", "SIGTERM");
-if (process.platform !== "win32") signals.push("SIGALRM", "SIGABRT", "SIGVTALRM", "SIGXCPU", "SIGXFSZ", "SIGUSR2", "SIGTRAP", "SIGSYS", "SIGQUIT", "SIGIOT");
-if (process.platform === "linux") signals.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT");
+const signals$1 = [];
+signals$1.push("SIGHUP", "SIGINT", "SIGTERM");
+if (process.platform !== "win32") signals$1.push("SIGALRM", "SIGABRT", "SIGVTALRM", "SIGXCPU", "SIGXFSZ", "SIGUSR2", "SIGTRAP", "SIGSYS", "SIGQUIT", "SIGIOT");
+if (process.platform === "linux") signals$1.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT");
 
 //#endregion
-//#region ../../node_modules/.pnpm/signal-exit@4.1.0/node_modules/signal-exit/dist/mjs/index.js
-const processOk = (process) => !!process && typeof process === "object" && typeof process.removeListener === "function" && typeof process.emit === "function" && typeof process.reallyExit === "function" && typeof process.listeners === "function" && typeof process.kill === "function" && typeof process.pid === "number" && typeof process.on === "function";
-const kExitEmitter = Symbol.for("signal-exit emitter");
-const global = globalThis;
-const ObjectDefineProperty = Object.defineProperty.bind(Object);
-var Emitter = class {
+//#region ../../node_modules/restore-cursor/node_modules/signal-exit/dist/mjs/index.js
+const processOk$1 = (process) => !!process && typeof process === "object" && typeof process.removeListener === "function" && typeof process.emit === "function" && typeof process.reallyExit === "function" && typeof process.listeners === "function" && typeof process.kill === "function" && typeof process.pid === "number" && typeof process.on === "function";
+const kExitEmitter$1 = Symbol.for("signal-exit emitter");
+const global$2 = globalThis;
+const ObjectDefineProperty$1 = Object.defineProperty.bind(Object);
+var Emitter$1 = class {
 	emitted = {
 		afterExit: false,
 		exit: false
@@ -568,8 +2494,8 @@ var Emitter = class {
 	count = 0;
 	id = Math.random();
 	constructor() {
-		if (global[kExitEmitter]) return global[kExitEmitter];
-		ObjectDefineProperty(global, kExitEmitter, {
+		if (global$2[kExitEmitter$1]) return global$2[kExitEmitter$1];
+		ObjectDefineProperty$1(global$2, kExitEmitter$1, {
 			value: this,
 			writable: false,
 			enumerable: false,
@@ -597,8 +2523,8 @@ var Emitter = class {
 		return ret;
 	}
 };
-var SignalExitBase = class {};
-const signalExitWrap = (handler) => {
+var SignalExitBase$1 = class {};
+const signalExitWrap$1 = (handler) => {
 	return {
 		onExit(cb, opts) {
 			return handler.onExit(cb, opts);
@@ -611,18 +2537,18 @@ const signalExitWrap = (handler) => {
 		}
 	};
 };
-var SignalExitFallback = class extends SignalExitBase {
+var SignalExitFallback$1 = class extends SignalExitBase$1 {
 	onExit() {
 		return () => {};
 	}
 	load() {}
 	unload() {}
 };
-var SignalExit = class extends SignalExitBase {
+var SignalExit$1 = class extends SignalExitBase$1 {
 	/* c8 ignore start */
-	#hupSig = process$7.platform === "win32" ? "SIGINT" : "SIGHUP";
+	#hupSig = process$8.platform === "win32" ? "SIGINT" : "SIGHUP";
 	/* c8 ignore stop */
-	#emitter = new Emitter();
+	#emitter = new Emitter$1();
 	#process;
 	#originalProcessEmit;
 	#originalProcessReallyExit;
@@ -632,7 +2558,7 @@ var SignalExit = class extends SignalExitBase {
 		super();
 		this.#process = process;
 		this.#sigListeners = {};
-		for (const sig of signals) this.#sigListeners[sig] = () => {
+		for (const sig of signals$1) this.#sigListeners[sig] = () => {
 			const listeners = this.#process.listeners(sig);
 			let { count } = this.#emitter;
 			/* c8 ignore start */
@@ -652,7 +2578,7 @@ var SignalExit = class extends SignalExitBase {
 	}
 	onExit(cb, opts) {
 		/* c8 ignore start */
-		if (!processOk(this.#process)) return () => {};
+		if (!processOk$1(this.#process)) return () => {};
 		/* c8 ignore stop */
 		if (this.#loaded === false) this.load();
 		const ev = opts?.alwaysLast ? "afterExit" : "exit";
@@ -666,7 +2592,7 @@ var SignalExit = class extends SignalExitBase {
 		if (this.#loaded) return;
 		this.#loaded = true;
 		this.#emitter.count += 1;
-		for (const sig of signals) try {
+		for (const sig of signals$1) try {
 			const fn = this.#sigListeners[sig];
 			if (fn) this.#process.on(sig, fn);
 		} catch (_) {}
@@ -680,7 +2606,7 @@ var SignalExit = class extends SignalExitBase {
 	unload() {
 		if (!this.#loaded) return;
 		this.#loaded = false;
-		signals.forEach((sig) => {
+		signals$1.forEach((sig) => {
 			const listener = this.#sigListeners[sig];
 			/* c8 ignore start */
 			if (!listener) throw new Error("Listener not defined for signal: " + sig);
@@ -696,7 +2622,7 @@ var SignalExit = class extends SignalExitBase {
 	}
 	#processReallyExit(code) {
 		/* c8 ignore start */
-		if (!processOk(this.#process)) return 0;
+		if (!processOk$1(this.#process)) return 0;
 		this.#process.exitCode = code || 0;
 		/* c8 ignore stop */
 		this.#emitter.emit("exit", this.#process.exitCode, null);
@@ -704,7 +2630,7 @@ var SignalExit = class extends SignalExitBase {
 	}
 	#processEmit(ev, ...args) {
 		const og = this.#originalProcessEmit;
-		if (ev === "exit" && processOk(this.#process)) {
+		if (ev === "exit" && processOk$1(this.#process)) {
 			if (typeof args[0] === "number") this.#process.exitCode = args[0];
 			/* c8 ignore start */
 			const ret = og.call(this.#process, ev, ...args);
@@ -715,20 +2641,20 @@ var SignalExit = class extends SignalExitBase {
 		} else return og.call(this.#process, ev, ...args);
 	}
 };
-const process$7 = globalThis.process;
-const { onExit, load, unload } = signalExitWrap(processOk(process$7) ? new SignalExit(process$7) : new SignalExitFallback());
+const process$8 = globalThis.process;
+const { onExit: onExit$1, load: load$1, unload: unload$1 } = signalExitWrap$1(processOk$1(process$8) ? new SignalExit$1(process$8) : new SignalExitFallback$1());
 
 //#endregion
-//#region ../../node_modules/.pnpm/restore-cursor@5.1.0/node_modules/restore-cursor/index.js
+//#region ../../node_modules/restore-cursor/index.js
 const terminal = node_process.default.stderr.isTTY ? node_process.default.stderr : node_process.default.stdout.isTTY ? node_process.default.stdout : void 0;
 const restoreCursor = terminal ? onetime(() => {
-	onExit(() => {
+	onExit$1(() => {
 		terminal.write("\x1B[?25h");
 	}, { alwaysLast: true });
 }) : () => {};
 
 //#endregion
-//#region ../../node_modules/.pnpm/cli-cursor@5.0.0/node_modules/cli-cursor/index.js
+//#region ../../node_modules/cli-cursor/index.js
 let isHidden = false;
 const cliCursor = {};
 cliCursor.show = (writableStream = node_process.default.stderr) => {
@@ -749,7 +2675,7 @@ cliCursor.toggle = (force, writableStream) => {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/cli-spinners@3.4.0/node_modules/cli-spinners/spinners.json
+//#region ../../node_modules/cli-spinners/spinners.json
 var spinners_default = {
 	dots: {
 		"interval": 80,
@@ -2407,12 +4333,12 @@ var spinners_default = {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/cli-spinners@3.4.0/node_modules/cli-spinners/index.js
+//#region ../../node_modules/cli-spinners/index.js
 var cli_spinners_default = spinners_default;
 const spinnersList = Object.keys(spinners_default);
 
 //#endregion
-//#region ../../node_modules/.pnpm/yoctocolors@2.1.2/node_modules/yoctocolors/base.js
+//#region ../../node_modules/yoctocolors/base.js
 const hasColors = node_tty.default?.WriteStream?.prototype?.hasColors?.() ?? false;
 const format = (open, close) => {
 	if (!hasColors) return (input) => input;
@@ -2477,7 +4403,7 @@ const bgCyanBright = format(106, 49);
 const bgWhiteBright = format(107, 49);
 
 //#endregion
-//#region ../../node_modules/.pnpm/is-unicode-supported@2.1.0/node_modules/is-unicode-supported/index.js
+//#region ../../node_modules/is-unicode-supported/index.js
 function isUnicodeSupported$1() {
 	const { env } = node_process.default;
 	const { TERM, TERM_PROGRAM } = env;
@@ -2486,7 +4412,7 @@ function isUnicodeSupported$1() {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/log-symbols@7.0.1/node_modules/log-symbols/symbols.js
+//#region ../../node_modules/log-symbols/symbols.js
 const _isUnicodeSupported = isUnicodeSupported$1();
 const info = blue(_isUnicodeSupported ? "ℹ" : "i");
 const success = green(_isUnicodeSupported ? "✔" : "√");
@@ -2494,13 +4420,13 @@ const warning = yellow(_isUnicodeSupported ? "⚠" : "‼");
 const error = red(_isUnicodeSupported ? "✖" : "×");
 
 //#endregion
-//#region ../../node_modules/.pnpm/ansi-regex@6.2.2/node_modules/ansi-regex/index.js
+//#region ../../node_modules/ansi-regex/index.js
 function ansiRegex({ onlyFirst = false } = {}) {
 	return new RegExp(`(?:\\u001B\\][\\s\\S]*?(?:\\u0007|\\u001B\\u005C|\\u009C))|[\\u001B\\u009B][[\\]()#;?]*(?:\\d{1,4}(?:[;:]\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]`, onlyFirst ? void 0 : "g");
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/strip-ansi@7.1.2/node_modules/strip-ansi/index.js
+//#region ../../node_modules/ora/node_modules/strip-ansi/index.js
 const regex = ansiRegex();
 function stripAnsi(string) {
 	if (typeof string !== "string") throw new TypeError(`Expected a \`string\`, got \`${typeof string}\``);
@@ -2508,7 +4434,7 @@ function stripAnsi(string) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/get-east-asian-width@1.5.0/node_modules/get-east-asian-width/lookup-data.js
+//#region ../../node_modules/get-east-asian-width/lookup-data.js
 const ambiguousRanges = [
 	161,
 	161,
@@ -3157,7 +5083,7 @@ const wideRanges = [
 ];
 
 //#endregion
-//#region ../../node_modules/.pnpm/get-east-asian-width@1.5.0/node_modules/get-east-asian-width/utilities.js
+//#region ../../node_modules/get-east-asian-width/utilities.js
 /**
 Binary search on a sorted flat array of [start, end] pairs.
 
@@ -3179,7 +5105,7 @@ const isInRange = (ranges, codePoint) => {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/get-east-asian-width@1.5.0/node_modules/get-east-asian-width/lookup.js
+//#region ../../node_modules/get-east-asian-width/lookup.js
 const minimumAmbiguousCodePoint = ambiguousRanges[0];
 const maximumAmbiguousCodePoint = ambiguousRanges.at(-1);
 const minimumFullWidthCodePoint = fullwidthRanges[0];
@@ -3221,7 +5147,7 @@ const isWide = (codePoint) => {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/get-east-asian-width@1.5.0/node_modules/get-east-asian-width/index.js
+//#region ../../node_modules/get-east-asian-width/index.js
 function validate(codePoint) {
 	if (!Number.isSafeInteger(codePoint)) throw new TypeError(`Expected a code point, got \`${typeof codePoint}\`.`);
 }
@@ -3232,7 +5158,7 @@ function eastAsianWidth(codePoint, { ambiguousAsWide = false } = {}) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/string-width@8.2.0/node_modules/string-width/index.js
+//#region ../../node_modules/ora/node_modules/string-width/index.js
 /**
 Logic:
 - Segment graphemes to match how terminals render clusters.
@@ -3293,13 +5219,13 @@ function stringWidth(input, options = {}) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/is-interactive@2.0.0/node_modules/is-interactive/index.js
+//#region ../../node_modules/is-interactive/index.js
 function isInteractive({ stream = process.stdout } = {}) {
 	return Boolean(stream && stream.isTTY && process.env.TERM !== "dumb" && !("CI" in process.env));
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/stdin-discarder@0.3.1/node_modules/stdin-discarder/index.js
+//#region ../../node_modules/stdin-discarder/index.js
 const ASCII_ETX_CODE = 3;
 var StdinDiscarder = class {
 	#activeCount = 0;
@@ -3347,7 +5273,7 @@ const stdinDiscarder = new StdinDiscarder();
 var stdin_discarder_default = Object.freeze(stdinDiscarder);
 
 //#endregion
-//#region ../../node_modules/.pnpm/ora@9.3.0/node_modules/ora/index.js
+//#region ../../node_modules/ora/index.js
 const RENDER_DEFERRAL_TIMEOUT = 200;
 const SYNCHRONIZED_OUTPUT_ENABLE = "\x1B[?2026h";
 const SYNCHRONIZED_OUTPUT_DISABLE = "\x1B[?2026l";
@@ -3716,7 +5642,7 @@ function ora(options) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/@inquirer+core@11.1.5_@types+node@25.3.0/node_modules/@inquirer/core/dist/lib/key.js
+//#region ../../node_modules/@inquirer/core/dist/lib/key.js
 const isUpKey = (key, keybindings = []) => key.name === "up" || keybindings.includes("vim") && key.name === "k" || keybindings.includes("emacs") && key.ctrl && key.name === "p";
 const isDownKey = (key, keybindings = []) => key.name === "down" || keybindings.includes("vim") && key.name === "j" || keybindings.includes("emacs") && key.ctrl && key.name === "n";
 const isSpaceKey = (key) => key.name === "space";
@@ -3726,7 +5652,7 @@ const isNumberKey = (key) => "1234567890".includes(key.name);
 const isEnterKey = (key) => key.name === "enter" || key.name === "return";
 
 //#endregion
-//#region ../../node_modules/.pnpm/@inquirer+core@11.1.5_@types+node@25.3.0/node_modules/@inquirer/core/dist/lib/errors.js
+//#region ../../node_modules/@inquirer/core/dist/lib/errors.js
 var AbortPromptError = class extends Error {
 	name = "AbortPromptError";
 	message = "Prompt was aborted";
@@ -3750,7 +5676,7 @@ var ValidationError = class extends Error {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/@inquirer+core@11.1.5_@types+node@25.3.0/node_modules/@inquirer/core/dist/lib/hook-engine.js
+//#region ../../node_modules/@inquirer/core/dist/lib/hook-engine.js
 const hookStorage = new node_async_hooks.AsyncLocalStorage();
 function createStore(rl) {
 	return {
@@ -3847,7 +5773,7 @@ const effectScheduler = {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/@inquirer+core@11.1.5_@types+node@25.3.0/node_modules/@inquirer/core/dist/lib/use-state.js
+//#region ../../node_modules/@inquirer/core/dist/lib/use-state.js
 function useState(defaultValue) {
 	return withPointer((pointer) => {
 		const setState = node_async_hooks.AsyncResource.bind(function setState(newValue) {
@@ -3864,7 +5790,7 @@ function useState(defaultValue) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/@inquirer+core@11.1.5_@types+node@25.3.0/node_modules/@inquirer/core/dist/lib/use-effect.js
+//#region ../../node_modules/@inquirer/core/dist/lib/use-effect.js
 function useEffect(cb, depArray) {
 	withPointer((pointer) => {
 		const oldDeps = pointer.get();
@@ -3874,7 +5800,7 @@ function useEffect(cb, depArray) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/@inquirer+figures@2.0.3/node_modules/@inquirer/figures/dist/index.js
+//#region ../../node_modules/@inquirer/figures/dist/index.js
 function isUnicodeSupported() {
 	if (node_process.default.platform !== "win32") return node_process.default.env["TERM"] !== "linux";
 	return Boolean(node_process.default.env["WT_SESSION"]) || Boolean(node_process.default.env["TERMINUS_SUBLIME"]) || node_process.default.env["ConEmuTask"] === "{cmd::Cmder}" || node_process.default.env["TERM_PROGRAM"] === "Terminus-Sublime" || node_process.default.env["TERM_PROGRAM"] === "vscode" || node_process.default.env["TERM"] === "xterm-256color" || node_process.default.env["TERM"] === "alacritty" || node_process.default.env["TERMINAL_EMULATOR"] === "JetBrains-JediTerm";
@@ -4160,7 +6086,7 @@ const figures = shouldUseMain ? mainSymbols : fallbackSymbols;
 const replacements = Object.entries(specialMainSymbols);
 
 //#endregion
-//#region ../../node_modules/.pnpm/@inquirer+core@11.1.5_@types+node@25.3.0/node_modules/@inquirer/core/dist/lib/theme.js
+//#region ../../node_modules/@inquirer/core/dist/lib/theme.js
 const defaultTheme = {
 	prefix: {
 		idle: (0, node_util.styleText)("blue", "?"),
@@ -4193,7 +6119,7 @@ const defaultTheme = {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/@inquirer+core@11.1.5_@types+node@25.3.0/node_modules/@inquirer/core/dist/lib/make-theme.js
+//#region ../../node_modules/@inquirer/core/dist/lib/make-theme.js
 function isPlainObject(value) {
 	if (typeof value !== "object" || value === null) return false;
 	let proto = value;
@@ -4213,7 +6139,7 @@ function makeTheme(...themes) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/@inquirer+core@11.1.5_@types+node@25.3.0/node_modules/@inquirer/core/dist/lib/use-prefix.js
+//#region ../../node_modules/@inquirer/core/dist/lib/use-prefix.js
 function usePrefix({ status = "idle", theme }) {
 	const [showLoader, setShowLoader] = useState(false);
 	const [tick, setTick] = useState(0);
@@ -4240,7 +6166,7 @@ function usePrefix({ status = "idle", theme }) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/@inquirer+core@11.1.5_@types+node@25.3.0/node_modules/@inquirer/core/dist/lib/use-memo.js
+//#region ../../node_modules/@inquirer/core/dist/lib/use-memo.js
 function useMemo(fn, dependencies) {
 	return withPointer((pointer) => {
 		const prev = pointer.get();
@@ -4257,13 +6183,13 @@ function useMemo(fn, dependencies) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/@inquirer+core@11.1.5_@types+node@25.3.0/node_modules/@inquirer/core/dist/lib/use-ref.js
+//#region ../../node_modules/@inquirer/core/dist/lib/use-ref.js
 function useRef(val) {
 	return useState({ current: val })[0];
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/@inquirer+core@11.1.5_@types+node@25.3.0/node_modules/@inquirer/core/dist/lib/use-keypress.js
+//#region ../../node_modules/@inquirer/core/dist/lib/use-keypress.js
 function useKeypress(userHandler) {
 	const signal = useRef(userHandler);
 	signal.current = userHandler;
@@ -4282,7 +6208,7 @@ function useKeypress(userHandler) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/cli-width@4.1.0/node_modules/cli-width/index.js
+//#region ../../node_modules/cli-width/index.js
 var require_cli_width = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	module.exports = cliWidth;
 	function normalizeOpts(options) {
@@ -4311,7 +6237,7 @@ var require_cli_width = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/fast-string-truncated-width@3.0.3/node_modules/fast-string-truncated-width/dist/utils.js
+//#region ../../node_modules/fast-string-truncated-width/dist/utils.js
 const getCodePointsLength = (() => {
 	const SURROGATE_PAIR_RE = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
 	return (input) => {
@@ -4329,7 +6255,7 @@ const isWideNotCJKTNotEmoji = (x) => {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/fast-string-truncated-width@3.0.3/node_modules/fast-string-truncated-width/dist/index.js
+//#region ../../node_modules/fast-string-truncated-width/dist/index.js
 const ANSI_RE = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]|\u001b\]8;[^;]*;.*?(?:\u0007|\u001b\u005c)/y;
 const CONTROL_RE = /[\x00-\x08\x0A-\x1F\x7F-\x9F]{1,1000}/y;
 const CJKT_WIDE_RE = /(?:(?![\uFF61-\uFF9F\uFF00-\uFFEF])[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}\p{Script=Tangut}]){1,1000}/uy;
@@ -4420,7 +6346,7 @@ const getStringTruncatedWidth = (input, truncationOptions = {}, widthOptions = {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/fast-string-width@3.0.2/node_modules/fast-string-width/dist/index.js
+//#region ../../node_modules/fast-string-width/dist/index.js
 const NO_TRUNCATION = {
 	limit: Infinity,
 	ellipsis: "",
@@ -4431,7 +6357,7 @@ const fastStringWidth = (input, options = {}) => {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/fast-wrap-ansi@0.2.0/node_modules/fast-wrap-ansi/lib/main.js
+//#region ../../node_modules/fast-wrap-ansi/lib/main.js
 const ESC$1 = "\x1B";
 const CSI = "›";
 const END_CODE = 39;
@@ -4597,7 +6523,7 @@ function wrapAnsi(string, columns, options) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/@inquirer+core@11.1.5_@types+node@25.3.0/node_modules/@inquirer/core/dist/lib/utils.js
+//#region ../../node_modules/@inquirer/core/dist/lib/utils.js
 var import_cli_width = /* @__PURE__ */ __toESM(require_cli_width(), 1);
 /**
 * Force line returns at specific width. This function is ANSI code friendly and it'll
@@ -4624,7 +6550,7 @@ function readlineWidth() {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/@inquirer+core@11.1.5_@types+node@25.3.0/node_modules/@inquirer/core/dist/lib/pagination/use-pagination.js
+//#region ../../node_modules/@inquirer/core/dist/lib/pagination/use-pagination.js
 function usePointerPosition({ active, renderedItems, pageSize, loop }) {
 	const state = useRef({
 		lastPointer: active,
@@ -4708,7 +6634,7 @@ function usePagination({ items, active, renderItem, pageSize, loop = true }) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/mute-stream@3.0.0/node_modules/mute-stream/lib/index.js
+//#region ../../node_modules/mute-stream/lib/index.js
 var require_lib = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const Stream = require("stream");
 	var MuteStream = class extends Stream {
@@ -4805,7 +6731,208 @@ var require_lib = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/@inquirer+ansi@2.0.3/node_modules/@inquirer/ansi/dist/index.js
+//#region ../../node_modules/@inquirer/core/node_modules/signal-exit/dist/mjs/signals.js
+/**
+* This is not the set of all possible signals.
+*
+* It IS, however, the set of all signals that trigger
+* an exit on either Linux or BSD systems.  Linux is a
+* superset of the signal names supported on BSD, and
+* the unknown signals just fail to register, so we can
+* catch that easily enough.
+*
+* Windows signals are a different set, since there are
+* signals that terminate Windows processes, but don't
+* terminate (or don't even exist) on Posix systems.
+*
+* Don't bother with SIGKILL.  It's uncatchable, which
+* means that we can't fire any callbacks anyway.
+*
+* If a user does happen to register a handler on a non-
+* fatal signal like SIGWINCH or something, and then
+* exit, it'll end up firing `process.emit('exit')`, so
+* the handler will be fired anyway.
+*
+* SIGBUS, SIGFPE, SIGSEGV and SIGILL, when not raised
+* artificially, inherently leave the process in a
+* state from which it is not safe to try and enter JS
+* listeners.
+*/
+const signals = [];
+signals.push("SIGHUP", "SIGINT", "SIGTERM");
+if (process.platform !== "win32") signals.push("SIGALRM", "SIGABRT", "SIGVTALRM", "SIGXCPU", "SIGXFSZ", "SIGUSR2", "SIGTRAP", "SIGSYS", "SIGQUIT", "SIGIOT");
+if (process.platform === "linux") signals.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT");
+
+//#endregion
+//#region ../../node_modules/@inquirer/core/node_modules/signal-exit/dist/mjs/index.js
+const processOk = (process) => !!process && typeof process === "object" && typeof process.removeListener === "function" && typeof process.emit === "function" && typeof process.reallyExit === "function" && typeof process.listeners === "function" && typeof process.kill === "function" && typeof process.pid === "number" && typeof process.on === "function";
+const kExitEmitter = Symbol.for("signal-exit emitter");
+const global$1 = globalThis;
+const ObjectDefineProperty = Object.defineProperty.bind(Object);
+var Emitter = class {
+	emitted = {
+		afterExit: false,
+		exit: false
+	};
+	listeners = {
+		afterExit: [],
+		exit: []
+	};
+	count = 0;
+	id = Math.random();
+	constructor() {
+		if (global$1[kExitEmitter]) return global$1[kExitEmitter];
+		ObjectDefineProperty(global$1, kExitEmitter, {
+			value: this,
+			writable: false,
+			enumerable: false,
+			configurable: false
+		});
+	}
+	on(ev, fn) {
+		this.listeners[ev].push(fn);
+	}
+	removeListener(ev, fn) {
+		const list = this.listeners[ev];
+		const i = list.indexOf(fn);
+		/* c8 ignore start */
+		if (i === -1) return;
+		/* c8 ignore stop */
+		if (i === 0 && list.length === 1) list.length = 0;
+		else list.splice(i, 1);
+	}
+	emit(ev, code, signal) {
+		if (this.emitted[ev]) return false;
+		this.emitted[ev] = true;
+		let ret = false;
+		for (const fn of this.listeners[ev]) ret = fn(code, signal) === true || ret;
+		if (ev === "exit") ret = this.emit("afterExit", code, signal) || ret;
+		return ret;
+	}
+};
+var SignalExitBase = class {};
+const signalExitWrap = (handler) => {
+	return {
+		onExit(cb, opts) {
+			return handler.onExit(cb, opts);
+		},
+		load() {
+			return handler.load();
+		},
+		unload() {
+			return handler.unload();
+		}
+	};
+};
+var SignalExitFallback = class extends SignalExitBase {
+	onExit() {
+		return () => {};
+	}
+	load() {}
+	unload() {}
+};
+var SignalExit = class extends SignalExitBase {
+	/* c8 ignore start */
+	#hupSig = process$1.platform === "win32" ? "SIGINT" : "SIGHUP";
+	/* c8 ignore stop */
+	#emitter = new Emitter();
+	#process;
+	#originalProcessEmit;
+	#originalProcessReallyExit;
+	#sigListeners = {};
+	#loaded = false;
+	constructor(process) {
+		super();
+		this.#process = process;
+		this.#sigListeners = {};
+		for (const sig of signals) this.#sigListeners[sig] = () => {
+			const listeners = this.#process.listeners(sig);
+			let { count } = this.#emitter;
+			/* c8 ignore start */
+			const p = process;
+			if (typeof p.__signal_exit_emitter__ === "object" && typeof p.__signal_exit_emitter__.count === "number") count += p.__signal_exit_emitter__.count;
+			/* c8 ignore stop */
+			if (listeners.length === count) {
+				this.unload();
+				const ret = this.#emitter.emit("exit", null, sig);
+				/* c8 ignore start */
+				const s = sig === "SIGHUP" ? this.#hupSig : sig;
+				if (!ret) process.kill(process.pid, s);
+			}
+		};
+		this.#originalProcessReallyExit = process.reallyExit;
+		this.#originalProcessEmit = process.emit;
+	}
+	onExit(cb, opts) {
+		/* c8 ignore start */
+		if (!processOk(this.#process)) return () => {};
+		/* c8 ignore stop */
+		if (this.#loaded === false) this.load();
+		const ev = opts?.alwaysLast ? "afterExit" : "exit";
+		this.#emitter.on(ev, cb);
+		return () => {
+			this.#emitter.removeListener(ev, cb);
+			if (this.#emitter.listeners["exit"].length === 0 && this.#emitter.listeners["afterExit"].length === 0) this.unload();
+		};
+	}
+	load() {
+		if (this.#loaded) return;
+		this.#loaded = true;
+		this.#emitter.count += 1;
+		for (const sig of signals) try {
+			const fn = this.#sigListeners[sig];
+			if (fn) this.#process.on(sig, fn);
+		} catch (_) {}
+		this.#process.emit = (ev, ...a) => {
+			return this.#processEmit(ev, ...a);
+		};
+		this.#process.reallyExit = (code) => {
+			return this.#processReallyExit(code);
+		};
+	}
+	unload() {
+		if (!this.#loaded) return;
+		this.#loaded = false;
+		signals.forEach((sig) => {
+			const listener = this.#sigListeners[sig];
+			/* c8 ignore start */
+			if (!listener) throw new Error("Listener not defined for signal: " + sig);
+			/* c8 ignore stop */
+			try {
+				this.#process.removeListener(sig, listener);
+			} catch (_) {}
+			/* c8 ignore stop */
+		});
+		this.#process.emit = this.#originalProcessEmit;
+		this.#process.reallyExit = this.#originalProcessReallyExit;
+		this.#emitter.count -= 1;
+	}
+	#processReallyExit(code) {
+		/* c8 ignore start */
+		if (!processOk(this.#process)) return 0;
+		this.#process.exitCode = code || 0;
+		/* c8 ignore stop */
+		this.#emitter.emit("exit", this.#process.exitCode, null);
+		return this.#originalProcessReallyExit.call(this.#process, this.#process.exitCode);
+	}
+	#processEmit(ev, ...args) {
+		const og = this.#originalProcessEmit;
+		if (ev === "exit" && processOk(this.#process)) {
+			if (typeof args[0] === "number") this.#process.exitCode = args[0];
+			/* c8 ignore start */
+			const ret = og.call(this.#process, ev, ...args);
+			/* c8 ignore start */
+			this.#emitter.emit("exit", this.#process.exitCode, null);
+			/* c8 ignore stop */
+			return ret;
+		} else return og.call(this.#process, ev, ...args);
+	}
+};
+const process$1 = globalThis.process;
+const { onExit, load, unload } = signalExitWrap(processOk(process$1) ? new SignalExit(process$1) : new SignalExitFallback());
+
+//#endregion
+//#region ../../node_modules/@inquirer/ansi/dist/index.js
 const ESC = "\x1B[";
 /** Move cursor to first column */
 const cursorLeft = ESC + "G";
@@ -4827,7 +6954,7 @@ const eraseLine = ESC + "2K";
 const eraseLines = (lines) => lines > 0 ? (eraseLine + cursorUp(1)).repeat(lines - 1) + eraseLine + cursorLeft : "";
 
 //#endregion
-//#region ../../node_modules/.pnpm/@inquirer+core@11.1.5_@types+node@25.3.0/node_modules/@inquirer/core/dist/lib/screen-manager.js
+//#region ../../node_modules/@inquirer/core/dist/lib/screen-manager.js
 const height = (content) => content.split("\n").length;
 const lastLine = (content) => content.split("\n").pop() ?? "";
 var ScreenManager = class {
@@ -4883,7 +7010,7 @@ var ScreenManager = class {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/@inquirer+core@11.1.5_@types+node@25.3.0/node_modules/@inquirer/core/dist/lib/promise-polyfill.js
+//#region ../../node_modules/@inquirer/core/dist/lib/promise-polyfill.js
 var PromisePolyfill = class extends Promise {
 	static withResolver() {
 		let resolve;
@@ -4900,8 +7027,8 @@ var PromisePolyfill = class extends Promise {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/@inquirer+core@11.1.5_@types+node@25.3.0/node_modules/@inquirer/core/dist/lib/create-prompt.js
-var import_lib = /* @__PURE__ */ __toESM(require_lib(), 1);
+//#region ../../node_modules/@inquirer/core/dist/lib/create-prompt.js
+var import_lib$1 = /* @__PURE__ */ __toESM(require_lib(), 1);
 const nativeSetImmediate = globalThis.setImmediate;
 function getCallSites() {
 	const _prepareStackTrace = Error.prepareStackTrace;
@@ -4924,7 +7051,7 @@ function createPrompt(view) {
 	const prompt = (config, context = {}) => {
 		const { input = process.stdin, signal } = context;
 		const cleanups = /* @__PURE__ */ new Set();
-		const output = new import_lib.default();
+		const output = new import_lib$1.default();
 		output.pipe(context.output ?? process.stdout);
 		output.mute();
 		const rl = node_readline.createInterface({
@@ -4994,7 +7121,7 @@ function createPrompt(view) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/@inquirer+core@11.1.5_@types+node@25.3.0/node_modules/@inquirer/core/dist/lib/Separator.js
+//#region ../../node_modules/@inquirer/core/dist/lib/Separator.js
 /**
 * Separator object
 * Used to space/separate choices group
@@ -5011,7 +7138,7 @@ var Separator = class {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/@inquirer+checkbox@5.1.0_@types+node@25.3.0/node_modules/@inquirer/checkbox/dist/index.js
+//#region ../../node_modules/@inquirer/checkbox/dist/index.js
 const checkboxTheme = {
 	icon: {
 		checked: (0, node_util.styleText)("green", figures.circleFilled),
@@ -5192,7 +7319,7 @@ var dist_default$2 = createPrompt((config, done) => {
 });
 
 //#endregion
-//#region ../../node_modules/.pnpm/@inquirer+confirm@6.0.8_@types+node@25.3.0/node_modules/@inquirer/confirm/dist/index.js
+//#region ../../node_modules/@inquirer/confirm/dist/index.js
 function getBooleanValue(value, defaultValue) {
 	let answer = defaultValue !== false;
 	if (/^(y|yes)/i.test(value)) answer = true;
@@ -5233,7 +7360,7 @@ var dist_default$1 = createPrompt((config, done) => {
 });
 
 //#endregion
-//#region ../../node_modules/.pnpm/@inquirer+select@5.1.0_@types+node@25.3.0/node_modules/@inquirer/select/dist/index.js
+//#region ../../node_modules/@inquirer/select/dist/index.js
 const selectTheme = {
 	icon: { cursor: figures.pointer },
 	style: {
@@ -5389,1100 +7516,602 @@ var dist_default = createPrompt((config, done) => {
 });
 
 //#endregion
-//#region ../adapters/dist/base.js
-var require_base = /* @__PURE__ */ __commonJSMin(((exports) => {
-	/**
-	* @maxsim/adapters — Shared base utilities extracted from bin/install.js
-	*/
-	var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
-		if (k2 === void 0) k2 = k;
-		var desc = Object.getOwnPropertyDescriptor(m, k);
-		if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) desc = {
-			enumerable: true,
-			get: function() {
-				return m[k];
-			}
-		};
-		Object.defineProperty(o, k2, desc);
-	}) : (function(o, m, k, k2) {
-		if (k2 === void 0) k2 = k;
-		o[k2] = m[k];
-	}));
-	var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
-		Object.defineProperty(o, "default", {
-			enumerable: true,
-			value: v
-		});
-	}) : function(o, v) {
-		o["default"] = v;
-	});
-	var __importStar = exports && exports.__importStar || (function() {
-		var ownKeys = function(o) {
-			ownKeys = Object.getOwnPropertyNames || function(o) {
-				var ar = [];
-				for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-				return ar;
-			};
-			return ownKeys(o);
-		};
-		return function(mod) {
-			if (mod && mod.__esModule) return mod;
-			var result = {};
-			if (mod != null) {
-				for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-			}
-			__setModuleDefault(result, mod);
-			return result;
-		};
-	})();
-	Object.defineProperty(exports, "__esModule", { value: true });
-	exports.expandTilde = expandTilde;
-	exports.extractFrontmatterAndBody = extractFrontmatterAndBody;
-	exports.processAttribution = processAttribution;
-	exports.buildHookCommand = buildHookCommand;
-	exports.readSettings = readSettings;
-	exports.writeSettings = writeSettings;
-	const path$4 = __importStar(require("node:path"));
-	const os$4 = __importStar(require("node:os"));
-	const fs = __importStar(require("node:fs"));
-	/**
-	* Expand ~ to home directory (shell doesn't expand in env vars passed to node)
-	*/
-	function expandTilde(filePath) {
-		if (filePath && filePath.startsWith("~/")) return path$4.join(os$4.homedir(), filePath.slice(2));
-		return filePath;
-	}
-	/**
-	* Extract YAML frontmatter and body from markdown content.
-	* Returns null frontmatter if content doesn't start with ---.
-	*/
-	function extractFrontmatterAndBody(content) {
-		if (!content.startsWith("---")) return {
-			frontmatter: null,
-			body: content
-		};
-		const endIndex = content.indexOf("---", 3);
-		if (endIndex === -1) return {
-			frontmatter: null,
-			body: content
-		};
-		return {
-			frontmatter: content.substring(3, endIndex).trim(),
-			body: content.substring(endIndex + 3)
-		};
-	}
-	/**
-	* Process Co-Authored-By lines based on attribution setting.
-	* @param content - File content to process
-	* @param attribution - null=remove, undefined=keep default, string=replace
-	*/
-	function processAttribution(content, attribution) {
-		if (attribution === null) return content.replace(/(\r?\n){2}Co-Authored-By:.*$/gim, "");
-		if (attribution === void 0) return content;
-		const safeAttribution = attribution.replace(/\$/g, "$$$$");
-		return content.replace(/Co-Authored-By:.*$/gim, `Co-Authored-By: ${safeAttribution}`);
-	}
-	/**
-	* Build a hook command path using forward slashes for cross-platform compatibility.
-	*/
-	function buildHookCommand(configDir, hookName) {
-		return `node "${configDir.replace(/\\/g, "/") + "/hooks/" + hookName}"`;
-	}
-	/**
-	* Read and parse settings.json, returning empty object if it doesn't exist.
-	*/
-	function readSettings(settingsPath) {
-		if (fs.existsSync(settingsPath)) try {
-			return JSON.parse(fs.readFileSync(settingsPath, "utf8"));
-		} catch {
-			return {};
-		}
-		return {};
-	}
-	/**
-	* Write settings.json with proper formatting.
-	*/
-	function writeSettings(settingsPath, settings) {
-		fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
-	}
-}));
-
-//#endregion
-//#region ../adapters/dist/claude.js
-var require_claude = /* @__PURE__ */ __commonJSMin(((exports) => {
-	/**
-	* @maxsim/adapters — Claude Code adapter
-	*
-	* Ports the Claude-specific logic from bin/install.js:
-	*   - getGlobalDir('claude', ...)  (lines 135-142)
-	*   - getDirName('claude')         (line 49)
-	*   - getConfigDirFromHome('claude', isGlobal) (lines 58-72)
-	*   - copyWithPathReplacement for Claude (lines 839-892)
-	*/
-	var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
-		if (k2 === void 0) k2 = k;
-		var desc = Object.getOwnPropertyDescriptor(m, k);
-		if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) desc = {
-			enumerable: true,
-			get: function() {
-				return m[k];
-			}
-		};
-		Object.defineProperty(o, k2, desc);
-	}) : (function(o, m, k, k2) {
-		if (k2 === void 0) k2 = k;
-		o[k2] = m[k];
-	}));
-	var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
-		Object.defineProperty(o, "default", {
-			enumerable: true,
-			value: v
-		});
-	}) : function(o, v) {
-		o["default"] = v;
-	});
-	var __importStar = exports && exports.__importStar || (function() {
-		var ownKeys = function(o) {
-			ownKeys = Object.getOwnPropertyNames || function(o) {
-				var ar = [];
-				for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-				return ar;
-			};
-			return ownKeys(o);
-		};
-		return function(mod) {
-			if (mod && mod.__esModule) return mod;
-			var result = {};
-			if (mod != null) {
-				for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-			}
-			__setModuleDefault(result, mod);
-			return result;
-		};
-	})();
-	Object.defineProperty(exports, "__esModule", { value: true });
-	exports.claudeAdapter = void 0;
-	exports.installClaude = installClaude;
-	const path$3 = __importStar(require("node:path"));
-	const os$3 = __importStar(require("node:os"));
-	const base_js_1 = require_base();
-	/**
-	* Get the global config directory for Claude Code.
-	* Priority: explicitDir > CLAUDE_CONFIG_DIR env > ~/.claude
-	*/
-	function getGlobalDir(explicitDir) {
-		if (explicitDir) return (0, base_js_1.expandTilde)(explicitDir);
-		if (process.env.CLAUDE_CONFIG_DIR) return (0, base_js_1.expandTilde)(process.env.CLAUDE_CONFIG_DIR);
-		return path$3.join(os$3.homedir(), ".claude");
-	}
-	/**
-	* Get the config directory path relative to home for hook templating.
-	* Used for path.join(homeDir, '<configDir>', ...) replacement in hooks.
-	*/
-	function getConfigDirFromHome(isGlobal) {
-		return "'.claude'";
-	}
-	/**
-	* Transform markdown content for Claude Code installation.
-	* For Claude, this is path replacement only — no frontmatter conversion needed.
-	* Replaces ~/.claude/ and ./.claude/ references with the actual install path prefix.
-	*/
-	function transformContent(content, pathPrefix) {
-		const globalClaudeRegex = /~\/\.claude\//g;
-		const localClaudeRegex = /\.\/\.claude\//g;
-		let result = content.replace(globalClaudeRegex, pathPrefix);
-		result = result.replace(localClaudeRegex, `./.claude/`);
-		return result;
-	}
-	/**
-	* Claude Code adapter configuration.
-	* Claude uses nested command structure (commands/maxsim/*.md).
-	*/
-	exports.claudeAdapter = {
-		runtime: "claude",
-		dirName: ".claude",
-		getGlobalDir,
-		getConfigDirFromHome,
-		transformContent,
-		commandStructure: "nested"
+//#region src/adapters/base.ts
+/**
+* @maxsim/adapters — Shared base utilities extracted from bin/install.js
+*/
+/**
+* Expand ~ to home directory (shell doesn't expand in env vars passed to node)
+*/
+function expandTilde(filePath) {
+	if (filePath && filePath.startsWith("~/")) return node_path.join(node_os.homedir(), filePath.slice(2));
+	return filePath;
+}
+/**
+* Extract YAML frontmatter and body from markdown content.
+* Returns null frontmatter if content doesn't start with ---.
+*/
+function extractFrontmatterAndBody(content) {
+	if (!content.startsWith("---")) return {
+		frontmatter: null,
+		body: content
 	};
-	/**
-	* Install Claude Code adapter files.
-	* Stub — actual install orchestration will be implemented in Phase 5.
-	*/
-	function installClaude() {
-		throw new Error("installClaude() not yet implemented — see Phase 5");
-	}
-}));
-
-//#endregion
-//#region ../adapters/dist/transforms/tool-maps.js
-var require_tool_maps = /* @__PURE__ */ __commonJSMin(((exports) => {
-	/**
-	* @maxsim/adapters — Tool name mappings per runtime
-	*
-	* Ported from bin/install.js lines ~327-390
-	*/
-	Object.defineProperty(exports, "__esModule", { value: true });
-	exports.convertToolName = convertToolName;
-	exports.convertGeminiToolName = convertGeminiToolName;
-	/** Tool name mapping from Claude Code to OpenCode */
-	const claudeToOpencodeTools = {
-		AskUserQuestion: "question",
-		SlashCommand: "skill",
-		TodoWrite: "todowrite",
-		WebFetch: "webfetch",
-		WebSearch: "websearch"
+	const endIndex = content.indexOf("---", 3);
+	if (endIndex === -1) return {
+		frontmatter: null,
+		body: content
 	};
-	/** Tool name mapping from Claude Code to Gemini CLI */
-	const claudeToGeminiTools = {
-		Read: "read_file",
-		Write: "write_file",
-		Edit: "replace",
-		Bash: "run_shell_command",
-		Glob: "glob",
-		Grep: "search_file_content",
-		WebSearch: "google_web_search",
-		WebFetch: "web_fetch",
-		TodoWrite: "write_todos",
-		AskUserQuestion: "ask_user"
+	return {
+		frontmatter: content.substring(3, endIndex).trim(),
+		body: content.substring(endIndex + 3)
 	};
-	/**
-	* Convert a Claude Code tool name to OpenCode format.
-	* - Applies special mappings (AskUserQuestion -> question, etc.)
-	* - Converts to lowercase (except MCP tools which keep their format)
-	*/
-	function convertToolName(claudeTool) {
-		if (claudeToOpencodeTools[claudeTool]) return claudeToOpencodeTools[claudeTool];
-		if (claudeTool.startsWith("mcp__")) return claudeTool;
-		return claudeTool.toLowerCase();
-	}
-	/**
-	* Convert a Claude Code tool name to Gemini CLI format.
-	* - Applies Claude->Gemini mapping (Read->read_file, Bash->run_shell_command, etc.)
-	* - Filters out MCP tools (mcp__*) -- auto-discovered at runtime in Gemini
-	* - Filters out Task -- agents are auto-registered as tools in Gemini
-	* @returns Gemini tool name, or null if tool should be excluded
-	*/
-	function convertGeminiToolName(claudeTool) {
-		if (claudeTool.startsWith("mcp__")) return null;
-		if (claudeTool === "Task") return null;
-		if (claudeToGeminiTools[claudeTool]) return claudeToGeminiTools[claudeTool];
-		return claudeTool.toLowerCase();
-	}
-}));
-
-//#endregion
-//#region ../adapters/dist/transforms/content.js
-var require_content = /* @__PURE__ */ __commonJSMin(((exports) => {
-	/**
-	* @maxsim/adapters — Content transformation utilities
-	*
-	* Ported from bin/install.js lines ~423-564
-	*/
-	Object.defineProperty(exports, "__esModule", { value: true });
-	exports.convertSlashCommandsToCodexSkillMentions = convertSlashCommandsToCodexSkillMentions;
-	exports.convertClaudeToCodexMarkdown = convertClaudeToCodexMarkdown;
-	exports.stripSubTags = stripSubTags;
-	exports.convertClaudeToGeminiAgent = convertClaudeToGeminiAgent;
-	exports.replacePathReferences = replacePathReferences;
-	const tool_maps_js_1 = require_tool_maps();
-	/**
-	* Convert /maxsim:command-name to $maxsim-command-name for Codex skill mentions.
-	* Ported from install.js line ~423
-	*/
-	function convertSlashCommandsToCodexSkillMentions(content) {
-		let converted = content.replace(/\/maxsim:([a-z0-9-]+)/gi, (_, commandName) => {
-			return `$maxsim-${String(commandName).toLowerCase()}`;
-		});
-		converted = converted.replace(/\/maxsim-help\b/g, "$maxsim-help");
-		return converted;
-	}
-	/**
-	* Convert Claude markdown to Codex markdown format.
-	* Replaces slash commands and $ARGUMENTS placeholder.
-	* Ported from install.js line ~431
-	*/
-	function convertClaudeToCodexMarkdown(content) {
-		let converted = convertSlashCommandsToCodexSkillMentions(content);
-		converted = converted.replace(/\$ARGUMENTS\b/g, "{{MAXSIM_ARGS}}");
-		return converted;
-	}
-	/**
-	* Strip HTML <sub> tags for Gemini CLI output.
-	* Terminals don't support subscript -- converts <sub>text</sub> to italic *(text)*.
-	* Ported from install.js line ~474
-	*/
-	function stripSubTags(content) {
-		return content.replace(/<sub>(.*?)<\/sub>/g, "*($1)*");
-	}
-	/**
-	* Convert Claude Code agent frontmatter to Gemini CLI format.
-	* - tools: must be a YAML array (not comma-separated string)
-	* - tool names: must use Gemini built-in names (read_file, not Read)
-	* - color: must be removed (causes validation error)
-	* - mcp__* tools: must be excluded (auto-discovered at runtime)
-	* - ${VAR} patterns: escaped to $VAR for Gemini template compatibility
-	*
-	* Ported from install.js line ~487
-	*/
-	function convertClaudeToGeminiAgent(content) {
-		if (!content.startsWith("---")) return content;
-		const endIndex = content.indexOf("---", 3);
-		if (endIndex === -1) return content;
-		const frontmatter = content.substring(3, endIndex).trim();
-		const body = content.substring(endIndex + 3);
-		const lines = frontmatter.split("\n");
-		const newLines = [];
-		let inAllowedTools = false;
-		const tools = [];
-		for (const line of lines) {
-			const trimmed = line.trim();
-			if (trimmed.startsWith("allowed-tools:")) {
-				inAllowedTools = true;
-				continue;
-			}
-			if (trimmed.startsWith("tools:")) {
-				const toolsValue = trimmed.substring(6).trim();
-				if (toolsValue) {
-					const parsed = toolsValue.split(",").map((t) => t.trim()).filter((t) => t);
-					for (const t of parsed) {
-						const mapped = (0, tool_maps_js_1.convertGeminiToolName)(t);
-						if (mapped) tools.push(mapped);
-					}
-				} else inAllowedTools = true;
-				continue;
-			}
-			if (trimmed.startsWith("color:")) continue;
-			if (inAllowedTools) {
-				if (trimmed.startsWith("- ")) {
-					const mapped = (0, tool_maps_js_1.convertGeminiToolName)(trimmed.substring(2).trim());
-					if (mapped) tools.push(mapped);
-					continue;
-				} else if (trimmed && !trimmed.startsWith("-")) inAllowedTools = false;
-			}
-			if (!inAllowedTools) newLines.push(line);
-		}
-		if (tools.length > 0) {
-			newLines.push("tools:");
-			for (const tool of tools) newLines.push(`  - ${tool}`);
-		}
-		return `---\n${newLines.join("\n").trim()}\n---${stripSubTags(body.replace(/\$\{(\w+)\}/g, "$$$1"))}`;
-	}
-	/**
-	* Replace path references in markdown content for a target runtime.
-	* Replaces ~/.claude/ with pathPrefix and ./.claude/ with ./dirName/.
-	*/
-	function replacePathReferences(content, pathPrefix, dirName) {
-		const globalClaudeRegex = /~\/\.claude\//g;
-		const localClaudeRegex = /\.\/\.claude\//g;
-		let result = content.replace(globalClaudeRegex, pathPrefix);
-		result = result.replace(localClaudeRegex, `./${dirName}/`);
-		return result;
+}
+/**
+* Process Co-Authored-By lines based on attribution setting.
+* @param content - File content to process
+* @param attribution - null=remove, undefined=keep default, string=replace
+*/
+function processAttribution(content, attribution) {
+	if (attribution === null) return content.replace(/(\r?\n){2}Co-Authored-By:.*$/gim, "");
+	if (attribution === void 0) return content;
+	const safeAttribution = attribution.replace(/\$/g, "$$$$");
+	return content.replace(/Co-Authored-By:.*$/gim, `Co-Authored-By: ${safeAttribution}`);
+}
+/**
+* Build a hook command path using forward slashes for cross-platform compatibility.
+*/
+function buildHookCommand(configDir, hookName) {
+	return `node "${configDir.replace(/\\/g, "/") + "/hooks/" + hookName}"`;
+}
+/**
+* Read and parse settings.json, returning empty object if it doesn't exist.
+*/
+function readSettings(settingsPath) {
+	if (node_fs.existsSync(settingsPath)) try {
+		return JSON.parse(node_fs.readFileSync(settingsPath, "utf8"));
+	} catch {
+		return {};
 	}
-}));
+	return {};
+}
+/**
+* Write settings.json with proper formatting.
+*/
+function writeSettings(settingsPath, settings) {
+	node_fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+}
 
 //#endregion
-//#region ../adapters/dist/transforms/frontmatter.js
-var require_frontmatter = /* @__PURE__ */ __commonJSMin(((exports) => {
-	/**
-	* @maxsim/adapters — Frontmatter conversion functions for opencode, gemini, codex
-	*
-	* Ported from bin/install.js lines ~308-711
-	*/
-	Object.defineProperty(exports, "__esModule", { value: true });
-	exports.colorNameToHex = void 0;
-	exports.toSingleLine = toSingleLine;
-	exports.yamlQuote = yamlQuote;
-	exports.extractFrontmatterField = extractFrontmatterField;
-	exports.convertClaudeToOpencodeFrontmatter = convertClaudeToOpencodeFrontmatter;
-	exports.convertClaudeToGeminiToml = convertClaudeToGeminiToml;
-	exports.convertClaudeCommandToCodexSkill = convertClaudeCommandToCodexSkill;
-	exports.getCodexSkillAdapterHeader = getCodexSkillAdapterHeader;
-	const base_js_1 = require_base();
-	const tool_maps_js_1 = require_tool_maps();
-	const content_js_1 = require_content();
-	/** Color name to hex mapping for opencode compatibility */
-	exports.colorNameToHex = {
-		cyan: "#00FFFF",
-		red: "#FF0000",
-		green: "#00FF00",
-		blue: "#0000FF",
-		yellow: "#FFFF00",
-		magenta: "#FF00FF",
-		orange: "#FFA500",
-		purple: "#800080",
-		pink: "#FFC0CB",
-		white: "#FFFFFF",
-		black: "#000000",
-		gray: "#808080",
-		grey: "#808080"
-	};
-	/** Collapse whitespace to single line */
-	function toSingleLine(value) {
-		return value.replace(/\s+/g, " ").trim();
-	}
-	/** Quote a value for YAML using JSON.stringify */
-	function yamlQuote(value) {
-		return JSON.stringify(value);
-	}
-	/** Extract a single-line field value from YAML frontmatter text */
-	function extractFrontmatterField(frontmatter, fieldName) {
-		const regex = new RegExp(`^${fieldName}:\\s*(.+)$`, "m");
-		const match = frontmatter.match(regex);
-		if (!match) return null;
-		return match[1].trim().replace(/^['"]|['"]$/g, "");
-	}
-	/**
-	* Convert Claude Code frontmatter to OpenCode format.
-	* - Converts 'allowed-tools:' array to 'tools:' object with tool: true entries
-	* - Converts color names to hex
-	* - Removes name: field (opencode uses filename)
-	* - Replaces tool name references in body content
-	* - Replaces /maxsim: with /maxsim- (flat command structure)
-	* - Replaces ~/.claude with ~/.config/opencode
-	* - Replaces subagent_type="general-purpose" with "general"
-	*
-	* Ported from install.js line ~566
-	*/
-	function convertClaudeToOpencodeFrontmatter(content) {
-		let convertedContent = content;
-		convertedContent = convertedContent.replace(/\bAskUserQuestion\b/g, "question");
-		convertedContent = convertedContent.replace(/\bSlashCommand\b/g, "skill");
-		convertedContent = convertedContent.replace(/\bTodoWrite\b/g, "todowrite");
-		convertedContent = convertedContent.replace(/\/maxsim:/g, "/maxsim-");
-		convertedContent = convertedContent.replace(/~\/\.claude\b/g, "~/.config/opencode");
-		convertedContent = convertedContent.replace(/subagent_type="general-purpose"/g, "subagent_type=\"general\"");
-		if (!convertedContent.startsWith("---")) return convertedContent;
-		const endIndex = convertedContent.indexOf("---", 3);
-		if (endIndex === -1) return convertedContent;
-		const frontmatter = convertedContent.substring(3, endIndex).trim();
-		const body = convertedContent.substring(endIndex + 3);
-		const lines = frontmatter.split("\n");
-		const newLines = [];
-		let inAllowedTools = false;
-		const allowedTools = [];
-		for (const line of lines) {
-			const trimmed = line.trim();
-			if (trimmed.startsWith("allowed-tools:")) {
-				inAllowedTools = true;
-				continue;
-			}
-			if (trimmed.startsWith("tools:")) {
-				const toolsValue = trimmed.substring(6).trim();
-				if (toolsValue) {
-					const tools = toolsValue.split(",").map((t) => t.trim()).filter((t) => t);
-					allowedTools.push(...tools);
-				}
-				continue;
-			}
-			if (trimmed.startsWith("name:")) continue;
-			if (trimmed.startsWith("color:")) {
-				const colorValue = trimmed.substring(6).trim().toLowerCase();
-				const hexColor = exports.colorNameToHex[colorValue];
-				if (hexColor) newLines.push(`color: "${hexColor}"`);
-				else if (colorValue.startsWith("#")) {
-					if (/^#[0-9a-f]{3}$|^#[0-9a-f]{6}$/i.test(colorValue)) newLines.push(line);
-				}
-				continue;
-			}
-			if (inAllowedTools) {
-				if (trimmed.startsWith("- ")) {
-					allowedTools.push(trimmed.substring(2).trim());
-					continue;
-				} else if (trimmed && !trimmed.startsWith("-")) inAllowedTools = false;
-			}
-			if (!inAllowedTools) newLines.push(line);
-		}
-		if (allowedTools.length > 0) {
-			newLines.push("tools:");
-			for (const tool of allowedTools) newLines.push(`  ${(0, tool_maps_js_1.convertToolName)(tool)}: true`);
-		}
-		return `---\n${newLines.join("\n").trim()}\n---${body}`;
-	}
-	/**
-	* Convert Claude Code markdown command to Gemini TOML format.
-	* Ported from install.js line ~677
-	*/
-	function convertClaudeToGeminiToml(content) {
-		if (!content.startsWith("---")) return `prompt = ${JSON.stringify(content)}\n`;
-		const endIndex = content.indexOf("---", 3);
-		if (endIndex === -1) return `prompt = ${JSON.stringify(content)}\n`;
-		const frontmatter = content.substring(3, endIndex).trim();
-		const body = content.substring(endIndex + 3).trim();
-		let description = "";
-		const lines = frontmatter.split("\n");
-		for (const line of lines) {
-			const trimmed = line.trim();
-			if (trimmed.startsWith("description:")) {
-				description = trimmed.substring(12).trim();
-				break;
-			}
-		}
-		let toml = "";
-		if (description) toml += `description = ${JSON.stringify(description)}\n`;
-		toml += `prompt = ${JSON.stringify(body)}\n`;
-		return toml;
-	}
-	/**
-	* Convert Claude command to Codex skill format with adapter header.
-	* Ported from install.js line ~452
-	*/
-	function convertClaudeCommandToCodexSkill(content, skillName) {
-		const converted = (0, content_js_1.convertClaudeToCodexMarkdown)(content);
-		const { frontmatter, body } = (0, base_js_1.extractFrontmatterAndBody)(converted);
-		let description = `Run MAXSIM workflow ${skillName}.`;
-		if (frontmatter) {
-			const maybeDescription = extractFrontmatterField(frontmatter, "description");
-			if (maybeDescription) description = maybeDescription;
-		}
-		description = toSingleLine(description);
-		const shortDescription = description.length > 180 ? `${description.slice(0, 177)}...` : description;
-		const adapter = getCodexSkillAdapterHeader(skillName);
-		return `---\nname: ${yamlQuote(skillName)}\ndescription: ${yamlQuote(description)}\nmetadata:\n  short-description: ${yamlQuote(shortDescription)}\n---\n\n${adapter}\n\n${body.trimStart()}`;
-	}
-	/**
-	* Generate the Codex skill adapter header block.
-	* Ported from install.js line ~437
-	*/
-	function getCodexSkillAdapterHeader(skillName) {
-		const invocation = `$${skillName}`;
-		return `<codex_skill_adapter>
-Codex skills-first mode:
-- This skill is invoked by mentioning \`${invocation}\`.
-- Treat all user text after \`${invocation}\` as \`{{MAXSIM_ARGS}}\`.
-- If no arguments are present, treat \`{{MAXSIM_ARGS}}\` as empty.
-
-Legacy orchestration compatibility:
-- Any \`Task(...)\` pattern in referenced workflow docs is legacy syntax.
-- Implement equivalent behavior with Codex collaboration tools: \`spawn_agent\`, \`wait\`, \`send_input\`, and \`close_agent\`.
-- Treat legacy \`subagent_type\` names as role hints in the spawned message.
-</codex_skill_adapter>`;
-	}
-}));
+//#region src/adapters/claude.ts
+/**
+* @maxsim/adapters — Claude Code adapter
+*
+* Ports the Claude-specific logic from bin/install.js:
+*   - getGlobalDir('claude', ...)  (lines 135-142)
+*   - getDirName('claude')         (line 49)
+*   - getConfigDirFromHome('claude', isGlobal) (lines 58-72)
+*   - copyWithPathReplacement for Claude (lines 839-892)
+*/
+/**
+* Get the global config directory for Claude Code.
+* Priority: explicitDir > CLAUDE_CONFIG_DIR env > ~/.claude
+*/
+function getGlobalDir$4(explicitDir) {
+	if (explicitDir) return expandTilde(explicitDir);
+	if (process.env.CLAUDE_CONFIG_DIR) return expandTilde(process.env.CLAUDE_CONFIG_DIR);
+	return node_path.join(node_os.homedir(), ".claude");
+}
+/**
+* Get the config directory path relative to home for hook templating.
+* Used for path.join(homeDir, '<configDir>', ...) replacement in hooks.
+*/
+function getConfigDirFromHome$4(isGlobal) {
+	return "'.claude'";
+}
+/**
+* Transform markdown content for Claude Code installation.
+* For Claude, this is path replacement only — no frontmatter conversion needed.
+* Replaces ~/.claude/ and ./.claude/ references with the actual install path prefix.
+*/
+function transformContent$3(content, pathPrefix) {
+	const globalClaudeRegex = /~\/\.claude\//g;
+	const localClaudeRegex = /\.\/\.claude\//g;
+	let result = content.replace(globalClaudeRegex, pathPrefix);
+	result = result.replace(localClaudeRegex, `./.claude/`);
+	return result;
+}
+/**
+* Claude Code adapter configuration.
+* Claude uses nested command structure (commands/maxsim/*.md).
+*/
+const claudeAdapter = {
+	runtime: "claude",
+	dirName: ".claude",
+	getGlobalDir: getGlobalDir$4,
+	getConfigDirFromHome: getConfigDirFromHome$4,
+	transformContent: transformContent$3,
+	commandStructure: "nested"
+};
 
 //#endregion
-//#region ../adapters/dist/opencode.js
-var require_opencode = /* @__PURE__ */ __commonJSMin(((exports) => {
-	/**
-	* @maxsim/adapters — OpenCode adapter
-	*
-	* Ports the OpenCode-specific logic from bin/install.js:
-	*   - getOpencodeGlobalDir()           (lines 79-97)
-	*   - getGlobalDir('opencode', ...)    (lines 104-111)
-	*   - getDirName('opencode')           (line 46)
-	*   - getConfigDirFromHome('opencode', isGlobal) (lines 58-68)
-	*   - convertClaudeToOpencodeFrontmatter + path replacement
-	*/
-	var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
-		if (k2 === void 0) k2 = k;
-		var desc = Object.getOwnPropertyDescriptor(m, k);
-		if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) desc = {
-			enumerable: true,
-			get: function() {
-				return m[k];
-			}
-		};
-		Object.defineProperty(o, k2, desc);
-	}) : (function(o, m, k, k2) {
-		if (k2 === void 0) k2 = k;
-		o[k2] = m[k];
-	}));
-	var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
-		Object.defineProperty(o, "default", {
-			enumerable: true,
-			value: v
-		});
-	}) : function(o, v) {
-		o["default"] = v;
-	});
-	var __importStar = exports && exports.__importStar || (function() {
-		var ownKeys = function(o) {
-			ownKeys = Object.getOwnPropertyNames || function(o) {
-				var ar = [];
-				for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-				return ar;
-			};
-			return ownKeys(o);
-		};
-		return function(mod) {
-			if (mod && mod.__esModule) return mod;
-			var result = {};
-			if (mod != null) {
-				for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-			}
-			__setModuleDefault(result, mod);
-			return result;
-		};
-	})();
-	Object.defineProperty(exports, "__esModule", { value: true });
-	exports.opencodeAdapter = void 0;
-	const path$2 = __importStar(require("node:path"));
-	const os$2 = __importStar(require("node:os"));
-	const base_js_1 = require_base();
-	const frontmatter_js_1 = require_frontmatter();
-	const content_js_1 = require_content();
-	/**
-	* Get the global config directory for OpenCode.
-	* OpenCode follows XDG Base Directory spec and uses ~/.config/opencode/.
-	* Priority: OPENCODE_CONFIG_DIR > dirname(OPENCODE_CONFIG) > XDG_CONFIG_HOME/opencode > ~/.config/opencode
-	*/
-	function getOpencodeGlobalDir() {
-		if (process.env.OPENCODE_CONFIG_DIR) return (0, base_js_1.expandTilde)(process.env.OPENCODE_CONFIG_DIR);
-		if (process.env.OPENCODE_CONFIG) return path$2.dirname((0, base_js_1.expandTilde)(process.env.OPENCODE_CONFIG));
-		if (process.env.XDG_CONFIG_HOME) return path$2.join((0, base_js_1.expandTilde)(process.env.XDG_CONFIG_HOME), "opencode");
-		return path$2.join(os$2.homedir(), ".config", "opencode");
-	}
-	/**
-	* Get the global config directory for OpenCode.
-	* Priority: explicitDir > env vars (via getOpencodeGlobalDir)
-	*/
-	function getGlobalDir(explicitDir) {
-		if (explicitDir) return (0, base_js_1.expandTilde)(explicitDir);
-		return getOpencodeGlobalDir();
-	}
-	/**
-	* Get the config directory path relative to home for hook templating.
-	*/
-	function getConfigDirFromHome(isGlobal) {
-		if (!isGlobal) return "'.opencode'";
-		return "'.config', 'opencode'";
-	}
-	/**
-	* Transform markdown content for OpenCode installation.
-	* Applies frontmatter conversion and path replacement.
-	*/
-	function transformContent(content, pathPrefix) {
-		let result = (0, content_js_1.replacePathReferences)(content, pathPrefix, ".opencode");
-		result = result.replace(/~\/\.opencode\//g, pathPrefix);
-		result = (0, frontmatter_js_1.convertClaudeToOpencodeFrontmatter)(result);
-		return result;
-	}
-	/**
-	* OpenCode adapter configuration.
-	* OpenCode uses flat command structure (command/maxsim-*.md).
-	*/
-	exports.opencodeAdapter = {
-		runtime: "opencode",
-		dirName: ".opencode",
-		getGlobalDir,
-		getConfigDirFromHome,
-		transformContent,
-		commandStructure: "flat"
-	};
-}));
+//#region src/adapters/transforms/tool-maps.ts
+/**
+* @maxsim/adapters — Tool name mappings per runtime
+*
+* Ported from bin/install.js lines ~327-390
+*/
+/** Tool name mapping from Claude Code to OpenCode */
+const claudeToOpencodeTools = {
+	AskUserQuestion: "question",
+	SlashCommand: "skill",
+	TodoWrite: "todowrite",
+	WebFetch: "webfetch",
+	WebSearch: "websearch"
+};
+/** Tool name mapping from Claude Code to Gemini CLI */
+const claudeToGeminiTools = {
+	Read: "read_file",
+	Write: "write_file",
+	Edit: "replace",
+	Bash: "run_shell_command",
+	Glob: "glob",
+	Grep: "search_file_content",
+	WebSearch: "google_web_search",
+	WebFetch: "web_fetch",
+	TodoWrite: "write_todos",
+	AskUserQuestion: "ask_user"
+};
+/**
+* Convert a Claude Code tool name to OpenCode format.
+* - Applies special mappings (AskUserQuestion -> question, etc.)
+* - Converts to lowercase (except MCP tools which keep their format)
+*/
+function convertToolName(claudeTool) {
+	if (claudeToOpencodeTools[claudeTool]) return claudeToOpencodeTools[claudeTool];
+	if (claudeTool.startsWith("mcp__")) return claudeTool;
+	return claudeTool.toLowerCase();
+}
+/**
+* Convert a Claude Code tool name to Gemini CLI format.
+* - Applies Claude->Gemini mapping (Read->read_file, Bash->run_shell_command, etc.)
+* - Filters out MCP tools (mcp__*) -- auto-discovered at runtime in Gemini
+* - Filters out Task -- agents are auto-registered as tools in Gemini
+* @returns Gemini tool name, or null if tool should be excluded
+*/
+function convertGeminiToolName(claudeTool) {
+	if (claudeTool.startsWith("mcp__")) return null;
+	if (claudeTool === "Task") return null;
+	if (claudeToGeminiTools[claudeTool]) return claudeToGeminiTools[claudeTool];
+	return claudeTool.toLowerCase();
+}
 
 //#endregion
-//#region ../adapters/dist/gemini.js
-var require_gemini = /* @__PURE__ */ __commonJSMin(((exports) => {
-	/**
-	* @maxsim/adapters — Gemini adapter
-	*
-	* Ports the Gemini-specific logic from bin/install.js:
-	*   - getGlobalDir('gemini', ...)         (lines 113-122)
-	*   - getDirName('gemini')                (line 47)
-	*   - getConfigDirFromHome('gemini', isGlobal) (line 69)
-	*   - convertClaudeToGeminiToml + convertClaudeToGeminiAgent + stripSubTags
-	*/
-	var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
-		if (k2 === void 0) k2 = k;
-		var desc = Object.getOwnPropertyDescriptor(m, k);
-		if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) desc = {
-			enumerable: true,
-			get: function() {
-				return m[k];
-			}
-		};
-		Object.defineProperty(o, k2, desc);
-	}) : (function(o, m, k, k2) {
-		if (k2 === void 0) k2 = k;
-		o[k2] = m[k];
-	}));
-	var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
-		Object.defineProperty(o, "default", {
-			enumerable: true,
-			value: v
-		});
-	}) : function(o, v) {
-		o["default"] = v;
+//#region src/adapters/transforms/content.ts
+/**
+* @maxsim/adapters — Content transformation utilities
+*
+* Ported from bin/install.js lines ~423-564
+*/
+/**
+* Convert /maxsim:command-name to $maxsim-command-name for Codex skill mentions.
+* Ported from install.js line ~423
+*/
+function convertSlashCommandsToCodexSkillMentions(content) {
+	let converted = content.replace(/\/maxsim:([a-z0-9-]+)/gi, (_, commandName) => {
+		return `$maxsim-${String(commandName).toLowerCase()}`;
 	});
-	var __importStar = exports && exports.__importStar || (function() {
-		var ownKeys = function(o) {
-			ownKeys = Object.getOwnPropertyNames || function(o) {
-				var ar = [];
-				for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-				return ar;
-			};
-			return ownKeys(o);
-		};
-		return function(mod) {
-			if (mod && mod.__esModule) return mod;
-			var result = {};
-			if (mod != null) {
-				for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-			}
-			__setModuleDefault(result, mod);
-			return result;
-		};
-	})();
-	Object.defineProperty(exports, "__esModule", { value: true });
-	exports.stripSubTags = exports.convertClaudeToGeminiAgent = exports.convertClaudeToGeminiToml = exports.geminiAdapter = void 0;
-	const path$1 = __importStar(require("node:path"));
-	const os$1 = __importStar(require("node:os"));
-	const base_js_1 = require_base();
-	const frontmatter_js_1 = require_frontmatter();
-	Object.defineProperty(exports, "convertClaudeToGeminiToml", {
-		enumerable: true,
-		get: function() {
-			return frontmatter_js_1.convertClaudeToGeminiToml;
+	converted = converted.replace(/\/maxsim-help\b/g, "$maxsim-help");
+	return converted;
+}
+/**
+* Convert Claude markdown to Codex markdown format.
+* Replaces slash commands and $ARGUMENTS placeholder.
+* Ported from install.js line ~431
+*/
+function convertClaudeToCodexMarkdown(content) {
+	let converted = convertSlashCommandsToCodexSkillMentions(content);
+	converted = converted.replace(/\$ARGUMENTS\b/g, "{{MAXSIM_ARGS}}");
+	return converted;
+}
+/**
+* Strip HTML <sub> tags for Gemini CLI output.
+* Terminals don't support subscript -- converts <sub>text</sub> to italic *(text)*.
+* Ported from install.js line ~474
+*/
+function stripSubTags(content) {
+	return content.replace(/<sub>(.*?)<\/sub>/g, "*($1)*");
+}
+/**
+* Convert Claude Code agent frontmatter to Gemini CLI format.
+* - tools: must be a YAML array (not comma-separated string)
+* - tool names: must use Gemini built-in names (read_file, not Read)
+* - color: must be removed (causes validation error)
+* - mcp__* tools: must be excluded (auto-discovered at runtime)
+* - ${VAR} patterns: escaped to $VAR for Gemini template compatibility
+*
+* Ported from install.js line ~487
+*/
+function convertClaudeToGeminiAgent(content) {
+	if (!content.startsWith("---")) return content;
+	const endIndex = content.indexOf("---", 3);
+	if (endIndex === -1) return content;
+	const frontmatter = content.substring(3, endIndex).trim();
+	const body = content.substring(endIndex + 3);
+	const lines = frontmatter.split("\n");
+	const newLines = [];
+	let inAllowedTools = false;
+	const tools = [];
+	for (const line of lines) {
+		const trimmed = line.trim();
+		if (trimmed.startsWith("allowed-tools:")) {
+			inAllowedTools = true;
+			continue;
 		}
-	});
-	const content_js_1 = require_content();
-	Object.defineProperty(exports, "convertClaudeToGeminiAgent", {
-		enumerable: true,
-		get: function() {
-			return content_js_1.convertClaudeToGeminiAgent;
+		if (trimmed.startsWith("tools:")) {
+			const toolsValue = trimmed.substring(6).trim();
+			if (toolsValue) {
+				const parsed = toolsValue.split(",").map((t) => t.trim()).filter((t) => t);
+				for (const t of parsed) {
+					const mapped = convertGeminiToolName(t);
+					if (mapped) tools.push(mapped);
+				}
+			} else inAllowedTools = true;
+			continue;
 		}
-	});
-	Object.defineProperty(exports, "stripSubTags", {
-		enumerable: true,
-		get: function() {
-			return content_js_1.stripSubTags;
+		if (trimmed.startsWith("color:")) continue;
+		if (inAllowedTools) {
+			if (trimmed.startsWith("- ")) {
+				const mapped = convertGeminiToolName(trimmed.substring(2).trim());
+				if (mapped) tools.push(mapped);
+				continue;
+			} else if (trimmed && !trimmed.startsWith("-")) inAllowedTools = false;
 		}
-	});
-	/**
-	* Get the global config directory for Gemini.
-	* Priority: explicitDir > GEMINI_CONFIG_DIR env > ~/.gemini
-	*/
-	function getGlobalDir(explicitDir) {
-		if (explicitDir) return (0, base_js_1.expandTilde)(explicitDir);
-		if (process.env.GEMINI_CONFIG_DIR) return (0, base_js_1.expandTilde)(process.env.GEMINI_CONFIG_DIR);
-		return path$1.join(os$1.homedir(), ".gemini");
-	}
-	/**
-	* Get the config directory path relative to home for hook templating.
-	*/
-	function getConfigDirFromHome(_isGlobal) {
-		return "'.gemini'";
+		if (!inAllowedTools) newLines.push(line);
 	}
-	/**
-	* Transform markdown content for Gemini installation.
-	* Applies TOML conversion for commands, agent conversion for agents,
-	* stripSubTags, and path replacement.
-	*/
-	function transformContent(content, pathPrefix) {
-		let result = (0, content_js_1.replacePathReferences)(content, pathPrefix, ".gemini");
-		result = (0, content_js_1.stripSubTags)(result);
-		result = (0, frontmatter_js_1.convertClaudeToGeminiToml)(result);
-		return result;
+	if (tools.length > 0) {
+		newLines.push("tools:");
+		for (const tool of tools) newLines.push(`  - ${tool}`);
 	}
-	/**
-	* Gemini adapter configuration.
-	* Gemini uses nested command structure (commands/maxsim/*.toml).
-	*/
-	exports.geminiAdapter = {
-		runtime: "gemini",
-		dirName: ".gemini",
-		getGlobalDir,
-		getConfigDirFromHome,
-		transformContent,
-		commandStructure: "nested"
-	};
-}));
+	return `---\n${newLines.join("\n").trim()}\n---${stripSubTags(body.replace(/\$\{(\w+)\}/g, "$$$1"))}`;
+}
+/**
+* Replace path references in markdown content for a target runtime.
+* Replaces ~/.claude/ with pathPrefix and ./.claude/ with ./dirName/.
+*/
+function replacePathReferences(content, pathPrefix, dirName) {
+	const globalClaudeRegex = /~\/\.claude\//g;
+	const localClaudeRegex = /\.\/\.claude\//g;
+	let result = content.replace(globalClaudeRegex, pathPrefix);
+	result = result.replace(localClaudeRegex, `./${dirName}/`);
+	return result;
+}
 
 //#endregion
-//#region ../adapters/dist/codex.js
-var require_codex = /* @__PURE__ */ __commonJSMin(((exports) => {
-	/**
-	* @maxsim/adapters — Codex adapter
-	*
-	* Ports the Codex-specific logic from bin/install.js:
-	*   - getGlobalDir('codex', ...)         (lines 124-133)
-	*   - getDirName('codex')                (line 48)
-	*   - getConfigDirFromHome('codex', isGlobal) (line 70)
-	*   - convertClaudeCommandToCodexSkill + convertClaudeToCodexMarkdown
-	*/
-	var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
-		if (k2 === void 0) k2 = k;
-		var desc = Object.getOwnPropertyDescriptor(m, k);
-		if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) desc = {
-			enumerable: true,
-			get: function() {
-				return m[k];
+//#region src/adapters/transforms/frontmatter.ts
+/**
+* @maxsim/adapters — Frontmatter conversion functions for opencode, gemini, codex
+*
+* Ported from bin/install.js lines ~308-711
+*/
+/** Color name to hex mapping for opencode compatibility */
+const colorNameToHex = {
+	cyan: "#00FFFF",
+	red: "#FF0000",
+	green: "#00FF00",
+	blue: "#0000FF",
+	yellow: "#FFFF00",
+	magenta: "#FF00FF",
+	orange: "#FFA500",
+	purple: "#800080",
+	pink: "#FFC0CB",
+	white: "#FFFFFF",
+	black: "#000000",
+	gray: "#808080",
+	grey: "#808080"
+};
+/** Collapse whitespace to single line */
+function toSingleLine(value) {
+	return value.replace(/\s+/g, " ").trim();
+}
+/** Quote a value for YAML using JSON.stringify */
+function yamlQuote(value) {
+	return JSON.stringify(value);
+}
+/** Extract a single-line field value from YAML frontmatter text */
+function extractFrontmatterField(frontmatter, fieldName) {
+	const regex = new RegExp(`^${fieldName}:\\s*(.+)$`, "m");
+	const match = frontmatter.match(regex);
+	if (!match) return null;
+	return match[1].trim().replace(/^['"]|['"]$/g, "");
+}
+/**
+* Convert Claude Code frontmatter to OpenCode format.
+* - Converts 'allowed-tools:' array to 'tools:' object with tool: true entries
+* - Converts color names to hex
+* - Removes name: field (opencode uses filename)
+* - Replaces tool name references in body content
+* - Replaces /maxsim: with /maxsim- (flat command structure)
+* - Replaces ~/.claude with ~/.config/opencode
+* - Replaces subagent_type="general-purpose" with "general"
+*
+* Ported from install.js line ~566
+*/
+function convertClaudeToOpencodeFrontmatter(content) {
+	let convertedContent = content;
+	convertedContent = convertedContent.replace(/\bAskUserQuestion\b/g, "question");
+	convertedContent = convertedContent.replace(/\bSlashCommand\b/g, "skill");
+	convertedContent = convertedContent.replace(/\bTodoWrite\b/g, "todowrite");
+	convertedContent = convertedContent.replace(/\/maxsim:/g, "/maxsim-");
+	convertedContent = convertedContent.replace(/~\/\.claude\b/g, "~/.config/opencode");
+	convertedContent = convertedContent.replace(/subagent_type="general-purpose"/g, "subagent_type=\"general\"");
+	if (!convertedContent.startsWith("---")) return convertedContent;
+	const endIndex = convertedContent.indexOf("---", 3);
+	if (endIndex === -1) return convertedContent;
+	const frontmatter = convertedContent.substring(3, endIndex).trim();
+	const body = convertedContent.substring(endIndex + 3);
+	const lines = frontmatter.split("\n");
+	const newLines = [];
+	let inAllowedTools = false;
+	const allowedTools = [];
+	for (const line of lines) {
+		const trimmed = line.trim();
+		if (trimmed.startsWith("allowed-tools:")) {
+			inAllowedTools = true;
+			continue;
+		}
+		if (trimmed.startsWith("tools:")) {
+			const toolsValue = trimmed.substring(6).trim();
+			if (toolsValue) {
+				const tools = toolsValue.split(",").map((t) => t.trim()).filter((t) => t);
+				allowedTools.push(...tools);
 			}
-		};
-		Object.defineProperty(o, k2, desc);
-	}) : (function(o, m, k, k2) {
-		if (k2 === void 0) k2 = k;
-		o[k2] = m[k];
-	}));
-	var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
-		Object.defineProperty(o, "default", {
-			enumerable: true,
-			value: v
-		});
-	}) : function(o, v) {
-		o["default"] = v;
-	});
-	var __importStar = exports && exports.__importStar || (function() {
-		var ownKeys = function(o) {
-			ownKeys = Object.getOwnPropertyNames || function(o) {
-				var ar = [];
-				for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-				return ar;
-			};
-			return ownKeys(o);
-		};
-		return function(mod) {
-			if (mod && mod.__esModule) return mod;
-			var result = {};
-			if (mod != null) {
-				for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+			continue;
+		}
+		if (trimmed.startsWith("name:")) continue;
+		if (trimmed.startsWith("color:")) {
+			const colorValue = trimmed.substring(6).trim().toLowerCase();
+			const hexColor = colorNameToHex[colorValue];
+			if (hexColor) newLines.push(`color: "${hexColor}"`);
+			else if (colorValue.startsWith("#")) {
+				if (/^#[0-9a-f]{3}$|^#[0-9a-f]{6}$/i.test(colorValue)) newLines.push(line);
 			}
-			__setModuleDefault(result, mod);
-			return result;
-		};
-	})();
-	Object.defineProperty(exports, "__esModule", { value: true });
-	exports.convertClaudeToCodexMarkdown = exports.convertClaudeCommandToCodexSkill = exports.codexAdapter = void 0;
-	const path = __importStar(require("node:path"));
-	const os = __importStar(require("node:os"));
-	const base_js_1 = require_base();
-	const frontmatter_js_1 = require_frontmatter();
-	Object.defineProperty(exports, "convertClaudeCommandToCodexSkill", {
-		enumerable: true,
-		get: function() {
-			return frontmatter_js_1.convertClaudeCommandToCodexSkill;
+			continue;
 		}
-	});
-	const content_js_1 = require_content();
-	Object.defineProperty(exports, "convertClaudeToCodexMarkdown", {
-		enumerable: true,
-		get: function() {
-			return content_js_1.convertClaudeToCodexMarkdown;
+		if (inAllowedTools) {
+			if (trimmed.startsWith("- ")) {
+				allowedTools.push(trimmed.substring(2).trim());
+				continue;
+			} else if (trimmed && !trimmed.startsWith("-")) inAllowedTools = false;
 		}
-	});
-	/**
-	* Get the global config directory for Codex.
-	* Priority: explicitDir > CODEX_HOME env > ~/.codex
-	*/
-	function getGlobalDir(explicitDir) {
-		if (explicitDir) return (0, base_js_1.expandTilde)(explicitDir);
-		if (process.env.CODEX_HOME) return (0, base_js_1.expandTilde)(process.env.CODEX_HOME);
-		return path.join(os.homedir(), ".codex");
-	}
-	/**
-	* Get the config directory path relative to home for hook templating.
-	*/
-	function getConfigDirFromHome(_isGlobal) {
-		return "'.codex'";
+		if (!inAllowedTools) newLines.push(line);
 	}
-	/**
-	* Transform markdown content for Codex installation.
-	* Applies Codex markdown conversion and path replacement.
-	*/
-	function transformContent(content, pathPrefix) {
-		let result = (0, content_js_1.replacePathReferences)(content, pathPrefix, ".codex");
-		result = result.replace(/~\/\.codex\//g, pathPrefix);
-		result = (0, frontmatter_js_1.convertClaudeCommandToCodexSkill)(result);
-		return result;
+	if (allowedTools.length > 0) {
+		newLines.push("tools:");
+		for (const tool of allowedTools) newLines.push(`  ${convertToolName(tool)}: true`);
 	}
-	/**
-	* Codex adapter configuration.
-	* Codex uses skill-based command structure (skills/maxsim-star/SKILL.md).
-	*/
-	exports.codexAdapter = {
-		runtime: "codex",
-		dirName: ".codex",
-		getGlobalDir,
-		getConfigDirFromHome,
-		transformContent,
-		commandStructure: "skills"
-	};
-}));
+	return `---\n${newLines.join("\n").trim()}\n---${body}`;
+}
+/**
+* Convert Claude Code markdown command to Gemini TOML format.
+* Ported from install.js line ~677
+*/
+function convertClaudeToGeminiToml(content) {
+	if (!content.startsWith("---")) return `prompt = ${JSON.stringify(content)}\n`;
+	const endIndex = content.indexOf("---", 3);
+	if (endIndex === -1) return `prompt = ${JSON.stringify(content)}\n`;
+	const frontmatter = content.substring(3, endIndex).trim();
+	const body = content.substring(endIndex + 3).trim();
+	let description = "";
+	const lines = frontmatter.split("\n");
+	for (const line of lines) {
+		const trimmed = line.trim();
+		if (trimmed.startsWith("description:")) {
+			description = trimmed.substring(12).trim();
+			break;
+		}
+	}
+	let toml = "";
+	if (description) toml += `description = ${JSON.stringify(description)}\n`;
+	toml += `prompt = ${JSON.stringify(body)}\n`;
+	return toml;
+}
+/**
+* Convert Claude command to Codex skill format with adapter header.
+* Ported from install.js line ~452
+*/
+function convertClaudeCommandToCodexSkill(content, skillName) {
+	const { frontmatter, body } = extractFrontmatterAndBody(convertClaudeToCodexMarkdown(content));
+	let description = `Run MAXSIM workflow ${skillName}.`;
+	if (frontmatter) {
+		const maybeDescription = extractFrontmatterField(frontmatter, "description");
+		if (maybeDescription) description = maybeDescription;
+	}
+	description = toSingleLine(description);
+	const shortDescription = description.length > 180 ? `${description.slice(0, 177)}...` : description;
+	const adapter = getCodexSkillAdapterHeader(skillName);
+	return `---\nname: ${yamlQuote(skillName)}\ndescription: ${yamlQuote(description)}\nmetadata:\n  short-description: ${yamlQuote(shortDescription)}\n---\n\n${adapter}\n\n${body.trimStart()}`;
+}
+/**
+* Generate the Codex skill adapter header block.
+* Ported from install.js line ~437
+*/
+function getCodexSkillAdapterHeader(skillName) {
+	const invocation = `$${skillName}`;
+	return `<codex_skill_adapter>
+Codex skills-first mode:
+- This skill is invoked by mentioning \`${invocation}\`.
+- Treat all user text after \`${invocation}\` as \`{{MAXSIM_ARGS}}\`.
+- If no arguments are present, treat \`{{MAXSIM_ARGS}}\` as empty.
+
+Legacy orchestration compatibility:
+- Any \`Task(...)\` pattern in referenced workflow docs is legacy syntax.
+- Implement equivalent behavior with Codex collaboration tools: \`spawn_agent\`, \`wait\`, \`send_input\`, and \`close_agent\`.
+- Treat legacy \`subagent_type\` names as role hints in the spawned message.
+</codex_skill_adapter>`;
+}
 
 //#endregion
-//#region ../adapters/dist/index.js
-var require_dist = /* @__PURE__ */ __commonJSMin(((exports) => {
-	/**
-	* @maxsim/adapters — Runtime adapter registry
-	*/
-	Object.defineProperty(exports, "__esModule", { value: true });
-	exports.replacePathReferences = exports.convertClaudeToGeminiAgent = exports.stripSubTags = exports.convertClaudeToCodexMarkdown = exports.convertSlashCommandsToCodexSkillMentions = exports.getCodexSkillAdapterHeader = exports.convertClaudeCommandToCodexSkill = exports.convertClaudeToGeminiToml = exports.convertClaudeToOpencodeFrontmatter = exports.extractFrontmatterField = exports.yamlQuote = exports.toSingleLine = exports.colorNameToHex = exports.convertGeminiToolName = exports.convertToolName = exports.writeSettings = exports.readSettings = exports.buildHookCommand = exports.processAttribution = exports.extractFrontmatterAndBody = exports.expandTilde = exports.codexAdapter = exports.geminiAdapter = exports.opencodeAdapter = exports.installClaude = exports.claudeAdapter = void 0;
-	const claude_js_1 = require_claude();
-	const opencode_js_1 = require_opencode();
-	const gemini_js_1 = require_gemini();
-	const codex_js_1 = require_codex();
-	var claude_js_2 = require_claude();
-	Object.defineProperty(exports, "claudeAdapter", {
-		enumerable: true,
-		get: function() {
-			return claude_js_2.claudeAdapter;
-		}
-	});
-	var claude_js_3 = require_claude();
-	Object.defineProperty(exports, "installClaude", {
-		enumerable: true,
-		get: function() {
-			return claude_js_3.installClaude;
-		}
-	});
-	var opencode_js_2 = require_opencode();
-	Object.defineProperty(exports, "opencodeAdapter", {
-		enumerable: true,
-		get: function() {
-			return opencode_js_2.opencodeAdapter;
-		}
-	});
-	var gemini_js_2 = require_gemini();
-	Object.defineProperty(exports, "geminiAdapter", {
-		enumerable: true,
-		get: function() {
-			return gemini_js_2.geminiAdapter;
-		}
-	});
-	var codex_js_2 = require_codex();
-	Object.defineProperty(exports, "codexAdapter", {
-		enumerable: true,
-		get: function() {
-			return codex_js_2.codexAdapter;
-		}
-	});
-	var base_js_1 = require_base();
-	Object.defineProperty(exports, "expandTilde", {
-		enumerable: true,
-		get: function() {
-			return base_js_1.expandTilde;
-		}
-	});
-	Object.defineProperty(exports, "extractFrontmatterAndBody", {
-		enumerable: true,
-		get: function() {
-			return base_js_1.extractFrontmatterAndBody;
-		}
-	});
-	Object.defineProperty(exports, "processAttribution", {
-		enumerable: true,
-		get: function() {
-			return base_js_1.processAttribution;
-		}
-	});
-	Object.defineProperty(exports, "buildHookCommand", {
-		enumerable: true,
-		get: function() {
-			return base_js_1.buildHookCommand;
-		}
-	});
-	Object.defineProperty(exports, "readSettings", {
-		enumerable: true,
-		get: function() {
-			return base_js_1.readSettings;
-		}
-	});
-	Object.defineProperty(exports, "writeSettings", {
-		enumerable: true,
-		get: function() {
-			return base_js_1.writeSettings;
-		}
-	});
-	var tool_maps_js_1 = require_tool_maps();
-	Object.defineProperty(exports, "convertToolName", {
-		enumerable: true,
-		get: function() {
-			return tool_maps_js_1.convertToolName;
-		}
-	});
-	Object.defineProperty(exports, "convertGeminiToolName", {
-		enumerable: true,
-		get: function() {
-			return tool_maps_js_1.convertGeminiToolName;
-		}
-	});
-	var frontmatter_js_1 = require_frontmatter();
-	Object.defineProperty(exports, "colorNameToHex", {
-		enumerable: true,
-		get: function() {
-			return frontmatter_js_1.colorNameToHex;
-		}
-	});
-	Object.defineProperty(exports, "toSingleLine", {
-		enumerable: true,
-		get: function() {
-			return frontmatter_js_1.toSingleLine;
-		}
-	});
-	Object.defineProperty(exports, "yamlQuote", {
-		enumerable: true,
-		get: function() {
-			return frontmatter_js_1.yamlQuote;
-		}
-	});
-	Object.defineProperty(exports, "extractFrontmatterField", {
-		enumerable: true,
-		get: function() {
-			return frontmatter_js_1.extractFrontmatterField;
-		}
-	});
-	Object.defineProperty(exports, "convertClaudeToOpencodeFrontmatter", {
-		enumerable: true,
-		get: function() {
-			return frontmatter_js_1.convertClaudeToOpencodeFrontmatter;
-		}
-	});
-	Object.defineProperty(exports, "convertClaudeToGeminiToml", {
-		enumerable: true,
-		get: function() {
-			return frontmatter_js_1.convertClaudeToGeminiToml;
-		}
-	});
-	Object.defineProperty(exports, "convertClaudeCommandToCodexSkill", {
-		enumerable: true,
-		get: function() {
-			return frontmatter_js_1.convertClaudeCommandToCodexSkill;
-		}
-	});
-	Object.defineProperty(exports, "getCodexSkillAdapterHeader", {
-		enumerable: true,
-		get: function() {
-			return frontmatter_js_1.getCodexSkillAdapterHeader;
-		}
-	});
-	var content_js_1 = require_content();
-	Object.defineProperty(exports, "convertSlashCommandsToCodexSkillMentions", {
-		enumerable: true,
-		get: function() {
-			return content_js_1.convertSlashCommandsToCodexSkillMentions;
-		}
-	});
-	Object.defineProperty(exports, "convertClaudeToCodexMarkdown", {
-		enumerable: true,
-		get: function() {
-			return content_js_1.convertClaudeToCodexMarkdown;
-		}
-	});
-	Object.defineProperty(exports, "stripSubTags", {
-		enumerable: true,
-		get: function() {
-			return content_js_1.stripSubTags;
-		}
-	});
-	Object.defineProperty(exports, "convertClaudeToGeminiAgent", {
-		enumerable: true,
-		get: function() {
-			return content_js_1.convertClaudeToGeminiAgent;
-		}
-	});
-	Object.defineProperty(exports, "replacePathReferences", {
-		enumerable: true,
-		get: function() {
-			return content_js_1.replacePathReferences;
-		}
-	});
-}));
+//#region src/adapters/opencode.ts
+/**
+* @maxsim/adapters — OpenCode adapter
+*
+* Ports the OpenCode-specific logic from bin/install.js:
+*   - getOpencodeGlobalDir()           (lines 79-97)
+*   - getGlobalDir('opencode', ...)    (lines 104-111)
+*   - getDirName('opencode')           (line 46)
+*   - getConfigDirFromHome('opencode', isGlobal) (lines 58-68)
+*   - convertClaudeToOpencodeFrontmatter + path replacement
+*/
+/**
+* Get the global config directory for OpenCode.
+* OpenCode follows XDG Base Directory spec and uses ~/.config/opencode/.
+* Priority: OPENCODE_CONFIG_DIR > dirname(OPENCODE_CONFIG) > XDG_CONFIG_HOME/opencode > ~/.config/opencode
+*/
+function getOpencodeGlobalDir$1() {
+	if (process.env.OPENCODE_CONFIG_DIR) return expandTilde(process.env.OPENCODE_CONFIG_DIR);
+	if (process.env.OPENCODE_CONFIG) return node_path.dirname(expandTilde(process.env.OPENCODE_CONFIG));
+	if (process.env.XDG_CONFIG_HOME) return node_path.join(expandTilde(process.env.XDG_CONFIG_HOME), "opencode");
+	return node_path.join(node_os.homedir(), ".config", "opencode");
+}
+/**
+* Get the global config directory for OpenCode.
+* Priority: explicitDir > env vars (via getOpencodeGlobalDir)
+*/
+function getGlobalDir$3(explicitDir) {
+	if (explicitDir) return expandTilde(explicitDir);
+	return getOpencodeGlobalDir$1();
+}
+/**
+* Get the config directory path relative to home for hook templating.
+*/
+function getConfigDirFromHome$3(isGlobal) {
+	if (!isGlobal) return "'.opencode'";
+	return "'.config', 'opencode'";
+}
+/**
+* Transform markdown content for OpenCode installation.
+* Applies frontmatter conversion and path replacement.
+*/
+function transformContent$2(content, pathPrefix) {
+	let result = replacePathReferences(content, pathPrefix, ".opencode");
+	result = result.replace(/~\/\.opencode\//g, pathPrefix);
+	result = convertClaudeToOpencodeFrontmatter(result);
+	return result;
+}
+/**
+* OpenCode adapter configuration.
+* OpenCode uses flat command structure (command/maxsim-*.md).
+*/
+const opencodeAdapter = {
+	runtime: "opencode",
+	dirName: ".opencode",
+	getGlobalDir: getGlobalDir$3,
+	getConfigDirFromHome: getConfigDirFromHome$3,
+	transformContent: transformContent$2,
+	commandStructure: "flat"
+};
+
+//#endregion
+//#region src/adapters/gemini.ts
+/**
+* @maxsim/adapters — Gemini adapter
+*
+* Ports the Gemini-specific logic from bin/install.js:
+*   - getGlobalDir('gemini', ...)         (lines 113-122)
+*   - getDirName('gemini')                (line 47)
+*   - getConfigDirFromHome('gemini', isGlobal) (line 69)
+*   - convertClaudeToGeminiToml + convertClaudeToGeminiAgent + stripSubTags
+*/
+/**
+* Get the global config directory for Gemini.
+* Priority: explicitDir > GEMINI_CONFIG_DIR env > ~/.gemini
+*/
+function getGlobalDir$2(explicitDir) {
+	if (explicitDir) return expandTilde(explicitDir);
+	if (process.env.GEMINI_CONFIG_DIR) return expandTilde(process.env.GEMINI_CONFIG_DIR);
+	return node_path.join(node_os.homedir(), ".gemini");
+}
+/**
+* Get the config directory path relative to home for hook templating.
+*/
+function getConfigDirFromHome$2(_isGlobal) {
+	return "'.gemini'";
+}
+/**
+* Transform markdown content for Gemini installation.
+* Applies TOML conversion for commands, agent conversion for agents,
+* stripSubTags, and path replacement.
+*/
+function transformContent$1(content, pathPrefix) {
+	let result = replacePathReferences(content, pathPrefix, ".gemini");
+	result = stripSubTags(result);
+	result = convertClaudeToGeminiToml(result);
+	return result;
+}
+/**
+* Gemini adapter configuration.
+* Gemini uses nested command structure (commands/maxsim/*.toml).
+*/
+const geminiAdapter = {
+	runtime: "gemini",
+	dirName: ".gemini",
+	getGlobalDir: getGlobalDir$2,
+	getConfigDirFromHome: getConfigDirFromHome$2,
+	transformContent: transformContent$1,
+	commandStructure: "nested"
+};
+
+//#endregion
+//#region src/adapters/codex.ts
+/**
+* @maxsim/adapters — Codex adapter
+*
+* Ports the Codex-specific logic from bin/install.js:
+*   - getGlobalDir('codex', ...)         (lines 124-133)
+*   - getDirName('codex')                (line 48)
+*   - getConfigDirFromHome('codex', isGlobal) (line 70)
+*   - convertClaudeCommandToCodexSkill + convertClaudeToCodexMarkdown
+*/
+/**
+* Get the global config directory for Codex.
+* Priority: explicitDir > CODEX_HOME env > ~/.codex
+*/
+function getGlobalDir$1(explicitDir) {
+	if (explicitDir) return expandTilde(explicitDir);
+	if (process.env.CODEX_HOME) return expandTilde(process.env.CODEX_HOME);
+	return node_path.join(node_os.homedir(), ".codex");
+}
+/**
+* Get the config directory path relative to home for hook templating.
+*/
+function getConfigDirFromHome$1(_isGlobal) {
+	return "'.codex'";
+}
+/**
+* Transform markdown content for Codex installation.
+* Applies Codex markdown conversion and path replacement.
+*/
+function transformContent(content, pathPrefix) {
+	let result = replacePathReferences(content, pathPrefix, ".codex");
+	result = result.replace(/~\/\.codex\//g, pathPrefix);
+	result = convertClaudeCommandToCodexSkill(result);
+	return result;
+}
+/**
+* Codex adapter configuration.
+* Codex uses skill-based command structure (skills/maxsim-star/SKILL.md).
+*/
+const codexAdapter = {
+	runtime: "codex",
+	dirName: ".codex",
+	getGlobalDir: getGlobalDir$1,
+	getConfigDirFromHome: getConfigDirFromHome$1,
+	transformContent,
+	commandStructure: "skills"
+};
 
 //#endregion
 //#region src/install.ts
-var import_dist = require_dist();
 const pkg = JSON.parse(node_fs.readFileSync(node_path.resolve(__dirname, "..", "package.json"), "utf-8"));
 const templatesRoot = node_path.resolve(__dirname, "assets", "templates");
 const args = process.argv.slice(2);
@@ -6513,10 +8142,10 @@ else {
 * Adapter registry keyed by runtime name
 */
 const adapterMap = {
-	claude: import_dist.claudeAdapter,
-	opencode: import_dist.opencodeAdapter,
-	gemini: import_dist.geminiAdapter,
-	codex: import_dist.codexAdapter
+	claude: claudeAdapter,
+	opencode: opencodeAdapter,
+	gemini: geminiAdapter,
+	codex: codexAdapter
 };
 /**
 * Get adapter for a runtime
@@ -6544,56 +8173,23 @@ function getDirName(runtime) {
 }
 /**
 * Recursively remove a directory, handling Windows read-only file attributes.
-* fs.rmSync with { force: true } only ignores ENOENT — it does NOT remove
-* read-only files on Windows (EPERM). We chmod recursively first on EPERM.
+* fs-extra handles cross-platform edge cases (EPERM on Windows, symlinks, etc.)
 */
 function safeRmDir(dirPath) {
-	if (!node_fs.existsSync(dirPath)) return;
-	try {
-		node_fs.rmSync(dirPath, {
-			recursive: true,
-			force: true
-		});
-	} catch (e) {
-		if (e.code === "EPERM" && process.platform === "win32") {
-			const chmodRecursive = (p) => {
-				try {
-					node_fs.chmodSync(p, 438);
-				} catch {}
-				try {
-					for (const entry of node_fs.readdirSync(p, { withFileTypes: true })) chmodRecursive(node_path.join(p, entry.name));
-				} catch {}
-			};
-			chmodRecursive(dirPath);
-			node_fs.rmSync(dirPath, {
-				recursive: true,
-				force: true
-			});
-		} else throw e;
-	}
+	import_lib.default.removeSync(dirPath);
 }
 /**
-* Recursively copy a directory (plain copy, no path replacement)
+* Recursively copy a directory (dereferences symlinks)
 */
 function copyDirRecursive(src, dest) {
-	node_fs.mkdirSync(dest, { recursive: true });
-	for (const entry of node_fs.readdirSync(src, { withFileTypes: true })) {
-		const srcPath = node_path.join(src, entry.name);
-		const destPath = node_path.join(dest, entry.name);
-		if (entry.isDirectory()) copyDirRecursive(srcPath, destPath);
-		else if (entry.isSymbolicLink()) {
-			const target = node_fs.realpathSync(srcPath);
-			if (node_fs.statSync(target).isDirectory()) copyDirRecursive(target, destPath);
-			else node_fs.copyFileSync(target, destPath);
-		} else node_fs.copyFileSync(srcPath, destPath);
-	}
+	import_lib.default.copySync(src, dest, { dereference: true });
 }
 /**
 * Get the global config directory for OpenCode (for JSONC permissions)
 * OpenCode follows XDG Base Directory spec
 */
 function getOpencodeGlobalDir() {
-	return import_dist.opencodeAdapter.getGlobalDir();
+	return opencodeAdapter.getGlobalDir();
 }
 const banner = "\n" + chalk.cyan(figlet.default.textSync("MAXSIM", { font: "ANSI Shadow" }).split("\n").map((line) => "  " + line).join("\n")) + "\n\n  MAXSIM " + chalk.dim("v" + pkg.version) + "\n  A meta-prompting, context engineering and spec-driven\n  development system for Claude Code, OpenCode, Gemini, and Codex.\n";
 function parseConfigDirArg() {
@@ -6638,14 +8234,14 @@ const attributionCache = /* @__PURE__ */ new Map();
 function getCommitAttribution(runtime) {
 	if (attributionCache.has(runtime)) return attributionCache.get(runtime);
 	let result;
-	if (runtime === "opencode") result = (0, import_dist.readSettings)(node_path.join(getGlobalDir("opencode", null), "opencode.json")).disable_ai_attribution === true ? null : void 0;
+	if (runtime === "opencode") result = readSettings(node_path.join(getGlobalDir("opencode", null), "opencode.json")).disable_ai_attribution === true ? null : void 0;
 	else if (runtime === "gemini") {
-		const attr = (0, import_dist.readSettings)(node_path.join(getGlobalDir("gemini", explicitConfigDir), "settings.json")).attribution;
+		const attr = readSettings(node_path.join(getGlobalDir("gemini", explicitConfigDir), "settings.json")).attribution;
 		if (!attr || attr.commit === void 0) result = void 0;
 		else if (attr.commit === "") result = null;
 		else result = attr.commit;
 	} else if (runtime === "claude") {
-		const attr = (0, import_dist.readSettings)(node_path.join(getGlobalDir("claude", explicitConfigDir), "settings.json")).attribution;
+		const attr = readSettings(node_path.join(getGlobalDir("claude", explicitConfigDir), "settings.json")).attribution;
 		if (!attr || attr.commit === void 0) result = void 0;
 		else if (attr.commit === "") result = null;
 		else result = attr.commit;
@@ -6677,8 +8273,8 @@ function copyFlattenedCommands(srcDir, destDir, prefix, pathPrefix, runtime) {
 			content = content.replace(globalClaudeRegex, pathPrefix);
 			content = content.replace(localClaudeRegex, `./${getDirName(runtime)}/`);
 			content = content.replace(opencodeDirRegex, pathPrefix);
-			content = (0, import_dist.processAttribution)(content, getCommitAttribution(runtime));
-			content = (0, import_dist.convertClaudeToOpencodeFrontmatter)(content);
+			content = processAttribution(content, getCommitAttribution(runtime));
+			content = convertClaudeToOpencodeFrontmatter(content);
 			node_fs.writeFileSync(destPath, content);
 		}
 	}
@@ -6711,8 +8307,8 @@ function copyCommandsAsCodexSkills(srcDir, skillsDir, prefix, pathPrefix, runtim
 			content = content.replace(globalClaudeRegex, pathPrefix);
 			content = content.replace(localClaudeRegex, `./${getDirName(runtime)}/`);
 			content = content.replace(codexDirRegex, pathPrefix);
-			content = (0, import_dist.processAttribution)(content, getCommitAttribution(runtime));
-			content = (0, import_dist.convertClaudeCommandToCodexSkill)(content, skillName);
+			content = processAttribution(content, getCommitAttribution(runtime));
+			content = convertClaudeCommandToCodexSkill(content, skillName);
 			node_fs.writeFileSync(node_path.join(skillDir, "SKILL.md"), content);
 		}
 	}
@@ -6739,18 +8335,18 @@ function copyWithPathReplacement(srcDir, destDir, pathPrefix, runtime, isCommand
 			const localClaudeRegex = /\.\/\.claude\//g;
 			content = content.replace(globalClaudeRegex, pathPrefix);
 			content = content.replace(localClaudeRegex, `./${dirName}/`);
-			content = (0, import_dist.processAttribution)(content, getCommitAttribution(runtime));
+			content = processAttribution(content, getCommitAttribution(runtime));
 			if (isOpencode) {
-				content = (0, import_dist.convertClaudeToOpencodeFrontmatter)(content);
+				content = convertClaudeToOpencodeFrontmatter(content);
 				node_fs.writeFileSync(destPath, content);
 			} else if (runtime === "gemini") if (isCommand) {
-				content = (0, import_dist.stripSubTags)(content);
-				const tomlContent = (0, import_dist.convertClaudeToGeminiToml)(content);
+				content = stripSubTags(content);
+				const tomlContent = convertClaudeToGeminiToml(content);
 				const tomlPath = destPath.replace(/\.md$/, ".toml");
 				node_fs.writeFileSync(tomlPath, tomlContent);
 			} else node_fs.writeFileSync(destPath, content);
 			else if (isCodex) {
-				content = (0, import_dist.convertClaudeToCodexMarkdown)(content);
+				content = convertClaudeToCodexMarkdown(content);
 				node_fs.writeFileSync(destPath, content);
 			} else node_fs.writeFileSync(destPath, content);
 		} else node_fs.copyFileSync(srcPath, destPath);
@@ -6903,7 +8499,7 @@ function uninstall(isGlobal, runtime = "claude") {
 	} catch {}
 	const settingsPath = node_path.join(targetDir, "settings.json");
 	if (node_fs.existsSync(settingsPath)) {
-		const settings = (0, import_dist.readSettings)(settingsPath);
+		const settings = readSettings(settingsPath);
 		let settingsModified = false;
 		const statusLine = settings.statusLine;
 		if (statusLine && statusLine.command && statusLine.command.includes("maxsim-statusline")) {
@@ -6938,7 +8534,7 @@ function uninstall(isGlobal, runtime = "claude") {
 		}
 		if (settingsHooks && Object.keys(settingsHooks).length === 0) delete settings.hooks;
 		if (settingsModified) {
-			(0, import_dist.writeSettings)(settingsPath, settings);
+			writeSettings(settingsPath, settings);
 			removedCount++;
 		}
 	}
@@ -7284,10 +8880,10 @@ function install(isGlobal, runtime = "claude") {
 		for (const entry of agentEntries) if (entry.isFile() && entry.name.endsWith(".md")) {
 			let content = node_fs.readFileSync(node_path.join(agentsSrc, entry.name), "utf8");
 			content = content.replace(/~\/\.claude\//g, pathPrefix);
-			content = (0, import_dist.processAttribution)(content, getCommitAttribution(runtime));
-			if (isOpencode) content = (0, import_dist.convertClaudeToOpencodeFrontmatter)(content);
-			else if (isGemini) content = (0, import_dist.convertClaudeToGeminiAgent)(content);
-			else if (isCodex) content = (0, import_dist.convertClaudeToCodexMarkdown)(content);
+			content = processAttribution(content, getCommitAttribution(runtime));
+			if (isOpencode) content = convertClaudeToOpencodeFrontmatter(content);
+			else if (isGemini) content = convertClaudeToGeminiAgent(content);
+			else if (isCodex) content = convertClaudeToCodexMarkdown(content);
 			node_fs.writeFileSync(node_path.join(agentsDest, entry.name), content);
 		}
 		if (verifyInstalled(agentsDest, "agents")) spinner.succeed(chalk.green("✓") + " Installed agents");
@@ -7402,10 +8998,10 @@ function install(isGlobal, runtime = "claude") {
 		runtime
 	};
 	const settingsPath = node_path.join(targetDir, "settings.json");
-	const settings = cleanupOrphanedHooks((0, import_dist.readSettings)(settingsPath));
-	const statuslineCommand = isGlobal ? (0, import_dist.buildHookCommand)(targetDir, "maxsim-statusline.js") : "node " + dirName + "/hooks/maxsim-statusline.js";
-	const updateCheckCommand = isGlobal ? (0, import_dist.buildHookCommand)(targetDir, "maxsim-check-update.js") : "node " + dirName + "/hooks/maxsim-check-update.js";
-	const contextMonitorCommand = isGlobal ? (0, import_dist.buildHookCommand)(targetDir, "maxsim-context-monitor.js") : "node " + dirName + "/hooks/maxsim-context-monitor.js";
+	const settings = cleanupOrphanedHooks(readSettings(settingsPath));
+	const statuslineCommand = isGlobal ? buildHookCommand(targetDir, "maxsim-statusline.js") : "node " + dirName + "/hooks/maxsim-statusline.js";
+	const updateCheckCommand = isGlobal ? buildHookCommand(targetDir, "maxsim-check-update.js") : "node " + dirName + "/hooks/maxsim-check-update.js";
+	const contextMonitorCommand = isGlobal ? buildHookCommand(targetDir, "maxsim-context-monitor.js") : "node " + dirName + "/hooks/maxsim-context-monitor.js";
 	if (isGemini) {
 		if (!settings.experimental) settings.experimental = {};
 		const experimental = settings.experimental;
@@ -7454,7 +9050,7 @@ function finishInstall(settingsPath, settings, statuslineCommand, shouldInstallS
 		};
 		console.log(`  ${chalk.green("✓")} Configured statusline`);
 	}
-	if (!isCodex && settingsPath && settings) (0, import_dist.writeSettings)(settingsPath, settings);
+	if (!isCodex && settingsPath && settings) writeSettings(settingsPath, settings);
 	if (isOpencode) configureOpencodePermissions(isGlobal);
 	let program = "Claude Code";
 	if (runtime === "opencode") program = "OpenCode";