@callstack/apex 0.3.0 → 0.4.1

package/dist/cli.js

@@ -48,13 +48,13 @@ function createScanner(text, ignoreTrivia = false) {
 		if (text.charCodeAt(pos) === 48) pos++;
 		else {
 			pos++;
-			while (pos < text.length && isDigit(text.charCodeAt(pos))) pos++;
+			while (pos < text.length && isDigit$1(text.charCodeAt(pos))) pos++;
 		}
 		if (pos < text.length && text.charCodeAt(pos) === 46) {
 			pos++;
-			if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+			if (pos < text.length && isDigit$1(text.charCodeAt(pos))) {
 				pos++;
-				while (pos < text.length && isDigit(text.charCodeAt(pos))) pos++;
+				while (pos < text.length && isDigit$1(text.charCodeAt(pos))) pos++;
 			} else {
 				scanError = 3;
 				return text.substring(start, pos);
@@ -64,9 +64,9 @@ function createScanner(text, ignoreTrivia = false) {
 		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))) {
+			if (pos < text.length && isDigit$1(text.charCodeAt(pos))) {
 				pos++;
-				while (pos < text.length && isDigit(text.charCodeAt(pos))) pos++;
+				while (pos < text.length && isDigit$1(text.charCodeAt(pos))) pos++;
 				end = pos;
 			} else scanError = 3;
 		}
@@ -234,7 +234,7 @@ function createScanner(text, ignoreTrivia = false) {
 			case 45:
 				value += String.fromCharCode(code);
 				pos++;
-				if (pos === len || !isDigit(text.charCodeAt(pos))) return token = 16;
+				if (pos === len || !isDigit$1(text.charCodeAt(pos))) return token = 16;
 			case 48:
 			case 49:
 			case 50:
@@ -306,7 +306,7 @@ function isWhiteSpace(ch) {
 function isLineBreak(ch) {
 	return ch === 10 || ch === 13;
 }
-function isDigit(ch) {
+function isDigit$1(ch) {
 	return ch >= 48 && ch <= 57;
 }
 var CharacterCodes;
@@ -1275,11 +1275,11 @@ function applyEdits(text, edits) {
 * 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);
+	let lines = string.slice(0, ptr).split(/\r?\n/);
 	return [lines.length, lines.pop().length + 1];
 }
 function makeCodeBlock(string, line, column) {
-	let lines = string.split(/\r\n|\n|\r/g);
+	let lines = string.split(/\r?\n/);
 	let codeblock = "";
 	let numberLen = (Math.log10(line + 1) | 0) + 1;
 	for (let i = line - 1; i <= line + 1; i++) {
@@ -1296,7 +1296,7 @@ function makeCodeBlock(string, line, column) {
 	}
 	return codeblock;
 }
-var TomlError = class extends Error {
+var TomlError = class TomlError extends Error {
 	line;
 	column;
 	codeblock;
@@ -1308,10 +1308,17 @@ var TomlError = class extends Error {
 		this.column = column;
 		this.codeblock = codeblock;
 	}
+	/** @internal */
+	static x(message, ctx, ptr) {
+		throw new TomlError(message, {
+			toml: ctx.s,
+			ptr: ptr ?? ctx.p
+		});
+	}
 };
 
 //#endregion
-//#region node_modules/smol-toml/dist/util.js
+//#region node_modules/smol-toml/dist/primitive.js
 /*!
 * Copyright (c) Squirrel Chat et al., All rights reserved.
 * SPDX-License-Identifier: BSD-3-Clause
@@ -1339,64 +1346,76 @@ var TomlError = class extends Error {
 * 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
-		});
+/** @internal */
+function parseString(ctx) {
+	let startPtr = ctx.p;
+	let c = ctx.s.charCodeAt(ctx.p++);
+	let first = c;
+	let isLiteral = c === 39;
+	let isMultiline = c === ctx.s.charCodeAt(ctx.p) && c === ctx.s.charCodeAt(ctx.p + 1);
+	if (isMultiline) {
+		if ((c = ctx.s.charCodeAt(ctx.p += 2)) === 10) ctx.p++;
+		else if (c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10) ctx.p += 2;
 	}
-	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++;
+	let parsed = "";
+	let sliceStart = ctx.p;
+	let state = 0;
+	for (; ctx.p < ctx.s.length; ctx.p++) {
+		c = ctx.s.charCodeAt(ctx.p);
+		if (isMultiline && (c === 10 || c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10)) state = state && 3;
+		else if (c < 32 && c !== 9 || c === 127) TomlError.x("control characters are not allowed in strings", ctx);
+		else if ((!state || state === 3) && c === first && (!isMultiline || ctx.s.charCodeAt(ctx.p + 1) === first && ctx.s.charCodeAt(ctx.p + 2) === first)) {
+			if (isMultiline) {
+				if (ctx.s.charCodeAt(ctx.p + 3) === first) ctx.p++;
+				if (ctx.s.charCodeAt(ctx.p + 3) === first) ctx.p++;
+			}
+			if (!state) {
+				let s = ctx.s.slice(sliceStart, ctx.p);
+				parsed = parsed ? parsed + s : s;
+			}
+			ctx.p += isMultiline ? 3 : 1;
+			return parsed;
+		} else if (!state) {
+			if (!isLiteral && c === 92) {
+				parsed += ctx.s.slice(sliceStart, sliceStart = ctx.p);
+				state = 1;
+			}
+		} else if (state === 1) {
+			if (c === 120 || c === 117 || c === 85) {
+				let errPtr = ctx.p++ - 1;
+				let value = 0;
+				let len = c === 120 ? 2 : c === 117 ? 4 : 8;
+				for (let j = 0; j < len; j++, ctx.p++) {
+					let hex = ctx.s.charCodeAt(ctx.p);
+					let digit = hex >= 48 && hex <= 57 ? hex - 48 : hex >= 65 && hex <= 70 ? hex - 65 + 10 : hex >= 97 && hex <= 102 ? hex - 97 + 10 : -1;
+					if (digit < 0) TomlError.x("invalid non-hex character in unicode escape", ctx);
+					value = value << 4 | digit;
+				}
+				if (value < 0 || value > 1114111 || value >= 55296 && value <= 57343) TomlError.x("invalid unicode escape", ctx, errPtr);
+				parsed += String.fromCodePoint(value);
+				sliceStart = ctx.p--;
+				state = 0;
+			} else if (isMultiline && (c === 32 || c === 9)) state = 2;
+			else {
+				if (c === 98) parsed += "\b";
+				else if (c === 116) parsed += "	";
+				else if (c === 110) parsed += "\n";
+				else if (c === 102) parsed += "\f";
+				else if (c === 114) parsed += "\r";
+				else if (c === 101) parsed += "\x1B";
+				else if (c === 34) parsed += "\"";
+				else if (c === 92) parsed += "\\";
+				else TomlError.x("unrecognised escape sequence", ctx);
+				sliceStart = ctx.p + 1;
+				state = 0;
+			}
+		} else if (c !== 32 && c !== 9) {
+			if (state === 2) TomlError.x("invalid escape: only line-ending whitespace may be escaped", ctx, sliceStart);
+			state = !isLiteral && c === 92 ? 1 : 0;
+			sliceStart = ctx.p;
 		}
 	}
-	return seek;
+	TomlError.x("unfinished string", ctx, startPtr);
 }
 
 //#endregion
@@ -1428,31 +1447,48 @@ function getStringEnd(str, seek) {
 * 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;
+let DATE_TIME_RE = /^(\d{4}-\d{2}-\d{2})?[Tt ]?(?:(\d{2}):\d{2}(?::\d{2}(?:\.\d+)?)?)?(Z|z|[-+]\d{2}:\d{2})?$/i;
 var TomlDate = class TomlDate extends Date {
 	#hasDate = false;
 	#hasTime = false;
 	#offset = null;
-	constructor(date) {
+	constructor(date, fasttype, unsafeDelim) {
 		let hasDate = true;
 		let hasTime = true;
 		let offset = "Z";
+		let c;
 		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 = "";
+			if (fasttype) prep: {
+				if (fasttype < 3) {
+					if (+date.slice(11, 13) > 23) {
+						date = "";
+						break prep;
+					}
+					if (fasttype === 2) {
+						offset = null;
+						date += "Z";
+					} else if ((c = date.charCodeAt(date.length - 1)) !== 90 && c !== 122) offset = date.slice(date.length - 6);
+					if (unsafeDelim) date = date.slice(0, 10) + "T" + date.slice(11);
+				} else if (fasttype === 4) date = +date.slice(0, 2) > 23 ? "" : `0000-01-01T${date}Z`;
+				hasDate = fasttype !== 4;
+				hasTime = fasttype !== 3;
+			}
+			else {
+				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;
+						if (!offset && hasTime) date += "Z";
+					}
+				} else date = "";
+			}
 		}
 		super(date);
 		if (!isNaN(this.getTime())) {
@@ -1481,7 +1517,7 @@ var TomlDate = class TomlDate extends Date {
 		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;
+		if (this.#offset === "Z" || 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;
@@ -1511,7 +1547,7 @@ var TomlDate = class TomlDate extends Date {
 };
 
 //#endregion
-//#region node_modules/smol-toml/dist/primitive.js
+//#region node_modules/smol-toml/dist/extract.js
 /*!
 * Copyright (c) Squirrel Chat et al., All rights reserved.
 * SPDX-License-Identifier: BSD-3-Clause
@@ -1539,117 +1575,147 @@ var TomlDate = class TomlDate extends Date {
 * 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++;
+function isDigit(char, base = 10) {
+	return base === 16 ? char > 47 && char < 58 || char > 64 && char < 71 || char > 96 && char < 103 : char > 47 && char < 48 + base;
+}
+function isEndOfValue(char, delim) {
+	return char === 32 || char === 9 || char === 10 || char === 13 || delim && (char === delim || char === 44) || char === 35;
+}
+/** @internal */
+function extractValue(ctx, end) {
+	let errPtr = ctx.p;
+	let c = ctx.s.charCodeAt(ctx.p);
+	if (c === 91 || c === 123) {
+		ctx.d-- || TomlError.x("document contains excessively nested structures. aborting.", ctx);
+		let value = c === 91 ? parseArray(ctx) : parseInlineTable(ctx);
+		ctx.d++;
+		return value;
 	}
-	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);
+	if (c === 34 || c === 39) return parseString(ctx);
+	if (c === 116) {
+		if (ctx.s.charCodeAt(++ctx.p) !== 114 || ctx.s.charCodeAt(++ctx.p) !== 117 || ctx.s.charCodeAt(++ctx.p) !== 101) TomlError.x("invalid value", ctx, errPtr);
+		return ctx.p++, true;
+	}
+	if (c === 102) {
+		if (ctx.s.charCodeAt(++ctx.p) !== 97 || ctx.s.charCodeAt(++ctx.p) !== 108 || ctx.s.charCodeAt(++ctx.p) !== 115 || ctx.s.charCodeAt(++ctx.p) !== 101) TomlError.x("invalid value", ctx, errPtr);
+		return ctx.p++, false;
+	}
+	if (c === 43 || c === 45) return parseNumber(ctx, ctx.p, ctx.s.charCodeAt(++ctx.p), 44 - c, end);
+	if (ctx.s.charCodeAt(ctx.p + 4) === 45 && ctx.s.charCodeAt(ctx.p + 7) === 45) return parseDate(ctx, c, end);
+	if (ctx.s.charCodeAt(ctx.p + 2) === 58) return parseTime(ctx, c, end);
+	return parseNumber(ctx, ctx.p, c, 0, end);
+}
+function parseNumber(ctx, startPtr, startChr, sign, endChr) {
+	let c = startChr;
+	let state = 0;
+	let hasUnderscores = false;
+	if (c === 105) {
+		if (ctx.s.charCodeAt(++ctx.p) !== 110 || ctx.s.charCodeAt(++ctx.p) !== 102) TomlError.x("invalid value", ctx, startPtr);
+		return ctx.p++, (sign || 1) / 0;
+	}
+	if (c === 110) {
+		if (ctx.s.charCodeAt(++ctx.p) !== 97 || ctx.s.charCodeAt(++ctx.p) !== 110) TomlError.x("invalid value", ctx, startPtr);
+		return ctx.p++, NaN;
+	}
+	if (c === 48) {
+		if (++ctx.p >= ctx.s.length || isEndOfValue(c = ctx.s.charCodeAt(ctx.p), endChr)) return ctx.bi === true ? 0n : 0;
+		if (!sign) {
+			if (c === 120) return parseIntegerBaseN(ctx, startPtr, 16, endChr);
+			else if (c === 98) return parseIntegerBaseN(ctx, startPtr, 2, endChr);
+			else if (c === 111) return parseIntegerBaseN(ctx, startPtr, 8, endChr);
+		}
+		if (c === 46) state = 2;
+		else if (c === 101 || c === 69) state = 4;
+		else TomlError.x("illegal leading zero", ctx, startPtr);
+	} else if (!isDigit(c)) TomlError.x("invalid value", ctx, startPtr);
+	while (++ctx.p < ctx.s.length && (c = ctx.s.charCodeAt(ctx.p), !isEndOfValue(c, endChr))) {
+		if (!state) state = 1;
+		if (c === 95) {
+			if (!(state & 1)) TomlError.x("illegal underscore", ctx);
+			state += 11;
+			hasUnderscores = true;
+		} else if (state === 1 && c === 46) state = 2;
+		else if ((state === 1 || state === 3) && (c === 101 || c === 69)) state = 4;
+		else if (state === 4 && (c === 43 || c === 45)) state = 6;
+		else if (!isDigit(c)) TomlError.x(`illegal character in numeric literal`, ctx);
+		else if (state > 9) state -= 11;
+		else if (!(state & 1)) state++;
+	}
+	if (!state) {
+		let val = (startChr - 48) * (sign || 1);
+		return ctx.bi === true ? BigInt(val) : val;
+	}
+	if (!(state & 1)) TomlError.x("unfinished numeric value", ctx, startPtr);
+	let str = ctx.s.slice(startPtr, ctx.p);
+	if (hasUnderscores) str = str.replaceAll("_", "");
+	return state > 1 ? parseFloat(str) : parseInteger(ctx, str, 10, startPtr);
+}
+function parseIntegerBaseN(ctx, startPtr, base, endChr) {
+	let c, underscore = 1;
+	while (++ctx.p < ctx.s.length && (c = ctx.s.charCodeAt(ctx.p), !isEndOfValue(c, endChr))) if (c === 95) {
+		if (underscore & 1) TomlError.x("illegal underscore", ctx);
+		underscore = 3;
+	} else if (!isDigit(c, base)) TomlError.x(`illegal character in numeric literal`, ctx);
+	else if (underscore & 1) underscore--;
+	if (underscore & 1) TomlError.x("unfinished numeric value", ctx);
+	let str = ctx.s.slice(startPtr + 2, ctx.p);
+	if (underscore) str = str.replaceAll("_", "");
+	return parseInteger(ctx, str, base, startPtr);
+}
+function parseInteger(ctx, str, base, startPtr) {
+	if (ctx.bi !== true) int: {
+		let val = parseInt(str, base);
+		if (!Number.isSafeInteger(val)) {
+			if (ctx.bi) break int;
+			TomlError.x("integer value cannot be represented losslessly", ctx, startPtr);
 		}
+		return val;
+	}
+	return base === 10 ? BigInt(str) : BigInt((base === 2 ? "0b" : base === 8 ? "0o" : "0x") + str);
+}
+function parseDate(ctx, c, endChr) {
+	let startPtr = ctx.p++, unsafeSeparator;
+	if (!isDigit(c) || !isDigit(ctx.s.charCodeAt(ctx.p++)) || !isDigit(ctx.s.charCodeAt(ctx.p++)) || !isDigit(ctx.s.charCodeAt(ctx.p++))) return parseNumber(ctx, ctx.p = startPtr, c, 0, endChr);
+	ctx.p += 5;
+	if (!isDigit(ctx.s.charCodeAt(ctx.p++))) TomlError.x("invalid date-time: date part is malformed", ctx, startPtr);
+	if (ctx.p >= ctx.s.length || ((c = ctx.s.charCodeAt(ctx.p)) !== 32 || (unsafeSeparator = true, !isDigit(ctx.s.charCodeAt(ctx.p + 1)))) && c !== 84 && c !== 116) return readDate(ctx, ctx.s.slice(startPtr, ctx.p), 3, false, startPtr);
+	if (ctx.s.charCodeAt(ctx.p += 3) !== 58) TomlError.x("invalid date-time: time part is malformed", ctx, startPtr);
+	if (ctx.s.charCodeAt(ctx.p += 3) === 58) ctx.p += 3;
+	if (ctx.s.charCodeAt(ctx.p) === 46) while (isDigit(ctx.s.charCodeAt(++ctx.p)));
+	if (c = ctx.s.charCodeAt(ctx.p)) {
+		if (c === 90 || c === 122) return readDate(ctx, ctx.s.slice(startPtr, ++ctx.p), 1, unsafeSeparator, startPtr, "[+00:00]");
+		if (c === 43 || c === 45) return readDate(ctx, ctx.s.slice(startPtr, ctx.p += 6), 1, unsafeSeparator, startPtr, !ctx.ld && "[" + ctx.s.slice(ctx.p - 6, ctx.p) + "]");
+	}
+	return readDate(ctx, ctx.s.slice(startPtr, ctx.p), 2, unsafeSeparator, startPtr);
+}
+function parseTime(ctx, c, endChr) {
+	let start = ctx.p;
+	if (!isDigit(c) || !isDigit(ctx.s.charCodeAt(++ctx.p))) return parseNumber(ctx, --ctx.p, c, 0, endChr);
+	if (ctx.s.charCodeAt(ctx.p += 4) === 58) ctx.p += 3;
+	if (ctx.s.charCodeAt(ctx.p) === 46) while (isDigit(ctx.s.charCodeAt(++ctx.p)));
+	return readDate(ctx, ctx.s.slice(start, ctx.p), 4, false, start);
+}
+function readDate(ctx, str, type, unsafeDelim, errPtr, temporalSuffix) {
+	if (ctx.ld) {
+		let date = new TomlDate(str, type, unsafeDelim);
+		if (!date.isValid()) TomlError.x("invalid date", ctx, errPtr);
+		return date;
 	}
-	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);
+	try {
+		if (temporalSuffix) str += temporalSuffix;
+		switch (type) {
+			case 1: return Temporal.ZonedDateTime.from(str);
+			case 2: return Temporal.PlainDateTime.from(str);
+			case 3: return Temporal.PlainDate.from(str);
+			case 4: return Temporal.PlainTime.from(str);
 		}
-		return numeric;
+	} catch (e) {
+		TomlError.x(e instanceof Error ? e.message : "" + e, ctx, errPtr);
 	}
-	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
+//#region node_modules/smol-toml/dist/util.js
 /*!
 * Copyright (c) Squirrel Chat et al., All rights reserved.
 * SPDX-License-Identifier: BSD-3-Clause
@@ -1677,66 +1743,26 @@ function parseValue(value, toml, ptr, integersAsBigInt) {
 * 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] === ",");
+/** @internal */
+function skipComment(ctx) {
+	for (; ctx.p < ctx.s.length; ctx.p++) {
+		let c = ctx.s.charCodeAt(ctx.p);
+		if (c === 10) break;
+		if (c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10) {
+			ctx.p++;
+			break;
 		}
-		return [parsed, endPtr];
+		if (c < 32 && c !== 9 || c === 127) TomlError.x("control characters are not allowed in comments", ctx);
 	}
-	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] === ",");
+}
+/** @internal */
+function skipVoid(ctx, banNewLines, banComments) {
+	let c;
+	while (ctx.p < ctx.s.length) {
+		while (ctx.p < ctx.s.length && ((c = ctx.s.charCodeAt(ctx.p)) === 32 || c === 9 || !banNewLines && (c === 10 || c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10))) ctx.p++;
+		if (banComments || c !== 35) break;
+		skipComment(ctx);
 	}
-	return [parseValue(slice[0], str, ptr, integersAsBigInt), endPtr];
 }
 
 //#endregion
@@ -1768,132 +1794,99 @@ function extractValue(str, ptr, end, depth, integersAsBigInt) {
 * 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;
+/** @internal */
+function parseKey(ctx, end = 61) {
+	let startPtr;
+	let state = 0;
 	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());
+	let sliceStart;
+	let c = ctx.s.charCodeAt(startPtr = ctx.p);
+	do
+		if (c === end) {
+			if (!state) TomlError.x("unexpected end of key", ctx);
+			if (state === 1) parsed.push(ctx.s.slice(sliceStart, ctx.p));
+			return ctx.p++, parsed;
+		} else if (c === 46) {
+			if (!state) TomlError.x("illegal empty bare key", ctx);
+			if (state === 1) parsed.push(ctx.s.slice(sliceStart, ctx.p));
+			state = 0;
+		} else if (!state && (c === 34 || c === 39)) {
+			if (c === ctx.s.charCodeAt(ctx.p + 1) && c === ctx.s.charCodeAt(ctx.p + 2)) TomlError.x("illegal quoted key: multiline strings are not allowed", ctx);
+			parsed.push(parseString(ctx));
+			state = 2;
+			ctx.p--;
+		} else if (c === 32 || c === 9) {
+			if (state === 1) {
+				parsed.push(ctx.s.slice(sliceStart, ctx.p));
+				state = 2;
 			}
+		} else if (state === 2 || c < 48 && c !== 45 || c > 57 && c < 65 || c > 90 && c < 97 && c !== 95 || c > 122) TomlError.x("illegal character in key", ctx);
+		else if (!state) {
+			state = 1;
+			sliceStart = ctx.p;
 		}
-	} while (dot + 1 && dot < endPtr);
-	return [parsed, skipVoid(str, endPtr + 1, true, true)];
+	while (c = ctx.s.charCodeAt(++ctx.p));
+	TomlError.x("incomplete key-value: cannot find end of key", ctx, startPtr);
 }
-function parseInlineTable(str, ptr, depth, integersAsBigInt) {
-	let res = {};
+/** @internal */
+function parseInlineTable(ctx) {
+	let startPtr = ctx.p++;
+	let res = Object.create(null);
 	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
-				});
+	while (ctx.p < ctx.s.length) {
+		skipVoid(ctx);
+		if ((c = ctx.s.charCodeAt(ctx.p)) === 125) {
+			ctx.p++;
+			return res;
+		}
+		let k;
+		let t = res;
+		let hasOwn = false;
+		let errPtr = ctx.p;
+		let key = parseKey(ctx);
+		for (let i = 0; i < key.length; i++) {
+			if (i) t = hasOwn ? t[k] : t[k] = Object.create(null);
+			k = key[i];
+			if ((hasOwn = Object.hasOwn(t, k)) && (typeof t[k] !== "object" || seen.has(t[k]))) TomlError.x("trying to redefine an already defined value", ctx, errPtr);
+			let unsafe = k === "__proto__";
+			if (ctx.uk && (unsafe || k === "constructor")) {
+				t = ctx.uk !== 1 && TomlError.x("document contains an unsafe property", ctx, errPtr);
+				break;
 			}
-			if (hasOwn) throw new TomlError("trying to redefine an already defined value", {
-				toml: str,
-				ptr
+			if (!hasOwn && unsafe) Object.defineProperty(t, k, {
+				enumerable: true,
+				configurable: true,
+				writable: true
 			});
-			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) {
+		if (hasOwn) TomlError.x("trying to redefine an already defined value", ctx, errPtr);
+		skipVoid(ctx, true, true);
+		let value = extractValue(ctx, 125);
+		if (t && typeof (t[k] = value) === "object") seen.add(value);
+		skipVoid(ctx);
+		if ((c = ctx.s.charCodeAt(ctx.p++)) === 125) return res;
+		if (c !== 44) TomlError.x("expected comma or end of structure", ctx, ctx.p - 1);
+	}
+	TomlError.x("unfinished table", ctx, startPtr);
+}
+/** @internal */
+function parseArray(ctx) {
+	let startPtr = ctx.p++;
 	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];
+	while (ctx.p < ctx.s.length) {
+		skipVoid(ctx);
+		if ((c = ctx.s.charCodeAt(ctx.p)) === 93) {
+			ctx.p++;
+			return res;
+		}
+		res.push(extractValue(ctx, 93));
+		skipVoid(ctx);
+		if ((c = ctx.s.charCodeAt(ctx.p++)) === 93) return res;
+		if (c !== 44) TomlError.x("expected comma or end of structure", ctx, ctx.p - 1);
+	}
+	TomlError.x("unfinished array", ctx, startPtr);
 }
 
 //#endregion
@@ -1925,7 +1918,7 @@ function parseArray(str, ptr, depth, integersAsBigInt) {
 * 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) {
+function peekTable(ctx, key, table, meta, type) {
 	let t = table;
 	let m = meta;
 	let k;
@@ -1933,7 +1926,7 @@ function peekTable(key, table, meta, type) {
 	let state;
 	for (let i = 0; i < key.length; i++) {
 		if (i) {
-			t = hasOwn ? t[k] : t[k] = {};
+			t = hasOwn ? t[k] : t[k] = Object.create(null);
 			m = (state = m[k]).c;
 			if (type === 0 && (state.t === 1 || state.t === 2)) return null;
 			if (state.t === 2) {
@@ -1945,7 +1938,9 @@ function peekTable(key, table, meta, type) {
 		k = key[i];
 		if ((hasOwn = Object.hasOwn(t, k)) && m[k]?.t === 0 && m[k]?.d) return null;
 		if (!hasOwn) {
-			if (k === "__proto__") {
+			let unsafe = k === "__proto__";
+			if (ctx.uk && (unsafe || k === "constructor")) return false;
+			if (unsafe) {
 				Object.defineProperty(t, k, {
 					enumerable: true,
 					configurable: true,
@@ -1961,7 +1956,7 @@ function peekTable(key, table, meta, type) {
 				t: i < key.length - 1 && type === 2 ? 3 : type,
 				d: false,
 				i: 0,
-				c: {}
+				c: Object.create(null)
 			};
 		}
 	}
@@ -1972,17 +1967,17 @@ function peekTable(key, table, meta, type) {
 			state.d = true;
 			t[k] = [];
 		}
-		t[k].push(t = {});
+		t[k].push(t = Object.create(null));
 		state.c[state.i++] = state = {
 			t: 1,
 			d: false,
 			i: 0,
-			c: {}
+			c: Object.create(null)
 		};
 	}
 	if (state.d) return null;
 	state.d = true;
-	if (type === 1) t = hasOwn ? t[k] : t[k] = {};
+	if (type === 1) t = hasOwn ? t[k] : t[k] = Object.create(null);
 	else if (type === 0 && hasOwn) return null;
 	return [
 		k,
@@ -1990,47 +1985,55 @@ function peekTable(key, table, meta, type) {
 		state.c
 	];
 }
-function parse$1(toml, { maxDepth = 1e3, integersAsBigInt } = {}) {
-	let res = {};
-	let meta = {};
+function validateTablePeek(ctx, peek, ptr) {
+	if (peek === null || ctx.uk === 2) TomlError.x(peek === null ? "trying to redefine an already defined table or value" : "document contains an unsafe property", ctx, ptr);
+}
+function parse$1(toml, options = {}) {
+	let ctx = {
+		s: toml,
+		p: 0,
+		d: options.maxDepth ?? 1e3,
+		bi: options.integersAsBigInt ?? false,
+		ld: options.useLegacyDate ?? true,
+		uk: options.unsafeKeyBehaviour === "throw" ? 2 : options.unsafeKeyBehaviour === "drop" ? 1 : 0
+	};
+	let res = Object.create(null);
+	let meta = Object.create(null);
+	let tmp;
+	let skipping = false;
 	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 (toml.charCodeAt(0) === 65279) ctx.p++;
+	skipVoid(ctx);
+	while (ctx.p < toml.length) {
+		if (toml.charCodeAt(ctx.p) === 91) {
+			let isTableArray = toml.charCodeAt(++ctx.p) === 91;
+			tmp = ctx.p += +isTableArray;
+			skipping = false;
+			let k = parseKey(ctx, 93);
 			if (isTableArray) {
-				if (toml[k[1] - 1] !== "]") throw new TomlError("expected end of table declaration", {
-					toml,
-					ptr: k[1] - 1
-				});
-				k[1]++;
+				if (toml.charCodeAt(ctx.p) !== 93) TomlError.x("expected end of table array declaration", ctx);
+				ctx.p++;
+			}
+			let p = peekTable(ctx, k, res, meta, isTableArray ? 2 : 1);
+			if (!p) {
+				validateTablePeek(ctx, p, tmp);
+				skipping = true;
+			} else {
+				m = p[2];
+				tbl = p[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];
+			tmp = ctx.p;
+			let p = peekTable(ctx, parseKey(ctx), tbl, m, 0);
+			if (!p && !skipping) validateTablePeek(ctx, p, tmp);
+			skipVoid(ctx, true, true);
+			let v = extractValue(ctx, void 0);
+			if (p && !skipping) p[1][p[0]] = v;
 		}
-		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);
+		skipVoid(ctx, true);
+		if (ctx.p < toml.length && (tmp = toml.charCodeAt(ctx.p)) !== 10 && (tmp !== 13 || toml.charCodeAt(ctx.p + 1) !== 10)) TomlError.x("each key-value declaration must be followed by an end-of-line", ctx);
+		skipVoid(ctx);
 	}
 	return res;
 }
@@ -2065,11 +2068,20 @@ function parse$1(toml, { maxDepth = 1e3, integersAsBigInt } = {}) {
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 let BARE_KEY = /^[a-z0-9-_]+$/i;
+let HAS_WELLFORMED = !!"".isWellFormed;
 function extendedTypeOf(obj) {
 	let type = typeof obj;
 	if (type === "object") {
 		if (Array.isArray(obj)) return "array";
-		if (obj instanceof Date) return "date";
+		if (typeof obj.getUTCDate === "function" && obj instanceof Date) return "date";
+		if (globalThis.Temporal) {
+			if (obj.until) {
+				if (obj instanceof Temporal.ZonedDateTime) return "temporal/tz+uc";
+				if (obj instanceof Temporal.PlainDateTime || obj instanceof Temporal.PlainDate) return "temporal/uc";
+				if (obj instanceof Temporal.PlainTime || obj instanceof Temporal.Instant) return "temporal";
+				if (obj instanceof Temporal.PlainYearMonth) return "temporal/x";
+			} else if (obj.toPlainDate && obj instanceof Temporal.PlainMonthDay || obj.negated && obj instanceof Temporal.Duration) return "temporal/x";
+		}
 	}
 	return type;
 }
@@ -2077,61 +2089,79 @@ function isArrayOfTables(obj) {
 	for (let i = 0; i < obj.length; i++) if (extendedTypeOf(obj[i]) !== "object") return false;
 	return obj.length != 0;
 }
+function formatWellFormedStringUnchecked(s) {
+	return JSON.stringify(s).replaceAll("", "\\u007f");
+}
 function formatString(s) {
-	return JSON.stringify(s).replace(/\x7f/g, "\\u007f");
+	return formatWellFormedStringUnchecked(HAS_WELLFORMED ? s.toWellFormed() : s);
+}
+function formatKey(s) {
+	if (BARE_KEY.test(s)) return s;
+	if (HAS_WELLFORMED && !s.isWellFormed()) throw new RangeError("key contains illegal lone surrogates");
+	return formatWellFormedStringUnchecked(s);
 }
-function stringifyValue(val, type, depth, numberAsFloat) {
+function stringifyValue(val, type, depth, numberAsFloat, strictTemporal) {
 	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) {
+	switch (type) {
+		case "number":
+			if (isNaN(val)) return "nan";
+			if (val === Infinity) return "inf";
+			if (val === -Infinity) return "-inf";
+			if (Number.isInteger(val) && (numberAsFloat || !Number.isSafeInteger(val))) return val.toFixed(1);
+		case "bigint":
+		case "boolean":
+		case "temporal": return val.toString();
+		case "string": return formatString(val);
+		case "date":
+			if (isNaN(val.getTime())) throw new TypeError("cannot serialize invalid date");
+			return val.toISOString();
+		case "object": return stringifyInlineTable(val, depth, numberAsFloat, strictTemporal);
+		case "array": return stringifyArray(val, depth, numberAsFloat, strictTemporal);
+		case "temporal/tz+uc": if (strictTemporal) {
+			let tz = val.timeZoneId;
+			let tzc = tz.charCodeAt(0);
+			if (tzc !== 43 && tzc !== 45 && (tzc !== 85 && tzc !== 71 && tzc !== 90 && tzc !== 69 || tz !== "UTC" && tz !== "UCT" && tz !== "Universal" && tz !== "Zulu" && !tz.startsWith("GMT") && tz !== "Greenwich" && !tz.startsWith("Etc/"))) throw new TypeError("Temporal objects with an IANA timezone are not allowed in Temporal strict mode");
+		}
+		case "temporal/uc":
+			if (strictTemporal && val.calendarId !== "iso8601") throw new TypeError("Temporal objects with a non-default calendar are not allowed in Temporal strict mode");
+			return val.toString({
+				calendarName: "never",
+				timeZoneName: "never"
+			});
+		case "temporal/x": throw new TypeError("Unsupported " + val[Symbol.toStringTag]);
+	}
+}
+function stringifyInlineTable(obj, depth, numberAsFloat, strictTemporal) {
 	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);
+		res += formatKey(k) + " = " + stringifyValue(obj[k], extendedTypeOf(obj[k]), depth - 1, numberAsFloat, strictTemporal);
 	}
 	return res + " }";
 }
-function stringifyArray(array, depth, numberAsFloat) {
+function stringifyArray(array, depth, numberAsFloat, strictTemporal) {
 	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);
+		res += stringifyValue(array[i], extendedTypeOf(array[i]), depth - 1, numberAsFloat, strictTemporal);
 	}
 	return res + " ]";
 }
-function stringifyArrayTable(array, key, depth, numberAsFloat) {
+function stringifyArrayTable(array, key, depth, numberAsFloat, strictTemporal) {
 	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";
+		res += `${res && "\n"}[[${key}]]\n`;
+		res += stringifyTable(0, array[i], key, depth, numberAsFloat, strictTemporal);
 	}
 	return res;
 }
-function stringifyTable(obj, prefix, depth, numberAsFloat) {
+function stringifyTable(tableKey, obj, prefix, depth, numberAsFloat, strictTemporal) {
 	if (depth === 0) throw new Error("Could not stringify the object: maximum object depth exceeded");
 	let preamble = "";
 	let tables = "";
@@ -2141,39 +2171,78 @@ function stringifyTable(obj, prefix, depth, numberAsFloat) {
 		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);
+			let key = formatKey(k);
+			if (type === "array" && isArrayOfTables(obj[k])) tables += (tables && "\n") + stringifyArrayTable(obj[k], prefix ? `${prefix}.${key}` : key, depth - 1, numberAsFloat, strictTemporal);
 			else if (type === "object") {
 				let tblKey = prefix ? `${prefix}.${key}` : key;
-				tables += `[${tblKey}]\n`;
-				tables += stringifyTable(obj[k], tblKey, depth - 1, numberAsFloat);
-				tables += "\n\n";
+				tables += (tables && "\n") + stringifyTable(tblKey, obj[k], tblKey, depth - 1, numberAsFloat, strictTemporal);
 			} else {
 				preamble += key;
 				preamble += " = ";
-				preamble += stringifyValue(obj[k], type, depth, numberAsFloat);
+				preamble += stringifyValue(obj[k], type, depth, numberAsFloat, strictTemporal);
 				preamble += "\n";
 			}
 		}
 	}
-	return `${preamble}\n${tables}`.trim();
+	if (tableKey && (preamble || !tables)) preamble = preamble ? `[${tableKey}]\n${preamble}` : `[${tableKey}]`;
+	return preamble && tables ? `${preamble}\n${tables}` : preamble || tables;
 }
-function stringify(obj, { maxDepth = 1e3, numbersAsFloat = false } = {}) {
+function stringify(obj, { maxDepth = 1e3, numbersAsFloat = false, strictTemporal = false } = {}) {
 	if (extendedTypeOf(obj) !== "object") throw new TypeError("stringify can only be called with an object");
-	return stringifyTable(obj, "", maxDepth, numbersAsFloat);
+	let str = stringifyTable(0, obj, "", maxDepth, numbersAsFloat, strictTemporal);
+	if (str[str.length - 1] !== "\n") return str + "\n";
+	return str;
 }
 
+//#endregion
+//#region node_modules/smol-toml/dist/index.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.
+*/
+
 //#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)) {
+	const full = resolve(path);
+	let current = parse(full).root;
+	for (const part of full.slice(current.length).split(/[\\/]/).filter(Boolean)) {
 		current = join(current, part);
+		let info;
 		try {
-			if ((await lstat(current)).isSymbolicLink()) throw new Error(`Refusing symbolic link: ${current}`);
+			info = await lstat(current);
 		} catch (error) {
-			if (error.code !== "ENOENT") throw error;
+			if (error.code === "ENOENT") return;
+			throw error;
 		}
+		if (!info.isSymbolicLink()) continue;
+		if (current === full) throw new Error(`Refusing symbolic link: ${current}`);
+		await stat(current).catch((error) => {
+			throw error.code === "ENOENT" ? /* @__PURE__ */ new Error(`Refusing dangling symbolic link: ${current}`) : error;
+		});
 	}
 }
 async function readConfig(path) {
@@ -2188,6 +2257,8 @@ async function readConfig(path) {
 function object(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value);
 }
+const plain$1 = (value) => Array.isArray(value) ? value.map(plain$1) : value !== null && typeof value === "object" && Object.getPrototypeOf(value) === null ? Object.fromEntries(Object.entries(value).map(([key, item]) => [key, plain$1(item)])) : value;
+const parseToml = (text) => plain$1(parse$1(text));
 function parseJson(text, path) {
 	const errors = [];
 	const value = parse$2(text ?? "{}", errors, { allowTrailingComma: true });
@@ -2212,26 +2283,123 @@ function editJson(text, changes, path) {
 	parseJson(next, path);
 	return next;
 }
-function addToml(text, desired, path) {
-	let existing;
+function updateToml(text, desired, path, obsolete = []) {
+	const before = text ?? "";
 	try {
-		existing = parse$1(text ?? "");
+		parseToml(before);
 	} 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;
+	const eol = before.includes("\r\n") ? "\r\n" : "\n";
+	const keyText = (key) => /^[\w-]+$/.test(key) ? key : JSON.stringify(key);
+	const lines = before.split(/\r?\n/);
+	const valueAt = (value, keys) => keys.reduce((parent, key) => parent?.[key], value);
+	const merge = (old, next) => object(next) ? Object.fromEntries(Object.entries({
+		...object(old) ? old : {},
+		...next
+	}).map(([key, value]) => [key, Object.hasOwn(next, key) ? merge(old?.[key], next[key]) : value])) : next;
+	const inline = (value) => value instanceof Date ? stringify({ value }).trim().replace(/^value\s*=\s*/, "") : object(value) ? `{ ${Object.entries(value).map(([key, item]) => `${JSON.stringify(key)} = ${inline(item)}`).join(", ")} }` : Array.isArray(value) ? `[${value.map(inline).join(", ")}]` : stringify({ value }).trim().replace(/^value\s*=\s*/, "");
+	const statements = [];
+	let section = [];
+	for (let i = 0; i < lines.length; i++) {
+		if (!lines[i].trim() || lines[i].trimStart().startsWith("#")) {
+			statements.push({
+				text: lines[i],
+				section
+			});
+			continue;
+		}
+		let block = lines[i], parsed;
+		for (;;) try {
+			parsed = parseToml(block);
+			break;
+		} catch {
+			if (++i >= lines.length) throw new Error(`Cannot safely update TOML in ${path}.`);
+			block += eol + lines[i];
+		}
+		if (block.trimStart().startsWith("[")) {
+			section = [];
+			let cursor = parsed;
+			while (object(cursor) && Object.keys(cursor).length === 1) {
+				const key = Object.keys(cursor)[0];
+				section.push(key);
+				cursor = cursor[key];
+			}
+			statements.push({
+				text: block,
+				section,
+				header: true,
+				array: Array.isArray(cursor)
+			});
+			continue;
+		}
+		let equal = 0, keyQuote = null;
+		for (; equal < block.length; equal++) {
+			const char = block[equal];
+			if (keyQuote === "\"" && char === "\\") {
+				equal++;
+				continue;
+			}
+			if (keyQuote) {
+				if (char === keyQuote) keyQuote = null;
+			} else if (char === "\"" || char === "'") keyQuote = char;
+			else if (char === "=") break;
+		}
+		const rawKey = block.slice(0, equal).trim();
+		let cursor = parseToml(`${rawKey} = 0`), keys = [];
+		while (object(cursor)) {
+			const key = Object.keys(cursor)[0];
+			keys.push(key);
+			cursor = cursor[key];
+		}
+		const full = [...section, ...keys];
+		if (obsolete.includes(full.join("."))) continue;
+		const next = valueAt(desired, full);
+		if (next !== void 0 && !isDeepStrictEqual(valueAt(parsed, keys), merge(valueAt(parsed, keys), next))) {
+			let comment = "", quote = null;
+			if (!block.includes(eol)) for (let j = equal + 1; j < block.length; j++) {
+				const char = block[j];
+				if (quote === "\"" && char === "\\") {
+					j++;
+					continue;
+				}
+				if (quote) {
+					if (char === quote) quote = null;
+				} else if (char === "\"" || char === "'") quote = char;
+				else if (char === "#") {
+					comment = ` ${block.slice(j)}`;
+					break;
+				}
+			}
+			block = `${block.slice(0, equal + 1)} ${inline(merge(valueAt(parsed, keys), next))}${comment}`;
+		}
+		statements.push({
+			text: block,
+			section
+		});
+	}
+	const leaves = (value, prefix = []) => Object.entries(value).flatMap(([key, item]) => object(item) ? leaves(item, [...prefix, key]) : [[[...prefix, key], item]]);
+	for (const [keys, value] of leaves(desired)) {
+		const current = parseToml(statements.map((item) => item.text).join(eol));
+		if (isDeepStrictEqual(valueAt(current, keys), value)) continue;
+		let header = -1, prefix = [];
+		statements.forEach((item, index) => {
+			if (item.header && !item.array && item.section.length < keys.length && item.section.every((key, i) => key === keys[i]) && item.section.length > prefix.length) {
+				header = index;
+				prefix = item.section;
+			}
+		});
+		let end = statements.findIndex((item, index) => index > header && item.header);
+		if (end === -1) end = statements.length;
+		statements.splice(end, 0, {
+			text: `${keys.slice(prefix.length).map(keyText).join(".")} = ${inline(value)}`,
+			section: prefix
+		});
+	}
+	const after = statements.map((item) => item.text).join(eol);
+	const result = parseToml(after);
+	for (const [keys, value] of leaves(desired)) if (!isDeepStrictEqual(valueAt(result, keys), value)) throw new Error(`Cannot safely update ${keys.join(".")} in ${path}.`);
+	return after === before ? before : `${after.replace(/\s+$/, "")}${eol}`;
 }
 function sha256(text) {
 	return createHash("sha256").update(text, "utf8").digest("hex");
@@ -2311,8 +2479,7 @@ const RUNNABLE = [
 	"pi"
 ];
 const CONTEXT_WINDOW = 262144;
-const MAX_INPUT = 24e4;
-const MAX_OUTPUT = 16384;
+const MAX_OUTPUT = 32768;
 const EFFORTS = [
 	"none",
 	"low",
@@ -2330,7 +2497,6 @@ const OPENCODE_MODEL = {
 	},
 	limit: {
 		context: CONTEXT_WINDOW,
-		input: MAX_INPUT,
 		output: MAX_OUTPUT
 	},
 	options: { reasoningEffort: "medium" },
@@ -2349,7 +2515,6 @@ const OPENCODE_V2_PROVIDER = {
 		},
 		limit: {
 			context: CONTEXT_WINDOW,
-			input: MAX_INPUT,
 			output: MAX_OUTPUT
 		},
 		settings: { reasoningEffort: "medium" },
@@ -2372,7 +2537,8 @@ const PI_MODEL = {
 		xhigh: "xhigh",
 		max: null
 	},
-	contextWindow: CONTEXT_WINDOW
+	contextWindow: CONTEXT_WINDOW,
+	maxTokens: MAX_OUTPUT
 };
 async function exists(path) {
 	try {
@@ -2497,7 +2663,34 @@ async function planAssistant(assistant) {
 			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]];
+				if (v2) return [
+					[[
+						"providers",
+						"callstack.ai",
+						"name"
+					], OPENCODE_V2_PROVIDER.name],
+					[[
+						"providers",
+						"callstack.ai",
+						"package"
+					], OPENCODE_V2_PROVIDER.package],
+					[[
+						"providers",
+						"callstack.ai",
+						"settings",
+						"baseURL"
+					], BASE_URL],
+					...Object.entries(OPENCODE_V2_PROVIDER.models[MODEL]).map(([key, value]) => [[
+						"providers",
+						"callstack.ai",
+						"models",
+						MODEL,
+						key
+					], key === "settings" ? {
+						...existing.providers?.["callstack.ai"]?.models?.[MODEL]?.settings,
+						...value
+					} : value])
+				];
 				return [
 					[[
 						"provider",
@@ -2515,18 +2708,22 @@ async function planAssistant(assistant) {
 						"options",
 						"baseURL"
 					], BASE_URL],
-					...storedKey ? [] : [[[
+					...storedKey || existing.provider?.["callstack.ai"]?.options?.apiKey ? [] : [[[
 						"provider",
 						"callstack.ai",
 						"options",
 						"apiKey"
 					], "{env:CALLSTACK_AUTH_TOKEN}"]],
-					[[
+					...Object.entries(OPENCODE_MODEL).map(([key, value]) => [[
 						"provider",
 						"callstack.ai",
 						"models",
-						MODEL
-					], OPENCODE_MODEL]
+						MODEL,
+						key
+					], key === "options" ? {
+						...existing.provider?.["callstack.ai"]?.models?.[MODEL]?.options,
+						...value
+					} : value])
 				];
 			});
 			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."];
@@ -2557,9 +2754,14 @@ async function planAssistant(assistant) {
 						"providers",
 						"callstack",
 						"models"
-					], models.some((model) => model.id === "callstack/Apex") ? models.map((model) => model.id === "callstack/Apex" ? PI_MODEL : model) : [...models, PI_MODEL]]
+					], models.some((model) => model.id === "callstack/Apex") ? models.map((model) => model.id === "callstack/Apex" ? {
+						...model,
+						...PI_MODEL,
+						...model.compat ? { compat: Object.fromEntries(Object.entries(model.compat).filter(([key]) => key !== "reasoningEffortMap")) } : {}
+					} : model) : [...models, PI_MODEL]]
 				];
 			});
+			await json("settings.json", [[["modelThinkingLevels", `callstack/${MODEL}`], "medium"]]);
 			break;
 		case "claude":
 			await json("settings.json", [[["env", "CLAUDE_CODE_ATTRIBUTION_HEADER"], "0"]]);
@@ -2567,7 +2769,7 @@ async function planAssistant(assistant) {
 		case "codex": {
 			const path = join(assistant.directory, "callstack_ai.config.toml");
 			const before = await readConfig(path);
-			const after = addToml(before, {
+			const after = updateToml(before, {
 				model_provider: "callstack_ai",
 				model: MODEL,
 				model_context_window: CONTEXT_WINDOW,
@@ -2579,7 +2781,7 @@ async function planAssistant(assistant) {
 					wire_api: "responses",
 					requires_openai_auth: false
 				} }
-			}, path);
+			}, path, ["model_max_output_tokens", "model_auto_compact_token_limit"]);
 			changes.push({
 				path,
 				before,
@@ -2609,7 +2811,9 @@ function launchOptions(id, env = process.env) {
 				"--provider",
 				"callstack",
 				"--model",
-				MODEL
+				MODEL,
+				"--thinking",
+				"medium"
 			],
 			env: childEnv
 		};
@@ -2629,7 +2833,9 @@ function launchOptions(id, env = process.env) {
 				ANTHROPIC_DEFAULT_OPUS_MODEL: MODEL,
 				ANTHROPIC_DEFAULT_SONNET_MODEL: MODEL,
 				ANTHROPIC_DEFAULT_HAIKU_MODEL: MODEL,
-				CLAUDE_CODE_SUBAGENT_MODEL: MODEL
+				CLAUDE_CODE_SUBAGENT_MODEL: MODEL,
+				CLAUDE_CODE_MAX_CONTEXT_TOKENS: String(CONTEXT_WINDOW),
+				CLAUDE_CODE_MAX_OUTPUT_TOKENS: String(MAX_OUTPUT)
 			});
 			return {
 				args: ["--model", MODEL],
@@ -2663,7 +2869,11 @@ const AI_SDK_SNIPPET = [
 	`  baseURL: '${BASE_URL}',`,
 	"  apiKey: process.env.CALLSTACK_AUTH_TOKEN,",
 	"});",
-	`// apex('${MODEL}') with generateText / streamText.`,
+	"const requestOptions = {",
+	`  model: apex('${MODEL}'),`,
+	`  maxOutputTokens: ${MAX_OUTPUT},`,
+	"};",
+	"// Pass requestOptions with your prompt to generateText / streamText.",
 	`// Reasoning effort (${EFFORTS.join(", ")}):`,
 	"// providerOptions: { callstack: { reasoningEffort: 'medium' } }"
 ];
@@ -2674,11 +2884,7 @@ const MANUAL = {
 		"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.`
-	]
+	"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]
 };
 const MANUAL_IDS = Object.keys(MANUAL);
 
@@ -3657,7 +3863,7 @@ const maskChanges = (changes, secret) => changes.map((change) => ({
 //#region src/diff.js
 function readValues(text, format) {
 	if (format === "toml") try {
-		return parse$1(text);
+		return parseToml(text);
 	} catch {
 		throw new Error("Invalid TOML while reading values.");
 	}