@creationix/rex 0.3.0 → 0.4.1

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,40 @@ 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",
+	size: "sz",
 } 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", "size"]);
+
 type EncodeOptions = {
-	domainRefs?: Record<string, number>;
+	domainRefs?: Record<string, string>;
+	domainOpcodes?: Record<string, string>;
 };
 
 type CompileOptions = {
@@ -141,10 +158,7 @@ type RexDomainConfigEntry = {
 	names?: unknown;
 };
 
-const FIRST_NON_RESERVED_REF = 5;
-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",
@@ -250,10 +264,32 @@ function encodeBareOrLengthString(value: string): string {
 	return `${encodeUint(byteLength(value))},${value}`;
 }
 
+const DEC_PARTS = /^(-?\d)(?:\.(\d+))?e([+-]\d+)$/;
+
+function splitDecimal(num: number): { base: number; exp: number } {
+	const match = num.toExponential().match(DEC_PARTS);
+	if (!match) throw new Error(`Failed to split decimal for ${num}`);
+	const [, b1, b2 = "", e1] = match as RegExpMatchArray;
+	const base = Number.parseInt(b1 + b2, 10);
+	const exp = Number.parseInt(e1!, 10) - b2.length;
+	return { base, exp };
+}
+
+function encodeDecimal(significand: number, power: number): string {
+	return `${encodeZigzag(power)}*${encodeInt(significand)}`;
+}
+
 function encodeNumberNode(node: Extract<IRNode, { type: "number" }>): string {
 	const numberValue = node.value;
-	if (!Number.isFinite(numberValue)) throw new Error(`Cannot encode non-finite number: ${node.raw}`);
-	if (Number.isInteger(numberValue)) return encodeInt(numberValue);
+	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);
+		if (exp >= 0 && exp <= 4) return encodeInt(numberValue);
+		return encodeDecimal(base, exp);
+	}
 
 	const raw = node.raw.toLowerCase();
 	const sign = raw.startsWith("-") ? -1 : 1;
@@ -276,11 +312,11 @@ function encodeNumberNode(node: Extract<IRNode, { type: "number" }>): string {
 		significand /= 10;
 		power += 1;
 	}
-	return `${encodeZigzag(power)}*${encodeInt(significand)}`;
+	return encodeDecimal(significand, power);
 }
 
 function encodeOpcode(opcode: OpcodeName): string {
-	return `${encodeUint(OPCODE_IDS[opcode])}%`;
+	return `${OPCODE_IDS[opcode]}%`;
 }
 
 function encodeCallParts(parts: string[]): string {
@@ -299,7 +335,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("(")) {
@@ -312,7 +348,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))]);
 }
@@ -329,9 +365,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;
@@ -340,15 +381,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));
@@ -373,9 +417,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})`;
 	}
@@ -387,31 +434,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;
@@ -422,7 +488,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":
@@ -433,11 +501,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":
@@ -448,6 +516,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))}`)
@@ -456,6 +526,8 @@ function encodeNode(node: IRNode): string {
 		}
 		case "objectComprehension":
 			return encodeObjectComprehension(node);
+		case "whileObjectComprehension":
+			return encodeWhileObjectComprehension(node);
 		case "key":
 			return encodeBareOrLengthString(node.name);
 		case "group":
@@ -463,6 +535,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") {
@@ -485,12 +561,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}`);
@@ -499,8 +581,14 @@ function encodeNode(node: IRNode): string {
 		}
 		case "navigation":
 			return encodeNavigation(node);
-		case "call":
+		case "call": {
+			// Keyword identifiers (boolean, number, string, array, object, size) 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);
@@ -508,6 +596,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":
@@ -587,6 +677,17 @@ function isBareKeyName(key: string): boolean {
 	return /^[A-Za-z_][A-Za-z0-9_-]*$/.test(key);
 }
 
+function isNumericKey(key: string): boolean {
+	if (key === "") return false;
+	return String(Number(key)) === key && Number.isFinite(Number(key));
+}
+
+function stringifyKey(key: string): string {
+	if (isBareKeyName(key)) return key;
+	if (isNumericKey(key)) return key;
+	return stringifyString(key);
+}
+
 function stringifyString(value: string): string {
 	return JSON.stringify(value);
 }
@@ -596,7 +697,9 @@ function stringifyInline(value: unknown): string {
 	if (value === null) return "null";
 	if (typeof value === "boolean") return value ? "true" : "false";
 	if (typeof value === "number") {
-		if (!Number.isFinite(value)) throw new Error("Rex stringify() cannot encode non-finite numbers");
+		if (Number.isNaN(value)) return "nan";
+		if (value === Infinity) return "inf";
+		if (value === -Infinity) return "-inf";
 		return String(value);
 	}
 	if (typeof value === "string") return stringifyString(value);
@@ -608,7 +711,7 @@ function stringifyInline(value: unknown): string {
 		const entries = Object.entries(value);
 		if (entries.length === 0) return "{}";
 		const body = entries
-			.map(([key, item]) => `${isBareKeyName(key) ? key : stringifyString(key)}: ${stringifyInline(item)}`)
+			.map(([key, item]) => `${stringifyKey(key)}: ${stringifyInline(item)}`)
 			.join(" ");
 		return `{${body}}`;
 	}
@@ -641,7 +744,7 @@ function stringifyPretty(value: unknown, depth: number, indentSize: number, maxW
 		const entries = Object.entries(value);
 		if (entries.length === 0) return "{}";
 		const lines = entries.map(([key, item]) => {
-			const keyText = isBareKeyName(key) ? key : stringifyString(key);
+			const keyText = stringifyKey(key);
 			const rendered = stringifyPretty(item, depth + 1, indentSize, maxWidth);
 			return `${childIndent}${keyText}: ${rendered}`;
 		});
@@ -655,81 +758,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)`);
+	const dataSection = configObj.data;
+	if (dataSection && typeof dataSection === "object" && !Array.isArray(dataSection)) {
+		mapConfigEntries(dataSection as Record<string, unknown>, domainRefs);
 	}
 
-	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 functionsSection = configObj.functions;
+	if (functionsSection && typeof functionsSection === "object" && !Array.isArray(functionsSection)) {
+		mapConfigEntries(functionsSection as Record<string, unknown>, domainOpcodes);
 	}
 
-	if (value < FIRST_NON_RESERVED_REF) {
-		throw new Error(`Invalid domain ref key '${refText}' (maps to reserved id ${value})`);
-	}
-
-	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);
 		}
 	}
@@ -1018,6 +1102,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":
@@ -1039,11 +1139,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;
@@ -1074,6 +1183,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;
@@ -1116,6 +1229,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;
 	}
@@ -1188,6 +1303,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:
@@ -1210,6 +1327,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:
@@ -1267,6 +1386,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;
 	}
@@ -1308,7 +1433,12 @@ function inlineAdjacentPureAssignments(block: IRNode[]): IRNode[] {
 }
 
 function toNumberNode(value: number): IRNode {
-	return { type: "number", raw: String(value), value } satisfies IRNode;
+	let raw: string;
+	if (Number.isNaN(value)) raw = "nan";
+	else if (value === Infinity) raw = "inf";
+	else if (value === -Infinity) raw = "-inf";
+	else raw = String(value);
+	return { type: "number", raw, value } satisfies IRNode;
 }
 
 function toStringNode(value: string): IRNode {
@@ -1319,7 +1449,7 @@ function toLiteralNode(value: unknown): IRNode | undefined {
 	if (value === undefined) return { type: "undefined" } satisfies IRNode;
 	if (value === null) return { type: "null" } satisfies IRNode;
 	if (typeof value === "boolean") return { type: "boolean", value } satisfies IRNode;
-	if (typeof value === "number" && Number.isFinite(value)) return toNumberNode(value);
+	if (typeof value === "number") return toNumberNode(value);
 	if (typeof value === "string") return toStringNode(value);
 	if (Array.isArray(value)) {
 		const items: IRNode[] = [];
@@ -1395,6 +1525,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;
 }
 
@@ -1557,6 +1690,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"
@@ -1666,31 +1805,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 {
@@ -1701,26 +1816,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 {
@@ -1729,28 +1825,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 {
@@ -1760,6 +1843,13 @@ 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;
 	}
@@ -1808,6 +1898,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);
@@ -1821,11 +1915,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;
 	}
@@ -1912,6 +2015,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);
@@ -1925,11 +2032,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;
 	}
@@ -2006,6 +2122,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)
@@ -2037,6 +2159,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",
@@ -2044,35 +2172,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 {
@@ -2123,9 +2248,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,
 	});
@@ -2137,6 +2262,9 @@ type IRPostfixStep =
 	| { kind: "call"; args: IRNode[] };
 
 function parseNumber(raw: string) {
+	if (raw === "nan") return NaN;
+	if (raw === "inf") return Infinity;
+	if (raw === "-inf") return -Infinity;
 	if (/^-?0x/i.test(raw)) return parseInt(raw, 16);
 	if (/^-?0b/i.test(raw)) {
 		const isNegative = raw.startsWith("-");
@@ -2256,6 +2384,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;
@@ -2267,6 +2398,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",
@@ -2309,6 +2444,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;
 	},
@@ -2365,13 +2503,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",
@@ -2383,25 +2514,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 IRBindingOrExpr,
+			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: { 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;
 	},
@@ -2412,10 +2557,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;
@@ -2449,6 +2618,18 @@ 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;
+	},
 
 	Pair(key, _colon, value) {
 		return { key: key.toIR(), value: value.toIR() };
@@ -2514,6 +2695,9 @@ semantics.addOperation("toIR", {
 	BooleanKw(_kw) {
 		return { type: "identifier", name: "boolean" } satisfies IRNode;
 	},
+	SizeKw(_kw) {
+		return { type: "identifier", name: "size" } satisfies IRNode;
+	},
 
 	identifier(_a, _b) {
 		return { type: "identifier", name: this.sourceString } satisfies IRNode;