@callstack/apex 0.2.1 → 0.3.0

package/dist/cli.js

@@ -0,0 +1,4859 @@
+#!/usr/bin/env node
+import { isDeepStrictEqual, parseArgs, styleText } from "node:util";
+import { spawn } from "node:child_process";
+import { access, lstat, mkdir, open, readFile, rename, stat, unlink } from "node:fs/promises";
+import { basename, delimiter, dirname, join, parse, resolve } from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import { homedir } from "node:os";
+import process$1, { stdin, stdout } from "node:process";
+import l__default from "node:readline";
+
+//#region \0rolldown/runtime.js
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+
+//#endregion
+//#region node_modules/jsonc-parser/lib/esm/impl/scanner.js
+/**
+* Creates a JSON scanner on the given text.
+* If ignoreTrivia is set, whitespaces or comments are ignored.
+*/
+function createScanner(text, ignoreTrivia = false) {
+	const len = text.length;
+	let pos = 0, value = "", tokenOffset = 0, token = 16, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0;
+	function scanHexDigits(count, exact) {
+		let digits = 0;
+		let value = 0;
+		while (digits < count || !exact) {
+			let ch = text.charCodeAt(pos);
+			if (ch >= 48 && ch <= 57) value = value * 16 + ch - 48;
+			else if (ch >= 65 && ch <= 70) value = value * 16 + ch - 65 + 10;
+			else if (ch >= 97 && ch <= 102) value = value * 16 + ch - 97 + 10;
+			else break;
+			pos++;
+			digits++;
+		}
+		if (digits < count) value = -1;
+		return value;
+	}
+	function setPosition(newPosition) {
+		pos = newPosition;
+		value = "";
+		tokenOffset = 0;
+		token = 16;
+		scanError = 0;
+	}
+	function scanNumber() {
+		let start = pos;
+		if (text.charCodeAt(pos) === 48) pos++;
+		else {
+			pos++;
+			while (pos < text.length && isDigit(text.charCodeAt(pos))) pos++;
+		}
+		if (pos < text.length && text.charCodeAt(pos) === 46) {
+			pos++;
+			if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+				pos++;
+				while (pos < text.length && isDigit(text.charCodeAt(pos))) pos++;
+			} else {
+				scanError = 3;
+				return text.substring(start, pos);
+			}
+		}
+		let end = pos;
+		if (pos < text.length && (text.charCodeAt(pos) === 69 || text.charCodeAt(pos) === 101)) {
+			pos++;
+			if (pos < text.length && text.charCodeAt(pos) === 43 || text.charCodeAt(pos) === 45) pos++;
+			if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+				pos++;
+				while (pos < text.length && isDigit(text.charCodeAt(pos))) pos++;
+				end = pos;
+			} else scanError = 3;
+		}
+		return text.substring(start, end);
+	}
+	function scanString() {
+		let result = "", start = pos;
+		while (true) {
+			if (pos >= len) {
+				result += text.substring(start, pos);
+				scanError = 2;
+				break;
+			}
+			const ch = text.charCodeAt(pos);
+			if (ch === 34) {
+				result += text.substring(start, pos);
+				pos++;
+				break;
+			}
+			if (ch === 92) {
+				result += text.substring(start, pos);
+				pos++;
+				if (pos >= len) {
+					scanError = 2;
+					break;
+				}
+				switch (text.charCodeAt(pos++)) {
+					case 34:
+						result += "\"";
+						break;
+					case 92:
+						result += "\\";
+						break;
+					case 47:
+						result += "/";
+						break;
+					case 98:
+						result += "\b";
+						break;
+					case 102:
+						result += "\f";
+						break;
+					case 110:
+						result += "\n";
+						break;
+					case 114:
+						result += "\r";
+						break;
+					case 116:
+						result += "	";
+						break;
+					case 117:
+						const ch3 = scanHexDigits(4, true);
+						if (ch3 >= 0) result += String.fromCharCode(ch3);
+						else scanError = 4;
+						break;
+					default: scanError = 5;
+				}
+				start = pos;
+				continue;
+			}
+			if (ch >= 0 && ch <= 31) {
+				if (isLineBreak(ch)) {
+					result += text.substring(start, pos);
+					scanError = 2;
+					break;
+				} else scanError = 6;
+			}
+			pos++;
+		}
+		return result;
+	}
+	function scanNext() {
+		value = "";
+		scanError = 0;
+		tokenOffset = pos;
+		lineStartOffset = lineNumber;
+		prevTokenLineStartOffset = tokenLineStartOffset;
+		if (pos >= len) {
+			tokenOffset = len;
+			return token = 17;
+		}
+		let code = text.charCodeAt(pos);
+		if (isWhiteSpace(code)) {
+			do {
+				pos++;
+				value += String.fromCharCode(code);
+				code = text.charCodeAt(pos);
+			} while (isWhiteSpace(code));
+			return token = 15;
+		}
+		if (isLineBreak(code)) {
+			pos++;
+			value += String.fromCharCode(code);
+			if (code === 13 && text.charCodeAt(pos) === 10) {
+				pos++;
+				value += "\n";
+			}
+			lineNumber++;
+			tokenLineStartOffset = pos;
+			return token = 14;
+		}
+		switch (code) {
+			case 123:
+				pos++;
+				return token = 1;
+			case 125:
+				pos++;
+				return token = 2;
+			case 91:
+				pos++;
+				return token = 3;
+			case 93:
+				pos++;
+				return token = 4;
+			case 58:
+				pos++;
+				return token = 6;
+			case 44:
+				pos++;
+				return token = 5;
+			case 34:
+				pos++;
+				value = scanString();
+				return token = 10;
+			case 47:
+				const start = pos - 1;
+				if (text.charCodeAt(pos + 1) === 47) {
+					pos += 2;
+					while (pos < len) {
+						if (isLineBreak(text.charCodeAt(pos))) break;
+						pos++;
+					}
+					value = text.substring(start, pos);
+					return token = 12;
+				}
+				if (text.charCodeAt(pos + 1) === 42) {
+					pos += 2;
+					const safeLength = len - 1;
+					let commentClosed = false;
+					while (pos < safeLength) {
+						const ch = text.charCodeAt(pos);
+						if (ch === 42 && text.charCodeAt(pos + 1) === 47) {
+							pos += 2;
+							commentClosed = true;
+							break;
+						}
+						pos++;
+						if (isLineBreak(ch)) {
+							if (ch === 13 && text.charCodeAt(pos) === 10) pos++;
+							lineNumber++;
+							tokenLineStartOffset = pos;
+						}
+					}
+					if (!commentClosed) {
+						pos++;
+						scanError = 1;
+					}
+					value = text.substring(start, pos);
+					return token = 13;
+				}
+				value += String.fromCharCode(code);
+				pos++;
+				return token = 16;
+			case 45:
+				value += String.fromCharCode(code);
+				pos++;
+				if (pos === len || !isDigit(text.charCodeAt(pos))) return token = 16;
+			case 48:
+			case 49:
+			case 50:
+			case 51:
+			case 52:
+			case 53:
+			case 54:
+			case 55:
+			case 56:
+			case 57:
+				value += scanNumber();
+				return token = 11;
+			default:
+				while (pos < len && isUnknownContentCharacter(code)) {
+					pos++;
+					code = text.charCodeAt(pos);
+				}
+				if (tokenOffset !== pos) {
+					value = text.substring(tokenOffset, pos);
+					switch (value) {
+						case "true": return token = 8;
+						case "false": return token = 9;
+						case "null": return token = 7;
+					}
+					return token = 16;
+				}
+				value += String.fromCharCode(code);
+				pos++;
+				return token = 16;
+		}
+	}
+	function isUnknownContentCharacter(code) {
+		if (isWhiteSpace(code) || isLineBreak(code)) return false;
+		switch (code) {
+			case 125:
+			case 93:
+			case 123:
+			case 91:
+			case 34:
+			case 58:
+			case 44:
+			case 47: return false;
+		}
+		return true;
+	}
+	function scanNextNonTrivia() {
+		let result;
+		do
+			result = scanNext();
+		while (result >= 12 && result <= 15);
+		return result;
+	}
+	return {
+		setPosition,
+		getPosition: () => pos,
+		scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
+		getToken: () => token,
+		getTokenValue: () => value,
+		getTokenOffset: () => tokenOffset,
+		getTokenLength: () => pos - tokenOffset,
+		getTokenStartLine: () => lineStartOffset,
+		getTokenStartCharacter: () => tokenOffset - prevTokenLineStartOffset,
+		getTokenError: () => scanError
+	};
+}
+function isWhiteSpace(ch) {
+	return ch === 32 || ch === 9;
+}
+function isLineBreak(ch) {
+	return ch === 10 || ch === 13;
+}
+function isDigit(ch) {
+	return ch >= 48 && ch <= 57;
+}
+var CharacterCodes;
+(function(CharacterCodes) {
+	CharacterCodes[CharacterCodes["lineFeed"] = 10] = "lineFeed";
+	CharacterCodes[CharacterCodes["carriageReturn"] = 13] = "carriageReturn";
+	CharacterCodes[CharacterCodes["space"] = 32] = "space";
+	CharacterCodes[CharacterCodes["_0"] = 48] = "_0";
+	CharacterCodes[CharacterCodes["_1"] = 49] = "_1";
+	CharacterCodes[CharacterCodes["_2"] = 50] = "_2";
+	CharacterCodes[CharacterCodes["_3"] = 51] = "_3";
+	CharacterCodes[CharacterCodes["_4"] = 52] = "_4";
+	CharacterCodes[CharacterCodes["_5"] = 53] = "_5";
+	CharacterCodes[CharacterCodes["_6"] = 54] = "_6";
+	CharacterCodes[CharacterCodes["_7"] = 55] = "_7";
+	CharacterCodes[CharacterCodes["_8"] = 56] = "_8";
+	CharacterCodes[CharacterCodes["_9"] = 57] = "_9";
+	CharacterCodes[CharacterCodes["a"] = 97] = "a";
+	CharacterCodes[CharacterCodes["b"] = 98] = "b";
+	CharacterCodes[CharacterCodes["c"] = 99] = "c";
+	CharacterCodes[CharacterCodes["d"] = 100] = "d";
+	CharacterCodes[CharacterCodes["e"] = 101] = "e";
+	CharacterCodes[CharacterCodes["f"] = 102] = "f";
+	CharacterCodes[CharacterCodes["g"] = 103] = "g";
+	CharacterCodes[CharacterCodes["h"] = 104] = "h";
+	CharacterCodes[CharacterCodes["i"] = 105] = "i";
+	CharacterCodes[CharacterCodes["j"] = 106] = "j";
+	CharacterCodes[CharacterCodes["k"] = 107] = "k";
+	CharacterCodes[CharacterCodes["l"] = 108] = "l";
+	CharacterCodes[CharacterCodes["m"] = 109] = "m";
+	CharacterCodes[CharacterCodes["n"] = 110] = "n";
+	CharacterCodes[CharacterCodes["o"] = 111] = "o";
+	CharacterCodes[CharacterCodes["p"] = 112] = "p";
+	CharacterCodes[CharacterCodes["q"] = 113] = "q";
+	CharacterCodes[CharacterCodes["r"] = 114] = "r";
+	CharacterCodes[CharacterCodes["s"] = 115] = "s";
+	CharacterCodes[CharacterCodes["t"] = 116] = "t";
+	CharacterCodes[CharacterCodes["u"] = 117] = "u";
+	CharacterCodes[CharacterCodes["v"] = 118] = "v";
+	CharacterCodes[CharacterCodes["w"] = 119] = "w";
+	CharacterCodes[CharacterCodes["x"] = 120] = "x";
+	CharacterCodes[CharacterCodes["y"] = 121] = "y";
+	CharacterCodes[CharacterCodes["z"] = 122] = "z";
+	CharacterCodes[CharacterCodes["A"] = 65] = "A";
+	CharacterCodes[CharacterCodes["B"] = 66] = "B";
+	CharacterCodes[CharacterCodes["C"] = 67] = "C";
+	CharacterCodes[CharacterCodes["D"] = 68] = "D";
+	CharacterCodes[CharacterCodes["E"] = 69] = "E";
+	CharacterCodes[CharacterCodes["F"] = 70] = "F";
+	CharacterCodes[CharacterCodes["G"] = 71] = "G";
+	CharacterCodes[CharacterCodes["H"] = 72] = "H";
+	CharacterCodes[CharacterCodes["I"] = 73] = "I";
+	CharacterCodes[CharacterCodes["J"] = 74] = "J";
+	CharacterCodes[CharacterCodes["K"] = 75] = "K";
+	CharacterCodes[CharacterCodes["L"] = 76] = "L";
+	CharacterCodes[CharacterCodes["M"] = 77] = "M";
+	CharacterCodes[CharacterCodes["N"] = 78] = "N";
+	CharacterCodes[CharacterCodes["O"] = 79] = "O";
+	CharacterCodes[CharacterCodes["P"] = 80] = "P";
+	CharacterCodes[CharacterCodes["Q"] = 81] = "Q";
+	CharacterCodes[CharacterCodes["R"] = 82] = "R";
+	CharacterCodes[CharacterCodes["S"] = 83] = "S";
+	CharacterCodes[CharacterCodes["T"] = 84] = "T";
+	CharacterCodes[CharacterCodes["U"] = 85] = "U";
+	CharacterCodes[CharacterCodes["V"] = 86] = "V";
+	CharacterCodes[CharacterCodes["W"] = 87] = "W";
+	CharacterCodes[CharacterCodes["X"] = 88] = "X";
+	CharacterCodes[CharacterCodes["Y"] = 89] = "Y";
+	CharacterCodes[CharacterCodes["Z"] = 90] = "Z";
+	CharacterCodes[CharacterCodes["asterisk"] = 42] = "asterisk";
+	CharacterCodes[CharacterCodes["backslash"] = 92] = "backslash";
+	CharacterCodes[CharacterCodes["closeBrace"] = 125] = "closeBrace";
+	CharacterCodes[CharacterCodes["closeBracket"] = 93] = "closeBracket";
+	CharacterCodes[CharacterCodes["colon"] = 58] = "colon";
+	CharacterCodes[CharacterCodes["comma"] = 44] = "comma";
+	CharacterCodes[CharacterCodes["dot"] = 46] = "dot";
+	CharacterCodes[CharacterCodes["doubleQuote"] = 34] = "doubleQuote";
+	CharacterCodes[CharacterCodes["minus"] = 45] = "minus";
+	CharacterCodes[CharacterCodes["openBrace"] = 123] = "openBrace";
+	CharacterCodes[CharacterCodes["openBracket"] = 91] = "openBracket";
+	CharacterCodes[CharacterCodes["plus"] = 43] = "plus";
+	CharacterCodes[CharacterCodes["slash"] = 47] = "slash";
+	CharacterCodes[CharacterCodes["formFeed"] = 12] = "formFeed";
+	CharacterCodes[CharacterCodes["tab"] = 9] = "tab";
+})(CharacterCodes || (CharacterCodes = {}));
+
+//#endregion
+//#region node_modules/jsonc-parser/lib/esm/impl/string-intern.js
+const cachedSpaces = new Array(20).fill(0).map((_, index) => {
+	return " ".repeat(index);
+});
+const maxCachedValues = 200;
+const cachedBreakLinesWithSpaces = {
+	" ": {
+		"\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+			return "\n" + " ".repeat(index);
+		}),
+		"\r": new Array(maxCachedValues).fill(0).map((_, index) => {
+			return "\r" + " ".repeat(index);
+		}),
+		"\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+			return "\r\n" + " ".repeat(index);
+		})
+	},
+	"	": {
+		"\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+			return "\n" + "	".repeat(index);
+		}),
+		"\r": new Array(maxCachedValues).fill(0).map((_, index) => {
+			return "\r" + "	".repeat(index);
+		}),
+		"\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+			return "\r\n" + "	".repeat(index);
+		})
+	}
+};
+const supportedEols = [
+	"\n",
+	"\r",
+	"\r\n"
+];
+
+//#endregion
+//#region node_modules/jsonc-parser/lib/esm/impl/format.js
+function format(documentText, range, options) {
+	let initialIndentLevel;
+	let formatText;
+	let formatTextStart;
+	let rangeStart;
+	let rangeEnd;
+	if (range) {
+		rangeStart = range.offset;
+		rangeEnd = rangeStart + range.length;
+		formatTextStart = rangeStart;
+		while (formatTextStart > 0 && !isEOL(documentText, formatTextStart - 1)) formatTextStart--;
+		let endOffset = rangeEnd;
+		while (endOffset < documentText.length && !isEOL(documentText, endOffset)) endOffset++;
+		formatText = documentText.substring(formatTextStart, endOffset);
+		initialIndentLevel = computeIndentLevel(formatText, options);
+	} else {
+		formatText = documentText;
+		initialIndentLevel = 0;
+		formatTextStart = 0;
+		rangeStart = 0;
+		rangeEnd = documentText.length;
+	}
+	const eol = getEOL(options, documentText);
+	const eolFastPathSupported = supportedEols.includes(eol);
+	let numberLineBreaks = 0;
+	let indentLevel = 0;
+	let indentValue;
+	if (options.insertSpaces) indentValue = cachedSpaces[options.tabSize || 4] ?? repeat(cachedSpaces[1], options.tabSize || 4);
+	else indentValue = "	";
+	const indentType = indentValue === "	" ? "	" : " ";
+	let scanner = createScanner(formatText, false);
+	let hasError = false;
+	function newLinesAndIndent() {
+		if (numberLineBreaks > 1) return repeat(eol, numberLineBreaks) + repeat(indentValue, initialIndentLevel + indentLevel);
+		const amountOfSpaces = indentValue.length * (initialIndentLevel + indentLevel);
+		if (!eolFastPathSupported || amountOfSpaces > cachedBreakLinesWithSpaces[indentType][eol].length) return eol + repeat(indentValue, initialIndentLevel + indentLevel);
+		if (amountOfSpaces <= 0) return eol;
+		return cachedBreakLinesWithSpaces[indentType][eol][amountOfSpaces];
+	}
+	function scanNext() {
+		let token = scanner.scan();
+		numberLineBreaks = 0;
+		while (token === 15 || token === 14) {
+			if (token === 14 && options.keepLines) numberLineBreaks += 1;
+			else if (token === 14) numberLineBreaks = 1;
+			token = scanner.scan();
+		}
+		hasError = token === 16 || scanner.getTokenError() !== 0;
+		return token;
+	}
+	const editOperations = [];
+	function addEdit(text, startOffset, endOffset) {
+		if (!hasError && (!range || startOffset < rangeEnd && endOffset > rangeStart) && documentText.substring(startOffset, endOffset) !== text) editOperations.push({
+			offset: startOffset,
+			length: endOffset - startOffset,
+			content: text
+		});
+	}
+	let firstToken = scanNext();
+	if (options.keepLines && numberLineBreaks > 0) addEdit(repeat(eol, numberLineBreaks), 0, 0);
+	if (firstToken !== 17) {
+		let firstTokenStart = scanner.getTokenOffset() + formatTextStart;
+		addEdit(indentValue.length * initialIndentLevel < 20 && options.insertSpaces ? cachedSpaces[indentValue.length * initialIndentLevel] : repeat(indentValue, initialIndentLevel), formatTextStart, firstTokenStart);
+	}
+	while (firstToken !== 17) {
+		let firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
+		let secondToken = scanNext();
+		let replaceContent = "";
+		let needsLineBreak = false;
+		while (numberLineBreaks === 0 && (secondToken === 12 || secondToken === 13)) {
+			let commentTokenStart = scanner.getTokenOffset() + formatTextStart;
+			addEdit(cachedSpaces[1], firstTokenEnd, commentTokenStart);
+			firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
+			needsLineBreak = secondToken === 12;
+			replaceContent = needsLineBreak ? newLinesAndIndent() : "";
+			secondToken = scanNext();
+		}
+		if (secondToken === 2) {
+			if (firstToken !== 1) indentLevel--;
+			if (options.keepLines && numberLineBreaks > 0 || !options.keepLines && firstToken !== 1) replaceContent = newLinesAndIndent();
+			else if (options.keepLines) replaceContent = cachedSpaces[1];
+		} else if (secondToken === 4) {
+			if (firstToken !== 3) indentLevel--;
+			if (options.keepLines && numberLineBreaks > 0 || !options.keepLines && firstToken !== 3) replaceContent = newLinesAndIndent();
+			else if (options.keepLines) replaceContent = cachedSpaces[1];
+		} else {
+			switch (firstToken) {
+				case 3:
+				case 1:
+					indentLevel++;
+					if (options.keepLines && numberLineBreaks > 0 || !options.keepLines) replaceContent = newLinesAndIndent();
+					else replaceContent = cachedSpaces[1];
+					break;
+				case 5:
+					if (options.keepLines && numberLineBreaks > 0 || !options.keepLines) replaceContent = newLinesAndIndent();
+					else replaceContent = cachedSpaces[1];
+					break;
+				case 12:
+					replaceContent = newLinesAndIndent();
+					break;
+				case 13:
+					if (numberLineBreaks > 0) replaceContent = newLinesAndIndent();
+					else if (!needsLineBreak) replaceContent = cachedSpaces[1];
+					break;
+				case 6:
+					if (options.keepLines && numberLineBreaks > 0) replaceContent = newLinesAndIndent();
+					else if (!needsLineBreak) replaceContent = cachedSpaces[1];
+					break;
+				case 10:
+					if (options.keepLines && numberLineBreaks > 0) replaceContent = newLinesAndIndent();
+					else if (secondToken === 6 && !needsLineBreak) replaceContent = "";
+					break;
+				case 7:
+				case 8:
+				case 9:
+				case 11:
+				case 2:
+				case 4:
+					if (options.keepLines && numberLineBreaks > 0) replaceContent = newLinesAndIndent();
+					else if ((secondToken === 12 || secondToken === 13) && !needsLineBreak) replaceContent = cachedSpaces[1];
+					else if (secondToken !== 5 && secondToken !== 17) hasError = true;
+					break;
+				case 16: hasError = true;
+			}
+			if (numberLineBreaks > 0 && (secondToken === 12 || secondToken === 13)) replaceContent = newLinesAndIndent();
+		}
+		if (secondToken === 17) {
+			if (options.keepLines && numberLineBreaks > 0) replaceContent = newLinesAndIndent();
+			else replaceContent = options.insertFinalNewline ? eol : "";
+		}
+		const secondTokenStart = scanner.getTokenOffset() + formatTextStart;
+		addEdit(replaceContent, firstTokenEnd, secondTokenStart);
+		firstToken = secondToken;
+	}
+	return editOperations;
+}
+function repeat(s, count) {
+	let result = "";
+	for (let i = 0; i < count; i++) result += s;
+	return result;
+}
+function computeIndentLevel(content, options) {
+	let i = 0;
+	let nChars = 0;
+	const tabSize = options.tabSize || 4;
+	while (i < content.length) {
+		let ch = content.charAt(i);
+		if (ch === cachedSpaces[1]) nChars++;
+		else if (ch === "	") nChars += tabSize;
+		else break;
+		i++;
+	}
+	return Math.floor(nChars / tabSize);
+}
+function getEOL(options, text) {
+	for (let i = 0; i < text.length; i++) {
+		const ch = text.charAt(i);
+		if (ch === "\r") {
+			if (i + 1 < text.length && text.charAt(i + 1) === "\n") return "\r\n";
+			return "\r";
+		} else if (ch === "\n") return "\n";
+	}
+	return options && options.eol || "\n";
+}
+function isEOL(text, offset) {
+	return "\r\n".indexOf(text.charAt(offset)) !== -1;
+}
+
+//#endregion
+//#region node_modules/jsonc-parser/lib/esm/impl/parser.js
+var ParseOptions;
+(function(ParseOptions) {
+	ParseOptions.DEFAULT = { allowTrailingComma: false };
+})(ParseOptions || (ParseOptions = {}));
+/**
+* Parses the given text and returns the object the JSON content represents. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
+* Therefore always check the errors list to find out if the input was valid.
+*/
+function parse$3(text, errors = [], options = ParseOptions.DEFAULT) {
+	let currentProperty = null;
+	let currentParent = [];
+	const previousParents = [];
+	function onValue(value) {
+		if (Array.isArray(currentParent)) currentParent.push(value);
+		else if (currentProperty !== null) currentParent[currentProperty] = value;
+	}
+	visit(text, {
+		onObjectBegin: () => {
+			const object = {};
+			onValue(object);
+			previousParents.push(currentParent);
+			currentParent = object;
+			currentProperty = null;
+		},
+		onObjectProperty: (name) => {
+			currentProperty = name;
+		},
+		onObjectEnd: () => {
+			currentParent = previousParents.pop();
+		},
+		onArrayBegin: () => {
+			const array = [];
+			onValue(array);
+			previousParents.push(currentParent);
+			currentParent = array;
+			currentProperty = null;
+		},
+		onArrayEnd: () => {
+			currentParent = previousParents.pop();
+		},
+		onLiteralValue: onValue,
+		onError: (error, offset, length) => {
+			errors.push({
+				error,
+				offset,
+				length
+			});
+		}
+	}, options);
+	return currentParent[0];
+}
+/**
+* Parses the given text and returns a tree representation the JSON content. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
+*/
+function parseTree(text, errors = [], options = ParseOptions.DEFAULT) {
+	let currentParent = {
+		type: "array",
+		offset: -1,
+		length: -1,
+		children: [],
+		parent: void 0
+	};
+	function ensurePropertyComplete(endOffset) {
+		if (currentParent.type === "property") {
+			currentParent.length = endOffset - currentParent.offset;
+			currentParent = currentParent.parent;
+		}
+	}
+	function onValue(valueNode) {
+		currentParent.children.push(valueNode);
+		return valueNode;
+	}
+	visit(text, {
+		onObjectBegin: (offset) => {
+			currentParent = onValue({
+				type: "object",
+				offset,
+				length: -1,
+				parent: currentParent,
+				children: []
+			});
+		},
+		onObjectProperty: (name, offset, length) => {
+			currentParent = onValue({
+				type: "property",
+				offset,
+				length: -1,
+				parent: currentParent,
+				children: []
+			});
+			currentParent.children.push({
+				type: "string",
+				value: name,
+				offset,
+				length,
+				parent: currentParent
+			});
+		},
+		onObjectEnd: (offset, length) => {
+			ensurePropertyComplete(offset + length);
+			currentParent.length = offset + length - currentParent.offset;
+			currentParent = currentParent.parent;
+			ensurePropertyComplete(offset + length);
+		},
+		onArrayBegin: (offset, length) => {
+			currentParent = onValue({
+				type: "array",
+				offset,
+				length: -1,
+				parent: currentParent,
+				children: []
+			});
+		},
+		onArrayEnd: (offset, length) => {
+			currentParent.length = offset + length - currentParent.offset;
+			currentParent = currentParent.parent;
+			ensurePropertyComplete(offset + length);
+		},
+		onLiteralValue: (value, offset, length) => {
+			onValue({
+				type: getNodeType(value),
+				offset,
+				length,
+				parent: currentParent,
+				value
+			});
+			ensurePropertyComplete(offset + length);
+		},
+		onSeparator: (sep, offset, length) => {
+			if (currentParent.type === "property") {
+				if (sep === ":") currentParent.colonOffset = offset;
+				else if (sep === ",") ensurePropertyComplete(offset);
+			}
+		},
+		onError: (error, offset, length) => {
+			errors.push({
+				error,
+				offset,
+				length
+			});
+		}
+	}, options);
+	const result = currentParent.children[0];
+	if (result) delete result.parent;
+	return result;
+}
+/**
+* Finds the node at the given path in a JSON DOM.
+*/
+function findNodeAtLocation(root, path) {
+	if (!root) return;
+	let node = root;
+	for (let segment of path) if (typeof segment === "string") {
+		if (node.type !== "object" || !Array.isArray(node.children)) return;
+		let found = false;
+		for (const propertyNode of node.children) if (Array.isArray(propertyNode.children) && propertyNode.children[0].value === segment && propertyNode.children.length === 2) {
+			node = propertyNode.children[1];
+			found = true;
+			break;
+		}
+		if (!found) return;
+	} else {
+		const index = segment;
+		if (node.type !== "array" || index < 0 || !Array.isArray(node.children) || index >= node.children.length) return;
+		node = node.children[index];
+	}
+	return node;
+}
+/**
+* Parses the given text and invokes the visitor functions for each object, array and literal reached.
+*/
+function visit(text, visitor, options = ParseOptions.DEFAULT) {
+	const _scanner = createScanner(text, false);
+	const _jsonPath = [];
+	let suppressedCallbacks = 0;
+	function toNoArgVisit(visitFunction) {
+		return visitFunction ? () => suppressedCallbacks === 0 && visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+	}
+	function toOneArgVisit(visitFunction) {
+		return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+	}
+	function toOneArgVisitWithPath(visitFunction) {
+		return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;
+	}
+	function toBeginVisit(visitFunction) {
+		return visitFunction ? () => {
+			if (suppressedCallbacks > 0) suppressedCallbacks++;
+			else if (visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) === false) suppressedCallbacks = 1;
+		} : () => true;
+	}
+	function toEndVisit(visitFunction) {
+		return visitFunction ? () => {
+			if (suppressedCallbacks > 0) suppressedCallbacks--;
+			if (suppressedCallbacks === 0) visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter());
+		} : () => true;
+	}
+	const onObjectBegin = toBeginVisit(visitor.onObjectBegin), onObjectProperty = toOneArgVisitWithPath(visitor.onObjectProperty), onObjectEnd = toEndVisit(visitor.onObjectEnd), onArrayBegin = toBeginVisit(visitor.onArrayBegin), onArrayEnd = toEndVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisitWithPath(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);
+	const disallowComments = options && options.disallowComments;
+	const allowTrailingComma = options && options.allowTrailingComma;
+	function scanNext() {
+		while (true) {
+			const token = _scanner.scan();
+			switch (_scanner.getTokenError()) {
+				case 4:
+					handleError(14);
+					break;
+				case 5:
+					handleError(15);
+					break;
+				case 3:
+					handleError(13);
+					break;
+				case 1:
+					if (!disallowComments) handleError(11);
+					break;
+				case 2:
+					handleError(12);
+					break;
+				case 6: handleError(16);
+			}
+			switch (token) {
+				case 12:
+				case 13:
+					if (disallowComments) handleError(10);
+					else onComment();
+					break;
+				case 16:
+					handleError(1);
+					break;
+				case 15:
+				case 14: break;
+				default: return token;
+			}
+		}
+	}
+	function handleError(error, skipUntilAfter = [], skipUntil = []) {
+		onError(error);
+		if (skipUntilAfter.length + skipUntil.length > 0) {
+			let token = _scanner.getToken();
+			while (token !== 17) {
+				if (skipUntilAfter.indexOf(token) !== -1) {
+					scanNext();
+					break;
+				} else if (skipUntil.indexOf(token) !== -1) break;
+				token = scanNext();
+			}
+		}
+	}
+	function parseString(isValue) {
+		const value = _scanner.getTokenValue();
+		if (isValue) onLiteralValue(value);
+		else {
+			onObjectProperty(value);
+			_jsonPath.push(value);
+		}
+		scanNext();
+		return true;
+	}
+	function parseLiteral() {
+		switch (_scanner.getToken()) {
+			case 11:
+				const tokenValue = _scanner.getTokenValue();
+				let value = Number(tokenValue);
+				if (isNaN(value)) {
+					handleError(2);
+					value = 0;
+				}
+				onLiteralValue(value);
+				break;
+			case 7:
+				onLiteralValue(null);
+				break;
+			case 8:
+				onLiteralValue(true);
+				break;
+			case 9:
+				onLiteralValue(false);
+				break;
+			default: return false;
+		}
+		scanNext();
+		return true;
+	}
+	function parseProperty() {
+		if (_scanner.getToken() !== 10) {
+			handleError(3, [], [2, 5]);
+			return false;
+		}
+		parseString(false);
+		if (_scanner.getToken() === 6) {
+			onSeparator(":");
+			scanNext();
+			if (!parseValue()) handleError(4, [], [2, 5]);
+		} else handleError(5, [], [2, 5]);
+		_jsonPath.pop();
+		return true;
+	}
+	function parseObject() {
+		onObjectBegin();
+		scanNext();
+		let needsComma = false;
+		while (_scanner.getToken() !== 2 && _scanner.getToken() !== 17) {
+			if (_scanner.getToken() === 5) {
+				if (!needsComma) handleError(4, [], []);
+				onSeparator(",");
+				scanNext();
+				if (_scanner.getToken() === 2 && allowTrailingComma) break;
+			} else if (needsComma) handleError(6, [], []);
+			if (!parseProperty()) handleError(4, [], [2, 5]);
+			needsComma = true;
+		}
+		onObjectEnd();
+		if (_scanner.getToken() !== 2) handleError(7, [2], []);
+		else scanNext();
+		return true;
+	}
+	function parseArray() {
+		onArrayBegin();
+		scanNext();
+		let isFirstElement = true;
+		let needsComma = false;
+		while (_scanner.getToken() !== 4 && _scanner.getToken() !== 17) {
+			if (_scanner.getToken() === 5) {
+				if (!needsComma) handleError(4, [], []);
+				onSeparator(",");
+				scanNext();
+				if (_scanner.getToken() === 4 && allowTrailingComma) break;
+			} else if (needsComma) handleError(6, [], []);
+			if (isFirstElement) {
+				_jsonPath.push(0);
+				isFirstElement = false;
+			} else _jsonPath[_jsonPath.length - 1]++;
+			if (!parseValue()) handleError(4, [], [4, 5]);
+			needsComma = true;
+		}
+		onArrayEnd();
+		if (!isFirstElement) _jsonPath.pop();
+		if (_scanner.getToken() !== 4) handleError(8, [4], []);
+		else scanNext();
+		return true;
+	}
+	function parseValue() {
+		switch (_scanner.getToken()) {
+			case 3: return parseArray();
+			case 1: return parseObject();
+			case 10: return parseString(true);
+			default: return parseLiteral();
+		}
+	}
+	scanNext();
+	if (_scanner.getToken() === 17) {
+		if (options.allowEmptyContent) return true;
+		handleError(4, [], []);
+		return false;
+	}
+	if (!parseValue()) {
+		handleError(4, [], []);
+		return false;
+	}
+	if (_scanner.getToken() !== 17) handleError(9, [], []);
+	return true;
+}
+function getNodeType(value) {
+	switch (typeof value) {
+		case "boolean": return "boolean";
+		case "number": return "number";
+		case "string": return "string";
+		case "object":
+			if (!value) return "null";
+			else if (Array.isArray(value)) return "array";
+			return "object";
+		default: return "null";
+	}
+}
+
+//#endregion
+//#region node_modules/jsonc-parser/lib/esm/impl/edit.js
+function setProperty(text, originalPath, value, options) {
+	const path = originalPath.slice();
+	const root = parseTree(text, []);
+	let parent = void 0;
+	let lastSegment = void 0;
+	while (path.length > 0) {
+		lastSegment = path.pop();
+		parent = findNodeAtLocation(root, path);
+		if (parent === void 0 && value !== void 0) {
+			if (typeof lastSegment === "string") value = { [lastSegment]: value };
+			else value = [value];
+		} else break;
+	}
+	if (!parent) {
+		if (value === void 0) throw new Error("Can not delete in empty document");
+		return withFormatting(text, {
+			offset: root ? root.offset : 0,
+			length: root ? root.length : 0,
+			content: JSON.stringify(value)
+		}, options);
+	} else if (parent.type === "object" && typeof lastSegment === "string" && Array.isArray(parent.children)) {
+		const existing = findNodeAtLocation(parent, [lastSegment]);
+		if (existing !== void 0) {
+			if (value === void 0) {
+				if (!existing.parent) throw new Error("Malformed AST");
+				const propertyIndex = parent.children.indexOf(existing.parent);
+				let removeBegin;
+				let removeEnd = existing.parent.offset + existing.parent.length;
+				if (propertyIndex > 0) {
+					let previous = parent.children[propertyIndex - 1];
+					removeBegin = previous.offset + previous.length;
+				} else {
+					removeBegin = parent.offset + 1;
+					if (parent.children.length > 1) removeEnd = parent.children[1].offset;
+				}
+				return withFormatting(text, {
+					offset: removeBegin,
+					length: removeEnd - removeBegin,
+					content: ""
+				}, options);
+			} else return withFormatting(text, {
+				offset: existing.offset,
+				length: existing.length,
+				content: JSON.stringify(value)
+			}, options);
+		} else {
+			if (value === void 0) return [];
+			const newProperty = `${JSON.stringify(lastSegment)}: ${JSON.stringify(value)}`;
+			const index = options.getInsertionIndex ? options.getInsertionIndex(parent.children.map((p) => p.children[0].value)) : parent.children.length;
+			let edit;
+			if (index > 0) {
+				let previous = parent.children[index - 1];
+				edit = {
+					offset: previous.offset + previous.length,
+					length: 0,
+					content: "," + newProperty
+				};
+			} else if (parent.children.length === 0) edit = {
+				offset: parent.offset + 1,
+				length: 0,
+				content: newProperty
+			};
+			else edit = {
+				offset: parent.offset + 1,
+				length: 0,
+				content: newProperty + ","
+			};
+			return withFormatting(text, edit, options);
+		}
+	} else if (parent.type === "array" && typeof lastSegment === "number" && Array.isArray(parent.children)) {
+		const insertIndex = lastSegment;
+		if (insertIndex === -1) {
+			const newProperty = `${JSON.stringify(value)}`;
+			let edit;
+			if (parent.children.length === 0) edit = {
+				offset: parent.offset + 1,
+				length: 0,
+				content: newProperty
+			};
+			else {
+				const previous = parent.children[parent.children.length - 1];
+				edit = {
+					offset: previous.offset + previous.length,
+					length: 0,
+					content: "," + newProperty
+				};
+			}
+			return withFormatting(text, edit, options);
+		} else if (value === void 0 && parent.children.length >= 0) {
+			const removalIndex = lastSegment;
+			const toRemove = parent.children[removalIndex];
+			let edit;
+			if (parent.children.length === 1) edit = {
+				offset: parent.offset + 1,
+				length: parent.length - 2,
+				content: ""
+			};
+			else if (parent.children.length - 1 === removalIndex) {
+				let previous = parent.children[removalIndex - 1];
+				let offset = previous.offset + previous.length;
+				edit = {
+					offset,
+					length: parent.offset + parent.length - 2 - offset,
+					content: ""
+				};
+			} else edit = {
+				offset: toRemove.offset,
+				length: parent.children[removalIndex + 1].offset - toRemove.offset,
+				content: ""
+			};
+			return withFormatting(text, edit, options);
+		} else if (value !== void 0) {
+			let edit;
+			const newProperty = `${JSON.stringify(value)}`;
+			if (!options.isArrayInsertion && parent.children.length > lastSegment) {
+				const toModify = parent.children[lastSegment];
+				edit = {
+					offset: toModify.offset,
+					length: toModify.length,
+					content: newProperty
+				};
+			} else if (parent.children.length === 0 || lastSegment === 0) edit = {
+				offset: parent.offset + 1,
+				length: 0,
+				content: parent.children.length === 0 ? newProperty : newProperty + ","
+			};
+			else {
+				const index = lastSegment > parent.children.length ? parent.children.length : lastSegment;
+				const previous = parent.children[index - 1];
+				edit = {
+					offset: previous.offset + previous.length,
+					length: 0,
+					content: "," + newProperty
+				};
+			}
+			return withFormatting(text, edit, options);
+		} else throw new Error(`Can not ${value === void 0 ? "remove" : options.isArrayInsertion ? "insert" : "modify"} Array index ${insertIndex} as length is not sufficient`);
+	} else throw new Error(`Can not add ${typeof lastSegment !== "number" ? "index" : "property"} to parent of type ${parent.type}`);
+}
+function withFormatting(text, edit, options) {
+	if (!options.formattingOptions) return [edit];
+	let newText = applyEdit(text, edit);
+	let begin = edit.offset;
+	let end = edit.offset + edit.content.length;
+	if (edit.length === 0 || edit.content.length === 0) {
+		while (begin > 0 && !isEOL(newText, begin - 1)) begin--;
+		while (end < newText.length && !isEOL(newText, end)) end++;
+	}
+	const edits = format(newText, {
+		offset: begin,
+		length: end - begin
+	}, {
+		...options.formattingOptions,
+		keepLines: false
+	});
+	for (let i = edits.length - 1; i >= 0; i--) {
+		const edit = edits[i];
+		newText = applyEdit(newText, edit);
+		begin = Math.min(begin, edit.offset);
+		end = Math.max(end, edit.offset + edit.length);
+		end += edit.content.length - edit.length;
+	}
+	const editLength = text.length - (newText.length - end) - begin;
+	return [{
+		offset: begin,
+		length: editLength,
+		content: newText.substring(begin, end)
+	}];
+}
+function applyEdit(text, edit) {
+	return text.substring(0, edit.offset) + edit.content + text.substring(edit.offset + edit.length);
+}
+
+//#endregion
+//#region node_modules/jsonc-parser/lib/esm/main.js
+var ScanError;
+(function(ScanError) {
+	ScanError[ScanError["None"] = 0] = "None";
+	ScanError[ScanError["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
+	ScanError[ScanError["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
+	ScanError[ScanError["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
+	ScanError[ScanError["InvalidUnicode"] = 4] = "InvalidUnicode";
+	ScanError[ScanError["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
+	ScanError[ScanError["InvalidCharacter"] = 6] = "InvalidCharacter";
+})(ScanError || (ScanError = {}));
+var SyntaxKind;
+(function(SyntaxKind) {
+	SyntaxKind[SyntaxKind["OpenBraceToken"] = 1] = "OpenBraceToken";
+	SyntaxKind[SyntaxKind["CloseBraceToken"] = 2] = "CloseBraceToken";
+	SyntaxKind[SyntaxKind["OpenBracketToken"] = 3] = "OpenBracketToken";
+	SyntaxKind[SyntaxKind["CloseBracketToken"] = 4] = "CloseBracketToken";
+	SyntaxKind[SyntaxKind["CommaToken"] = 5] = "CommaToken";
+	SyntaxKind[SyntaxKind["ColonToken"] = 6] = "ColonToken";
+	SyntaxKind[SyntaxKind["NullKeyword"] = 7] = "NullKeyword";
+	SyntaxKind[SyntaxKind["TrueKeyword"] = 8] = "TrueKeyword";
+	SyntaxKind[SyntaxKind["FalseKeyword"] = 9] = "FalseKeyword";
+	SyntaxKind[SyntaxKind["StringLiteral"] = 10] = "StringLiteral";
+	SyntaxKind[SyntaxKind["NumericLiteral"] = 11] = "NumericLiteral";
+	SyntaxKind[SyntaxKind["LineCommentTrivia"] = 12] = "LineCommentTrivia";
+	SyntaxKind[SyntaxKind["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
+	SyntaxKind[SyntaxKind["LineBreakTrivia"] = 14] = "LineBreakTrivia";
+	SyntaxKind[SyntaxKind["Trivia"] = 15] = "Trivia";
+	SyntaxKind[SyntaxKind["Unknown"] = 16] = "Unknown";
+	SyntaxKind[SyntaxKind["EOF"] = 17] = "EOF";
+})(SyntaxKind || (SyntaxKind = {}));
+/**
+* Parses the given text and returns the object the JSON content represents. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
+* Therefore, always check the errors list to find out if the input was valid.
+*/
+const parse$2 = parse$3;
+var ParseErrorCode;
+(function(ParseErrorCode) {
+	ParseErrorCode[ParseErrorCode["InvalidSymbol"] = 1] = "InvalidSymbol";
+	ParseErrorCode[ParseErrorCode["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
+	ParseErrorCode[ParseErrorCode["PropertyNameExpected"] = 3] = "PropertyNameExpected";
+	ParseErrorCode[ParseErrorCode["ValueExpected"] = 4] = "ValueExpected";
+	ParseErrorCode[ParseErrorCode["ColonExpected"] = 5] = "ColonExpected";
+	ParseErrorCode[ParseErrorCode["CommaExpected"] = 6] = "CommaExpected";
+	ParseErrorCode[ParseErrorCode["CloseBraceExpected"] = 7] = "CloseBraceExpected";
+	ParseErrorCode[ParseErrorCode["CloseBracketExpected"] = 8] = "CloseBracketExpected";
+	ParseErrorCode[ParseErrorCode["EndOfFileExpected"] = 9] = "EndOfFileExpected";
+	ParseErrorCode[ParseErrorCode["InvalidCommentToken"] = 10] = "InvalidCommentToken";
+	ParseErrorCode[ParseErrorCode["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
+	ParseErrorCode[ParseErrorCode["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
+	ParseErrorCode[ParseErrorCode["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
+	ParseErrorCode[ParseErrorCode["InvalidUnicode"] = 14] = "InvalidUnicode";
+	ParseErrorCode[ParseErrorCode["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
+	ParseErrorCode[ParseErrorCode["InvalidCharacter"] = 16] = "InvalidCharacter";
+})(ParseErrorCode || (ParseErrorCode = {}));
+/**
+* Computes the edit operations needed to modify a value in the JSON document.
+*
+* @param documentText The input text
+* @param path The path of the value to change. The path represents either to the document root, a property or an array item.
+* If the path points to an non-existing property or item, it will be created.
+* @param value The new value for the specified property or item. If the value is undefined,
+* the property or item will be removed.
+* @param options Options
+* @returns The edit operations describing the changes to the original document, following the format described in {@linkcode EditResult}.
+* To apply the edit operations to the input, use {@linkcode applyEdits}.
+*/
+function modify(text, path, value, options) {
+	return setProperty(text, path, value, options);
+}
+/**
+* Applies edits to an input string.
+* @param text The input text
+* @param edits Edit operations following the format described in {@linkcode EditResult}.
+* @returns The text with the applied edits.
+* @throws An error if the edit operations are not well-formed as described in {@linkcode EditResult}.
+*/
+function applyEdits(text, edits) {
+	let sortedEdits = edits.slice(0).sort((a, b) => {
+		const diff = a.offset - b.offset;
+		if (diff === 0) return a.length - b.length;
+		return diff;
+	});
+	let lastModifiedOffset = text.length;
+	for (let i = sortedEdits.length - 1; i >= 0; i--) {
+		let e = sortedEdits[i];
+		if (e.offset + e.length <= lastModifiedOffset) text = applyEdit(text, e);
+		else throw new Error("Overlapping edit");
+		lastModifiedOffset = e.offset;
+	}
+	return text;
+}
+
+//#endregion
+//#region node_modules/smol-toml/dist/error.js
+/*!
+* Copyright (c) Squirrel Chat et al., All rights reserved.
+* SPDX-License-Identifier: BSD-3-Clause
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are met:
+*
+* 1. Redistributions of source code must retain the above copyright notice, this
+*    list of conditions and the following disclaimer.
+* 2. Redistributions in binary form must reproduce the above copyright notice,
+*    this list of conditions and the following disclaimer in the
+*    documentation and/or other materials provided with the distribution.
+* 3. Neither the name of the copyright holder nor the names of its contributors
+*    may be used to endorse or promote products derived from this software without
+*    specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+function getLineColFromPtr(string, ptr) {
+	let lines = string.slice(0, ptr).split(/\r\n|\n|\r/g);
+	return [lines.length, lines.pop().length + 1];
+}
+function makeCodeBlock(string, line, column) {
+	let lines = string.split(/\r\n|\n|\r/g);
+	let codeblock = "";
+	let numberLen = (Math.log10(line + 1) | 0) + 1;
+	for (let i = line - 1; i <= line + 1; i++) {
+		let l = lines[i - 1];
+		if (!l) continue;
+		codeblock += i.toString().padEnd(numberLen, " ");
+		codeblock += ":  ";
+		codeblock += l;
+		codeblock += "\n";
+		if (i === line) {
+			codeblock += " ".repeat(numberLen + column + 2);
+			codeblock += "^\n";
+		}
+	}
+	return codeblock;
+}
+var TomlError = class extends Error {
+	line;
+	column;
+	codeblock;
+	constructor(message, options) {
+		const [line, column] = getLineColFromPtr(options.toml, options.ptr);
+		const codeblock = makeCodeBlock(options.toml, line, column);
+		super(`Invalid TOML document: ${message}\n\n${codeblock}`, options);
+		this.line = line;
+		this.column = column;
+		this.codeblock = codeblock;
+	}
+};
+
+//#endregion
+//#region node_modules/smol-toml/dist/util.js
+/*!
+* Copyright (c) Squirrel Chat et al., All rights reserved.
+* SPDX-License-Identifier: BSD-3-Clause
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are met:
+*
+* 1. Redistributions of source code must retain the above copyright notice, this
+*    list of conditions and the following disclaimer.
+* 2. Redistributions in binary form must reproduce the above copyright notice,
+*    this list of conditions and the following disclaimer in the
+*    documentation and/or other materials provided with the distribution.
+* 3. Neither the name of the copyright holder nor the names of its contributors
+*    may be used to endorse or promote products derived from this software without
+*    specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+function isEscaped(str, ptr) {
+	let i = 0;
+	while (str[ptr - ++i] === "\\");
+	return --i && i % 2;
+}
+function indexOfNewline(str, start = 0, end = str.length) {
+	let idx = str.indexOf("\n", start);
+	if (str[idx - 1] === "\r") idx--;
+	return idx <= end ? idx : -1;
+}
+function skipComment(str, ptr) {
+	for (let i = ptr; i < str.length; i++) {
+		let c = str[i];
+		if (c === "\n") return i;
+		if (c === "\r" && str[i + 1] === "\n") return i + 1;
+		if (c < " " && c !== "	" || c === "") throw new TomlError("control characters are not allowed in comments", {
+			toml: str,
+			ptr
+		});
+	}
+	return str.length;
+}
+function skipVoid(str, ptr, banNewLines, banComments) {
+	let c;
+	while ((c = str[ptr]) === " " || c === "	" || !banNewLines && (c === "\n" || c === "\r" && str[ptr + 1] === "\n")) ptr++;
+	return banComments || c !== "#" ? ptr : skipVoid(str, skipComment(str, ptr), banNewLines);
+}
+function skipUntil(str, ptr, sep, end, banNewLines = false) {
+	if (!end) {
+		ptr = indexOfNewline(str, ptr);
+		return ptr < 0 ? str.length : ptr;
+	}
+	for (let i = ptr; i < str.length; i++) {
+		let c = str[i];
+		if (c === "#") i = indexOfNewline(str, i);
+		else if (c === sep) return i + 1;
+		else if (c === end || banNewLines && (c === "\n" || c === "\r" && str[i + 1] === "\n")) return i;
+	}
+	throw new TomlError("cannot find end of structure", {
+		toml: str,
+		ptr
+	});
+}
+function getStringEnd(str, seek) {
+	let first = str[seek];
+	let target = first === str[seek + 1] && str[seek + 1] === str[seek + 2] ? str.slice(seek, seek + 3) : first;
+	seek += target.length - 1;
+	do
+		seek = str.indexOf(target, ++seek);
+	while (seek > -1 && first !== "'" && isEscaped(str, seek));
+	if (seek > -1) {
+		seek += target.length;
+		if (target.length > 1) {
+			if (str[seek] === first) seek++;
+			if (str[seek] === first) seek++;
+		}
+	}
+	return seek;
+}
+
+//#endregion
+//#region node_modules/smol-toml/dist/date.js
+/*!
+* Copyright (c) Squirrel Chat et al., All rights reserved.
+* SPDX-License-Identifier: BSD-3-Clause
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are met:
+*
+* 1. Redistributions of source code must retain the above copyright notice, this
+*    list of conditions and the following disclaimer.
+* 2. Redistributions in binary form must reproduce the above copyright notice,
+*    this list of conditions and the following disclaimer in the
+*    documentation and/or other materials provided with the distribution.
+* 3. Neither the name of the copyright holder nor the names of its contributors
+*    may be used to endorse or promote products derived from this software without
+*    specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+let DATE_TIME_RE = /^(\d{4}-\d{2}-\d{2})?[T ]?(?:(\d{2}):\d{2}:\d{2}(?:\.\d+)?)?(Z|[-+]\d{2}:\d{2})?$/i;
+var TomlDate = class TomlDate extends Date {
+	#hasDate = false;
+	#hasTime = false;
+	#offset = null;
+	constructor(date) {
+		let hasDate = true;
+		let hasTime = true;
+		let offset = "Z";
+		if (typeof date === "string") {
+			let match = date.match(DATE_TIME_RE);
+			if (match) {
+				if (!match[1]) {
+					hasDate = false;
+					date = `0000-01-01T${date}`;
+				}
+				hasTime = !!match[2];
+				hasTime && date[10] === " " && (date = date.replace(" ", "T"));
+				if (match[2] && +match[2] > 23) date = "";
+				else {
+					offset = match[3] || null;
+					date = date.toUpperCase();
+					if (!offset && hasTime) date += "Z";
+				}
+			} else date = "";
+		}
+		super(date);
+		if (!isNaN(this.getTime())) {
+			this.#hasDate = hasDate;
+			this.#hasTime = hasTime;
+			this.#offset = offset;
+		}
+	}
+	isDateTime() {
+		return this.#hasDate && this.#hasTime;
+	}
+	isLocal() {
+		return !this.#hasDate || !this.#hasTime || !this.#offset;
+	}
+	isDate() {
+		return this.#hasDate && !this.#hasTime;
+	}
+	isTime() {
+		return this.#hasTime && !this.#hasDate;
+	}
+	isValid() {
+		return this.#hasDate || this.#hasTime;
+	}
+	toISOString() {
+		let iso = super.toISOString();
+		if (this.isDate()) return iso.slice(0, 10);
+		if (this.isTime()) return iso.slice(11, 23);
+		if (this.#offset === null) return iso.slice(0, -1);
+		if (this.#offset === "Z") return iso;
+		let offset = +this.#offset.slice(1, 3) * 60 + +this.#offset.slice(4, 6);
+		offset = this.#offset[0] === "-" ? offset : -offset;
+		return (/* @__PURE__ */ new Date(this.getTime() - offset * 6e4)).toISOString().slice(0, -1) + this.#offset;
+	}
+	static wrapAsOffsetDateTime(jsDate, offset = "Z") {
+		let date = new TomlDate(jsDate);
+		date.#offset = offset;
+		return date;
+	}
+	static wrapAsLocalDateTime(jsDate) {
+		let date = new TomlDate(jsDate);
+		date.#offset = null;
+		return date;
+	}
+	static wrapAsLocalDate(jsDate) {
+		let date = new TomlDate(jsDate);
+		date.#hasTime = false;
+		date.#offset = null;
+		return date;
+	}
+	static wrapAsLocalTime(jsDate) {
+		let date = new TomlDate(jsDate);
+		date.#hasDate = false;
+		date.#offset = null;
+		return date;
+	}
+};
+
+//#endregion
+//#region node_modules/smol-toml/dist/primitive.js
+/*!
+* Copyright (c) Squirrel Chat et al., All rights reserved.
+* SPDX-License-Identifier: BSD-3-Clause
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are met:
+*
+* 1. Redistributions of source code must retain the above copyright notice, this
+*    list of conditions and the following disclaimer.
+* 2. Redistributions in binary form must reproduce the above copyright notice,
+*    this list of conditions and the following disclaimer in the
+*    documentation and/or other materials provided with the distribution.
+* 3. Neither the name of the copyright holder nor the names of its contributors
+*    may be used to endorse or promote products derived from this software without
+*    specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+let INT_REGEX = /^((0x[0-9a-fA-F](_?[0-9a-fA-F])*)|(([+-]|0[ob])?\d(_?\d)*))$/;
+let FLOAT_REGEX = /^[+-]?\d(_?\d)*(\.\d(_?\d)*)?([eE][+-]?\d(_?\d)*)?$/;
+let LEADING_ZERO = /^[+-]?0[0-9_]/;
+let ESCAPE_REGEX = /^[0-9a-f]{4,8}$/i;
+let ESC_MAP = {
+	b: "\b",
+	t: "	",
+	n: "\n",
+	f: "\f",
+	r: "\r",
+	"\"": "\"",
+	"\\": "\\"
+};
+function parseString(str, ptr = 0, endPtr = str.length) {
+	let isLiteral = str[ptr] === "'";
+	let isMultiline = str[ptr++] === str[ptr] && str[ptr] === str[ptr + 1];
+	if (isMultiline) {
+		endPtr -= 2;
+		if (str[ptr += 2] === "\r") ptr++;
+		if (str[ptr] === "\n") ptr++;
+	}
+	let tmp = 0;
+	let isEscape;
+	let parsed = "";
+	let sliceStart = ptr;
+	while (ptr < endPtr - 1) {
+		let c = str[ptr++];
+		if (c === "\n" || c === "\r" && str[ptr] === "\n") {
+			if (!isMultiline) throw new TomlError("newlines are not allowed in strings", {
+				toml: str,
+				ptr: ptr - 1
+			});
+		} else if (c < " " && c !== "	" || c === "") throw new TomlError("control characters are not allowed in strings", {
+			toml: str,
+			ptr: ptr - 1
+		});
+		if (isEscape) {
+			isEscape = false;
+			if (c === "u" || c === "U") {
+				let code = str.slice(ptr, ptr += c === "u" ? 4 : 8);
+				if (!ESCAPE_REGEX.test(code)) throw new TomlError("invalid unicode escape", {
+					toml: str,
+					ptr: tmp
+				});
+				try {
+					parsed += String.fromCodePoint(parseInt(code, 16));
+				} catch {
+					throw new TomlError("invalid unicode escape", {
+						toml: str,
+						ptr: tmp
+					});
+				}
+			} else if (isMultiline && (c === "\n" || c === " " || c === "	" || c === "\r")) {
+				ptr = skipVoid(str, ptr - 1, true);
+				if (str[ptr] !== "\n" && str[ptr] !== "\r") throw new TomlError("invalid escape: only line-ending whitespace may be escaped", {
+					toml: str,
+					ptr: tmp
+				});
+				ptr = skipVoid(str, ptr);
+			} else if (c in ESC_MAP) parsed += ESC_MAP[c];
+			else throw new TomlError("unrecognized escape sequence", {
+				toml: str,
+				ptr: tmp
+			});
+			sliceStart = ptr;
+		} else if (!isLiteral && c === "\\") {
+			tmp = ptr - 1;
+			isEscape = true;
+			parsed += str.slice(sliceStart, tmp);
+		}
+	}
+	return parsed + str.slice(sliceStart, endPtr - 1);
+}
+function parseValue(value, toml, ptr, integersAsBigInt) {
+	if (value === "true") return true;
+	if (value === "false") return false;
+	if (value === "-inf") return -Infinity;
+	if (value === "inf" || value === "+inf") return Infinity;
+	if (value === "nan" || value === "+nan" || value === "-nan") return NaN;
+	if (value === "-0") return integersAsBigInt ? 0n : 0;
+	let isInt = INT_REGEX.test(value);
+	if (isInt || FLOAT_REGEX.test(value)) {
+		if (LEADING_ZERO.test(value)) throw new TomlError("leading zeroes are not allowed", {
+			toml,
+			ptr
+		});
+		value = value.replace(/_/g, "");
+		let numeric = +value;
+		if (isNaN(numeric)) throw new TomlError("invalid number", {
+			toml,
+			ptr
+		});
+		if (isInt) {
+			if ((isInt = !Number.isSafeInteger(numeric)) && !integersAsBigInt) throw new TomlError("integer value cannot be represented losslessly", {
+				toml,
+				ptr
+			});
+			if (isInt || integersAsBigInt === true) numeric = BigInt(value);
+		}
+		return numeric;
+	}
+	const date = new TomlDate(value);
+	if (!date.isValid()) throw new TomlError("invalid value", {
+		toml,
+		ptr
+	});
+	return date;
+}
+
+//#endregion
+//#region node_modules/smol-toml/dist/extract.js
+/*!
+* Copyright (c) Squirrel Chat et al., All rights reserved.
+* SPDX-License-Identifier: BSD-3-Clause
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are met:
+*
+* 1. Redistributions of source code must retain the above copyright notice, this
+*    list of conditions and the following disclaimer.
+* 2. Redistributions in binary form must reproduce the above copyright notice,
+*    this list of conditions and the following disclaimer in the
+*    documentation and/or other materials provided with the distribution.
+* 3. Neither the name of the copyright holder nor the names of its contributors
+*    may be used to endorse or promote products derived from this software without
+*    specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+function sliceAndTrimEndOf(str, startPtr, endPtr, allowNewLines) {
+	let value = str.slice(startPtr, endPtr);
+	let commentIdx = value.indexOf("#");
+	if (commentIdx > -1) {
+		skipComment(str, commentIdx);
+		value = value.slice(0, commentIdx);
+	}
+	let trimmed = value.trimEnd();
+	if (!allowNewLines) {
+		let newlineIdx = value.indexOf("\n", trimmed.length);
+		if (newlineIdx > -1) throw new TomlError("newlines are not allowed in inline tables", {
+			toml: str,
+			ptr: startPtr + newlineIdx
+		});
+	}
+	return [trimmed, commentIdx];
+}
+function extractValue(str, ptr, end, depth, integersAsBigInt) {
+	if (depth === 0) throw new TomlError("document contains excessively nested structures. aborting.", {
+		toml: str,
+		ptr
+	});
+	let c = str[ptr];
+	if (c === "[" || c === "{") {
+		let [value, endPtr] = c === "[" ? parseArray(str, ptr, depth, integersAsBigInt) : parseInlineTable(str, ptr, depth, integersAsBigInt);
+		let newPtr = end ? skipUntil(str, endPtr, ",", end) : endPtr;
+		if (endPtr - newPtr && end === "}") {
+			let nextNewLine = indexOfNewline(str, endPtr, newPtr);
+			if (nextNewLine > -1) throw new TomlError("newlines are not allowed in inline tables", {
+				toml: str,
+				ptr: nextNewLine
+			});
+		}
+		return [value, newPtr];
+	}
+	let endPtr;
+	if (c === "\"" || c === "'") {
+		endPtr = getStringEnd(str, ptr);
+		let parsed = parseString(str, ptr, endPtr);
+		if (end) {
+			endPtr = skipVoid(str, endPtr, end !== "]");
+			if (str[endPtr] && str[endPtr] !== "," && str[endPtr] !== end && str[endPtr] !== "\n" && str[endPtr] !== "\r") throw new TomlError("unexpected character encountered", {
+				toml: str,
+				ptr: endPtr
+			});
+			endPtr += +(str[endPtr] === ",");
+		}
+		return [parsed, endPtr];
+	}
+	endPtr = skipUntil(str, ptr, ",", end);
+	let slice = sliceAndTrimEndOf(str, ptr, endPtr - +(str[endPtr - 1] === ","), end === "]");
+	if (!slice[0]) throw new TomlError("incomplete key-value declaration: no value specified", {
+		toml: str,
+		ptr
+	});
+	if (end && slice[1] > -1) {
+		endPtr = skipVoid(str, ptr + slice[1]);
+		endPtr += +(str[endPtr] === ",");
+	}
+	return [parseValue(slice[0], str, ptr, integersAsBigInt), endPtr];
+}
+
+//#endregion
+//#region node_modules/smol-toml/dist/struct.js
+/*!
+* Copyright (c) Squirrel Chat et al., All rights reserved.
+* SPDX-License-Identifier: BSD-3-Clause
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are met:
+*
+* 1. Redistributions of source code must retain the above copyright notice, this
+*    list of conditions and the following disclaimer.
+* 2. Redistributions in binary form must reproduce the above copyright notice,
+*    this list of conditions and the following disclaimer in the
+*    documentation and/or other materials provided with the distribution.
+* 3. Neither the name of the copyright holder nor the names of its contributors
+*    may be used to endorse or promote products derived from this software without
+*    specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+let KEY_PART_RE = /^[a-zA-Z0-9-_]+[ \t]*$/;
+function parseKey(str, ptr, end = "=") {
+	let dot = ptr - 1;
+	let parsed = [];
+	let endPtr = str.indexOf(end, ptr);
+	if (endPtr < 0) throw new TomlError("incomplete key-value: cannot find end of key", {
+		toml: str,
+		ptr
+	});
+	do {
+		let c = str[ptr = ++dot];
+		if (c !== " " && c !== "	") {
+			if (c === "\"" || c === "'") {
+				if (c === str[ptr + 1] && c === str[ptr + 2]) throw new TomlError("multiline strings are not allowed in keys", {
+					toml: str,
+					ptr
+				});
+				let eos = getStringEnd(str, ptr);
+				if (eos < 0) throw new TomlError("unfinished string encountered", {
+					toml: str,
+					ptr
+				});
+				dot = str.indexOf(".", eos);
+				let strEnd = str.slice(eos, dot < 0 || dot > endPtr ? endPtr : dot);
+				let newLine = indexOfNewline(strEnd);
+				if (newLine > -1) throw new TomlError("newlines are not allowed in keys", {
+					toml: str,
+					ptr: ptr + dot + newLine
+				});
+				if (strEnd.trimStart()) throw new TomlError("found extra tokens after the string part", {
+					toml: str,
+					ptr: eos
+				});
+				if (endPtr < eos) {
+					endPtr = str.indexOf(end, eos);
+					if (endPtr < 0) throw new TomlError("incomplete key-value: cannot find end of key", {
+						toml: str,
+						ptr
+					});
+				}
+				parsed.push(parseString(str, ptr, eos));
+			} else {
+				dot = str.indexOf(".", ptr);
+				let part = str.slice(ptr, dot < 0 || dot > endPtr ? endPtr : dot);
+				if (!KEY_PART_RE.test(part)) throw new TomlError("only letter, numbers, dashes and underscores are allowed in keys", {
+					toml: str,
+					ptr
+				});
+				parsed.push(part.trimEnd());
+			}
+		}
+	} while (dot + 1 && dot < endPtr);
+	return [parsed, skipVoid(str, endPtr + 1, true, true)];
+}
+function parseInlineTable(str, ptr, depth, integersAsBigInt) {
+	let res = {};
+	let seen = /* @__PURE__ */ new Set();
+	let c;
+	let comma = 0;
+	ptr++;
+	while ((c = str[ptr++]) !== "}" && c) {
+		let err = {
+			toml: str,
+			ptr: ptr - 1
+		};
+		if (c === "\n") throw new TomlError("newlines are not allowed in inline tables", err);
+		else if (c === "#") throw new TomlError("inline tables cannot contain comments", err);
+		else if (c === ",") throw new TomlError("expected key-value, found comma", err);
+		else if (c !== " " && c !== "	") {
+			let k;
+			let t = res;
+			let hasOwn = false;
+			let [key, keyEndPtr] = parseKey(str, ptr - 1);
+			for (let i = 0; i < key.length; i++) {
+				if (i) t = hasOwn ? t[k] : t[k] = {};
+				k = key[i];
+				if ((hasOwn = Object.hasOwn(t, k)) && (typeof t[k] !== "object" || seen.has(t[k]))) throw new TomlError("trying to redefine an already defined value", {
+					toml: str,
+					ptr
+				});
+				if (!hasOwn && k === "__proto__") Object.defineProperty(t, k, {
+					enumerable: true,
+					configurable: true,
+					writable: true
+				});
+			}
+			if (hasOwn) throw new TomlError("trying to redefine an already defined value", {
+				toml: str,
+				ptr
+			});
+			let [value, valueEndPtr] = extractValue(str, keyEndPtr, "}", depth - 1, integersAsBigInt);
+			seen.add(value);
+			t[k] = value;
+			ptr = valueEndPtr;
+			comma = str[ptr - 1] === "," ? ptr - 1 : 0;
+		}
+	}
+	if (comma) throw new TomlError("trailing commas are not allowed in inline tables", {
+		toml: str,
+		ptr: comma
+	});
+	if (!c) throw new TomlError("unfinished table encountered", {
+		toml: str,
+		ptr
+	});
+	return [res, ptr];
+}
+function parseArray(str, ptr, depth, integersAsBigInt) {
+	let res = [];
+	let c;
+	ptr++;
+	while ((c = str[ptr++]) !== "]" && c) if (c === ",") throw new TomlError("expected value, found comma", {
+		toml: str,
+		ptr: ptr - 1
+	});
+	else if (c === "#") ptr = skipComment(str, ptr);
+	else if (c !== " " && c !== "	" && c !== "\n" && c !== "\r") {
+		let e = extractValue(str, ptr - 1, "]", depth - 1, integersAsBigInt);
+		res.push(e[0]);
+		ptr = e[1];
+	}
+	if (!c) throw new TomlError("unfinished array encountered", {
+		toml: str,
+		ptr
+	});
+	return [res, ptr];
+}
+
+//#endregion
+//#region node_modules/smol-toml/dist/parse.js
+/*!
+* Copyright (c) Squirrel Chat et al., All rights reserved.
+* SPDX-License-Identifier: BSD-3-Clause
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are met:
+*
+* 1. Redistributions of source code must retain the above copyright notice, this
+*    list of conditions and the following disclaimer.
+* 2. Redistributions in binary form must reproduce the above copyright notice,
+*    this list of conditions and the following disclaimer in the
+*    documentation and/or other materials provided with the distribution.
+* 3. Neither the name of the copyright holder nor the names of its contributors
+*    may be used to endorse or promote products derived from this software without
+*    specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+function peekTable(key, table, meta, type) {
+	let t = table;
+	let m = meta;
+	let k;
+	let hasOwn = false;
+	let state;
+	for (let i = 0; i < key.length; i++) {
+		if (i) {
+			t = hasOwn ? t[k] : t[k] = {};
+			m = (state = m[k]).c;
+			if (type === 0 && (state.t === 1 || state.t === 2)) return null;
+			if (state.t === 2) {
+				let l = t.length - 1;
+				t = t[l];
+				m = m[l].c;
+			}
+		}
+		k = key[i];
+		if ((hasOwn = Object.hasOwn(t, k)) && m[k]?.t === 0 && m[k]?.d) return null;
+		if (!hasOwn) {
+			if (k === "__proto__") {
+				Object.defineProperty(t, k, {
+					enumerable: true,
+					configurable: true,
+					writable: true
+				});
+				Object.defineProperty(m, k, {
+					enumerable: true,
+					configurable: true,
+					writable: true
+				});
+			}
+			m[k] = {
+				t: i < key.length - 1 && type === 2 ? 3 : type,
+				d: false,
+				i: 0,
+				c: {}
+			};
+		}
+	}
+	state = m[k];
+	if (state.t !== type && !(type === 1 && state.t === 3)) return null;
+	if (type === 2) {
+		if (!state.d) {
+			state.d = true;
+			t[k] = [];
+		}
+		t[k].push(t = {});
+		state.c[state.i++] = state = {
+			t: 1,
+			d: false,
+			i: 0,
+			c: {}
+		};
+	}
+	if (state.d) return null;
+	state.d = true;
+	if (type === 1) t = hasOwn ? t[k] : t[k] = {};
+	else if (type === 0 && hasOwn) return null;
+	return [
+		k,
+		t,
+		state.c
+	];
+}
+function parse$1(toml, { maxDepth = 1e3, integersAsBigInt } = {}) {
+	let res = {};
+	let meta = {};
+	let tbl = res;
+	let m = meta;
+	for (let ptr = skipVoid(toml, 0); ptr < toml.length;) {
+		if (toml[ptr] === "[") {
+			let isTableArray = toml[++ptr] === "[";
+			let k = parseKey(toml, ptr += +isTableArray, "]");
+			if (isTableArray) {
+				if (toml[k[1] - 1] !== "]") throw new TomlError("expected end of table declaration", {
+					toml,
+					ptr: k[1] - 1
+				});
+				k[1]++;
+			}
+			let p = peekTable(k[0], res, meta, isTableArray ? 2 : 1);
+			if (!p) throw new TomlError("trying to redefine an already defined table or value", {
+				toml,
+				ptr
+			});
+			m = p[2];
+			tbl = p[1];
+			ptr = k[1];
+		} else {
+			let k = parseKey(toml, ptr);
+			let p = peekTable(k[0], tbl, m, 0);
+			if (!p) throw new TomlError("trying to redefine an already defined table or value", {
+				toml,
+				ptr
+			});
+			let v = extractValue(toml, k[1], void 0, maxDepth, integersAsBigInt);
+			p[1][p[0]] = v[0];
+			ptr = v[1];
+		}
+		ptr = skipVoid(toml, ptr, true);
+		if (toml[ptr] && toml[ptr] !== "\n" && toml[ptr] !== "\r") throw new TomlError("each key-value declaration must be followed by an end-of-line", {
+			toml,
+			ptr
+		});
+		ptr = skipVoid(toml, ptr);
+	}
+	return res;
+}
+
+//#endregion
+//#region node_modules/smol-toml/dist/stringify.js
+/*!
+* Copyright (c) Squirrel Chat et al., All rights reserved.
+* SPDX-License-Identifier: BSD-3-Clause
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are met:
+*
+* 1. Redistributions of source code must retain the above copyright notice, this
+*    list of conditions and the following disclaimer.
+* 2. Redistributions in binary form must reproduce the above copyright notice,
+*    this list of conditions and the following disclaimer in the
+*    documentation and/or other materials provided with the distribution.
+* 3. Neither the name of the copyright holder nor the names of its contributors
+*    may be used to endorse or promote products derived from this software without
+*    specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+let BARE_KEY = /^[a-z0-9-_]+$/i;
+function extendedTypeOf(obj) {
+	let type = typeof obj;
+	if (type === "object") {
+		if (Array.isArray(obj)) return "array";
+		if (obj instanceof Date) return "date";
+	}
+	return type;
+}
+function isArrayOfTables(obj) {
+	for (let i = 0; i < obj.length; i++) if (extendedTypeOf(obj[i]) !== "object") return false;
+	return obj.length != 0;
+}
+function formatString(s) {
+	return JSON.stringify(s).replace(/\x7f/g, "\\u007f");
+}
+function stringifyValue(val, type, depth, numberAsFloat) {
+	if (depth === 0) throw new Error("Could not stringify the object: maximum object depth exceeded");
+	if (type === "number") {
+		if (isNaN(val)) return "nan";
+		if (val === Infinity) return "inf";
+		if (val === -Infinity) return "-inf";
+		if (numberAsFloat && Number.isInteger(val)) return val.toFixed(1);
+		return val.toString();
+	}
+	if (type === "bigint" || type === "boolean") return val.toString();
+	if (type === "string") return formatString(val);
+	if (type === "date") {
+		if (isNaN(val.getTime())) throw new TypeError("cannot serialize invalid date");
+		return val.toISOString();
+	}
+	if (type === "object") return stringifyInlineTable(val, depth, numberAsFloat);
+	if (type === "array") return stringifyArray(val, depth, numberAsFloat);
+}
+function stringifyInlineTable(obj, depth, numberAsFloat) {
+	let keys = Object.keys(obj);
+	if (keys.length === 0) return "{}";
+	let res = "{ ";
+	for (let i = 0; i < keys.length; i++) {
+		let k = keys[i];
+		if (i) res += ", ";
+		res += BARE_KEY.test(k) ? k : formatString(k);
+		res += " = ";
+		res += stringifyValue(obj[k], extendedTypeOf(obj[k]), depth - 1, numberAsFloat);
+	}
+	return res + " }";
+}
+function stringifyArray(array, depth, numberAsFloat) {
+	if (array.length === 0) return "[]";
+	let res = "[ ";
+	for (let i = 0; i < array.length; i++) {
+		if (i) res += ", ";
+		if (array[i] === null || array[i] === void 0) throw new TypeError("arrays cannot contain null or undefined values");
+		res += stringifyValue(array[i], extendedTypeOf(array[i]), depth - 1, numberAsFloat);
+	}
+	return res + " ]";
+}
+function stringifyArrayTable(array, key, depth, numberAsFloat) {
+	if (depth === 0) throw new Error("Could not stringify the object: maximum object depth exceeded");
+	let res = "";
+	for (let i = 0; i < array.length; i++) {
+		res += `[[${key}]]\n`;
+		res += stringifyTable(array[i], key, depth, numberAsFloat);
+		res += "\n\n";
+	}
+	return res;
+}
+function stringifyTable(obj, prefix, depth, numberAsFloat) {
+	if (depth === 0) throw new Error("Could not stringify the object: maximum object depth exceeded");
+	let preamble = "";
+	let tables = "";
+	let keys = Object.keys(obj);
+	for (let i = 0; i < keys.length; i++) {
+		let k = keys[i];
+		if (obj[k] !== null && obj[k] !== void 0) {
+			let type = extendedTypeOf(obj[k]);
+			if (type === "symbol" || type === "function") throw new TypeError(`cannot serialize values of type '${type}'`);
+			let key = BARE_KEY.test(k) ? k : formatString(k);
+			if (type === "array" && isArrayOfTables(obj[k])) tables += stringifyArrayTable(obj[k], prefix ? `${prefix}.${key}` : key, depth - 1, numberAsFloat);
+			else if (type === "object") {
+				let tblKey = prefix ? `${prefix}.${key}` : key;
+				tables += `[${tblKey}]\n`;
+				tables += stringifyTable(obj[k], tblKey, depth - 1, numberAsFloat);
+				tables += "\n\n";
+			} else {
+				preamble += key;
+				preamble += " = ";
+				preamble += stringifyValue(obj[k], type, depth, numberAsFloat);
+				preamble += "\n";
+			}
+		}
+	}
+	return `${preamble}\n${tables}`.trim();
+}
+function stringify(obj, { maxDepth = 1e3, numbersAsFloat = false } = {}) {
+	if (extendedTypeOf(obj) !== "object") throw new TypeError("stringify can only be called with an object");
+	return stringifyTable(obj, "", maxDepth, numbersAsFloat);
+}
+
+//#endregion
+//#region src/config.js
+async function assertSafePath(path) {
+	let current = parse(resolve(path)).root;
+	for (const part of resolve(path).slice(current.length).split(/[\\/]/).filter(Boolean)) {
+		current = join(current, part);
+		try {
+			if ((await lstat(current)).isSymbolicLink()) throw new Error(`Refusing symbolic link: ${current}`);
+		} catch (error) {
+			if (error.code !== "ENOENT") throw error;
+		}
+	}
+}
+async function readConfig(path) {
+	await assertSafePath(path);
+	try {
+		return await readFile(path, "utf8");
+	} catch (error) {
+		if (error.code === "ENOENT") return null;
+		throw error;
+	}
+}
+function object(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function parseJson(text, path) {
+	const errors = [];
+	const value = parse$2(text ?? "{}", errors, { allowTrailingComma: true });
+	if (errors.length || !object(value)) throw new Error(`Invalid JSON/JSONC object in ${path}; nothing overwritten.`);
+	return value;
+}
+function editJson(text, changes, path) {
+	let next = text ?? "{}\n";
+	for (const [keys, value] of changes) {
+		let parent = parseJson(next, path);
+		for (const key of keys.slice(0, -1)) {
+			if (!Object.hasOwn(parent, key)) break;
+			if (!object(parent[key])) throw new Error(`Expected object at ${keys.join(".")} in ${path}`);
+			parent = parent[key];
+		}
+		next = applyEdits(next, modify(next, keys, value, { formattingOptions: {
+			insertSpaces: true,
+			tabSize: 2,
+			eol: next.includes("\r\n") ? "\r\n" : "\n"
+		} }));
+	}
+	parseJson(next, path);
+	return next;
+}
+function addToml(text, desired, path) {
+	let existing;
+	try {
+		existing = parse$1(text ?? "");
+	} catch {
+		throw new Error(`Invalid TOML in ${path}; nothing overwritten.`);
+	}
+	const missing = {};
+	for (const [key, value] of Object.entries(desired)) if (!Object.hasOwn(existing, key)) missing[key] = value;
+	else if (!isDeepStrictEqual(existing[key], value)) throw new Error(`Conflicting ${key} in ${path}. Review it manually; nothing overwritten.`);
+	if (!Object.keys(missing).length) return text ?? "";
+	const scalars = Object.fromEntries(Object.entries(missing).filter(([, value]) => !object(value)));
+	const tables = Object.fromEntries(Object.entries(missing).filter(([, value]) => object(value)));
+	const parts = [];
+	if (Object.keys(scalars).length) parts.push(stringify(scalars));
+	if ((text ?? "").trim()) parts.push(text);
+	if (Object.keys(tables).length) parts.push(stringify(tables));
+	const next = `${parts.map((part) => part.replace(/\s+$/, "")).join("\n\n")}\n`;
+	parse$1(next);
+	return next;
+}
+function sha256(text) {
+	return createHash("sha256").update(text, "utf8").digest("hex");
+}
+async function writeAtomic(path, text, check = async () => {}) {
+	await mkdir(dirname(path), {
+		recursive: true,
+		mode: 448
+	});
+	const temporary = `${path}.apex-tmp-${randomUUID().slice(0, 8)}`;
+	try {
+		const handle = await open(temporary, "wx", 384);
+		try {
+			await handle.writeFile(text);
+			await handle.sync();
+		} finally {
+			await handle.close();
+		}
+		await check();
+		await rename(temporary, path);
+	} finally {
+		await unlink(temporary).catch((error) => {
+			if (error.code !== "ENOENT") throw error;
+		});
+	}
+}
+async function removeChange(change) {
+	const { path, before } = change;
+	if (await readConfig(path) !== before) throw new Error(`Configuration changed while planning: ${path}. Run undo again.`);
+	await unlink(path);
+}
+async function writeChange(change) {
+	const { path, before, after } = change;
+	if (await readConfig(path) !== before) throw new Error(`Configuration changed while planning: ${path}. Run init again.`);
+	const backup = before === null ? null : `${path}.apex-backup-${randomUUID().slice(0, 8)}`;
+	if (backup) {
+		const handle = await open(backup, "wx", 384);
+		try {
+			await handle.writeFile(before);
+		} finally {
+			await handle.close();
+		}
+	}
+	await writeAtomic(path, after, async () => {
+		if (await readConfig(path) !== before) throw new Error(`Configuration changed before saving: ${path}`);
+	});
+	return backup;
+}
+
+//#endregion
+//#region src/assistants.js
+const MODEL = "callstack/Apex";
+const BASE_URL = "https://api.callstack.ai/v1";
+const GUIDE_URL = "https://app.notion.com/p/callstack/Apex-how-to-use-it-36d5d027c0f880e99d03d1c37a77382f";
+const IDS = [
+	"opencode",
+	"codex",
+	"claude",
+	"pi",
+	"cursor",
+	"copilot",
+	"ai-sdk"
+];
+const NAMES = {
+	opencode: "OpenCode",
+	codex: "Codex",
+	claude: "Claude Code",
+	pi: "Pi",
+	cursor: "Cursor",
+	copilot: "VS Code (Copilot)",
+	"ai-sdk": "Vercel AI SDK / Eve"
+};
+const RUNNABLE = [
+	"codex",
+	"claude",
+	"opencode",
+	"pi"
+];
+const CONTEXT_WINDOW = 262144;
+const MAX_INPUT = 24e4;
+const MAX_OUTPUT = 16384;
+const EFFORTS = [
+	"none",
+	"low",
+	"medium",
+	"xhigh"
+];
+const OPENCODE_MODEL = {
+	name: "Apex",
+	reasoning: true,
+	tool_call: true,
+	attachment: true,
+	modalities: {
+		input: ["text", "image"],
+		output: ["text"]
+	},
+	limit: {
+		context: CONTEXT_WINDOW,
+		input: MAX_INPUT,
+		output: MAX_OUTPUT
+	},
+	options: { reasoningEffort: "medium" },
+	variants: Object.fromEntries(EFFORTS.map((effort) => [effort, { reasoningEffort: effort }]))
+};
+const OPENCODE_V2_PROVIDER = {
+	name: "callstack.ai",
+	package: "@opencode/ai/providers/openai-compatible",
+	settings: { baseURL: BASE_URL },
+	models: { [MODEL]: {
+		name: "Apex",
+		capabilities: {
+			tools: true,
+			input: ["text", "image"],
+			output: ["text"]
+		},
+		limit: {
+			context: CONTEXT_WINDOW,
+			input: MAX_INPUT,
+			output: MAX_OUTPUT
+		},
+		settings: { reasoningEffort: "medium" },
+		variants: EFFORTS.map((effort) => ({
+			id: effort,
+			settings: { reasoningEffort: effort }
+		}))
+	} }
+};
+const PI_MODEL = {
+	id: MODEL,
+	reasoning: true,
+	input: ["text", "image"],
+	thinkingLevelMap: {
+		off: "none",
+		minimal: null,
+		low: "low",
+		medium: "medium",
+		high: null,
+		xhigh: "xhigh",
+		max: null
+	},
+	contextWindow: CONTEXT_WINDOW
+};
+async function exists(path) {
+	try {
+		await stat(path);
+		return true;
+	} catch (error) {
+		if (error.code === "ENOENT" || error.code === "ENOTDIR") return false;
+		throw error;
+	}
+}
+async function executable(command, env = process.env, platform = process.platform) {
+	const extensions = platform === "win32" ? (env.PATHEXT || ".EXE;.CMD;.BAT").split(";") : [""];
+	for (const directory of (env.PATH || "").split(platform === "win32" ? ";" : delimiter).filter(Boolean)) for (const extension of extensions) {
+		const path = join(directory, command + extension.toLowerCase());
+		try {
+			await access(path, platform === "win32" ? constants.F_OK : constants.X_OK);
+			if ((await stat(path)).isFile()) return path;
+		} catch (error) {
+			if (![
+				"ENOENT",
+				"ENOTDIR",
+				"EACCES"
+			].includes(error.code)) throw error;
+		}
+	}
+	return null;
+}
+function locations(home = homedir(), env = process.env, platform = process.platform) {
+	const config = env.XDG_CONFIG_HOME || join(home, ".config");
+	const userData = platform === "darwin" ? join(home, "Library", "Application Support") : platform === "win32" ? env.APPDATA || join(home, "AppData", "Roaming") : config;
+	return {
+		opencode: join(config, "opencode"),
+		codex: env.CODEX_HOME || join(home, ".codex"),
+		claude: env.CLAUDE_CONFIG_DIR || join(home, ".claude"),
+		pi: env.PI_CODING_AGENT_DIR || join(home, ".pi", "agent"),
+		cursor: join(userData, "Cursor"),
+		copilot: join(userData, "Code")
+	};
+}
+async function aiSdkProject(cwd) {
+	const path = join(cwd, "package.json");
+	let pkg;
+	try {
+		pkg = JSON.parse(await readFile(path, "utf8"));
+	} catch {
+		return null;
+	}
+	const deps = {
+		...pkg?.dependencies,
+		...pkg?.devDependencies
+	};
+	return [
+		"ai",
+		"@ai-sdk/openai",
+		"eve"
+	].some((name) => Object.hasOwn(deps, name)) ? path : null;
+}
+async function detect(options = {}) {
+	const home = options.home ?? homedir();
+	const env = options.env ?? process.env;
+	const platform = options.platform ?? process.platform;
+	const cwd = options.cwd ?? process.cwd();
+	const paths = locations(home, env, platform);
+	return Promise.all(IDS.map(async (id) => {
+		if (id === "ai-sdk") {
+			const evidence = await aiSdkProject(cwd);
+			return {
+				id,
+				detected: Boolean(evidence),
+				binary: null,
+				evidence,
+				directory: cwd
+			};
+		}
+		const binary = await executable(id === "copilot" ? "code" : id, env, platform);
+		const markers = [paths[id]];
+		if (platform === "darwin" && ["cursor", "copilot"].includes(id)) {
+			const name = id === "cursor" ? "Cursor.app" : "Visual Studio Code.app";
+			markers.push(join("/Applications", name), join(home, "Applications", name));
+		}
+		if (id === "copilot") markers.push(join(home, ".vscode", "extensions"));
+		const found = [];
+		for (const path of markers) if (await exists(path)) found.push(path);
+		return {
+			id,
+			detected: Boolean(binary || found.length),
+			binary,
+			evidence: binary || found[0],
+			directory: paths[id],
+			...id === "opencode" ? { authFile: join(env.XDG_DATA_HOME || join(home, ".local", "share"), "opencode", "auth.json") } : {}
+		};
+	}));
+}
+async function openCodeHasKey(authFile) {
+	if (!authFile) return false;
+	try {
+		return Object.hasOwn(JSON.parse(await readConfig(authFile) ?? "{}"), "callstack.ai");
+	} catch {
+		return false;
+	}
+}
+const PI_PLACEHOLDER = "XXX";
+async function planAssistant(assistant) {
+	const changes = [];
+	const json = async (filename, updates) => {
+		const path = join(assistant.directory, filename);
+		const before = await readConfig(path);
+		const after = editJson(before, typeof updates === "function" ? updates(parseJson(before, path)) : updates, path);
+		changes.push({
+			path,
+			before,
+			after,
+			format: "json"
+		});
+	};
+	switch (assistant.id) {
+		case "opencode": {
+			const hasJson = await exists(join(assistant.directory, "opencode.json"));
+			const hasJsonc = await exists(join(assistant.directory, "opencode.jsonc"));
+			if (hasJson && hasJsonc) throw new Error("Both opencode.json and opencode.jsonc exist. Consolidate them before init.");
+			let v2 = false;
+			const storedKey = await openCodeHasKey(assistant.authFile);
+			await json(hasJsonc ? "opencode.jsonc" : "opencode.json", (existing) => {
+				v2 = Object.hasOwn(existing, "providers");
+				if (v2) return [[["providers", "callstack.ai"], OPENCODE_V2_PROVIDER]];
+				return [
+					[[
+						"provider",
+						"callstack.ai",
+						"npm"
+					], "@ai-sdk/openai-compatible"],
+					[[
+						"provider",
+						"callstack.ai",
+						"name"
+					], "callstack.ai"],
+					[[
+						"provider",
+						"callstack.ai",
+						"options",
+						"baseURL"
+					], BASE_URL],
+					...storedKey ? [] : [[[
+						"provider",
+						"callstack.ai",
+						"options",
+						"apiKey"
+					], "{env:CALLSTACK_AUTH_TOKEN}"]],
+					[[
+						"provider",
+						"callstack.ai",
+						"models",
+						MODEL
+					], OPENCODE_MODEL]
+				];
+			});
+			if (v2) changes[0].steps = ["OpenCode 2 stores provider keys itself: run /connect in OpenCode, pick callstack.ai → \"Manually enter API Key\", and paste your Callstack key."];
+			break;
+		}
+		case "pi":
+			await json("models.json", (existing) => {
+				const models = existing.providers?.callstack?.models ?? [];
+				const key = existing.providers?.callstack?.apiKey;
+				if (!Array.isArray(models) || models.some((model) => !model || typeof model.id !== "string")) throw new Error("Expected Pi models to be an array of model objects.");
+				return [
+					[[
+						"providers",
+						"callstack",
+						"baseUrl"
+					], BASE_URL],
+					[[
+						"providers",
+						"callstack",
+						"api"
+					], "openai-completions"],
+					...key && key !== PI_PLACEHOLDER ? [] : [[[
+						"providers",
+						"callstack",
+						"apiKey"
+					], "$CALLSTACK_AUTH_TOKEN"]],
+					[[
+						"providers",
+						"callstack",
+						"models"
+					], models.some((model) => model.id === "callstack/Apex") ? models.map((model) => model.id === "callstack/Apex" ? PI_MODEL : model) : [...models, PI_MODEL]]
+				];
+			});
+			break;
+		case "claude":
+			await json("settings.json", [[["env", "CLAUDE_CODE_ATTRIBUTION_HEADER"], "0"]]);
+			break;
+		case "codex": {
+			const path = join(assistant.directory, "callstack_ai.config.toml");
+			const before = await readConfig(path);
+			const after = addToml(before, {
+				model_provider: "callstack_ai",
+				model: MODEL,
+				model_context_window: CONTEXT_WINDOW,
+				model_reasoning_effort: "medium",
+				model_providers: { callstack_ai: {
+					name: "callstack.ai",
+					base_url: BASE_URL,
+					env_key: "CALLSTACK_AUTH_TOKEN",
+					wire_api: "responses",
+					requires_openai_auth: false
+				} }
+			}, path);
+			changes.push({
+				path,
+				before,
+				after,
+				format: "toml"
+			});
+			break;
+		}
+	}
+	return changes;
+}
+function launchOptions(id, env = process.env) {
+	const token = env.CALLSTACK_AUTH_TOKEN;
+	if (!token?.trim()) throw new Error("Set CALLSTACK_AUTH_TOKEN in your environment before launching.");
+	const childEnv = { ...env };
+	switch (id) {
+		case "opencode": return {
+			args: ["--model", `callstack.ai/${MODEL}`],
+			env: childEnv
+		};
+		case "codex": return {
+			args: ["--profile", "callstack_ai"],
+			env: childEnv
+		};
+		case "pi": return {
+			args: [
+				"--provider",
+				"callstack",
+				"--model",
+				MODEL
+			],
+			env: childEnv
+		};
+		case "claude":
+			for (const key of [
+				"ANTHROPIC_API_KEY",
+				"CLAUDE_CODE_OAUTH_TOKEN",
+				"CLAUDE_CODE_USE_BEDROCK",
+				"CLAUDE_CODE_USE_VERTEX",
+				"CLAUDE_CODE_USE_FOUNDRY"
+			]) delete childEnv[key];
+			Object.assign(childEnv, {
+				ANTHROPIC_BASE_URL: "https://api.callstack.ai",
+				ANTHROPIC_AUTH_TOKEN: token,
+				ANTHROPIC_MODEL: MODEL,
+				CLAUDE_CODE_ATTRIBUTION_HEADER: "0",
+				ANTHROPIC_DEFAULT_OPUS_MODEL: MODEL,
+				ANTHROPIC_DEFAULT_SONNET_MODEL: MODEL,
+				ANTHROPIC_DEFAULT_HAIKU_MODEL: MODEL,
+				CLAUDE_CODE_SUBAGENT_MODEL: MODEL
+			});
+			return {
+				args: ["--model", MODEL],
+				env: childEnv
+			};
+		default: throw new Error(`Cannot launch ${id}. Use the editor's model selector.`);
+	}
+}
+const RUN_NOTE = { claude: "(ANTHROPIC_* gateway environment set)" };
+function runExpansion(id) {
+	const { args } = launchOptions(id, { CALLSTACK_AUTH_TOKEN: "placeholder" });
+	return [`${id} ${args.join(" ")}`, RUN_NOTE[id]].filter(Boolean).join("  ");
+}
+const COPILOT_MODEL = JSON.stringify({
+	id: MODEL,
+	name: "Apex",
+	url: BASE_URL,
+	toolCalling: true,
+	vision: true,
+	thinking: true,
+	contextWindow: CONTEXT_WINDOW,
+	maxOutputTokens: MAX_OUTPUT,
+	supportsReasoningEffort: EFFORTS,
+	reasoningEffortFormat: "chat-completions"
+}, null, 2);
+const AI_SDK_SNIPPET = [
+	"import { createOpenAI } from '@ai-sdk/openai';",
+	"",
+	"const apex = createOpenAI({",
+	"  name: 'callstack',",
+	`  baseURL: '${BASE_URL}',`,
+	"  apiKey: process.env.CALLSTACK_AUTH_TOKEN,",
+	"});",
+	`// apex('${MODEL}') with generateText / streamText.`,
+	`// Reasoning effort (${EFFORTS.join(", ")}):`,
+	"// providerOptions: { callstack: { reasoningEffort: 'medium' } }"
+];
+const MANUAL = {
+	cursor: [`Cursor: Settings → Models → API Keys → OpenAI API Key. Enter your Callstack key, override the base URL with ${BASE_URL}, add and enable ${MODEL}, then select it in Agent.`, "Cursor has no way to declare what a custom model can do (tool calling, vision, reasoning); it infers that itself."],
+	copilot: [
+		"Installation of Copilot itself is not verified: Copilot → model selector → Manage Models → Add Models → Custom Endpoint → name callstack.ai → enter your key → Chat Completions.",
+		"Keep the generated apiKey secret reference; add this object to its models array:",
+		...COPILOT_MODEL.split("\n")
+	],
+	"ai-sdk": [
+		"Apex CLI never writes your key into a project. Keep it in CALLSTACK_AUTH_TOKEN (for example in a .env that git ignores) and create the provider with:",
+		...AI_SDK_SNIPPET,
+		`Eve: set modelContextWindowTokens: ${CONTEXT_WINDOW} on defineAgent, or compaction will fail to compile.`
+	]
+};
+const MANUAL_IDS = Object.keys(MANUAL);
+
+//#endregion
+//#region node_modules/fast-string-truncated-width/dist/utils.js
+const getCodePointsLength = (() => {
+	const SURROGATE_PAIR_RE = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+	return (input) => {
+		let surrogatePairsNr = 0;
+		SURROGATE_PAIR_RE.lastIndex = 0;
+		while (SURROGATE_PAIR_RE.test(input)) surrogatePairsNr += 1;
+		return input.length - surrogatePairsNr;
+	};
+})();
+const isFullWidth = (x) => {
+	return x === 12288 || x >= 65281 && x <= 65376 || x >= 65504 && x <= 65510;
+};
+const isWideNotCJKTNotEmoji = (x) => {
+	return x === 8987 || x === 9001 || x >= 12272 && x <= 12287 || x >= 12289 && x <= 12350 || x >= 12441 && x <= 12543 || x >= 12549 && x <= 12591 || x >= 12593 && x <= 12686 || x >= 12688 && x <= 12771 || x >= 12783 && x <= 12830 || x >= 12832 && x <= 12871 || x >= 12880 && x <= 19903 || x >= 65040 && x <= 65049 || x >= 65072 && x <= 65106 || x >= 65108 && x <= 65126 || x >= 65128 && x <= 65131 || x >= 127488 && x <= 127490 || x >= 127504 && x <= 127547 || x >= 127552 && x <= 127560 || x >= 131072 && x <= 196605 || x >= 196608 && x <= 262141;
+};
+
+//#endregion
+//#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;
+const TAB_RE = /\t{1,1000}/y;
+const EMOJI_RE = /[\u{1F1E6}-\u{1F1FF}]{2}|\u{1F3F4}[\u{E0061}-\u{E007A}]{2}[\u{E0030}-\u{E0039}\u{E0061}-\u{E007A}]{1,3}\u{E007F}|(?:\p{Emoji}\uFE0F\u20E3?|\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|\p{Emoji_Presentation})(?:\u200D(?:\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|\p{Emoji_Presentation}|\p{Emoji}\uFE0F\u20E3?))*/uy;
+const LATIN_RE = /(?:[\x20-\x7E\xA0-\xFF](?!\uFE0F)){1,1000}/y;
+const MODIFIER_RE = /\p{M}+/gu;
+const NO_TRUNCATION$1 = {
+	limit: Infinity,
+	ellipsis: ""
+};
+const getStringTruncatedWidth = (input, truncationOptions = {}, widthOptions = {}) => {
+	const LIMIT = truncationOptions.limit ?? Infinity;
+	const ELLIPSIS = truncationOptions.ellipsis ?? "";
+	const ELLIPSIS_WIDTH = truncationOptions?.ellipsisWidth ?? (ELLIPSIS ? getStringTruncatedWidth(ELLIPSIS, NO_TRUNCATION$1, widthOptions).width : 0);
+	const ANSI_WIDTH = 0;
+	const CONTROL_WIDTH = widthOptions.controlWidth ?? 0;
+	const TAB_WIDTH = widthOptions.tabWidth ?? 8;
+	const EMOJI_WIDTH = widthOptions.emojiWidth ?? 2;
+	const FULL_WIDTH_WIDTH = 2;
+	const REGULAR_WIDTH = widthOptions.regularWidth ?? 1;
+	const WIDE_WIDTH = widthOptions.wideWidth ?? FULL_WIDTH_WIDTH;
+	const PARSE_BLOCKS = [
+		[LATIN_RE, REGULAR_WIDTH],
+		[ANSI_RE, ANSI_WIDTH],
+		[CONTROL_RE, CONTROL_WIDTH],
+		[TAB_RE, TAB_WIDTH],
+		[EMOJI_RE, EMOJI_WIDTH],
+		[CJKT_WIDE_RE, WIDE_WIDTH]
+	];
+	let indexPrev = 0;
+	let index = 0;
+	let length = input.length;
+	let lengthExtra = 0;
+	let truncationEnabled = false;
+	let truncationIndex = length;
+	let truncationLimit = Math.max(0, LIMIT - ELLIPSIS_WIDTH);
+	let unmatchedStart = 0;
+	let unmatchedEnd = 0;
+	let width = 0;
+	let widthExtra = 0;
+	outer: while (true) {
+		if (unmatchedEnd > unmatchedStart || index >= length && index > indexPrev) {
+			const unmatched = input.slice(unmatchedStart, unmatchedEnd) || input.slice(indexPrev, index);
+			lengthExtra = 0;
+			for (const char of unmatched.replaceAll(MODIFIER_RE, "")) {
+				const codePoint = char.codePointAt(0) || 0;
+				if (isFullWidth(codePoint)) widthExtra = FULL_WIDTH_WIDTH;
+				else if (isWideNotCJKTNotEmoji(codePoint)) widthExtra = WIDE_WIDTH;
+				else widthExtra = REGULAR_WIDTH;
+				if (width + widthExtra > truncationLimit) truncationIndex = Math.min(truncationIndex, Math.max(unmatchedStart, indexPrev) + lengthExtra);
+				if (width + widthExtra > LIMIT) {
+					truncationEnabled = true;
+					break outer;
+				}
+				lengthExtra += char.length;
+				width += widthExtra;
+			}
+			unmatchedStart = unmatchedEnd = 0;
+		}
+		if (index >= length) break outer;
+		for (let i = 0, l = PARSE_BLOCKS.length; i < l; i++) {
+			const [BLOCK_RE, BLOCK_WIDTH] = PARSE_BLOCKS[i];
+			BLOCK_RE.lastIndex = index;
+			if (BLOCK_RE.test(input)) {
+				lengthExtra = BLOCK_RE === CJKT_WIDE_RE ? getCodePointsLength(input.slice(index, BLOCK_RE.lastIndex)) : BLOCK_RE === EMOJI_RE ? 1 : BLOCK_RE.lastIndex - index;
+				widthExtra = lengthExtra * BLOCK_WIDTH;
+				if (width + widthExtra > truncationLimit) truncationIndex = Math.min(truncationIndex, index + Math.floor((truncationLimit - width) / BLOCK_WIDTH));
+				if (width + widthExtra > LIMIT) {
+					truncationEnabled = true;
+					break outer;
+				}
+				width += widthExtra;
+				unmatchedStart = indexPrev;
+				unmatchedEnd = index;
+				index = indexPrev = BLOCK_RE.lastIndex;
+				continue outer;
+			}
+		}
+		index += 1;
+	}
+	return {
+		width: truncationEnabled ? truncationLimit : width,
+		index: truncationEnabled ? truncationIndex : length,
+		truncated: truncationEnabled,
+		ellipsed: truncationEnabled && LIMIT >= ELLIPSIS_WIDTH
+	};
+};
+
+//#endregion
+//#region node_modules/fast-string-width/dist/index.js
+const NO_TRUNCATION = {
+	limit: Infinity,
+	ellipsis: "",
+	ellipsisWidth: 0
+};
+const fastStringWidth = (input, options = {}) => {
+	return getStringTruncatedWidth(input, NO_TRUNCATION, options).width;
+};
+
+//#endregion
+//#region node_modules/fast-wrap-ansi/lib/main.js
+const ESC = "\x1B";
+const CSI = "›";
+const END_CODE = 39;
+const ANSI_ESCAPE_BELL = "\x07";
+const ANSI_CSI = "[";
+const ANSI_OSC = "]";
+const ANSI_SGR_TERMINATOR = "m";
+const ANSI_ESCAPE_LINK = `${ANSI_OSC}8;;`;
+const GROUP_REGEX = new RegExp(`(?:\\${ANSI_CSI}(?<code>\\d+)m|\\${ANSI_ESCAPE_LINK}(?<uri>.*)${ANSI_ESCAPE_BELL})`, "y");
+const getClosingCode = (openingCode) => {
+	if (openingCode >= 30 && openingCode <= 37) return 39;
+	if (openingCode >= 90 && openingCode <= 97) return 39;
+	if (openingCode >= 40 && openingCode <= 47) return 49;
+	if (openingCode >= 100 && openingCode <= 107) return 49;
+	if (openingCode === 1 || openingCode === 2) return 22;
+	if (openingCode === 3) return 23;
+	if (openingCode === 4) return 24;
+	if (openingCode === 7) return 27;
+	if (openingCode === 8) return 28;
+	if (openingCode === 9) return 29;
+	if (openingCode === 0) return 0;
+};
+const wrapAnsiCode = (code) => `${ESC}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`;
+const wrapAnsiHyperlink = (url) => `${ESC}${ANSI_ESCAPE_LINK}${url}${ANSI_ESCAPE_BELL}`;
+const wrapWord = (rows, word, columns) => {
+	const characters = word[Symbol.iterator]();
+	let isInsideEscape = false;
+	let isInsideLinkEscape = false;
+	let lastRow = rows.at(-1);
+	let visible = lastRow === void 0 ? 0 : fastStringWidth(lastRow);
+	let currentCharacter = characters.next();
+	let nextCharacter = characters.next();
+	let rawCharacterIndex = 0;
+	while (!currentCharacter.done) {
+		const character = currentCharacter.value;
+		const characterLength = fastStringWidth(character);
+		if (visible + characterLength <= columns) rows[rows.length - 1] += character;
+		else {
+			rows.push(character);
+			visible = 0;
+		}
+		if (character === ESC || character === CSI) {
+			isInsideEscape = true;
+			isInsideLinkEscape = word.startsWith(ANSI_ESCAPE_LINK, rawCharacterIndex + 1);
+		}
+		if (isInsideEscape) {
+			if (isInsideLinkEscape) {
+				if (character === ANSI_ESCAPE_BELL) {
+					isInsideEscape = false;
+					isInsideLinkEscape = false;
+				}
+			} else if (character === ANSI_SGR_TERMINATOR) isInsideEscape = false;
+		} else {
+			visible += characterLength;
+			if (visible === columns && !nextCharacter.done) {
+				rows.push("");
+				visible = 0;
+			}
+		}
+		currentCharacter = nextCharacter;
+		nextCharacter = characters.next();
+		rawCharacterIndex += character.length;
+	}
+	lastRow = rows.at(-1);
+	if (!visible && lastRow !== void 0 && lastRow.length && rows.length > 1) rows[rows.length - 2] += rows.pop();
+};
+const stringVisibleTrimSpacesRight = (string) => {
+	const words = string.split(" ");
+	let last = words.length;
+	while (last) {
+		if (fastStringWidth(words[last - 1])) break;
+		last--;
+	}
+	if (last === words.length) return string;
+	return words.slice(0, last).join(" ") + words.slice(last).join("");
+};
+const exec = (string, columns, options = {}) => {
+	if (options.trim !== false && string.trim() === "") return "";
+	let returnValue = "";
+	let escapeCode;
+	let escapeUrl;
+	const words = string.split(" ");
+	let rows = [""];
+	let rowLength = 0;
+	for (let index = 0; index < words.length; index++) {
+		const word = words[index];
+		if (options.trim !== false) {
+			const row = rows.at(-1) ?? "";
+			const trimmed = row.trimStart();
+			if (row.length !== trimmed.length) {
+				rows[rows.length - 1] = trimmed;
+				rowLength = fastStringWidth(trimmed);
+			}
+		}
+		if (index !== 0) {
+			if (rowLength >= columns && (options.wordWrap === false || options.trim === false)) {
+				rows.push("");
+				rowLength = 0;
+			}
+			if (rowLength || options.trim === false) {
+				rows[rows.length - 1] += " ";
+				rowLength++;
+			}
+		}
+		const wordLength = fastStringWidth(word);
+		if (options.hard && wordLength > columns) {
+			const remainingColumns = columns - rowLength;
+			const breaksStartingThisLine = 1 + Math.floor((wordLength - remainingColumns - 1) / columns);
+			if (Math.floor((wordLength - 1) / columns) < breaksStartingThisLine) rows.push("");
+			wrapWord(rows, word, columns);
+			rowLength = fastStringWidth(rows.at(-1) ?? "");
+			continue;
+		}
+		if (rowLength + wordLength > columns && rowLength && wordLength) {
+			if (options.wordWrap === false && rowLength < columns) {
+				wrapWord(rows, word, columns);
+				rowLength = fastStringWidth(rows.at(-1) ?? "");
+				continue;
+			}
+			rows.push("");
+			rowLength = 0;
+		}
+		if (rowLength + wordLength > columns && options.wordWrap === false) {
+			wrapWord(rows, word, columns);
+			rowLength = fastStringWidth(rows.at(-1) ?? "");
+			continue;
+		}
+		rows[rows.length - 1] += word;
+		rowLength += wordLength;
+	}
+	if (options.trim !== false) rows = rows.map((row) => stringVisibleTrimSpacesRight(row));
+	const preString = rows.join("\n");
+	let inSurrogate = false;
+	for (let i = 0; i < preString.length; i++) {
+		const character = preString[i];
+		returnValue += character;
+		if (!inSurrogate) {
+			inSurrogate = character >= "\ud800" && character <= "\udbff";
+			if (inSurrogate) continue;
+		} else inSurrogate = false;
+		if (character === ESC || character === CSI) {
+			GROUP_REGEX.lastIndex = i + 1;
+			const groups = GROUP_REGEX.exec(preString)?.groups;
+			if (groups?.code !== void 0) {
+				const code = Number.parseFloat(groups.code);
+				escapeCode = code === END_CODE ? void 0 : code;
+			} else if (groups?.uri !== void 0) escapeUrl = groups.uri.length === 0 ? void 0 : groups.uri;
+		}
+		if (preString[i + 1] === "\n") {
+			if (escapeUrl) returnValue += wrapAnsiHyperlink("");
+			const closingCode = escapeCode ? getClosingCode(escapeCode) : void 0;
+			if (escapeCode && closingCode) returnValue += wrapAnsiCode(closingCode);
+		} else if (character === "\n") {
+			if (escapeCode && getClosingCode(escapeCode)) returnValue += wrapAnsiCode(escapeCode);
+			if (escapeUrl) returnValue += wrapAnsiHyperlink(escapeUrl);
+		}
+	}
+	return returnValue;
+};
+const CRLF_OR_LF = /\r?\n/;
+function wrapAnsi(string, columns, options) {
+	return String(string).normalize().split(CRLF_OR_LF).map((line) => exec(line, columns, options)).join("\n");
+}
+
+//#endregion
+//#region node_modules/sisteransi/src/index.js
+var require_src = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const ESC = "\x1B";
+	const CSI = `${ESC}[`;
+	const beep = "\x07";
+	const cursor = {
+		to(x, y) {
+			if (!y) return `${CSI}${x + 1}G`;
+			return `${CSI}${y + 1};${x + 1}H`;
+		},
+		move(x, y) {
+			let ret = "";
+			if (x < 0) ret += `${CSI}${-x}D`;
+			else if (x > 0) ret += `${CSI}${x}C`;
+			if (y < 0) ret += `${CSI}${-y}A`;
+			else if (y > 0) ret += `${CSI}${y}B`;
+			return ret;
+		},
+		up: (count = 1) => `${CSI}${count}A`,
+		down: (count = 1) => `${CSI}${count}B`,
+		forward: (count = 1) => `${CSI}${count}C`,
+		backward: (count = 1) => `${CSI}${count}D`,
+		nextLine: (count = 1) => `${CSI}E`.repeat(count),
+		prevLine: (count = 1) => `${CSI}F`.repeat(count),
+		left: `${CSI}G`,
+		hide: `${CSI}?25l`,
+		show: `${CSI}?25h`,
+		save: `${ESC}7`,
+		restore: `${ESC}8`
+	};
+	const scroll = {
+		up: (count = 1) => `${CSI}S`.repeat(count),
+		down: (count = 1) => `${CSI}T`.repeat(count)
+	};
+	const erase = {
+		screen: `${CSI}2J`,
+		up: (count = 1) => `${CSI}1J`.repeat(count),
+		down: (count = 1) => `${CSI}J`.repeat(count),
+		line: `${CSI}2K`,
+		lineEnd: `${CSI}K`,
+		lineStart: `${CSI}1K`,
+		lines(count) {
+			let clear = "";
+			for (let i = 0; i < count; i++) clear += this.line + (i < count - 1 ? cursor.up() : "");
+			if (count) clear += cursor.left;
+			return clear;
+		}
+	};
+	module.exports = {
+		cursor,
+		scroll,
+		erase,
+		beep
+	};
+}));
+
+//#endregion
+//#region node_modules/@clack/core/dist/index.mjs
+var import_src = require_src();
+function findCursor(s, o, l) {
+	if (!l.some((r) => !r.disabled)) return s;
+	const t = s + o, n = Math.max(l.length - 1, 0), e = t < 0 ? n : t > n ? 0 : t;
+	return l[e]?.disabled ? findCursor(e, o < 0 ? -1 : 1, l) : e;
+}
+const settings = {
+	actions: /* @__PURE__ */ new Set([
+		"up",
+		"down",
+		"left",
+		"right",
+		"space",
+		"enter",
+		"cancel"
+	]),
+	aliases: /* @__PURE__ */ new Map([
+		["k", "up"],
+		["j", "down"],
+		["h", "left"],
+		["l", "right"],
+		["", "cancel"],
+		["escape", "cancel"]
+	]),
+	messages: {
+		cancel: "Canceled",
+		error: "Something went wrong"
+	},
+	withGuide: true,
+	accessible: void 0,
+	date: {
+		monthNames: [...[
+			"January",
+			"February",
+			"March",
+			"April",
+			"May",
+			"June",
+			"July",
+			"August",
+			"September",
+			"October",
+			"November",
+			"December"
+		]],
+		messages: {
+			required: "Please enter a valid date",
+			invalidMonth: "There are only 12 months in a year",
+			invalidDay: (n, e) => `There are only ${n} days in ${e}`,
+			afterMin: (n) => `Date must be on or after ${n.toISOString().slice(0, 10)}`,
+			beforeMax: (n) => `Date must be on or before ${n.toISOString().slice(0, 10)}`
+		}
+	}
+};
+function isAccessible(n) {
+	if (n !== void 0) return n;
+	if (settings.accessible !== void 0) return settings.accessible;
+	const e = process.env.ACCESSIBLE;
+	return e !== void 0 && e !== "" && e !== "0" && e !== "false";
+}
+function isActionKey(n, e) {
+	if (typeof n == "string") return settings.aliases.get(n) === e;
+	for (const s of n) if (s !== void 0 && isActionKey(s, e)) return true;
+	return false;
+}
+function diffLines(i, s) {
+	if (i === s) return;
+	const e = i.split(`
+`), t = s.split(`
+`), r = Math.max(e.length, t.length), f = [];
+	for (let n = 0; n < r; n++) e[n] !== t[n] && f.push(n);
+	return {
+		lines: f,
+		numLinesBefore: e.length,
+		numLinesAfter: t.length,
+		numLines: r
+	};
+}
+const R = globalThis.process.platform.startsWith("win");
+const CANCEL_SYMBOL = Symbol("clack:cancel");
+function isCancel(e) {
+	return e === CANCEL_SYMBOL;
+}
+function setRawMode(e, r) {
+	const o = e;
+	o.isTTY && o.setRawMode(r);
+}
+const getColumns = (e) => "columns" in e && typeof e.columns == "number" ? e.columns : 80;
+const getRows = (e) => "rows" in e && typeof e.rows == "number" ? e.rows : 20;
+function wrapTextWithPrefix(e, r, o, n = o, s = o, t) {
+	const f = getColumns(e ?? stdout);
+	return wrapAnsi(r, f - o.length, {
+		hard: true,
+		trim: false
+	}).split(`
+`).map((c, i, m) => {
+		const d = t ? t(c, i) : c;
+		return i === 0 ? `${n}${d}` : i === m.length - 1 ? `${s}${d}` : `${o}${d}`;
+	}).join(`
+`);
+}
+function runValidation(e, a) {
+	if ("~standard" in e) {
+		const n = e["~standard"].validate(a);
+		return n instanceof Promise ? n.then((r) => r.issues?.at(0)?.message) : n.issues?.at(0)?.message;
+	}
+	return e(a);
+}
+var y = class {
+	input;
+	output;
+	_abortSignal;
+	rl;
+	opts;
+	_render;
+	_track = false;
+	_prevFrame = "";
+	_subscribers = /* @__PURE__ */ new Map();
+	_cursor = 0;
+	state = "initial";
+	error = "";
+	value;
+	userInput = "";
+	/**
+	* Whether accessible (static, screen-reader friendly) output is enabled for
+	* this prompt, resolved from the `accessible` option, the global setting,
+	* and the `ACCESSIBLE` env var.
+	*/
+	get accessible() {
+		return isAccessible(this.opts.accessible);
+	}
+	constructor(t, e = true) {
+		const { input: i = stdin, output: s = stdout, render: r, signal: n, ...o } = t;
+		this.opts = o, this.onKeypress = this.onKeypress.bind(this), this.close = this.close.bind(this), this.render = this.render.bind(this), this._render = r.bind(this), this._track = e, this._abortSignal = n, this.input = i, this.output = s;
+	}
+	/**
+	* Unsubscribe all listeners
+	*/
+	unsubscribe() {
+		this._subscribers.clear();
+	}
+	/**
+	* Set a subscriber with opts
+	* @param event - The event name
+	*/
+	setSubscriber(t, e) {
+		const i = this._subscribers.get(t) ?? [];
+		i.push(e), this._subscribers.set(t, i);
+	}
+	/**
+	* Subscribe to an event
+	* @param event - The event name
+	* @param cb - The callback
+	*/
+	on(t, e) {
+		this.setSubscriber(t, { cb: e });
+	}
+	/**
+	* Subscribe to an event once
+	* @param event - The event name
+	* @param cb - The callback
+	*/
+	once(t, e) {
+		this.setSubscriber(t, {
+			cb: e,
+			once: true
+		});
+	}
+	/**
+	* Emit an event with data
+	* @param event - The event name
+	* @param data - The data to pass to the callback
+	*/
+	emit(t, ...e) {
+		const i = this._subscribers.get(t) ?? [], s = [];
+		for (const r of i) r.cb(...e), r.once && s.push(() => i.splice(i.indexOf(r), 1));
+		for (const r of s) r();
+	}
+	prompt() {
+		return new Promise((t) => {
+			if (this._abortSignal) {
+				if (this._abortSignal.aborted) return this.state = "cancel", this.close(), t(CANCEL_SYMBOL);
+				this._abortSignal.addEventListener("abort", () => {
+					this.state = "cancel", this.close();
+				}, { once: true });
+			}
+			this.rl = l__default.createInterface({
+				input: this.input,
+				tabSize: 2,
+				prompt: "",
+				escapeCodeTimeout: 50,
+				terminal: true
+			}), this.rl.prompt(), this.opts.initialUserInput !== void 0 && this._setUserInput(this.opts.initialUserInput, true), this.input.on("keypress", this.onKeypress), setRawMode(this.input, true), this.output.on("resize", this.render), this.render(), this.once("submit", () => {
+				this.output.write(import_src.cursor.show), this.output.off("resize", this.render), setRawMode(this.input, false), t(this.value);
+			}), this.once("cancel", () => {
+				this.output.write(import_src.cursor.show), this.output.off("resize", this.render), setRawMode(this.input, false), t(CANCEL_SYMBOL);
+			});
+		});
+	}
+	_isActionKey(t, e) {
+		return t === "	";
+	}
+	_shouldSubmit(t, e) {
+		return true;
+	}
+	_setValue(t) {
+		this.value = t, this.emit("value", this.value);
+	}
+	_setUserInput(t, e) {
+		this.userInput = t ?? "", this.emit("userInput", this.userInput), e && this._track && this.rl && (this.rl.write(this.userInput), this._cursor = this.rl.cursor);
+	}
+	_clearUserInput() {
+		this.rl?.write(null, {
+			ctrl: true,
+			name: "u"
+		}), this._setUserInput("");
+	}
+	async onKeypress(t, e) {
+		if (this.state !== "validating") {
+			if (this._track && e.name !== "return" && (e.name && this._isActionKey(t, e) && this.rl?.write(null, {
+				ctrl: true,
+				name: "h"
+			}), this._cursor = this.rl?.cursor ?? 0, this._setUserInput(this.rl?.line)), this.state === "error" && (this.state = "active"), e?.name && (!this._track && settings.aliases.has(e.name) && this.emit("cursor", settings.aliases.get(e.name)), settings.actions.has(e.name) && this.emit("cursor", e.name)), t && (t.toLowerCase() === "y" || t.toLowerCase() === "n") && this.emit("confirm", t.toLowerCase() === "y"), this.emit("key", t, e), e?.name === "return" && this._shouldSubmit(t, e)) {
+				if (this.opts.validate) {
+					const i = runValidation(this.opts.validate, this.value);
+					let s;
+					i instanceof Promise ? (this.state = "validating", this.render(), s = await i) : s = i, s && (this.error = s instanceof Error ? s.message : s, this.state = "error", this.rl?.write(this.userInput));
+				}
+				this.state !== "error" && (this.state = "submit");
+			}
+			isActionKey([
+				t,
+				e?.name,
+				e?.sequence
+			], "cancel") && (this.state = "cancel"), (this.state === "submit" || this.state === "cancel") && this.emit("finalize"), this.render(), (this.state === "submit" || this.state === "cancel") && this.close();
+		}
+	}
+	close() {
+		this.input.unpipe(), this.input.removeListener("keypress", this.onKeypress), this.output.write(`
+`), setRawMode(this.input, false), this.rl?.close(), this.rl = void 0, this.emit(`${this.state}`, this.value), this.unsubscribe();
+	}
+	restoreCursor() {
+		const t = wrapAnsi(this._prevFrame, process.stdout.columns, {
+			hard: true,
+			trim: false
+		}).split(`
+`).length - 1;
+		this.output.write(import_src.cursor.move(-999, t * -1));
+	}
+	render() {
+		const t = wrapAnsi(this._render(this) ?? "", process.stdout.columns, {
+			hard: true,
+			trim: false
+		});
+		if (t !== this._prevFrame) {
+			if (this.state === "initial") this.output.write(import_src.cursor.hide);
+			else {
+				const e = diffLines(this._prevFrame, t), i = getRows(this.output);
+				if (this.restoreCursor(), e) {
+					const s = Math.max(0, e.numLinesAfter - i), r = Math.max(0, e.numLinesBefore - i);
+					let n = e.lines.find((o) => o >= s);
+					if (n === void 0) {
+						this._prevFrame = t;
+						return;
+					}
+					if (e.lines.length === 1) {
+						this.output.write(import_src.cursor.move(0, n - r)), this.output.write(import_src.erase.lines(1));
+						const o = t.split(`
+`);
+						this.output.write(o[n]), this._prevFrame = t, this.output.write(import_src.cursor.move(0, o.length - n - 1));
+						return;
+					} else if (e.lines.length > 1) {
+						if (s < r) n = s;
+						else {
+							const h = n - r;
+							h > 0 && this.output.write(import_src.cursor.move(0, h));
+						}
+						this.output.write(import_src.erase.down());
+						const f = t.split(`
+`).slice(n);
+						this.output.write(f.join(`
+`)), this._prevFrame = t;
+						return;
+					}
+				}
+				this.output.write(import_src.erase.down());
+			}
+			this.output.write(t), this.state === "initial" && (this.state = "active"), this._prevFrame = t;
+		}
+	}
+};
+var r = class extends y {
+	get cursor() {
+		return this.value ? 0 : 1;
+	}
+	get _value() {
+		return this.cursor === 0;
+	}
+	constructor(t) {
+		super(t, false), this.value = !!t.initialValue, this.on("userInput", () => {
+			this.value = this._value;
+		}), this.on("confirm", (i) => {
+			this.output.write(import_src.cursor.move(0, -1)), this.value = i, this.state = "submit", this.close();
+		}), this.on("cursor", () => {
+			this.value = !this.value;
+		});
+	}
+};
+var a = class extends y {
+	options;
+	cursor = 0;
+	get _value() {
+		return this.options[this.cursor]?.value;
+	}
+	get _enabledOptions() {
+		return this.options.filter((e) => e.disabled !== true);
+	}
+	toggleAll() {
+		const e = this._enabledOptions, i = this.value !== void 0 && this.value.length === e.length;
+		this.value = i ? [] : e.map((t) => t.value);
+	}
+	toggleInvert() {
+		const e = this.value;
+		if (!e) return;
+		const i = this._enabledOptions.filter((t) => !e.includes(t.value));
+		this.value = i.map((t) => t.value);
+	}
+	toggleValue() {
+		this.value === void 0 && (this.value = []);
+		const e = this.value.includes(this._value);
+		this.value = e ? this.value.filter((i) => i !== this._value) : [...this.value, this._value];
+	}
+	constructor(e) {
+		super(e, false), this.options = e.options, this.value = [...e.initialValues ?? []];
+		const i = Math.max(this.options.findIndex(({ value: t }) => t === e.cursorAt), 0);
+		this.cursor = this.options[i]?.disabled ? findCursor(i, 1, this.options) : i, this.on("key", (t, l) => {
+			l.name === "a" && this.toggleAll(), l.name === "i" && this.toggleInvert();
+		}), this.on("cursor", (t) => {
+			switch (t) {
+				case "left":
+				case "up":
+					this.cursor = findCursor(this.cursor, -1, this.options);
+					break;
+				case "down":
+				case "right":
+					this.cursor = findCursor(this.cursor, 1, this.options);
+					break;
+				case "space": this.toggleValue();
+			}
+		});
+	}
+};
+
+//#endregion
+//#region node_modules/@clack/prompts/dist/index.mjs
+function isUnicodeSupported() {
+	if (process$1.platform !== "win32") return process$1.env.TERM !== "linux";
+	return Boolean(process$1.env.CI) || Boolean(process$1.env.WT_SESSION) || Boolean(process$1.env.TERMINUS_SUBLIME) || process$1.env.ConEmuTask === "{cmd::Cmder}" || process$1.env.TERM_PROGRAM === "Terminus-Sublime" || process$1.env.TERM_PROGRAM === "vscode" || process$1.env.TERM === "xterm-256color" || process$1.env.TERM === "alacritty" || process$1.env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
+}
+const unicode = isUnicodeSupported();
+const isTTY = (o) => o.isTTY === true;
+const unicodeOr = (o, e) => unicode ? o : e;
+const S_STEP_ACTIVE = unicodeOr("◆", "*");
+const S_STEP_CANCEL = unicodeOr("■", "x");
+const S_STEP_ERROR = unicodeOr("▲", "x");
+const S_STEP_SUBMIT = unicodeOr("◇", "o");
+const S_BAR_START = unicodeOr("┌", "T");
+const S_BAR = unicodeOr("│", "|");
+const S_BAR_END = unicodeOr("└", "—");
+const S_BAR_START_RIGHT = unicodeOr("┐", "T");
+const S_BAR_END_RIGHT = unicodeOr("┘", "—");
+const S_RADIO_ACTIVE = unicodeOr("●", ">");
+const S_RADIO_INACTIVE = unicodeOr("○", " ");
+const S_CHECKBOX_ACTIVE = unicodeOr("◻", "[•]");
+const S_CHECKBOX_SELECTED = unicodeOr("◼", "[+]");
+const S_CHECKBOX_INACTIVE = unicodeOr("◻", "[ ]");
+const S_PASSWORD_MASK = unicodeOr("▪", "•");
+const S_BAR_H = unicodeOr("─", "-");
+const S_CORNER_TOP_RIGHT = unicodeOr("╮", "+");
+const S_CONNECT_LEFT = unicodeOr("├", "+");
+const S_CORNER_BOTTOM_RIGHT = unicodeOr("╯", "+");
+const S_CORNER_BOTTOM_LEFT = unicodeOr("╰", "+");
+const S_CORNER_TOP_LEFT = unicodeOr("╭", "+");
+const S_INFO = unicodeOr("●", "•");
+const S_SUCCESS = unicodeOr("◆", "*");
+const S_WARN = unicodeOr("▲", "!");
+const S_ERROR = unicodeOr("■", "x");
+const symbol = (o) => {
+	switch (o) {
+		case "initial":
+		case "active": return styleText("cyan", S_STEP_ACTIVE);
+		case "cancel": return styleText("red", S_STEP_CANCEL);
+		case "error": return styleText("yellow", S_STEP_ERROR);
+		case "submit": return styleText("green", S_STEP_SUBMIT);
+		case "validating": return styleText("dim", S_STEP_ACTIVE);
+	}
+};
+const symbolBar = (o) => {
+	switch (o) {
+		case "initial":
+		case "active": return styleText("cyan", S_BAR);
+		case "cancel": return styleText("red", S_BAR);
+		case "error": return styleText("yellow", S_BAR);
+		case "submit": return styleText("green", S_BAR);
+	}
+};
+function formatInstructionFooter(o, e) {
+	const r = [`${e ? `${styleText("cyan", S_BAR)}  ` : ""}${o.join(" • ")}`];
+	return e && r.push(styleText("cyan", S_BAR_END)), r;
+}
+const I = (l, e, w, p, b, C = false) => {
+	let r = e, O = 0;
+	if (C) for (let i = p - 1; i >= w; i--) {
+		const m = l[i];
+		if (m && (r -= m.length), O++, r <= b) break;
+	}
+	else for (let i = w; i < p; i++) {
+		const m = l[i];
+		if (m && (r -= m.length), O++, r <= b) break;
+	}
+	return {
+		lineCount: r,
+		removals: O
+	};
+};
+const limitOptions = ({ cursor: l, options: e, style: w, output: p = process.stdout, maxItems: b = Number.POSITIVE_INFINITY, columnPadding: C = 0, rowPadding: r = 4 }) => {
+	const i = getColumns(p) - C, m = getRows(p), M = styleText("dim", "..."), v = Math.max(m - r, 0), a = Math.max(Math.min(b, v), 5);
+	let f = 0;
+	l >= a - 3 && (f = Math.max(Math.min(l - a + 3, e.length - a), 0));
+	let d = a < e.length && f > 0, c = a < e.length && f + a < e.length;
+	const W = Math.min(f + a, e.length), s = [];
+	let g = 0;
+	d && g++, c && g++;
+	const T = f + (d ? 1 : 0), y = W - (c ? 1 : 0);
+	for (let t = T; t < y; t++) {
+		const n = e[t], o = n ? w(n, t === l) : "", h = wrapAnsi(o, i, {
+			hard: true,
+			trim: false
+		}).split(`
+`);
+		s.push(h), g += h.length;
+	}
+	if (g > v) {
+		let t = 0, n = 0, o = g;
+		const h = l - T;
+		let u = v;
+		const L = () => I(s, o, 0, h, u), E = () => I(s, o, h + 1, s.length, u, true);
+		d ? ({lineCount: o, removals: t} = L(), o > u && (c || (u -= 1), {lineCount: o, removals: n} = E())) : (c || (u -= 1), {lineCount: o, removals: n} = E(), o > u && (u -= 1, {lineCount: o, removals: t} = L())), t > 0 && (d = true, s.splice(0, t)), n > 0 && (c = true, s.splice(s.length - n, n));
+	}
+	const x = [];
+	d && x.push(M);
+	for (const t of s) for (const n of t) x.push(n);
+	return c && x.push(M), x;
+};
+const confirm = (e) => {
+	const a = e.active ?? "Yes", o = e.inactive ?? "No";
+	return new r({
+		active: a,
+		inactive: o,
+		signal: e.signal,
+		input: e.input,
+		output: e.output,
+		initialValue: e.initialValue ?? true,
+		render() {
+			const i = e.withGuide ?? settings.withGuide, u = `${symbol(this.state)}  `, l = i ? `${styleText("gray", S_BAR)}  ` : "", f = wrapTextWithPrefix(e.output, e.message, l, u), s = `${i ? `${styleText("gray", S_BAR)}
+` : ""}${f}
+`, c = this.value ? a : o;
+			switch (this.state) {
+				case "submit": return `${s}${i ? `${styleText("gray", S_BAR)}  ` : ""}${styleText("dim", c)}`;
+				case "cancel": return `${s}${i ? `${styleText("gray", S_BAR)}  ` : ""}${styleText(["strikethrough", "dim"], c)}${i ? `
+${styleText("gray", S_BAR)}` : ""}`;
+				default: {
+					const r = i ? `${styleText("cyan", S_BAR)}  ` : "", g = i ? styleText("cyan", S_BAR_END) : "";
+					return `${s}${r}${this.value ? `${styleText("green", S_RADIO_ACTIVE)} ${a}` : `${styleText("dim", S_RADIO_INACTIVE)} ${styleText("dim", a)}`}${e.vertical ? i ? `
+${styleText("cyan", S_BAR)}  ` : `
+` : ` ${styleText("dim", "/")} `}${this.value ? `${styleText("dim", S_RADIO_INACTIVE)} ${styleText("dim", o)}` : `${styleText("green", S_RADIO_ACTIVE)} ${o}`}
+${g}
+`;
+				}
+			}
+		}
+	}).prompt();
+};
+const MULTISELECT_INSTRUCTIONS = [
+	`${styleText("dim", "↑/↓")} to navigate`,
+	`${styleText("dim", "Space:")} select`,
+	`${styleText("dim", "Enter:")} confirm`
+];
+const m = (i, u) => i.split(`
+`).map((d) => u(d)).join(`
+`);
+const multiselect = (i) => {
+	const u = (t, a) => {
+		const r = t.label ?? String(t.value);
+		return a === "disabled" ? `${styleText("gray", S_CHECKBOX_INACTIVE)} ${m(r, (o) => styleText(["strikethrough", "gray"], o))}${t.hint ? ` ${styleText("dim", `(${t.hint ?? "disabled"})`)}` : ""}` : a === "active" ? `${styleText("cyan", S_CHECKBOX_ACTIVE)} ${r}${t.hint ? ` ${styleText("dim", `(${t.hint})`)}` : ""}` : a === "selected" ? `${styleText("green", S_CHECKBOX_SELECTED)} ${m(r, (o) => styleText("dim", o))}${t.hint ? ` ${styleText("dim", `(${t.hint})`)}` : ""}` : a === "cancelled" ? `${m(r, (o) => styleText(["strikethrough", "dim"], o))}` : a === "active-selected" ? `${styleText("green", S_CHECKBOX_SELECTED)} ${r}${t.hint ? ` ${styleText("dim", `(${t.hint})`)}` : ""}` : a === "submitted" ? `${m(r, (o) => styleText("dim", o))}` : `${styleText("dim", S_CHECKBOX_INACTIVE)} ${m(r, (o) => styleText("dim", o))}`;
+	}, d = i.required ?? true, x = i.showInstructions ?? true;
+	return new a({
+		options: i.options,
+		signal: i.signal,
+		input: i.input,
+		output: i.output,
+		initialValues: i.initialValues,
+		required: d,
+		cursorAt: i.cursorAt,
+		validate(t) {
+			if (d && (t === void 0 || t.length === 0)) return `Please select at least one option.
+${styleText("reset", styleText("dim", `Press ${styleText([
+				"gray",
+				"bgWhite",
+				"inverse"
+			], " space ")} to select, ${styleText("gray", styleText("bgWhite", styleText("inverse", " enter ")))} to submit`))}`;
+		},
+		render() {
+			const t = i.withGuide ?? settings.withGuide, a = wrapTextWithPrefix(i.output, i.message, t ? `${symbolBar(this.state)}  ` : "", `${symbol(this.state)}  `), r = `${t ? `${styleText("gray", S_BAR)}
+` : ""}${a}
+`, o = this.value ?? [], g = (n, l) => {
+				if (n.disabled) return u(n, "disabled");
+				const s = o.includes(n.value);
+				return l && s ? u(n, "active-selected") : s ? u(n, "selected") : u(n, l ? "active" : "inactive");
+			};
+			switch (this.state) {
+				case "submit": {
+					const n = this.options.filter(({ value: s }) => o.includes(s)).map((s) => u(s, "submitted")).join(styleText("dim", ", ")) || styleText("dim", "none");
+					return `${r}${wrapTextWithPrefix(i.output, n, t ? `${styleText("gray", S_BAR)}  ` : "")}`;
+				}
+				case "cancel": {
+					const n = this.options.filter(({ value: s }) => o.includes(s)).map((s) => u(s, "cancelled")).join(styleText("dim", ", "));
+					if (n.trim() === "") return `${r}${styleText("gray", S_BAR)}`;
+					return `${r}${wrapTextWithPrefix(i.output, n, t ? `${styleText("gray", S_BAR)}  ` : "")}${t ? `
+${styleText("gray", S_BAR)}` : ""}`;
+				}
+				case "error": {
+					const n = t ? `${styleText("yellow", S_BAR)}  ` : "", l = this.error.split(`
+`).map(($, v) => v === 0 ? `${t ? `${styleText("yellow", S_BAR_END)}  ` : ""}${styleText("yellow", $)}` : `   ${$}`).join(`
+`), s = r.split(`
+`).length, h = l.split(`
+`).length + 1;
+					return `${r}${n}${limitOptions({
+						output: i.output,
+						options: this.options,
+						cursor: this.cursor,
+						maxItems: i.maxItems,
+						columnPadding: n.length,
+						rowPadding: s + h,
+						style: g
+					}).join(`
+${n}`)}
+${l}
+`;
+				}
+				default: {
+					const n = t ? `${styleText("cyan", S_BAR)}  ` : "", l = r.split(`
+`).length, s = x ? formatInstructionFooter(MULTISELECT_INSTRUCTIONS, t) : t ? [styleText("cyan", S_BAR_END)] : [], h = s.join(`
+`), $ = s.length + 1;
+					return `${r}${n}${limitOptions({
+						output: i.output,
+						options: this.options,
+						cursor: this.cursor,
+						maxItems: i.maxItems,
+						columnPadding: n.length,
+						rowPadding: l + $,
+						style: g
+					}).join(`
+${n}`)}
+${h}
+`;
+				}
+			}
+		}
+	}).prompt();
+};
+const cancel = (o = "", t) => {
+	const i = t?.output ?? process.stdout, e = t?.withGuide ?? settings.withGuide ? `${styleText("gray", S_BAR_END)}  ` : "";
+	i.write(`${e}${styleText("red", o)}
+
+`);
+};
+const u = {
+	light: unicodeOr("─", "-"),
+	heavy: unicodeOr("━", "="),
+	block: unicodeOr("█", "#")
+};
+const SELECT_INSTRUCTIONS = [`${styleText("dim", "↑/↓")} to navigate`, `${styleText("dim", "Enter:")} confirm`];
+const i = `${styleText("gray", S_BAR)}  `;
+
+//#endregion
+//#region src/secrets.js
+const REDACTED = "<redacted>";
+const MIN_TOKEN = 12;
+const containsSecret = (text, secret) => typeof text === "string" && typeof secret === "string" && secret.length >= MIN_TOKEN && text.includes(secret);
+const SECRET_KEY = /^(?:.*_)?(?:key|token|secret|password|passwd|credential|auth|authorization)s?$/;
+function isSecretKey(key) {
+	const leaf = key.split(".").at(-1).replace(/([^A-Z_])([A-Z])/g, (_, before, after) => `${before}_${after}`).replaceAll("-", "_").toLowerCase();
+	return SECRET_KEY.test(leaf);
+}
+function isEnvReference(value) {
+	return typeof value === "string" && value.length <= 128 && /^(?:\{env:[A-Za-z0-9_]+\}|\$[A-Za-z0-9_]+|[A-Z][A-Z0-9_]{2,})$/.test(value);
+}
+const LITERAL = /^(?:true|false|null|-?\d+(?:\.\d+)?)$/;
+const hidesValue = (key, value) => isSecretKey(key) && !isEnvReference(value) && !LITERAL.test(value);
+function maskValue(key, value, secret) {
+	if (typeof value !== "string") return value;
+	if (containsSecret(value, secret)) return REDACTED;
+	return hidesValue(key, value) ? REDACTED : value;
+}
+const unquote = (text) => text.replace(/^["']|["']$/g, "");
+const SECRET_PAIR = /("(?:[^"\n]*)"|'[^'\n]+'|[A-Za-z0-9_.-]+)(\s*[:=]\s*)("(?:[^"\\\n]*)"|'(?:[^'\\\n]*)'|\[[^\]]*\]|[^\s,}\]{\[][^,}\]\n{\[]*)/g;
+const QUOTED = /"(?:[^"\\\n]*)"|'[^'\\\n]*'/g;
+function redactPair(key, value) {
+	if (!hidesValue(unquote(key), unquote(value))) return null;
+	return value.startsWith("[") ? value.replace(QUOTED, REDACTED) : REDACTED;
+}
+function redactText(text, secret) {
+	const redacted = text.replace(SECRET_PAIR, (whole, key, separator, value) => {
+		const masked = redactPair(key, value);
+		return masked === null ? whole : `${key}${separator}${masked}`;
+	});
+	return containsSecret(redacted, secret) ? redacted.replaceAll(secret, REDACTED) : redacted;
+}
+const maskChanges = (changes, secret) => changes.map((change) => ({
+	op: change.op,
+	key: change.key,
+	value: maskValue(change.key, change.value, secret),
+	...change.op === "replace" ? { oldValue: maskValue(change.key, change.oldValue, secret) } : {}
+}));
+
+//#endregion
+//#region src/diff.js
+function readValues(text, format) {
+	if (format === "toml") try {
+		return parse$1(text);
+	} catch {
+		throw new Error("Invalid TOML while reading values.");
+	}
+	return parseJson(text, "values");
+}
+function* leaves(value, prefix = []) {
+	if (value !== null && typeof value === "object" && !Array.isArray(value)) for (const [key, child] of Object.entries(value)) yield* leaves(child, [...prefix, key]);
+	else yield [prefix.join("."), value];
+}
+function diffValues({ before, after, format = "json" }) {
+	const previous = before === null ? {} : readValues(before, format);
+	const next = after === null ? {} : readValues(after, format);
+	const oldKeys = new Map(leaves(previous));
+	const newKeys = new Map(leaves(next));
+	const changes = [];
+	for (const [key, value] of newKeys) if (!oldKeys.has(key)) changes.push({
+		op: "add",
+		key,
+		value
+	});
+	else if (!isDeepStrictEqual(oldKeys.get(key), value)) changes.push({
+		op: "replace",
+		key,
+		value,
+		oldValue: oldKeys.get(key)
+	});
+	for (const [key, value] of oldKeys) if (!newKeys.has(key)) changes.push({
+		op: "remove",
+		key,
+		value
+	});
+	return changes;
+}
+function formatValue(value) {
+	if (value === null || value === void 0) return "null";
+	if (typeof value === "string") return value === "" ? "\"\"" : value;
+	if (typeof value === "object") {
+		const inner = Array.isArray(value) ? value.map(formatValue).join(", ") : Object.entries(value).map(([key, child]) => `${key}: ${formatValue(child)}`).join(", ");
+		return Array.isArray(value) ? `[ ${inner} ]` : `{ ${inner} }`;
+	}
+	return String(value);
+}
+function toLines(text) {
+	if (text === null || text === "") return [];
+	const lines = text.split("\n");
+	return lines.length > 1 && lines.at(-1) === "" ? lines.slice(0, -1) : lines;
+}
+function align(oldLines, newLines) {
+	if (oldLines.length * newLines.length > 25e4) return null;
+	const rows = Array.from({ length: oldLines.length + 1 }, () => new Uint32Array(newLines.length + 1));
+	for (let i = oldLines.length - 1; i >= 0; i -= 1) for (let j = newLines.length - 1; j >= 0; j -= 1) rows[i][j] = oldLines[i] === newLines[j] ? rows[i + 1][j + 1] + 1 : Math.max(rows[i + 1][j], rows[i][j + 1]);
+	const ops = [];
+	let i = 0;
+	let j = 0;
+	while (i < oldLines.length && j < newLines.length) if (oldLines[i] === newLines[j]) {
+		ops.push([" ", i]);
+		i += 1;
+		j += 1;
+	} else if (rows[i + 1][j] >= rows[i][j + 1]) {
+		ops.push(["-", i]);
+		i += 1;
+	} else {
+		ops.push(["+", j]);
+		j += 1;
+	}
+	while (i < oldLines.length) ops.push(["-", i++]);
+	while (j < newLines.length) ops.push(["+", j++]);
+	return ops;
+}
+function unifiedDiff(path, before, after, secret) {
+	const oldLines = toLines(before);
+	const newLines = toLines(after);
+	const ops = align(oldLines, newLines) ?? [...oldLines.map((_, index) => ["-", index]), ...newLines.map((_, index) => ["+", index])];
+	if (ops.every(([mark]) => mark === " ")) return [];
+	const CONTEXT = 3;
+	const changed = ops.map(([mark], index) => mark === " " ? -1 : index).filter((index) => index >= 0);
+	const hunks = [];
+	for (const index of changed) {
+		const last = hunks.at(-1);
+		if (last && index - last.end <= 6) last.end = index;
+		else hunks.push({
+			start: index,
+			end: index
+		});
+	}
+	const prefix = [{
+		old: 0,
+		new: 0
+	}];
+	for (const [index, [mark]] of ops.entries()) {
+		const prev = prefix[index];
+		prefix.push({
+			old: prev.old + (mark !== "+"),
+			new: prev.new + (mark !== "-")
+		});
+	}
+	const shown = (text) => toLines(text === null ? null : redactText(text, secret));
+	const [oldShown, newShown] = [shown(before), shown(after)];
+	const body = ops.map(([mark, index]) => `${mark}${(mark === "+" ? newShown : oldShown)[index]}`);
+	const lines = [`--- ${before === null ? "/dev/null" : path}`, `+++ ${after === null ? "/dev/null" : path}`];
+	for (const hunk of hunks) {
+		const from = Math.max(0, hunk.start - CONTEXT);
+		const to = Math.min(ops.length, hunk.end + 1 + CONTEXT);
+		const oldCount = prefix[to].old - prefix[from].old;
+		const newCount = prefix[to].new - prefix[from].new;
+		const oldStart = oldCount ? prefix[from].old + 1 : 0;
+		const newStart = newCount ? prefix[from].new + 1 : 0;
+		lines.push(`@@ -${oldStart},${oldCount} +${newStart},${newCount} @@`, ...body.slice(from, to));
+	}
+	return lines;
+}
+
+//#endregion
+//#region src/paths.js
+const home = homedir();
+const shortPath = (text) => home ? String(text).replaceAll(`${home}/`, "~/") : String(text);
+
+//#endregion
+//#region src/tty.js
+const interactive = () => isTTY(process.stdout) && isTTY(process.stdin);
+
+//#endregion
+//#region src/ui.js
+const green = (text) => styleText("green", text);
+const red = (text) => styleText("red", text);
+const yellow = (text) => styleText("yellow", text);
+const magenta = (text) => styleText("magenta", text);
+const gray = (text) => styleText("gray", text);
+const dim = (text) => styleText("dim", text);
+const bold = (text) => styleText("bold", text);
+const underline = (text) => styleText("underline", text);
+const link = (text) => styleText(["blue", "underline"], text);
+if (!interactive()) settings.withGuide = false;
+const columns = () => process.stdout.columns || Number(process.env.COLUMNS) || 88;
+const width = () => Math.min(columns(), 96);
+const GUTTER = "   ";
+const visible = (text) => text.replace(/\u001b\[[0-9;]*m/g, "");
+const unbreakable = (word) => /^[a-z][a-z0-9+.-]*:\/\//i.test(word);
+function pieces(text, limit) {
+	return text.split(" ").flatMap((word) => unbreakable(word) || visible(word).length <= limit ? [word] : word.match(new RegExp(`.{1,${limit}}`, "g")));
+}
+function wrap(text, limit) {
+	if (visible(text).length <= limit) return [text];
+	const lines = [];
+	let line = null;
+	for (const word of pieces(text, limit)) if (line !== null && visible(`${line} ${word}`).length > limit) {
+		lines.push(line);
+		line = word;
+	} else line = line === null ? word : `${line} ${word}`;
+	if (line !== null) lines.push(line);
+	return lines;
+}
+function displayValue(key, value, secret) {
+	const safe = maskValue(key, value, secret);
+	if (safe === "<redacted>") return {
+		text: safe,
+		color: yellow
+	};
+	if (isEnvReference(safe)) return {
+		text: String(safe),
+		color: magenta
+	};
+	return {
+		text: formatValue(safe),
+		color: (text) => text
+	};
+}
+const OP = {
+	add: {
+		mark: "+",
+		color: green
+	},
+	replace: {
+		mark: "~",
+		color: yellow
+	},
+	remove: {
+		mark: "-",
+		color: red
+	}
+};
+const STATUS = {
+	create: {
+		word: "Create",
+		color: green
+	},
+	update: {
+		word: "Update",
+		color: green
+	},
+	unchanged: {
+		word: "Unchanged",
+		color: gray
+	},
+	restore: {
+		word: "Restore",
+		color: yellow
+	},
+	remove: {
+		word: "Delete",
+		color: red
+	}
+};
+const columnWidth = (values, gap = 2) => Math.max(...values.map((value) => visible(String(value)).length), 0) + gap;
+const pad = (text, column) => {
+	const value = String(text);
+	return value + " ".repeat(Math.max(1, column - visible(value).length));
+};
+const MODEL_PATTERN = new RegExp(`(?<![\\w/.-])${MODEL.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?![\\w-])`, "g");
+const model = (text) => String(text).replace(MODEL_PATTERN, (match) => green(match));
+const STATUS_COLUMN = columnWidth(Object.values(STATUS).map((status) => status.word));
+function clip(text, limit) {
+	const visibleText = visible(text);
+	if (visibleText.length <= limit) return text;
+	const head = Math.max(Math.ceil((limit - 1) / 2), 1);
+	const tail = Math.max(limit - 1 - head, 1);
+	return `${visibleText.slice(0, head)}\u2026${visibleText.slice(-tail)}`;
+}
+function changeLines(changes, secret, limit) {
+	const keyWidth = Math.min(columnWidth(changes.map((change) => change.key)), 45, Math.max(17, limit - 3 - 3 - 20));
+	const rows = [];
+	for (const change of changes) {
+		const op = OP[change.op];
+		const key = change.key.length > keyWidth ? `${change.key.slice(0, keyWidth - 1)}…` : change.key;
+		const prefix = `${op.color(op.mark)} ${dim(model(pad(key, keyWidth)))}`;
+		if (change.op === "replace") {
+			const from = displayValue(change.key, change.oldValue, secret);
+			const to = displayValue(change.key, change.value, secret);
+			rows.push(prefix + dim(model(from.text)) + yellow(" → ") + to.color(model(to.text)));
+			continue;
+		}
+		const value = displayValue(change.key, change.value, secret);
+		const [first, ...rest] = wrap(value.text, Math.max(limit - 3 - 3 - keyWidth, 20));
+		rows.push(prefix + value.color(model(first ?? "")));
+		for (const line of rest) rows.push(dim(" ".repeat(2)) + " ".repeat(keyWidth) + value.color(model(line)));
+	}
+	return rows;
+}
+const DIFF_MARKS = [
+	"+",
+	"-",
+	"@"
+];
+function fileBlock(file, { secret }) {
+	const status = STATUS[file.status];
+	const limit = width() - 3;
+	const path = clip(shortPath(file.path), limit - STATUS_COLUMN);
+	const lines = [`${status.color(pad(status.word, STATUS_COLUMN))}${bold(path)}`];
+	if (file.diff?.length) {
+		for (const line of file.diff) {
+			const mark = DIFF_MARKS.includes(line[0]) ? line[0] : " ";
+			const color = mark === "+" ? green : mark === "-" ? red : mark === "@" ? magenta : dim;
+			const [first, ...rest] = wrap(line, limit);
+			lines.push(color(first));
+			for (const folded of rest) lines.push(color(mark === "@" ? ` ${folded}` : `${mark}${folded}`));
+		}
+		return lines;
+	}
+	const shown = file.changes.slice(0, 12);
+	lines.push(...changeLines(shown, secret, width()));
+	if (file.changes.length > shown.length) lines.push(dim(`… ${file.changes.length - shown.length} more`));
+	return lines;
+}
+const SECTION_GAP = 2;
+const write = (text) => process.stdout.write(`${text}\n`);
+function plain(text = "") {
+	write(text === "" ? "" : `${GUTTER}${text}`);
+}
+function prose(text) {
+	for (const line of wrap(text, width() - 3)) plain(line);
+}
+function heading(text, gap = SECTION_GAP) {
+	for (let index = 0; index < gap; index += 1) write("");
+	for (const line of wrap(text, width() - 3)) plain(bold(model(line)));
+}
+function renderPlan(title, files, options = {}) {
+	heading(files.some((file) => file.status !== "unchanged") ? `${title}:` : `${title}: nothing to change`);
+	plain("");
+	for (const [index, file] of files.entries()) {
+		for (const line of fileBlock(file, options)) plain(line);
+		if (index < files.length - 1) plain("");
+	}
+}
+function section(title, lines) {
+	heading(title);
+	plain("");
+	for (const line of lines) for (const wrapped of wrap(line, width() - 3)) plain(model(wrapped));
+}
+function box(lines) {
+	const left = " ".repeat(1);
+	const inner = Math.max(...lines.map((line) => visible(line).length));
+	const edge = "─".repeat(inner + 2);
+	write(`${left}\u250c${edge}\u2510`);
+	for (const line of lines) write(`${left}\u2502 ${line}${" ".repeat(inner - visible(line).length)} \u2502`);
+	write(`${left}\u2514${edge}\u2518`);
+}
+function intro(title, subtitle) {
+	const inner = Math.max(24, width() - 3 - 4);
+	const lines = wrap(title, inner).map((line) => bold(model(line)));
+	if (subtitle) lines.push("", ...wrap(subtitle, inner).map((line) => dim(line)));
+	box(lines);
+}
+const outro = (message) => heading(message, 1);
+const MARK_WIDTH = 2;
+function bullet(marker, message) {
+	wrap(message, width() - 3 - MARK_WIDTH).forEach((line, index) => {
+		plain(`${index === 0 ? `${marker}${" ".repeat(Math.max(MARK_WIDTH - visible(marker).length, 1))}` : " ".repeat(MARK_WIDTH)}${line}`);
+	});
+}
+const success = (message) => bullet(green("✔"), message);
+const warn = (message) => bullet(yellow("!"), message);
+const error = (message) => bullet(red("✖"), message);
+async function selectAssistants(options, initial) {
+	const chosen = await multiselect({
+		message: model(`Set up ${MODEL} for which assistants?  ${dim("(space toggles, enter confirms)")}`),
+		options,
+		initialValues: initial,
+		required: false,
+		maxItems: 8
+	});
+	if (isCancel(chosen)) {
+		cancel("Cancelled. Nothing was written.");
+		return false;
+	}
+	return chosen;
+}
+async function confirmApply(question, hint) {
+	if (hint) {
+		plain("");
+		plain(dim(hint));
+	}
+	const answer = await confirm({
+		message: question,
+		initialValue: false
+	});
+	if (isCancel(answer)) {
+		cancel("Cancelled. Nothing was written.");
+		return false;
+	}
+	if (!answer) warn("Cancelled. Nothing was written.");
+	return answer;
+}
+async function ask(question) {
+	plain("");
+	return await confirm({
+		message: question,
+		initialValue: true
+	}) === true;
+}
+
+//#endregion
+//#region src/plan.js
+function resolveMode({ apply, nonInteractive }) {
+	if (apply) return "apply";
+	return nonInteractive || !interactive() ? "preview" : "prompt";
+}
+const MODE_NOTE = {
+	preview: "Preview only. Pass --apply to write.",
+	apply: "Writing now (--apply).",
+	prompt: "Nothing is written until you confirm."
+};
+function describeFile(change, { secret, showDiff = true } = {}) {
+	const status = change.before === change.after ? "unchanged" : change.before === null ? "create" : "update";
+	const changes = status === "unchanged" ? [] : diffValues({
+		before: change.before,
+		after: change.after,
+		format: change.format
+	});
+	return {
+		path: change.path,
+		status,
+		changes,
+		diff: status === "unchanged" || !showDiff ? [] : unifiedDiff(shortPath(change.path), change.before, change.after, secret),
+		change
+	};
+}
+async function runWrites({ title, files, options, mode, prompt, hint, pending, write }) {
+	renderPlan(title, files, options);
+	if (mode === "preview") {
+		outro("Dry run complete. No files were changed.");
+		return { applied: 0 };
+	}
+	if (!pending.length) {
+		outro("Already configured. Nothing to write.");
+		return { applied: 0 };
+	}
+	if (mode === "prompt" && !await confirmApply(prompt, hint)) return {
+		applied: 0,
+		declined: true
+	};
+	plain("");
+	let applied = 0;
+	for (const item of pending) {
+		success(await write(item));
+		applied += 1;
+	}
+	return { applied };
+}
+
+//#endregion
+//#region src/journal.js
+function journalPath(env = process.env, home = homedir(), platform = process.platform) {
+	if (env.APEX_STATE_DIR) return join(env.APEX_STATE_DIR, "journal.json");
+	const state = env.XDG_STATE_HOME || (platform === "win32" ? join(env.APPDATA || join(home, "AppData", "Roaming"), "apex-state") : join(home, ".local", "state"));
+	return join(state, "apex", "journal.json");
+}
+async function readJournal(path) {
+	const text = await readConfig(path);
+	if (text === null) return [];
+	let entries;
+	try {
+		entries = JSON.parse(text);
+	} catch {
+		throw new Error(`Apex CLI journal is not valid JSON: ${path}\n  Inspect or remove it manually; Apex CLI changed nothing.`);
+	}
+	const shaped = (entry) => typeof entry?.batch === "string" && typeof entry?.at === "string" && typeof entry?.path === "string" && typeof entry?.afterSha === "string" && (entry.backup === null || typeof entry.backup === "string");
+	if (!Array.isArray(entries) || entries.some((entry) => !shaped(entry))) throw new Error(`Unrecognised Apex CLI journal: ${path}\n  Inspect or remove it manually; Apex CLI changed nothing.`);
+	return entries;
+}
+async function writeJournal(path, entries) {
+	const keep = new Set(batchIds(entries).slice(-20));
+	await writeAtomic(path, `${JSON.stringify(entries.filter((entry) => keep.has(entry.batch)), null, 2)}\n`);
+}
+const batchIds = (entries) => [...new Set(entries.map((entry) => entry.batch))];
+function newEntry(change, batch, backup) {
+	return {
+		batch,
+		at: (/* @__PURE__ */ new Date()).toISOString(),
+		path: change.path,
+		format: change.format ?? "json",
+		created: change.before === null,
+		beforeSha: change.before === null ? null : sha256(change.before),
+		afterSha: sha256(change.after),
+		backup,
+		undoneAt: null
+	};
+}
+async function markUndone(journalFile, entry) {
+	const entries = await readJournal(journalFile);
+	const found = entries.find((candidate) => candidate.batch === entry.batch && candidate.path === entry.path && !candidate.undoneAt);
+	if (!found) throw new Error(`Journal has no pending entry for ${entry.path}. That file was already reverted, so mark it undone by hand if you restored it yourself.`);
+	found.undoneAt = (/* @__PURE__ */ new Date()).toISOString();
+	await writeJournal(journalFile, entries);
+}
+async function appendEntry(journalFile, entry) {
+	const entries = await readJournal(journalFile);
+	entries.push(entry);
+	await writeJournal(journalFile, entries);
+}
+function pendingBatches(entries) {
+	return batchIds(entries).reverse().map((batch) => ({
+		batch,
+		at: entries.findLast((entry) => entry.batch === batch).at,
+		items: entries.filter((entry) => entry.batch === batch && !entry.undoneAt)
+	})).filter((batch) => batch.items.length);
+}
+async function planEntry(entry) {
+	const current = await readConfig(entry.path);
+	if (current === null) return {
+		entry,
+		action: "skip",
+		reason: "file no longer exists"
+	};
+	if (sha256(current) !== entry.afterSha) return {
+		entry,
+		action: "skip",
+		reason: `changed by something else since Apex CLI wrote it${entry.backup ? `. Restore ${entry.backup} manually` : ""}`
+	};
+	const format = entry.format ?? "json";
+	if (entry.created) return {
+		entry,
+		action: "remove",
+		change: {
+			path: entry.path,
+			before: current,
+			after: null,
+			format
+		}
+	};
+	if (entry.backup === null) return {
+		entry,
+		action: "skip",
+		reason: "original backup was never recorded for this file"
+	};
+	const stored = await readConfig(entry.backup);
+	if (stored === null || sha256(stored) !== entry.beforeSha) return {
+		entry,
+		action: "skip",
+		reason: `original backup is missing (${entry.backup})`
+	};
+	return {
+		entry,
+		action: "restore",
+		change: {
+			path: entry.path,
+			before: current,
+			after: stored,
+			format
+		}
+	};
+}
+async function planUndo(entries) {
+	let newest = null;
+	for (const batch of pendingBatches(entries)) {
+		const plan = {
+			...batch,
+			planned: await Promise.all(batch.items.map(planEntry))
+		};
+		if (plan.planned.some((item) => item.action !== "skip")) return plan;
+		newest ??= plan;
+	}
+	return newest;
+}
+
+//#endregion
+//#region src/cli.js
+const FLAGS = {
+	assistants: {
+		type: "string",
+		usage: "--assistants <ids>",
+		hint: "assistant ids",
+		text: `comma list of: ${IDS.join(", ")} (skips the picker)`
+	},
+	"no-interactive": {
+		type: "boolean",
+		usage: "--no-interactive",
+		hint: "never prompt",
+		text: "skip the questions and just print the plan"
+	},
+	apply: {
+		type: "boolean",
+		usage: "--apply",
+		hint: "write without prompting",
+		text: "write changes without prompting (scripts and CI)"
+	},
+	"no-diff": {
+		type: "boolean",
+		usage: "--no-diff",
+		hint: "list settings instead of the file diff",
+		text: "hide the raw file diff (it is shown by default, secrets redacted)"
+	},
+	json: {
+		type: "boolean",
+		usage: "--json",
+		hint: "machine-readable output",
+		text: "print machine-readable output instead of the human UI"
+	},
+	list: {
+		type: "boolean",
+		usage: "--list",
+		hint: "list recorded setups",
+		text: "show recorded setups instead of reverting one"
+	},
+	help: {
+		type: "boolean",
+		short: "h",
+		usage: "--help, -h",
+		hint: "show help",
+		text: "show all commands"
+	}
+};
+const COMMANDS = {
+	init: {
+		args: "[--assistants <ids>] [options]",
+		summary: "configure assistants",
+		flags: [
+			"assistants",
+			"no-interactive",
+			"apply",
+			"no-diff",
+			"json",
+			"help"
+		]
+	},
+	detect: {
+		args: "[--json]",
+		summary: "show what Apex CLI can see on this machine",
+		flags: ["json", "help"]
+	},
+	undo: {
+		args: "[--list] [options]",
+		summary: "reverse the most recent Apex CLI setup",
+		flags: [
+			"no-interactive",
+			"apply",
+			"no-diff",
+			"json",
+			"list",
+			"help"
+		]
+	},
+	run: {
+		args: `<${RUNNABLE.join("|")}> [-- <args>]`,
+		summary: "launch an assistant with the gateway set",
+		flags: []
+	},
+	completion: {
+		args: "<zsh|bash|fish>",
+		summary: "print a shell completion script",
+		flags: []
+	},
+	help: {
+		args: "",
+		summary: "show all commands",
+		flags: []
+	}
+};
+const SHELLS = [
+	"zsh",
+	"bash",
+	"fish"
+];
+const APEX = process.env.npm_command === "exec" ? "npx @callstack/apex" : "apex";
+const packageVersion = async () => JSON.parse(await readFile(new URL("../package.json", import.meta.url))).version;
+async function installApex() {
+	if (!await ask("Install the apex command globally, so apex undo and apex run work later?")) return false;
+	const npm = spawn("npm", [
+		"install",
+		"--global",
+		`@callstack/apex@${await packageVersion()}`
+	], {
+		stdio: [
+			"ignore",
+			"ignore",
+			"inherit"
+		],
+		shell: process.platform === "win32"
+	});
+	const code = await new Promise((resolve) => {
+		npm.once("error", () => resolve(1));
+		npm.once("exit", resolve);
+	});
+	if (code === 0) success("Installed. From now on, just type apex.");
+	else warn("npm could not install it. Run npm install -g @callstack/apex yourself.");
+	return code === 0;
+}
+const OPTIONS = Object.fromEntries(Object.entries(FLAGS).map(([name, flag]) => [name, {
+	type: flag.type,
+	...flag.short ? { short: flag.short } : {}
+}]));
+const flagsOf = (command) => COMMANDS[command].flags;
+const commandsFor = (flag) => Object.keys(COMMANDS).filter((name) => COMMANDS[name].flags.includes(flag));
+const usageRows = Object.entries(COMMANDS).map(([name, command]) => [`apex ${name}${command.args ? ` ${command.args}` : ""}`, command.summary]);
+const optionRows = [[
+	"(no flags)",
+	"(init, undo)",
+	"interactive: pick assistants, review every change and diff, then confirm"
+], ...Object.entries(FLAGS).map(([name, flag]) => [
+	flag.usage,
+	`(${commandsFor(name).join(", ")})`,
+	flag.text
+])];
+const exampleRows = [
+	["apex init", "pick assistants, review, confirm"],
+	["apex init --assistants codex,pi", "preview two tools (agent and CI friendly)"],
+	["apex init --assistants codex,pi --apply", "write those two without asking"],
+	["apex undo", "preview the reversal"],
+	["apex undo --apply", "reverse the last setup without asking"],
+	["apex detect --json", "machine-readable inventory"]
+];
+const environmentRows = [
+	["CALLSTACK_AUTH_TOKEN", "your callstack.ai key, needed by apex run and by every assistant you configure"],
+	["Config directories", "XDG_CONFIG_HOME, CODEX_HOME, CLAUDE_CONFIG_DIR, PI_CODING_AGENT_DIR"],
+	["Undo journal", "APEX_STATE_DIR, XDG_STATE_HOME (default ~/.local/state/apex)"]
+];
+const installRows = [
+	["zsh", "apex completion zsh  > \"${fpath[1]}/_apex\""],
+	["bash", "apex completion bash >> ~/.bashrc"],
+	["fish", "apex completion fish > ~/.config/fish/completions/apex.fish"]
+];
+const INDENT = "  ";
+const MIN_TEXT = 24;
+const helpHeading = (text) => bold(underline(text));
+const PLAIN = (text) => text;
+const rowColors = (lead, scope = PLAIN, text = PLAIN) => ({
+	lead,
+	scope,
+	text
+});
+const optionColors = rowColors((text) => text.startsWith("--") ? green(text) : dim(text), dim, PLAIN);
+const commandLine = (line, index = 0) => index ? dim(line) : line.replace(/^(apex)( \S+)?(.*)$/, (_, apex, command = "", rest) => green(apex) + command + (rest && dim(rest)));
+function columnRows(rows, color, width) {
+	const leadWidth = Math.min(columnWidth(rows.map(([lead]) => lead)), Math.floor(width / 2) - 2);
+	const scopeWidth = rows.some(([, scope]) => scope) ? columnWidth(rows.map(([, scope]) => scope)) : 0;
+	const textCol = 2 + leadWidth + scopeWidth;
+	const stacked = width - textCol < MIN_TEXT;
+	const lines = [];
+	for (const [lead, scope, text] of rows) {
+		const head = `${INDENT}${pad(color.lead(lead), leadWidth)}${scope ? pad(color.scope(scope), scopeWidth) : ""}`;
+		if (stacked || lead.length + 1 > leadWidth) {
+			const leadLines = wrap(lead, width - 2);
+			leadLines.forEach((part, index) => lines.push(`${INDENT}${color.lead(part, index)}${index === leadLines.length - 1 && scope ? ` ${color.scope(scope)}` : ""}`));
+			const below = `${INDENT}    `;
+			for (const line of wrap(text, width - below.length).map(color.text)) lines.push(below + line);
+			continue;
+		}
+		const [first, ...rest] = wrap(text, width - textCol).map(color.text);
+		lines.push((head + first).replace(/\s+$/, ""));
+		for (const line of rest) lines.push(" ".repeat(textCol) + line);
+	}
+	return lines;
+}
+function helpText() {
+	const width$1 = width();
+	const section = (title, rows, color) => [
+		helpHeading(title),
+		...columnRows(rows, color, width$1),
+		""
+	];
+	return [
+		...wrap(`Apex CLI: point your coding assistants at ${MODEL}`, width$1).map((line) => bold(model(line))),
+		"",
+		...section("Usage", usageRows.map(([lead, text]) => [
+			lead,
+			"",
+			text
+		]), rowColors(commandLine)),
+		...section("Options", optionRows, optionColors),
+		...section("Examples", exampleRows.map(([lead, text]) => [
+			lead,
+			"",
+			text
+		]), rowColors(commandLine, PLAIN, dim)),
+		...section("Environment", environmentRows.map(([lead, text]) => [
+			lead,
+			"",
+			text
+		]), rowColors(yellow, PLAIN, PLAIN)),
+		...section("Install completions", installRows.map(([lead, text]) => [
+			lead,
+			"",
+			text
+		]), rowColors(PLAIN, PLAIN, commandLine)),
+		...wrap("Restart the shell afterwards, or rehash zsh and re-source your bashrc.", width$1 - 2).map((line) => `${INDENT}${dim(line)}`),
+		"",
+		...wrap("Node.js 22+ required. Codex profiles target 0.134.0+", width$1).map((line) => dim(line))
+	].join("\n");
+}
+const printHelp = () => console.log(helpText());
+function readFlags(rest, command) {
+	const { values } = parseArgs({
+		args: rest,
+		options: OPTIONS,
+		allowPositionals: false
+	});
+	const unsupported = Object.keys(values).filter((name) => !flagsOf(command).includes(name));
+	if (unsupported.length) throw new Error(`--${unsupported[0]} is not valid for apex ${command}. See ${APEX} --help.`);
+	const selected = values.assistants === void 0 ? null : [...new Set(values.assistants.split(",").map((id) => id.trim()))];
+	if (selected?.includes("")) throw new Error("--assistants needs at least one id.");
+	if (selected?.some((id) => !IDS.includes(id))) throw new Error(`Unknown assistant in --assistants. Choose from: ${IDS.join(", ")}`);
+	const json = Boolean(values.json);
+	return {
+		selected,
+		showDiff: !values["no-diff"],
+		json,
+		help: Boolean(values.help),
+		list: Boolean(values.list),
+		mode: resolveMode({
+			apply: Boolean(values.apply),
+			nonInteractive: Boolean(values["no-interactive"] || json)
+		})
+	};
+}
+async function planAll(assistants, options) {
+	return Promise.all(assistants.map(async (assistant) => {
+		const base = {
+			id: assistant.id,
+			name: NAMES[assistant.id],
+			detected: assistant.detected,
+			evidence: assistant.evidence || null,
+			manual: MANUAL_IDS.includes(assistant.id),
+			error: null,
+			files: [],
+			steps: []
+		};
+		try {
+			base.files = (await planAssistant(assistant)).map((change) => describeFile(change, options));
+			base.steps = base.files.flatMap((file) => file.change.steps ?? []);
+		} catch (error) {
+			base.error = error.message;
+		}
+		return base;
+	}));
+}
+const token = () => process.env.CALLSTACK_AUTH_TOKEN?.trim() || void 0;
+const stamp = (iso) => iso.replace("T", " ").replace(/\.\d{3}Z$/, " UTC");
+const pendingOf = (entry) => entry.files.filter((file) => file.status !== "unchanged");
+async function applyAll(items, apply) {
+	const applied = [];
+	try {
+		for (const item of items) applied.push(await apply(item));
+	} catch (error) {
+		return {
+			applied,
+			failure: error
+		};
+	}
+	return {
+		applied,
+		failure: null
+	};
+}
+const jsonFile = (file, secret) => ({
+	path: file.path,
+	status: file.status,
+	changes: maskChanges(file.changes, secret)
+});
+const jsonAssistant = (entry, secret) => ({
+	id: entry.id,
+	name: entry.name,
+	detected: entry.detected,
+	evidence: entry.evidence,
+	manual: entry.manual,
+	...entry.error ? { error: entry.error } : {},
+	...entry.steps.length ? { steps: entry.steps } : {},
+	files: entry.files.map((file) => jsonFile(file, secret))
+});
+function pickerOptions(entries) {
+	return entries.map((entry) => {
+		const pending = pendingOf(entry).length;
+		return {
+			value: entry.id,
+			label: entry.detected ? entry.name : `${entry.name} (not detected)`,
+			hint: entry.manual ? "manual steps only" : entry.error ? "needs attention" : pending ? "not set up yet" : "already configured"
+		};
+	});
+}
+async function commandInit(rest) {
+	const flags = readFlags(rest, "init");
+	if (flags.help) {
+		printHelp();
+		return;
+	}
+	const secret = token();
+	const options = {
+		secret,
+		showDiff: flags.showDiff && !flags.json
+	};
+	const journalFile = journalPath();
+	if (flags.mode !== "preview") await readJournal(journalFile);
+	const batch = randomUUID();
+	const entries = await planAll(await detect(), options);
+	let ids = flags.selected ?? entries.filter((entry) => entry.detected).map((entry) => entry.id);
+	if (!flags.json) {
+		intro("Apex CLI · Configure callstack/Apex for your favorite harness", MODE_NOTE[flags.mode]);
+		if (flags.mode === "prompt" && !flags.selected) {
+			const defaults = entries.filter((entry) => entry.detected && !entry.manual && !entry.error && pendingOf(entry).length).map((entry) => entry.id);
+			const picked = await selectAssistants(pickerOptions(entries), defaults);
+			if (picked === false) return;
+			ids = picked;
+		}
+	}
+	const chosen = ids.map((id) => entries.find((entry) => entry.id === id));
+	const blocked = chosen.filter((entry) => entry.error);
+	const manual = chosen.filter((entry) => entry.manual && !entry.error);
+	const active = chosen.filter((entry) => !entry.manual && !entry.error);
+	const files = active.flatMap((entry) => entry.files);
+	const pending = files.filter((file) => file.status !== "unchanged").map((file) => file.change);
+	const applyOne = async (change) => {
+		const backup = await writeChange(change);
+		await appendEntry(journalFile, newEntry(change, batch, backup));
+		return backup;
+	};
+	if (flags.json) {
+		const { applied, failure } = await applyAll(flags.mode === "apply" && !blocked.length ? pending : [], async (change) => {
+			await applyOne(change);
+			return change.path;
+		});
+		console.log(JSON.stringify({
+			command: "init",
+			mode: flags.mode,
+			model: MODEL,
+			endpoint: BASE_URL,
+			applied: applied.length,
+			appliedPaths: applied,
+			...failure ? { error: failure.message } : {},
+			blocked: blocked.map((entry) => ({
+				id: entry.id,
+				error: entry.error
+			})),
+			manualSetup: manual.map((entry) => entry.id),
+			assistants: chosen.map((entry) => jsonAssistant(entry, secret)),
+			journal: journalFile,
+			undo: `${APEX} undo`,
+			envVar: "CALLSTACK_AUTH_TOKEN",
+			nextSteps: active.filter((entry) => RUNNABLE.includes(entry.id)).map((entry) => `${APEX} run ${entry.id}`)
+		}, null, 2));
+		if (blocked.length || failure) process.exitCode = 1;
+		return;
+	}
+	if (!ids.length) {
+		outro(`No assistant selected, so nothing was written. Pick one with --assistants or run ${APEX} init interactively.`);
+		return;
+	}
+	if (flags.mode !== "prompt") prose(`${gray("setup for:")} ${chosen.map((entry) => entry.name + (entry.detected ? "" : " (not detected)")).join(", ")}`);
+	if (blocked.length) {
+		plain("");
+		for (const entry of blocked) error(`${entry.name}: ${shortPath(entry.error)}`);
+		outro(`Blocked by the configuration problems above. Nothing was written. Fix those files and run ${APEX} init again.`);
+		process.exitCode = 1;
+		return;
+	}
+	let applied = 0;
+	if (active.length) {
+		const result = await runWrites({
+			title: "Planned changes",
+			files,
+			options,
+			mode: flags.mode,
+			prompt: "Apply these changes?",
+			hint: "Existing files get a .apex-backup-<id> copy first.",
+			pending,
+			write: async (change) => {
+				const backup = await applyOne(change);
+				return `${bold(shortPath(change.path))} ${dim(backup ? `backup: ${basename(backup)}` : "created")}`;
+			}
+		});
+		if (result.declined) return;
+		applied = result.applied;
+	}
+	const apex = APEX !== "apex" && flags.mode === "prompt" && await installApex() ? "apex" : APEX;
+	for (const entry of active.filter((entry) => entry.steps.length)) section(`Finish setting up ${entry.name}`, entry.steps);
+	for (const entry of manual) section(`Manual setup for ${entry.name}: Apex CLI writes nothing`, MANUAL[entry.id]);
+	section("Environment", [
+		...secret ? [] : ["export CALLSTACK_AUTH_TOKEN=<your callstack.ai key>"],
+		secret ? `${green("✓")} CALLSTACK_AUTH_TOKEN is set in this shell` : `${yellow("!")}  CALLSTACK_AUTH_TOKEN is not set here yet`,
+		dim("Apex CLI never reads, stores or logs the key itself.")
+	]);
+	const runnable = active.map((entry) => entry.id).filter((id) => RUNNABLE.includes(id));
+	const rows = runnable.map((id) => ({
+		command: `${apex} run ${id}`,
+		expansion: runExpansion(id)
+	}));
+	const commandWidth = columnWidth(rows.map((row) => row.command));
+	section(runnable.length ? `Use these commands to run ${MODEL} with your selected harnesses:` : `Use ${MODEL} with your assistant:`, [
+		...rows.flatMap((row) => wrap(row.expansion, width() - 3 - commandWidth).map((part, index) => `${pad(index ? "" : row.command, commandWidth)}${dim(part)}`)),
+		"",
+		`...or pick "${MODEL}" from the UI when setting up manually.`,
+		`For more instructions, visit: ${link(GUIDE_URL)}`,
+		...applied ? ["", `If you want to undo the changes, run ${bold(`${apex} undo`)}`] : [],
+		...apex === "apex" ? [] : ["", dim("For the short apex command: npm install -g @callstack/apex")]
+	]);
+}
+async function commandDetect(rest) {
+	const flags = readFlags(rest, "detect");
+	if (flags.help) {
+		printHelp();
+		return;
+	}
+	const secret = token();
+	const entries = await planAll(await detect(), {
+		secret,
+		showDiff: false
+	});
+	if (flags.json) {
+		console.log(JSON.stringify(entries.map((entry) => jsonAssistant(entry, secret)), null, 2));
+		return;
+	}
+	intro("Apex CLI · What this machine has", "Read only: nothing is created, edited or removed.");
+	const rows = entries.map((entry) => {
+		const pending = pendingOf(entry).length;
+		return {
+			entry,
+			text: entry.manual ? "manual setup" : entry.error ? "unreadable config" : pending ? "needs setup" : "already configured",
+			shade: entry.manual ? dim : entry.error || pending ? yellow : gray
+		};
+	});
+	const nameWidth = columnWidth(rows.map((row) => row.entry.name));
+	const stateWidth = columnWidth(rows.map((row) => row.text));
+	const lead = 8 + nameWidth + stateWidth;
+	const room = width() - 3 - lead;
+	for (const { entry, text, shade } of rows) {
+		const found = entry.evidence ? shortPath(entry.evidence) : "no config found";
+		const evidence = room >= 8 ? clip(found, room) : "";
+		plain(`${pad(entry.detected ? green("found") : dim("absent"), 8)}${pad(entry.name, nameWidth)}${shade(evidence ? pad(text, stateWidth) : text)}${dim(evidence)}`);
+	}
+	outro(`Next: ${APEX} init`);
+}
+async function commandUndo(rest) {
+	const flags = readFlags(rest, "undo");
+	if (flags.help) {
+		printHelp();
+		return;
+	}
+	const secret = token();
+	const options = {
+		secret,
+		showDiff: flags.showDiff && !flags.json
+	};
+	const journalFile = journalPath();
+	const entries = await readJournal(journalFile);
+	if (flags.list) {
+		if (flags.json) {
+			console.log(JSON.stringify({
+				command: "undo",
+				journal: journalFile,
+				entries
+			}, null, 2));
+			return;
+		}
+		const batches = batchIds(entries);
+		intro("Apex CLI · Setup history", "Only the journal is read here; configs stay untouched.");
+		for (const batch of batches) {
+			const items = entries.filter((entry) => entry.batch === batch);
+			prose(`${gray(stamp(items[0].at))}  ${bold(items.length === 1 ? "1 file" : `${items.length} files`)}  ${items.every((item) => item.undoneAt) ? gray("undone") : yellow("pending")}`);
+			for (const item of items) prose(`${dim(clip(shortPath(item.path), width() - 3))}${item.undoneAt ? gray("  (already undone)") : ""}`);
+		}
+		if (!batches.length) plain(dim("nothing recorded yet"));
+		outro(`Journal: ${shortPath(journalFile)}`);
+		return;
+	}
+	const plan = await planUndo(entries);
+	const skipped = plan?.planned.filter((item) => item.action === "skip") ?? [];
+	const restorable = [];
+	const files = [];
+	for (const item of plan?.planned.filter((entry) => entry.action !== "skip") ?? []) try {
+		files.push({
+			...describeFile(item.change, options),
+			status: item.action === "remove" ? "remove" : "restore"
+		});
+		restorable.push(item);
+	} catch (error) {
+		skipped.push({
+			entry: item.entry,
+			reason: `its stored contents cannot be read: ${error.message}`
+		});
+	}
+	const applyOne = async (item) => {
+		if (item.action === "remove") await removeChange(item.change);
+		const backup = item.action === "restore" ? await writeChange(item.change) : null;
+		await markUndone(journalFile, item.entry);
+		return backup;
+	};
+	if (flags.json) {
+		const { applied, failure } = await applyAll(flags.mode === "apply" ? restorable : [], async (item) => {
+			await applyOne(item);
+			return item.entry.path;
+		});
+		console.log(JSON.stringify({
+			command: "undo",
+			mode: flags.mode,
+			journal: journalFile,
+			batch: plan?.batch ?? null,
+			at: plan?.at ?? null,
+			applied: applied.length,
+			appliedPaths: applied,
+			...failure ? { error: failure.message } : {},
+			files: files.map((file) => jsonFile(file, secret)),
+			skipped: skipped.map((item) => ({
+				path: item.entry.path,
+				reason: item.reason
+			}))
+		}, null, 2));
+		if (failure) process.exitCode = 1;
+		return;
+	}
+	intro("Apex CLI · Undo the last setup", MODE_NOTE[flags.mode]);
+	if (!plan) {
+		outro(entries.length ? `Everything Apex CLI has written here has already been undone. History: ${APEX} undo --list (journal: ${shortPath(journalFile)})` : `Nothing recorded yet, so nothing to undo. Journal: ${shortPath(journalFile)}`);
+		return;
+	}
+	if (skipped.length) plain("");
+	for (const item of skipped) warn(`${bold(shortPath(item.entry.path))} stays as it is: ${shortPath(item.reason)}`);
+	if (!restorable.length) {
+		outro("No file Apex CLI wrote can be restored safely. Nothing was written.");
+		return;
+	}
+	if ((await runWrites({
+		title: `Undo of the setup from ${stamp(plan.at)}`,
+		files,
+		options,
+		mode: flags.mode,
+		prompt: "Undo these changes?",
+		hint: "Files Apex CLI created are deleted; edited files go back to their pre-setup contents.",
+		pending: restorable,
+		write: async (item) => {
+			const backup = await applyOne(item);
+			const path = bold(shortPath(item.entry.path));
+			return item.action === "remove" ? `${path} ${dim("deleted (Apex CLI created it)")}` : `${path} ${dim(`restored; current contents kept as ${basename(backup)}`)}`;
+		}
+	})).applied) outro("Undone. Configs are back to how they were. Restart any open assistant to reload them.");
+}
+async function commandRun(rest) {
+	const [id, ...passed] = rest;
+	if (!RUNNABLE.includes(id)) throw new Error(`apex run needs one of: ${RUNNABLE.join(", ")}. See ${APEX} --help.`);
+	const options = launchOptions(id);
+	const binary = await executable(id);
+	if (!binary) throw new Error(`${id} was not found on PATH. Install it first, then run ${APEX} init.`);
+	if (process.platform === "win32" && /\.(cmd|bat)$/i.test(binary)) throw new Error("Windows .cmd/.bat launchers are not executed through a shell. Use WSL or launch the configured assistant directly.");
+	const args = passed[0] === "--" ? passed.slice(1) : passed;
+	const child = spawn(binary, [...options.args, ...args], {
+		env: options.env,
+		stdio: "inherit",
+		shell: false
+	});
+	await new Promise((resolve, reject) => {
+		child.once("error", reject);
+		child.once("exit", (code, signal) => {
+			process.exitCode = code ?? (signal === "SIGINT" ? 130 : 1);
+			resolve();
+		});
+	});
+}
+const GLOBALS = [["--version", "print the version"], ["--help", "show all commands"]];
+const completionsFor = (command) => COMMANDS[command].flags.map((flag) => ({
+	long: `--${flag}`,
+	short: FLAGS[flag].short ? `-${FLAGS[flag].short}` : null,
+	hint: FLAGS[flag].hint,
+	...command === "init" && flag === "assistants" ? { values: IDS } : {}
+}));
+const spellings = (entry) => [entry.long, entry.short].filter(Boolean);
+function completionScript(shell) {
+	const taking = Object.keys(COMMANDS).filter((name) => COMMANDS[name].flags.length);
+	const words = (list) => list.join(" ");
+	if (shell === "zsh") return `#compdef apex
+_apex() {
+  local -a commands assistants runnable${taking.length ? " " : ""}${words(taking.map((name) => `${name}_flags`))}
+  commands=(${words([...Object.entries(COMMANDS).map(([name, command]) => `'${name}:${command.summary}'`), ...GLOBALS.map(([flag, text]) => `'${flag}:${text}'`)])})
+  assistants=(${words(IDS)})
+  runnable=(${words(RUNNABLE)})
+${taking.map((name) => `  ${name}_flags=(${words(completionsFor(name).flatMap((entry) => spellings(entry).map((word) => `'${word}:${entry.hint}'`)))})`).join("\n")}
+  if (( CURRENT == 2 )); then
+    _describe -t commands 'apex command' commands
+  elif [[ "\${words[CURRENT - 1]}" == --assistants ]]; then
+    _describe -t assistants 'assistant' assistants
+  else
+    case "\${words[2]}" in
+${taking.map((name) => `      ${name}) _describe -t flags 'option' ${name}_flags ;;`).join("\n")}
+      run) (( CURRENT == 3 )) && _describe -t assistants 'assistant' runnable ;;
+      completion) _describe -t shells 'shell' '(${words(SHELLS)})' ;;
+    esac
+  fi
+}
+# Autoloaded from $fpath, this file body is the first completion call, so it must complete too.
+if [[ "\${funcstack[1]}" == _apex ]]; then _apex "$@"; else compdef _apex apex; fi
+`;
+	if (shell === "bash") return `_apex_completions() {
+  local sub="\${COMP_WORDS[1]}" prev="\${COMP_WORDS[COMP_CWORD - 1]}" current="\${COMP_WORDS[COMP_CWORD]}"
+  if [[ "$prev" == --assistants ]]; then COMPREPLY=( $(compgen -W "${words(IDS)}" -- "$current") ); return; fi
+  if (( COMP_CWORD == 1 )); then
+    COMPREPLY=( $(compgen -W "${words([...Object.keys(COMMANDS), ...GLOBALS.map(([flag]) => flag)])}" -- "$current") )
+    return
+  fi
+  case "$sub" in
+${taking.map((name) => `    ${name}) COMPREPLY=( $(compgen -W "${words(completionsFor(name).flatMap(spellings))}" -- "$current") ) ;;`).join("\n")}
+    run) (( COMP_CWORD == 2 )) && COMPREPLY=( $(compgen -W "${words(RUNNABLE)}" -- "$current") ) ;;
+    completion) (( COMP_CWORD == 2 )) && COMPREPLY=( $(compgen -W "${words(SHELLS)}" -- "$current") ) ;;
+  esac
+}
+complete -F _apex_completions apex
+`;
+	const fish = (condition, { long, short, hint, values }) => `complete -c apex -f -n "${condition}" -l ${long.slice(2)}${short ? ` -s ${short.slice(1)}` : ""}${values ? ` -a "${words(values)}"` : ""} -d '${hint}'`;
+	return [
+		...Object.entries(COMMANDS).map(([name, command]) => `complete -c apex -f -n "__fish_use_subcommand" -a ${name} -d '${command.summary}'`),
+		...GLOBALS.map(([flag, hint]) => `complete -c apex -f -n "__fish_use_subcommand" -l ${flag.slice(2)} -d '${hint}'`),
+		...taking.flatMap((name) => completionsFor(name).map((entry) => fish(`__fish_seen_subcommand_from ${name}`, entry))),
+		...RUNNABLE.map((id) => `complete -c apex -f -n "__fish_seen_subcommand_from run" -a ${id} -d 'assistant'`),
+		...SHELLS.map((name) => `complete -c apex -f -n "__fish_seen_subcommand_from completion" -a ${name} -d 'shell'`)
+	].join("\n") + "\n";
+}
+function commandCompletion(rest) {
+	const [shell] = rest;
+	if (!SHELLS.includes(shell)) throw new Error(`apex completion needs one of: ${SHELLS.join(", ")}.`);
+	process.stdout.write(completionScript(shell));
+}
+async function main(argv) {
+	const [command, ...rest] = argv;
+	if (!command || [
+		"--help",
+		"-h",
+		"help"
+	].includes(command)) {
+		printHelp();
+		return;
+	}
+	if (["--version", "-v"].includes(command)) {
+		console.log(await packageVersion());
+		return;
+	}
+	if (command === "completion") return commandCompletion(rest);
+	if (command === "run") return commandRun(rest);
+	if (command === "init") return commandInit(rest);
+	if (command === "detect") return commandDetect(rest);
+	if (command === "undo") return commandUndo(rest);
+	throw new Error(`Unknown command: ${command}. See apex --help.`);
+}
+main(process.argv.slice(2)).catch((error) => {
+	const line = `Apex CLI: ${error.message}`;
+	if (interactive()) console.error(styleText("red", line));
+	else console.error(line);
+	process.exitCode = 1;
+});
+for (const stream of [process.stdout, process.stderr]) stream.on("error", (error) => {
+	if (error.code === "EPIPE") process.exit(process.exitCode ?? 0);
+	throw error;
+});
+
+//#endregion
+export {  };