@creationix/rex 0.3.1 → 0.6.0

package/rex.ts

@@ -19,6 +19,7 @@ export type IRNode =
 	| { type: "string"; raw: string }
 	| { type: "array"; items: IRNode[] }
 	| { type: "arrayComprehension"; binding: IRBindingOrExpr; body: IRNode }
+	| { type: "whileArrayComprehension"; condition: IRNode; body: IRNode }
 	| { type: "object"; entries: { key: IRNode; value: IRNode }[] }
 	| {
 			type: "objectComprehension";
@@ -26,9 +27,15 @@ export type IRNode =
 			key: IRNode;
 			value: IRNode;
 	  }
+	| {
+			type: "whileObjectComprehension";
+			condition: IRNode;
+			key: IRNode;
+			value: IRNode;
+	  }
 	| { type: "key"; name: string }
 	| { type: "group"; expression: IRNode }
-	| { type: "unary"; op: "neg" | "not" | "delete"; value: IRNode }
+	| { type: "unary"; op: "neg" | "not" | "logicalNot" | "delete"; value: IRNode }
 	| {
 			type: "binary";
 			op:
@@ -42,6 +49,7 @@ export type IRNode =
 				| "bitXor"
 				| "and"
 				| "or"
+				| "nor"
 				| "eq"
 				| "neq"
 				| "gt"
@@ -53,7 +61,7 @@ export type IRNode =
 	  }
 	| {
 			type: "assign";
-			op: "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "&=" | "|=" | "^=";
+			op: ":=" | "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "&=" | "|=" | "^=";
 			place: IRNode;
 			value: IRNode;
 	  }
@@ -72,15 +80,18 @@ export type IRNode =
 	  }
 	| { type: "for"; binding: IRBindingOrExpr; body: IRNode[] }
 	| { type: "while"; condition: IRNode; body: IRNode[] }
+	| { type: "range"; from: IRNode; to: IRNode }
 	| { type: "break" }
 	| { type: "continue" };
 
 export type IRBinding =
 	| { type: "binding:keyValueIn"; key: string; value: string; source: IRNode }
 	| { type: "binding:valueIn"; value: string; source: IRNode }
-	| { type: "binding:keyOf"; key: string; source: IRNode };
+	| { type: "binding:keyOf"; key: string; source: IRNode }
+	| { type: "binding:bareIn"; source: IRNode }
+	| { type: "binding:bareOf"; source: IRNode };
 
-export type IRBindingOrExpr = IRBinding | { type: "binding:expr"; source: IRNode };
+export type IRBindingOrExpr = IRBinding;
 
 export type IRConditionalElse =
 	| { type: "else"; block: IRNode[] }
@@ -99,34 +110,39 @@ function byteLength(value: string): number {
 }
 
 const OPCODE_IDS = {
-	do: 0,
-	add: 1,
-	sub: 2,
-	mul: 3,
-	div: 4,
-	eq: 5,
-	neq: 6,
-	lt: 7,
-	lte: 8,
-	gt: 9,
-	gte: 10,
-	and: 11,
-	or: 12,
-	xor: 13,
-	not: 14,
-	boolean: 15,
-	number: 16,
-	string: 17,
-	array: 18,
-	object: 19,
-	mod: 20,
-	neg: 21,
+	do: "",
+	add: "ad",
+	sub: "sb",
+	mul: "ml",
+	div: "dv",
+	eq: "eq",
+	neq: "nq",
+	lt: "lt",
+	lte: "le",
+	gt: "gt",
+	gte: "ge",
+	and: "an",
+	or: "or",
+	xor: "xr",
+	not: "nt",
+	boolean: "bt",
+	number: "nm",
+	string: "st",
+	array: "ar",
+	object: "ob",
+	mod: "md",
+	neg: "ng",
+	range: "rn",
 } as const;
 
 type OpcodeName = keyof typeof OPCODE_IDS;
 
+// Keyword identifiers that are reserved in the grammar and compile to opcodes when called.
+const KEYWORD_OPCODES: ReadonlySet<string> = new Set(["boolean", "number", "string", "array", "object"]);
+
 type EncodeOptions = {
-	domainRefs?: Record<string, number>;
+	domainRefs?: Record<string, string>;
+	domainOpcodes?: Record<string, string>;
 };
 
 type CompileOptions = {
@@ -141,10 +157,7 @@ type RexDomainConfigEntry = {
 	names?: unknown;
 };
 
-const FIRST_NON_RESERVED_REF = 8;
-const DOMAIN_DIGIT_INDEX = new Map<string, number>(Array.from(DIGITS).map((char, index) => [char, index]));
-
-const BINARY_TO_OPCODE: Record<Extract<IRNode, { type: "binary" }> ["op"], OpcodeName> = {
+const BINARY_TO_OPCODE: Record<Exclude<Extract<IRNode, { type: "binary" }> ["op"], "nor">, OpcodeName> = {
 	add: "add",
 	sub: "sub",
 	mul: "mul",
@@ -267,9 +280,9 @@ function encodeDecimal(significand: number, power: number): string {
 
 function encodeNumberNode(node: Extract<IRNode, { type: "number" }>): string {
 	const numberValue = node.value;
-	if (Number.isNaN(numberValue)) return "5'";
-	if (numberValue === Infinity) return "6'";
-	if (numberValue === -Infinity) return "7'";
+	if (Number.isNaN(numberValue)) return "nan'";
+	if (numberValue === Infinity) return "inf'";
+	if (numberValue === -Infinity) return "nif'";
 
 	if (Number.isInteger(numberValue)) {
 		const { base, exp } = splitDecimal(numberValue);
@@ -302,7 +315,7 @@ function encodeNumberNode(node: Extract<IRNode, { type: "number" }>): string {
 }
 
 function encodeOpcode(opcode: OpcodeName): string {
-	return `${encodeUint(OPCODE_IDS[opcode])}%`;
+	return `${OPCODE_IDS[opcode]}%`;
 }
 
 function encodeCallParts(parts: string[]): string {
@@ -321,7 +334,7 @@ function addOptionalPrefix(encoded: string): string {
 	if (encoded.startsWith("?(") || encoded.startsWith("!(") || encoded.startsWith("|(") || encoded.startsWith("&(") || encoded.startsWith(">(") || encoded.startsWith("<(") || encoded.startsWith("#(")) {
 		payload = encoded.slice(2, -1);
 	}
-	else if (encoded.startsWith(">[") || encoded.startsWith(">{")) {
+	else if (encoded.startsWith(">[") || encoded.startsWith(">{") || encoded.startsWith("<[") || encoded.startsWith("<{") || encoded.startsWith("#[") || encoded.startsWith("#{")) {
 		payload = encoded.slice(2, -1);
 	}
 	else if (encoded.startsWith("[") || encoded.startsWith("{") || encoded.startsWith("(")) {
@@ -334,7 +347,7 @@ function addOptionalPrefix(encoded: string): string {
 }
 
 function encodeBlockExpression(block: IRNode[]): string {
-	if (block.length === 0) return "4'";
+	if (block.length === 0) return "un'";
 	if (block.length === 1) return encodeNode(block[0] as IRNode);
 	return encodeCallParts([encodeOpcode("do"), ...block.map((node) => encodeNode(node))]);
 }
@@ -351,9 +364,14 @@ function encodeConditionalElse(elseBranch: IRConditionalElse): string {
 	return encodeNode(nested);
 }
 
+function encodeDomainLookup(shortCode: string, tag: string): string {
+	return `${shortCode}${tag}`;
+}
+
 function encodeNavigation(node: Extract<IRNode, { type: "navigation" }>): string {
 	const domainRefs = activeEncodeOptions?.domainRefs;
-	if (domainRefs && node.target.type === "identifier") {
+	const domainOpcodes = activeEncodeOptions?.domainOpcodes;
+	if ((domainRefs || domainOpcodes) && node.target.type === "identifier") {
 		const staticPath = [node.target.name];
 		for (const segment of node.segments) {
 			if (segment.type !== "static") break;
@@ -362,15 +380,18 @@ function encodeNavigation(node: Extract<IRNode, { type: "navigation" }>): string
 
 		for (let pathLength = staticPath.length; pathLength >= 1; pathLength -= 1) {
 			const dottedName = staticPath.slice(0, pathLength).join(".");
-			const domainRef = domainRefs[dottedName];
-			if (domainRef === undefined) continue;
+			const refCode = domainRefs?.[dottedName];
+			const opcodeCode = domainOpcodes?.[dottedName];
+			const shortCode = refCode ?? opcodeCode;
+			if (shortCode === undefined) continue;
+			const tag = refCode !== undefined ? "'" : "%";
 
 			const consumedStaticSegments = pathLength - 1;
 			if (consumedStaticSegments === node.segments.length) {
-				return `${encodeUint(domainRef)}'`;
+				return encodeDomainLookup(shortCode, tag);
 			}
 
-			const parts = [`${encodeUint(domainRef)}'`];
+			const parts = [encodeDomainLookup(shortCode, tag)];
 			for (const segment of node.segments.slice(consumedStaticSegments)) {
 				if (segment.type === "static") parts.push(encodeBareOrLengthString(segment.key));
 				else parts.push(encodeNode(segment.key));
@@ -395,9 +416,12 @@ function encodeWhile(node: Extract<IRNode, { type: "while" }>): string {
 
 function encodeFor(node: Extract<IRNode, { type: "for" }>): string {
 	const body = addOptionalPrefix(encodeBlockExpression(node.body));
-	if (node.binding.type === "binding:expr") {
+	if (node.binding.type === "binding:bareIn") {
 		return `>(${encodeNode(node.binding.source)}${body})`;
 	}
+	if (node.binding.type === "binding:bareOf") {
+		return `<(${encodeNode(node.binding.source)}${body})`;
+	}
 	if (node.binding.type === "binding:valueIn") {
 		return `>(${encodeNode(node.binding.source)}${node.binding.value}$${body})`;
 	}
@@ -409,31 +433,50 @@ function encodeFor(node: Extract<IRNode, { type: "for" }>): string {
 
 function encodeArrayComprehension(node: Extract<IRNode, { type: "arrayComprehension" }>): string {
 	const body = addOptionalPrefix(encodeNode(node.body));
-	if (node.binding.type === "binding:expr") {
+	if (node.binding.type === "binding:bareIn") {
 		return `>[${encodeNode(node.binding.source)}${body}]`;
 	}
+	if (node.binding.type === "binding:bareOf") {
+		return `<[${encodeNode(node.binding.source)}${body}]`;
+	}
 	if (node.binding.type === "binding:valueIn") {
 		return `>[${encodeNode(node.binding.source)}${node.binding.value}$${body}]`;
 	}
 	if (node.binding.type === "binding:keyValueIn") {
 		return `>[${encodeNode(node.binding.source)}${node.binding.key}$${node.binding.value}$${body}]`;
 	}
-	return `>[${encodeNode(node.binding.source)}${node.binding.key}$${body}]`;
+	return `<[${encodeNode(node.binding.source)}${node.binding.key}$${body}]`;
 }
 
 function encodeObjectComprehension(node: Extract<IRNode, { type: "objectComprehension" }>): string {
 	const key = addOptionalPrefix(encodeNode(node.key));
 	const value = addOptionalPrefix(encodeNode(node.value));
-	if (node.binding.type === "binding:expr") {
+	if (node.binding.type === "binding:bareIn") {
 		return `>{${encodeNode(node.binding.source)}${key}${value}}`;
 	}
+	if (node.binding.type === "binding:bareOf") {
+		return `<{${encodeNode(node.binding.source)}${key}${value}}`;
+	}
 	if (node.binding.type === "binding:valueIn") {
 		return `>{${encodeNode(node.binding.source)}${node.binding.value}$${key}${value}}`;
 	}
 	if (node.binding.type === "binding:keyValueIn") {
 		return `>{${encodeNode(node.binding.source)}${node.binding.key}$${node.binding.value}$${key}${value}}`;
 	}
-	return `>{${encodeNode(node.binding.source)}${node.binding.key}$${key}${value}}`;
+	return `<{${encodeNode(node.binding.source)}${node.binding.key}$${key}${value}}`;
+}
+
+function encodeWhileArrayComprehension(node: Extract<IRNode, { type: "whileArrayComprehension" }>): string {
+	const cond = encodeNode(node.condition);
+	const body = addOptionalPrefix(encodeNode(node.body));
+	return `#[${cond}${body}]`;
+}
+
+function encodeWhileObjectComprehension(node: Extract<IRNode, { type: "whileObjectComprehension" }>): string {
+	const cond = encodeNode(node.condition);
+	const key = addOptionalPrefix(encodeNode(node.key));
+	const value = addOptionalPrefix(encodeNode(node.value));
+	return `#{${cond}${key}${value}}`;
 }
 
 let activeEncodeOptions: EncodeOptions | undefined;
@@ -444,7 +487,9 @@ function encodeNode(node: IRNode): string {
 			return encodeBlockExpression(node.body);
 		case "identifier": {
 			const domainRef = activeEncodeOptions?.domainRefs?.[node.name];
-			if (domainRef !== undefined) return `${encodeUint(domainRef)}'`;
+			if (domainRef !== undefined) return `${domainRef}'`;
+			const domainOpcode = activeEncodeOptions?.domainOpcodes?.[node.name];
+			if (domainOpcode !== undefined) return `${domainOpcode}%`;
 			return `${node.name}$`;
 		}
 		case "self":
@@ -455,11 +500,11 @@ function encodeNode(node: IRNode): string {
 			return `${encodeUint(node.depth - 1)}@`;
 		}
 		case "boolean":
-			return node.value ? "1'" : "2'";
+			return node.value ? "tr'" : "fl'";
 		case "null":
-			return "3'";
+			return "nl'";
 		case "undefined":
-			return "4'";
+			return "un'";
 		case "number":
 			return encodeNumberNode(node);
 		case "string":
@@ -470,6 +515,8 @@ function encodeNode(node: IRNode): string {
 		}
 		case "arrayComprehension":
 			return encodeArrayComprehension(node);
+		case "whileArrayComprehension":
+			return encodeWhileArrayComprehension(node);
 		case "object": {
 			const body = node.entries
 				.map(({ key, value }) => `${encodeNode(key)}${addOptionalPrefix(encodeNode(value))}`)
@@ -478,6 +525,8 @@ function encodeNode(node: IRNode): string {
 		}
 		case "objectComprehension":
 			return encodeObjectComprehension(node);
+		case "whileObjectComprehension":
+			return encodeWhileObjectComprehension(node);
 		case "key":
 			return encodeBareOrLengthString(node.name);
 		case "group":
@@ -485,6 +534,10 @@ function encodeNode(node: IRNode): string {
 		case "unary":
 			if (node.op === "delete") return `~${encodeNode(node.value)}`;
 			if (node.op === "neg") return encodeCallParts([encodeOpcode("neg"), encodeNode(node.value)]);
+			if (node.op === "logicalNot") {
+				const val = encodeNode(node.value);
+				return `!(${val}tr')`;
+			}
 			return encodeCallParts([encodeOpcode("not"), encodeNode(node.value)]);
 		case "binary":
 			if (node.op === "and") {
@@ -507,12 +560,18 @@ function encodeNode(node: IRNode): string {
 					.join("");
 				return `|(${body})`;
 			}
+			if (node.op === "nor") {
+				const left = encodeNode(node.left);
+				const right = addOptionalPrefix(encodeNode(node.right));
+				return `!(${left}${right})`;
+			}
 			return encodeCallParts([
 				encodeOpcode(BINARY_TO_OPCODE[node.op]),
 				encodeNode(node.left),
 				encodeNode(node.right),
 			]);
 		case "assign": {
+			if (node.op === ":=") return `/${encodeNode(node.place)}${addOptionalPrefix(encodeNode(node.value))}`;
 			if (node.op === "=") return `=${encodeNode(node.place)}${addOptionalPrefix(encodeNode(node.value))}`;
 			const opcode = ASSIGN_COMPOUND_TO_OPCODE[node.op];
 			if (!opcode) throw new Error(`Unsupported assignment op: ${node.op}`);
@@ -521,8 +580,14 @@ function encodeNode(node: IRNode): string {
 		}
 		case "navigation":
 			return encodeNavigation(node);
-		case "call":
+		case "call": {
+			// Keyword identifiers (boolean, number, string, array, object) are parsed
+			// as identifier nodes but must be encoded as opcode calls, not variable navigation.
+			if (node.callee.type === "identifier" && KEYWORD_OPCODES.has(node.callee.name)) {
+				return encodeCallParts([encodeOpcode(node.callee.name as OpcodeName), ...node.args.map((arg) => encodeNode(arg))]);
+			}
 			return encodeCallParts([encodeNode(node.callee), ...node.args.map((arg) => encodeNode(arg))]);
+		}
 		case "conditional": {
 			const opener = node.head === "when" ? "?(" : "!(";
 			const cond = encodeNode(node.condition);
@@ -530,6 +595,8 @@ function encodeNode(node: IRNode): string {
 			const elseExpr = node.elseBranch ? addOptionalPrefix(encodeConditionalElse(node.elseBranch)) : "";
 			return `${opener}${cond}${thenExpr}${elseExpr})`;
 		}
+		case "range":
+			return encodeCallParts([encodeOpcode("range"), encodeNode(node.from), encodeNode(node.to)]);
 		case "for":
 			return encodeFor(node);
 		case "while":
@@ -550,11 +617,28 @@ function collectLogicalChain(node: IRNode, op: "and" | "or"): IRNode[] {
 	return [...collectLogicalChain(node.left, op), ...collectLogicalChain(node.right, op)];
 }
 
+type ParseFailure = { message?: string; getRightmostFailurePosition?: () => number };
+
+export function formatParseError(source: string, match: ParseFailure): string {
+	const message = match.message ?? "Parse failed";
+	const pos = match.getRightmostFailurePosition?.();
+	if (typeof pos !== "number" || !Number.isFinite(pos)) return message;
+
+	const safePos = Math.max(0, Math.min(source.length, pos));
+	const lineStart = source.lastIndexOf("\n", safePos - 1) + 1;
+	const lineEndIndex = source.indexOf("\n", safePos);
+	const lineEnd = lineEndIndex === -1 ? source.length : lineEndIndex;
+	const lineText = source.slice(lineStart, lineEnd);
+	const lineNumber = source.slice(0, lineStart).split("\n").length;
+	const columnNumber = safePos - lineStart + 1;
+	const caret = `${" ".repeat(Math.max(0, columnNumber - 1))}^`;
+	return `${message}\n  ${lineText}\n  ${caret}`;
+}
+
 export function parseToIR(source: string): IRNode {
 	const match = grammar.match(source);
 	if (!match.succeeded()) {
-		const failure = match as unknown as { message?: string };
-		throw new Error(failure.message ?? "Parse failed");
+		throw new Error(formatParseError(source, match as ParseFailure));
 	}
 	return semantics(match).toIR() as IRNode;
 }
@@ -690,81 +774,62 @@ export function parse(source: string): unknown {
 	return parseDataNode(parseToIR(source));
 }
 
-export function domainRefsFromConfig(config: unknown): Record<string, number> {
+type DomainMaps = { domainRefs: Record<string, string>; domainOpcodes: Record<string, string> };
+
+export function domainRefsFromConfig(config: unknown): DomainMaps {
 	if (!config || typeof config !== "object" || Array.isArray(config)) {
 		throw new Error("Domain config must be an object");
 	}
-	const refs: Record<string, number> = {};
-	for (const section of Object.values(config)) {
-		if (!section || typeof section !== "object" || Array.isArray(section)) continue;
-		mapConfigEntries(section as Record<string, unknown>, refs);
-	}
-	return refs;
-}
+	const configObj = config as Record<string, unknown>;
+	const domainRefs: Record<string, string> = {};
+	const domainOpcodes: Record<string, string> = {};
 
-function decodeDomainRefKey(refText: string): number {
-	if (!refText) throw new Error("Domain ref key cannot be empty");
-	if (!/^[0-9A-Za-z_-]+$/.test(refText)) {
-		throw new Error(`Invalid domain ref key '${refText}' (must use base64 alphabet 0-9a-zA-Z-_)`);
-	}
-	if (refText.length > 1 && refText[0] === "0") {
-		throw new Error(`Invalid domain ref key '${refText}' (leading zeroes are not allowed)`);
-	}
-	if (/^[1-9]$/.test(refText)) {
-		throw new Error(`Invalid domain ref key '${refText}' (reserved by core language)`);
-	}
-
-	let value = 0;
-	for (const char of refText) {
-		const digit = DOMAIN_DIGIT_INDEX.get(char);
-		if (digit === undefined) throw new Error(`Invalid domain ref key '${refText}'`);
-		value = value * 64 + digit;
-		if (value > Number.MAX_SAFE_INTEGER) {
-			throw new Error(`Invalid domain ref key '${refText}' (must fit in 53 bits)`);
-		}
+	const dataSection = configObj.data;
+	if (dataSection && typeof dataSection === "object" && !Array.isArray(dataSection)) {
+		mapConfigEntries(dataSection as Record<string, unknown>, domainRefs);
 	}
 
-	if (value < FIRST_NON_RESERVED_REF) {
-		throw new Error(`Invalid domain ref key '${refText}' (maps to reserved id ${value})`);
+	const functionsSection = configObj.functions;
+	if (functionsSection && typeof functionsSection === "object" && !Array.isArray(functionsSection)) {
+		mapConfigEntries(functionsSection as Record<string, unknown>, domainOpcodes);
 	}
 
-	return value;
+	return { domainRefs, domainOpcodes };
 }
 
-function mapConfigEntries(entries: Record<string, unknown>, refs: Record<string, number>) {
+function mapConfigEntries(entries: Record<string, unknown>, refs: Record<string, string>) {
 	const sourceKindByRoot = new Map<string, "explicit" | "implicit">();
 	for (const root of Object.keys(refs)) {
 		sourceKindByRoot.set(root, "explicit");
 	}
 
-	for (const [refText, rawEntry] of Object.entries(entries)) {
+	for (const [shortCode, rawEntry] of Object.entries(entries)) {
 		const entry = rawEntry as RexDomainConfigEntry;
 		if (!entry || typeof entry !== "object") continue;
 		if (!Array.isArray(entry.names)) continue;
 
-		const refId = decodeDomainRefKey(refText);
 		for (const rawName of entry.names) {
 			if (typeof rawName !== "string") continue;
-			const existingNameRef = refs[rawName];
-			if (existingNameRef !== undefined && existingNameRef !== refId) {
-				throw new Error(`Conflicting refs for '${rawName}': ${existingNameRef} vs ${refId}`);
+			const existingRef = refs[rawName];
+			if (existingRef !== undefined && existingRef !== shortCode) {
+				throw new Error(`Conflicting refs for '${rawName}': ${existingRef} vs ${shortCode}`);
 			}
-			refs[rawName] = refId;
+			refs[rawName] = shortCode;
 
 			const root = rawName.split(".")[0];
 			if (!root) continue;
 			const currentKind: "explicit" | "implicit" = rawName.includes(".") ? "implicit" : "explicit";
 			const existing = refs[root];
 			if (existing !== undefined) {
-				if (existing === refId) continue;
+				if (existing === shortCode) continue;
 				const existingKind = sourceKindByRoot.get(root) ?? "explicit";
 				if (currentKind === "explicit") {
-					throw new Error(`Conflicting refs for '${root}': ${existing} vs ${refId}`);
+					throw new Error(`Conflicting refs for '${root}': ${existing} vs ${shortCode}`);
 				}
 				if (existingKind === "explicit") continue;
 				continue;
 			}
-			refs[root] = refId;
+			refs[root] = shortCode;
 			sourceKindByRoot.set(root, currentKind);
 		}
 	}
@@ -910,17 +975,10 @@ function gatherEncodedValueSpans(text: string): EncodedSpan[] {
 	return spans;
 }
 
-function buildPointerToken(pointerStart: number, targetStart: number): string | undefined {
-	let offset = targetStart - (pointerStart + 1);
+function buildPointerToken(pointerStart: number, targetStart: number, occurrenceSize: number): string | undefined {
+	const offset = targetStart - pointerStart - occurrenceSize;
 	if (offset < 0) return undefined;
-	for (let guard = 0; guard < 8; guard += 1) {
-		const prefix = encodeUint(offset);
-		const recalculated = targetStart - (pointerStart + prefix.length + 1);
-		if (recalculated === offset) return `${prefix}^`;
-		offset = recalculated;
-		if (offset < 0) return undefined;
-	}
-	return undefined;
+	return `${encodeUint(offset)}^`;
 }
 
 function buildDedupeCandidateTable(encoded: string, minBytes: number): Map<string, DedupeCandidate[]> {
@@ -962,10 +1020,10 @@ function dedupeLargeEncodedValues(encoded: string, minBytes = 4): string {
 
 				if (current.slice(occurrence.span.start, occurrence.span.end) !== value) continue;
 
-				const canonicalCurrentStart = current.length - canonical.offsetFromEnd - canonical.sizeBytes;
-				const pointerToken = buildPointerToken(occurrence.span.start, canonicalCurrentStart);
-				if (!pointerToken) continue;
-				if (pointerToken.length >= occurrence.sizeBytes) continue;
+			const canonicalCurrentStart = current.length - canonical.offsetFromEnd - canonical.sizeBytes;
+			const pointerToken = buildPointerToken(occurrence.span.start, canonicalCurrentStart, occurrence.sizeBytes);
+			if (!pointerToken) continue;
+			if (pointerToken.length >= occurrence.sizeBytes) continue;
 
 				current = `${current.slice(0, occurrence.span.start)}${pointerToken}${current.slice(occurrence.span.end)}`;
 				replaced = true;
@@ -1053,6 +1111,22 @@ function dropBindingNames(env: OptimizeEnv, binding: IRBindingOrExpr) {
 	}
 }
 
+function optimizeBinding(binding: IRBindingOrExpr, sourceEnv: OptimizeEnv, currentDepth: number): IRBinding {
+	const source = optimizeNode(binding.source, sourceEnv, currentDepth);
+	switch (binding.type) {
+		case "binding:bareIn":
+			return { type: "binding:bareIn", source };
+		case "binding:bareOf":
+			return { type: "binding:bareOf", source };
+		case "binding:valueIn":
+			return { type: "binding:valueIn", value: binding.value, source };
+		case "binding:keyValueIn":
+			return { type: "binding:keyValueIn", key: binding.key, value: binding.value, source };
+		case "binding:keyOf":
+			return { type: "binding:keyOf", key: binding.key, source };
+	}
+}
+
 function collectReads(node: IRNode, out: Set<string>) {
 	switch (node.type) {
 		case "identifier":
@@ -1074,11 +1148,20 @@ function collectReads(node: IRNode, out: Set<string>) {
 			collectReads(node.binding.source, out);
 			collectReads(node.body, out);
 			return;
+		case "whileArrayComprehension":
+			collectReads(node.condition, out);
+			collectReads(node.body, out);
+			return;
 		case "objectComprehension":
 			collectReads(node.binding.source, out);
 			collectReads(node.key, out);
 			collectReads(node.value, out);
 			return;
+		case "whileObjectComprehension":
+			collectReads(node.condition, out);
+			collectReads(node.key, out);
+			collectReads(node.value, out);
+			return;
 		case "unary":
 			collectReads(node.value, out);
 			return;
@@ -1109,6 +1192,10 @@ function collectReads(node: IRNode, out: Set<string>) {
 			collectReads(node.binding.source, out);
 			for (const part of node.body) collectReads(part, out);
 			return;
+		case "range":
+			collectReads(node.from, out);
+			collectReads(node.to, out);
+			return;
 		case "program":
 			for (const part of node.body) collectReads(part, out);
 			return;
@@ -1151,6 +1238,8 @@ function isPureNode(node: IRNode): boolean {
 			return node.op !== "delete" && isPureNode(node.value);
 		case "binary":
 			return isPureNode(node.left) && isPureNode(node.right);
+		case "range":
+			return isPureNode(node.from) && isPureNode(node.to);
 		default:
 			return false;
 	}
@@ -1223,6 +1312,8 @@ function hasIdentifierRead(node: IRNode, name: string, asPlace = false): boolean
 			return hasIdentifierRead(node.value, name, node.op === "delete");
 		case "binary":
 			return hasIdentifierRead(node.left, name) || hasIdentifierRead(node.right, name);
+		case "range":
+			return hasIdentifierRead(node.from, name) || hasIdentifierRead(node.to, name);
 		case "assign":
 			return hasIdentifierRead(node.place, name, true) || hasIdentifierRead(node.value, name);
 		default:
@@ -1245,6 +1336,8 @@ function countIdentifierReads(node: IRNode, name: string, asPlace = false): numb
 			return countIdentifierReads(node.value, name, node.op === "delete");
 		case "binary":
 			return countIdentifierReads(node.left, name) + countIdentifierReads(node.right, name);
+		case "range":
+			return countIdentifierReads(node.from, name) + countIdentifierReads(node.to, name);
 		case "assign":
 			return countIdentifierReads(node.place, name, true) + countIdentifierReads(node.value, name);
 		default:
@@ -1302,6 +1395,12 @@ function replaceIdentifier(node: IRNode, name: string, replacement: IRNode, asPl
 				place: replaceIdentifier(node.place, name, replacement, true),
 				value: replaceIdentifier(node.value, name, replacement),
 			} satisfies IRNode;
+		case "range":
+			return {
+				type: "range",
+				from: replaceIdentifier(node.from, name, replacement),
+				to: replaceIdentifier(node.to, name, replacement),
+			} satisfies IRNode;
 		default:
 			return node;
 	}
@@ -1435,6 +1534,9 @@ function foldUnary(op: Extract<IRNode, { type: "unary" }> ["op"], value: unknown
 		if (typeof value === "number") return ~value;
 		return undefined;
 	}
+	if (op === "logicalNot") {
+		return value === undefined ? true : undefined;
+	}
 	return undefined;
 }
 
@@ -1597,6 +1699,12 @@ function optimizeNode(node: IRNode, env: OptimizeEnv, currentDepth: number, asPl
 			}
 			return { type: "binary", op: node.op, left, right } satisfies IRNode;
 		}
+		case "range":
+			return {
+				type: "range",
+				from: optimizeNode(node.from, env, currentDepth),
+				to: optimizeNode(node.to, env, currentDepth),
+			} satisfies IRNode;
 		case "navigation": {
 			const target = optimizeNode(node.target, env, currentDepth);
 			const segments = node.segments.map((segment) => (segment.type === "static"
@@ -1706,31 +1814,7 @@ function optimizeNode(node: IRNode, env: OptimizeEnv, currentDepth: number, asPl
 		}
 		case "for": {
 			const sourceEnv = cloneOptimizeEnv(env);
-			const binding = (() => {
-				if (node.binding.type === "binding:expr") {
-					return { type: "binding:expr", source: optimizeNode(node.binding.source, sourceEnv, currentDepth) } satisfies IRBindingOrExpr;
-				}
-				if (node.binding.type === "binding:valueIn") {
-					return {
-						type: "binding:valueIn",
-						value: node.binding.value,
-						source: optimizeNode(node.binding.source, sourceEnv, currentDepth),
-					} satisfies IRBinding;
-				}
-				if (node.binding.type === "binding:keyValueIn") {
-					return {
-						type: "binding:keyValueIn",
-						key: node.binding.key,
-						value: node.binding.value,
-						source: optimizeNode(node.binding.source, sourceEnv, currentDepth),
-					} satisfies IRBinding;
-				}
-				return {
-					type: "binding:keyOf",
-					key: node.binding.key,
-					source: optimizeNode(node.binding.source, sourceEnv, currentDepth),
-				} satisfies IRBinding;
-			})();
+			const binding = optimizeBinding(node.binding, sourceEnv, currentDepth);
 			const bodyEnv = cloneOptimizeEnv(env);
 			dropBindingNames(bodyEnv, binding);
 			return {
@@ -1741,26 +1825,7 @@ function optimizeNode(node: IRNode, env: OptimizeEnv, currentDepth: number, asPl
 		}
 		case "arrayComprehension": {
 			const sourceEnv = cloneOptimizeEnv(env);
-			const binding = node.binding.type === "binding:expr"
-				? ({ type: "binding:expr", source: optimizeNode(node.binding.source, sourceEnv, currentDepth) } satisfies IRBindingOrExpr)
-				: node.binding.type === "binding:valueIn"
-					? ({
-						type: "binding:valueIn",
-						value: node.binding.value,
-						source: optimizeNode(node.binding.source, sourceEnv, currentDepth),
-					} satisfies IRBinding)
-					: node.binding.type === "binding:keyValueIn"
-						? ({
-							type: "binding:keyValueIn",
-							key: node.binding.key,
-							value: node.binding.value,
-							source: optimizeNode(node.binding.source, sourceEnv, currentDepth),
-						} satisfies IRBinding)
-						: ({
-							type: "binding:keyOf",
-							key: node.binding.key,
-							source: optimizeNode(node.binding.source, sourceEnv, currentDepth),
-						} satisfies IRBinding);
+			const binding = optimizeBinding(node.binding, sourceEnv, currentDepth);
 			const bodyEnv = cloneOptimizeEnv(env);
 			dropBindingNames(bodyEnv, binding);
 			return {
@@ -1769,28 +1834,15 @@ function optimizeNode(node: IRNode, env: OptimizeEnv, currentDepth: number, asPl
 				body: optimizeNode(node.body, bodyEnv, currentDepth + 1),
 			} satisfies IRNode;
 		}
+		case "whileArrayComprehension":
+			return {
+				type: "whileArrayComprehension",
+				condition: optimizeNode(node.condition, env, currentDepth),
+				body: optimizeNode(node.body, env, currentDepth + 1),
+			} satisfies IRNode;
 		case "objectComprehension": {
 			const sourceEnv = cloneOptimizeEnv(env);
-			const binding = node.binding.type === "binding:expr"
-				? ({ type: "binding:expr", source: optimizeNode(node.binding.source, sourceEnv, currentDepth) } satisfies IRBindingOrExpr)
-				: node.binding.type === "binding:valueIn"
-					? ({
-						type: "binding:valueIn",
-						value: node.binding.value,
-						source: optimizeNode(node.binding.source, sourceEnv, currentDepth),
-					} satisfies IRBinding)
-					: node.binding.type === "binding:keyValueIn"
-						? ({
-							type: "binding:keyValueIn",
-							key: node.binding.key,
-							value: node.binding.value,
-							source: optimizeNode(node.binding.source, sourceEnv, currentDepth),
-						} satisfies IRBinding)
-						: ({
-							type: "binding:keyOf",
-							key: node.binding.key,
-							source: optimizeNode(node.binding.source, sourceEnv, currentDepth),
-						} satisfies IRBinding);
+			const binding = optimizeBinding(node.binding, sourceEnv, currentDepth);
 			const bodyEnv = cloneOptimizeEnv(env);
 			dropBindingNames(bodyEnv, binding);
 			return {
@@ -1800,13 +1852,21 @@ function optimizeNode(node: IRNode, env: OptimizeEnv, currentDepth: number, asPl
 				value: optimizeNode(node.value, bodyEnv, currentDepth + 1),
 			} satisfies IRNode;
 		}
+		case "whileObjectComprehension":
+			return {
+				type: "whileObjectComprehension",
+				condition: optimizeNode(node.condition, env, currentDepth),
+				key: optimizeNode(node.key, env, currentDepth + 1),
+				value: optimizeNode(node.value, env, currentDepth + 1),
+			} satisfies IRNode;
 		default:
 			return node;
 	}
 }
 
 export function optimizeIR(node: IRNode): IRNode {
-	return optimizeNode(node, emptyOptimizeEnv(), 1);
+	// Optimization is temporarily disabled pending correctness fixes.
+	return node;
 }
 
 function collectLocalBindings(node: IRNode, locals: Set<string>) {
@@ -1848,6 +1908,10 @@ function collectLocalBindings(node: IRNode, locals: Set<string>) {
 			collectLocalBindings(node.left, locals);
 			collectLocalBindings(node.right, locals);
 			return;
+		case "range":
+			collectLocalBindings(node.from, locals);
+			collectLocalBindings(node.to, locals);
+			return;
 		case "conditional":
 			collectLocalBindings(node.condition, locals);
 			for (const part of node.thenBlock) collectLocalBindings(part, locals);
@@ -1861,11 +1925,20 @@ function collectLocalBindings(node: IRNode, locals: Set<string>) {
 			collectLocalBindingFromBinding(node.binding, locals);
 			collectLocalBindings(node.body, locals);
 			return;
+		case "whileArrayComprehension":
+			collectLocalBindings(node.condition, locals);
+			collectLocalBindings(node.body, locals);
+			return;
 		case "objectComprehension":
 			collectLocalBindingFromBinding(node.binding, locals);
 			collectLocalBindings(node.key, locals);
 			collectLocalBindings(node.value, locals);
 			return;
+		case "whileObjectComprehension":
+			collectLocalBindings(node.condition, locals);
+			collectLocalBindings(node.key, locals);
+			collectLocalBindings(node.value, locals);
+			return;
 		default:
 			return;
 	}
@@ -1952,6 +2025,10 @@ function collectNameFrequencies(node: IRNode, locals: Set<string>, frequencies:
 			collectNameFrequencies(node.left, locals, frequencies, order, nextOrder);
 			collectNameFrequencies(node.right, locals, frequencies, order, nextOrder);
 			return;
+		case "range":
+			collectNameFrequencies(node.from, locals, frequencies, order, nextOrder);
+			collectNameFrequencies(node.to, locals, frequencies, order, nextOrder);
+			return;
 		case "conditional":
 			collectNameFrequencies(node.condition, locals, frequencies, order, nextOrder);
 			for (const part of node.thenBlock) collectNameFrequencies(part, locals, frequencies, order, nextOrder);
@@ -1965,11 +2042,20 @@ function collectNameFrequencies(node: IRNode, locals: Set<string>, frequencies:
 			collectNameFrequenciesBinding(node.binding, locals, frequencies, order, nextOrder);
 			collectNameFrequencies(node.body, locals, frequencies, order, nextOrder);
 			return;
+		case "whileArrayComprehension":
+			collectNameFrequencies(node.condition, locals, frequencies, order, nextOrder);
+			collectNameFrequencies(node.body, locals, frequencies, order, nextOrder);
+			return;
 		case "objectComprehension":
 			collectNameFrequenciesBinding(node.binding, locals, frequencies, order, nextOrder);
 			collectNameFrequencies(node.key, locals, frequencies, order, nextOrder);
 			collectNameFrequencies(node.value, locals, frequencies, order, nextOrder);
 			return;
+		case "whileObjectComprehension":
+			collectNameFrequencies(node.condition, locals, frequencies, order, nextOrder);
+			collectNameFrequencies(node.key, locals, frequencies, order, nextOrder);
+			collectNameFrequencies(node.value, locals, frequencies, order, nextOrder);
+			return;
 		default:
 			return;
 	}
@@ -2046,6 +2132,12 @@ function renameLocalNames(node: IRNode, map: Map<string, string>): IRNode {
 				left: renameLocalNames(node.left, map),
 				right: renameLocalNames(node.right, map),
 			} satisfies IRNode;
+		case "range":
+			return {
+				type: "range",
+				from: renameLocalNames(node.from, map),
+				to: renameLocalNames(node.to, map),
+			} satisfies IRNode;
 		case "assign": {
 			const place = node.place.type === "identifier" && map.has(node.place.name)
 				? ({ type: "identifier", name: map.get(node.place.name) as string } satisfies IRNode)
@@ -2077,6 +2169,12 @@ function renameLocalNames(node: IRNode, map: Map<string, string>): IRNode {
 				binding: renameLocalNamesBinding(node.binding, map),
 				body: renameLocalNames(node.body, map),
 			} satisfies IRNode;
+		case "whileArrayComprehension":
+			return {
+				type: "whileArrayComprehension",
+				condition: renameLocalNames(node.condition, map),
+				body: renameLocalNames(node.body, map),
+			} satisfies IRNode;
 		case "objectComprehension":
 			return {
 				type: "objectComprehension",
@@ -2084,35 +2182,32 @@ function renameLocalNames(node: IRNode, map: Map<string, string>): IRNode {
 				key: renameLocalNames(node.key, map),
 				value: renameLocalNames(node.value, map),
 			} satisfies IRNode;
+		case "whileObjectComprehension":
+			return {
+				type: "whileObjectComprehension",
+				condition: renameLocalNames(node.condition, map),
+				key: renameLocalNames(node.key, map),
+				value: renameLocalNames(node.value, map),
+			} satisfies IRNode;
 		default:
 			return node;
 	}
 }
 
 function renameLocalNamesBinding(binding: IRBindingOrExpr, map: Map<string, string>): IRBindingOrExpr {
-	if (binding.type === "binding:expr") {
-		return { type: "binding:expr", source: renameLocalNames(binding.source, map) } satisfies IRBindingOrExpr;
+	const source = renameLocalNames(binding.source, map);
+	switch (binding.type) {
+		case "binding:bareIn":
+			return { type: "binding:bareIn", source };
+		case "binding:bareOf":
+			return { type: "binding:bareOf", source };
+		case "binding:valueIn":
+			return { type: "binding:valueIn", value: map.get(binding.value) ?? binding.value, source };
+		case "binding:keyValueIn":
+			return { type: "binding:keyValueIn", key: map.get(binding.key) ?? binding.key, value: map.get(binding.value) ?? binding.value, source };
+		case "binding:keyOf":
+			return { type: "binding:keyOf", key: map.get(binding.key) ?? binding.key, source };
 	}
-	if (binding.type === "binding:valueIn") {
-		return {
-			type: "binding:valueIn",
-			value: map.get(binding.value) ?? binding.value,
-			source: renameLocalNames(binding.source, map),
-		} satisfies IRBinding;
-	}
-	if (binding.type === "binding:keyValueIn") {
-		return {
-			type: "binding:keyValueIn",
-			key: map.get(binding.key) ?? binding.key,
-			value: map.get(binding.value) ?? binding.value,
-			source: renameLocalNames(binding.source, map),
-		} satisfies IRBinding;
-	}
-	return {
-		type: "binding:keyOf",
-		key: map.get(binding.key) ?? binding.key,
-		source: renameLocalNames(binding.source, map),
-	} satisfies IRBinding;
 }
 
 function renameLocalNamesElse(elseBranch: IRConditionalElse, map: Map<string, string>): IRConditionalElse {
@@ -2163,9 +2258,9 @@ export function compile(source: string, options?: CompileOptions): string {
 	const ir = parseToIR(source);
 	let lowered = options?.optimize ? optimizeIR(ir) : ir;
 	if (options?.minifyNames) lowered = minifyLocalNamesIR(lowered);
-	const domainRefs = options?.domainConfig ? domainRefsFromConfig(options.domainConfig) : undefined;
+	const domainMaps = options?.domainConfig ? domainRefsFromConfig(options.domainConfig) : undefined;
 	return encodeIR(lowered, {
-		domainRefs,
+		...domainMaps,
 		dedupeValues: options?.dedupeValues,
 		dedupeMinBytes: options?.dedupeMinBytes,
 	});
@@ -2299,6 +2394,9 @@ semantics.addOperation("toIR", {
 	ExistenceExpr_or(left, _or, right) {
 		return { type: "binary", op: "or", left: left.toIR(), right: right.toIR() } satisfies IRNode;
 	},
+	ExistenceExpr_nor(left, _nor, right) {
+		return { type: "binary", op: "nor", left: left.toIR(), right: right.toIR() } satisfies IRNode;
+	},
 
 	BitExpr_and(left, _op, right) {
 		return { type: "binary", op: "bitAnd", left: left.toIR(), right: right.toIR() } satisfies IRNode;
@@ -2310,6 +2408,10 @@ semantics.addOperation("toIR", {
 		return { type: "binary", op: "bitOr", left: left.toIR(), right: right.toIR() } satisfies IRNode;
 	},
 
+	RangeExpr_range(left, _op, right) {
+		return { type: "range", from: left.toIR(), to: right.toIR() } satisfies IRNode;
+	},
+
 	CompareExpr_binary(left, op, right) {
 		const map: Record<string, Extract<IRNode, { type: "binary" }>["op"]> = {
 			"==": "eq",
@@ -2352,6 +2454,9 @@ semantics.addOperation("toIR", {
 	UnaryExpr_not(_op, value) {
 		return { type: "unary", op: "not", value: value.toIR() } satisfies IRNode;
 	},
+	UnaryExpr_logicalNot(_not, value) {
+		return { type: "unary", op: "logicalNot", value: value.toIR() } satisfies IRNode;
+	},
 	UnaryExpr_delete(_del, place) {
 		return { type: "unary", op: "delete", value: place.toIR() } satisfies IRNode;
 	},
@@ -2408,13 +2513,6 @@ semantics.addOperation("toIR", {
 		return { type: "else", block: block.toIR() as IRNode[] } satisfies IRConditionalElse;
 	},
 
-	DoExpr(_do, block, _end) {
-		const body = block.toIR() as IRNode[];
-		if (body.length === 0) return { type: "undefined" } satisfies IRNode;
-		if (body.length === 1) return body[0] as IRNode;
-		return { type: "program", body } satisfies IRNode;
-	},
-
 	WhileExpr(_while, condition, _do, block, _end) {
 		return {
 			type: "while",
@@ -2426,25 +2524,39 @@ semantics.addOperation("toIR", {
 	ForExpr(_for, binding, _do, block, _end) {
 		return {
 			type: "for",
-			binding: binding.toIR() as IRBindingOrExpr,
+			binding: binding.toIR() as IRBinding,
 			body: block.toIR() as IRNode[],
 		} satisfies IRNode;
 	},
-	BindingExpr(iterOrExpr) {
-		const node = iterOrExpr.toIR();
-		if (typeof node === "object" && node && "type" in node && String(node.type).startsWith("binding:")) {
-			return node as IRBinding;
-		}
-		return { type: "binding:expr", source: node as IRNode } satisfies IRBindingOrExpr;
-	},
 
 	Array_empty(_open, _close) {
 		return { type: "array", items: [] } satisfies IRNode;
 	},
-	Array_comprehension(_open, binding, _semi, body, _close) {
+	Array_forComprehension(_open, body, _for, binding, _close) {
+		return {
+			type: "arrayComprehension",
+			binding: binding.toIR() as IRBinding,
+			body: body.toIR(),
+		} satisfies IRNode;
+	},
+	Array_whileComprehension(_open, body, _while, condition, _close) {
+		return {
+			type: "whileArrayComprehension",
+			condition: condition.toIR(),
+			body: body.toIR(),
+		} satisfies IRNode;
+	},
+	Array_inComprehension(_open, body, _in, source, _close) {
 		return {
 			type: "arrayComprehension",
-			binding: binding.toIR() as IRBindingOrExpr,
+			binding: { type: "binding:bareIn", source: source.toIR() } satisfies IRBinding,
+			body: body.toIR(),
+		} satisfies IRNode;
+	},
+	Array_ofComprehension(_open, body, _of, source, _close) {
+		return {
+			type: "arrayComprehension",
+			binding: { type: "binding:bareOf", source: source.toIR() } satisfies IRBinding,
 			body: body.toIR(),
 		} satisfies IRNode;
 	},
@@ -2455,10 +2567,34 @@ semantics.addOperation("toIR", {
 	Object_empty(_open, _close) {
 		return { type: "object", entries: [] } satisfies IRNode;
 	},
-	Object_comprehension(_open, binding, _semi, key, _colon, value, _close) {
+	Object_forComprehension(_open, key, _colon, value, _for, binding, _close) {
 		return {
 			type: "objectComprehension",
-			binding: binding.toIR() as IRBindingOrExpr,
+			binding: binding.toIR() as IRBinding,
+			key: key.toIR(),
+			value: value.toIR(),
+		} satisfies IRNode;
+	},
+	Object_whileComprehension(_open, key, _colon, value, _while, condition, _close) {
+		return {
+			type: "whileObjectComprehension",
+			condition: condition.toIR(),
+			key: key.toIR(),
+			value: value.toIR(),
+		} satisfies IRNode;
+	},
+	Object_inComprehension(_open, key, _colon, value, _in, source, _close) {
+		return {
+			type: "objectComprehension",
+			binding: { type: "binding:bareIn", source: source.toIR() } satisfies IRBinding,
+			key: key.toIR(),
+			value: value.toIR(),
+		} satisfies IRNode;
+	},
+	Object_ofComprehension(_open, key, _colon, value, _of, source, _close) {
+		return {
+			type: "objectComprehension",
+			binding: { type: "binding:bareOf", source: source.toIR() } satisfies IRBinding,
 			key: key.toIR(),
 			value: value.toIR(),
 		} satisfies IRNode;
@@ -2492,6 +2628,40 @@ semantics.addOperation("toIR", {
 			source: source.toIR(),
 		} satisfies IRBinding;
 	},
+	IterBinding_bareIn(_in, source) {
+		return {
+			type: "binding:bareIn",
+			source: source.toIR(),
+		} satisfies IRBinding;
+	},
+	IterBinding_bareOf(_of, source) {
+		return {
+			type: "binding:bareOf",
+			source: source.toIR(),
+		} satisfies IRBinding;
+	},
+	IterBindingComprehension_keyValueIn(key, _comma, value, _in, source) {
+		return {
+			type: "binding:keyValueIn",
+			key: key.sourceString,
+			value: value.sourceString,
+			source: source.toIR(),
+		} satisfies IRBinding;
+	},
+	IterBindingComprehension_valueIn(value, _in, source) {
+		return {
+			type: "binding:valueIn",
+			value: value.sourceString,
+			source: source.toIR(),
+		} satisfies IRBinding;
+	},
+	IterBindingComprehension_keyOf(key, _of, source) {
+		return {
+			type: "binding:keyOf",
+			key: key.sourceString,
+			source: source.toIR(),
+		} satisfies IRBinding;
+	},
 
 	Pair(key, _colon, value) {
 		return { key: key.toIR(), value: value.toIR() };