@oh-my-pi/omptype 17.2.7 → 17.2.8

package/dist/js/compile.js

@@ -15,13 +15,10 @@
  *   members compile to inline predicates
  */
 import { MISSING, OmpErrors } from "./errors.js";
-import { canRefineUnionFailure, unionFail, walk } from "./interp.js";
+import { canRefineUnionFailure, materializeDefault, unionFail, walk } from "./interp.js";
 import { expectedOf, hasMorph } from "./ir.js";
 const own = Object.prototype.hasOwnProperty;
 const IDENT = /^[A-Za-z_$][\w$]*$/;
-function access(base, key) {
-    return IDENT.test(key) ? `${base}.${key}` : `${base}[${JSON.stringify(key)}]`;
-}
 /** Inline-able literal, else undefined (caller hoists into the refs pool). */
 function litSource(v) {
     if (v === null)
@@ -98,8 +95,11 @@ class Builder {
     lit(v) {
         return litSource(v) ?? this.ref(v);
     }
+    access(base, key) {
+        return typeof key === "string" && IDENT.test(key) ? `${base}.${key}` : `${base}[${this.lit(key)}]`;
+    }
     pathExpr(segs) {
-        const parts = segs.map(seg => ("s" in seg ? JSON.stringify(seg.s) : seg.d));
+        const parts = segs.map(seg => ("s" in seg ? this.lit(seg.s) : seg.d));
         return `[${parts.join(",")}]`;
     }
     storedPathExpr(segs) {
@@ -107,7 +107,7 @@ class Builder {
             return "undefined";
         if (segs.length === 1) {
             const seg = segs[0];
-            return "s" in seg ? JSON.stringify(seg.s) : seg.d;
+            return "s" in seg ? this.lit(seg.s) : seg.d;
         }
         const staticParts = [];
         for (const seg of segs) {
@@ -117,8 +117,14 @@ class Builder {
         }
         return this.ref(staticParts);
     }
+    error(segs, expected, dataExpr) {
+        return `new AE(${this.storedPathExpr(segs)},${JSON.stringify(expected)},${dataExpr})`;
+    }
     fail(segs, expected, dataExpr) {
-        return `return new AE(${this.storedPathExpr(segs)},${JSON.stringify(expected)},${dataExpr})`;
+        return `return ${this.error(segs, expected, dataExpr)}`;
+    }
+    appendError(errors, error) {
+        return `if(${errors}===undefined)${errors}=${error};else ${errors}.append(${error});`;
     }
     /** Pure boolean predicate for a morph-free subtree. */
     predicate(node, v) {
@@ -193,10 +199,10 @@ class Builder {
                 return out;
             }
             case "object": {
-                const checks = [`typeof ${v}==="object"`, `${v}!==null`, `!Array.isArray(${v})`];
+                const checks = [`typeof ${v}==="object"`, `${v}!==null`];
                 for (const p of node.props) {
-                    const av = access(v, p.key);
-                    const present = `${JSON.stringify(p.key)} in ${v}`;
+                    const av = this.access(v, p.key);
+                    const present = `${this.lit(p.key)} in ${v}`;
                     const predicate = this.predicate(p.val, av);
                     checks.push(p.opt || p.hasDefault
                         ? rejectsUndefined(p.val)
@@ -206,13 +212,29 @@ class Builder {
                             ? predicate
                             : `((${present})&&(${predicate}))`);
                 }
-                if (node.index) {
-                    const k = this.next("k");
-                    checks.push(`(()=>{for(const ${k} in ${v})if(own.call(${v},${k})&&!(${this.predicate(node.index, `${v}[${k}]`)}))return false;return true})()`);
+                const stringKey = this.next("k");
+                if (node.index !== undefined) {
+                    checks.push(`(()=>{for(const ${stringKey} in ${v})if(own.call(${v},${stringKey})&&!(${this.predicate(node.index, `${v}[${stringKey}]`)}))return false;return true})()`);
                 }
-                else if (node.extras === "reject") {
-                    const k = this.next("k");
-                    checks.push(`(()=>{for(const ${k} in ${v})if(own.call(${v},${k})&&!(${this.declaredCheck(node.props, k)}))return false;return true})()`);
+                if (node.patternIndexes !== undefined) {
+                    for (const pattern of node.patternIndexes) {
+                        checks.push(`(()=>{for(const ${stringKey} in ${v})if(own.call(${v},${stringKey})&&(${this.predicate(pattern.key, stringKey)})&&!(${this.predicate(pattern.val, `${v}[${stringKey}]`)}))return false;return true})()`);
+                    }
+                }
+                if (node.symbolIndex !== undefined) {
+                    const symbol = this.next("s");
+                    checks.push(`(()=>{for(const ${symbol} of Object.getOwnPropertySymbols(${v}))if(Object.prototype.propertyIsEnumerable.call(${v},${symbol})&&!(${this.predicate(node.symbolIndex, `${v}[${symbol}]`)}))return false;return true})()`);
+                }
+                if (node.extras === "reject") {
+                    const patternMatch = node.patternIndexes?.map(pattern => `(${this.predicate(pattern.key, stringKey)})`).join("||") ??
+                        "false";
+                    if (node.index === undefined) {
+                        checks.push(`(()=>{for(const ${stringKey} in ${v})if(own.call(${v},${stringKey})&&!(${this.declaredCheck(node.props, stringKey)})&&!(${patternMatch}))return false;return true})()`);
+                    }
+                    if (node.symbolIndex === undefined) {
+                        const symbol = this.next("s");
+                        checks.push(`(()=>{for(const ${symbol} of Object.getOwnPropertySymbols(${v}))if(Object.prototype.propertyIsEnumerable.call(${v},${symbol})&&!(${this.declaredCheck(node.props, symbol)}))return false;return true})()`);
+                    }
                 }
                 return `(${checks.join("&&")})`;
             }
@@ -229,125 +251,207 @@ class Builder {
             const set = this.ref(new Set(props.map(p => p.key)));
             return `${set}.has(${keyVar})`;
         }
-        return `(${props.map(p => `${keyVar}===${JSON.stringify(p.key)}`).join("||")})`;
+        return `(${props.map(p => `${keyVar}===${this.lit(p.key)}`).join("||")})`;
     }
-    emitDelegate(node, v, segs, out) {
-        const runner = node.k === "sub" ? node.schema.run : boundWalk(node);
+    /**
+     * Run a node through its interpreter/sub-schema runner, appending any
+     * failure to `errors`. `brk` (when given) exits the enclosing block on
+     * failure so dependent statements (output assignment, morph fns) are
+     * skipped. Both runner kinds receive the absolute path so nested step
+     * callbacks observe ctx.path; walk-produced errors are already absolute,
+     * while sub runners return schema-relative errors that need prefixing.
+     */
+    emitCollectDelegate(node, v, segs, errors, brk, out) {
+        const sub = node.k === "sub";
+        const runner = 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)});`);
+        const args = segs.length > 0 ? `${v},${this.pathExpr(segs)}` : v;
+        this.push(`const ${result}=${this.ref(runner)}(${args});`);
+        const failure = sub && segs.length > 0 ? `PF(${result},${this.pathExpr(segs)})` : result;
+        this.push(`if(${result} instanceof AE){${this.appendError(errors, failure)}${brk === undefined ? "" : `break ${brk};`}}`);
         if (out !== undefined)
             this.push(`${out}=${result};`);
     }
-    emitTupleShape(node, v, segs, failureData) {
-        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 };
+    /** Snapshot the error count so sequencing sites can detect soft failures. */
+    markErrors(errors) {
+        const mark = this.next("n");
+        this.push(`const ${mark}=${errors}===void 0?0:${errors}.length;`);
+        return mark;
     }
-    /** Statement-form check for a morph-free subtree with precise error paths. */
-    emitCheck(node, v, segs, failureData = v) {
+    /** Exit `brk` when errors were appended since `mark` (interp's return-on-error). */
+    guardGrowth(errors, mark, brk) {
+        this.push(`if((${errors}===void 0?0:${errors}.length)!==${mark})break ${brk};`);
+    }
+    /** Aggregate every independent failure in a morph-free subtree. */
+    emitCollectCheck(node, v, segs, errors, failureData = v) {
+        if (node.cfg !== undefined || node.k === "refine") {
+            this.emitCollectDelegate(node, v, segs, errors);
+            return;
+        }
         switch (node.k) {
             case "unknown":
                 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), 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}];`);
-                this.emitCheck(node.el, x, [...segs, { d: i }]);
-                this.push("}");
+                this.push(`if(!Array.isArray(${v})){${this.appendError(errors, this.error(segs, "an array", failureData))}}`);
+                if (node.min !== undefined) {
+                    this.push(`else if(${v}.length<${node.min}){${this.appendError(errors, this.error(segs, `at least length ${node.min}`, `${v}.length`))}}`);
+                }
+                if (node.max !== undefined) {
+                    this.push(`else if(${v}.length>${node.max}){${this.appendError(errors, this.error(segs, `at most length ${node.max}`, `${v}.length`))}}`);
+                }
+                this.push("else{");
+                const index = this.next("i");
+                this.push(`for(let ${index}=0;${index}<${v}.length;${index}++){`);
+                this.emitCollectCheck(node.el, `${v}[${index}]`, [...segs, { d: index }], errors);
+                this.push("}}");
                 return;
             }
             case "tuple": {
-                const { postfixStart, prefixCount, requiredPrefix } = this.emitTupleShape(node, v, segs, failureData);
+                this.push(`if(!Array.isArray(${v})){${this.appendError(errors, this.error(segs, "an array", failureData))}}else{`);
+                const requiredPrefix = node.prefix.filter(item => !item.opt && !item.hasDefault).length;
+                const minimum = requiredPrefix + node.postfix.length;
+                const maximum = node.prefix.length + node.postfix.length;
+                if (minimum > 0) {
+                    this.push(`if(${v}.length<${minimum}){${this.appendError(errors, this.error(segs, `an array of at least length ${minimum}`, failureData))}}else{`);
+                }
+                if (node.variadic === undefined) {
+                    this.push(`if(${v}.length>${maximum}){${this.appendError(errors, this.error(segs, `an array of at most length ${maximum}`, failureData))}}else{`);
+                }
+                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});`);
+                }
                 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) }]);
+                    this.emitCollectCheck(node.prefix[index].val, `${v}[${index}]`, [...segs, { d: String(index) }], errors);
                     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.emitCollectCheck(node.variadic, `${v}[${index}]`, [...segs, { d: index }], errors);
                     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 }]);
+                    this.emitCollectCheck(node.postfix[index], `${v}[${inputIndex}]`, [...segs, { d: inputIndex }], errors);
                 }
+                if (node.variadic === undefined)
+                    this.push("}");
+                if (minimum > 0)
+                    this.push("}");
+                this.push("}");
                 return;
             }
             case "object": {
-                this.push(`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}`;
-                    const propSegs = [...segs, { s: p.key }];
-                    if (p.opt || p.hasDefault) {
+                if (node.patternIndexes !== undefined ||
+                    node.symbolIndex !== undefined ||
+                    node.props.some(prop => typeof prop.key === "symbol")) {
+                    this.emitCollectDelegate(node, v, segs, errors);
+                    return;
+                }
+                this.push(`if(typeof ${v}!=="object"||${v}===null){${this.appendError(errors, this.error(segs, "an object", failureData))}}else{`);
+                for (const prop of node.props) {
+                    const present = `${this.lit(prop.key)} in ${v}`;
+                    const propSegs = [...segs, { s: prop.key }];
+                    if (prop.opt || prop.hasDefault) {
                         this.push(`if(${present}){`);
-                        this.emitCheck(p.val, access(v, p.key), propSegs);
+                        this.emitCollectCheck(prop.val, this.access(v, prop.key), propSegs, errors);
                         this.push("}");
                     }
                     else {
-                        this.push(`if(!(${present}))${this.fail(propSegs, expectedOf(p.val), "M")};`);
-                        this.emitCheck(p.val, access(v, p.key), propSegs);
+                        this.push(`if(!(${present})){${this.appendError(errors, this.error(propSegs, expectedOf(prop.val), "M"))}}else{`);
+                        this.emitCollectCheck(prop.val, this.access(v, prop.key), propSegs, errors);
+                        this.push("}");
                     }
                 }
-                if (node.index) {
-                    const k = this.next("k");
-                    this.push(`for(const ${k} in ${v})if(own.call(${v},${k})){`);
-                    this.emitCheck(node.index, `${v}[${k}]`, [...segs, { d: k }]);
+                if (node.index !== undefined) {
+                    const key = this.next("k");
+                    this.push(`for(const ${key} in ${v})if(own.call(${v},${key})){`);
+                    this.emitCollectCheck(node.index, `${v}[${key}]`, [...segs, { d: key }], errors);
                     this.push("}");
                 }
                 else if (node.extras === "reject") {
-                    const k = this.next("k");
-                    this.push(`for(const ${k} in ${v})if(own.call(${v},${k})&&!(${this.declaredCheck(node.props, k)}))${this.fail([...segs, { d: k }], "removed (undeclared key)", `${v}[${k}]`)};`);
+                    const key = this.next("k");
+                    this.push(`for(const ${key} in ${v})if(own.call(${v},${key})&&!(${this.declaredCheck(node.props, key)})){`);
+                    this.push(this.appendError(errors, this.error([...segs, { d: key }], "removed", `${v}[${key}]`)));
+                    this.push("}");
+                }
+                if (node.extras === "reject") {
+                    const symbol = this.next("s");
+                    this.push(`for(const ${symbol} of Object.getOwnPropertySymbols(${v}))if(Object.prototype.propertyIsEnumerable.call(${v},${symbol})&&!(${this.declaredCheck(node.props, symbol)})){${this.appendError(errors, this.error([...segs, { d: symbol }], "removed", `${v}[${symbol}]`))}}`);
                 }
+                this.push("}");
                 return;
             }
-            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};}`);
+                    ? `UF(${this.ref(node)},${failureData},${this.pathExpr(segs)},${JSON.stringify(expectedOf(node))})`
+                    : this.error(segs, expectedOf(node), failureData);
+                this.push(`if(!(${this.predicate(node, v)})){${this.appendError(errors, failure)}}`);
+                return;
+            }
+            case "string": {
+                this.push(`if(typeof ${v}!=="string"){${this.appendError(errors, this.error(segs, "a string", failureData))}}`);
+                if (node.min !== undefined) {
+                    this.push(`else if(${v}.length<${node.min}){${this.appendError(errors, this.error(segs, `at least length ${node.min}`, `${v}.length`))}}`);
                 }
-                else {
-                    this.push(`if(!(${this.predicate(node, v)}))${failure};`);
+                if (node.max !== undefined) {
+                    this.push(`else if(${v}.length>${node.max}){${this.appendError(errors, this.error(segs, `at most length ${node.max}`, `${v}.length`))}}`);
                 }
+                if (node.url) {
+                    this.push(`else if(!URL.canParse(${v})){${this.appendError(errors, this.error(segs, "a URL string", failureData))}}`);
+                }
+                return;
+            }
+            case "number": {
+                this.push(`if(typeof ${v}!=="number"||!Number.isFinite(${v})){${this.appendError(errors, this.error(segs, node.int ? "an integer" : "a number", failureData))}}else{`);
+                if (node.int) {
+                    this.push(`if(!Number.isInteger(${v})){${this.appendError(errors, this.error(segs, "an integer", failureData))}}`);
+                }
+                if (node.divisor !== undefined) {
+                    this.push(`if(${v}%${node.divisor}!==0){${this.appendError(errors, this.error(segs, `a number divisible by ${node.divisor}`, failureData))}}`);
+                }
+                if (node.min !== undefined) {
+                    const expected = node.min === 0
+                        ? node.xmin
+                            ? "positive"
+                            : "non-negative"
+                        : `a number ${node.xmin ? "more than" : "at least"} ${node.min}`;
+                    this.push(`if(${v}${node.xmin ? "<=" : "<"}${node.min}){${this.appendError(errors, this.error(segs, expected, failureData))}}`);
+                }
+                if (node.max !== undefined) {
+                    const expected = node.max === 0
+                        ? node.xmax
+                            ? "negative"
+                            : "non-positive"
+                        : `a number ${node.xmax ? "less than" : "at most"} ${node.max}`;
+                    this.push(`if(${v}${node.xmax ? ">=" : ">"}${node.max}){${this.appendError(errors, this.error(segs, expected, failureData))}}`);
+                }
+                this.push("}");
                 return;
             }
+            case "lit":
+                if ((node.v !== null && typeof node.v === "object" && !(node.v instanceof Date)) ||
+                    typeof node.v === "function") {
+                    this.emitCollectDelegate(node, v, segs, errors);
+                }
+                else {
+                    this.push(`if(!(${this.predicate(node, v)})){${this.appendError(errors, this.error(segs, expectedOf(node), failureData))}}`);
+                }
+                return;
+            case "intersection":
+            case "sub":
+                this.emitCollectDelegate(node, v, segs, errors);
+                return;
             case "null":
             case "undefined":
             case "boolean":
@@ -355,53 +459,87 @@ class Builder {
             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);
+                this.push(`if(!(${this.predicate(node, v)})){${this.appendError(errors, this.error(segs, expectedOf(node), failureData))}}`);
                 return;
             default:
-                this.emitDelegate(node, v, segs);
+                this.emitCollectDelegate(node, v, segs, errors);
+        }
+    }
+    emitTupleShape(node, v, segs, errors, brk, failureData) {
+        this.push(`if(!Array.isArray(${v})){${this.appendError(errors, this.error(segs, "an array", failureData))}break ${brk};}`);
+        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.appendError(errors, this.error(segs, `an array of at least length ${minimum}`, failureData))}break ${brk};}`);
+        }
+        if (node.variadic === undefined) {
+            const maximum = node.prefix.length + node.postfix.length;
+            this.push(`if(${v}.length>${maximum}){${this.appendError(errors, this.error(segs, `an array of at most length ${maximum}`, failureData))}break ${brk};}`);
+        }
+        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 };
+    }
+    /** Fill `target` with a validated default (factory output revalidated per call). */
+    emitDefaultFill(val, def, isFactory, target, segs, errors) {
+        if (isFactory && typeof def === "function") {
+            const candidate = this.next("d");
+            const resolved = this.next("t");
+            const label = this.next("L");
+            this.push(`const ${candidate}=${this.ref(def)}();let ${resolved};${label}:{`);
+            this.emitCollectProduce(val, candidate, segs, resolved, errors, label);
+            this.push(`${target}=${resolved};}`);
+        }
+        else {
+            // Static defaults were prevalidated at construction; MD clones
+            // mutable payloads so callers cannot alias the schema's copy.
+            this.push(`${target}=${litSource(def) ?? `MD(${this.ref(def)})`};`);
         }
     }
     /**
      * Validate `v` against a morphing subtree and assign the produced output
-     * to `out` (an already-declared `let`).
+     * to `out` (an already-declared `let`). Failures append to `errors` and
+     * `break ${brk}` (skipping the output assignment), mirroring interp: an
+     * error in one child never suppresses sibling validation or morphs.
      */
-    emitProduce(node, v, segs, out, failureData = v) {
+    emitCollectProduce(node, v, segs, out, errors, brk, failureData = v) {
+        if (node.cfg !== undefined || node.k === "refine") {
+            this.emitCollectDelegate(node, v, segs, errors, brk, out);
+            return;
+        }
         if (!hasMorph(node)) {
-            this.emitCheck(node, v, segs, failureData);
+            this.emitCollectCheck(node, v, segs, errors, failureData);
             this.push(`${out}=${v};`);
             return;
         }
         switch (node.k) {
             case "sub":
-                this.emitDelegate(node, v, segs, out);
+                this.emitCollectDelegate(node, v, segs, errors, brk, out);
                 return;
             case "morph": {
                 const input = this.next("t");
                 this.push(`let ${input};`);
-                this.emitProduce(node.input, v, segs, input, failureData);
+                const mark = this.markErrors(errors);
+                this.emitCollectProduce(node.input, v, segs, input, errors, brk, failureData);
+                this.guardGrowth(errors, mark, brk);
                 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};`);
+                this.push(`if(${result} instanceof AE){${this.appendError(errors, result)}break ${brk};}`);
                 if (node.out === undefined)
                     this.push(`${out}=${result};`);
                 else
-                    this.emitProduce(node.out, result, segs, out);
+                    this.emitCollectProduce(node.out, result, segs, out, errors, brk);
                 return;
             }
             case "alias": {
@@ -411,12 +549,12 @@ class Builder {
                     this.#activeAliases = active;
                 }
                 if (active.has(node)) {
-                    this.emitDelegate(node, v, segs, out);
+                    this.emitCollectDelegate(node, v, segs, errors, brk, out);
                     return;
                 }
                 active.add(node);
                 try {
-                    this.emitProduce(node.resolve(), v, segs, out, failureData);
+                    this.emitCollectProduce(node.resolve(), v, segs, out, errors, brk, failureData);
                 }
                 finally {
                     active.delete(node);
@@ -442,47 +580,58 @@ class Builder {
                     }
                 }
                 this.push("}");
-                this.push(`if(!${ok})return UF(${this.ref(node)},${failureData},${this.pathExpr(segs)},${JSON.stringify(expectedOf(node))});`);
+                const failure = `UF(${this.ref(node)},${failureData},${this.pathExpr(segs)},${JSON.stringify(expectedOf(node))})`;
+                this.push(`if(!${ok}){${this.appendError(errors, failure)}break ${brk};}`);
                 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), failureData)};`);
-                const arr = this.next("a");
-                const i = this.next("i");
-                const x = this.next("x");
-                const el = this.next("t");
-                this.push(`const ${arr}=new Array(${v}.length);`);
-                this.push(`for(let ${i}=0;${i}<${v}.length;${i}++){const ${x}=${v}[${i}];let ${el};`);
-                this.emitProduce(node.el, x, [...segs, { d: i }], el);
-                this.push(`${arr}[${i}]=${el};}`);
-                this.push(`${out}=${arr};`);
+                this.push(`if(!Array.isArray(${v})){${this.appendError(errors, this.error(segs, "an array", failureData))}break ${brk};}`);
+                if (node.min !== undefined) {
+                    this.push(`if(${v}.length<${node.min}){${this.appendError(errors, this.error(segs, `at least length ${node.min}`, `${v}.length`))}break ${brk};}`);
+                }
+                if (node.max !== undefined) {
+                    this.push(`if(${v}.length>${node.max}){${this.appendError(errors, this.error(segs, `at most length ${node.max}`, `${v}.length`))}break ${brk};}`);
+                }
+                const array = this.next("a");
+                const index = this.next("i");
+                const input = this.next("x");
+                const element = this.next("t");
+                const label = this.next("L");
+                this.push(`const ${array}=new Array(${v}.length);`);
+                this.push(`for(let ${index}=0;${index}<${v}.length;${index}++){const ${input}=${v}[${index}];let ${element};${label}:{`);
+                this.emitCollectProduce(node.el, input, [...segs, { d: index }], element, errors, label);
+                this.push(`${array}[${index}]=${element};}}`);
+                this.push(`${out}=${array};`);
                 return;
             }
             case "tuple": {
-                const { postfixStart, prefixCount, requiredPrefix } = this.emitTupleShape(node, v, segs, failureData);
+                const { postfixStart, prefixCount, requiredPrefix } = this.emitTupleShape(node, v, segs, errors, brk, 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 itemSegs = [...segs, { s: index }];
                     const input = `${v}[${index}]`;
                     const output = `${tuple}[${index}]`;
+                    const label = this.next("L");
                     if (index >= requiredPrefix)
                         this.push(`if(${index}<${prefixCount}){`);
-                    if (hasMorph(item.val))
-                        this.emitProduce(item.val, input, [...segs, { d: String(index) }], output);
+                    this.push(`${label}:{`);
+                    if (hasMorph(item.val)) {
+                        const temporary = this.next("t");
+                        this.push(`let ${temporary};`);
+                        this.emitCollectProduce(item.val, input, itemSegs, temporary, errors, label);
+                        this.push(`${output}=${temporary};`);
+                    }
                     else {
-                        this.emitCheck(item.val, input, [...segs, { d: String(index) }]);
-                        this.push(`${output}=${input};`);
+                        this.emitCollectCheck(item.val, input, itemSegs, errors);
                     }
+                    this.push("}");
                     if (index >= requiredPrefix) {
                         if (item.hasDefault) {
-                            const defaultValue = item.defFactory ? `${this.ref(item.def)}()` : this.lit(item.def);
-                            this.push(`}else{${output}=${defaultValue};}`);
+                            this.push("}else{");
+                            this.emitDefaultFill(item.val, item.def, item.defFactory === true, output, itemSegs, errors);
+                            this.push("}");
                         }
                         else {
                             this.push("}");
@@ -492,125 +641,142 @@ class Builder {
                 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}];`);
+                    const label = this.next("L");
+                    this.push(`for(let ${index}=${prefixCount};${index}<${postfixStart};${index}++){const ${input}=${v}[${index}];${label}:{`);
                     if (hasMorph(node.variadic)) {
-                        this.emitProduce(node.variadic, input, [...segs, { d: index }], `${tuple}[${index}]`);
+                        const temporary = this.next("t");
+                        this.push(`let ${temporary};`);
+                        this.emitCollectProduce(node.variadic, input, [...segs, { d: index }], temporary, errors, label);
+                        this.push(`${tuple}[${index}]=${temporary};`);
                     }
                     else {
-                        this.emitCheck(node.variadic, input, [...segs, { d: index }]);
-                        this.push(`${tuple}[${index}]=${input};`);
+                        this.emitCollectCheck(node.variadic, input, [...segs, { d: index }], errors);
                     }
-                    this.push("}");
+                    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);
+                    const label = this.next("L");
+                    this.push(`${label}:{`);
+                    if (hasMorph(item)) {
+                        const temporary = this.next("t");
+                        this.push(`let ${temporary};`);
+                        this.emitCollectProduce(item, input, [...segs, { d: inputIndex }], temporary, errors, label);
+                        this.push(`${tuple}[${inputIndex}]=${temporary};`);
+                    }
                     else {
-                        this.emitCheck(item, input, [...segs, { d: inputIndex }]);
-                        this.push(`${output}=${input};`);
+                        this.emitCollectCheck(item, input, [...segs, { d: inputIndex }], errors);
                     }
+                    this.push("}");
                 }
                 this.push(`${out}=${tuple};`);
                 return;
             }
             case "object": {
-                this.push(`if(typeof ${v}!=="object"||${v}===null||Array.isArray(${v}))${this.fail(segs, "an object", failureData)};`);
-                const o = this.next("o");
-                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}`;
-                    const propSegs = [...segs, { s: p.key }];
-                    const av = access(v, p.key);
-                    const ao = access(o, p.key);
-                    const morphChild = hasMorph(p.val);
-                    const missing = [];
-                    if (p.hasDefault) {
-                        const dflt = p.defFactory ? `${this.ref(p.def)}()` : this.lit(p.def);
-                        missing.push(`${ao}=${dflt};`);
+                if (node.patternIndexes !== undefined ||
+                    node.symbolIndex !== undefined ||
+                    node.props.some(prop => typeof prop.key === "symbol")) {
+                    this.emitCollectDelegate(node, v, segs, errors, brk, out);
+                    return;
+                }
+                this.push(`if(typeof ${v}!=="object"||${v}===null){${this.appendError(errors, this.error(segs, "an object", failureData))}break ${brk};}`);
+                const object = this.next("o");
+                const fresh = node.extras === "delete" && node.index === undefined;
+                this.push(fresh ? `const ${object}={};` : `const ${object}={...${v}};`);
+                for (const prop of node.props) {
+                    const present = `${this.lit(prop.key)} in ${v}`;
+                    const propSegs = [...segs, { s: prop.key }];
+                    const input = this.access(v, prop.key);
+                    const output = this.access(object, prop.key);
+                    const label = this.next("L");
+                    this.push(`if(!(${present})){`);
+                    if (prop.hasDefault) {
+                        this.emitDefaultFill(prop.val, prop.def, prop.defFactory === true, output, propSegs, errors);
                     }
-                    else if (!p.opt) {
-                        missing.push(`${this.fail(propSegs, expectedOf(p.val), "M")};`);
+                    else if (!prop.opt) {
+                        this.push(this.appendError(errors, this.error(propSegs, expectedOf(prop.val), "M")));
                     }
-                    this.push(`if(!(${present})){${missing.join("")}}else{`);
-                    if (morphChild) {
-                        const t = this.next("t");
-                        this.push(`let ${t};`);
-                        this.emitProduce(p.val, av, propSegs, t);
-                        this.push(`${ao}=${t};`);
+                    this.push(`}else{${label}:{`);
+                    if (hasMorph(prop.val)) {
+                        const temporary = this.next("t");
+                        this.push(`let ${temporary};`);
+                        this.emitCollectProduce(prop.val, input, propSegs, temporary, errors, label);
+                        this.push(`${output}=${temporary};`);
                     }
                     else {
-                        this.emitCheck(p.val, av, propSegs);
+                        this.emitCollectCheck(prop.val, input, propSegs, errors);
                         if (fresh)
-                            this.push(`${ao}=${av};`);
+                            this.push(`${output}=${input};`);
                     }
-                    this.push("}");
+                    this.push("}}");
                 }
-                if (node.index) {
-                    const k = this.next("k");
-                    this.push(`for(const ${k} in ${v})if(own.call(${v},${k})){`);
+                if (node.index !== undefined) {
+                    const key = this.next("k");
+                    const label = this.next("L");
+                    this.push(`for(const ${key} in ${v})if(own.call(${v},${key})){${label}:{`);
                     if (hasMorph(node.index)) {
-                        const t = this.next("t");
-                        this.push(`let ${t};`);
-                        this.emitProduce(node.index, `${v}[${k}]`, [...segs, { d: k }], t);
-                        this.push(`${o}[${k}]=${t};`);
+                        const temporary = this.next("t");
+                        this.push(`let ${temporary};`);
+                        this.emitCollectProduce(node.index, `${v}[${key}]`, [...segs, { d: key }], temporary, errors, label);
+                        this.push(`${object}[${key}]=${temporary};`);
                     }
                     else {
-                        this.emitCheck(node.index, `${v}[${k}]`, [...segs, { d: k }]);
+                        this.emitCollectCheck(node.index, `${v}[${key}]`, [...segs, { d: key }], errors);
                     }
-                    this.push("}");
+                    this.push("}}");
                 }
                 else if (node.extras === "reject") {
-                    const k = this.next("k");
-                    this.push(`for(const ${k} in ${v})if(own.call(${v},${k})&&!(${this.declaredCheck(node.props, k)}))${this.fail([...segs, { d: k }], "removed (undeclared key)", `${v}[${k}]`)};`);
+                    const key = this.next("k");
+                    this.push(`for(const ${key} in ${v})if(own.call(${v},${key})&&!(${this.declaredCheck(node.props, key)})){${this.appendError(errors, this.error([...segs, { d: key }], "removed", `${v}[${key}]`))}}`);
                 }
-                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};`);
+                if (node.extras === "reject") {
+                    const symbol = this.next("s");
+                    this.push(`for(const ${symbol} of Object.getOwnPropertySymbols(${v}))if(Object.prototype.propertyIsEnumerable.call(${v},${symbol})&&!(${this.declaredCheck(node.props, symbol)})){${this.appendError(errors, this.error([...segs, { d: symbol }], "removed", `${v}[${symbol}]`))}}`);
+                }
+                this.push(`${out}=${object};`);
                 return;
             }
             case "intersection": {
                 const current = this.next("t");
                 this.push(`let ${current}=${v};`);
-                for (const member of node.members) {
+                const mark = this.markErrors(errors);
+                for (let index = 0; index < node.members.length; index++) {
+                    if (index > 0)
+                        this.guardGrowth(errors, mark, brk);
+                    const member = node.members[index];
                     if (hasMorph(member))
-                        this.emitProduce(member, current, segs, current);
+                        this.emitCollectProduce(member, current, segs, current, errors, brk);
                     else
-                        this.emitCheck(member, current, segs);
+                        this.emitCollectCheck(member, current, segs, errors);
                 }
                 this.push(`${out}=${current};`);
                 return;
             }
             default:
-                this.emitDelegate(node, v, segs, out);
+                this.emitCollectDelegate(node, v, segs, errors, brk, out);
         }
     }
     build(ir) {
+        const errors = this.next("e");
         let ret;
         if (hasMorph(ir)) {
-            this.push("let o;");
-            // body emitted below needs `o` declared first, so splice ordering:
-            this.emitProduce(ir, "v", [], "o");
+            const label = this.next("L");
+            this.push(`let ${errors};let o;${label}:{`);
+            this.emitCollectProduce(ir, "v", [], "o", errors, label);
+            this.push("}");
             ret = "o";
         }
         else {
-            this.emitCheck(ir, "v", []);
+            this.push(`let ${errors};`);
+            this.emitCollectCheck(ir, "v", [], errors);
             ret = "v";
         }
+        this.push(`if(${errors}!==undefined)return ${errors};`);
         const src = `return function(v){${this.#lines.join("")}return ${ret}}`;
-        const make = new Function("R", "AE", "M", "PF", "UF", "MC", "own", src);
-        return make(this.#refs, OmpErrors, MISSING, prefixErrors, unionFail, CompiledMorphContext, own);
+        const make = new Function("R", "AE", "M", "PF", "UF", "MC", "own", "MD", src);
+        return make(this.#refs, OmpErrors, MISSING, prefixErrors, unionFail, CompiledMorphContext, own, materializeDefault);
     }
     emitAllows(node, v) {
         switch (node.k) {
@@ -629,11 +795,11 @@ class Builder {
             }
             case "object": {
                 const object = this.next("o");
-                this.push(`const ${object}=${v};if(typeof ${object}!=="object"||${object}===null||Array.isArray(${object}))return false;`);
+                this.push(`const ${object}=${v};if(typeof ${object}!=="object"||${object}===null)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)};`);
+                    const present = `${this.lit(prop.key)} in ${object}`;
+                    this.push(`const ${value}=${this.access(object, prop.key)};`);
                     if (prop.opt || prop.hasDefault) {
                         if (rejectsUndefined(prop.val)) {
                             this.push(`if(${value}!==undefined){`);
@@ -652,15 +818,33 @@ class Builder {
                         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}]`);
+                const stringKey = this.next("k");
+                if (node.index !== undefined) {
+                    this.push(`for(const ${stringKey} in ${object}){if(!own.call(${object},${stringKey}))continue;`);
+                    this.emitAllows(node.index, `${object}[${stringKey}]`);
                     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;`);
+                if (node.patternIndexes !== undefined) {
+                    for (const pattern of node.patternIndexes) {
+                        this.push(`for(const ${stringKey} in ${object})if(own.call(${object},${stringKey})&&(${this.predicate(pattern.key, stringKey)})&&!(${this.predicate(pattern.val, `${object}[${stringKey}]`)}))return false;`);
+                    }
+                }
+                if (node.symbolIndex !== undefined) {
+                    const symbol = this.next("s");
+                    this.push(`for(const ${symbol} of Object.getOwnPropertySymbols(${object})){if(!Object.prototype.propertyIsEnumerable.call(${object},${symbol}))continue;`);
+                    this.emitAllows(node.symbolIndex, `${object}[${symbol}]`);
+                    this.push("}");
+                }
+                if (node.extras === "reject") {
+                    const patternMatch = node.patternIndexes?.map(pattern => `(${this.predicate(pattern.key, stringKey)})`).join("||") ??
+                        "false";
+                    if (node.index === undefined) {
+                        this.push(`for(const ${stringKey} in ${object})if(own.call(${object},${stringKey})&&!(${this.declaredCheck(node.props, stringKey)})&&!(${patternMatch}))return false;`);
+                    }
+                    if (node.symbolIndex === undefined) {
+                        const symbol = this.next("s");
+                        this.push(`for(const ${symbol} of Object.getOwnPropertySymbols(${object}))if(Object.prototype.propertyIsEnumerable.call(${object},${symbol})&&!(${this.declaredCheck(node.props, symbol)}))return false;`);
+                    }
                 }
                 return;
             }
@@ -703,7 +887,7 @@ function boundWalk(node) {
     const tagged = node;
     let fn = tagged[kWalk];
     if (!fn) {
-        fn = (value) => walk(node, value);
+        fn = (value, path) => walk(node, value, path);
         tagged[kWalk] = fn;
     }
     return fn;
@@ -716,20 +900,31 @@ const allowsCache = new WeakMap();
 /** Compile `ir` into a specialized validator. */
 export function compile(ir) {
     const root = resolvedRoot(ir);
-    let validator = compiledCache.get(root);
+    const validator = compiledCache.get(root);
     if (validator === undefined) {
-        validator = new Builder().build(root);
-        compiledCache.set(root, validator);
+        // Publish a deferred wrapper before building: recursive schemas re-enter
+        // compile() for the same root mid-build (e.g. an alias element inside an
+        // array), and each re-entry must reuse this build instead of starting a
+        // fresh one forever. The wrapper resolves to the built validator by call
+        // time; the interpreter is a safety net that never triggers post-build.
+        let built;
+        compiledCache.set(root, value => (built === undefined ? walk(root, value) : built(value)));
+        built = new Builder().build(root);
+        compiledCache.set(root, built);
+        return built;
     }
     return validator;
 }
 /** Compile `ir` into an allocation-free boolean validator. */
 export function compileAllows(ir) {
     const root = resolvedRoot(ir);
-    let validator = allowsCache.get(root);
+    const validator = allowsCache.get(root);
     if (validator === undefined) {
-        validator = new Builder().buildAllows(root);
-        allowsCache.set(root, validator);
+        let built;
+        allowsCache.set(root, ((value) => built === undefined ? !(walk(root, value) instanceof OmpErrors) : built(value)));
+        built = new Builder().buildAllows(root);
+        allowsCache.set(root, built);
+        return built;
     }
     return validator;
 }
@@ -739,9 +934,9 @@ export function compileToSource(ir) {
     const builder = new Builder();
     if (hasMorph(root)) {
         builder.push("let o;");
-        builder.emitProduce(root, "v", [], "o");
+        builder.emitCollectProduce(root, "v", [], "o", "e", "L0");
         return `function(v){/* refs elided */return o}`;
     }
-    builder.emitCheck(root, "v", []);
+    builder.emitCollectCheck(root, "v", [], "e");
     return `function(v){/* refs elided */return v}`;
 }