typesea 0.2.0 → 0.3.0

package/dist/compile/graph-predicate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph-predicate.d.ts","sourceRoot":"","sources":["../../src/compile/graph-predicate.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAYH,OAAO,EAGH,KAAK,MAAM,EACd,MAAM,oBAAoB,CAAC;AAQ5B,OAAO,KAAK,EAAE,WAAW,EAAkB,MAAM,YAAY,CAAC;AA8G9D;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC7B,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,WAAW,EACpB,aAAa,CAAC,EAAE,MAAM,GACvB,MAAM,CAoBR;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,CAS/D"}
+{"version":3,"file":"graph-predicate.d.ts","sourceRoot":"","sources":["../../src/compile/graph-predicate.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAqBH,OAAO,EAIH,KAAK,MAAM,EACd,MAAM,oBAAoB,CAAC;AAQ5B,OAAO,KAAK,EAAE,WAAW,EAAkB,MAAM,YAAY,CAAC;AA8G9D;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC7B,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,WAAW,EACpB,aAAa,CAAC,EAAE,MAAM,GACvB,MAAM,CAoBR;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,CAS/D"}

package/dist/compile/graph-predicate.js

@@ -4,7 +4,7 @@
  * @details Generated-source helpers keep the side-table ABI and JavaScript source shape
  * stable across runtime and AOT emission.
  */
-import { NodeTag, ObjectModeTag, PresenceTag, SchemaTag } from "../kind/index.js";
+import { ArrayCheckTag, NodeTag, ObjectModeTag, PresenceTag, SchemaTag } from "../kind/index.js";
 import { makeValidationPlan } from "../plan/index.js";
 import { schemaCanAcceptUndefined } from "../schema/index.js";
 import { pushKeyset, pushLiteral, pushRegex, pushSchema, stringRef } from "./context.js";
@@ -271,7 +271,7 @@ function emitFalseCheck(graph, id, value, context, state) {
         return;
     }
     if (node?.tag === NodeTag.ArrayEvery) {
-        emitArrayEveryCheck(graph, node.value, node.item, node.itemGraph, value, context, state);
+        emitArrayEveryCheck(graph, node.value, node.item, node.checks, node.itemGraph, value, context, state);
         return;
     }
     if (node?.tag === NodeTag.TupleItems) {
@@ -279,7 +279,7 @@ function emitFalseCheck(graph, id, value, context, state) {
         return;
     }
     if (node?.tag === NodeTag.RecordEvery) {
-        emitRecordEveryCheck(graph, node.value, node.itemGraph, value, context, state);
+        emitRecordEveryCheck(graph, node.value, node.item, node.itemGraph, value, context, state);
         return;
     }
     if (node?.tag === NodeTag.PrimitiveUnion) {
@@ -329,9 +329,9 @@ function emitFalseCheck(graph, id, value, context, state) {
  * @param state Mutable graph emitter state.
  * @post Appends branch code to `state.chunks`.
  */
-function emitArrayEveryCheck(graph, valueId, item, itemGraph, value, context, state) {
+function emitArrayEveryCheck(graph, valueId, item, checks, itemGraph, value, context, state) {
     if (isUnsafeMode(context)) {
-        emitUnsafeArrayEveryCheck(graph, valueId, itemGraph, value, context, state);
+        emitUnsafeArrayEveryCheck(graph, valueId, checks, itemGraph, value, context, state);
         return;
     }
     const arrayExpression = emitGraphExpression(graph, valueId, value, context, state);
@@ -342,6 +342,7 @@ function emitArrayEveryCheck(graph, valueId, item, itemGraph, value, context, st
     const allowsUndefined = schemaCanAcceptUndefined(item);
     const itemConstant = readGraphResultBoolean(itemGraph);
     emitArrayGuard(arrayExpression, state);
+    emitArrayLengthChecks(arrayExpression, checks, state);
     if (itemConstant === false) {
         /*
          * If the item graph is impossible, only an empty array can pass. This
@@ -358,7 +359,7 @@ function emitArrayEveryCheck(graph, valueId, item, itemGraph, value, context, st
         emitPresentArrayEveryCheck(itemGraph, itemConstant, arrayExpression, context, state);
         return;
     }
-    state.chunks.push(`for(let ${index}=0;${index}<${arrayExpression}.length;${index}+=1){`, `const ${descriptor}=gp(${arrayExpression},${index});`, `if(${descriptor}===undefined||!h.call(${descriptor},"value"))${failStatement(state)}`);
+    state.chunks.push(`for(let ${index}=0;${index}<${arrayExpression}.length;${index}+=1){`, `const ${descriptor}=gp(${arrayExpression},${index});`, `if(${descriptor}===undefined)${failStatement(state)}`);
     if (itemConstant !== true) {
         const itemValue = `v${String(state.temp)}`;
         state.temp += 1;
@@ -410,12 +411,13 @@ function emitPresentArrayEveryCheck(itemGraph, itemConstant, arrayExpression, co
  * @brief Execute emit unsafe array every check.
  * @details Code generation helpers keep emitted JavaScript shape stable across runtime and AOT paths.
  */
-function emitUnsafeArrayEveryCheck(graph, valueId, itemGraph, value, context, state) {
+function emitUnsafeArrayEveryCheck(graph, valueId, checks, itemGraph, value, context, state) {
     const arrayExpression = emitGraphExpression(graph, valueId, value, context, state);
     const index = `i${String(state.temp)}`;
     state.temp += 1;
     const itemConstant = readGraphResultBoolean(itemGraph);
     emitArrayGuard(arrayExpression, state);
+    emitArrayLengthChecks(arrayExpression, checks, state);
     if (itemConstant === false) {
         state.chunks.push(`if(${arrayExpression}.length!==0)${failStatement(state)}`);
         return;
@@ -429,6 +431,30 @@ function emitUnsafeArrayEveryCheck(graph, valueId, itemGraph, value, context, st
     emitFalseCheck(itemGraph, itemGraph.result, itemValue, context, state);
     state.chunks.push("}");
 }
+/**
+ * @brief Emit array length failure branches.
+ * @param arrayExpression Generated expression already proven to be an array.
+ * @param checks Normalized array length checks.
+ * @param state Mutable graph emitter state.
+ * @post Appends no code when the schema has no length checks.
+ */
+function emitArrayLengthChecks(arrayExpression, checks, state) {
+    for (let index = 0; index < checks.length; index += 1) {
+        const check = checks[index];
+        if (check === undefined) {
+            state.chunks.push(failStatement(state));
+            continue;
+        }
+        switch (check.tag) {
+            case ArrayCheckTag.Min:
+                state.chunks.push(`if(${arrayExpression}.length<${String(check.value)})${failStatement(state)}`);
+                break;
+            case ArrayCheckTag.Max:
+                state.chunks.push(`if(${arrayExpression}.length>${String(check.value)})${failStatement(state)}`);
+                break;
+        }
+    }
+}
 /**
  * @brief emit tuple items check.
  * @details Emission is isolated here so optimized graph nodes lower to stable JavaScript shapes across safe, unsafe, and unchecked modes.
@@ -465,7 +491,7 @@ function emitTupleItemsCheck(graph, valueId, items, itemGraphs, value, context,
             state.chunks.push(`if(${descriptor}!==undefined&&!h.call(${descriptor},"value"))${failStatement(state)}`);
         }
         else {
-            state.chunks.push(`if(${descriptor}===undefined||!h.call(${descriptor},"value"))${failStatement(state)}`);
+            state.chunks.push(`if(${descriptor}===undefined)${failStatement(state)}`);
         }
         if (itemConstant !== true) {
             const itemValue = `v${String(state.temp)}`;
@@ -508,7 +534,7 @@ function emitUnsafeTupleItemsCheck(graph, valueId, itemGraphs, value, context, s
  * @brief emit record every check.
  * @details Emission is isolated here so optimized graph nodes lower to stable JavaScript shapes across safe, unsafe, and unchecked modes.
  */
-function emitRecordEveryCheck(graph, valueId, itemGraph, value, context, state) {
+function emitRecordEveryCheck(graph, valueId, item, itemGraph, value, context, state) {
     if (isUnsafeMode(context)) {
         emitUnsafeRecordEveryCheck(graph, valueId, itemGraph, value, context, state);
         return;
@@ -519,12 +545,15 @@ function emitRecordEveryCheck(graph, valueId, itemGraph, value, context, state)
     const descriptor = `d${String(state.temp)}`;
     state.temp += 1;
     const itemConstant = readGraphResultBoolean(itemGraph);
+    const rejectsUndefined = !schemaCanAcceptUndefined(item);
     emitObjectGuard(recordExpression, state);
     if (itemConstant === false) {
         state.chunks.push(`for(const ${key} in ${recordExpression}){`, `if(h.call(${recordExpression},${key}))${failStatement(state)}`, "}");
         return;
     }
-    state.chunks.push(`for(const ${key} in ${recordExpression}){`, `if(!h.call(${recordExpression},${key}))continue;`, `const ${descriptor}=gp(${recordExpression},${key});`, `if(${descriptor}===undefined||!h.call(${descriptor},"value"))${failStatement(state)}`);
+    state.chunks.push(`for(const ${key} in ${recordExpression}){`, `if(!h.call(${recordExpression},${key}))continue;`, `const ${descriptor}=gp(${recordExpression},${key});`, rejectsUndefined
+        ? `if(${descriptor}===undefined)${failStatement(state)}`
+        : `if(${descriptor}===undefined||!h.call(${descriptor},"value"))${failStatement(state)}`);
     if (itemConstant !== true) {
         const itemValue = `v${String(state.temp)}`;
         state.temp += 1;
@@ -618,7 +647,7 @@ function emitDiscriminantDispatchReturn(graph, node, value, context, state) {
     }
     const descriptor = `d${String(state.temp)}`;
     state.temp += 1;
-    state.chunks.push(objectGuardStatement(objectExpression, state), `const ${descriptor}=gp(${objectExpression},${stringRef(context, node.key)});`, `if(${descriptor}===undefined||!h.call(${descriptor},"value")||typeof ${descriptor}.value!=="string")${failStatement(state)}`, `switch(${descriptor}.value){`);
+    state.chunks.push(objectGuardStatement(objectExpression, state), `const ${descriptor}=gp(${objectExpression},${stringRef(context, node.key)});`, `if(${descriptor}===undefined||typeof ${descriptor}.value!=="string")${failStatement(state)}`, `switch(${descriptor}.value){`);
     markKnownObject(objectExpression, state);
     for (let index = 0; index < node.graphs.length; index += 1) {
         const childGraph = node.graphs[index];
@@ -1279,9 +1308,7 @@ function emitGraphExpression(graph, id, value, context, state) {
              * Expression-mode code uses compact helpers. `eu` is the present-key
              * variant; `ea` is the dense logical-slot variant.
              */
-            return schemaCanAcceptUndefined(node.item)
-                ? `eu(${emitGraphExpression(graph, node.value, value, context, state)},${emitGraphChildFunction(node.itemGraph, context)})`
-                : `ea(${emitGraphExpression(graph, node.value, value, context, state)},${emitGraphChildFunction(node.itemGraph, context)})`;
+            return emitArrayEveryExpression(emitGraphExpression(graph, node.value, value, context, state), node, context);
         case NodeTag.TupleItems:
             return emitTupleItemsExpression(emitGraphExpression(graph, node.value, value, context, state), node.itemGraphs, context);
         case NodeTag.RecordEvery:
@@ -1327,6 +1354,7 @@ function emitObjectShapeBody(node, value, context) {
     emitObjectGuard(value, state);
     const emittedStrictKeyCount = emitEarlyStrictKeyCount(node, value, context, state);
     emitObjectShapeEntries(node, value, context, state);
+    emitObjectShapeCatchall(node, value, context, state);
     if (!emittedStrictKeyCount) {
         emitObjectShapeStrictKeys(node, value, context, state);
     }
@@ -1342,6 +1370,7 @@ function emitObjectShapeCheck(graph, node, value, context, state) {
     emitObjectGuard(objectExpression, state);
     const emittedStrictKeyCount = emitEarlyStrictKeyCount(node, objectExpression, context, state);
     emitObjectShapeEntries(node, objectExpression, context, state);
+    emitObjectShapeCatchall(node, objectExpression, context, state);
     if (!emittedStrictKeyCount) {
         emitObjectShapeStrictKeys(node, objectExpression, context, state);
     }
@@ -1352,6 +1381,7 @@ function emitObjectShapeCheck(graph, node, value, context, state) {
  */
 function emitEarlyStrictKeyCount(node, objectExpression, context, state) {
     if (node.mode !== ObjectModeTag.Strict ||
+        node.catchall !== undefined ||
         !node.allRequired ||
         isUnsafeMode(context)) {
         return false;
@@ -1359,6 +1389,62 @@ function emitEarlyStrictKeyCount(node, objectExpression, context, state) {
     state.chunks.push(`if(Object.getOwnPropertyNames(${objectExpression}).length!==${String(node.entries.length)}||Object.getOwnPropertySymbols(${objectExpression}).length!==0)${failStatement(state)}`);
     return true;
 }
+/**
+ * @brief Emit catchall validation for undeclared own object keys.
+ * @param node Object shape node with optional catchall graph.
+ * @param objectExpression JavaScript object expression already proven object.
+ * @param context Shared emission context.
+ * @param state Mutable graph emitter state.
+ */
+function emitObjectShapeCatchall(node, objectExpression, context, state) {
+    if (node.catchallGraph === undefined) {
+        return;
+    }
+    if (isUnsafeMode(context)) {
+        emitUnsafeObjectShapeCatchall(node, objectExpression, context, state);
+        return;
+    }
+    const keys = `xs${String(state.temp)}`;
+    state.temp += 1;
+    const length = `n${String(state.temp)}`;
+    state.temp += 1;
+    const index = `i${String(state.temp)}`;
+    state.temp += 1;
+    const key = `key${String(state.temp)}`;
+    state.temp += 1;
+    const descriptor = `d${String(state.temp)}`;
+    state.temp += 1;
+    const itemValue = `v${String(state.temp)}`;
+    state.temp += 1;
+    state.chunks.push(`const ${keys}=Reflect.ownKeys(${objectExpression});`, `const ${length}=${keys}.length;`, `for(let ${index}=0;${index}<${length};${index}+=1){`, `const ${key}=${keys}[${index}];`, `if(typeof ${key}==="string"&&${keyMembershipExpression(key, node.keys, context)})continue;`, `const ${descriptor}=gp(${objectExpression},${key});`, `if(${descriptor}===undefined||!h.call(${descriptor},"value"))${failStatement(state)}`, `const ${itemValue}=${descriptor}.value;`);
+    emitFalseCheck(node.catchallGraph, node.catchallGraph.result, itemValue, context, state);
+    state.chunks.push("}");
+}
+/**
+ * @brief Emit unsafe catchall validation for undeclared own object keys.
+ * @param node Object shape node with catchall graph.
+ * @param objectExpression JavaScript object expression already proven object.
+ * @param context Shared emission context.
+ * @param state Mutable graph emitter state.
+ */
+function emitUnsafeObjectShapeCatchall(node, objectExpression, context, state) {
+    if (node.catchallGraph === undefined) {
+        return;
+    }
+    const keys = `xs${String(state.temp)}`;
+    state.temp += 1;
+    const length = `n${String(state.temp)}`;
+    state.temp += 1;
+    const index = `i${String(state.temp)}`;
+    state.temp += 1;
+    const key = `key${String(state.temp)}`;
+    state.temp += 1;
+    const itemValue = `v${String(state.temp)}`;
+    state.temp += 1;
+    state.chunks.push(`const ${keys}=Reflect.ownKeys(${objectExpression});`, `const ${length}=${keys}.length;`, `for(let ${index}=0;${index}<${length};${index}+=1){`, `const ${key}=${keys}[${index}];`, `if(typeof ${key}==="string"&&${unsafeKeyMembershipExpression(key, node.keys)})continue;`, `const ${itemValue}=${objectExpression}[${key}];`);
+    emitFalseCheck(node.catchallGraph, node.catchallGraph.result, itemValue, context, state);
+    state.chunks.push("}");
+}
 /**
  * @brief emit object shape entries.
  * @details Emission is isolated here so optimized graph nodes lower to stable JavaScript shapes across safe, unsafe, and unchecked modes.
@@ -1368,8 +1454,9 @@ function emitObjectShapeEntries(node, objectExpression, context, state) {
         emitUnsafeObjectShapeEntries(node, objectExpression, context, state);
         return;
     }
-    for (let index = 0; index < node.entries.length; index += 1) {
-        const entry = node.entries[index];
+    const entries = scheduleObjectShapeEntries(node.entries);
+    for (let index = 0; index < entries.length; index += 1) {
+        const entry = entries[index];
         if (entry === undefined) {
             state.chunks.push(failStatement(state));
             continue;
@@ -1377,7 +1464,11 @@ function emitObjectShapeEntries(node, objectExpression, context, state) {
         const cacheKey = dataSlotKey(node.value, entry.key, objectExpression);
         const slot = emitDataSlotForExpression(node.value, entry.key, objectExpression, context, state);
         if (entry.presence === PresenceTag.Optional) {
-            state.chunks.push(`if(${slot.descriptor}!==undefined){`, `if(!h.call(${slot.descriptor},"value"))${failStatement(state)}`);
+            const rejectsUndefined = !schemaCanAcceptUndefined(entry.schema);
+            state.chunks.push(`if(${slot.descriptor}!==undefined){`);
+            if (!rejectsUndefined) {
+                state.chunks.push(`if(!h.call(${slot.descriptor},"value"))${failStatement(state)}`);
+            }
             state.dataGuards.add(cacheKey);
             const itemValue = emitDataSlotValue(cacheKey, slot, state);
             emitFalseCheck(entry.graph, entry.graph.result, itemValue, context, state);
@@ -1385,7 +1476,10 @@ function emitObjectShapeEntries(node, objectExpression, context, state) {
         }
         else {
             if (!state.dataGuards.has(cacheKey)) {
-                state.chunks.push(`if(${slot.descriptor}===undefined||!h.call(${slot.descriptor},"value"))${failStatement(state)}`);
+                const rejectsUndefined = !schemaCanAcceptUndefined(entry.schema);
+                state.chunks.push(rejectsUndefined
+                    ? `if(${slot.descriptor}===undefined)${failStatement(state)}`
+                    : `if(${slot.descriptor}===undefined||!h.call(${slot.descriptor},"value"))${failStatement(state)}`);
                 state.dataGuards.add(cacheKey);
             }
             if (isKnownLiteralDataSlot(entry.schema, cacheKey, state)) {
@@ -1396,6 +1490,235 @@ function emitObjectShapeEntries(node, objectExpression, context, state) {
         }
     }
 }
+/**
+ * @brief Schedule pure object fields for predicate-only fast failure.
+ * @details SchemaCheck nodes can run user code through refine or lazy fallback,
+ * so they act as barriers. Pure fields between barriers may be reordered because
+ * boolean validation has no diagnostic ordering contract.
+ * @param entries Object shape entries in schema order.
+ * @returns Entry view ordered for V8-friendly predicate emission.
+ */
+function scheduleObjectShapeEntries(entries) {
+    if (entries.length < 2) {
+        return entries;
+    }
+    const scheduled = [];
+    let index = 0;
+    while (index < entries.length) {
+        const entry = entries[index];
+        if (entry === undefined) {
+            index += 1;
+            continue;
+        }
+        if (!isSchedulableObjectShapeEntry(entry)) {
+            scheduled.push(entry);
+            index += 1;
+            continue;
+        }
+        const run = [];
+        while (index < entries.length) {
+            const candidate = entries[index];
+            if (candidate === undefined || !isSchedulableObjectShapeEntry(candidate)) {
+                break;
+            }
+            run.push({
+                entry: candidate,
+                order: index
+            });
+            index += 1;
+        }
+        run.sort(compareScheduledObjectShapeEntries);
+        for (let runIndex = 0; runIndex < run.length; runIndex += 1) {
+            const scheduledEntry = run[runIndex];
+            if (scheduledEntry !== undefined) {
+                scheduled.push(scheduledEntry.entry);
+            }
+        }
+    }
+    return scheduled;
+}
+/**
+ * @brief Compare two object entries for predicate emission.
+ * @details Required fields can fail on absence and are therefore tested before
+ * optional fields. Within the same presence class, cheaper child graphs run
+ * first so invalid objects fail before arrays, records, or regex-heavy checks.
+ * @param left Left scheduled entry.
+ * @param right Right scheduled entry.
+ * @returns Negative when left should be emitted before right.
+ */
+function compareScheduledObjectShapeEntries(left, right) {
+    const leftPresence = objectShapePresenceCost(left.entry);
+    const rightPresence = objectShapePresenceCost(right.entry);
+    if (leftPresence !== rightPresence) {
+        return leftPresence - rightPresence;
+    }
+    const leftCost = estimateGraphCost(left.entry.graph);
+    const rightCost = estimateGraphCost(right.entry.graph);
+    if (leftCost !== rightCost) {
+        return leftCost - rightCost;
+    }
+    return left.order - right.order;
+}
+/**
+ * @brief Return whether an object entry may move within its pure run.
+ * @details SchemaCheck is the IR boundary for user predicates and lazy
+ * resolution. Keeping those entries fixed preserves observable user-code order.
+ * @param entry Object shape entry under consideration.
+ * @returns True when the entry graph has no opaque runtime callback.
+ */
+function isSchedulableObjectShapeEntry(entry) {
+    return !graphContainsSchemaCheck(entry.graph);
+}
+/**
+ * @brief Estimate object field presence cost.
+ * @details Required fields receive the lower rank because missing required keys
+ * are common fast-fail cases and optional absence usually succeeds.
+ * @param entry Object shape entry.
+ * @returns Numeric rank used before graph cost.
+ */
+function objectShapePresenceCost(entry) {
+    return entry.presence === PresenceTag.Optional ? 1_000 : 0;
+}
+/**
+ * @brief Estimate predicate cost for one child graph.
+ * @details The values are intentionally coarse. The scheduler only needs stable
+ * buckets that keep scalar checks before regexes and bounded loops.
+ * @param graph Child graph emitted for one object field.
+ * @returns Relative cost used by Tide scheduling.
+ */
+function estimateGraphCost(graph) {
+    let cost = 0;
+    for (let index = 0; index < graph.nodes.length; index += 1) {
+        const node = graph.nodes[index];
+        if (node !== undefined) {
+            cost += estimateNodeCost(node);
+        }
+    }
+    return cost;
+}
+/**
+ * @brief Estimate one node's predicate cost.
+ * @details Compile-time scheduling only needs relative ordering, so the weights
+ * favor V8-friendly scalar branches and push bounded or dynamic loops later.
+ * @param node Graph node inspected by the scheduler.
+ * @returns Relative node cost.
+ */
+function estimateNodeCost(node) {
+    switch (node.tag) {
+        case NodeTag.Start:
+        case NodeTag.Param:
+        case NodeTag.Const:
+        case NodeTag.Return:
+            return 0;
+        case NodeTag.IsString:
+        case NodeTag.IsNumber:
+        case NodeTag.IsBoolean:
+        case NodeTag.IsBigInt:
+        case NodeTag.IsSymbol:
+        case NodeTag.IsObject:
+        case NodeTag.IsArray:
+        case NodeTag.IsUndefined:
+        case NodeTag.IsNull:
+        case NodeTag.IsInteger:
+        case NodeTag.StringMin:
+        case NodeTag.StringMax:
+        case NodeTag.Gte:
+        case NodeTag.Lte:
+        case NodeTag.Equals:
+            return 1;
+        case NodeTag.Regex:
+            return 8;
+        case NodeTag.PrimitiveUnion:
+        case NodeTag.UnionDispatch:
+        case NodeTag.DiscriminantDispatch:
+        case NodeTag.ObjectShape:
+        case NodeTag.TupleItems:
+            return 16;
+        case NodeTag.ArrayEvery:
+        case NodeTag.RecordEvery:
+            return 64;
+        case NodeTag.SchemaCheck:
+            return 128;
+        default:
+            return 2;
+    }
+}
+/**
+ * @brief Check whether a graph can enter user-controlled runtime logic.
+ * @details Refine and lazy schemas lower to SchemaCheck nodes. Treating them as
+ * scheduling barriers prevents pure field reordering from hiding side effects.
+ * @param graph Child graph scanned for opaque checks.
+ * @returns True when the graph contains a SchemaCheck node at some depth.
+ */
+function graphContainsSchemaCheck(graph) {
+    for (let index = 0; index < graph.nodes.length; index += 1) {
+        const node = graph.nodes[index];
+        if (node === undefined) {
+            continue;
+        }
+        if (node.tag === NodeTag.SchemaCheck) {
+            return true;
+        }
+        if (nodeContainsSchemaCheck(node)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * @brief Scan nested graphs owned by one node.
+ * @details Composite IR nodes store child graphs by value, so barrier discovery
+ * must recurse through those embedded validation graphs.
+ * @param node Node whose embedded graphs are inspected.
+ * @returns True when a nested graph contains SchemaCheck.
+ */
+function nodeContainsSchemaCheck(node) {
+    switch (node.tag) {
+        case NodeTag.ArrayEvery:
+        case NodeTag.RecordEvery:
+            return graphContainsSchemaCheck(node.itemGraph);
+        case NodeTag.TupleItems:
+            return graphArrayContainsSchemaCheck(node.itemGraphs);
+        case NodeTag.ObjectShape:
+            return objectEntriesContainSchemaCheck(node.entries);
+        case NodeTag.DiscriminantDispatch:
+        case NodeTag.UnionDispatch:
+        case NodeTag.PrimitiveUnion:
+            return graphArrayContainsSchemaCheck(node.graphs);
+        default:
+            return false;
+    }
+}
+/**
+ * @brief Scan a graph vector for SchemaCheck.
+ * @details Undefined holes are ignored because they carry no executable graph.
+ * @param graphs Child graph vector.
+ * @returns True when a present graph contains SchemaCheck.
+ */
+function graphArrayContainsSchemaCheck(graphs) {
+    for (let index = 0; index < graphs.length; index += 1) {
+        const graph = graphs[index];
+        if (graph !== undefined && graphContainsSchemaCheck(graph)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * @brief Scan object entries for SchemaCheck.
+ * @details Nested object shapes may appear inside scheduled parent fields.
+ * @param entries Nested object shape entries.
+ * @returns True when an entry graph contains an opaque check.
+ */
+function objectEntriesContainSchemaCheck(entries) {
+    for (let index = 0; index < entries.length; index += 1) {
+        const entry = entries[index];
+        if (entry !== undefined && graphContainsSchemaCheck(entry.graph)) {
+            return true;
+        }
+    }
+    return false;
+}
 /**
  * @brief Execute emit unsafe object shape entries.
  * @details Code generation helpers keep emitted JavaScript shape stable across runtime and AOT paths.
@@ -1441,6 +1764,9 @@ function emitObjectShapeStrictKeys(node, objectExpression, context, state) {
     if (node.mode !== ObjectModeTag.Strict) {
         return;
     }
+    if (node.catchall !== undefined) {
+        return;
+    }
     if (isUncheckedMode(context)) {
         return;
     }
@@ -2140,6 +2466,51 @@ function regexExpression(value, regex, context) {
 function regexNeedsLastIndexReset(regex) {
     return regex.global || regex.sticky;
 }
+/**
+ * @brief Emit compact expression-mode array iteration.
+ * @param value Generated expression for the candidate array.
+ * @param node ArrayEvery node with sparse-slot and length metadata.
+ * @param context Shared code-generation context.
+ * @returns Boolean JavaScript expression for array iteration.
+ */
+function emitArrayEveryExpression(value, node, context) {
+    const loop = schemaCanAcceptUndefined(node.item)
+        ? `eu(${value},${emitGraphChildFunction(node.itemGraph, context)})`
+        : `ea(${value},${emitGraphChildFunction(node.itemGraph, context)})`;
+    const lengthParts = arrayLengthPredicateParts(value, node.checks);
+    if (lengthParts.length === 0) {
+        return loop;
+    }
+    return `(${lengthParts.join("&&")}&&${loop})`;
+}
+/**
+ * @brief Build expression-mode array length predicates.
+ * @param value Generated expression for the candidate array.
+ * @param checks Normalized length check vector.
+ * @returns Predicate fragments guarding safe `.length` access.
+ */
+function arrayLengthPredicateParts(value, checks) {
+    if (checks.length === 0) {
+        return [];
+    }
+    const parts = [`Array.isArray(${value})`];
+    for (let index = 0; index < checks.length; index += 1) {
+        const check = checks[index];
+        if (check === undefined) {
+            parts.push("false");
+            continue;
+        }
+        switch (check.tag) {
+            case ArrayCheckTag.Min:
+                parts.push(`${value}.length>=${String(check.value)}`);
+                break;
+            case ArrayCheckTag.Max:
+                parts.push(`${value}.length<=${String(check.value)}`);
+                break;
+        }
+    }
+    return parts;
+}
 /**
  * @brief emit tuple items expression.
  * @details Expression helpers centralize escaping, side-table references, and JavaScript corner cases so runtime and AOT output stay byte-for-byte consistent.

package/dist/compile/guard.d.ts

@@ -18,9 +18,10 @@ import type { CompileOptions, CompiledGuard } from "./types.js";
 export declare class CompiledBaseGuard<TValue, TPresence extends Presence = "required"> extends BaseGuard<TValue, TPresence> implements CompiledGuard<TValue, TPresence> {
     #private;
     readonly source: string;
-    constructor(schema: Schema, test: BooleanPredicate, collect: IssueCollectorRoot, source: string, trustedCollector?: boolean, checkResult?: CheckResultRoot);
+    constructor(schema: Schema, test: BooleanPredicate, collect: IssueCollectorRoot, source: string, trustedCollector?: boolean, checkResult?: CheckResultRoot, checkFirstResult?: CheckResultRoot);
     is(this: CompiledBaseGuard<TValue, TPresence>, value: unknown): value is RuntimeValue<TValue, TPresence>;
     check(this: CompiledBaseGuard<TValue, TPresence>, value: unknown): CheckResult<RuntimeValue<TValue, TPresence>>;
+    checkFirst(this: CompiledBaseGuard<TValue, TPresence>, value: unknown): CheckResult<RuntimeValue<TValue, TPresence>>;
     assert(this: CompiledBaseGuard<TValue, TPresence>, value: unknown): asserts value is RuntimeValue<TValue, TPresence>;
 }
 /**

package/dist/compile/guard.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"guard.d.ts","sourceRoot":"","sources":["../../src/compile/guard.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACH,SAAS,EAET,KAAK,KAAK,EACV,KAAK,QAAQ,EACb,KAAK,YAAY,EACpB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGrD,OAAO,EAGH,KAAK,MAAM,EACd,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAIH,KAAK,gBAAgB,EACrB,KAAK,eAAe,EAEpB,KAAK,kBAAkB,EAC1B,MAAM,cAAc,CAAC;AAEtB,OAAO,KAAK,EAER,cAAc,EACd,aAAa,EAChB,MAAM,YAAY,CAAC;AAMpB;;;;;GAKG;AACH,qBAAa,iBAAiB,CAC1B,MAAM,EACN,SAAS,SAAS,QAAQ,GAAG,UAAU,CACzC,SAAQ,SAAS,CAAC,MAAM,EAAE,SAAS,CAAE,YAAW,aAAa,CAAC,MAAM,EAAE,SAAS,CAAC;;IAM9E,SAAwB,MAAM,EAAE,MAAM,CAAC;gBAGnC,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,gBAAgB,EACtB,OAAO,EAAE,kBAAkB,EAC3B,MAAM,EAAE,MAAM,EACd,gBAAgB,UAAQ,EACxB,WAAW,CAAC,EAAE,eAAe;IA8BjB,EAAE,CACd,IAAI,EAAE,iBAAiB,CAAC,MAAM,EAAE,SAAS,CAAC,EAC1C,KAAK,EAAE,OAAO,GACf,KAAK,IAAI,YAAY,CAAC,MAAM,EAAE,SAAS,CAAC;IAI3B,KAAK,CACjB,IAAI,EAAE,iBAAiB,CAAC,MAAM,EAAE,SAAS,CAAC,EAC1C,KAAK,EAAE,OAAO,GACf,WAAW,CAAC,YAAY,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAW/B,MAAM,CAClB,IAAI,EAAE,iBAAiB,CAAC,MAAM,EAAE,SAAS,CAAC,EAC1C,KAAK,EAAE,OAAO,GACf,OAAO,CAAC,KAAK,IAAI,YAAY,CAAC,MAAM,EAAE,SAAS,CAAC;CAYtD;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,SAAS,SAAS,QAAQ,EACtD,KAAK,EAAE,KAAK,CAAC,MAAM,EAAE,SAAS,CAAC,EAC/B,OAAO,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,GAClC,iBAAiB,CAAC,MAAM,EAAE,SAAS,CAAC,CAsCtC"}
+{"version":3,"file":"guard.d.ts","sourceRoot":"","sources":["../../src/compile/guard.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACH,SAAS,EAET,KAAK,KAAK,EACV,KAAK,QAAQ,EACb,KAAK,YAAY,EACpB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGrD,OAAO,EAGH,KAAK,MAAM,EACd,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAKH,KAAK,gBAAgB,EACrB,KAAK,eAAe,EAEpB,KAAK,kBAAkB,EAC1B,MAAM,cAAc,CAAC;AAEtB,OAAO,KAAK,EAER,cAAc,EACd,aAAa,EAChB,MAAM,YAAY,CAAC;AAMpB;;;;;GAKG;AACH,qBAAa,iBAAiB,CAC1B,MAAM,EACN,SAAS,SAAS,QAAQ,GAAG,UAAU,CACzC,SAAQ,SAAS,CAAC,MAAM,EAAE,SAAS,CAAE,YAAW,aAAa,CAAC,MAAM,EAAE,SAAS,CAAC;;IAO9E,SAAwB,MAAM,EAAE,MAAM,CAAC;gBAGnC,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,gBAAgB,EACtB,OAAO,EAAE,kBAAkB,EAC3B,MAAM,EAAE,MAAM,EACd,gBAAgB,UAAQ,EACxB,WAAW,CAAC,EAAE,eAAe,EAC7B,gBAAgB,CAAC,EAAE,eAAe;IAqCtB,EAAE,CACd,IAAI,EAAE,iBAAiB,CAAC,MAAM,EAAE,SAAS,CAAC,EAC1C,KAAK,EAAE,OAAO,GACf,KAAK,IAAI,YAAY,CAAC,MAAM,EAAE,SAAS,CAAC;IAI3B,KAAK,CACjB,IAAI,EAAE,iBAAiB,CAAC,MAAM,EAAE,SAAS,CAAC,EAC1C,KAAK,EAAE,OAAO,GACf,WAAW,CAAC,YAAY,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAW/B,UAAU,CACtB,IAAI,EAAE,iBAAiB,CAAC,MAAM,EAAE,SAAS,CAAC,EAC1C,KAAK,EAAE,OAAO,GACf,WAAW,CAAC,YAAY,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAW/B,MAAM,CAClB,IAAI,EAAE,iBAAiB,CAAC,MAAM,EAAE,SAAS,CAAC,EAC1C,KAAK,EAAE,OAAO,GACf,OAAO,CAAC,KAAK,IAAI,YAAY,CAAC,MAAM,EAAE,SAAS,CAAC;CAYtD;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,SAAS,SAAS,QAAQ,EACtD,KAAK,EAAE,KAAK,CAAC,MAAM,EAAE,SAAS,CAAC,EAC/B,OAAO,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,GAClC,iBAAiB,CAAC,MAAM,EAAE,SAAS,CAAC,CA2CtC"}