@gabrielbryk/jq-ts 1.3.6 → 1.4.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,195 +1771,575 @@ 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 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);
+			}
+		}
+	}
+];
+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
+/**
+* Resolves properties paths for assignment or `path()` built-in.
+* Returns an array of paths (arrays of strings/numbers) for valid locations.
+*
+* @param node - The AST node describing trailing field access/indexing.
+* @param input - The current input value.
+* @param env - The environment.
+* @param tracker - Limits tracker.
+* @param evaluate - Recursive evaluator.
+*/
+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)) yield [...parent, node.field];
+			return;
+		case "IndexAccess": {
+			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;
+				else if (typeof keyVal === "number" && Number.isInteger(keyVal)) key = keyVal;
+				else throw new RuntimeError("Path index must be string or integer", node.span);
+				for (const parent of parentPaths) yield [...parent, key];
+			}
+			return;
+		}
+		case "Pipe": {
+			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)) yield [...p, ...q];
+			}
+			return;
+		}
+		case "Comma":
+			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));
+			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];
+				else if (val !== null && typeof val === "object") for (const key of Object.keys(val)) yield [...p, key];
+				else {
+					if (val === null) continue;
+					throw new RuntimeError(`Cannot iterate over ${typeof val}`, node.span);
+				}
+			}
+			return;
+		}
+		case "Call":
+			if (node.name === "select") {
+				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 [];
+				return;
+			}
+			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));
+			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,
+					end: typeof endVal === "number" ? endVal : null
+				};
+				for (const p of parentPaths) yield [...p, sliceSpec];
+			}
+			return;
+		}
+		case "Try":
+			try {
+				yield* evaluatePath(node.body, input, env, tracker, evaluate);
+			} catch (e) {
+				if (!(e instanceof RuntimeError)) throw e;
+			}
+			return;
+		case "Var":
+			yield [];
+			return;
+		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 (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);
+	}
+	else if (isPlainObject$1(root)) {
+		const keys = Object.keys(root).sort();
+		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$1(p) && ("start" in p || "end" in p));
+};
+const ensurePath = (val, span) => {
+	if (isPath(val)) return val;
+	throw new RuntimeError("Path must be an array of strings, integers, or slice objects", span);
+};
+const getPath = (root, path) => {
+	let curr = root;
+	for (const part of path) {
+		if (curr === null) return void 0;
+		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)) {
+			if (part < 0 || part >= curr.length) return void 0;
+			curr = curr[part];
+		} else return;
+	}
+	return curr;
+};
+const updatePath = (root, path, updateFn, span, depth = 0) => {
+	if (path.length === 0) return updateFn(root);
+	const [head, ...tail] = path;
+	if (typeof head === "string") {
+		let obj = {};
+		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);
+		if (newVal === void 0) delete obj[head];
+		else obj[head] = newVal;
+		return obj;
+	}
+	if (typeof head === "number") {
+		let arr = [];
+		if (Array.isArray(root)) arr = [...root];
+		else if (root === null) arr = [];
+		else throw new RuntimeError(`Cannot index ${describeType(root)} with number ${head}`, span);
+		const idx = head < 0 ? arr.length + head : head;
+		if (idx < 0) throw new RuntimeError("Invalid negative index", span);
+		const newVal = updatePath((idx < arr.length ? arr[idx] : null) ?? null, tail, updateFn, span, depth + 1);
+		if (newVal === void 0) if (idx >= arr.length) {
+			while (arr.length < idx) arr.push(null);
+			arr.push(newVal);
+		} else arr[idx] = newVal;
+		else if (idx >= arr.length) {
+			while (arr.length < idx) arr.push(null);
+			arr.push(newVal);
+		} else arr[idx] = newVal;
+		return arr;
+	}
+	if (typeof head === "object" && head !== null) {
+		if (!Array.isArray(root)) throw new RuntimeError(`Cannot slice ${describeType(root)}`, span);
+		const arr = [...root];
+		const start = head.start ?? 0;
+		const end = head.end ?? arr.length;
+		const newSliceVal = updateFn(arr.slice(start, end));
+		if (!Array.isArray(newSliceVal)) throw new RuntimeError("Assignment to a slice must be an array", span);
+		arr.splice(start, end - start, ...newSliceVal);
+		return arr;
+	}
+	throw new RuntimeError(`Path segment must be string, integer, or slice object`, span);
+};
+const deletePaths = (root, paths, span) => {
+	if (paths.some((p) => p.length === 0)) return null;
+	if (isPlainObject$1(root)) {
+		const result = { ...root };
+		const relevantPaths = paths.filter((p) => p.length > 0 && typeof p[0] === "string");
+		const byKey = {};
+		for (const p of relevantPaths) {
+			const key = p[0];
+			if (!byKey[key]) byKey[key] = [];
+			byKey[key].push(p.slice(1));
+		}
+		for (const key of Object.keys(byKey)) {
+			const tails = byKey[key];
+			if (tails.some((t) => t.length === 0)) delete result[key];
+			else result[key] = deletePaths(root[key], tails, span);
+		}
+		return result;
+	}
+	if (Array.isArray(root)) {
+		const relevantPaths = paths.filter((p) => p.length > 0 && typeof p[0] === "number");
+		const actions = {};
+		for (const p of relevantPaths) {
+			let idx = p[0];
+			if (idx < 0) idx = root.length + idx;
+			if (idx < 0 || idx >= root.length) continue;
+			if (!actions[idx]) actions[idx] = [];
+			actions[idx].push(p.slice(1));
+		}
+		const finalArr = [];
+		for (let i = 0; i < root.length; i++) {
+			const tails = actions[i];
+			if (tails) if (tails.some((t) => t.length === 0)) continue;
+			else finalArr.push(deletePaths(root[i], tails, span));
+			else finalArr.push(root[i]);
+		}
+		return finalArr;
+	}
+	return root;
+};
+const pathBuiltins = [
+	{
+		name: "paths",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			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, 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, 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);
+			}
+		}
+	},
+	{
+		name: "delpaths",
+		arity: 1,
+		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);
+			}
+		}
+	},
+	{
+		name: "path",
+		arity: 1,
+		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/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: "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: "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: "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: "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;
+			}
+			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: "select",
+		arity: 1,
+		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;
+			}
+		}
+	},
+	{
+		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: "sort_by",
+		arity: 1,
+		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(sortStable(pairs, (a, b) => compareValues(a.key, b.key)).map((p) => p.val), span, tracker);
+		}
+	},
+	{
+		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: "unique_by",
+		arity: 1,
+		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: "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: "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);
+				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] = obj["value"];
+				result[key] = value;
 			}
 			yield emit$1(result, span, tracker);
 		}
@@ -1817,7 +2347,7 @@ const collectionBuiltins = [
 	{
 		name: "with_entries",
 		arity: 1,
-		apply: function* (input, args, env, tracker, evaluate$1, span) {
+		apply: function* (input, args, env, tracker, evaluate, span) {
 			let entries;
 			if (Array.isArray(input)) entries = input.map((v, i) => ({
 				key: i,
@@ -1832,7 +2362,7 @@ const collectionBuiltins = [
 			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);
+				for (const outVar of evaluate(filter, entry, env, tracker)) transformed.push(outVar);
 			}
 			const result = {};
 			for (const item of transformed) {
@@ -1849,13 +2379,13 @@ const collectionBuiltins = [
 	{
 		name: "group_by",
 		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("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));
+				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,
@@ -1889,6 +2419,46 @@ const collectionBuiltins = [
 			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,
@@ -1906,9 +2476,9 @@ const collectionBuiltins = [
 	{
 		name: "flatten",
 		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("flatten expects an array", span);
-			const depths = evaluate$1(args[0], input, env, tracker);
+			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) => {
@@ -1962,9 +2532,9 @@ const collectionBuiltins = [
 	{
 		name: "bsearch",
 		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("bsearch expects an array", span);
-			const targetGen = evaluate$1(args[0], input, env, tracker);
+			const targetGen = evaluate(args[0], input, env, tracker);
 			for (const target of targetGen) {
 				let low = 0;
 				let high = input.length - 1;
@@ -2013,9 +2583,9 @@ const collectionBuiltins = [
 	{
 		name: "combinations",
 		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("combinations expects an array", span);
-			const nGen = evaluate$1(args[0], input, env, tracker);
+			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) {
@@ -2043,278 +2613,23 @@ const collectionBuiltins = [
 	{
 		name: "inside",
 		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(b, input), span, tracker);
 		}
 	}
 ];
-
-//#endregion
-//#region src/eval/path_eval.ts
-/**
-* Resolves properties paths for assignment or `path()` built-in.
-* Returns an array of paths (arrays of strings/numbers) for valid locations.
-*
-* @param node - The AST node describing trailing field access/indexing.
-* @param input - The current input value.
-* @param env - The environment.
-* @param tracker - Limits tracker.
-* @param evaluate - Recursive evaluator.
-*/
-const evaluatePath = function* (node, input, env, tracker, evaluate$1) {
-	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];
-			return;
-		case "IndexAccess": {
-			const parentPaths = Array.from(evaluatePath(node.target, input, env, tracker, evaluate$1));
-			const output = evaluate$1(node.index, input, env, tracker);
-			for (const keyVal of output) {
-				let key;
-				if (typeof keyVal === "string") key = keyVal;
-				else if (typeof keyVal === "number" && Number.isInteger(keyVal)) key = keyVal;
-				else throw new RuntimeError("Path index must be string or integer", node.span);
-				for (const parent of parentPaths) yield [...parent, key];
-			}
-			return;
-		}
-		case "Pipe": {
-			const leftPaths = Array.from(evaluatePath(node.left, input, env, tracker, evaluate$1));
-			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];
-			}
-			return;
-		}
-		case "Comma":
-			yield* evaluatePath(node.left, input, env, tracker, evaluate$1);
-			yield* evaluatePath(node.right, input, env, tracker, evaluate$1);
-			return;
-		case "Iterate": {
-			const parentPaths = Array.from(evaluatePath(node.target, input, env, tracker, evaluate$1));
-			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];
-				else if (val !== null && typeof val === "object") for (const key of Object.keys(val)) yield [...p, key];
-				else {
-					if (val === null) continue;
-					throw new RuntimeError(`Cannot iterate over ${typeof val}`, node.span);
-				}
-			}
-			return;
-		}
-		case "Call":
-			if (node.name === "select") {
-				const conds = evaluate$1(node.args[0], input, env, tracker);
-				let matched = false;
-				for (const c of conds) if (c !== null && c !== false) matched = true;
-				if (matched) yield [];
-				return;
-			}
-			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];
-			for (const startVal of startRes) for (const endVal of endRes) {
-				const sliceSpec = {
-					start: typeof startVal === "number" ? startVal : null,
-					end: typeof endVal === "number" ? endVal : null
-				};
-				for (const p of parentPaths) yield [...p, sliceSpec];
-			}
-			return;
-		}
-		case "Try":
-			try {
-				yield* evaluatePath(node.body, input, env, tracker, evaluate$1);
-			} catch (e) {
-				if (!(e instanceof RuntimeError)) throw e;
-			}
-			return;
-		case "Var":
-			yield [];
-			return;
-		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++) yield* traversePaths(root[i], [...currentPath, i], span, tracker);
-	else if (isPlainObject(root)) {
-		const keys = Object.keys(root).sort();
-		for (const key of keys) yield* traversePaths(root[key], [...currentPath, key], 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));
-};
-const ensurePath = (val, span) => {
-	if (isPath(val)) return val;
-	throw new RuntimeError("Path must be an array of strings, integers, or slice objects", span);
-};
-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 (!Object.prototype.hasOwnProperty.call(curr, part)) return void 0;
-			curr = curr[part];
-		} else if (typeof part === "number" && Array.isArray(curr)) {
-			if (part < 0 || part >= curr.length) return void 0;
-			curr = curr[part];
-		} else return;
-	}
-	return curr;
-};
-const updatePath = (root, path, updateFn, span, depth = 0) => {
-	if (path.length === 0) return updateFn(root);
-	const [head, ...tail] = path;
-	if (typeof head === "string") {
-		let obj = {};
-		if (isPlainObject(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);
-		if (newVal === void 0) delete obj[head];
-		else obj[head] = newVal;
-		return obj;
-	}
-	if (typeof head === "number") {
-		let arr = [];
-		if (Array.isArray(root)) arr = [...root];
-		else if (root === null) arr = [];
-		else throw new RuntimeError(`Cannot index ${describeType(root)} with number ${head}`, span);
-		const idx = head < 0 ? arr.length + head : head;
-		if (idx < 0) throw new RuntimeError("Invalid negative index", span);
-		const newVal = updatePath((idx < arr.length ? arr[idx] : null) ?? null, tail, updateFn, span, depth + 1);
-		if (newVal === void 0) if (idx >= arr.length) {
-			while (arr.length < idx) arr.push(null);
-			arr.push(newVal);
-		} else arr[idx] = newVal;
-		else if (idx >= arr.length) {
-			while (arr.length < idx) arr.push(null);
-			arr.push(newVal);
-		} else arr[idx] = newVal;
-		return arr;
-	}
-	if (typeof head === "object" && head !== null) {
-		if (!Array.isArray(root)) throw new RuntimeError(`Cannot slice ${describeType(root)}`, span);
-		const arr = [...root];
-		const start = head.start ?? 0;
-		const end = head.end ?? arr.length;
-		const newSliceVal = updateFn(arr.slice(start, end));
-		if (!Array.isArray(newSliceVal)) throw new RuntimeError("Assignment to a slice must be an array", span);
-		arr.splice(start, end - start, ...newSliceVal);
-		return arr;
-	}
-	throw new RuntimeError(`Path segment must be string, integer, or slice object`, span);
-};
-const deletePaths = (root, paths, span) => {
-	if (paths.some((p) => p.length === 0)) return null;
-	if (isPlainObject(root)) {
-		const result = { ...root };
-		const relevantPaths = paths.filter((p) => p.length > 0 && typeof p[0] === "string");
-		const byKey = {};
-		for (const p of relevantPaths) {
-			const key = p[0];
-			if (!byKey[key]) byKey[key] = [];
-			byKey[key].push(p.slice(1));
-		}
-		for (const key of Object.keys(byKey)) {
-			const tails = byKey[key];
-			if (tails.some((t) => t.length === 0)) delete result[key];
-			else result[key] = deletePaths(root[key], tails, span);
-		}
-		return result;
-	}
-	if (Array.isArray(root)) {
-		const relevantPaths = paths.filter((p) => p.length > 0 && typeof p[0] === "number");
-		const actions = {};
-		for (const p of relevantPaths) {
-			let idx = p[0];
-			if (idx < 0) idx = root.length + idx;
-			if (idx < 0 || idx >= root.length) continue;
-			if (!actions[idx]) actions[idx] = [];
-			actions[idx].push(p.slice(1));
-		}
-		const finalArr = [];
-		for (let i = 0; i < root.length; i++) {
-			const tails = actions[i];
-			if (tails) if (tails.some((t) => t.length === 0)) continue;
-			else finalArr.push(deletePaths(root[i], tails, span));
-			else finalArr.push(root[i]);
-		}
-		return finalArr;
-	}
-	return root;
-};
-const pathBuiltins = [
-	{
-		name: "paths",
-		arity: 0,
-		apply: function* (input, _args, _env, tracker, _eval, span) {
-			yield* traversePaths(input, [], 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);
-		}
-	},
-	{
-		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));
-			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);
-			}
-		}
-	},
-	{
-		name: "delpaths",
-		arity: 1,
-		apply: function* (input, args, env, tracker, evaluate$1, span) {
-			for (const pathsVal of evaluate$1(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);
-			}
-		}
-	},
-	{
-		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);
-		}
-	}
-];
-
+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$1, span) {
-			const ends = evaluate$1(args[0], input, env, tracker);
+		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);
@@ -2324,9 +2639,9 @@ const iteratorBuiltins = [
 	{
 		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));
+		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);
@@ -2336,10 +2651,10 @@ const iteratorBuiltins = [
 	{
 		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));
+		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);
@@ -2351,12 +2666,12 @@ const iteratorBuiltins = [
 	{
 		name: "limit",
 		arity: 2,
-		apply: function* (input, args, env, tracker, evaluate$1, span) {
-			const limits = evaluate$1(args[0], input, env, tracker);
+		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$1(args[1], input, env, tracker)) {
+				if (n > 0) for (const val of evaluate(args[1], input, env, tracker)) {
 					yield val;
 					count++;
 					if (count >= n) break;
@@ -2364,38 +2679,78 @@ const iteratorBuiltins = [
 			}
 		}
 	},
+	{
+		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$1) {
-			for (const val of evaluate$1(args[0], input, env, tracker)) {
+		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$1) {
+		apply: function* (input, args, env, tracker, evaluate) {
 			let lastVal;
 			let found = false;
-			for (const val of evaluate$1(args[0], input, env, tracker)) {
+			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$1, span) {
-			const indices = evaluate$1(args[0], input, env, tracker);
+		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$1(args[1], input, env, tracker)) {
+				for (const val of evaluate(args[1], input, env, tracker)) {
 					if (count === n) {
 						yield val;
 						break;
@@ -2408,67 +2763,161 @@ const iteratorBuiltins = [
 	{
 		name: "isempty",
 		arity: 1,
-		apply: function* (input, args, env, tracker, evaluate$1, span) {
+		apply: function* (input, args, env, tracker, evaluate, span) {
 			let empty = true;
-			for (const _ of evaluate$1(args[0], input, env, tracker)) {
+			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$1, span) {
+		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 val of evaluate$1(args[0], input, env, tracker)) if (!isTruthy(val)) {
-				result = false;
-				break;
+			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$1, span) {
+		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 val of evaluate$1(args[0], input, env, tracker)) if (isTruthy(val)) {
-				result = true;
-				break;
+			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$1, span) {
+		apply: function* (input, args, env, tracker, evaluate, span) {
 			const rec = function* (curr) {
 				yield emit$1(curr, span, tracker);
-				const nexts = evaluate$1(args[0], curr, env, 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$1, span) {
+		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$1(condExpr, curr, env, tracker)) if (isTruthy(c)) {
+				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$1(updateExpr, curr, env, tracker)) yield* rec(next);
+					for (const next of evaluate(updateExpr, curr, env, tracker)) yield* rec(next);
 				}
 			};
 			yield* rec(input);
@@ -2477,18 +2926,18 @@ const iteratorBuiltins = [
 	{
 		name: "until",
 		arity: 2,
-		apply: function* (input, args, env, tracker, evaluate$1, span) {
+		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$1(condExpr, curr, env, tracker)) if (isTruthy(c)) {
+				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$1(updateExpr, curr, env, tracker)) yield* rec(next);
+				else for (const next of evaluate(updateExpr, curr, env, tracker)) yield* rec(next);
 			};
 			yield* rec(input);
 		}
@@ -2496,15 +2945,14 @@ const iteratorBuiltins = [
 	{
 		name: "repeat",
 		arity: 1,
-		apply: function* (input, args, env, tracker, evaluate$1, span) {
+		apply: function* (input, args, env, tracker, evaluate, span) {
 			while (true) {
 				tracker.step(span);
-				yield* evaluate$1(args[0], input, env, tracker);
+				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,15 +3101,14 @@ 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 = [
@@ -2719,12 +3166,22 @@ const mathBuiltins = [
 	{
 		name: "infinite",
 		arity: 0,
+		apply: function* (_input, _args, _env, tracker, _eval, span) {
+			yield emit$1(Infinity, span, tracker);
+		}
+	},
+	{
+		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") {
-				yield emit$1(false, span, tracker);
-				return;
-			}
-			yield emit$1(!Number.isFinite(input) && !Number.isNaN(input), span, tracker);
+			yield emit$1(typeof input === "number" && !Number.isFinite(input) && !Number.isNaN(input), span, tracker);
 		}
 	},
 	{
@@ -2753,6 +3210,13 @@ const mathBuiltins = [
 			yield emit$1(true, span, tracker);
 		}
 	},
+	{
+		name: "isnormal",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			yield emit$1(typeof input === "number" && Number.isFinite(input) && input !== 0, span, tracker);
+		}
+	},
 	{
 		name: "subnormal",
 		arity: 0,
@@ -2795,7 +3259,7 @@ const mathBuiltins = [
 	{
 		name: "min_by",
 		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("min_by expects an array", span);
 			if (input.length === 0) {
 				yield emit$1(null, span, tracker);
@@ -2803,12 +3267,12 @@ const mathBuiltins = [
 			}
 			let minItem = input[0];
 			let minKey;
-			const keys0 = Array.from(evaluate$1(args[0], minItem, env, tracker));
+			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$1(args[0], item, env, tracker));
+				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) {
@@ -2822,7 +3286,7 @@ const mathBuiltins = [
 	{
 		name: "max_by",
 		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("max_by expects an array", span);
 			if (input.length === 0) {
 				yield emit$1(null, span, tracker);
@@ -2830,12 +3294,12 @@ const mathBuiltins = [
 			}
 			let maxItem = input[0];
 			let maxKey;
-			const keys0 = Array.from(evaluate$1(args[0], maxItem, env, tracker));
+			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$1(args[0], item, env, tracker));
+				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) {
@@ -2862,9 +3326,25 @@ const mathBuiltins = [
 			}
 			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/index.ts
 const registerAllBuiltins = () => {
@@ -2876,11 +3356,9 @@ const registerAllBuiltins = () => {
 	registerBuiltins(iteratorBuiltins);
 	registerBuiltins(mathBuiltins);
 };
-
 //#endregion
 //#region src/builtins.ts
 registerAllBuiltins();
-
 //#endregion
 //#region src/validate.ts
 /**
@@ -2891,57 +3369,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 +3428,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 +3485,6 @@ var BreakSignal = class BreakSignal extends Error {
 		Object.setPrototypeOf(this, BreakSignal.prototype);
 	}
 };
-
 //#endregion
 //#region src/limits.ts
 const DEFAULT_LIMITS = {
@@ -3069,7 +3545,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 +3554,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 +3605,6 @@ const toIndex = (value, span) => {
 	}
 	throw new RuntimeError("Expected numeric index", span);
 };
-
 //#endregion
 //#region src/eval/assignment.ts
 /**
@@ -3127,15 +3620,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 +3637,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 +3647,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 +3677,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 +3693,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 +3719,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 +3749,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 +3779,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 +3800,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 +3823,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 +3843,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 +3863,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 +3897,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 +3914,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 +3926,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 +3953,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 +3975,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 +3984,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 +3998,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 +4013,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 +4026,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 +4047,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 +4065,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,7 +4075,6 @@ const evalLabel = function* (node, input, env, tracker, evaluate$1) {
 		throw e;
 	}
 };
-
 //#endregion
 //#region src/eval/dispatch.ts
 /**
@@ -3702,8 +4195,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 +4217,301 @@ 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) => [
+	"now",
+	"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 +4531,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