@gabrielbryk/jq-ts 1.3.6 → 1.5.0

package/dist/index.mjs

@@ -41,7 +41,6 @@ var RuntimeError = class extends BaseError {
 		super("runtime", message, span);
 	}
 };
-
 //#endregion
 //#region src/tokens.ts
 const keywordKinds = {
@@ -65,7 +64,6 @@ const keywordKinds = {
 	label: "Label",
 	break: "Break"
 };
-
 //#endregion
 //#region src/lexer.ts
 /**
@@ -379,7 +377,6 @@ const lex = (text) => {
 	}
 };
 const isHexDigit = (ch) => !!ch && (ch >= "0" && ch <= "9" || ch >= "a" && ch <= "f" || ch >= "A" && ch <= "F");
-
 //#endregion
 //#region src/parser.ts
 /**
@@ -446,19 +443,93 @@ var Parser = class {
 		}
 		let expr = this.parsePipe(allowComma);
 		while (this.match("As")) {
-			const varToken = this.consume("Variable", "Expected variable name after \"as\"");
-			this.consume("Pipe", "Expected \"|\" after variable binding");
+			const pattern = this.parseBindingPattern();
+			this.consume("Pipe", "Expected \"|\" after binding pattern");
 			const body = this.parseBinding(allowComma);
 			expr = {
 				kind: "As",
 				bind: expr,
-				name: String(varToken.value),
+				pattern,
 				body,
 				span: spanBetween(expr.span, body.span)
 			};
 		}
 		return expr;
 	}
+	parseBindingPattern() {
+		if (this.match("Variable")) {
+			const token = this.previous();
+			return {
+				kind: "VariablePattern",
+				name: String(token.value),
+				span: token.span
+			};
+		}
+		if (this.match("LBracket")) {
+			const start = this.previous();
+			const items = [];
+			if (!this.match("RBracket")) {
+				do
+					items.push(this.parseBindingPattern());
+				while (this.match("Comma"));
+				this.consume("RBracket", "Expected \"]\" after array binding pattern");
+			}
+			return {
+				kind: "ArrayPattern",
+				items,
+				span: spanBetween(start.span, this.previous().span)
+			};
+		}
+		if (this.match("LBrace")) {
+			const start = this.previous();
+			const entries = [];
+			if (!this.match("RBrace")) {
+				do
+					entries.push(this.parseObjectBindingPatternEntry());
+				while (this.match("Comma"));
+				this.consume("RBrace", "Expected \"}\" after object binding pattern");
+			}
+			return {
+				kind: "ObjectPattern",
+				entries,
+				span: spanBetween(start.span, this.previous().span)
+			};
+		}
+		throw this.error(this.peek(), "Expected variable or destructuring pattern after \"as\"");
+	}
+	parseObjectBindingPatternEntry() {
+		if (this.match("Variable")) {
+			const token = this.previous();
+			const name = String(token.value);
+			return {
+				key: name,
+				pattern: {
+					kind: "VariablePattern",
+					name,
+					span: token.span
+				},
+				span: token.span
+			};
+		}
+		let key;
+		let keySpan;
+		if (this.match("Identifier")) {
+			const token = this.previous();
+			key = String(token.value);
+			keySpan = token.span;
+		} else if (this.match("String")) {
+			const token = this.previous();
+			key = String(token.value);
+			keySpan = token.span;
+		} else throw this.error(this.peek(), "Expected identifier, string, or variable shorthand in object binding pattern");
+		this.consume("Colon", "Expected \":\" after object binding pattern key");
+		const pattern = this.parseBindingPattern();
+		return {
+			key,
+			pattern,
+			span: spanBetween(keySpan, pattern.span)
+		};
+	}
 	parsePipe(allowComma = true) {
 		let expr = this.parseComma(allowComma);
 		while (this.match("Pipe")) {
@@ -692,10 +763,7 @@ var Parser = class {
 				expr = {
 					kind: "Try",
 					body: expr,
-					handler: {
-						kind: "Identity",
-						span: op.span
-					},
+					handler: void 0,
 					span: spanBetween(expr.span, op.span)
 				};
 				continue;
@@ -753,8 +821,8 @@ var Parser = class {
 	parseReduce(start) {
 		const source = this.parsePipe();
 		this.consume("As", "Expected \"as\" after reduce source");
-		const varToken = this.consume("Variable", "Expected variable after \"as\"");
-		this.consume("LParen", "Expected \"(\" after variable");
+		const pattern = this.parseBindingPattern();
+		this.consume("LParen", "Expected \"(\" after binding pattern");
 		const init = this.parseComma();
 		this.consume("Semicolon", "Expected \";\" after init");
 		const update = this.parseComma();
@@ -762,7 +830,7 @@ var Parser = class {
 		return {
 			kind: "Reduce",
 			source,
-			var: String(varToken.value),
+			pattern,
 			init,
 			update,
 			span: spanBetween(start.span, end.span)
@@ -771,8 +839,8 @@ var Parser = class {
 	parseForeach(start) {
 		const source = this.parsePipe();
 		this.consume("As", "Expected \"as\" after foreach source");
-		const varToken = this.consume("Variable", "Expected variable after \"as\"");
-		this.consume("LParen", "Expected \"(\" after variable");
+		const pattern = this.parseBindingPattern();
+		this.consume("LParen", "Expected \"(\" after binding pattern");
 		const init = this.parseComma();
 		this.consume("Semicolon", "Expected \";\" after init");
 		const update = this.parseComma();
@@ -782,7 +850,7 @@ var Parser = class {
 		return {
 			kind: "Foreach",
 			source,
-			var: String(varToken.value),
+			pattern,
 			init,
 			update,
 			extract,
@@ -1004,10 +1072,7 @@ var Parser = class {
 				expr = {
 					kind: "Try",
 					body: expr,
-					handler: {
-						kind: "Identity",
-						span: op.span
-					},
+					handler: void 0,
 					span: spanBetween(expr.span, op.span)
 				};
 				continue;
@@ -1153,7 +1218,6 @@ const spanBetween = (a, b) => ({
 	start: Math.min(a.start, b.start),
 	end: Math.max(a.end, b.end)
 });
-
 //#endregion
 //#region src/builtins/registry.ts
 const builtins = {};
@@ -1164,7 +1228,6 @@ const registerBuiltin = (spec) => {
 const registerBuiltins = (specs) => {
 	for (const spec of specs) registerBuiltin(spec);
 };
-
 //#endregion
 //#region src/value.ts
 /**
@@ -1191,7 +1254,7 @@ const valueEquals = (a, b) => {
 		for (let i = 0; i < a.length; i += 1) if (!valueEquals(a[i], b[i])) return false;
 		return true;
 	}
-	if (isPlainObject(a) && isPlainObject(b)) {
+	if (isPlainObject$1(a) && isPlainObject$1(b)) {
 		const aKeys = Object.keys(a).sort();
 		const bKeys = Object.keys(b).sort();
 		if (aKeys.length !== bKeys.length) return false;
@@ -1228,7 +1291,7 @@ const compareValues = (a, b) => {
 		}
 		return a.length < b.length ? -1 : 1;
 	}
-	if (isPlainObject(a) && isPlainObject(b)) {
+	if (isPlainObject$1(a) && isPlainObject$1(b)) {
 		const aKeys = Object.keys(a).sort();
 		const bKeys = Object.keys(b).sort();
 		const len = Math.min(aKeys.length, bKeys.length);
@@ -1262,7 +1325,7 @@ const typeRank = (value) => {
 * @param value - The value to check.
 * @returns `true` if `value` is a non-null object (and not an array).
 */
-const isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isPlainObject$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 /**
 * Checks if a value is a JSON array.
 *
@@ -1285,7 +1348,6 @@ const describeType = (value) => {
 	if (Array.isArray(value)) return "array";
 	return "object";
 };
-
 //#endregion
 //#region src/builtins/utils.ts
 const emit$1 = (value, span, tracker) => {
@@ -1307,7 +1369,6 @@ const stableStringify = (value) => {
 	if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
 	return `{${Object.keys(value).sort().map((k) => `${JSON.stringify(k)}:${stableStringify(value[k])}`).join(",")}}`;
 };
-
 //#endregion
 //#region src/builtins/std.ts
 const toJqString = (value) => {
@@ -1353,9 +1414,87 @@ const stdBuiltins = [
 			if (typeof input === "string") yield emit$1(Array.from(input).length, span, tracker);
 			else if (Array.isArray(input)) yield emit$1(input.length, span, tracker);
 			else if (input !== null && typeof input === "object") yield emit$1(Object.keys(input).length, span, tracker);
+			else if (typeof input === "number") yield emit$1(Math.abs(input), span, tracker);
 			else throw new RuntimeError(`Cannot take length of ${describeType(input)}`, span);
 		}
 	},
+	{
+		name: "arrays",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (Array.isArray(input)) yield emit$1(input, span, tracker);
+		}
+	},
+	{
+		name: "objects",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (isPlainObject$1(input)) yield emit$1(input, span, tracker);
+		}
+	},
+	{
+		name: "iterables",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (Array.isArray(input) || isPlainObject$1(input)) yield emit$1(input, span, tracker);
+		}
+	},
+	{
+		name: "booleans",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (typeof input === "boolean") yield emit$1(input, span, tracker);
+		}
+	},
+	{
+		name: "numbers",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (typeof input === "number") yield emit$1(input, span, tracker);
+		}
+	},
+	{
+		name: "strings",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (typeof input === "string") yield emit$1(input, span, tracker);
+		}
+	},
+	{
+		name: "nulls",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (input === null) yield emit$1(input, span, tracker);
+		}
+	},
+	{
+		name: "values",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (input !== null) yield emit$1(input, span, tracker);
+		}
+	},
+	{
+		name: "scalars",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (input === null || typeof input !== "object") yield emit$1(input, span, tracker);
+		}
+	},
+	{
+		name: "finites",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (typeof input === "number" && Number.isFinite(input)) yield emit$1(input, span, tracker);
+		}
+	},
+	{
+		name: "normals",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (typeof input === "number" && Number.isFinite(input) && input !== 0) yield emit$1(input, span, tracker);
+		}
+	},
 	{
 		name: "empty",
 		arity: 0,
@@ -1378,7 +1517,7 @@ const stdBuiltins = [
 	{
 		name: "walk",
 		arity: 1,
-		apply: function* (input, args, env, tracker, evaluate$1, span) {
+		apply: function* (input, args, env, tracker, evaluate, span) {
 			const f = args[0];
 			const walkRec = function* (curr) {
 				tracker.step(span);
@@ -1387,7 +1526,7 @@ const stdBuiltins = [
 					const newArr = [];
 					for (const item of curr) for (const walkedItem of walkRec(item)) newArr.push(walkedItem);
 					newStruct = newArr;
-				} else if (isPlainObject(curr)) {
+				} else if (isPlainObject$1(curr)) {
 					const newObj = {};
 					const keys = Object.keys(curr).sort();
 					let objValid = true;
@@ -1408,23 +1547,27 @@ const stdBuiltins = [
 					if (!objValid) return;
 					newStruct = newObj;
 				}
-				yield* evaluate$1(f, newStruct, env, tracker);
+				yield* evaluate(f, newStruct, env, tracker);
 			};
 			yield* walkRec(input);
 		}
 	}
 ];
-
 //#endregion
 //#region src/builtins/errors.ts
 const errorBuiltins = [{
+	name: "error",
+	arity: 0,
+	apply: function* (_input, _args, _env, _tracker, _eval, span) {
+		throw new RuntimeError("null", span);
+	}
+}, {
 	name: "error",
 	arity: 1,
-	apply: function* (input, args, env, tracker, evaluate$1, span) {
-		for (const msg of evaluate$1(args[0], input, env, tracker)) throw new RuntimeError(typeof msg === "string" ? msg : stableStringify(msg), span);
+	apply: function* (input, args, env, tracker, evaluate, span) {
+		for (const msg of evaluate(args[0], input, env, tracker)) throw new RuntimeError(typeof msg === "string" ? msg : stableStringify(msg), span);
 	}
 }];
-
 //#endregion
 //#region src/builtins/strings.ts
 const checkContains = (a, b) => {
@@ -1432,7 +1575,7 @@ const checkContains = (a, b) => {
 	if (typeof a !== typeof b) return false;
 	if (typeof a === "string" && typeof b === "string") return a.includes(b);
 	if (Array.isArray(a) && Array.isArray(b)) return b.every((bItem) => a.some((aItem) => checkContains(aItem, bItem)));
-	if (isPlainObject(a) && isPlainObject(b)) {
+	if (isPlainObject$1(a) && isPlainObject$1(b)) {
 		const keys = Object.keys(b);
 		for (const key of keys) {
 			if (!Object.prototype.hasOwnProperty.call(a, key)) return false;
@@ -1448,9 +1591,9 @@ const stringBuiltins = [
 	{
 		name: "split",
 		arity: 1,
-		apply: function* (input, args, env, tracker, evaluate$1, span) {
+		apply: function* (input, args, env, tracker, evaluate, span) {
 			if (typeof input !== "string") throw new RuntimeError("split input must be a string", span);
-			const sepGen = evaluate$1(args[0], input, env, tracker);
+			const sepGen = evaluate(args[0], input, env, tracker);
 			for (const sep of sepGen) {
 				if (typeof sep !== "string") throw new RuntimeError("split separator must be a string", span);
 				yield emit$1(input.split(sep), span, tracker);
@@ -1460,16 +1603,15 @@ const stringBuiltins = [
 	{
 		name: "join",
 		arity: 1,
-		apply: function* (input, args, env, tracker, evaluate$1, span) {
+		apply: function* (input, args, env, tracker, evaluate, span) {
 			if (!Array.isArray(input)) throw new RuntimeError("join input must be an array", span);
-			const sepGen = evaluate$1(args[0], input, env, tracker);
+			const sepGen = evaluate(args[0], input, env, tracker);
 			for (const sep of sepGen) {
 				if (typeof sep !== "string") throw new RuntimeError("join separator must be a string", span);
 				const parts = [];
-				for (const item of input) {
-					if (typeof item !== "string") throw new RuntimeError(`join expects strings, but got ${describeType(item)}`, span);
-					parts.push(item);
-				}
+				for (const item of input) if (item === null) parts.push("");
+				else if (typeof item === "string" || typeof item === "number" || typeof item === "boolean") parts.push(String(item));
+				else throw new RuntimeError(`join cannot join ${describeType(item)}`, span);
 				yield emit$1(parts.join(sep), span, tracker);
 			}
 		}
@@ -1477,9 +1619,9 @@ const stringBuiltins = [
 	{
 		name: "startswith",
 		arity: 1,
-		apply: function* (input, args, env, tracker, evaluate$1, span) {
+		apply: function* (input, args, env, tracker, evaluate, span) {
 			if (typeof input !== "string") throw new RuntimeError("startswith input must be a string", span);
-			const prefixGen = evaluate$1(args[0], input, env, tracker);
+			const prefixGen = evaluate(args[0], input, env, tracker);
 			for (const prefix of prefixGen) {
 				if (typeof prefix !== "string") throw new RuntimeError("startswith prefix must be a string", span);
 				yield emit$1(input.startsWith(prefix), span, tracker);
@@ -1489,9 +1631,9 @@ const stringBuiltins = [
 	{
 		name: "endswith",
 		arity: 1,
-		apply: function* (input, args, env, tracker, evaluate$1, span) {
+		apply: function* (input, args, env, tracker, evaluate, span) {
 			if (typeof input !== "string") throw new RuntimeError("endswith input must be a string", span);
-			const suffixGen = evaluate$1(args[0], input, env, tracker);
+			const suffixGen = evaluate(args[0], input, env, tracker);
 			for (const suffix of suffixGen) {
 				if (typeof suffix !== "string") throw new RuntimeError("endswith suffix must be a string", span);
 				yield emit$1(input.endsWith(suffix), span, tracker);
@@ -1501,16 +1643,16 @@ const stringBuiltins = [
 	{
 		name: "contains",
 		arity: 1,
-		apply: function* (input, args, env, tracker, evaluate$1, span) {
-			const bGen = evaluate$1(args[0], input, env, tracker);
+		apply: function* (input, args, env, tracker, evaluate, span) {
+			const bGen = evaluate(args[0], input, env, tracker);
 			for (const b of bGen) yield emit$1(checkContains(input, b), span, tracker);
 		}
 	},
 	{
 		name: "index",
 		arity: 1,
-		apply: function* (input, args, env, tracker, evaluate$1, span) {
-			const searchGen = evaluate$1(args[0], input, env, tracker);
+		apply: function* (input, args, env, tracker, evaluate, span) {
+			const searchGen = evaluate(args[0], input, env, tracker);
 			for (const search of searchGen) if (Array.isArray(input)) {
 				let foundIndex = null;
 				for (let i = 0; i < input.length; i++) {
@@ -1532,8 +1674,8 @@ const stringBuiltins = [
 	{
 		name: "rindex",
 		arity: 1,
-		apply: function* (input, args, env, tracker, evaluate$1, span) {
-			const searchGen = evaluate$1(args[0], input, env, tracker);
+		apply: function* (input, args, env, tracker, evaluate, span) {
+			const searchGen = evaluate(args[0], input, env, tracker);
 			for (const search of searchGen) if (Array.isArray(input)) {
 				let foundIndex = null;
 				for (let i = input.length - 1; i >= 0; i--) {
@@ -1555,8 +1697,8 @@ const stringBuiltins = [
 	{
 		name: "indices",
 		arity: 1,
-		apply: function* (input, args, env, tracker, evaluate$1, span) {
-			const searchGen = evaluate$1(args[0], input, env, tracker);
+		apply: function* (input, args, env, tracker, evaluate, span) {
+			const searchGen = evaluate(args[0], input, env, tracker);
 			for (const search of searchGen) {
 				const indices = [];
 				if (Array.isArray(input)) for (let i = 0; i < input.length; i++) {
@@ -1594,6 +1736,14 @@ const stringBuiltins = [
 			yield emit$1(Array.from(input).map((c) => c.codePointAt(0)), span, tracker);
 		}
 	},
+	{
+		name: "utf8bytelength",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (typeof input !== "string") throw new RuntimeError("utf8bytelength expects string", span);
+			yield emit$1(utf8ByteLength(input), span, tracker);
+		}
+	},
 	{
 		name: "implode",
 		arity: 0,
@@ -1610,9 +1760,9 @@ const stringBuiltins = [
 	{
 		name: "ltrimstr",
 		arity: 1,
-		apply: function* (input, args, env, tracker, evaluate$1, span) {
+		apply: function* (input, args, env, tracker, evaluate, span) {
 			if (typeof input !== "string") throw new RuntimeError("ltrimstr expects string", span);
-			const prefixGen = evaluate$1(args[0], input, env, tracker);
+			const prefixGen = evaluate(args[0], input, env, tracker);
 			for (const prefix of prefixGen) {
 				if (typeof prefix !== "string") throw new RuntimeError("ltrimstr prefix must be a string", span);
 				if (input.startsWith(prefix)) yield emit$1(input.slice(prefix.length), span, tracker);
@@ -1621,435 +1771,103 @@ const stringBuiltins = [
 		}
 	},
 	{
-		name: "rtrimstr",
+		name: "trimstr",
 		arity: 1,
-		apply: function* (input, args, env, tracker, evaluate$1, span) {
-			if (typeof input !== "string") throw new RuntimeError("rtrimstr expects string", span);
-			const suffixGen = evaluate$1(args[0], input, env, tracker);
-			for (const suffix of suffixGen) {
-				if (typeof suffix !== "string") throw new RuntimeError("rtrimstr suffix must be a string", span);
-				if (input.endsWith(suffix)) yield emit$1(input.slice(0, input.length - suffix.length), span, tracker);
-				else yield emit$1(input, span, tracker);
+		apply: function* (input, args, env, tracker, evaluate, span) {
+			if (typeof input !== "string") throw new RuntimeError("trimstr expects string", span);
+			for (const trim of evaluate(args[0], input, env, tracker)) {
+				if (typeof trim !== "string") throw new RuntimeError("trimstr argument must be string", span);
+				let result = input;
+				if (result.startsWith(trim)) result = result.slice(trim.length);
+				if (result.endsWith(trim)) result = result.slice(0, result.length - trim.length);
+				yield emit$1(result, span, tracker);
 			}
 		}
 	},
 	{
-		name: "ascii_downcase",
+		name: "trim",
 		arity: 0,
 		apply: function* (input, _args, _env, tracker, _eval, span) {
-			if (typeof input !== "string") throw new RuntimeError("ascii_downcase expects string", span);
-			yield emit$1(input.toLowerCase(), span, tracker);
+			if (typeof input !== "string") throw new RuntimeError("trim expects string", span);
+			yield emit$1(input.trim(), span, tracker);
 		}
 	},
 	{
-		name: "ascii_upcase",
+		name: "ltrim",
 		arity: 0,
 		apply: function* (input, _args, _env, tracker, _eval, span) {
-			if (typeof input !== "string") throw new RuntimeError("ascii_upcase expects string", span);
-			yield emit$1(input.toUpperCase(), span, tracker);
+			if (typeof input !== "string") throw new RuntimeError("ltrim expects string", span);
+			yield emit$1(input.trimStart(), span, tracker);
 		}
-	}
-];
-
-//#endregion
-//#region src/builtins/collections.ts
-function sortStable(arr, compare$1) {
-	return arr.map((item, index) => ({
-		item,
-		index
-	})).sort((a, b) => {
-		const cmp = compare$1(a.item, b.item);
-		return cmp !== 0 ? cmp : a.index - b.index;
-	}).map((p) => p.item);
-}
-const collectionBuiltins = [
+	},
 	{
-		name: "keys",
+		name: "rtrim",
 		arity: 0,
 		apply: function* (input, _args, _env, tracker, _eval, span) {
-			if (Array.isArray(input)) yield emit$1(Array.from({ length: input.length }, (_, i) => i), span, tracker);
-			else if (input !== null && typeof input === "object") yield emit$1(Object.keys(input).sort(), span, tracker);
-			else throw new RuntimeError(`keys expects an array or object`, span);
-		}
-	},
-	{
-		name: "has",
-		arity: 1,
-		apply: function* (input, args, env, tracker, evaluate$1, span) {
-			const keyFilter = args[0];
-			for (const key of evaluate$1(keyFilter, input, env, tracker)) if (Array.isArray(input)) {
-				const idx = ensureIndex(key);
-				yield emit$1(idx !== void 0 && idx >= 0 && idx < input.length, span, tracker);
-			} else if (input !== null && typeof input === "object") {
-				let keyStr;
-				if (typeof key === "string") keyStr = key;
-				else if (typeof key === "number") keyStr = key.toString();
-				else throw new RuntimeError(`has() key must be string or number for object input`, span);
-				yield emit$1(Object.prototype.hasOwnProperty.call(input, keyStr), span, tracker);
-			} else throw new RuntimeError(`has() expects an array or object input`, span);
-		}
-	},
-	{
-		name: "map",
-		arity: 1,
-		apply: function* (input, args, env, tracker, evaluate$1, span) {
-			if (!Array.isArray(input)) throw new RuntimeError("map expects an array", span);
-			const result = [];
-			const filter = args[0];
-			for (const item of input) {
-				tracker.step(span);
-				for (const output of evaluate$1(filter, item, env, tracker)) result.push(output);
-			}
-			yield emit$1(result, span, tracker);
+			if (typeof input !== "string") throw new RuntimeError("rtrim expects string", span);
+			yield emit$1(input.trimEnd(), span, tracker);
 		}
 	},
 	{
-		name: "select",
+		name: "rtrimstr",
 		arity: 1,
-		apply: function* (input, args, env, tracker, evaluate$1, span) {
-			const filter = args[0];
-			for (const res of evaluate$1(filter, input, env, tracker)) if (isTruthy(res)) {
-				yield emit$1(input, span, tracker);
-				return;
+		apply: function* (input, args, env, tracker, evaluate, span) {
+			if (typeof input !== "string") throw new RuntimeError("rtrimstr expects string", span);
+			const suffixGen = evaluate(args[0], input, env, tracker);
+			for (const suffix of suffixGen) {
+				if (typeof suffix !== "string") throw new RuntimeError("rtrimstr suffix must be a string", span);
+				if (input.endsWith(suffix)) yield emit$1(input.slice(0, input.length - suffix.length), span, tracker);
+				else yield emit$1(input, span, tracker);
 			}
 		}
 	},
 	{
-		name: "sort",
+		name: "ascii_downcase",
 		arity: 0,
 		apply: function* (input, _args, _env, tracker, _eval, span) {
-			if (!Array.isArray(input)) throw new RuntimeError("sort expects an array", span);
-			const sorted = sortStable(input, (a, b) => compareValues(a, b));
-			tracker.step(span);
-			yield emit$1(sorted, span, tracker);
-		}
-	},
-	{
-		name: "sort_by",
-		arity: 1,
-		apply: function* (input, args, env, tracker, evaluate$1, span) {
-			if (!Array.isArray(input)) throw new RuntimeError("sort_by expects an array", span);
-			const filter = args[0];
-			const pairs = [];
-			for (const item of input) {
-				tracker.step(span);
-				const keys = Array.from(evaluate$1(filter, item, env, tracker));
-				if (keys.length !== 1) throw new RuntimeError("sort_by key expression must return exactly one value", span);
-				pairs.push({
-					val: item,
-					key: keys[0]
-				});
-			}
-			yield emit$1(sortStable(pairs, (a, b) => compareValues(a.key, b.key)).map((p) => p.val), span, tracker);
+			if (typeof input !== "string") throw new RuntimeError("ascii_downcase expects string", span);
+			yield emit$1(input.replace(/[A-Z]/g, (char) => char.toLowerCase()), span, tracker);
 		}
 	},
 	{
-		name: "unique",
+		name: "ascii_upcase",
 		arity: 0,
 		apply: function* (input, _args, _env, tracker, _eval, span) {
-			if (!Array.isArray(input)) throw new RuntimeError("unique expects an array", span);
-			const seen = [];
-			const result = [];
-			for (const item of input) {
-				tracker.step(span);
-				if (!seen.some((s) => valueEquals(s, item))) {
-					seen.push(item);
-					result.push(item);
-				}
-			}
-			yield emit$1(result, span, tracker);
-		}
-	},
-	{
-		name: "unique_by",
-		arity: 1,
-		apply: function* (input, args, env, tracker, evaluate$1, span) {
-			if (!Array.isArray(input)) throw new RuntimeError("unique_by expects an array", span);
-			const filter = args[0];
-			const seenKeys = [];
-			const result = [];
-			for (const item of input) {
-				tracker.step(span);
-				const keys = Array.from(evaluate$1(filter, item, env, tracker));
-				if (keys.length !== 1) throw new RuntimeError("unique_by key expression must return exactly one value", span);
-				const key = keys[0];
-				if (!seenKeys.some((s) => valueEquals(s, key))) {
-					seenKeys.push(key);
-					result.push(item);
-				}
-			}
-			yield emit$1(result, span, tracker);
+			if (typeof input !== "string") throw new RuntimeError("ascii_upcase expects string", span);
+			yield emit$1(input.replace(/[a-z]/g, (char) => char.toUpperCase()), span, tracker);
 		}
 	},
 	{
-		name: "to_entries",
+		name: "tojson",
 		arity: 0,
 		apply: function* (input, _args, _env, tracker, _eval, span) {
-			if (Array.isArray(input)) yield emit$1(input.map((v, i) => ({
-				key: i,
-				value: v
-			})), span, tracker);
-			else if (input !== null && typeof input === "object") yield emit$1(Object.keys(input).sort().map((k) => ({
-				key: k,
-				value: input[k]
-			})), span, tracker);
-			else throw new RuntimeError("to_entries expects array or object", span);
+			yield emit$1(stableStringify(input), span, tracker);
 		}
 	},
 	{
-		name: "from_entries",
+		name: "fromjson",
 		arity: 0,
 		apply: function* (input, _args, _env, tracker, _eval, span) {
-			if (!Array.isArray(input)) throw new RuntimeError("from_entries expects an array", span);
-			const result = {};
-			for (const item of input) {
-				tracker.step(span);
-				if (item === null || typeof item !== "object" || Array.isArray(item)) throw new RuntimeError("from_entries expects array of objects", span);
-				const obj = item;
-				if (!("key" in obj) || !("value" in obj)) throw new RuntimeError("from_entries items must have \"key\" and \"value\"", span);
-				const key = obj["key"];
-				if (typeof key !== "string") throw new RuntimeError("from_entries object keys must be strings", span);
-				result[key] = obj["value"];
-			}
-			yield emit$1(result, span, tracker);
-		}
-	},
-	{
-		name: "with_entries",
-		arity: 1,
-		apply: function* (input, args, env, tracker, evaluate$1, span) {
-			let entries;
-			if (Array.isArray(input)) entries = input.map((v, i) => ({
-				key: i,
-				value: v
-			}));
-			else if (input !== null && typeof input === "object") entries = Object.keys(input).sort().map((k) => ({
-				key: k,
-				value: input[k]
-			}));
-			else throw new RuntimeError("with_entries expects array or object", span);
-			const transformed = [];
-			const filter = args[0];
-			for (const entry of entries) {
-				tracker.step(span);
-				for (const outVar of evaluate$1(filter, entry, env, tracker)) transformed.push(outVar);
-			}
-			const result = {};
-			for (const item of transformed) {
-				if (item === null || typeof item !== "object" || Array.isArray(item)) throw new RuntimeError("with_entries filter must produce objects", span);
-				const obj = item;
-				if (!("key" in obj) || !("value" in obj)) throw new RuntimeError("with_entries items must have \"key\" and \"value\"", span);
-				const key = obj["key"];
-				if (typeof key !== "string") throw new RuntimeError("with_entries keys must be strings", span);
-				result[key] = obj["value"];
-			}
-			yield emit$1(result, span, tracker);
-		}
-	},
-	{
-		name: "group_by",
-		arity: 1,
-		apply: function* (input, args, env, tracker, evaluate$1, span) {
-			if (!Array.isArray(input)) throw new RuntimeError("group_by expects an array", span);
-			const pairs = [];
-			const filter = args[0];
-			for (const item of input) {
-				tracker.step(span);
-				const keys = Array.from(evaluate$1(filter, item, env, tracker));
-				if (keys.length !== 1) throw new RuntimeError("group_by key expression must return exactly one value", span);
-				pairs.push({
-					val: item,
-					key: keys[0]
-				});
-			}
-			const sorted = sortStable(pairs, (a, b) => compareValues(a.key, b.key));
-			const groups = [];
-			if (sorted.length > 0) {
-				let currentGroup = [sorted[0].val];
-				let currentKey = sorted[0].key;
-				for (let i = 1; i < sorted.length; i++) {
-					const pair = sorted[i];
-					if (compareValues(pair.key, currentKey) === 0) currentGroup.push(pair.val);
-					else {
-						groups.push(currentGroup);
-						currentGroup = [pair.val];
-						currentKey = pair.key;
-					}
-				}
-				groups.push(currentGroup);
-			}
-			yield emit$1(groups, span, tracker);
-		}
-	},
-	{
-		name: "reverse",
-		arity: 0,
-		apply: function* (input, _args, _env, tracker, _eval, span) {
-			if (!Array.isArray(input)) throw new RuntimeError("reverse expects an array", span);
-			yield emit$1([...input].reverse(), span, tracker);
-		}
-	},
-	{
-		name: "flatten",
-		arity: 0,
-		apply: function* (input, _args, _env, tracker, _eval, span) {
-			if (!Array.isArray(input)) throw new RuntimeError("flatten expects an array", span);
-			const flattenRec = (arr) => {
-				let res = [];
-				for (const item of arr) if (Array.isArray(item)) res = res.concat(flattenRec(item));
-				else res.push(item);
-				return res;
-			};
-			yield emit$1(flattenRec(input), span, tracker);
-		}
-	},
-	{
-		name: "flatten",
-		arity: 1,
-		apply: function* (input, args, env, tracker, evaluate$1, span) {
-			if (!Array.isArray(input)) throw new RuntimeError("flatten expects an array", span);
-			const depths = evaluate$1(args[0], input, env, tracker);
-			for (const depthVal of depths) {
-				if (typeof depthVal !== "number") throw new RuntimeError("flatten depth must be a number", span);
-				const flattenDepth = (arr, d) => {
-					if (d <= 0) return arr;
-					let res = [];
-					for (const item of arr) if (Array.isArray(item)) res = res.concat(flattenDepth(item, d - 1));
-					else res.push(item);
-					return res;
-				};
-				yield emit$1(flattenDepth(input, depthVal), span, tracker);
-			}
-		}
-	},
-	{
-		name: "keys_unsorted",
-		arity: 0,
-		apply: function* (input, _args, _env, tracker, _eval, span) {
-			if (Array.isArray(input)) yield emit$1(Array.from({ length: input.length }, (_, i) => i), span, tracker);
-			else if (input !== null && typeof input === "object") yield emit$1(Object.keys(input), span, tracker);
-			else throw new RuntimeError(`keys_unsorted expects an array or object`, span);
-		}
-	},
-	{
-		name: "transpose",
-		arity: 0,
-		apply: function* (input, _args, _env, tracker, _eval, span) {
-			if (!Array.isArray(input)) throw new RuntimeError("transpose expects an array", span);
-			const arr = input;
-			if (arr.length === 0) {
-				yield emit$1([], span, tracker);
-				return;
-			}
-			let maxLen = 0;
-			for (const row of arr) {
-				if (!Array.isArray(row)) throw new RuntimeError("transpose input must be array of arrays", span);
-				if (row.length > maxLen) maxLen = row.length;
-			}
-			const result = [];
-			for (let j = 0; j < maxLen; j++) {
-				const newRow = [];
-				for (let i = 0; i < arr.length; i++) {
-					const row = arr[i];
-					const val = j < row.length ? row[j] : null;
-					newRow.push(val);
-				}
-				result.push(newRow);
-			}
-			yield emit$1(result, span, tracker);
-		}
-	},
-	{
-		name: "bsearch",
-		arity: 1,
-		apply: function* (input, args, env, tracker, evaluate$1, span) {
-			if (!Array.isArray(input)) throw new RuntimeError("bsearch expects an array", span);
-			const targetGen = evaluate$1(args[0], input, env, tracker);
-			for (const target of targetGen) {
-				let low = 0;
-				let high = input.length - 1;
-				let idx = -1;
-				while (low <= high) {
-					const mid = Math.floor((low + high) / 2);
-					const cmp = compareValues(input[mid], target);
-					if (cmp === 0) {
-						idx = mid;
-						break;
-					} else if (cmp < 0) low = mid + 1;
-					else high = mid - 1;
-				}
-				if (idx !== -1) yield emit$1(idx, span, tracker);
-				else yield emit$1(-low - 1, span, tracker);
-			}
-		}
-	},
-	{
-		name: "combinations",
-		arity: 0,
-		apply: function* (input, _args, _env, tracker, _eval, span) {
-			if (!Array.isArray(input)) throw new RuntimeError("combinations expects an array", span);
-			if (input.some((x) => !Array.isArray(x))) throw new RuntimeError("combinations input must be array of arrays", span);
-			const arrays = input;
-			if (arrays.length === 0) {
-				yield emit$1([], span, tracker);
-				return;
-			}
-			const helper = function* (idx, current) {
-				if (idx === arrays.length) {
-					yield [...current];
-					return;
-				}
-				const arr = arrays[idx];
-				if (arr.length === 0) return;
-				for (const item of arr) {
-					current.push(item);
-					yield* helper(idx + 1, current);
-					current.pop();
-				}
-			};
-			for (const combo of helper(0, [])) yield emit$1(combo, span, tracker);
-		}
-	},
-	{
-		name: "combinations",
-		arity: 1,
-		apply: function* (input, args, env, tracker, evaluate$1, span) {
-			if (!Array.isArray(input)) throw new RuntimeError("combinations expects an array", span);
-			const nGen = evaluate$1(args[0], input, env, tracker);
-			for (const nVal of nGen) {
-				if (typeof nVal !== "number") throw new RuntimeError("combinations(n) expects n to be number", span);
-				if (nVal === 0) {
-					yield emit$1([], span, tracker);
-					continue;
-				}
-				const arrays = [];
-				for (let i = 0; i < nVal; i++) arrays.push(input);
-				const helper = function* (idx, current) {
-					if (idx === arrays.length) {
-						yield [...current];
-						return;
-					}
-					const arr = arrays[idx];
-					for (const item of arr) {
-						current.push(item);
-						yield* helper(idx + 1, current);
-						current.pop();
-					}
-				};
-				if (input.length === 0 && nVal > 0) {} else for (const combo of helper(0, [])) yield emit$1(combo, span, tracker);
+			if (typeof input !== "string") throw new RuntimeError("fromjson expects string", span);
+			try {
+				yield emit$1(JSON.parse(input), span, tracker);
+			} catch {
+				throw new RuntimeError("fromjson could not parse JSON", span);
 			}
 		}
-	},
-	{
-		name: "inside",
-		arity: 1,
-		apply: function* (input, args, env, tracker, evaluate$1, span) {
-			const bGen = evaluate$1(args[0], input, env, tracker);
-			for (const b of bGen) yield emit$1(checkContains(b, input), span, tracker);
-		}
 	}
 ];
-
+const utf8ByteLength = (input) => {
+	let length = 0;
+	for (const char of input) {
+		const codePoint = char.codePointAt(0);
+		if (codePoint <= 127) length += 1;
+		else if (codePoint <= 2047) length += 2;
+		else if (codePoint <= 65535) length += 3;
+		else length += 4;
+	}
+	return length;
+};
 //#endregion
 //#region src/eval/path_eval.ts
 /**
@@ -2062,17 +1880,17 @@ const collectionBuiltins = [
 * @param tracker - Limits tracker.
 * @param evaluate - Recursive evaluator.
 */
-const evaluatePath = function* (node, input, env, tracker, evaluate$1) {
+const evaluatePath = function* (node, input, env, tracker, evaluate) {
 	switch (node.kind) {
 		case "Identity":
 			yield [];
 			return;
 		case "FieldAccess":
-			for (const parent of evaluatePath(node.target, input, env, tracker, evaluate$1)) yield [...parent, node.field];
+			for (const parent of evaluatePath(node.target, input, env, tracker, evaluate)) yield [...parent, node.field];
 			return;
 		case "IndexAccess": {
-			const parentPaths = Array.from(evaluatePath(node.target, input, env, tracker, evaluate$1));
-			const output = evaluate$1(node.index, input, env, tracker);
+			const parentPaths = Array.from(evaluatePath(node.target, input, env, tracker, evaluate));
+			const output = evaluate(node.index, input, env, tracker);
 			for (const keyVal of output) {
 				let key;
 				if (typeof keyVal === "string") key = keyVal;
@@ -2083,19 +1901,19 @@ const evaluatePath = function* (node, input, env, tracker, evaluate$1) {
 			return;
 		}
 		case "Pipe": {
-			const leftPaths = Array.from(evaluatePath(node.left, input, env, tracker, evaluate$1));
+			const leftPaths = Array.from(evaluatePath(node.left, input, env, tracker, evaluate));
 			for (const p of leftPaths) {
 				const val = getPath(input, p) ?? null;
-				for (const q of evaluatePath(node.right, val, env, tracker, evaluate$1)) yield [...p, ...q];
+				for (const q of evaluatePath(node.right, val, env, tracker, evaluate)) yield [...p, ...q];
 			}
 			return;
 		}
 		case "Comma":
-			yield* evaluatePath(node.left, input, env, tracker, evaluate$1);
-			yield* evaluatePath(node.right, input, env, tracker, evaluate$1);
+			yield* evaluatePath(node.left, input, env, tracker, evaluate);
+			yield* evaluatePath(node.right, input, env, tracker, evaluate);
 			return;
 		case "Iterate": {
-			const parentPaths = Array.from(evaluatePath(node.target, input, env, tracker, evaluate$1));
+			const parentPaths = Array.from(evaluatePath(node.target, input, env, tracker, evaluate));
 			for (const p of parentPaths) {
 				const val = getPath(input, p);
 				if (Array.isArray(val)) for (let i = 0; i < val.length; i++) yield [...p, i];
@@ -2109,7 +1927,7 @@ const evaluatePath = function* (node, input, env, tracker, evaluate$1) {
 		}
 		case "Call":
 			if (node.name === "select") {
-				const conds = evaluate$1(node.args[0], input, env, tracker);
+				const conds = evaluate(node.args[0], input, env, tracker);
 				let matched = false;
 				for (const c of conds) if (c !== null && c !== false) matched = true;
 				if (matched) yield [];
@@ -2117,9 +1935,9 @@ const evaluatePath = function* (node, input, env, tracker, evaluate$1) {
 			}
 			throw new RuntimeError(`Function ${node.name} not supported in path expression`, node.span);
 		case "Slice": {
-			const parentPaths = Array.from(evaluatePath(node.target, input, env, tracker, evaluate$1));
-			const startRes = node.start ? Array.from(evaluate$1(node.start, input, env, tracker)) : [null];
-			const endRes = node.end ? Array.from(evaluate$1(node.end, input, env, tracker)) : [null];
+			const parentPaths = Array.from(evaluatePath(node.target, input, env, tracker, evaluate));
+			const startRes = node.start ? Array.from(evaluate(node.start, input, env, tracker)) : [null];
+			const endRes = node.end ? Array.from(evaluate(node.end, input, env, tracker)) : [null];
 			for (const startVal of startRes) for (const endVal of endRes) {
 				const sliceSpec = {
 					start: typeof startVal === "number" ? startVal : null,
@@ -2131,7 +1949,7 @@ const evaluatePath = function* (node, input, env, tracker, evaluate$1) {
 		}
 		case "Try":
 			try {
-				yield* evaluatePath(node.body, input, env, tracker, evaluate$1);
+				yield* evaluatePath(node.body, input, env, tracker, evaluate);
 			} catch (e) {
 				if (!(e instanceof RuntimeError)) throw e;
 			}
@@ -2142,24 +1960,27 @@ const evaluatePath = function* (node, input, env, tracker, evaluate$1) {
 		default: throw new RuntimeError("Invalid path expression", node.span);
 	}
 };
-
 //#endregion
 //#region src/builtins/paths.ts
 function* traversePaths(root, currentPath, span, tracker) {
 	tracker.step(span);
-	if (root === null || typeof root !== "object" || Array.isArray(root) && root.length === 0 || isPlainObject(root) && Object.keys(root).length === 0) {
-		yield emit$1([...currentPath], span, tracker);
-		return;
+	if (Array.isArray(root)) for (let i = 0; i < root.length; i++) {
+		const path = [...currentPath, i];
+		yield emit$1(path, span, tracker);
+		yield* traversePaths(root[i], path, span, tracker);
 	}
-	if (Array.isArray(root)) for (let i = 0; i < root.length; i++) yield* traversePaths(root[i], [...currentPath, i], span, tracker);
-	else if (isPlainObject(root)) {
+	else if (isPlainObject$1(root)) {
 		const keys = Object.keys(root).sort();
-		for (const key of keys) yield* traversePaths(root[key], [...currentPath, key], span, tracker);
+		for (const key of keys) {
+			const path = [...currentPath, key];
+			yield emit$1(path, span, tracker);
+			yield* traversePaths(root[key], path, span, tracker);
+		}
 	}
 }
 const isPath = (val) => {
 	if (!Array.isArray(val)) return false;
-	return val.every((p) => typeof p === "string" || typeof p === "number" && Number.isInteger(p) || isPlainObject(p) && ("start" in p || "end" in p));
+	return val.every((p) => typeof p === "string" || typeof p === "number" && Number.isInteger(p) || isPlainObject$1(p) && ("start" in p || "end" in p));
 };
 const ensurePath = (val, span) => {
 	if (isPath(val)) return val;
@@ -2169,7 +1990,7 @@ const getPath = (root, path) => {
 	let curr = root;
 	for (const part of path) {
 		if (curr === null) return void 0;
-		if (typeof part === "string" && isPlainObject(curr)) {
+		if (typeof part === "string" && isPlainObject$1(curr)) {
 			if (!Object.prototype.hasOwnProperty.call(curr, part)) return void 0;
 			curr = curr[part];
 		} else if (typeof part === "number" && Array.isArray(curr)) {
@@ -2184,7 +2005,7 @@ const updatePath = (root, path, updateFn, span, depth = 0) => {
 	const [head, ...tail] = path;
 	if (typeof head === "string") {
 		let obj = {};
-		if (isPlainObject(root)) obj = { ...root };
+		if (isPlainObject$1(root)) obj = { ...root };
 		else if (root === null) obj = {};
 		else throw new RuntimeError(`Cannot index ${describeType(root)} with string "${head}"`, span);
 		const newVal = updatePath((Object.prototype.hasOwnProperty.call(obj, head) ? obj[head] : void 0) ?? null, tail, updateFn, span, depth + 1);
@@ -2224,7 +2045,7 @@ const updatePath = (root, path, updateFn, span, depth = 0) => {
 };
 const deletePaths = (root, paths, span) => {
 	if (paths.some((p) => p.length === 0)) return null;
-	if (isPlainObject(root)) {
+	if (isPlainObject$1(root)) {
 		const result = { ...root };
 		const relevantPaths = paths.filter((p) => p.length > 0 && typeof p[0] === "string");
 		const byKey = {};
@@ -2269,19 +2090,35 @@ const pathBuiltins = [
 			yield* traversePaths(input, [], span, tracker);
 		}
 	},
+	{
+		name: "paths",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate, span) {
+			for (const pathVal of traversePaths(input, [], span, tracker)) {
+				const path = ensurePath(pathVal, span);
+				const value = getPath(input, path) ?? null;
+				let matched = false;
+				for (const result of evaluate(args[0], value, env, tracker)) if (result !== null && result !== false) {
+					matched = true;
+					break;
+				}
+				if (matched) yield emit$1(path, span, tracker);
+			}
+		}
+	},
 	{
 		name: "getpath",
 		arity: 1,
-		apply: function* (input, args, env, tracker, evaluate$1, span) {
-			for (const pathVal of evaluate$1(args[0], input, env, tracker)) yield emit$1(getPath(input, ensurePath(pathVal, span)) ?? null, span, tracker);
+		apply: function* (input, args, env, tracker, evaluate, span) {
+			for (const pathVal of evaluate(args[0], input, env, tracker)) yield emit$1(getPath(input, ensurePath(pathVal, span)) ?? null, span, tracker);
 		}
 	},
 	{
 		name: "setpath",
 		arity: 2,
-		apply: function* (input, args, env, tracker, evaluate$1, span) {
-			const paths = Array.from(evaluate$1(args[0], input, env, tracker));
-			const values = Array.from(evaluate$1(args[1], input, env, tracker));
+		apply: function* (input, args, env, tracker, evaluate, span) {
+			const paths = Array.from(evaluate(args[0], input, env, tracker));
+			const values = Array.from(evaluate(args[1], input, env, tracker));
 			for (const pathVal of paths) {
 				const path = ensurePath(pathVal, span);
 				for (const val of values) yield emit$1(updatePath(input, path, () => val, span) ?? null, span, tracker);
@@ -2291,8 +2128,8 @@ const pathBuiltins = [
 	{
 		name: "delpaths",
 		arity: 1,
-		apply: function* (input, args, env, tracker, evaluate$1, span) {
-			for (const pathsVal of evaluate$1(args[0], input, env, tracker)) {
+		apply: function* (input, args, env, tracker, evaluate, span) {
+			for (const pathsVal of evaluate(args[0], input, env, tracker)) {
 				if (!Array.isArray(pathsVal)) throw new RuntimeError("delpaths expects an array of paths", span);
 				yield emit$1(deletePaths(input, pathsVal.map((p) => ensurePath(p, span)), span), span, tracker);
 			}
@@ -2301,210 +2138,821 @@ const pathBuiltins = [
 	{
 		name: "path",
 		arity: 1,
-		apply: function* (input, args, env, tracker, evaluate$1, span) {
-			for (const p of evaluatePath(args[0], input, env, tracker, evaluate$1)) yield emit$1(p, span, tracker);
+		apply: function* (input, args, env, tracker, evaluate, span) {
+			for (const p of evaluatePath(args[0], input, env, tracker, evaluate)) yield emit$1(p, span, tracker);
 		}
 	}
 ];
-
 //#endregion
-//#region src/builtins/iterators.ts
-const iteratorBuiltins = [
+//#region src/builtins/collections.ts
+function sortStable(arr, compare) {
+	return arr.map((item, index) => ({
+		item,
+		index
+	})).sort((a, b) => {
+		const cmp = compare(a.item, b.item);
+		return cmp !== 0 ? cmp : a.index - b.index;
+	}).map((p) => p.item);
+}
+const collectionBuiltins = [
 	{
-		name: "range",
-		arity: 1,
-		apply: function* (input, args, env, tracker, evaluate$1, span) {
-			const ends = evaluate$1(args[0], input, env, tracker);
-			for (const end of ends) {
-				if (typeof end !== "number") throw new RuntimeError("range expects numbers", span);
-				for (let i = 0; i < end; i++) yield emit$1(i, span, tracker);
-			}
+		name: "keys",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (Array.isArray(input)) yield emit$1(Array.from({ length: input.length }, (_, i) => i), span, tracker);
+			else if (input !== null && typeof input === "object") yield emit$1(Object.keys(input).sort(), span, tracker);
+			else throw new RuntimeError(`keys expects an array or object`, span);
 		}
 	},
 	{
-		name: "range",
-		arity: 2,
-		apply: function* (input, args, env, tracker, evaluate$1, span) {
-			const starts = Array.from(evaluate$1(args[0], input, env, tracker));
-			const ends = Array.from(evaluate$1(args[1], input, env, tracker));
-			for (const start of starts) for (const end of ends) {
-				if (typeof start !== "number" || typeof end !== "number") throw new RuntimeError("range expects numbers", span);
-				if (start < end) for (let i = start; i < end; i++) yield emit$1(i, span, tracker);
-			}
+		name: "has",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate, span) {
+			const keyFilter = args[0];
+			for (const key of evaluate(keyFilter, input, env, tracker)) if (Array.isArray(input)) {
+				const idx = ensureIndex(key);
+				yield emit$1(idx !== void 0 && idx >= 0 && idx < input.length, span, tracker);
+			} else if (input !== null && typeof input === "object") {
+				let keyStr;
+				if (typeof key === "string") keyStr = key;
+				else if (typeof key === "number") keyStr = key.toString();
+				else throw new RuntimeError(`has() key must be string or number for object input`, span);
+				yield emit$1(Object.prototype.hasOwnProperty.call(input, keyStr), span, tracker);
+			} else throw new RuntimeError(`has() expects an array or object input`, span);
 		}
 	},
 	{
-		name: "range",
-		arity: 3,
-		apply: function* (input, args, env, tracker, evaluate$1, span) {
-			const starts = Array.from(evaluate$1(args[0], input, env, tracker));
-			const ends = Array.from(evaluate$1(args[1], input, env, tracker));
-			const steps = Array.from(evaluate$1(args[2], input, env, tracker));
-			for (const start of starts) for (const end of ends) for (const step of steps) {
-				if (typeof start !== "number" || typeof end !== "number" || typeof step !== "number") throw new RuntimeError("range expects numbers", span);
-				if (step === 0) throw new RuntimeError("range step cannot be zero", span);
-				if (step > 0) for (let i = start; i < end; i += step) yield emit$1(i, span, tracker);
-				else for (let i = start; i > end; i += step) yield emit$1(i, span, tracker);
+		name: "map",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate, span) {
+			if (!Array.isArray(input)) throw new RuntimeError("map expects an array", span);
+			const result = [];
+			const filter = args[0];
+			for (const item of input) {
+				tracker.step(span);
+				for (const output of evaluate(filter, item, env, tracker)) result.push(output);
 			}
+			yield emit$1(result, span, tracker);
 		}
 	},
 	{
-		name: "limit",
-		arity: 2,
-		apply: function* (input, args, env, tracker, evaluate$1, span) {
-			const limits = evaluate$1(args[0], input, env, tracker);
-			for (const n of limits) {
-				if (typeof n !== "number") throw new RuntimeError("limit expects number", span);
-				let count = 0;
-				if (n > 0) for (const val of evaluate$1(args[1], input, env, tracker)) {
-					yield val;
-					count++;
-					if (count >= n) break;
+		name: "map_values",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate, span) {
+			const filter = args[0];
+			if (Array.isArray(input)) {
+				const result = [];
+				for (const item of input) {
+					tracker.step(span);
+					for (const output of evaluate(filter, item, env, tracker)) result.push(output);
 				}
+				yield emit$1(result, span, tracker);
+				return;
 			}
-		}
-	},
-	{
-		name: "first",
-		arity: 1,
-		apply: function* (input, args, env, tracker, evaluate$1) {
-			for (const val of evaluate$1(args[0], input, env, tracker)) {
-				yield val;
-				break;
+			if (input !== null && typeof input === "object") {
+				const result = {};
+				for (const key of Object.keys(input)) {
+					tracker.step(span);
+					let last;
+					let found = false;
+					for (const output of evaluate(filter, input[key], env, tracker)) {
+						last = output;
+						found = true;
+					}
+					if (found) result[key] = last;
+				}
+				yield emit$1(result, span, tracker);
+				return;
 			}
+			throw new RuntimeError("map_values expects an array or object", span);
 		}
 	},
 	{
-		name: "last",
+		name: "select",
 		arity: 1,
-		apply: function* (input, args, env, tracker, evaluate$1) {
-			let lastVal;
-			let found = false;
-			for (const val of evaluate$1(args[0], input, env, tracker)) {
-				lastVal = val;
-				found = true;
+		apply: function* (input, args, env, tracker, evaluate, span) {
+			const filter = args[0];
+			for (const res of evaluate(filter, input, env, tracker)) if (isTruthy(res)) {
+				yield emit$1(input, span, tracker);
+				return;
 			}
-			if (found) yield lastVal;
 		}
 	},
 	{
-		name: "nth",
-		arity: 2,
-		apply: function* (input, args, env, tracker, evaluate$1, span) {
-			const indices = evaluate$1(args[0], input, env, tracker);
-			for (const n of indices) {
-				if (typeof n !== "number") throw new RuntimeError("nth expects number", span);
-				let count = 0;
-				for (const val of evaluate$1(args[1], input, env, tracker)) {
-					if (count === n) {
-						yield val;
-						break;
-					}
-					count++;
-				}
-			}
+		name: "sort",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (!Array.isArray(input)) throw new RuntimeError("sort expects an array", span);
+			const sorted = sortStable(input, (a, b) => compareValues(a, b));
+			tracker.step(span);
+			yield emit$1(sorted, span, tracker);
 		}
 	},
 	{
-		name: "isempty",
+		name: "sort_by",
 		arity: 1,
-		apply: function* (input, args, env, tracker, evaluate$1, span) {
-			let empty = true;
-			for (const _ of evaluate$1(args[0], input, env, tracker)) {
-				empty = false;
-				break;
+		apply: function* (input, args, env, tracker, evaluate, span) {
+			if (!Array.isArray(input)) throw new RuntimeError("sort_by expects an array", span);
+			const filter = args[0];
+			const pairs = [];
+			for (const item of input) {
+				tracker.step(span);
+				const keys = Array.from(evaluate(filter, item, env, tracker));
+				if (keys.length !== 1) throw new RuntimeError("sort_by key expression must return exactly one value", span);
+				pairs.push({
+					val: item,
+					key: keys[0]
+				});
 			}
-			yield emit$1(empty, span, tracker);
+			yield emit$1(sortStable(pairs, (a, b) => compareValues(a.key, b.key)).map((p) => p.val), span, tracker);
 		}
 	},
 	{
-		name: "all",
-		arity: 1,
-		apply: function* (input, args, env, tracker, evaluate$1, span) {
-			let result = true;
-			for (const val of evaluate$1(args[0], input, env, tracker)) if (!isTruthy(val)) {
-				result = false;
-				break;
+		name: "unique",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (!Array.isArray(input)) throw new RuntimeError("unique expects an array", span);
+			const seen = [];
+			const result = [];
+			for (const item of input) {
+				tracker.step(span);
+				if (!seen.some((s) => valueEquals(s, item))) {
+					seen.push(item);
+					result.push(item);
+				}
 			}
 			yield emit$1(result, span, tracker);
 		}
 	},
 	{
-		name: "any",
+		name: "unique_by",
 		arity: 1,
-		apply: function* (input, args, env, tracker, evaluate$1, span) {
-			let result = false;
-			for (const val of evaluate$1(args[0], input, env, tracker)) if (isTruthy(val)) {
-				result = true;
-				break;
+		apply: function* (input, args, env, tracker, evaluate, span) {
+			if (!Array.isArray(input)) throw new RuntimeError("unique_by expects an array", span);
+			const filter = args[0];
+			const seenKeys = [];
+			const result = [];
+			for (const item of input) {
+				tracker.step(span);
+				const keys = Array.from(evaluate(filter, item, env, tracker));
+				if (keys.length !== 1) throw new RuntimeError("unique_by key expression must return exactly one value", span);
+				const key = keys[0];
+				if (!seenKeys.some((s) => valueEquals(s, key))) {
+					seenKeys.push(key);
+					result.push(item);
+				}
 			}
 			yield emit$1(result, span, tracker);
 		}
 	},
 	{
-		name: "recurse",
-		arity: 1,
-		apply: function* (input, args, env, tracker, evaluate$1, span) {
-			const rec = function* (curr) {
-				yield emit$1(curr, span, tracker);
-				const nexts = evaluate$1(args[0], curr, env, tracker);
-				for (const next of nexts) yield* rec(next);
-			};
-			yield* rec(input);
+		name: "to_entries",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (Array.isArray(input)) yield emit$1(input.map((v, i) => ({
+				key: i,
+				value: v
+			})), span, tracker);
+			else if (input !== null && typeof input === "object") yield emit$1(Object.keys(input).sort().map((k) => ({
+				key: k,
+				value: input[k]
+			})), span, tracker);
+			else throw new RuntimeError("to_entries expects array or object", span);
 		}
 	},
 	{
-		name: "while",
-		arity: 2,
-		apply: function* (input, args, env, tracker, evaluate$1, span) {
-			const condExpr = args[0];
-			const updateExpr = args[1];
-			const rec = function* (curr) {
+		name: "from_entries",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (!Array.isArray(input)) throw new RuntimeError("from_entries expects an array", span);
+			const result = {};
+			for (const item of input) {
 				tracker.step(span);
-				let condMatches = false;
-				for (const c of evaluate$1(condExpr, curr, env, tracker)) if (isTruthy(c)) {
-					condMatches = true;
-					break;
-				}
-				if (condMatches) {
-					yield emit$1(curr, span, tracker);
-					for (const next of evaluate$1(updateExpr, curr, env, tracker)) yield* rec(next);
-				}
-			};
-			yield* rec(input);
+				if (item === null || typeof item !== "object" || Array.isArray(item)) throw new RuntimeError("from_entries expects array of objects", span);
+				const obj = item;
+				const key = getEntryField(obj, [
+					"key",
+					"Key",
+					"name",
+					"Name"
+				]);
+				const value = getEntryField(obj, ["value", "Value"]);
+				if (key === void 0 || value === void 0) throw new RuntimeError("from_entries items must have key/name and value fields", span);
+				if (typeof key !== "string") throw new RuntimeError("from_entries object keys must be strings", span);
+				result[key] = value;
+			}
+			yield emit$1(result, span, tracker);
 		}
 	},
 	{
-		name: "until",
-		arity: 2,
-		apply: function* (input, args, env, tracker, evaluate$1, span) {
-			const condExpr = args[0];
-			const updateExpr = args[1];
-			const rec = function* (curr) {
+		name: "with_entries",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate, span) {
+			let entries;
+			if (Array.isArray(input)) entries = input.map((v, i) => ({
+				key: i,
+				value: v
+			}));
+			else if (input !== null && typeof input === "object") entries = Object.keys(input).sort().map((k) => ({
+				key: k,
+				value: input[k]
+			}));
+			else throw new RuntimeError("with_entries expects array or object", span);
+			const transformed = [];
+			const filter = args[0];
+			for (const entry of entries) {
 				tracker.step(span);
-				let condMatches = false;
-				for (const c of evaluate$1(condExpr, curr, env, tracker)) if (isTruthy(c)) {
-					condMatches = true;
-					break;
-				}
-				if (condMatches) yield emit$1(curr, span, tracker);
-				else for (const next of evaluate$1(updateExpr, curr, env, tracker)) yield* rec(next);
-			};
-			yield* rec(input);
+				for (const outVar of evaluate(filter, entry, env, tracker)) transformed.push(outVar);
+			}
+			const result = {};
+			for (const item of transformed) {
+				if (item === null || typeof item !== "object" || Array.isArray(item)) throw new RuntimeError("with_entries filter must produce objects", span);
+				const obj = item;
+				if (!("key" in obj) || !("value" in obj)) throw new RuntimeError("with_entries items must have \"key\" and \"value\"", span);
+				const key = obj["key"];
+				if (typeof key !== "string") throw new RuntimeError("with_entries keys must be strings", span);
+				result[key] = obj["value"];
+			}
+			yield emit$1(result, span, tracker);
 		}
 	},
 	{
-		name: "repeat",
+		name: "group_by",
 		arity: 1,
-		apply: function* (input, args, env, tracker, evaluate$1, span) {
-			while (true) {
+		apply: function* (input, args, env, tracker, evaluate, span) {
+			if (!Array.isArray(input)) throw new RuntimeError("group_by expects an array", span);
+			const pairs = [];
+			const filter = args[0];
+			for (const item of input) {
 				tracker.step(span);
-				yield* evaluate$1(args[0], input, env, tracker);
+				const keys = Array.from(evaluate(filter, item, env, tracker));
+				if (keys.length !== 1) throw new RuntimeError("group_by key expression must return exactly one value", span);
+				pairs.push({
+					val: item,
+					key: keys[0]
+				});
+			}
+			const sorted = sortStable(pairs, (a, b) => compareValues(a.key, b.key));
+			const groups = [];
+			if (sorted.length > 0) {
+				let currentGroup = [sorted[0].val];
+				let currentKey = sorted[0].key;
+				for (let i = 1; i < sorted.length; i++) {
+					const pair = sorted[i];
+					if (compareValues(pair.key, currentKey) === 0) currentGroup.push(pair.val);
+					else {
+						groups.push(currentGroup);
+						currentGroup = [pair.val];
+						currentKey = pair.key;
+					}
+				}
+				groups.push(currentGroup);
 			}
+			yield emit$1(groups, span, tracker);
 		}
-	}
+	},
+	{
+		name: "reverse",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (!Array.isArray(input)) throw new RuntimeError("reverse expects an array", span);
+			yield emit$1([...input].reverse(), span, tracker);
+		}
+	},
+	{
+		name: "in",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate, span) {
+			for (const container of evaluate(args[0], input, env, tracker)) {
+				if (Array.isArray(container)) {
+					if (typeof input !== "number") throw new RuntimeError(`Cannot check whether array has a ${typeof input} key`, span);
+					const idx = ensureIndex(input);
+					yield emit$1(idx !== void 0 && idx >= 0 && idx < container.length, span, tracker);
+					continue;
+				}
+				if (container !== null && typeof container === "object") {
+					if (typeof input !== "string") throw new RuntimeError(`Cannot check whether object has a ${typeof input} key`, span);
+					yield emit$1(Object.prototype.hasOwnProperty.call(container, input), span, tracker);
+					continue;
+				}
+				throw new RuntimeError("in expects an array or object argument", span);
+			}
+		}
+	},
+	{
+		name: "del",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate, span) {
+			yield emit$1(deletePaths(input, Array.from(evaluatePath(args[0], input, env, tracker, evaluate)), span), span, tracker);
+		}
+	},
+	{
+		name: "pick",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate, span) {
+			const paths = Array.from(evaluatePath(args[0], input, env, tracker, evaluate));
+			let result = null;
+			for (const path of paths) {
+				const value = getPath(input, path);
+				result = updatePath(result, path, () => value ?? null, span) ?? null;
+			}
+			yield emit$1(result, span, tracker);
+		}
+	},
+	{
+		name: "flatten",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (!Array.isArray(input)) throw new RuntimeError("flatten expects an array", span);
+			const flattenRec = (arr) => {
+				let res = [];
+				for (const item of arr) if (Array.isArray(item)) res = res.concat(flattenRec(item));
+				else res.push(item);
+				return res;
+			};
+			yield emit$1(flattenRec(input), span, tracker);
+		}
+	},
+	{
+		name: "flatten",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate, span) {
+			if (!Array.isArray(input)) throw new RuntimeError("flatten expects an array", span);
+			const depths = evaluate(args[0], input, env, tracker);
+			for (const depthVal of depths) {
+				if (typeof depthVal !== "number") throw new RuntimeError("flatten depth must be a number", span);
+				const flattenDepth = (arr, d) => {
+					if (d <= 0) return arr;
+					let res = [];
+					for (const item of arr) if (Array.isArray(item)) res = res.concat(flattenDepth(item, d - 1));
+					else res.push(item);
+					return res;
+				};
+				yield emit$1(flattenDepth(input, depthVal), span, tracker);
+			}
+		}
+	},
+	{
+		name: "keys_unsorted",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (Array.isArray(input)) yield emit$1(Array.from({ length: input.length }, (_, i) => i), span, tracker);
+			else if (input !== null && typeof input === "object") yield emit$1(Object.keys(input), span, tracker);
+			else throw new RuntimeError(`keys_unsorted expects an array or object`, span);
+		}
+	},
+	{
+		name: "transpose",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (!Array.isArray(input)) throw new RuntimeError("transpose expects an array", span);
+			const arr = input;
+			if (arr.length === 0) {
+				yield emit$1([], span, tracker);
+				return;
+			}
+			let maxLen = 0;
+			for (const row of arr) {
+				if (!Array.isArray(row)) throw new RuntimeError("transpose input must be array of arrays", span);
+				if (row.length > maxLen) maxLen = row.length;
+			}
+			const result = [];
+			for (let j = 0; j < maxLen; j++) {
+				const newRow = [];
+				for (let i = 0; i < arr.length; i++) {
+					const row = arr[i];
+					const val = j < row.length ? row[j] : null;
+					newRow.push(val);
+				}
+				result.push(newRow);
+			}
+			yield emit$1(result, span, tracker);
+		}
+	},
+	{
+		name: "bsearch",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate, span) {
+			if (!Array.isArray(input)) throw new RuntimeError("bsearch expects an array", span);
+			const targetGen = evaluate(args[0], input, env, tracker);
+			for (const target of targetGen) {
+				let low = 0;
+				let high = input.length - 1;
+				let idx = -1;
+				while (low <= high) {
+					const mid = Math.floor((low + high) / 2);
+					const cmp = compareValues(input[mid], target);
+					if (cmp === 0) {
+						idx = mid;
+						break;
+					} else if (cmp < 0) low = mid + 1;
+					else high = mid - 1;
+				}
+				if (idx !== -1) yield emit$1(idx, span, tracker);
+				else yield emit$1(-low - 1, span, tracker);
+			}
+		}
+	},
+	{
+		name: "combinations",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (!Array.isArray(input)) throw new RuntimeError("combinations expects an array", span);
+			if (input.some((x) => !Array.isArray(x))) throw new RuntimeError("combinations input must be array of arrays", span);
+			const arrays = input;
+			if (arrays.length === 0) {
+				yield emit$1([], span, tracker);
+				return;
+			}
+			const helper = function* (idx, current) {
+				if (idx === arrays.length) {
+					yield [...current];
+					return;
+				}
+				const arr = arrays[idx];
+				if (arr.length === 0) return;
+				for (const item of arr) {
+					current.push(item);
+					yield* helper(idx + 1, current);
+					current.pop();
+				}
+			};
+			for (const combo of helper(0, [])) yield emit$1(combo, span, tracker);
+		}
+	},
+	{
+		name: "combinations",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate, span) {
+			if (!Array.isArray(input)) throw new RuntimeError("combinations expects an array", span);
+			const nGen = evaluate(args[0], input, env, tracker);
+			for (const nVal of nGen) {
+				if (typeof nVal !== "number") throw new RuntimeError("combinations(n) expects n to be number", span);
+				if (nVal === 0) {
+					yield emit$1([], span, tracker);
+					continue;
+				}
+				const arrays = [];
+				for (let i = 0; i < nVal; i++) arrays.push(input);
+				const helper = function* (idx, current) {
+					if (idx === arrays.length) {
+						yield [...current];
+						return;
+					}
+					const arr = arrays[idx];
+					for (const item of arr) {
+						current.push(item);
+						yield* helper(idx + 1, current);
+						current.pop();
+					}
+				};
+				if (input.length === 0 && nVal > 0) {} else for (const combo of helper(0, [])) yield emit$1(combo, span, tracker);
+			}
+		}
+	},
+	{
+		name: "inside",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate, span) {
+			const bGen = evaluate(args[0], input, env, tracker);
+			for (const b of bGen) yield emit$1(checkContains(b, input), span, tracker);
+		}
+	}
+];
+const getEntryField = (obj, names) => {
+	for (const name of names) if (Object.prototype.hasOwnProperty.call(obj, name)) return obj[name];
+};
+//#endregion
+//#region src/builtins/iterators.ts
+const iteratorBuiltins = [
+	{
+		name: "range",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate, span) {
+			const ends = evaluate(args[0], input, env, tracker);
+			for (const end of ends) {
+				if (typeof end !== "number") throw new RuntimeError("range expects numbers", span);
+				for (let i = 0; i < end; i++) yield emit$1(i, span, tracker);
+			}
+		}
+	},
+	{
+		name: "range",
+		arity: 2,
+		apply: function* (input, args, env, tracker, evaluate, span) {
+			const starts = Array.from(evaluate(args[0], input, env, tracker));
+			const ends = Array.from(evaluate(args[1], input, env, tracker));
+			for (const start of starts) for (const end of ends) {
+				if (typeof start !== "number" || typeof end !== "number") throw new RuntimeError("range expects numbers", span);
+				if (start < end) for (let i = start; i < end; i++) yield emit$1(i, span, tracker);
+			}
+		}
+	},
+	{
+		name: "range",
+		arity: 3,
+		apply: function* (input, args, env, tracker, evaluate, span) {
+			const starts = Array.from(evaluate(args[0], input, env, tracker));
+			const ends = Array.from(evaluate(args[1], input, env, tracker));
+			const steps = Array.from(evaluate(args[2], input, env, tracker));
+			for (const start of starts) for (const end of ends) for (const step of steps) {
+				if (typeof start !== "number" || typeof end !== "number" || typeof step !== "number") throw new RuntimeError("range expects numbers", span);
+				if (step === 0) throw new RuntimeError("range step cannot be zero", span);
+				if (step > 0) for (let i = start; i < end; i += step) yield emit$1(i, span, tracker);
+				else for (let i = start; i > end; i += step) yield emit$1(i, span, tracker);
+			}
+		}
+	},
+	{
+		name: "limit",
+		arity: 2,
+		apply: function* (input, args, env, tracker, evaluate, span) {
+			const limits = evaluate(args[0], input, env, tracker);
+			for (const n of limits) {
+				if (typeof n !== "number") throw new RuntimeError("limit expects number", span);
+				let count = 0;
+				if (n > 0) for (const val of evaluate(args[1], input, env, tracker)) {
+					yield val;
+					count++;
+					if (count >= n) break;
+				}
+			}
+		}
+	},
+	{
+		name: "skip",
+		arity: 2,
+		apply: function* (input, args, env, tracker, evaluate, span) {
+			for (const n of evaluate(args[0], input, env, tracker)) {
+				if (typeof n !== "number") throw new RuntimeError("skip expects number", span);
+				let count = 0;
+				for (const val of evaluate(args[1], input, env, tracker)) {
+					if (count >= n) yield val;
+					count++;
+				}
+			}
+		}
+	},
+	{
+		name: "first",
+		arity: 0,
+		apply: function* (input) {
+			if (Array.isArray(input) && input.length > 0) yield input[0];
+		}
+	},
+	{
+		name: "first",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate) {
+			for (const val of evaluate(args[0], input, env, tracker)) {
+				yield val;
+				break;
+			}
+		}
+	},
+	{
+		name: "last",
+		arity: 0,
+		apply: function* (input) {
+			if (Array.isArray(input) && input.length > 0) yield input[input.length - 1];
+		}
+	},
+	{
+		name: "last",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate) {
+			let lastVal;
+			let found = false;
+			for (const val of evaluate(args[0], input, env, tracker)) {
+				lastVal = val;
+				found = true;
+			}
+			if (found) yield lastVal;
+		}
+	},
+	{
+		name: "nth",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate, span) {
+			if (!Array.isArray(input)) throw new RuntimeError("nth expects array input", span);
+			for (const n of evaluate(args[0], input, env, tracker)) {
+				if (typeof n !== "number") throw new RuntimeError("nth expects number", span);
+				const idx = Math.trunc(n);
+				if (idx >= 0 && idx < input.length) yield input[idx];
+			}
+		}
+	},
+	{
+		name: "nth",
+		arity: 2,
+		apply: function* (input, args, env, tracker, evaluate, span) {
+			const indices = evaluate(args[0], input, env, tracker);
+			for (const n of indices) {
+				if (typeof n !== "number") throw new RuntimeError("nth expects number", span);
+				let count = 0;
+				for (const val of evaluate(args[1], input, env, tracker)) {
+					if (count === n) {
+						yield val;
+						break;
+					}
+					count++;
+				}
+			}
+		}
+	},
+	{
+		name: "isempty",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate, span) {
+			let empty = true;
+			for (const _ of evaluate(args[0], input, env, tracker)) {
+				empty = false;
+				break;
+			}
+			yield emit$1(empty, span, tracker);
+		}
+	},
+	{
+		name: "all",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _evaluate, span) {
+			if (!Array.isArray(input)) throw new RuntimeError("all expects an array", span);
+			yield emit$1(input.every(isTruthy), span, tracker);
+		}
+	},
+	{
+		name: "all",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate, span) {
+			if (!Array.isArray(input)) throw new RuntimeError("all expects an array", span);
+			let result = true;
+			for (const item of input) {
+				let itemResult = false;
+				for (const val of evaluate(args[0], item, env, tracker)) if (isTruthy(val)) {
+					itemResult = true;
+					break;
+				}
+				if (!itemResult) {
+					result = false;
+					break;
+				}
+			}
+			yield emit$1(result, span, tracker);
+		}
+	},
+	{
+		name: "all",
+		arity: 2,
+		apply: function* (input, args, env, tracker, evaluate, span) {
+			let result = true;
+			for (const item of evaluate(args[0], input, env, tracker)) {
+				let itemResult = false;
+				for (const condition of evaluate(args[1], item, env, tracker)) if (isTruthy(condition)) {
+					itemResult = true;
+					break;
+				}
+				if (!itemResult) {
+					result = false;
+					break;
+				}
+			}
+			yield emit$1(result, span, tracker);
+		}
+	},
+	{
+		name: "any",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _evaluate, span) {
+			if (!Array.isArray(input)) throw new RuntimeError("any expects an array", span);
+			yield emit$1(input.some(isTruthy), span, tracker);
+		}
+	},
+	{
+		name: "any",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate, span) {
+			if (!Array.isArray(input)) throw new RuntimeError("any expects an array", span);
+			let result = false;
+			for (const item of input) {
+				for (const val of evaluate(args[0], item, env, tracker)) if (isTruthy(val)) {
+					result = true;
+					break;
+				}
+				if (result) break;
+			}
+			yield emit$1(result, span, tracker);
+		}
+	},
+	{
+		name: "any",
+		arity: 2,
+		apply: function* (input, args, env, tracker, evaluate, span) {
+			let result = false;
+			for (const item of evaluate(args[0], input, env, tracker)) {
+				for (const condition of evaluate(args[1], item, env, tracker)) if (isTruthy(condition)) {
+					result = true;
+					break;
+				}
+				if (result) break;
+			}
+			yield emit$1(result, span, tracker);
+		}
+	},
+	{
+		name: "recurse",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _evaluate, span) {
+			const rec = function* (curr) {
+				yield emit$1(curr, span, tracker);
+				if (Array.isArray(curr)) for (const item of curr) yield* rec(item);
+				else if (curr !== null && typeof curr === "object") {
+					const keys = Object.keys(curr).sort();
+					for (const key of keys) yield* rec(curr[key]);
+				}
+			};
+			yield* rec(input);
+		}
+	},
+	{
+		name: "recurse",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate, span) {
+			const rec = function* (curr) {
+				yield emit$1(curr, span, tracker);
+				const nexts = evaluate(args[0], curr, env, tracker);
+				for (const next of nexts) yield* rec(next);
+			};
+			yield* rec(input);
+		}
+	},
+	{
+		name: "recurse",
+		arity: 2,
+		apply: function* (input, args, env, tracker, evaluate, span) {
+			const stepExpr = args[0];
+			const conditionExpr = args[1];
+			const rec = function* (curr) {
+				yield emit$1(curr, span, tracker);
+				for (const condition of evaluate(conditionExpr, curr, env, tracker)) {
+					if (!isTruthy(condition)) return;
+					break;
+				}
+				for (const next of evaluate(stepExpr, curr, env, tracker)) yield* rec(next);
+			};
+			yield* rec(input);
+		}
+	},
+	{
+		name: "while",
+		arity: 2,
+		apply: function* (input, args, env, tracker, evaluate, span) {
+			const condExpr = args[0];
+			const updateExpr = args[1];
+			const rec = function* (curr) {
+				tracker.step(span);
+				let condMatches = false;
+				for (const c of evaluate(condExpr, curr, env, tracker)) if (isTruthy(c)) {
+					condMatches = true;
+					break;
+				}
+				if (condMatches) {
+					yield emit$1(curr, span, tracker);
+					for (const next of evaluate(updateExpr, curr, env, tracker)) yield* rec(next);
+				}
+			};
+			yield* rec(input);
+		}
+	},
+	{
+		name: "until",
+		arity: 2,
+		apply: function* (input, args, env, tracker, evaluate, span) {
+			const condExpr = args[0];
+			const updateExpr = args[1];
+			const rec = function* (curr) {
+				tracker.step(span);
+				let condMatches = false;
+				for (const c of evaluate(condExpr, curr, env, tracker)) if (isTruthy(c)) {
+					condMatches = true;
+					break;
+				}
+				if (condMatches) yield emit$1(curr, span, tracker);
+				else for (const next of evaluate(updateExpr, curr, env, tracker)) yield* rec(next);
+			};
+			yield* rec(input);
+		}
+	},
+	{
+		name: "repeat",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate, span) {
+			while (true) {
+				tracker.step(span);
+				yield* evaluate(args[0], input, env, tracker);
+			}
+		}
+	}
 ];
-
 //#endregion
 //#region src/eval/ops.ts
 /**
@@ -2553,7 +3001,7 @@ function isEqual(a, b) {
 		if (a.length !== b.length) return false;
 		return a.every((v, i) => isEqual(v, b[i]));
 	}
-	if (isPlainObject$1(a) && isPlainObject$1(b)) {
+	if (isPlainObject(a) && isPlainObject(b)) {
 		const ka = Object.keys(a).sort();
 		const kb = Object.keys(b).sort();
 		if (ka.length !== kb.length) return false;
@@ -2570,7 +3018,7 @@ function compare(a, b) {
 		if (typeof v === "number") return 2;
 		if (typeof v === "string") return 3;
 		if (Array.isArray(v)) return 4;
-		if (isPlainObject$1(v)) return 5;
+		if (isPlainObject(v)) return 5;
 		return 6;
 	};
 	const ta = typeOrder(a);
@@ -2586,7 +3034,7 @@ function compare(a, b) {
 		}
 		return a.length - b.length;
 	}
-	if (isPlainObject$1(a) && isPlainObject$1(b)) {
+	if (isPlainObject(a) && isPlainObject(b)) {
 		const keysA = Object.keys(a).sort();
 		const keysB = Object.keys(b).sort();
 		for (let i = 0; i < Math.min(keysA.length, keysB.length); i++) {
@@ -2606,7 +3054,7 @@ function add(left, right, span) {
 	if (typeof left === "number" && typeof right === "number") return left + right;
 	if (typeof left === "string" && typeof right === "string") return left + right;
 	if (Array.isArray(left) && Array.isArray(right)) return [...left, ...right];
-	if (isPlainObject$1(left) && isPlainObject$1(right)) return {
+	if (isPlainObject(left) && isPlainObject(right)) return {
 		...left,
 		...right
 	};
@@ -2624,7 +3072,7 @@ function mul(left, right, span) {
 	if (typeof left === "number" && typeof right === "number") return left * right;
 	if (typeof left === "string" && typeof right === "number") return repeatString(left, right);
 	if (typeof left === "number" && typeof right === "string") return repeatString(right, left);
-	if (isPlainObject$1(left) && isPlainObject$1(right)) return mergeDeep(left, right);
+	if (isPlainObject(left) && isPlainObject(right)) return mergeDeep(left, right);
 	throw new RuntimeError(`Cannot multiply ${describeType(left)} by ${describeType(right)}`, span);
 }
 function div(left, right, span) {
@@ -2653,218 +3101,784 @@ function mergeDeep(target, source) {
 	for (const key of Object.keys(source)) {
 		const sVal = source[key];
 		const tVal = result[key];
-		if (isPlainObject$1(sVal) && tVal !== void 0 && isPlainObject$1(tVal)) result[key] = mergeDeep(tVal, sVal);
+		if (isPlainObject(sVal) && tVal !== void 0 && isPlainObject(tVal)) result[key] = mergeDeep(tVal, sVal);
 		else result[key] = sVal;
 	}
 	return result;
 }
-function isPlainObject$1(v) {
+function isPlainObject(v) {
 	return typeof v === "object" && v !== null && !Array.isArray(v);
 }
-
 //#endregion
 //#region src/builtins/math.ts
 const mathBuiltins = [
 	{
-		name: "floor",
+		name: "floor",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (typeof input !== "number") throw new RuntimeError("floor expects number", span);
+			yield emit$1(Math.floor(input), span, tracker);
+		}
+	},
+	{
+		name: "ceil",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (typeof input !== "number") throw new RuntimeError("ceil expects number", span);
+			yield emit$1(Math.ceil(input), span, tracker);
+		}
+	},
+	{
+		name: "round",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (typeof input !== "number") throw new RuntimeError("round expects number", span);
+			yield emit$1(Math.round(input), span, tracker);
+		}
+	},
+	{
+		name: "abs",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (typeof input !== "number") throw new RuntimeError("abs expects number", span);
+			yield emit$1(Math.abs(input), span, tracker);
+		}
+	},
+	{
+		name: "sqrt",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (typeof input !== "number") throw new RuntimeError("sqrt expects number", span);
+			yield emit$1(Math.sqrt(input), span, tracker);
+		}
+	},
+	{
+		name: "isnan",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (typeof input !== "number") {
+				yield emit$1(false, span, tracker);
+				return;
+			}
+			yield emit$1(Number.isNaN(input), span, tracker);
+		}
+	},
+	{
+		name: "infinite",
 		arity: 0,
-		apply: function* (input, _args, _env, tracker, _eval, span) {
-			if (typeof input !== "number") throw new RuntimeError("floor expects number", span);
-			yield emit$1(Math.floor(input), span, tracker);
+		apply: function* (_input, _args, _env, tracker, _eval, span) {
+			yield emit$1(Infinity, span, tracker);
 		}
 	},
 	{
-		name: "ceil",
+		name: "nan",
+		arity: 0,
+		apply: function* (_input, _args, _env, tracker, _eval, span) {
+			yield emit$1(NaN, span, tracker);
+		}
+	},
+	{
+		name: "isinfinite",
 		arity: 0,
 		apply: function* (input, _args, _env, tracker, _eval, span) {
-			if (typeof input !== "number") throw new RuntimeError("ceil expects number", span);
-			yield emit$1(Math.ceil(input), span, tracker);
+			yield emit$1(typeof input === "number" && !Number.isFinite(input) && !Number.isNaN(input), span, tracker);
 		}
 	},
 	{
-		name: "round",
+		name: "isfinite",
 		arity: 0,
 		apply: function* (input, _args, _env, tracker, _eval, span) {
-			if (typeof input !== "number") throw new RuntimeError("round expects number", span);
-			yield emit$1(Math.round(input), span, tracker);
+			if (typeof input !== "number") {
+				yield emit$1(true, span, tracker);
+				return;
+			}
+			yield emit$1(Number.isFinite(input), span, tracker);
 		}
 	},
 	{
-		name: "abs",
+		name: "normal",
 		arity: 0,
 		apply: function* (input, _args, _env, tracker, _eval, span) {
-			if (typeof input !== "number") throw new RuntimeError("abs expects number", span);
-			yield emit$1(Math.abs(input), span, tracker);
+			if (typeof input !== "number") {
+				yield emit$1(false, span, tracker);
+				return;
+			}
+			if (!Number.isFinite(input) || Number.isNaN(input) || input === 0) {
+				yield emit$1(false, span, tracker);
+				return;
+			}
+			yield emit$1(true, span, tracker);
 		}
 	},
 	{
-		name: "sqrt",
+		name: "isnormal",
 		arity: 0,
 		apply: function* (input, _args, _env, tracker, _eval, span) {
-			if (typeof input !== "number") throw new RuntimeError("sqrt expects number", span);
-			yield emit$1(Math.sqrt(input), span, tracker);
+			yield emit$1(typeof input === "number" && Number.isFinite(input) && input !== 0, span, tracker);
 		}
 	},
 	{
-		name: "isnan",
+		name: "subnormal",
 		arity: 0,
 		apply: function* (input, _args, _env, tracker, _eval, span) {
 			if (typeof input !== "number") {
 				yield emit$1(false, span, tracker);
 				return;
 			}
-			yield emit$1(Number.isNaN(input), span, tracker);
+			yield emit$1(false, span, tracker);
+		}
+	},
+	{
+		name: "min",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (!Array.isArray(input)) throw new RuntimeError("min expects an array", span);
+			if (input.length === 0) {
+				yield emit$1(null, span, tracker);
+				return;
+			}
+			let minVal = input[0];
+			for (let i = 1; i < input.length; i++) if (compareValues(input[i], minVal) < 0) minVal = input[i];
+			yield emit$1(minVal, span, tracker);
+		}
+	},
+	{
+		name: "max",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (!Array.isArray(input)) throw new RuntimeError("max expects an array", span);
+			if (input.length === 0) {
+				yield emit$1(null, span, tracker);
+				return;
+			}
+			let maxVal = input[0];
+			for (let i = 1; i < input.length; i++) if (compareValues(input[i], maxVal) > 0) maxVal = input[i];
+			yield emit$1(maxVal, span, tracker);
+		}
+	},
+	{
+		name: "min_by",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate, span) {
+			if (!Array.isArray(input)) throw new RuntimeError("min_by expects an array", span);
+			if (input.length === 0) {
+				yield emit$1(null, span, tracker);
+				return;
+			}
+			let minItem = input[0];
+			let minKey;
+			const keys0 = Array.from(evaluate(args[0], minItem, env, tracker));
+			if (keys0.length !== 1) throw new RuntimeError("min_by key must return one value", span);
+			minKey = keys0[0];
+			for (let i = 1; i < input.length; i++) {
+				const item = input[i];
+				const keys = Array.from(evaluate(args[0], item, env, tracker));
+				if (keys.length !== 1) throw new RuntimeError("min_by key must return one value", span);
+				const key = keys[0];
+				if (compareValues(key, minKey) < 0) {
+					minKey = key;
+					minItem = item;
+				}
+			}
+			yield emit$1(minItem, span, tracker);
+		}
+	},
+	{
+		name: "max_by",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate, span) {
+			if (!Array.isArray(input)) throw new RuntimeError("max_by expects an array", span);
+			if (input.length === 0) {
+				yield emit$1(null, span, tracker);
+				return;
+			}
+			let maxItem = input[0];
+			let maxKey;
+			const keys0 = Array.from(evaluate(args[0], maxItem, env, tracker));
+			if (keys0.length !== 1) throw new RuntimeError("max_by key must return one value", span);
+			maxKey = keys0[0];
+			for (let i = 1; i < input.length; i++) {
+				const item = input[i];
+				const keys = Array.from(evaluate(args[0], item, env, tracker));
+				if (keys.length !== 1) throw new RuntimeError("max_by key must return one value", span);
+				const key = keys[0];
+				if (compareValues(key, maxKey) > 0) {
+					maxKey = key;
+					maxItem = item;
+				}
+			}
+			yield emit$1(maxItem, span, tracker);
+		}
+	},
+	{
+		name: "add",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (!Array.isArray(input)) throw new RuntimeError("add expects an array", span);
+			if (input.length === 0) {
+				yield emit$1(null, span, tracker);
+				return;
+			}
+			let acc = input[0];
+			for (let i = 1; i < input.length; i++) {
+				tracker.step(span);
+				acc = add(acc, input[i], span);
+			}
+			yield emit$1(acc, span, tracker);
+		}
+	},
+	{
+		name: "add",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate, span) {
+			const values = Array.from(evaluate(args[0], input, env, tracker));
+			if (values.length === 0) {
+				yield emit$1(null, span, tracker);
+				return;
+			}
+			let acc = values[0];
+			for (let i = 1; i < values.length; i++) {
+				tracker.step(span);
+				acc = add(acc, values[i], span);
+			}
+			yield emit$1(acc, span, tracker);
+		}
+	}
+];
+//#endregion
+//#region src/builtins/dates.ts
+/**
+* Date/time builtins matching the jq binary (jq 1.7+/1.8).
+*
+* jq represents time in two forms:
+*   - a number of seconds since the Unix epoch (possibly fractional), and
+*   - a "broken down time": an 8-element array
+*       [ year, month(0-11), mday, hour, minute, second,
+*         weekday(0-6, Sun=0), yearday(0-365) ].
+*     The second slot carries the fractional part of the input, and `year` is
+*     the full year (NOT year-1900). This mirrors `1425599507 | gmtime ==
+*     [2015,2,5,23,51,47,4,63]`.
+*
+* `now` is the only clock-dependent builtin; it reads the instant injected via
+* `options.now` and throws when none was supplied (jq-ts never reads the host
+* clock on its own). Every other builtin here is a pure function of its input.
+*
+* Known deviation: `strftime`'s `%s` specifier is computed as the UTC epoch of
+* the broken-down time, whereas glibc's `%s` uses the host timezone. jq-ts
+* favors determinism/portability here; every other specifier matches jq.
+*/
+const WEEKDAY_ABBR = [
+	"Sun",
+	"Mon",
+	"Tue",
+	"Wed",
+	"Thu",
+	"Fri",
+	"Sat"
+];
+const WEEKDAY_FULL = [
+	"Sunday",
+	"Monday",
+	"Tuesday",
+	"Wednesday",
+	"Thursday",
+	"Friday",
+	"Saturday"
+];
+const MONTH_ABBR = [
+	"Jan",
+	"Feb",
+	"Mar",
+	"Apr",
+	"May",
+	"Jun",
+	"Jul",
+	"Aug",
+	"Sep",
+	"Oct",
+	"Nov",
+	"Dec"
+];
+const MONTH_FULL = [
+	"January",
+	"February",
+	"March",
+	"April",
+	"May",
+	"June",
+	"July",
+	"August",
+	"September",
+	"October",
+	"November",
+	"December"
+];
+const MS_PER_DAY = 864e5;
+/**
+* `Date.UTC` / `new Date(y, …)` map years 0–99 to 1900–1999 (a legacy JS
+* quirk). jq uses the literal year, so these helpers correct it via
+* `setUTCFullYear` / `setFullYear`, which accept the true year.
+*/
+const utcMillis = (year, mon, mday, hour = 0, min = 0, sec = 0) => {
+	const ms = Date.UTC(year, mon, mday, hour, min, sec);
+	if (year >= 0 && year <= 99) {
+		const d = new Date(ms);
+		d.setUTCFullYear(year);
+		return d.getTime();
+	}
+	return ms;
+};
+const localMillis = (year, mon, mday, hour = 0, min = 0, sec = 0) => {
+	const d = new Date(year, mon, mday, hour, min, sec);
+	if (year >= 0 && year <= 99) d.setFullYear(year);
+	return d.getTime();
+};
+const pad = (value, width, fill = "0") => String(Math.trunc(value)).padStart(width, fill);
+const requireNumber = (input, fn, span) => {
+	if (typeof input !== "number") throw new RuntimeError(`${fn}() requires numeric inputs`, span);
+	return input;
+};
+const requireString = (input, fn, span) => {
+	if (typeof input !== "string") throw new RuntimeError(`${fn} requires a string, got ${describeType(input)}`, span);
+	return input;
+};
+/** Day-of-year (0-based), computed with date-only UTC math so DST can't skew it. */
+const yearDay = (year, mon, mday) => Math.round((utcMillis(year, mon, mday) - utcMillis(year, 0, 1)) / MS_PER_DAY);
+/** Converts epoch seconds into broken-down time fields (UTC or local). */
+const fieldsFromEpoch = (epochSeconds, utc) => {
+	const whole = Math.floor(epochSeconds);
+	const frac = epochSeconds - whole;
+	const d = /* @__PURE__ */ new Date(whole * 1e3);
+	const year = utc ? d.getUTCFullYear() : d.getFullYear();
+	const mon = utc ? d.getUTCMonth() : d.getMonth();
+	const mday = utc ? d.getUTCDate() : d.getDate();
+	const hour = utc ? d.getUTCHours() : d.getHours();
+	const min = utc ? d.getUTCMinutes() : d.getMinutes();
+	const sec = utc ? d.getUTCSeconds() : d.getSeconds();
+	const wday = utc ? d.getUTCDay() : d.getDay();
+	return {
+		year,
+		mon,
+		mday,
+		hour,
+		min,
+		sec: sec + frac,
+		wday,
+		yday: yearDay(year, mon, mday)
+	};
+};
+const fieldsToArray = (f) => [
+	f.year,
+	f.mon,
+	f.mday,
+	f.hour,
+	f.min,
+	f.sec,
+	f.wday,
+	f.yday
+];
+/**
+* Parses a jq broken-down time array into fields. Missing trailing slots
+* default to 0 (jq is lenient: `[1,2,3] | mktime` works); present-but-non-number
+* slots are an error. wday/yday are derived from the calendar date when absent.
+*/
+const fieldsFromArray = (input, fn, span) => {
+	if (!Array.isArray(input)) throw new RuntimeError(`${fn} requires array inputs`, span);
+	const at = (index) => {
+		if (index >= input.length) return 0;
+		const raw = input[index];
+		if (typeof raw !== "number") throw new RuntimeError(`${fn} requires an array of numbers`, span);
+		return raw;
+	};
+	const year = at(0);
+	const mon = at(1);
+	const mday = at(2);
+	return {
+		year,
+		mon,
+		mday,
+		hour: at(3),
+		min: at(4),
+		sec: at(5),
+		wday: input.length > 6 && typeof input[6] === "number" ? input[6] : new Date(utcMillis(year, mon, mday)).getUTCDay(),
+		yday: input.length > 7 && typeof input[7] === "number" ? input[7] : yearDay(year, mon, mday)
+	};
+};
+/** Converts broken-down time fields back into epoch seconds (mktime). */
+const epochFromFields = (f, utc) => {
+	const wholeSec = Math.floor(f.sec);
+	const frac = f.sec - wholeSec;
+	return (utc ? utcMillis(f.year, f.mon, f.mday, f.hour, f.min, wholeSec) : localMillis(f.year, f.mon, f.mday, f.hour, f.min, wholeSec)) / 1e3 + frac;
+};
+/** ISO-8601 week-numbering year and week (for %G / %V). */
+const isoWeek = (year, mon, mday) => {
+	const date = new Date(utcMillis(year, mon, mday));
+	const dayNum = (date.getUTCDay() + 6) % 7;
+	date.setUTCDate(date.getUTCDate() - dayNum + 3);
+	const isoYear = date.getUTCFullYear();
+	const firstThursday = new Date(utcMillis(isoYear, 0, 4));
+	const firstDayNum = (firstThursday.getUTCDay() + 6) % 7;
+	firstThursday.setUTCDate(firstThursday.getUTCDate() - firstDayNum + 3);
+	return {
+		year: isoYear,
+		week: 1 + Math.round((date.getTime() - firstThursday.getTime()) / (7 * MS_PER_DAY))
+	};
+};
+const localOffsetString = (f) => {
+	const offsetMin = -new Date(localMillis(f.year, f.mon, f.mday, f.hour, f.min, Math.floor(f.sec))).getTimezoneOffset();
+	const sign = offsetMin >= 0 ? "+" : "-";
+	const abs = Math.abs(offsetMin);
+	return `${sign}${pad(Math.floor(abs / 60), 2)}${pad(abs % 60, 2)}`;
+};
+/** Best-effort local timezone abbreviation via Intl, falling back to the offset. */
+const localTzAbbr = (f) => {
+	try {
+		const tz = new Intl.DateTimeFormat("en-US", { timeZoneName: "short" }).formatToParts(new Date(localMillis(f.year, f.mon, f.mday, f.hour, f.min, Math.floor(f.sec)))).find((p) => p.type === "timeZoneName")?.value;
+		if (tz) return tz;
+	} catch {}
+	return localOffsetString(f);
+};
+/** Formats broken-down time with a C `strftime`-style format. */
+const formatStrftime = (f, fmt, utc) => {
+	const hour12 = f.hour % 12 === 0 ? 12 : f.hour % 12;
+	let out = "";
+	for (let i = 0; i < fmt.length; i++) {
+		if (fmt[i] !== "%") {
+			out += fmt[i];
+			continue;
+		}
+		i++;
+		const spec = fmt[i];
+		switch (spec) {
+			case "Y":
+				out += String(f.year);
+				break;
+			case "C":
+				out += pad(Math.floor(f.year / 100), 2);
+				break;
+			case "y":
+				out += pad((f.year % 100 + 100) % 100, 2);
+				break;
+			case "m":
+				out += pad(f.mon + 1, 2);
+				break;
+			case "d":
+				out += pad(f.mday, 2);
+				break;
+			case "e":
+				out += pad(f.mday, 2, " ");
+				break;
+			case "H":
+				out += pad(f.hour, 2);
+				break;
+			case "k":
+				out += pad(f.hour, 2, " ");
+				break;
+			case "I":
+				out += pad(hour12, 2);
+				break;
+			case "l":
+				out += pad(hour12, 2, " ");
+				break;
+			case "M":
+				out += pad(f.min, 2);
+				break;
+			case "S":
+				out += pad(Math.floor(f.sec), 2);
+				break;
+			case "p":
+				out += f.hour < 12 ? "AM" : "PM";
+				break;
+			case "P":
+				out += f.hour < 12 ? "am" : "pm";
+				break;
+			case "j":
+				out += pad(f.yday + 1, 3);
+				break;
+			case "a":
+				out += WEEKDAY_ABBR[(f.wday % 7 + 7) % 7];
+				break;
+			case "A":
+				out += WEEKDAY_FULL[(f.wday % 7 + 7) % 7];
+				break;
+			case "b":
+			case "h":
+				out += MONTH_ABBR[(f.mon % 12 + 12) % 12];
+				break;
+			case "B":
+				out += MONTH_FULL[(f.mon % 12 + 12) % 12];
+				break;
+			case "u":
+				out += String(f.wday === 0 ? 7 : f.wday);
+				break;
+			case "w":
+				out += String(f.wday);
+				break;
+			case "V":
+				out += pad(isoWeek(f.year, f.mon, f.mday).week, 2);
+				break;
+			case "G":
+				out += String(isoWeek(f.year, f.mon, f.mday).year);
+				break;
+			case "Z":
+				out += utc ? "GMT" : localTzAbbr(f);
+				break;
+			case "z":
+				out += utc ? "+0000" : localOffsetString(f);
+				break;
+			case "s":
+				out += String(Math.floor(epochFromFields(f, true)));
+				break;
+			case "T":
+				out += `${pad(f.hour, 2)}:${pad(f.min, 2)}:${pad(Math.floor(f.sec), 2)}`;
+				break;
+			case "R":
+				out += `${pad(f.hour, 2)}:${pad(f.min, 2)}`;
+				break;
+			case "F":
+				out += `${String(f.year)}-${pad(f.mon + 1, 2)}-${pad(f.mday, 2)}`;
+				break;
+			case "D":
+				out += `${pad(f.mon + 1, 2)}/${pad(f.mday, 2)}/${pad((f.year % 100 + 100) % 100, 2)}`;
+				break;
+			case "n":
+				out += "\n";
+				break;
+			case "t":
+				out += "	";
+				break;
+			case "%":
+				out += "%";
+				break;
+			case void 0:
+				out += "%";
+				break;
+			default:
+				out += `%${spec}`;
+				break;
+		}
+	}
+	return out;
+};
+/** Parses a string into broken-down time fields using a C `strptime`-style format. */
+const parseStrptime = (input, fmt, span) => {
+	let s = 0;
+	let year = 1900;
+	let mon = 0;
+	let mday = 1;
+	let hour = 0;
+	let min = 0;
+	let sec = 0;
+	const fail = () => {
+		throw new RuntimeError(`date "${input}" does not match format "${fmt}"`, span);
+	};
+	const readInt = (maxLen) => {
+		const start = s;
+		if (input[s] === "+" || input[s] === "-") s++;
+		let digits = 0;
+		while (s < input.length && digits < maxLen && /[0-9]/.test(input[s])) {
+			s++;
+			digits++;
+		}
+		if (digits === 0) fail();
+		return parseInt(input.slice(start, s), 10);
+	};
+	const matchName = (names) => {
+		const lower = input.slice(s).toLowerCase();
+		let best = -1;
+		let bestLen = 0;
+		names.forEach((name, index) => {
+			const n = name.toLowerCase();
+			if (lower.startsWith(n) && n.length > bestLen) {
+				best = index;
+				bestLen = n.length;
+			}
+		});
+		if (best < 0) fail();
+		s += bestLen;
+		return best;
+	};
+	for (let i = 0; i < fmt.length; i++) {
+		if (fmt[i] !== "%") {
+			if (/\s/.test(fmt[i])) while (s < input.length && /\s/.test(input[s])) s++;
+			else {
+				if (input[s] !== fmt[i]) fail();
+				s++;
+			}
+			continue;
+		}
+		i++;
+		switch (fmt[i]) {
+			case "Y":
+				year = readInt(4);
+				break;
+			case "y": {
+				const yy = readInt(2);
+				year = yy < 69 ? 2e3 + yy : 1900 + yy;
+				break;
+			}
+			case "C":
+				year = readInt(2) * 100;
+				break;
+			case "m":
+				mon = readInt(2) - 1;
+				break;
+			case "d":
+			case "e":
+				while (s < input.length && input[s] === " ") s++;
+				mday = readInt(2);
+				break;
+			case "H":
+			case "k":
+			case "I":
+			case "l":
+				while (s < input.length && input[s] === " ") s++;
+				hour = readInt(2);
+				break;
+			case "M":
+				min = readInt(2);
+				break;
+			case "S":
+				sec = readInt(2);
+				break;
+			case "j":
+				readInt(3);
+				break;
+			case "b":
+			case "B":
+			case "h":
+				mon = matchName([...MONTH_ABBR, ...MONTH_FULL]) % 12;
+				break;
+			case "a":
+			case "A":
+				matchName([...WEEKDAY_ABBR, ...WEEKDAY_FULL]);
+				break;
+			case "p":
+			case "P": {
+				const ampm = input.slice(s, s + 2).toUpperCase();
+				if (ampm === "AM") {
+					if (hour === 12) hour = 0;
+					s += 2;
+				} else if (ampm === "PM") {
+					if (hour < 12) hour += 12;
+					s += 2;
+				} else fail();
+				break;
+			}
+			case "z":
+				if (input[s] === "Z") s++;
+				else {
+					if (input[s] === "+" || input[s] === "-") s++;
+					s += 2;
+					if (input[s] === ":") s++;
+					s += 2;
+				}
+				break;
+			case "Z":
+				while (s < input.length && /[A-Za-z]/.test(input[s])) s++;
+				break;
+			case "n":
+			case "t":
+				while (s < input.length && /\s/.test(input[s])) s++;
+				break;
+			case "%":
+				if (input[s] !== "%") fail();
+				s++;
+				break;
+			default: fail();
+		}
+	}
+	return fieldsFromEpoch(utcMillis(year, mon, mday, hour, min, sec) / 1e3, true);
+};
+/** Resolves strftime input that may be either an epoch number or a broken-down array. */
+const fieldsForFormat = (input, fn, span, utc) => typeof input === "number" ? fieldsFromEpoch(input, utc) : fieldsFromArray(input, fn, span);
+const readFormat = (value, fn, span) => {
+	if (typeof value !== "string") throw new RuntimeError(`${fn}/1 requires a string format`, span);
+	return value;
+};
+const ISO8601 = "%Y-%m-%dT%H:%M:%SZ";
+const dateBuiltins = [
+	{
+		name: "now",
+		arity: 0,
+		apply: function* (_input, _args, _env, tracker, _eval, span) {
+			yield emit$1(tracker.now(span), span, tracker);
 		}
 	},
 	{
-		name: "infinite",
+		name: "gmtime",
 		arity: 0,
 		apply: function* (input, _args, _env, tracker, _eval, span) {
-			if (typeof input !== "number") {
-				yield emit$1(false, span, tracker);
-				return;
-			}
-			yield emit$1(!Number.isFinite(input) && !Number.isNaN(input), span, tracker);
+			yield emit$1(fieldsToArray(fieldsFromEpoch(requireNumber(input, "gmtime", span), true)), span, tracker);
 		}
 	},
 	{
-		name: "isfinite",
+		name: "localtime",
 		arity: 0,
 		apply: function* (input, _args, _env, tracker, _eval, span) {
-			if (typeof input !== "number") {
-				yield emit$1(true, span, tracker);
-				return;
-			}
-			yield emit$1(Number.isFinite(input), span, tracker);
+			yield emit$1(fieldsToArray(fieldsFromEpoch(requireNumber(input, "localtime", span), false)), span, tracker);
 		}
 	},
 	{
-		name: "normal",
+		name: "mktime",
 		arity: 0,
 		apply: function* (input, _args, _env, tracker, _eval, span) {
-			if (typeof input !== "number") {
-				yield emit$1(false, span, tracker);
-				return;
-			}
-			if (!Number.isFinite(input) || Number.isNaN(input) || input === 0) {
-				yield emit$1(false, span, tracker);
-				return;
-			}
-			yield emit$1(true, span, tracker);
+			yield emit$1(epochFromFields(fieldsFromArray(input, "mktime", span), true), span, tracker);
 		}
 	},
 	{
-		name: "subnormal",
-		arity: 0,
-		apply: function* (input, _args, _env, tracker, _eval, span) {
-			if (typeof input !== "number") {
-				yield emit$1(false, span, tracker);
-				return;
-			}
-			yield emit$1(false, span, tracker);
+		name: "strftime",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate, span) {
+			const fields = fieldsForFormat(input, "strftime", span, true);
+			for (const fmt of evaluate(args[0], input, env, tracker)) yield emit$1(formatStrftime(fields, readFormat(fmt, "strftime", span), true), span, tracker);
 		}
 	},
 	{
-		name: "min",
-		arity: 0,
-		apply: function* (input, _args, _env, tracker, _eval, span) {
-			if (!Array.isArray(input)) throw new RuntimeError("min expects an array", span);
-			if (input.length === 0) {
-				yield emit$1(null, span, tracker);
-				return;
-			}
-			let minVal = input[0];
-			for (let i = 1; i < input.length; i++) if (compareValues(input[i], minVal) < 0) minVal = input[i];
-			yield emit$1(minVal, span, tracker);
+		name: "strflocaltime",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate, span) {
+			const fields = fieldsForFormat(input, "strflocaltime", span, false);
+			for (const fmt of evaluate(args[0], input, env, tracker)) yield emit$1(formatStrftime(fields, readFormat(fmt, "strflocaltime", span), false), span, tracker);
 		}
 	},
 	{
-		name: "max",
+		name: "strptime",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate, span) {
+			const str = requireString(input, "strptime", span);
+			for (const fmt of evaluate(args[0], input, env, tracker)) yield emit$1(fieldsToArray(parseStrptime(str, readFormat(fmt, "strptime", span), span)), span, tracker);
+		}
+	},
+	{
+		name: "todate",
 		arity: 0,
 		apply: function* (input, _args, _env, tracker, _eval, span) {
-			if (!Array.isArray(input)) throw new RuntimeError("max expects an array", span);
-			if (input.length === 0) {
-				yield emit$1(null, span, tracker);
-				return;
-			}
-			let maxVal = input[0];
-			for (let i = 1; i < input.length; i++) if (compareValues(input[i], maxVal) > 0) maxVal = input[i];
-			yield emit$1(maxVal, span, tracker);
+			yield emit$1(formatStrftime(fieldsFromEpoch(requireNumber(input, "todate", span), true), ISO8601, true), span, tracker);
 		}
 	},
 	{
-		name: "min_by",
-		arity: 1,
-		apply: function* (input, args, env, tracker, evaluate$1, span) {
-			if (!Array.isArray(input)) throw new RuntimeError("min_by expects an array", span);
-			if (input.length === 0) {
-				yield emit$1(null, span, tracker);
-				return;
-			}
-			let minItem = input[0];
-			let minKey;
-			const keys0 = Array.from(evaluate$1(args[0], minItem, env, tracker));
-			if (keys0.length !== 1) throw new RuntimeError("min_by key must return one value", span);
-			minKey = keys0[0];
-			for (let i = 1; i < input.length; i++) {
-				const item = input[i];
-				const keys = Array.from(evaluate$1(args[0], item, env, tracker));
-				if (keys.length !== 1) throw new RuntimeError("min_by key must return one value", span);
-				const key = keys[0];
-				if (compareValues(key, minKey) < 0) {
-					minKey = key;
-					minItem = item;
-				}
-			}
-			yield emit$1(minItem, span, tracker);
+		name: "todateiso8601",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			yield emit$1(formatStrftime(fieldsFromEpoch(requireNumber(input, "todateiso8601", span), true), ISO8601, true), span, tracker);
 		}
 	},
 	{
-		name: "max_by",
-		arity: 1,
-		apply: function* (input, args, env, tracker, evaluate$1, span) {
-			if (!Array.isArray(input)) throw new RuntimeError("max_by expects an array", span);
-			if (input.length === 0) {
-				yield emit$1(null, span, tracker);
-				return;
-			}
-			let maxItem = input[0];
-			let maxKey;
-			const keys0 = Array.from(evaluate$1(args[0], maxItem, env, tracker));
-			if (keys0.length !== 1) throw new RuntimeError("max_by key must return one value", span);
-			maxKey = keys0[0];
-			for (let i = 1; i < input.length; i++) {
-				const item = input[i];
-				const keys = Array.from(evaluate$1(args[0], item, env, tracker));
-				if (keys.length !== 1) throw new RuntimeError("max_by key must return one value", span);
-				const key = keys[0];
-				if (compareValues(key, maxKey) > 0) {
-					maxKey = key;
-					maxItem = item;
-				}
-			}
-			yield emit$1(maxItem, span, tracker);
+		name: "fromdate",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			yield emit$1(epochFromFields(parseStrptime(requireString(input, "fromdate", span), ISO8601, span), true), span, tracker);
 		}
 	},
 	{
-		name: "add",
+		name: "fromdateiso8601",
 		arity: 0,
 		apply: function* (input, _args, _env, tracker, _eval, span) {
-			if (!Array.isArray(input)) throw new RuntimeError("add expects an array", span);
-			if (input.length === 0) {
-				yield emit$1(null, span, tracker);
-				return;
-			}
-			let acc = input[0];
-			for (let i = 1; i < input.length; i++) {
-				tracker.step(span);
-				acc = add(acc, input[i], span);
-			}
-			yield emit$1(acc, span, tracker);
+			yield emit$1(epochFromFields(parseStrptime(requireString(input, "fromdateiso8601", span), ISO8601, span), true), span, tracker);
 		}
 	}
 ];
-
 //#endregion
 //#region src/builtins/index.ts
 const registerAllBuiltins = () => {
@@ -2875,12 +3889,11 @@ const registerAllBuiltins = () => {
 	registerBuiltins(pathBuiltins);
 	registerBuiltins(iteratorBuiltins);
 	registerBuiltins(mathBuiltins);
+	registerBuiltins(dateBuiltins);
 };
-
 //#endregion
 //#region src/builtins.ts
 registerAllBuiltins();
-
 //#endregion
 //#region src/validate.ts
 /**
@@ -2891,57 +3904,57 @@ registerAllBuiltins();
 * @throws {ValidationError} If validation fails.
 */
 const validate = (node) => {
-	visit(node, []);
+	visit$1(node, []);
 };
-const visit = (node, scope) => {
+const visit$1 = (node, scope) => {
 	switch (node.kind) {
 		case "Identity":
 		case "Literal":
 		case "Var": return;
 		case "FieldAccess":
-			visit(node.target, scope);
+			visit$1(node.target, scope);
 			return;
 		case "IndexAccess":
-			visit(node.target, scope);
-			visit(node.index, scope);
+			visit$1(node.target, scope);
+			visit$1(node.index, scope);
 			return;
 		case "Array":
-			node.items.forEach((n) => visit(n, scope));
+			node.items.forEach((n) => visit$1(n, scope));
 			return;
 		case "Object":
 			node.entries.forEach((entry) => {
-				if (entry.key.kind === "KeyExpr") visit(entry.key.expr, scope);
-				visit(entry.value, scope);
+				if (entry.key.kind === "KeyExpr") visit$1(entry.key.expr, scope);
+				visit$1(entry.value, scope);
 			});
 			return;
 		case "Pipe":
 		case "Comma":
 		case "Alt":
-			visit(node.left, scope);
-			visit(node.right, scope);
+			visit$1(node.left, scope);
+			visit$1(node.right, scope);
 			return;
 		case "Binary":
 		case "Bool":
-			visit(node.left, scope);
-			visit(node.right, scope);
+			visit$1(node.left, scope);
+			visit$1(node.right, scope);
 			return;
 		case "Unary":
-			visit(node.expr, scope);
+			visit$1(node.expr, scope);
 			return;
 		case "If":
 			node.branches.forEach((branch) => {
-				visit(branch.cond, scope);
-				visit(branch.then, scope);
+				visit$1(branch.cond, scope);
+				visit$1(branch.then, scope);
 			});
-			visit(node.else, scope);
+			visit$1(node.else, scope);
 			return;
 		case "As":
-			visit(node.bind, scope);
-			visit(node.body, scope);
+			visit$1(node.bind, scope);
+			visit$1(node.body, scope);
 			return;
 		case "Call": {
 			for (let i = scope.length - 1; i >= 0; i--) if (scope[i].has(node.name)) {
-				for (const arg of node.args) visit(arg, scope);
+				for (const arg of node.args) visit$1(arg, scope);
 				return;
 			}
 			const specs = builtins[node.name];
@@ -2950,51 +3963,50 @@ const visit = (node, scope) => {
 				const arities = specs.map((s) => s.arity).join(" or ");
 				throw new ValidationError(`Function ${node.name} expects ${arities} arguments, but got ${node.args.length}`, node.span);
 			}
-			for (const arg of node.args) visit(arg, scope);
+			for (const arg of node.args) visit$1(arg, scope);
 			return;
 		}
 		case "Assignment":
-			visit(node.left, scope);
-			visit(node.right, scope);
+			visit$1(node.left, scope);
+			visit$1(node.right, scope);
 			return;
 		case "Def": {
 			const bodyScope = new Set(node.args);
 			bodyScope.add(node.name);
-			visit(node.body, [...scope, bodyScope]);
+			visit$1(node.body, [...scope, bodyScope]);
 			const nextScope = new Set([node.name]);
-			visit(node.next, [...scope, nextScope]);
+			visit$1(node.next, [...scope, nextScope]);
 			return;
 		}
 		case "Reduce":
-			visit(node.source, scope);
-			visit(node.init, scope);
-			visit(node.update, scope);
+			visit$1(node.source, scope);
+			visit$1(node.init, scope);
+			visit$1(node.update, scope);
 			return;
 		case "Foreach":
-			visit(node.source, scope);
-			visit(node.init, scope);
-			visit(node.update, scope);
-			if (node.extract) visit(node.extract, scope);
+			visit$1(node.source, scope);
+			visit$1(node.init, scope);
+			visit$1(node.update, scope);
+			if (node.extract) visit$1(node.extract, scope);
 			return;
 		case "Try":
-			visit(node.body, scope);
-			if (node.handler) visit(node.handler, scope);
+			visit$1(node.body, scope);
+			if (node.handler) visit$1(node.handler, scope);
 			return;
 		case "Recurse":
 		case "Iterate":
 		case "Break": return;
 		case "Label":
-			visit(node.body, scope);
+			visit$1(node.body, scope);
 			return;
 		case "Slice":
-			visit(node.target, scope);
-			if (node.start) visit(node.start, scope);
-			if (node.end) visit(node.end, scope);
+			visit$1(node.target, scope);
+			if (node.start) visit$1(node.start, scope);
+			if (node.end) visit$1(node.end, scope);
 			return;
 		default: return node;
 	}
 };
-
 //#endregion
 //#region src/eval/break.ts
 /**
@@ -3008,7 +4020,6 @@ var BreakSignal = class BreakSignal extends Error {
 		Object.setPrototypeOf(this, BreakSignal.prototype);
 	}
 };
-
 //#endregion
 //#region src/limits.ts
 const DEFAULT_LIMITS = {
@@ -3035,8 +4046,27 @@ var LimitTracker = class {
 	steps = 0;
 	depth = 0;
 	outputs = 0;
-	constructor(limits) {
+	/**
+	* @param limits - Resolved execution limits.
+	* @param nowSeconds - The wall-clock instant exposed to the `now` builtin, as
+	*   seconds since the Unix epoch (may be fractional). When `undefined`, the
+	*   `now` builtin throws rather than reading the host clock — jq-ts never
+	*   reads the real clock on its own, so date programs stay deterministic
+	*   unless the caller injects a clock via `options.now`.
+	*/
+	constructor(limits, nowSeconds) {
 		this.limits = limits;
+		this.nowSeconds = nowSeconds;
+	}
+	/**
+	* Returns the injected wall-clock instant (seconds since the Unix epoch) for
+	* the `now` builtin.
+	* @param span - The source span for error reporting.
+	* @throws {RuntimeError} If no clock was injected (`options.now` was unset).
+	*/
+	now(span) {
+		if (this.nowSeconds === void 0) throw new RuntimeError("now/0 requires an injected clock; pass options.now (a Date or epoch seconds)", span);
+		return this.nowSeconds;
 	}
 	/**
 	* Records a single execution step (AST node visit).
@@ -3069,7 +4099,6 @@ var LimitTracker = class {
 		if (this.outputs > this.limits.maxOutputs) throw new RuntimeError("Output limit exceeded", span);
 	}
 };
-
 //#endregion
 //#region src/eval/env.ts
 /**
@@ -3079,7 +4108,26 @@ var LimitTracker = class {
 const getVar = (env, name) => {
 	for (let i = env.length - 1; i >= 0; i--) if (env[i].vars.has(name)) return env[i].vars.get(name);
 };
-
+/**
+* Binds jq `as` destructuring patterns into a variable map.
+*/
+const bindPattern = (pattern, value, bindings) => {
+	switch (pattern.kind) {
+		case "VariablePattern":
+			bindings.set(pattern.name, value);
+			return;
+		case "ArrayPattern":
+			if (!Array.isArray(value)) throw new RuntimeError(`Cannot index ${describeType(value)} with number`, pattern.span);
+			pattern.items.forEach((item, index) => {
+				bindPattern(item, index < value.length ? value[index] : null, bindings);
+			});
+			return;
+		case "ObjectPattern":
+			if (!isPlainObject$1(value)) throw new RuntimeError(`Cannot index ${describeType(value)} with string`, pattern.span);
+			for (const entry of pattern.entries) bindPattern(entry.pattern, Object.prototype.hasOwnProperty.call(value, entry.key) ? value[entry.key] : null, bindings);
+			return;
+	}
+};
 //#endregion
 //#region src/eval/common.ts
 /**
@@ -3111,7 +4159,6 @@ const toIndex = (value, span) => {
 	}
 	throw new RuntimeError("Expected numeric index", span);
 };
-
 //#endregion
 //#region src/eval/assignment.ts
 /**
@@ -3127,15 +4174,15 @@ const toIndex = (value, span) => {
 * @param tracker - Limits tracker.
 * @param evaluate - Recursive evaluator.
 */
-const evalAssignment = function* (node, input, env, tracker, evaluate$1) {
-	const paths = Array.from(evaluatePath(node.left, input, env, tracker, evaluate$1));
+const evalAssignment = function* (node, input, env, tracker, evaluate) {
+	const paths = Array.from(evaluatePath(node.left, input, env, tracker, evaluate));
 	paths.sort((a, b) => compareValues(a, b) * -1);
 	if (paths.length === 0) {
 		yield emit(input, node.span, tracker);
 		return;
 	}
 	if (node.op === "=") {
-		const rhsValues = Array.from(evaluate$1(node.right, input, env, tracker));
+		const rhsValues = Array.from(evaluate(node.right, input, env, tracker));
 		if (rhsValues.length === 0) return;
 		for (const rhsVal of rhsValues) {
 			let current = input;
@@ -3144,9 +4191,9 @@ const evalAssignment = function* (node, input, env, tracker, evaluate$1) {
 		}
 		return;
 	}
-	yield* applyUpdates(input, paths, 0, node.op, node.right, input, env, tracker, evaluate$1);
+	yield* applyUpdates(input, paths, 0, node.op, node.right, input, env, tracker, evaluate);
 };
-function* applyUpdates(current, paths, index, op, rhsNode, contextInput, env, tracker, evaluate$1) {
+function* applyUpdates(current, paths, index, op, rhsNode, contextInput, env, tracker, evaluate) {
 	if (index >= paths.length) {
 		yield current;
 		return;
@@ -3154,9 +4201,9 @@ function* applyUpdates(current, paths, index, op, rhsNode, contextInput, env, tr
 	const path = paths[index];
 	const oldValue = getPath(current, path) ?? null;
 	let newValues = [];
-	if (op === "|=") newValues = Array.from(evaluate$1(rhsNode, oldValue, env, tracker));
+	if (op === "|=") newValues = Array.from(evaluate(rhsNode, oldValue, env, tracker));
 	else {
-		const rhsResults = Array.from(evaluate$1(rhsNode, contextInput, env, tracker));
+		const rhsResults = Array.from(evaluate(rhsNode, contextInput, env, tracker));
 		for (const rhs of rhsResults) {
 			let res;
 			switch (op) {
@@ -3184,12 +4231,11 @@ function* applyUpdates(current, paths, index, op, rhsNode, contextInput, env, tr
 		}
 	}
 	if (newValues.length === 0) {
-		yield* applyUpdates(deletePaths(current, [path], rhsNode.span), paths, index + 1, op, rhsNode, contextInput, env, tracker, evaluate$1);
+		yield* applyUpdates(deletePaths(current, [path], rhsNode.span), paths, index + 1, op, rhsNode, contextInput, env, tracker, evaluate);
 		return;
 	}
-	for (const val of newValues) yield* applyUpdates(updatePath(current, path, () => val, rhsNode.span) ?? current, paths, index + 1, op, rhsNode, contextInput, env, tracker, evaluate$1);
+	for (const val of newValues) yield* applyUpdates(updatePath(current, path, () => val, rhsNode.span) ?? current, paths, index + 1, op, rhsNode, contextInput, env, tracker, evaluate);
 }
-
 //#endregion
 //#region src/eval/iterators.ts
 /**
@@ -3201,14 +4247,14 @@ function* applyUpdates(current, paths, index, op, rhsNode, contextInput, env, tr
 * @param tracker - Limits tracker.
 * @param evaluate - Recursive evaluator.
 */
-const evalIterate = function* (node, input, env, tracker, evaluate$1) {
-	for (const container of evaluate$1(node.target, input, env, tracker)) {
+const evalIterate = function* (node, input, env, tracker, evaluate) {
+	for (const container of evaluate(node.target, input, env, tracker)) {
 		if (container === null) continue;
 		if (isValueArray(container)) {
 			for (const item of container) yield emit(item, node.span, tracker);
 			continue;
 		}
-		if (isPlainObject(container)) {
+		if (isPlainObject$1(container)) {
 			const keys = Object.keys(container).sort();
 			for (const key of keys) yield emit(container[key], node.span, tracker);
 			continue;
@@ -3227,18 +4273,20 @@ const evalIterate = function* (node, input, env, tracker, evaluate$1) {
 * @param tracker - Limits tracker.
 * @param evaluate - Recursive evaluator.
 */
-const evalReduce = function* (node, input, env, tracker, evaluate$1) {
-	const initValues = Array.from(evaluate$1(node.init, input, env, tracker));
+const evalReduce = function* (node, input, env, tracker, evaluate) {
+	const initValues = Array.from(evaluate(node.init, input, env, tracker));
 	if (initValues.length !== 1) throw new RuntimeError("Reduce init must single value", node.init.span);
 	let acc = initValues[0];
-	for (const item of evaluate$1(node.source, input, env, tracker)) {
+	for (const item of evaluate(node.source, input, env, tracker)) {
 		tracker.step(node.span);
+		const vars = /* @__PURE__ */ new Map();
+		bindPattern(node.pattern, item, vars);
 		const newFrame = {
-			vars: new Map([[node.var, item]]),
+			vars,
 			funcs: /* @__PURE__ */ new Map()
 		};
 		const newEnv = [...env, newFrame];
-		const updates = Array.from(evaluate$1(node.update, acc, newEnv, tracker));
+		const updates = Array.from(evaluate(node.update, acc, newEnv, tracker));
 		if (updates.length !== 1) throw new RuntimeError("Reduce update must produce single value", node.update.span);
 		acc = updates[0];
 	}
@@ -3255,21 +4303,23 @@ const evalReduce = function* (node, input, env, tracker, evaluate$1) {
 * @param tracker - Limits tracker.
 * @param evaluate - Recursive evaluator.
 */
-const evalForeach = function* (node, input, env, tracker, evaluate$1) {
-	const initValues = Array.from(evaluate$1(node.init, input, env, tracker));
+const evalForeach = function* (node, input, env, tracker, evaluate) {
+	const initValues = Array.from(evaluate(node.init, input, env, tracker));
 	if (initValues.length !== 1) throw new RuntimeError("Foreach init must single value", node.init.span);
 	let acc = initValues[0];
-	for (const item of evaluate$1(node.source, input, env, tracker)) {
+	for (const item of evaluate(node.source, input, env, tracker)) {
 		tracker.step(node.span);
+		const vars = /* @__PURE__ */ new Map();
+		bindPattern(node.pattern, item, vars);
 		const newFrame = {
-			vars: new Map([[node.var, item]]),
+			vars,
 			funcs: /* @__PURE__ */ new Map()
 		};
 		const newEnv = [...env, newFrame];
-		const updates = Array.from(evaluate$1(node.update, acc, newEnv, tracker));
+		const updates = Array.from(evaluate(node.update, acc, newEnv, tracker));
 		if (updates.length !== 1) throw new RuntimeError("Foreach update must produce single value", node.update.span);
 		acc = updates[0];
-		if (node.extract) for (const extracted of evaluate$1(node.extract, acc, newEnv, tracker)) yield emit(extracted, node.span, tracker);
+		if (node.extract) for (const extracted of evaluate(node.extract, acc, newEnv, tracker)) yield emit(extracted, node.span, tracker);
 		else yield emit(acc, node.span, tracker);
 	}
 };
@@ -3283,17 +4333,16 @@ const evalForeach = function* (node, input, env, tracker, evaluate$1) {
 * @param tracker - Limits tracker.
 * @param evaluate - Recursive evaluator.
 */
-const evalRecurse = function* (node, input, env, tracker, evaluate$1) {
+const evalRecurse = function* (node, input, env, tracker, evaluate) {
 	yield emit(input, node.span, tracker);
 	const children = [];
 	if (isValueArray(input)) children.push(...input);
-	else if (isPlainObject(input)) {
+	else if (isPlainObject$1(input)) {
 		const keys = Object.keys(input).sort();
 		for (const key of keys) children.push(input[key]);
 	}
-	for (const child of children) yield* evalRecurse(node, child, env, tracker, evaluate$1);
+	for (const child of children) yield* evalRecurse(node, child, env, tracker, evaluate);
 };
-
 //#endregion
 //#region src/eval/access.ts
 /**
@@ -3305,13 +4354,13 @@ const evalRecurse = function* (node, input, env, tracker, evaluate$1) {
 * @param tracker - Limits tracker.
 * @param evaluate - Recursive evaluator.
 */
-const evalField = function* (node, input, env, tracker, evaluate$1) {
-	for (const container of evaluate$1(node.target, input, env, tracker)) {
+const evalField = function* (node, input, env, tracker, evaluate) {
+	for (const container of evaluate(node.target, input, env, tracker)) {
 		if (container === null) {
 			yield emit(null, node.span, tracker);
 			continue;
 		}
-		if (isPlainObject(container)) {
+		if (isPlainObject$1(container)) {
 			yield emit(Object.prototype.hasOwnProperty.call(container, node.field) ? container[node.field] : null, node.span, tracker);
 			continue;
 		}
@@ -3328,9 +4377,9 @@ const evalField = function* (node, input, env, tracker, evaluate$1) {
 * @param tracker - Limits tracker.
 * @param evaluate - Recursive evaluator.
 */
-const evalIndex = function* (node, input, env, tracker, evaluate$1) {
-	const indexValues = Array.from(evaluate$1(node.index, input, env, tracker));
-	for (const container of evaluate$1(node.target, input, env, tracker)) {
+const evalIndex = function* (node, input, env, tracker, evaluate) {
+	const indexValues = Array.from(evaluate(node.index, input, env, tracker));
+	for (const container of evaluate(node.target, input, env, tracker)) {
 		if (container === null) {
 			yield emit(null, node.span, tracker);
 			continue;
@@ -3348,7 +4397,7 @@ const evalIndex = function* (node, input, env, tracker, evaluate$1) {
 			}
 			continue;
 		}
-		if (isPlainObject(container)) {
+		if (isPlainObject$1(container)) {
 			for (const keyValue of indexValues) {
 				if (typeof keyValue !== "string") throw new RuntimeError(`Cannot index object with ${describeType(keyValue)}`, node.span);
 				yield emit(Object.prototype.hasOwnProperty.call(container, keyValue) ? container[keyValue] : null, node.span, tracker);
@@ -3368,25 +4417,26 @@ const evalIndex = function* (node, input, env, tracker, evaluate$1) {
 * @param tracker - Limits tracker.
 * @param evaluate - Recursive evaluator.
 */
-const evalSlice = function* (node, input, env, tracker, evaluate$1) {
-	for (const target of evaluate$1(node.target, input, env, tracker)) {
+const evalSlice = function* (node, input, env, tracker, evaluate) {
+	for (const target of evaluate(node.target, input, env, tracker)) {
 		if (typeof target !== "string" && !Array.isArray(target)) throw new RuntimeError("Slice expected string or array", node.span);
 		const starts = [];
-		if (node.start) for (const s of evaluate$1(node.start, input, env, tracker)) {
+		if (node.start) for (const s of evaluate(node.start, input, env, tracker)) {
 			if (typeof s !== "number") throw new RuntimeError("Slice start must be number", node.span);
 			starts.push(s);
 		}
 		else starts.push(0);
 		const ends = [];
-		if (node.end) for (const e of evaluate$1(node.end, input, env, tracker)) {
+		if (node.end) for (const e of evaluate(node.end, input, env, tracker)) {
 			if (typeof e !== "number") throw new RuntimeError("Slice end must be number", node.span);
 			ends.push(e);
 		}
 		else ends.push(target.length);
-		for (const s of starts) for (const e of ends) yield emit(target.slice(s, e), node.span, tracker);
+		for (const s of starts) for (const e of ends) yield emit(target.slice(normalizeSliceStart(s), normalizeSliceEnd(e)), node.span, tracker);
 	}
 };
-
+const normalizeSliceStart = (value) => Math.floor(value);
+const normalizeSliceEnd = (value) => Math.ceil(value);
 //#endregion
 //#region src/eval/constructors.ts
 /**
@@ -3401,9 +4451,9 @@ const evalSlice = function* (node, input, env, tracker, evaluate$1) {
 * @param tracker - Limits tracker.
 * @param evaluate - Recursive evaluator.
 */
-const buildArray = function* (node, input, env, tracker, evaluate$1) {
+const buildArray = function* (node, input, env, tracker, evaluate) {
 	const result = [];
-	for (const itemNode of node.items) for (const itemVal of evaluate$1(itemNode, input, env, tracker)) result.push(itemVal);
+	for (const itemNode of node.items) for (const itemVal of evaluate(itemNode, input, env, tracker)) result.push(itemVal);
 	yield result;
 };
 /**
@@ -3418,10 +4468,10 @@ const buildArray = function* (node, input, env, tracker, evaluate$1) {
 * @param tracker - Limits tracker.
 * @param evaluate - Recursive evaluator.
 */
-const buildObjects = function* (node, input, env, tracker, evaluate$1) {
-	yield* fillObject(node.entries, 0, {}, input, env, tracker, evaluate$1);
+const buildObjects = function* (node, input, env, tracker, evaluate) {
+	yield* fillObject(node.entries, 0, {}, input, env, tracker, evaluate);
 };
-function* fillObject(entries, index, current, input, env, tracker, evaluate$1) {
+function* fillObject(entries, index, current, input, env, tracker, evaluate) {
 	if (index >= entries.length) {
 		yield { ...current };
 		return;
@@ -3430,17 +4480,16 @@ function* fillObject(entries, index, current, input, env, tracker, evaluate$1) {
 	let keys = [];
 	if (entry.key.kind === "KeyIdentifier") keys = [entry.key.name];
 	else if (entry.key.kind === "KeyString") keys = [entry.key.value];
-	else for (const k of evaluate$1(entry.key.expr, input, env, tracker)) {
+	else for (const k of evaluate(entry.key.expr, input, env, tracker)) {
 		if (typeof k !== "string") throw new RuntimeError("Object key must be a string", entry.key.span);
 		keys.push(k);
 	}
-	for (const key of keys) for (const val of evaluate$1(entry.value, input, env, tracker)) {
+	for (const key of keys) for (const val of evaluate(entry.value, input, env, tracker)) {
 		current[key] = val;
-		yield* fillObject(entries, index + 1, current, input, env, tracker, evaluate$1);
+		yield* fillObject(entries, index + 1, current, input, env, tracker, evaluate);
 		delete current[key];
 	}
 }
-
 //#endregion
 //#region src/eval/functions.ts
 /**
@@ -3458,7 +4507,7 @@ function* fillObject(entries, index, current, input, env, tracker, evaluate$1) {
 * @param tracker - Limits tracker.
 * @param evaluate - Recursive evaluator.
 */
-const evalCall = function* (node, input, env, tracker, evaluate$1) {
+const evalCall = function* (node, input, env, tracker, evaluate) {
 	for (let i = env.length - 1; i >= 0; i--) {
 		const funcs = env[i].funcs.get(node.name);
 		if (funcs) {
@@ -3480,7 +4529,7 @@ const evalCall = function* (node, input, env, tracker, evaluate$1) {
 					newFrame.funcs.set(argName, argDefs);
 				}
 				const newStack = [...def.closure, newFrame];
-				yield* evaluate$1(def.body, input, newStack, tracker);
+				yield* evaluate(def.body, input, newStack, tracker);
 				return;
 			}
 		}
@@ -3489,7 +4538,7 @@ const evalCall = function* (node, input, env, tracker, evaluate$1) {
 	if (!specs) throw new RuntimeError(`Unknown function: ${node.name}`, node.span);
 	const builtin = specs.find((s) => s.arity === node.args.length);
 	if (!builtin) throw new RuntimeError(`Function ${node.name} does not accept ${node.args.length} arguments`, node.span);
-	yield* builtin.apply(input, node.args, env, tracker, evaluate$1, node.span);
+	yield* builtin.apply(input, node.args, env, tracker, evaluate, node.span);
 };
 /**
 * Defines a new function in the environment.
@@ -3503,7 +4552,7 @@ const evalCall = function* (node, input, env, tracker, evaluate$1) {
 * @param tracker - Limits tracker.
 * @param evaluate - Recursive evaluator.
 */
-const evalDef = function* (node, input, env, tracker, evaluate$1) {
+const evalDef = function* (node, input, env, tracker, evaluate) {
 	const newFrame = {
 		vars: /* @__PURE__ */ new Map(),
 		funcs: /* @__PURE__ */ new Map()
@@ -3518,9 +4567,8 @@ const evalDef = function* (node, input, env, tracker, evaluate$1) {
 	newFrame.funcs.set(node.name, currentDefs);
 	const newStack = [...env, newFrame];
 	funDef.closure = newStack;
-	yield* evaluate$1(node.next, input, newStack, tracker);
+	yield* evaluate(node.next, input, newStack, tracker);
 };
-
 //#endregion
 //#region src/eval/control_flow.ts
 /**
@@ -3532,17 +4580,17 @@ const evalDef = function* (node, input, env, tracker, evaluate$1) {
 * @param tracker - Limits tracker.
 * @param evaluate - Recursive evaluator.
 */
-const evalIf = function* (node, input, env, tracker, evaluate$1) {
-	yield* evalIfBranch(node, 0, input, env, tracker, evaluate$1);
+const evalIf = function* (node, input, env, tracker, evaluate) {
+	yield* evalIfBranch(node, 0, input, env, tracker, evaluate);
 };
-function* evalIfBranch(node, branchIndex, input, env, tracker, evaluate$1) {
+function* evalIfBranch(node, branchIndex, input, env, tracker, evaluate) {
 	if (branchIndex >= node.branches.length) {
-		yield* evaluate$1(node.else, input, env, tracker);
+		yield* evaluate(node.else, input, env, tracker);
 		return;
 	}
 	const branch = node.branches[branchIndex];
-	for (const cond of evaluate$1(branch.cond, input, env, tracker)) if (isTruthy(cond)) yield* evaluate$1(branch.then, input, env, tracker);
-	else yield* evalIfBranch(node, branchIndex + 1, input, env, tracker, evaluate$1);
+	for (const cond of evaluate(branch.cond, input, env, tracker)) if (isTruthy(cond)) yield* evaluate(branch.then, input, env, tracker);
+	else yield* evalIfBranch(node, branchIndex + 1, input, env, tracker, evaluate);
 }
 /**
 * Evaluates a `try-catch` expression.
@@ -3553,12 +4601,12 @@ function* evalIfBranch(node, branchIndex, input, env, tracker, evaluate$1) {
 * @param tracker - Limits tracker.
 * @param evaluate - Recursive evaluator.
 */
-const evalTry = function* (node, input, env, tracker, evaluate$1) {
+const evalTry = function* (node, input, env, tracker, evaluate) {
 	try {
-		yield* evaluate$1(node.body, input, env, tracker);
+		yield* evaluate(node.body, input, env, tracker);
 	} catch (err) {
 		if (err instanceof RuntimeError) {
-			if (node.handler) yield* evaluate$1(node.handler, err.message, env, tracker);
+			if (node.handler) yield* evaluate(node.handler, err.message, env, tracker);
 		} else throw err;
 	}
 };
@@ -3571,9 +4619,9 @@ const evalTry = function* (node, input, env, tracker, evaluate$1) {
 * @param tracker - Limits tracker.
 * @param evaluate - Recursive evaluator.
 */
-const evalLabel = function* (node, input, env, tracker, evaluate$1) {
+const evalLabel = function* (node, input, env, tracker, evaluate) {
 	try {
-		yield* evaluate$1(node.body, input, env, tracker);
+		yield* evaluate(node.body, input, env, tracker);
 	} catch (e) {
 		if (e instanceof BreakSignal) {
 			if (e.label === node.label) return;
@@ -3581,10 +4629,16 @@ const evalLabel = function* (node, input, env, tracker, evaluate$1) {
 		throw e;
 	}
 };
-
 //#endregion
 //#region src/eval/dispatch.ts
 /**
+* Normalizes the `now` option to seconds since the Unix epoch.
+*/
+const resolveNowSeconds = (now) => {
+	if (now === void 0) return void 0;
+	return now instanceof Date ? now.getTime() / 1e3 : now;
+};
+/**
 * Runs a jq AST against an input value.
 *
 * @param ast - The parsed AST.
@@ -3593,7 +4647,7 @@ const evalLabel = function* (node, input, env, tracker, evaluate$1) {
 * @returns An array of all values yielded by the filter.
 */
 const runAst = (ast, input, options = {}) => {
-	const tracker = new LimitTracker(resolveLimits(options.limits));
+	const tracker = new LimitTracker(resolveLimits(options.limits), resolveNowSeconds(options.now));
 	const env = [{
 		vars: new Map(Object.entries(options.vars ?? {})),
 		funcs: /* @__PURE__ */ new Map()
@@ -3702,8 +4756,10 @@ function* evaluate(node, input, env, tracker) {
 			case "As": {
 				const values = Array.from(evaluate(node.bind, input, env, tracker));
 				for (const val of values) {
+					const vars = /* @__PURE__ */ new Map();
+					bindPattern(node.pattern, val, vars);
 					const newFrame = {
-						vars: new Map([[node.name, val]]),
+						vars,
 						funcs: /* @__PURE__ */ new Map()
 					};
 					const newEnv = [...env, newFrame];
@@ -3722,7 +4778,300 @@ function* evaluate(node, input, env, tracker) {
 		tracker.exit();
 	}
 }
-
+//#endregion
+//#region src/compat.ts
+const semanticWarnings = {
+	unique: "jq sorts unique results; jq-ts preserves first-seen order for determinism.",
+	unique_by: "jq sorts unique_by results by key; jq-ts preserves first-seen order.",
+	to_entries: "jq preserves object insertion order; jq-ts sorts object keys deterministically.",
+	with_entries: "jq preserves object insertion order; jq-ts processes object keys in sorted order.",
+	tostring: "jq stringifies objects in input key order; jq-ts uses stable sorted-key stringification.",
+	tojson: "jq tojson preserves input object order; jq-ts uses stable sorted-key stringification.",
+	infinite: "jq serializes infinite as a finite JSON number; jq-ts returns JavaScript Infinity internally.",
+	normal: "jq documents isnormal; jq-ts exposes normal with approximate JavaScript number semantics.",
+	subnormal: "jq documents subnormal classification; jq-ts currently approximates this as false."
+};
+const specialVariableWarnings = {
+	ENV: "jq $ENV is an environment snapshot; jq-ts does not populate it unless the caller injects an ENV variable.",
+	__loc__: "jq $__loc__ reports source location metadata; jq-ts does not populate it unless the caller injects a __loc__ variable.",
+	JQ_BUILD_CONFIGURATION: "jq $JQ_BUILD_CONFIGURATION reports jq build metadata; jq-ts does not populate it unless the caller injects a JQ_BUILD_CONFIGURATION variable.",
+	ARGS: "jq $ARGS is populated from CLI arguments; jq-ts does not populate it unless the caller injects an ARGS variable."
+};
+const syntaxWarningsByKind = { Slice: "jq slice bounds have jq-specific numeric coercion; jq-ts uses JavaScript slice semantics." };
+/**
+* Checks whether a jq expression can be parsed and statically validated by jq-ts.
+*
+* This is a syntax/subset check only. It does not prove that runtime behavior
+* matches the jq binary for every possible input.
+*/
+const checkCompatibility = (source) => {
+	try {
+		validate(parse(source));
+		return {
+			compatible: true,
+			findings: []
+		};
+	} catch (err) {
+		const finding = toFinding(err);
+		if (finding) return {
+			compatible: false,
+			findings: [finding]
+		};
+		throw err;
+	}
+};
+/**
+* Checks jq-ts compatibility and reports known semantic differences from jq.
+*/
+const analyzeCompatibility = (source) => {
+	const check = checkCompatibility(source);
+	if (!check.compatible) return {
+		...check,
+		warnings: []
+	};
+	const warnings = collectWarnings(parse(source));
+	return {
+		compatible: true,
+		findings: warnings,
+		warnings
+	};
+};
+/**
+* Compares jq-ts execution against a caller-provided jq runner or jq result.
+*
+* The function is safe to export from the isolate-safe library because it does
+* not spawn the jq binary itself. Tests and development tools can pass a runner
+* that shells out to jq.
+*/
+const compareWithJq = (source, input, jq, options = {}) => {
+	const analysis = analyzeCompatibility(source);
+	const jqTs = runJqTs(source, input, options);
+	const jqResult = typeof jq === "function" ? runExternalJq(jq, source, input) : jq;
+	const findings = [...analysis.findings];
+	if (!jqTs.ok) findings.push({
+		severity: "error",
+		stage: jqTs.stage ?? "runtime",
+		category: "runtime-error",
+		message: jqTs.error
+	});
+	if (!jqResult.ok) findings.push({
+		severity: "error",
+		stage: "compare",
+		category: "jq-error",
+		message: jqResult.error
+	});
+	const equivalent = jqTs.ok && jqResult.ok ? outputStreamsEqual(jqTs.outputs, jqResult.outputs) : null;
+	if (equivalent === false) findings.push({
+		severity: "error",
+		stage: "compare",
+		category: "output-mismatch",
+		message: "jq-ts output stream does not match jq output stream."
+	});
+	return {
+		compatible: analysis.compatible && jqTs.ok,
+		equivalent,
+		analysis,
+		jqTs,
+		jq: jqResult,
+		findings
+	};
+};
+const runJqTs = (source, input, options) => {
+	try {
+		const ast = parse(source);
+		validate(ast);
+		return {
+			ok: true,
+			outputs: runAst(ast, input, options)
+		};
+	} catch (err) {
+		const jqTsError = asJqTsError(err);
+		return {
+			ok: false,
+			error: err instanceof Error ? err.message : String(err),
+			stage: jqTsError?.kind
+		};
+	}
+};
+const runExternalJq = (runner, source, input) => {
+	try {
+		const result = runner(source, input);
+		if (Array.isArray(result)) return {
+			ok: true,
+			outputs: result
+		};
+		return result;
+	} catch (err) {
+		return {
+			ok: false,
+			error: err instanceof Error ? err.message : String(err),
+			stage: "compare"
+		};
+	}
+};
+const outputStreamsEqual = (left, right) => left.length === right.length && left.every((value, index) => valueEquals(value, right[index]));
+const toFinding = (err) => {
+	const jqTsError = asJqTsError(err);
+	if (!jqTsError) return null;
+	return {
+		severity: "error",
+		stage: jqTsError.kind,
+		category: classifyError(jqTsError),
+		message: jqTsError.message,
+		span: jqTsError.span
+	};
+};
+const asJqTsError = (err) => {
+	if (err instanceof LexError || err instanceof ParseError || err instanceof ValidationError || err instanceof RuntimeError) return err;
+	return null;
+};
+const classifyError = (err) => {
+	if (err.kind === "parse" || err.kind === "lex") return "unsupported-syntax";
+	if (err.kind === "runtime") return "runtime-error";
+	if (err.message.startsWith("Unknown function:")) return isIntentionalExclusion(err.message) ? "intentional-exclusion" : "unsupported-builtin";
+	if (err.message.includes("expects") && err.message.includes("arguments")) return "arity-mismatch";
+	return "unsupported-syntax";
+};
+const isIntentionalExclusion = (message) => [
+	"input",
+	"inputs",
+	"env"
+].some((name) => message === `Unknown function: ${name}`);
+const collectWarnings = (node) => {
+	const warnings = [];
+	visit(node, (current) => {
+		const syntaxWarning = syntaxWarningsByKind[current.kind];
+		if (syntaxWarning) warnings.push({
+			severity: "warning",
+			stage: "validate",
+			category: "input-dependent",
+			message: syntaxWarning,
+			span: current.span
+		});
+		if (current.kind === "Call") {
+			const warning = semanticWarnings[current.name];
+			if (warning) warnings.push({
+				severity: "warning",
+				stage: "validate",
+				category: "semantic-deviation",
+				message: warning,
+				span: current.span
+			});
+		}
+		if (current.kind === "Var") {
+			const warning = specialVariableWarnings[current.name];
+			if (warning) warnings.push({
+				severity: "warning",
+				stage: "validate",
+				category: current.name === "ENV" ? "intentional-exclusion" : "semantic-deviation",
+				message: warning,
+				span: current.span
+			});
+		}
+	});
+	return dedupeFindings(warnings);
+};
+const dedupeFindings = (findings) => {
+	const seen = /* @__PURE__ */ new Set();
+	const result = [];
+	for (const finding of findings) {
+		const key = `${finding.category}:${finding.message}:${finding.span?.start ?? ""}:${finding.span?.end ?? ""}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		result.push(finding);
+	}
+	return result;
+};
+const visit = (node, callback) => {
+	callback(node);
+	switch (node.kind) {
+		case "Identity":
+		case "Literal":
+		case "Var":
+		case "Recurse":
+		case "Break": return;
+		case "FieldAccess":
+			visit(node.target, callback);
+			return;
+		case "IndexAccess":
+			visit(node.target, callback);
+			visit(node.index, callback);
+			return;
+		case "Iterate":
+			visit(node.target, callback);
+			return;
+		case "Slice":
+			visit(node.target, callback);
+			if (node.start) visit(node.start, callback);
+			if (node.end) visit(node.end, callback);
+			return;
+		case "Array":
+			node.items.forEach((item) => visit(item, callback));
+			return;
+		case "Object":
+			node.entries.forEach((entry) => visitObjectEntry(entry, callback));
+			return;
+		case "Pipe":
+		case "Comma":
+		case "Alt":
+		case "Binary":
+		case "Bool":
+			visit(node.left, callback);
+			visit(node.right, callback);
+			return;
+		case "Unary":
+			visit(node.expr, callback);
+			return;
+		case "If":
+			node.branches.forEach((branch) => {
+				visit(branch.cond, callback);
+				visit(branch.then, callback);
+			});
+			visit(node.else, callback);
+			return;
+		case "As":
+			visit(node.bind, callback);
+			visit(node.body, callback);
+			return;
+		case "Call":
+			node.args.forEach((arg) => visit(arg, callback));
+			return;
+		case "Reduce":
+			visit(node.source, callback);
+			visit(node.init, callback);
+			visit(node.update, callback);
+			return;
+		case "Foreach":
+			visit(node.source, callback);
+			visit(node.init, callback);
+			visit(node.update, callback);
+			if (node.extract) visit(node.extract, callback);
+			return;
+		case "Try":
+			visit(node.body, callback);
+			if (node.handler) visit(node.handler, callback);
+			return;
+		case "Assignment":
+			visit(node.left, callback);
+			visit(node.right, callback);
+			return;
+		case "Def":
+			visit(node.body, callback);
+			visit(node.next, callback);
+			return;
+		case "Label":
+			visit(node.body, callback);
+			return;
+		default: return node;
+	}
+};
+const visitObjectEntry = (entry, callback) => {
+	visitObjectKey(entry.key, callback);
+	visit(entry.value, callback);
+};
+const visitObjectKey = (key, callback) => {
+	if (key.kind === "KeyExpr") visit(key.expr, callback);
+};
 //#endregion
 //#region src/index.ts
 /**
@@ -3742,7 +5091,7 @@ const run = (source, input, options = {}) => {
 	validate(ast);
 	return runAst(ast, input, options);
 };
-
 //#endregion
-export { LexError, LimitTracker, ParseError, RuntimeError, ValidationError, parse, resolveLimits, run, runAst, validate };
+export { LexError, LimitTracker, ParseError, RuntimeError, ValidationError, analyzeCompatibility, checkCompatibility, compareWithJq, parse, resolveLimits, run, runAst, validate };
+
 //# sourceMappingURL=index.mjs.map