@oh-my-pi/omptype 17.2.6 → 17.2.7

package/src/compile.ts

@@ -11,12 +11,12 @@
  *   arrays and messages are inline literals, so cost is one small allocation
  * - morphing nodes (defaults, `"+": "delete"`, embedded stepped schemas)
  *   produce a fresh output object; pure subtrees below them stay check-only
- * - union members that morph are validated by hoisted interpreter closures;
- *   pure members compile to inline predicates
+ * - morphing union members use separately compiled or hoisted runners; pure
+ *   members compile to inline predicates
  */
 import { MISSING, OmpErrors } from "./errors";
-import { unionFail, walk } from "./interp";
-import { expectedOf, hasMorph, type IR, type PropIR } from "./ir";
+import { canRefineUnionFailure, unionFail, walk } from "./interp";
+import { expectedOf, hasMorph, type IR, type MorphContext, type PropIR, type TupleIR } from "./ir";
 
 const own = Object.prototype.hasOwnProperty;
 
@@ -43,9 +43,57 @@ function litSource(v: unknown): string | undefined {
 
 type PathSeg = { s: PropertyKey } | { d: string };
 
+type LiteralIR = Extract<IR, { k: "lit" }>;
+
+function isPrimitiveLiteral(node: IR): node is LiteralIR {
+	return node.k === "lit" && (node.v === null || (typeof node.v !== "object" && typeof node.v !== "function"));
+}
+
+/** Whether `undefined` necessarily fails, allowing property-presence checks to be elided. */
+function rejectsUndefined(node: IR): boolean {
+	switch (node.k) {
+		case "unknown":
+		case "undefined":
+		case "alias":
+		case "sub":
+			return false;
+		case "lit":
+			return node.v !== undefined;
+		case "union":
+			return node.members.every(rejectsUndefined);
+		case "intersection":
+			return node.members.some(rejectsUndefined);
+		case "refine":
+			return rejectsUndefined(node.base);
+		case "morph":
+			return rejectsUndefined(node.input);
+		default:
+			return true;
+	}
+}
+
+class CompiledMorphContext implements MorphContext {
+	#path: PropertyKey[] | PropertyKey | undefined;
+	#data: unknown;
+
+	constructor(path: PropertyKey[] | PropertyKey | undefined, data: unknown) {
+		this.#path = path;
+		this.#data = data;
+	}
+
+	error(expectation: string): OmpErrors {
+		return new OmpErrors(this.#path, expectation, this.#data);
+	}
+
+	reject(expectation: string): OmpErrors {
+		return this.error(expectation);
+	}
+}
+
 class Builder {
 	#lines: string[] = [];
 	#refs: unknown[] = [];
+	#activeAliases: Set<IR> | undefined;
 	#id = 0;
 
 	next(prefix: string): string {
@@ -72,8 +120,22 @@ class Builder {
 		return `[${parts.join(",")}]`;
 	}
 
+	storedPathExpr(segs: PathSeg[]): string {
+		if (segs.length === 0) return "undefined";
+		if (segs.length === 1) {
+			const seg = segs[0];
+			return "s" in seg ? JSON.stringify(seg.s) : seg.d;
+		}
+		const staticParts: PropertyKey[] = [];
+		for (const seg of segs) {
+			if ("d" in seg) return this.pathExpr(segs);
+			staticParts.push(seg.s);
+		}
+		return this.ref(staticParts);
+	}
+
 	fail(segs: PathSeg[], expected: string, dataExpr: string): string {
-		return `return E(${this.pathExpr(segs)},${JSON.stringify(expected)},${dataExpr})`;
+		return `return new AE(${this.storedPathExpr(segs)},${JSON.stringify(expected)},${dataExpr})`;
 	}
 
 	/** Pure boolean predicate for a morph-free subtree. */
@@ -89,10 +151,18 @@ class Builder {
 				return `typeof ${v}==="boolean"`;
 			case "bigint":
 				return `typeof ${v}==="bigint"`;
+			case "symbol":
+				return `typeof ${v}==="symbol"`;
+			case "never":
+				return "false";
 			case "anyobject":
 				return `(typeof ${v}==="object"&&${v}!==null)`;
 			case "lit":
-				return `${v}===${this.lit(node.v)}`;
+				return node.v instanceof Date
+					? `(${v} instanceof Date&&${v}.valueOf()===${node.v.valueOf()})`
+					: `${v}===${this.lit(node.v)}`;
+			case "instance":
+				return `${v} instanceof ${this.ref(node.ctor)}`;
 			case "string": {
 				let out = `typeof ${v}==="string"`;
 				if (node.min !== undefined) out += `&&${v}.length>=${node.min}`;
@@ -101,29 +171,34 @@ class Builder {
 				return out;
 			}
 			case "number": {
-				let out = `typeof ${v}==="number"`;
-				if (node.int) out += `&&Number.isInteger(${v})`;
+				let out = node.int ? `Number.isInteger(${v})` : `Number.isFinite(${v})`;
+				if (node.divisor !== undefined) out += `&&${v}%${node.divisor}===0`;
 				if (node.min !== undefined) out += `&&${v}${node.xmin ? ">" : ">="}${node.min}`;
 				if (node.max !== undefined) out += `&&${v}${node.xmax ? "<" : "<="}${node.max}`;
 				return out;
 			}
 			case "union": {
-				const lits = node.members.filter(m => m.k === "lit");
-				if (lits.length > 4) {
-					const set = this.ref(new Set(lits.map(m => m.v)));
-					const rest = node.members.filter(m => m.k !== "lit");
-					let out = `${set}.has(${v})`;
+				const lits = node.members.filter(isPrimitiveLiteral);
+				if (lits.length > 8) {
+					const values = this.ref(new Set(lits.map(member => member.v)));
+					const literalNodes = new Set<IR>(lits);
+					const rest = node.members.filter(member => !literalNodes.has(member));
+					let out = `${values}.has(${v})`;
 					for (const m of rest) out += `||(${this.predicate(m, v)})`;
 					return `(${out})`;
 				}
 				return `(${node.members.map(m => `(${this.predicate(m, v)})`).join("||")})`;
 			}
+			case "intersection":
+				return `(${node.members.map(member => `(${this.predicate(member, v)})`).join("&&")})`;
 			case "array": {
-				const x = this.next("x");
+				const array = this.next("a");
+				const index = this.next("i");
 				let out = `Array.isArray(${v})`;
 				if (node.min !== undefined) out += `&&${v}.length>=${node.min}`;
 				if (node.max !== undefined) out += `&&${v}.length<=${node.max}`;
-				out += `&&${v}.every(${x}=>${this.predicate(node.el, x)})`;
+				const item = `${array}[${index}]`;
+				out += `&&((${array})=>{for(let ${index}=0;${index}<${array}.length;${index}++)if(!(${this.predicate(node.el, item)}))return false;return true})(${v})`;
 				return out;
 			}
 			case "object": {
@@ -131,10 +206,15 @@ class Builder {
 				for (const p of node.props) {
 					const av = access(v, p.key);
 					const present = `${JSON.stringify(p.key)} in ${v}`;
+					const predicate = this.predicate(p.val, av);
 					checks.push(
 						p.opt || p.hasDefault
-							? `(!(${present})||(${this.predicate(p.val, av)}))`
-							: `((${present})&&(${this.predicate(p.val, av)}))`,
+							? rejectsUndefined(p.val)
+								? `((${av}!==undefined&&(${predicate}))||!(${present}))`
+								: `(!(${present})||(${predicate}))`
+							: rejectsUndefined(p.val)
+								? predicate
+								: `((${present})&&(${predicate}))`,
 					);
 				}
 				if (node.index) {
@@ -152,6 +232,8 @@ class Builder {
 			}
 			case "sub":
 				return `!(${this.ref(node.schema.run)}(${v}) instanceof AE)`;
+			default:
+				return `!(${this.ref(boundWalk(node))}(${v}) instanceof AE)`;
 		}
 	}
 
@@ -164,8 +246,53 @@ class Builder {
 		return `(${props.map(p => `${keyVar}===${JSON.stringify(p.key)}`).join("||")})`;
 	}
 
+	emitDelegate(node: IR, v: string, segs: PathSeg[], out?: string): void {
+		const runner = node.k === "sub" ? node.schema.run : boundWalk(node);
+		const result = this.next("r");
+		this.push(`const ${result}=${this.ref(runner)}(${v});`);
+		this.push(
+			segs.length === 0
+				? `if(${result} instanceof AE)return ${result};`
+				: `if(${result} instanceof AE)return PF(${result},${this.pathExpr(segs)});`,
+		);
+		if (out !== undefined) this.push(`${out}=${result};`);
+	}
+
+	emitTupleShape(
+		node: TupleIR,
+		v: string,
+		segs: PathSeg[],
+		failureData: string,
+	): { postfixStart: string; prefixCount: string; requiredPrefix: number } {
+		this.push(`if(!Array.isArray(${v}))${this.fail(segs, "an array", failureData)};`);
+		const requiredPrefix = node.prefix.filter(item => !item.opt && !item.hasDefault).length;
+		const minimum = requiredPrefix + node.postfix.length;
+		if (minimum > 0) {
+			this.push(
+				`if(${v}.length<${minimum})${this.fail(segs, `an array of at least length ${minimum}`, failureData)};`,
+			);
+		}
+		if (node.variadic === undefined) {
+			const maximum = node.prefix.length + node.postfix.length;
+			this.push(
+				`if(${v}.length>${maximum})${this.fail(segs, `an array of at most length ${maximum}`, failureData)};`,
+			);
+		}
+		let postfixStart = `${v}.length`;
+		if (node.postfix.length > 0) {
+			postfixStart = this.next("p");
+			this.push(`const ${postfixStart}=${v}.length-${node.postfix.length};`);
+		}
+		let prefixCount = String(node.prefix.length);
+		if (requiredPrefix !== node.prefix.length) {
+			prefixCount = this.next("n");
+			this.push(`const ${prefixCount}=Math.min(${node.prefix.length},${postfixStart});`);
+		}
+		return { postfixStart, prefixCount, requiredPrefix };
+	}
+
 	/** Statement-form check for a morph-free subtree with precise error paths. */
-	emitCheck(node: IR, v: string, segs: PathSeg[]): void {
+	emitCheck(node: IR, v: string, segs: PathSeg[], failureData = v): void {
 		switch (node.k) {
 			case "unknown":
 				return;
@@ -173,7 +300,7 @@ class Builder {
 				let head = `Array.isArray(${v})`;
 				if (node.min !== undefined) head += `&&${v}.length>=${node.min}`;
 				if (node.max !== undefined) head += `&&${v}.length<=${node.max}`;
-				this.push(`if(!(${head}))${this.fail(segs, expectedOf(node), v)};`);
+				this.push(`if(!(${head}))${this.fail(segs, expectedOf(node), failureData)};`);
 				const i = this.next("i");
 				const x = this.next("x");
 				this.push(`for(let ${i}=0;${i}<${v}.length;${i}++){const ${x}=${v}[${i}];`);
@@ -181,9 +308,28 @@ class Builder {
 				this.push("}");
 				return;
 			}
+			case "tuple": {
+				const { postfixStart, prefixCount, requiredPrefix } = this.emitTupleShape(node, v, segs, failureData);
+				for (let index = 0; index < node.prefix.length; index++) {
+					if (index >= requiredPrefix) this.push(`if(${index}<${prefixCount}){`);
+					this.emitCheck(node.prefix[index].val, `${v}[${index}]`, [...segs, { d: String(index) }]);
+					if (index >= requiredPrefix) this.push("}");
+				}
+				if (node.variadic !== undefined) {
+					const index = this.next("i");
+					this.push(`for(let ${index}=${prefixCount};${index}<${postfixStart};${index}++){`);
+					this.emitCheck(node.variadic, `${v}[${index}]`, [...segs, { d: index }]);
+					this.push("}");
+				}
+				for (let index = 0; index < node.postfix.length; index++) {
+					const inputIndex = index === 0 ? postfixStart : `${postfixStart}+${index}`;
+					this.emitCheck(node.postfix[index], `${v}[${inputIndex}]`, [...segs, { d: inputIndex }]);
+				}
+				return;
+			}
 			case "object": {
 				this.push(
-					`if(typeof ${v}!=="object"||${v}===null||Array.isArray(${v}))${this.fail(segs, "an object", v)};`,
+					`if(typeof ${v}!=="object"||${v}===null||Array.isArray(${v}))${this.fail(segs, "an object", failureData)};`,
 				);
 				for (const p of node.props) {
 					const present = `${JSON.stringify(p.key)} in ${v}`;
@@ -214,17 +360,46 @@ class Builder {
 				}
 				return;
 			}
-			case "sub": {
-				const r = this.next("r");
-				this.push(`const ${r}=${this.ref(node.schema.run)}(${v});`);
-				this.push(`if(${r} instanceof AE)return PF(${r},${this.pathExpr(segs)});`);
+			case "sub":
+				this.emitDelegate(node, v, segs);
+				return;
+			case "union": {
+				const failure = node.members.some(canRefineUnionFailure)
+					? `return UF(${this.ref(node)},${failureData},${this.pathExpr(segs)},${JSON.stringify(expectedOf(node))})`
+					: this.fail(segs, expectedOf(node), failureData);
+				const literals = node.members.filter(isPrimitiveLiteral);
+				if (literals.length === node.members.length && literals.length >= 4) {
+					const cases = literals.map(member => `case ${this.lit(member.v)}:`).join("");
+					this.push(`switch(${v}){${cases}break;default:${failure};}`);
+				} else {
+					this.push(`if(!(${this.predicate(node, v)}))${failure};`);
+				}
 				return;
 			}
-			case "union":
-				this.push(`if(!(${this.predicate(node, v)}))return UF(${this.ref(node)},${v},${this.pathExpr(segs)});`);
+			case "null":
+			case "undefined":
+			case "boolean":
+			case "bigint":
+			case "symbol":
+			case "never":
+			case "anyobject":
+			case "lit":
+			case "string":
+			case "number":
+			case "instance":
+				this.push(`if(!(${this.predicate(node, v)}))${this.fail(segs, expectedOf(node), failureData)};`);
+				return;
+			case "refine": {
+				this.emitCheck(node.base, v, segs, failureData);
+				const failure = this.fail(segs, node.expected, v);
+				this.push(`try{if(!${this.ref(node.pred)}(${v}))${failure};}catch{${failure};}`);
+				return;
+			}
+			case "intersection":
+				for (const member of node.members) this.emitCheck(member, v, segs, failureData);
 				return;
 			default:
-				this.push(`if(!(${this.predicate(node, v)}))${this.fail(segs, expectedOf(node), v)};`);
+				this.emitDelegate(node, v, segs);
 		}
 	}
 
@@ -232,18 +407,45 @@ class Builder {
 	 * Validate `v` against a morphing subtree and assign the produced output
 	 * to `out` (an already-declared `let`).
 	 */
-	emitProduce(node: IR, v: string, segs: PathSeg[], out: string): void {
+	emitProduce(node: IR, v: string, segs: PathSeg[], out: string, failureData = v): void {
 		if (!hasMorph(node)) {
-			this.emitCheck(node, v, segs);
+			this.emitCheck(node, v, segs, failureData);
 			this.push(`${out}=${v};`);
 			return;
 		}
 		switch (node.k) {
-			case "sub": {
-				const r = this.next("r");
-				this.push(`const ${r}=${this.ref(node.schema.run)}(${v});`);
-				this.push(`if(${r} instanceof AE)return PF(${r},${this.pathExpr(segs)});`);
-				this.push(`${out}=${r};`);
+			case "sub":
+				this.emitDelegate(node, v, segs, out);
+				return;
+			case "morph": {
+				const input = this.next("t");
+				this.push(`let ${input};`);
+				this.emitProduce(node.input, v, segs, input, failureData);
+				const context = this.next("c");
+				const result = this.next("r");
+				this.push(`const ${context}=new MC(${this.storedPathExpr(segs)},${input});`);
+				this.push(`const ${result}=${this.ref(node.fn)}(${input},${context});`);
+				this.push(`if(${result} instanceof AE)return ${result};`);
+				if (node.out === undefined) this.push(`${out}=${result};`);
+				else this.emitProduce(node.out, result, segs, out);
+				return;
+			}
+			case "alias": {
+				let active = this.#activeAliases;
+				if (active === undefined) {
+					active = new Set();
+					this.#activeAliases = active;
+				}
+				if (active.has(node)) {
+					this.emitDelegate(node, v, segs, out);
+					return;
+				}
+				active.add(node);
+				try {
+					this.emitProduce(node.resolve(), v, segs, out, failureData);
+				} finally {
+					active.delete(node);
+				}
 				return;
 			}
 			case "union": {
@@ -258,21 +460,23 @@ class Builder {
 				}
 				for (const m of node.members) {
 					if (m.k === "sub" || hasMorph(m)) {
-						const runner = m.k === "sub" ? m.schema.run : boundWalk(m);
+						const runner = m.k === "sub" ? m.schema.run : m.k === "alias" ? boundWalk(m) : compile(m);
 						const r = this.next("r");
 						this.push(`const ${r}=${this.ref(runner)}(${v});`);
 						this.push(`if(!(${r} instanceof AE)){${out}=${r};${ok}=true;break ${label};}`);
 					}
 				}
 				this.push("}");
-				this.push(`if(!${ok})return UF(${this.ref(node)},${v},${this.pathExpr(segs)});`);
+				this.push(
+					`if(!${ok})return UF(${this.ref(node)},${failureData},${this.pathExpr(segs)},${JSON.stringify(expectedOf(node))});`,
+				);
 				return;
 			}
 			case "array": {
 				let head = `Array.isArray(${v})`;
 				if (node.min !== undefined) head += `&&${v}.length>=${node.min}`;
 				if (node.max !== undefined) head += `&&${v}.length<=${node.max}`;
-				this.push(`if(!(${head}))${this.fail(segs, expectedOf(node), v)};`);
+				this.push(`if(!(${head}))${this.fail(segs, expectedOf(node), failureData)};`);
 				const arr = this.next("a");
 				const i = this.next("i");
 				const x = this.next("x");
@@ -284,12 +488,63 @@ class Builder {
 				this.push(`${out}=${arr};`);
 				return;
 			}
+			case "tuple": {
+				const { postfixStart, prefixCount, requiredPrefix } = this.emitTupleShape(node, v, segs, failureData);
+				const tuple = this.next("a");
+				this.push(`const ${tuple}=[...${v}];`);
+				for (let index = 0; index < node.prefix.length; index++) {
+					const item = node.prefix[index];
+					const input = `${v}[${index}]`;
+					const output = `${tuple}[${index}]`;
+					if (index >= requiredPrefix) this.push(`if(${index}<${prefixCount}){`);
+					if (hasMorph(item.val)) this.emitProduce(item.val, input, [...segs, { d: String(index) }], output);
+					else {
+						this.emitCheck(item.val, input, [...segs, { d: String(index) }]);
+						this.push(`${output}=${input};`);
+					}
+					if (index >= requiredPrefix) {
+						if (item.hasDefault) {
+							const defaultValue = item.defFactory ? `${this.ref(item.def)}()` : this.lit(item.def);
+							this.push(`}else{${output}=${defaultValue};}`);
+						} else {
+							this.push("}");
+						}
+					}
+				}
+				if (node.variadic !== undefined) {
+					const index = this.next("i");
+					const input = this.next("x");
+					this.push(
+						`for(let ${index}=${prefixCount};${index}<${postfixStart};${index}++){const ${input}=${v}[${index}];`,
+					);
+					if (hasMorph(node.variadic)) {
+						this.emitProduce(node.variadic, input, [...segs, { d: index }], `${tuple}[${index}]`);
+					} else {
+						this.emitCheck(node.variadic, input, [...segs, { d: index }]);
+						this.push(`${tuple}[${index}]=${input};`);
+					}
+					this.push("}");
+				}
+				for (let index = 0; index < node.postfix.length; index++) {
+					const inputIndex = index === 0 ? postfixStart : `${postfixStart}+${index}`;
+					const input = `${v}[${inputIndex}]`;
+					const output = `${tuple}[${inputIndex}]`;
+					const item = node.postfix[index];
+					if (hasMorph(item)) this.emitProduce(item, input, [...segs, { d: inputIndex }], output);
+					else {
+						this.emitCheck(item, input, [...segs, { d: inputIndex }]);
+						this.push(`${output}=${input};`);
+					}
+				}
+				this.push(`${out}=${tuple};`);
+				return;
+			}
 			case "object": {
 				this.push(
-					`if(typeof ${v}!=="object"||${v}===null||Array.isArray(${v}))${this.fail(segs, "an object", v)};`,
+					`if(typeof ${v}!=="object"||${v}===null||Array.isArray(${v}))${this.fail(segs, "an object", failureData)};`,
 				);
 				const o = this.next("o");
-				const fresh = node.extras === "delete" && !node.index;
+				const fresh = node.extras !== "keep" && !node.index;
 				this.push(fresh ? `const ${o}={};` : `const ${o}={...${v}};`);
 				for (const p of node.props) {
 					const present = `${JSON.stringify(p.key)} in ${v}`;
@@ -303,8 +558,6 @@ class Builder {
 						missing.push(`${ao}=${dflt};`);
 					} else if (!p.opt) {
 						missing.push(`${this.fail(propSegs, expectedOf(p.val), "M")};`);
-					} else if (fresh) {
-						// optional + absent under "delete": nothing to copy
 					}
 					this.push(`if(!(${present})){${missing.join("")}}else{`);
 					if (morphChild) {
@@ -343,10 +596,27 @@ class Builder {
 				this.push(`${out}=${o};`);
 				return;
 			}
+			case "refine": {
+				const refined = this.next("t");
+				this.push(`let ${refined};`);
+				this.emitProduce(node.base, v, segs, refined, failureData);
+				const failure = this.fail(segs, node.expected, refined);
+				this.push(`try{if(!${this.ref(node.pred)}(${refined}))${failure};}catch{${failure};}`);
+				this.push(`${out}=${refined};`);
+				return;
+			}
+			case "intersection": {
+				const current = this.next("t");
+				this.push(`let ${current}=${v};`);
+				for (const member of node.members) {
+					if (hasMorph(member)) this.emitProduce(member, current, segs, current);
+					else this.emitCheck(member, current, segs);
+				}
+				this.push(`${out}=${current};`);
+				return;
+			}
 			default:
-				// morph-free kinds are handled by the hasMorph guard above
-				this.emitCheck(node, v, segs);
-				this.push(`${out}=${v};`);
+				this.emitDelegate(node, v, segs, out);
 		}
 	}
 
@@ -362,16 +632,99 @@ class Builder {
 			ret = "v";
 		}
 		const src = `return function(v){${this.#lines.join("")}return ${ret}}`;
-		const make = new Function("R", "E", "AE", "M", "PF", "UF", "own", src) as (
+		const make = new Function("R", "AE", "M", "PF", "UF", "MC", "own", src) as (
 			refs: unknown[],
-			e: typeof OmpErrors.single,
 			ae: typeof OmpErrors,
 			m: typeof MISSING,
 			pf: typeof prefixErrors,
 			uf: typeof unionFail,
+			mc: typeof CompiledMorphContext,
 			ownFn: typeof own,
 		) => (value: unknown) => unknown;
-		return make(this.#refs, OmpErrors.single, OmpErrors, MISSING, prefixErrors, unionFail, own);
+		return make(this.#refs, OmpErrors, MISSING, prefixErrors, unionFail, CompiledMorphContext, own);
+	}
+
+	emitAllows(node: IR, v: string): void {
+		switch (node.k) {
+			case "array": {
+				const array = this.next("a");
+				const index = this.next("i");
+				this.push(`const ${array}=${v};if(!Array.isArray(${array}))return false;`);
+				if (node.min !== undefined) this.push(`if(${array}.length<${node.min})return false;`);
+				if (node.max !== undefined) this.push(`if(${array}.length>${node.max})return false;`);
+				this.push(`for(let ${index}=0;${index}<${array}.length;${index}++){`);
+				this.emitAllows(node.el, `${array}[${index}]`);
+				this.push("}");
+				return;
+			}
+			case "object": {
+				const object = this.next("o");
+				this.push(
+					`const ${object}=${v};if(typeof ${object}!=="object"||${object}===null||Array.isArray(${object}))return false;`,
+				);
+				for (const prop of node.props) {
+					const value = this.next("p");
+					const present = `${JSON.stringify(prop.key)} in ${object}`;
+					this.push(`const ${value}=${access(object, prop.key)};`);
+					if (prop.opt || prop.hasDefault) {
+						if (rejectsUndefined(prop.val)) {
+							this.push(`if(${value}!==undefined){`);
+							this.emitAllows(prop.val, value);
+							this.push(`}else if(${present})return false;`);
+						} else {
+							this.push(`if(${present}){`);
+							this.emitAllows(prop.val, value);
+							this.push("}");
+						}
+					} else {
+						if (!rejectsUndefined(prop.val)) this.push(`if(!(${present}))return false;`);
+						this.emitAllows(prop.val, value);
+					}
+				}
+				if (node.index) {
+					const key = this.next("k");
+					this.push(`for(const ${key} in ${object}){if(!own.call(${object},${key}))continue;`);
+					this.emitAllows(node.index, `${object}[${key}]`);
+					this.push("}");
+				} else if (node.extras === "reject") {
+					const key = this.next("k");
+					this.push(
+						`for(const ${key} in ${object})if(own.call(${object},${key})&&!(${this.declaredCheck(node.props, key)}))return false;`,
+					);
+				}
+				return;
+			}
+			case "union": {
+				const sources: string[] = [];
+				for (const member of node.members) {
+					if (!isPrimitiveLiteral(member)) break;
+					const source = litSource(member.v);
+					if (source === undefined) break;
+					sources.push(source);
+				}
+				if (sources.length === node.members.length && sources.length >= 4) {
+					this.push(
+						`switch(${v}){${sources.map(source => `case ${source}:`).join("")}break;default:return false;}`,
+					);
+					return;
+				}
+				this.push(`if(!(${this.predicate(node, v)}))return false;`);
+				return;
+			}
+			default:
+				this.push(`if(!(${this.predicate(node, v)}))return false;`);
+		}
+	}
+
+	buildAllows(ir: IR): (value: unknown) => boolean {
+		this.emitAllows(ir, "v");
+		const src = `return function(v){${this.#lines.join("")}return true}`;
+		const make = new Function("R", "AE", "own", src) as (
+			refs: unknown[],
+			ae: typeof OmpErrors,
+			ownFn: typeof own,
+		) => (value: unknown) => boolean;
+		return make(this.#refs, OmpErrors, own);
 	}
 }
 
@@ -386,7 +739,7 @@ interface WalkTagged {
 	[kWalk]?: (value: unknown) => unknown;
 }
 
-/** Interpreter closure for a morphing union member (rare; hoisted into refs). */
+/** Cached interpreter closure for recursive aliases and predicate-only fallbacks. */
 function boundWalk(node: IR): (value: unknown) => unknown {
 	const tagged = node as IR & WalkTagged;
 	let fn = tagged[kWalk];
@@ -397,19 +750,44 @@ function boundWalk(node: IR): (value: unknown) => unknown {
 	return fn;
 }
 
+function resolvedRoot(ir: IR): IR {
+	return ir.k === "alias" ? ir.resolve() : ir;
+}
+
+const compiledCache = new WeakMap<IR, (value: unknown) => unknown>();
+const allowsCache = new WeakMap<IR, (value: unknown) => boolean>();
+
 /** Compile `ir` into a specialized validator. */
 export function compile(ir: IR): (value: unknown) => unknown {
-	return new Builder().build(ir);
+	const root = resolvedRoot(ir);
+	let validator = compiledCache.get(root);
+	if (validator === undefined) {
+		validator = new Builder().build(root);
+		compiledCache.set(root, validator);
+	}
+	return validator;
+}
+
+/** Compile `ir` into an allocation-free boolean validator. */
+export function compileAllows(ir: IR): (value: unknown) => boolean {
+	const root = resolvedRoot(ir);
+	let validator = allowsCache.get(root);
+	if (validator === undefined) {
+		validator = new Builder().buildAllows(root);
+		allowsCache.set(root, validator);
+	}
+	return validator;
 }
 
 /** Generated source for inspection/debugging. */
 export function compileToSource(ir: IR): string {
-	const b = new Builder();
-	if (hasMorph(ir)) {
-		b.push("let o;");
-		b.emitProduce(ir, "v", [], "o");
+	const root = resolvedRoot(ir);
+	const builder = new Builder();
+	if (hasMorph(root)) {
+		builder.push("let o;");
+		builder.emitProduce(root, "v", [], "o");
 		return `function(v){/* refs elided */return o}`;
 	}
-	b.emitCheck(ir, "v", []);
+	builder.emitCheck(root, "v", []);
 	return `function(v){/* refs elided */return v}`;
 }