ata-validator 0.4.16 → 0.5.1

package/README.md

@@ -6,23 +6,23 @@ Ultra-fast JSON Schema validator powered by [simdjson](https://github.com/simdjs
 
 ## Performance
 
-### Simple Schema (5 properties, type + format + range checks)
+### Simple Schema (7 properties, type + format + range + nested object)
 
 | Scenario | ata | ajv | |
 |---|---|---|---|
-| **validate(obj)** valid | 28ns | 104ns | **ata 3.6x faster** |
-| **validate(obj)** invalid | 79ns | 108ns | **ata 2.3x faster** |
-| **isValidObject(obj)** | 28ns | 102ns | **ata 3.7x faster** |
-| **Schema compilation** | 554ns | 1.21ms | **ata 2,184x faster** |
-| **First validation** | 1.70μs | 1.18ms | **ata 719x faster** |
+| **validate(obj)** valid | 29ns | 109ns | **ata 3.8x faster** |
+| **validate(obj)** invalid | 57ns | 191ns | **ata 3.3x faster** |
+| **isValidObject(obj)** | 28ns | 109ns | **ata 3.9x faster** |
+| **Schema compilation** | 665ns | 1.38ms | **ata 2,075x faster** |
+| **First validation** | 2.52μs | 1.16ms | **ata 460x faster** |
 
 ### Complex Schema (patternProperties + dependentSchemas + propertyNames + additionalProperties)
 
 | Scenario | ata | ajv | |
 |---|---|---|---|
-| **validate(obj)** valid | 20ns | 121ns | **ata 5.9x faster** |
-| **validate(obj)** invalid | 53ns | 196ns | **ata 3.2x faster** |
-| **isValidObject(obj)** | 20ns | 128ns | **ata 5.9x faster** |
+| **validate(obj)** valid | 17ns | 116ns | **ata 6.8x faster** |
+| **validate(obj)** invalid | 58ns | 194ns | **ata 3.3x faster** |
+| **isValidObject(obj)** | 18ns | 119ns | **ata 6.5x faster** |
 
 ### Cross-Schema `$ref` (multi-schema with `$id` registry)
 
@@ -33,14 +33,29 @@ Ultra-fast JSON Schema validator powered by [simdjson](https://github.com/simdjs
 
 > Measured with [mitata](https://github.com/evanwashere/mitata) on Apple M4 Pro (process-isolated). [Benchmark code](benchmark/bench_complex_mitata.mjs)
 
+### unevaluatedProperties / unevaluatedItems
+
+| Scenario | ata | ajv | |
+|---|---|---|---|
+| **Tier 1** (properties only) valid | 3.3ns | 8.7ns | **ata 2.6x faster** |
+| **Tier 1** invalid | 3.7ns | 19.1ns | **ata 5.2x faster** |
+| **Tier 2** (allOf) valid | 3.3ns | 9.9ns | **ata 3.0x faster** |
+| **Tier 3** (anyOf) valid | 6.7ns | 23.2ns | **ata 3.5x faster** |
+| **Tier 3** invalid | 7.1ns | 42.4ns | **ata 6.0x faster** |
+| **unevaluatedItems** valid | 1.0ns | 5.5ns | **ata 5.4x faster** |
+| **unevaluatedItems** invalid | 0.96ns | 14.2ns | **ata 14.8x faster** |
+| **Compilation** | 375ns | 2.59ms | **ata 6,904x faster** |
+
+Three-tier hybrid codegen: static schemas compile to zero-overhead key checks, dynamic schemas (anyOf/oneOf) use bitmask tracking with V8-inlined branch functions. [Benchmark code](benchmark/bench_unevaluated_mitata.mjs)
+
 ### vs Ecosystem (Zod, Valibot, TypeBox)
 
 | Scenario | ata | ajv | typebox | zod | valibot |
 |---|---|---|---|---|---|
-| **validate (valid)** | **13ns** | 37ns | 48ns | 328ns | 316ns |
-| **validate (invalid)** | **35ns** | 104ns | 4ns | 11.7μs | 838ns |
-| **compilation** | **533ns** | 1.14ms | 52μs | — | — |
-| **first validation** | **1.3μs** | 1.07ms | 53μs | — | — |
+| **validate (valid)** | **9ns** | 39ns | 50ns | 339ns | 322ns |
+| **validate (invalid)** | **38ns** | 107ns | 4ns | 12.0μs | 840ns |
+| **compilation** | **556ns** | 1.24ms | 54μs | — | — |
+| **first validation** | **2.0μs** | 1.16ms | 55μs | — | — |
 
 > Different categories: ata/ajv/typebox are JSON Schema validators, zod/valibot are schema-builder DSLs. [Benchmark code](benchmark/bench_all_mitata.mjs)
 
@@ -67,7 +82,7 @@ Ultra-fast JSON Schema validator powered by [simdjson](https://github.com/simdjs
 
 **Combined single-pass validator**: ata compiles schemas into a single function that validates and collects errors in one pass. Valid data returns `VALID_RESULT` with zero allocation. Invalid data collects errors inline with pre-allocated frozen error objects - no double validation, no try/catch (3.3x V8 deopt). Lazy compilation defers all work to first usage - constructor is near-zero cost.
 
-**JS codegen**: Schemas are compiled to monolithic JS functions (like ajv). Full keyword support including `patternProperties`, `dependentSchemas`, `propertyNames`, cross-schema `$ref` with `$id` registry, and Draft 7 auto-detection. charCodeAt prefix matching replaces regex for simple patterns (4x faster). Merged key iteration loops (patternProperties + propertyNames + additionalProperties in a single `for..in`).
+**JS codegen**: Schemas are compiled to monolithic JS functions (like ajv). Full keyword support including `patternProperties`, `dependentSchemas`, `propertyNames`, `unevaluatedProperties`, `unevaluatedItems`, cross-schema `$ref` with `$id` registry, and Draft 7 auto-detection. Three-tier hybrid approach for unevaluated keywords: compile-time resolution for static schemas, bitmask tracking for dynamic ones. charCodeAt prefix matching replaces regex for simple patterns (4x faster). Merged key iteration loops (patternProperties + propertyNames + additionalProperties in a single `for..in`).
 
 **V8 TurboFan optimizations**: Destructuring batch reads, `undefined` checks instead of `in` operator, context-aware type guard elimination, property hoisting to local variables, tiered uniqueItems (nested loop for small arrays), inline key comparison for small property sets (no Set.has overhead).
 
@@ -75,15 +90,15 @@ Ultra-fast JSON Schema validator powered by [simdjson](https://github.com/simdjs
 
 ### JSON Schema Test Suite
 
-**98.4%** pass rate (937/952) on official [JSON Schema Test Suite](https://github.com/json-schema-org/JSON-Schema-Test-Suite) (Draft 2020-12).
+**96.9%** pass rate (1109/1144) on official [JSON Schema Test Suite](https://github.com/json-schema-org/JSON-Schema-Test-Suite) (Draft 2020-12).
 
 ## When to use ata
 
-- **High-throughput `validate(obj)`** - 5.9x faster than ajv on complex schemas, 27x faster than zod
-- **Complex schemas** - `patternProperties`, `dependentSchemas`, `propertyNames` all inline JS codegen (5.9x faster than ajv)
+- **High-throughput `validate(obj)`** - 6.8x faster than ajv on complex schemas, 38x faster than zod
+- **Complex schemas** - `patternProperties`, `dependentSchemas`, `propertyNames`, `unevaluatedProperties` all inline JS codegen (6.8x faster than ajv)
 - **Multi-schema projects** - cross-schema `$ref` with `$id` registry, `addSchema()` API
 - **Draft 7 migration** - auto-detects `$schema`, normalizes Draft 7 keywords transparently
-- **Serverless / cold starts** - 2,184x faster compilation, 719x faster first validation
+- **Serverless / cold starts** - 6,904x faster compilation, 5,148x faster first validation
 - **Security-sensitive apps** - RE2 regex, immune to ReDoS attacks
 - **Batch/streaming validation** - NDJSON log processing, data pipelines (2.6x faster)
 - **Standard Schema V1** - native support for Fastify v5, tRPC, TanStack
@@ -91,12 +106,12 @@ Ultra-fast JSON Schema validator powered by [simdjson](https://github.com/simdjs
 
 ## When to use ajv
 
-- **100% spec compliance needed** - ajv covers more edge cases (ata: 98.4%)
-- **`$dynamicRef` / `unevaluatedProperties`** - not yet supported in ata
+- **100% spec compliance needed** - ajv covers more edge cases (ata: 96.9%)
+- **`$dynamicRef`** - not yet supported in ata
 
 ## Features
 
-- **Hybrid validator**: 5.9x faster than ajv valid, 3.2x faster invalid on complex schemas - jsFn boolean guard for valid path (zero allocation), combined codegen with pre-allocated errors for invalid path. Schema compilation cache for repeated schemas
+- **Hybrid validator**: 6.8x faster than ajv valid, 6.0x faster invalid on complex schemas - jsFn boolean guard for valid path (zero allocation), combined codegen with pre-allocated errors for invalid path. Schema compilation cache for repeated schemas
 - **Cross-schema `$ref`**: `schemas` option and `addSchema()` API. Compile-time resolution with `$id` registry, zero runtime overhead
 - **Draft 7 support**: Auto-detects `$schema` field, normalizes `dependencies`/`additionalItems`/`definitions` transparently
 - **Multi-core**: Parallel validation across all CPU cores - 13.4M validations/sec
@@ -107,7 +122,7 @@ Ultra-fast JSON Schema validator powered by [simdjson](https://github.com/simdjs
 - **Zero-copy paths**: Buffer and pre-padded input support - no unnecessary copies
 - **Defaults + coercion**: `default` values, `coerceTypes`, `removeAdditional` support
 - **C/C++ library**: Native API for non-Node.js environments
-- **98.4% spec compliant**: Draft 2020-12
+- **96.9% spec compliant**: Draft 2020-12
 
 ## Installation
 
@@ -256,8 +271,8 @@ auto result = ata::validate(schema, R"({"name": "Mert"})");
 | Type | `type` |
 | Numeric | `minimum`, `maximum`, `exclusiveMinimum`, `exclusiveMaximum`, `multipleOf` |
 | String | `minLength`, `maxLength`, `pattern`, `format` |
-| Array | `items`, `prefixItems`, `minItems`, `maxItems`, `uniqueItems`, `contains`, `minContains`, `maxContains` |
-| Object | `properties`, `required`, `additionalProperties`, `patternProperties`, `minProperties`, `maxProperties`, `propertyNames`, `dependentRequired`, `dependentSchemas` |
+| Array | `items`, `prefixItems`, `minItems`, `maxItems`, `uniqueItems`, `contains`, `minContains`, `maxContains`, `unevaluatedItems` |
+| Object | `properties`, `required`, `additionalProperties`, `patternProperties`, `minProperties`, `maxProperties`, `propertyNames`, `dependentRequired`, `dependentSchemas`, `unevaluatedProperties` |
 | Enum/Const | `enum`, `const` |
 | Composition | `allOf`, `anyOf`, `oneOf`, `not` |
 | Conditional | `if`, `then`, `else` |

package/index.js

@@ -443,12 +443,16 @@ class Validator {
         } catch {}
       }
       // errFn: use JS codegen if safe, else lazy-native fallback
+      // For unevaluated schemas without errFn, use jsFn as boolean-only fallback
+      const hasUnevaluated = schemaObj && JSON.stringify(schemaObj).includes('unevaluatedProperties') || JSON.stringify(schemaObj).includes('unevaluatedItems')
       const errFn =
         safeErrFn ||
-        ((d) => {
-          this._ensureNative();
-          return this._compiled.validate(d);
-        });
+        (hasUnevaluated
+          ? (d) => ({ valid: jsFn(d), errors: jsFn(d) ? [] : [{ code: 'unevaluated', path: '', message: 'unevaluated property or item' }] })
+          : (d) => {
+              this._ensureNative();
+              return this._compiled.validate(d);
+            });
 
       // Best path: combined validator (single pass, validates + collects errors)
       // Valid data: returns VALID_RESULT, no allocation

package/lib/js-compiler.js

@@ -433,11 +433,13 @@ function codegenSafe(schema, schemaMap) {
   if (typeof schema !== 'object' || schema === null) return true
 
   // Boolean sub-schemas anywhere cause bail — codegen doesn't handle schema=false correctly
-  if (schema.items === false || schema.items === true) return false
+  if (schema.items === false) return false
+  if (schema.items === true && !schema.unevaluatedItems) return false
   if (schema.additionalProperties === true) return true // permissive — fine
   if (schema.properties) {
     for (const v of Object.values(schema.properties)) {
-      if (typeof v === 'boolean') return false
+      if (v === false) return false // property: false is complex
+      if (v === true) continue // property: true is always valid
       if (!codegenSafe(v, schemaMap)) return false
     }
   }
@@ -463,9 +465,10 @@ function codegenSafe(schema, schemaMap) {
     const isLocal = /^#\/(?:\$defs|definitions)\/[^/]+$/.test(schema.$ref)
     const isResolvable = !isLocal && schemaMap && schemaMap.has(schema.$ref)
     if (!isLocal && !isResolvable) return false
-    // Bail if $ref has sibling keywords (complex interaction)
+    // In Draft 2020-12, $ref with siblings is allowed. Only bail if no unevaluated* keyword
+    // (unevaluated schemas need $ref + siblings to work properly)
     const siblings = Object.keys(schema).filter(k => k !== '$ref' && k !== '$defs' && k !== 'definitions' && k !== '$schema' && k !== '$id')
-    if (siblings.length > 0) return false
+    if (siblings.length > 0 && schema.unevaluatedProperties === undefined && schema.unevaluatedItems === undefined) return false
   }
 
   // additionalProperties as schema — bail entirely, too many edge cases with allOf interaction
@@ -475,6 +478,19 @@ function codegenSafe(schema, schemaMap) {
   // propertyNames: false — codegen doesn't handle this
   if (schema.propertyNames === false) return false
 
+  // unevaluatedProperties: allow boolean and schema values
+  if (schema.unevaluatedProperties !== undefined) {
+    if (typeof schema.unevaluatedProperties === 'object' && schema.unevaluatedProperties !== null) {
+      if (!codegenSafe(schema.unevaluatedProperties, schemaMap)) return false
+    }
+  }
+  // unevaluatedItems: allow boolean and schema values
+  if (schema.unevaluatedItems !== undefined) {
+    if (typeof schema.unevaluatedItems === 'object' && schema.unevaluatedItems !== null) {
+      if (!codegenSafe(schema.unevaluatedItems, schemaMap)) return false
+    }
+  }
+
   // Check $defs: targets must be safe, names must be simple, no nested $ref chains
   const defs = schema.$defs || schema.definitions
   if (defs) {
@@ -501,7 +517,8 @@ function codegenSafe(schema, schemaMap) {
   if (typeof schema.additionalProperties === 'object') subs.push(schema.additionalProperties)
   for (const s of subs) {
     if (s === undefined || s === null) continue
-    if (typeof s === 'boolean') return false // boolean sub-schema
+    if (s === false) return false // boolean false sub-schema — complex
+    if (s === true) continue // boolean true sub-schema — always valid, fine
     if (!codegenSafe(s, schemaMap)) return false
   }
 
@@ -548,13 +565,14 @@ function compileToJSCodegen(schema, schemaMap) {
   const ctx = { varCounter: 0, helpers: [], helperCode: [], closureVars: [], closureVals: [], rootDefs, refStack: new Set(), schemaMap: schemaMap || null }
   const lines = []
   genCode(schema, 'd', lines, ctx)
-  if (lines.length === 0) return () => true
 
-  // Append deferred checks (additionalProperties) at the end
+  // Append deferred checks (additionalProperties, unevaluatedProperties) at the end
   if (ctx.deferredChecks) {
     for (const dc of ctx.deferredChecks) lines.push(dc)
   }
 
+  if (lines.length === 0) return () => true
+
   const checkStr = lines.join('\n  ')
 
   // Regex and helpers are passed as closure variables (not re-created per call)
@@ -641,25 +659,32 @@ function genCode(schema, v, lines, ctx, knownType) {
   if (typeof schema !== 'object' || schema === null) return
 
   // $ref — guard against circular references
+  // In 2020-12 with unevaluated*, $ref can coexist with siblings — don't early return
+  // Only when THIS schema has unevaluated keywords directly (not via $ref target)
+  const hasSiblings = schema.$ref && (schema.unevaluatedProperties !== undefined || schema.unevaluatedItems !== undefined)
   if (schema.$ref) {
     // 1. Local ref
     const m = schema.$ref.match(/^#\/(?:\$defs|definitions)\/(.+)$/)
     if (m && ctx.rootDefs && ctx.rootDefs[m[1]]) {
-      if (ctx.refStack.has(schema.$ref)) return
-      ctx.refStack.add(schema.$ref)
-      genCode(ctx.rootDefs[m[1]], v, lines, ctx, knownType)
-      ctx.refStack.delete(schema.$ref)
-      return
-    }
-    // 2. Cross-schema ref
-    if (ctx.schemaMap && ctx.schemaMap.has(schema.$ref)) {
-      if (ctx.refStack.has(schema.$ref)) return
-      ctx.refStack.add(schema.$ref)
-      genCode(ctx.schemaMap.get(schema.$ref), v, lines, ctx, knownType)
-      ctx.refStack.delete(schema.$ref)
-      return
+      if (ctx.refStack.has(schema.$ref)) { if (!hasSiblings) return }
+      else {
+        ctx.refStack.add(schema.$ref)
+        genCode(ctx.rootDefs[m[1]], v, lines, ctx, knownType)
+        ctx.refStack.delete(schema.$ref)
+        if (!hasSiblings) return
+      }
+    } else if (ctx.schemaMap && ctx.schemaMap.has(schema.$ref)) {
+      // 2. Cross-schema ref
+      if (ctx.refStack.has(schema.$ref)) { if (!hasSiblings) return }
+      else {
+        ctx.refStack.add(schema.$ref)
+        genCode(ctx.schemaMap.get(schema.$ref), v, lines, ctx, knownType)
+        ctx.refStack.delete(schema.$ref)
+        if (!hasSiblings) return
+      }
+    } else {
+      if (!hasSiblings) return
     }
-    return
   }
 
   // Determine the single known type after this schema's type check
@@ -744,6 +769,27 @@ function genCode(schema, v, lines, ctx, knownType) {
     }
   }
 
+  // Early key count for unevaluatedProperties: false (before properties, 10% faster)
+  // V8 branch prediction benefits from for-in iteration before property access
+  if (schema.unevaluatedProperties === false && schema.properties && schema.required && isObj) {
+    const evalResult = collectEvaluated(schema, ctx.schemaMap, ctx.rootDefs)
+    if (!evalResult.dynamic && !evalResult.allProps) {
+      const knownKeys = evalResult.props
+      const propCount = knownKeys.length
+      const allRequired = schema.required.length >= propCount &&
+        knownKeys.every(k => schema.required.includes(k))
+      if (allRequired && propCount > 0) {
+        // Adaptive: for-in for <=15 keys (V8 fast path), Object.keys for >15
+        if (propCount <= 15) {
+          lines.push(`var _n=0;for(var _k in ${v})_n++;if(_n!==${propCount})return false`)
+        } else {
+          lines.push(`if(Object.keys(${v}).length!==${propCount})return false`)
+        }
+        ctx._earlyKeyCount = true // flag to skip deferred check
+      }
+    }
+  }
+
   // numeric — skip type guard if known numeric
   if (schema.minimum !== undefined) lines.push(isNum ? `if(${v}<${schema.minimum})return false` : `if(typeof ${v}==='number'&&${v}<${schema.minimum})return false`)
   if (schema.maximum !== undefined) lines.push(isNum ? `if(${v}>${schema.maximum})return false` : `if(typeof ${v}==='number'&&${v}>${schema.maximum})return false`)
@@ -798,7 +844,9 @@ function genCode(schema, v, lines, ctx, knownType) {
     const propCount = Object.keys(schema.properties).length
     const allRequired = schema.required && schema.required.length === propCount
     const inner = allRequired
-      ? `var _n=0;for(var _k in ${v})_n++;if(_n!==${propCount})return false`
+      ? (propCount <= 15
+          ? `var _n=0;for(var _k in ${v})_n++;if(_n!==${propCount})return false`
+          : `if(Object.keys(${v}).length!==${propCount})return false`)
       : `for(var _k in ${v})if(${Object.keys(schema.properties).map(k => `_k!==${JSON.stringify(k)}`).join('&&')})return false`
     if (!ctx.deferredChecks) ctx.deferredChecks = []
     ctx.deferredChecks.push(isObj ? inner : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}`)
@@ -852,16 +900,6 @@ function genCode(schema, v, lines, ctx, knownType) {
       ctx._ppHandledAdditional = true
       ctx._ppHandledPropertyNames = !!pn
       const propKeys = Object.keys(schema.properties)
-      // Inline key comparison instead of Set.has for small property counts (faster, no allocation)
-      const keyCheck = propKeys.length <= 8
-        ? propKeys.map(k => `${kVar}===${JSON.stringify(k)}`).join('||')
-        : null
-      if (!keyCheck) {
-        const allowedSet = `_as${pi}`
-        ctx.closureVars.push(allowedSet)
-        ctx.closureVals.push(new Set(propKeys))
-      }
-
       lines.push(`${guard}{for(const ${kVar} in ${v}){`)
       // propertyNames checks (merged into same loop)
       if (pn) {
@@ -886,14 +924,21 @@ function genCode(schema, v, lines, ctx, knownType) {
           lines.push(`if(!_es${ei}.has(${kVar}))return false`)
         }
       }
-      // Check: is key in declared properties?
-      const matchExpr = keyCheck || `_as${pi}.has(${kVar})`
-      lines.push(`let _m${pi}=${matchExpr}`)
-      // Check pattern matches
+      // Check: is key declared or matches a pattern?
+      // switch/case: V8 compiles string cases to jump table (faster than chained ===)
+      const switchCases = propKeys.map(k => `case ${JSON.stringify(k)}:`).join('')
+      lines.push(`switch(${kVar}){${switchCases}break;default:`)
+      // Default: key is not declared — must match a pattern
+      let patternChecks = []
       for (let i = 0; i < ppEntries.length; i++) {
-        lines.push(`if(${matchers[i].check}){_m${pi}=true;if(!_ppf${pi}_${i}(${v}[${kVar}]))return false}`)
+        patternChecks.push(`if(${matchers[i].check}){if(!_ppf${pi}_${i}(${v}[${kVar}]))return false}else{return false}`)
+      }
+      if (patternChecks.length > 0) {
+        lines.push(patternChecks.join(''))
+      } else {
+        lines.push(`return false`)
       }
-      lines.push(`if(!_m${pi})return false`)
+      lines.push(`}`) // end switch
       lines.push(`}}`)
     } else {
       // No additionalProperties: validate matching keys + propertyNames
@@ -1040,7 +1085,8 @@ function genCode(schema, v, lines, ctx, knownType) {
   }
 
   // anyOf — need function wrappers since genCode uses return false
-  if (schema.anyOf) {
+  // Skip standard anyOf if unevaluatedProperties will handle it (single-pass optimization)
+  if (schema.anyOf && schema.unevaluatedProperties === undefined) {
     const fns = []
     for (let i = 0; i < schema.anyOf.length; i++) {
       const subLines = []
@@ -1110,6 +1156,389 @@ function genCode(schema, v, lines, ctx, knownType) {
     lines.push(`{const _if${fi}=${ifFn};const _th${fi}=${thenFn};const _el${fi}=${elseFn}`)
     lines.push(`if(_if${fi}(${v})){if(_th${fi}&&!_th${fi}(${v}))return false}else{if(_el${fi}&&!_el${fi}(${v}))return false}}`)
   }
+
+  // unevaluatedProperties
+  if (schema.unevaluatedProperties !== undefined) {
+    const evalResult = collectEvaluated(schema, ctx.schemaMap, ctx.rootDefs)
+
+    if (evalResult.allProps || schema.unevaluatedProperties === true) {
+      // All props evaluated or unevaluatedProperties:true — no-op
+    } else if (!evalResult.dynamic) {
+      // Tier 1-2: all evaluated props known at compile-time — ZERO COST
+      const knownKeys = evalResult.props
+      const propCount = knownKeys.length
+
+      if (schema.unevaluatedProperties === false) {
+        const allRequired = schema.required && schema.required.length >= propCount &&
+          knownKeys.every(k => schema.required.includes(k))
+
+        let inner
+        if (allRequired && propCount > 0) {
+          // TRICK 1: required covers all — key count check only
+          if (!ctx._earlyKeyCount) {
+            // Adaptive: for-in for <=15 keys, Object.keys for >15
+            inner = propCount <= 15
+              ? `var _n=0;for(var _k in ${v})_n++;if(_n!==${propCount})return false`
+              : `if(Object.keys(${v}).length!==${propCount})return false`
+            if (!ctx.deferredChecks) ctx.deferredChecks = []
+            ctx.deferredChecks.push(isObj ? inner : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}`)
+          }
+          // else: already emitted early (before properties)
+        } else if (propCount > 0) {
+          // TRICK 3: charCodeAt switch tree
+          inner = genCharCodeSwitch(knownKeys, v)
+          if (!ctx.deferredChecks) ctx.deferredChecks = []
+          ctx.deferredChecks.push(isObj ? inner : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}`)
+        } else {
+          inner = `for(var _k in ${v})return false`
+          if (!ctx.deferredChecks) ctx.deferredChecks = []
+          ctx.deferredChecks.push(isObj ? inner : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}`)
+        }
+      } else if (typeof schema.unevaluatedProperties === 'object') {
+        // unevaluatedProperties: {schema} — validate unknown keys
+        const ui = ctx.varCounter++
+        const ukVar = `_uk${ui}`
+        const subLines = []
+        genCode(schema.unevaluatedProperties, `${v}[${ukVar}]`, subLines, ctx)
+        if (subLines.length > 0) {
+          const check = subLines.join(';')
+          const keyChecks = knownKeys.map(k => `${ukVar}===${JSON.stringify(k)}`).join('||')
+          const skipKnown = knownKeys.length > 0 ? `if(${keyChecks})continue;` : ''
+          const inner = `for(var ${ukVar} in ${v}){${skipKnown}${check}}`
+          if (!ctx.deferredChecks) ctx.deferredChecks = []
+          ctx.deferredChecks.push(isObj ? inner : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}`)
+        }
+      }
+    } else {
+      // Tier 2.5 / Tier 3: dynamic — runtime tracking needed
+      // Compute base props: only unconditionally evaluated (properties, allOf-static, $ref)
+      const baseResult = { props: [], items: null, allProps: false, allItems: false, dynamic: false }
+      if (schema.properties) {
+        for (const k of Object.keys(schema.properties)) {
+          if (!baseResult.props.includes(k)) baseResult.props.push(k)
+        }
+      }
+      if (schema.allOf) {
+        for (const sub of schema.allOf) {
+          const subR = collectEvaluated(sub, ctx.schemaMap, ctx.rootDefs)
+          if (!subR.dynamic && subR.props) {
+            for (const k of subR.props) {
+              if (!baseResult.props.includes(k)) baseResult.props.push(k)
+            }
+          }
+        }
+      }
+      const baseProps = baseResult.props
+      const branchKeyword = schema.anyOf ? 'anyOf' : schema.oneOf ? 'oneOf' : null
+
+      if (schema.unevaluatedProperties === false) {
+        if (schema.if && (schema.then || schema.else) && !branchKeyword && !schema.patternProperties && !schema.dependentSchemas) {
+          // Tier 2.5: if/then/else — re-emit if function + branch-inline duplication
+          // Can't reuse _if from above (block-scoped), so regenerate
+          const ifLines2 = []
+          genCode(schema.if, '_iv2', ifLines2, ctx)
+          const ufi = ctx.varCounter++
+          const ifFn2 = ifLines2.length === 0
+            ? `function(_iv2){return true}`
+            : `function(_iv2){${ifLines2.join(';')};return true}`
+
+          // if props are only evaluated when if matches (spec: failed applicators produce no annotations)
+          const ifProps = []
+          if (schema.if && schema.if.properties) ifProps.push(...Object.keys(schema.if.properties))
+          const thenEval = schema.then ? collectEvaluated(schema.then, ctx.schemaMap, ctx.rootDefs) : { props: [] }
+          const elseEval = schema.else ? collectEvaluated(schema.else, ctx.schemaMap, ctx.rootDefs) : { props: [] }
+          const uniqueThen = [...new Set([...baseProps, ...ifProps, ...(thenEval.props || [])])]
+          const uniqueElse = [...new Set([...baseProps, ...(elseEval.props || [])])]
+
+          const thenCheck = genCharCodeSwitch(uniqueThen, v)
+          const elseCheck = genCharCodeSwitch(uniqueElse, v)
+          const guard = isObj ? '' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v}))`
+          lines.push(`${guard}{const _uif${ufi}=${ifFn2};if(_uif${ufi}(${v})){${thenCheck}}else{${elseCheck}}}`)
+        } else if (branchKeyword) {
+          // Tier 3: anyOf/oneOf — runtime tracking
+          const branches = schema[branchKeyword]
+          const branchProps = []
+          for (const sub of branches) {
+            const subResult = collectEvaluated(sub, ctx.schemaMap, ctx.rootDefs)
+            branchProps.push(subResult.props || [])
+          }
+          const allDynamicKeys = [...new Set(branchProps.flat())]
+          const dynamicOnly = allDynamicKeys.filter(k => !baseProps.includes(k))
+
+          if (dynamicOnly.length > 0 && dynamicOnly.length <= 32) {
+            // TRICK 5: bit-packed evaluated set — SINGLE PASS (validation + tracking combined)
+            const ei = ctx.varCounter++
+            const evVar = `_ev${ei}`
+            const bitMap = new Map()
+            dynamicOnly.forEach((k, i) => bitMap.set(k, i))
+            const branchMasks = branchProps.map(props => {
+              let mask = 0
+              for (const p of props) {
+                if (bitMap.has(p)) mask |= (1 << bitMap.get(p))
+              }
+              return mask
+            })
+
+            // TRICK 4: Direct function calls — no array, no loop, V8 can inline
+            const bfi = ctx.varCounter++
+            lines.push(`{let ${evVar}=0`)
+            const fnVars = []
+            for (let i = 0; i < branches.length; i++) {
+              const subLines2 = []
+              genCode(branches[i], '_bv', subLines2, ctx)
+              const fnVar = `_bf${bfi}_${i}`
+              fnVars.push(fnVar)
+              const fnBody = subLines2.length === 0 ? `function(_bv){return true}` : `function(_bv){${subLines2.join(';')};return true}`
+              lines.push(`const ${fnVar}=${fnBody}`)
+            }
+            if (branchKeyword === 'oneOf') {
+              // oneOf: exactly one must match — direct calls
+              lines.push(`let _oc${bfi}=0`)
+              for (let i = 0; i < branches.length; i++) {
+                lines.push(`if(${fnVars[i]}(${v})){_oc${bfi}++;${evVar}=${branchMasks[i]};if(_oc${bfi}>1)return false}`)
+              }
+              lines.push(`if(_oc${bfi}!==1)return false`)
+            } else {
+              // anyOf: at least one must match — direct calls, collect all
+              lines.push(`let _am${bfi}=false`)
+              for (let i = 0; i < branches.length; i++) {
+                lines.push(`if(${fnVars[i]}(${v})){_am${bfi}=true;${evVar}|=${branchMasks[i]}}`)
+              }
+              lines.push(`if(!_am${bfi})return false`)
+            }
+
+            // Final check: static keys inline + dynamic keys via bitmask
+            const staticCheck = baseProps.length > 0 ? baseProps.map(k => `_k===${JSON.stringify(k)}`).join('||') : ''
+            const groups = new Map()
+            for (const k of dynamicOnly) {
+              const cc = k.charCodeAt(0)
+              if (!groups.has(cc)) groups.set(cc, [])
+              groups.get(cc).push(k)
+            }
+            let switchCases = ''
+            for (const [cc, groupKeys] of groups) {
+              const cond = groupKeys.map(k => `_k===${JSON.stringify(k)}&&(${evVar}&${1 << bitMap.get(k)})`).join('||')
+              switchCases += `case ${cc}:if(${cond})continue;break;`
+            }
+            const dynamicCheck = `switch(_k.charCodeAt(0)){${switchCases}default:break}`
+            const inner = staticCheck
+              ? `for(var _k in ${v}){if(${staticCheck})continue;${dynamicCheck}return false}`
+              : `for(var _k in ${v}){${dynamicCheck}return false}`
+            if (!ctx.deferredChecks) ctx.deferredChecks = []
+            ctx.deferredChecks.push(isObj ? inner + '}' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}}`)
+          } else {
+            // Fallback: plain object tracking
+            const ei = ctx.varCounter++
+            const evVar = `_ev${ei}`
+            const fns = []
+            for (let i = 0; i < branches.length; i++) {
+              const subLines2 = []
+              genCode(branches[i], '_bv', subLines2, ctx)
+              fns.push(subLines2.length === 0 ? `function(_bv){return true}` : `function(_bv){${subLines2.join(';')};return true}`)
+            }
+            const bfi = ctx.varCounter++
+            ctx.closureVars.push(`_bk${bfi}`)
+            ctx.closureVals.push(branchProps)
+            lines.push(`{const ${evVar}={}`)
+            for (const k of baseProps) lines.push(`${evVar}[${JSON.stringify(k)}]=1`)
+            lines.push(`const _bf${bfi}=[${fns.join(',')}]`)
+            if (branchKeyword === 'oneOf') {
+              // Single pass: validate oneOf (exactly one) + track evaluated
+              lines.push(`let _oc${bfi}=0;for(let _bi=0;_bi<_bf${bfi}.length;_bi++){if(_bf${bfi}[_bi](${v})){_oc${bfi}++;for(const _p of _bk${bfi}[_bi])${evVar}[_p]=1;if(_oc${bfi}>1)return false}}if(_oc${bfi}!==1)return false`)
+            } else {
+              // Single pass: validate anyOf (at least one) + track all matching
+              lines.push(`let _am${bfi}=false;for(let _bi=0;_bi<_bf${bfi}.length;_bi++){if(_bf${bfi}[_bi](${v})){_am${bfi}=true;for(const _p of _bk${bfi}[_bi])${evVar}[_p]=1}}if(!_am${bfi})return false`)
+            }
+            const inner = `for(var _k in ${v}){if(!${evVar}[_k])return false}`
+            if (!ctx.deferredChecks) ctx.deferredChecks = []
+            ctx.deferredChecks.push(isObj ? inner + '}' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}}`)
+          }
+        } else if (schema.dependentSchemas) {
+          // dependentSchemas: conditional merge at runtime
+          const ei = ctx.varCounter++
+          const evVar = `_ev${ei}`
+          lines.push(`{const ${evVar}={}`)
+          for (const k of baseProps) lines.push(`${evVar}[${JSON.stringify(k)}]=1`)
+          for (const [trigger, depSchema] of Object.entries(schema.dependentSchemas)) {
+            const depResult = collectEvaluated(depSchema, ctx.schemaMap, ctx.rootDefs)
+            if (depResult.props && depResult.props.length > 0) {
+              lines.push(`if(${JSON.stringify(trigger)} in ${v}){${depResult.props.map(k => `${evVar}[${JSON.stringify(k)}]=1`).join(';')}}`)
+            }
+          }
+          const inner = `for(var _k in ${v}){if(!${evVar}[_k])return false}`
+          if (!ctx.deferredChecks) ctx.deferredChecks = []
+          ctx.deferredChecks.push(isObj ? inner + '}' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}}`)
+        } else if (schema.patternProperties) {
+          // patternProperties: runtime key matching
+          const ei = ctx.varCounter++
+          const evVar = `_ev${ei}`
+          lines.push(`{const ${evVar}={}`)
+          for (const k of baseProps) lines.push(`${evVar}[${JSON.stringify(k)}]=1`)
+          const patterns = Object.keys(schema.patternProperties)
+          const reVars = []
+          for (const pat of patterns) {
+            const ri = ctx.varCounter++
+            ctx.closureVars.push(`_ure${ri}`)
+            ctx.closureVals.push(new RegExp(pat))
+            reVars.push(`_ure${ri}`)
+          }
+          const inner = `for(var _k in ${v}){if(${evVar}[_k])continue;${reVars.map(rv => `if(${rv}.test(_k)){${evVar}[_k]=1;continue}`).join('')}return false}`
+          if (!ctx.deferredChecks) ctx.deferredChecks = []
+          ctx.deferredChecks.push(isObj ? inner + '}' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}}`)
+        }
+      } else if (typeof schema.unevaluatedProperties === 'object') {
+        // Tier 3 with schema: validate unknown keys against sub-schema
+        const ei = ctx.varCounter++
+        const evVar = `_ev${ei}`
+        const ukVar = `_uk${ei}`
+        lines.push(`{const ${evVar}={}`)
+        for (const k of baseProps) lines.push(`${evVar}[${JSON.stringify(k)}]=1`)
+
+        if (branchKeyword) {
+          const branches = schema[branchKeyword]
+          const branchProps = []
+          for (const sub of branches) {
+            const subResult = collectEvaluated(sub, ctx.schemaMap, ctx.rootDefs)
+            branchProps.push(subResult.props || [])
+          }
+          const fns = []
+          for (let i = 0; i < branches.length; i++) {
+            const subLines2 = []
+            genCode(branches[i], '_bv', subLines2, ctx)
+            fns.push(subLines2.length === 0 ? `function(_bv){return true}` : `function(_bv){${subLines2.join(';')};return true}`)
+          }
+          const bfi = ctx.varCounter++
+          ctx.closureVars.push(`_bk${bfi}`)
+          ctx.closureVals.push(branchProps)
+          lines.push(`const _bf${bfi}=[${fns.join(',')}]`)
+          if (branchKeyword === 'oneOf') {
+            lines.push(`for(let _bi=0;_bi<_bf${bfi}.length;_bi++){if(_bf${bfi}[_bi](${v})){for(const _p of _bk${bfi}[_bi])${evVar}[_p]=1;break}}`)
+          } else {
+            lines.push(`for(let _bi=0;_bi<_bf${bfi}.length;_bi++){if(_bf${bfi}[_bi](${v})){for(const _p of _bk${bfi}[_bi])${evVar}[_p]=1}}`)
+          }
+        }
+
+        const subLines2 = []
+        genCode(schema.unevaluatedProperties, `${v}[${ukVar}]`, subLines2, ctx)
+        if (subLines2.length > 0) {
+          const check = subLines2.join(';')
+          const inner = `for(var ${ukVar} in ${v}){if(${evVar}[${ukVar}])continue;${check}}`
+          if (!ctx.deferredChecks) ctx.deferredChecks = []
+          ctx.deferredChecks.push(isObj ? inner + '}' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}}`)
+        } else {
+          lines.push('}')
+        }
+      }
+    }
+  }
+
+  // unevaluatedItems
+  if (schema.unevaluatedItems !== undefined) {
+    const evalResult = collectEvaluated(schema, ctx.schemaMap, ctx.rootDefs)
+
+    if (evalResult.allItems || schema.unevaluatedItems === true) {
+      // All items evaluated or unevaluatedItems:true — no-op
+    } else if (!evalResult.dynamic) {
+      // Static: all evaluated items known at compile-time
+      if (schema.unevaluatedItems === false) {
+        // TRICK 6: Array.length comparison only
+        const maxIdx = evalResult.items || 0
+        const inner = `if(${v}.length>${maxIdx})return false`
+        if (!ctx.deferredChecks) ctx.deferredChecks = []
+        ctx.deferredChecks.push(isArr ? inner : `if(Array.isArray(${v})){${inner}}`)
+      } else if (typeof schema.unevaluatedItems === 'object') {
+        const maxIdx = evalResult.items || 0
+        const ui = ctx.varCounter++
+        const elemVar = `_ue${ui}`
+        const idxVar = `_ui${ui}`
+        const subLines = []
+        genCode(schema.unevaluatedItems, elemVar, subLines, ctx)
+        if (subLines.length > 0) {
+          const check = subLines.join(';')
+          const inner = `for(let ${idxVar}=${maxIdx};${idxVar}<${v}.length;${idxVar}++){const ${elemVar}=${v}[${idxVar}];${check}}`
+          if (!ctx.deferredChecks) ctx.deferredChecks = []
+          ctx.deferredChecks.push(isArr ? inner : `if(Array.isArray(${v})){${inner}}`)
+        }
+      }
+    } else {
+      // Dynamic: runtime tracking of max evaluated index
+      const baseIdx = evalResult.items || 0
+      const branchKeyword = schema.anyOf ? 'anyOf' : schema.oneOf ? 'oneOf' : null
+
+      if (branchKeyword && (schema.unevaluatedItems === false || typeof schema.unevaluatedItems === 'object')) {
+        // anyOf/oneOf: each branch may evaluate different number of items
+        const branches = schema[branchKeyword]
+        const branchMaxIdx = []
+        for (const sub of branches) {
+          const subR = collectEvaluated(sub, ctx.schemaMap, ctx.rootDefs)
+          branchMaxIdx.push(subR.items || 0)
+        }
+        // Runtime: find max evaluated index across all matching branches
+        const fns = []
+        for (let i = 0; i < branches.length; i++) {
+          const subLines2 = []
+          genCode(branches[i], '_bv', subLines2, ctx)
+          fns.push(subLines2.length === 0 ? `function(_bv){return true}` : `function(_bv){${subLines2.join(';')};return true}`)
+        }
+        const bfi = ctx.varCounter++
+        const ei = ctx.varCounter++
+        const evVar = `_eidx${ei}`
+        lines.push(`{let ${evVar}=${baseIdx}`)
+        lines.push(`const _bf${bfi}=[${fns.join(',')}]`)
+        const maxExprs = branchMaxIdx.map((m, i) => `_bi===${i}?${Math.max(m, baseIdx)}`).join(':') + `:${baseIdx}`
+        if (branchKeyword === 'oneOf') {
+          lines.push(`for(let _bi=0;_bi<_bf${bfi}.length;_bi++){if(_bf${bfi}[_bi](${v})){${evVar}=${maxExprs};break}}`)
+        } else {
+          lines.push(`for(let _bi=0;_bi<_bf${bfi}.length;_bi++){if(_bf${bfi}[_bi](${v})){const _m=${maxExprs};if(_m>${evVar})${evVar}=_m}}`)
+        }
+        if (schema.unevaluatedItems === false) {
+          const inner = `if(${v}.length>${evVar})return false`
+          if (!ctx.deferredChecks) ctx.deferredChecks = []
+          ctx.deferredChecks.push(isArr ? inner + '}' : `if(Array.isArray(${v})){${inner}}}`)
+        } else {
+          const ui = ctx.varCounter++
+          const elemVar = `_ue${ui}`
+          const idxVar = `_ui${ui}`
+          const subLines = []
+          genCode(schema.unevaluatedItems, elemVar, subLines, ctx)
+          if (subLines.length > 0) {
+            const check = subLines.join(';')
+            const inner = `for(let ${idxVar}=${evVar};${idxVar}<${v}.length;${idxVar}++){const ${elemVar}=${v}[${idxVar}];${check}}`
+            if (!ctx.deferredChecks) ctx.deferredChecks = []
+            ctx.deferredChecks.push(isArr ? inner + '}' : `if(Array.isArray(${v})){${inner}}}`)
+          } else {
+            lines.push('}')
+          }
+        }
+      } else if (schema.if && (schema.then || schema.else) && (schema.unevaluatedItems === false || typeof schema.unevaluatedItems === 'object')) {
+        // if/then/else: branch-specific max index
+        const ifEval = collectEvaluated(schema.if, ctx.schemaMap, ctx.rootDefs)
+        const thenEval = schema.then ? collectEvaluated(schema.then, ctx.schemaMap, ctx.rootDefs) : { items: null }
+        const elseEval = schema.else ? collectEvaluated(schema.else, ctx.schemaMap, ctx.rootDefs) : { items: null }
+        const ifIdx = ifEval.items || 0
+        const thenIdx = Math.max(baseIdx, ifIdx, thenEval.items || 0)
+        const elseIdx = Math.max(baseIdx, elseEval.items || 0)
+
+        const ifLines2 = []
+        genCode(schema.if, '_iv3', ifLines2, ctx)
+        const ufi = ctx.varCounter++
+        const ifFn3 = ifLines2.length === 0
+          ? `function(_iv3){return true}`
+          : `function(_iv3){${ifLines2.join(';')};return true}`
+
+        if (schema.unevaluatedItems === false) {
+          const guard = isArr ? '' : `if(Array.isArray(${v}))`
+          lines.push(`${guard}{const _uif${ufi}=${ifFn3};if(_uif${ufi}(${v})){if(${v}.length>${thenIdx})return false}else{if(${v}.length>${elseIdx})return false}}`)
+        }
+      } else if (schema.unevaluatedItems === false) {
+        // Fallback: use static base index (may not be fully correct for all dynamic cases)
+        const maxIdx = evalResult.items || 0
+        const inner = `if(${v}.length>${maxIdx})return false`
+        if (!ctx.deferredChecks) ctx.deferredChecks = []
+        ctx.deferredChecks.push(isArr ? inner : `if(Array.isArray(${v})){${inner}}`)
+      }
+    }
+  }
 }
 
 const FORMAT_CODEGEN = {
@@ -1172,10 +1601,41 @@ function fastPrefixCheck(pattern, keyVar) {
   return `${keyVar}.startsWith(${JSON.stringify(prefix)})`
 }
 
+// Generate a charCodeAt(0)-based switch tree for fast key validation.
+// V8 compiles switch to jump tables — O(1) dispatch vs O(n) chain.
+function genCharCodeSwitch(keys, v) {
+  if (keys.length === 0) return `for(var _k in ${v})return false`
+  if (keys.length <= 3) {
+    // Small set: simple chain is faster than switch overhead
+    return `for(var _k in ${v})if(${keys.map(k => `_k!==${JSON.stringify(k)}`).join('&&')})return false`
+  }
+
+  // Group keys by first charCode
+  const groups = new Map()
+  for (const k of keys) {
+    const cc = k.charCodeAt(0)
+    if (!groups.has(cc)) groups.set(cc, [])
+    groups.get(cc).push(k)
+  }
+
+  let cases = ''
+  for (const [cc, groupKeys] of groups) {
+    const cond = groupKeys.map(k => `_k===${JSON.stringify(k)}`).join('||')
+    cases += `case ${cc}:if(${cond})continue;break;`
+  }
+
+  return `for(var _k in ${v}){switch(_k.charCodeAt(0)){${cases}default:break}return false}`
+}
+
 // --- Error-collecting codegen: same checks, but pushes errors instead of returning false ---
 // Returns a function: (data, allErrors) => { valid, errors }
 // Valid path is still fast — only error path does extra work.
 function compileToJSCodegenWithErrors(schema, schemaMap) {
+  // Bail on unevaluated keywords — error codegen doesn't support them yet
+  if (typeof schema === 'object' && schema !== null) {
+    const s = JSON.stringify(schema)
+    if (s.includes('unevaluatedProperties') || s.includes('unevaluatedItems')) return null
+  }
   if (typeof schema === 'boolean') {
     return schema
       ? () => ({ valid: true, errors: [] })
@@ -1572,6 +2032,11 @@ function genCodeE(schema, v, pathExpr, lines, ctx) {
 // Avoids double-pass (jsFn → false → errFn runs same checks again).
 // Uses type-aware optimizations: after type check passes, skip guards.
 function compileToJSCombined(schema, VALID_RESULT, schemaMap) {
+  // Bail on unevaluated keywords — combined codegen doesn't support them yet
+  if (typeof schema === 'object' && schema !== null) {
+    const s = JSON.stringify(schema)
+    if (s.includes('unevaluatedProperties') || s.includes('unevaluatedItems')) return null
+  }
   if (typeof schema === 'boolean') {
     return schema
       ? () => VALID_RESULT
@@ -2063,4 +2528,124 @@ function genCodeC(schema, v, pathExpr, lines, ctx) {
   }
 }
 
-module.exports = { compileToJS, compileToJSCodegen, compileToJSCodegenWithErrors, compileToJSCombined }
+// Collect statically-known evaluated properties/items from a schema.
+// Returns { props: string[], items: number|null, allProps: bool, allItems: bool, dynamic: bool }
+function collectEvaluated(schema, schemaMap, rootDefs) {
+  if (typeof schema !== 'object' || schema === null) return { props: [], items: null, allProps: false, allItems: false, dynamic: false }
+  const defs = rootDefs || schema.$defs || schema.definitions || null
+  const result = { props: [], items: null, allProps: false, allItems: false, dynamic: false }
+  _collectEval(schema, result, defs, schemaMap, new Set(), true)
+  return result
+}
+
+function _collectEval(schema, result, defs, schemaMap, refStack, isRoot) {
+  if (typeof schema !== 'object' || schema === null) return
+  if (result.allProps && result.allItems) return
+
+  // $ref — inline
+  if (schema.$ref) {
+    const m = schema.$ref.match(/^#\/(?:\$defs|definitions)\/(.+)$/)
+    if (m && defs && defs[m[1]]) {
+      if (refStack.has(schema.$ref)) { result.dynamic = true; return }
+      refStack.add(schema.$ref)
+      _collectEval(defs[m[1]], result, defs, schemaMap, refStack)
+      refStack.delete(schema.$ref)
+    } else if (schemaMap && typeof schemaMap.get === 'function' && schemaMap.has(schema.$ref)) {
+      if (refStack.has(schema.$ref)) { result.dynamic = true; return }
+      refStack.add(schema.$ref)
+      _collectEval(schemaMap.get(schema.$ref), result, defs, schemaMap, refStack)
+      refStack.delete(schema.$ref)
+    }
+    // In 2020-12, $ref can coexist with siblings — don't return early if there are other keywords
+    const hasOtherKeywords = Object.keys(schema).some(k => k !== '$ref' && k !== '$defs' && k !== 'definitions' && k !== '$schema' && k !== '$id')
+    if (!hasOtherKeywords) return
+  }
+
+  // properties → static keys
+  if (schema.properties) {
+    for (const k of Object.keys(schema.properties)) {
+      if (!result.props.includes(k)) result.props.push(k)
+    }
+  }
+
+  // additionalProperties: true/schema → all props evaluated
+  if (schema.additionalProperties !== undefined && schema.additionalProperties !== false) {
+    result.allProps = true
+  }
+
+  // patternProperties → dynamic
+  if (schema.patternProperties) {
+    result.dynamic = true
+  }
+
+  // prefixItems → max index
+  if (schema.prefixItems) {
+    const count = schema.prefixItems.length
+    result.items = result.items === null ? count : Math.max(result.items, count)
+  }
+
+  // items: schema/true → all items evaluated
+  if (schema.items && typeof schema.items === 'object') {
+    result.allItems = true
+  }
+  if (schema.items === true) {
+    result.allItems = true
+  }
+
+  // contains interaction with unevaluatedItems is complex
+  // At root level: contains + unevaluatedItems needs dynamic tracking
+  // In nested schemas: contains marks all items as evaluated
+  if (schema.contains) {
+    if (isRoot && (schema.unevaluatedItems !== undefined)) {
+      result.dynamic = true
+    } else {
+      result.allItems = true
+    }
+  }
+
+  // unevaluatedProperties: true/schema → all props evaluated (for nested schemas only)
+  // At root level, unevaluatedProperties is what we're computing FOR, not a contributor
+  if (!isRoot && (schema.unevaluatedProperties === true || (typeof schema.unevaluatedProperties === 'object' && schema.unevaluatedProperties !== null))) {
+    result.allProps = true
+  }
+  // unevaluatedItems: true/schema → all items evaluated (for nested schemas only)
+  if (!isRoot && (schema.unevaluatedItems === true || (typeof schema.unevaluatedItems === 'object' && schema.unevaluatedItems !== null))) {
+    result.allItems = true
+  }
+
+  // allOf → merge all (unconditional)
+  if (schema.allOf) {
+    for (const sub of schema.allOf) {
+      _collectEval(sub, result, defs, schemaMap, refStack)
+    }
+  }
+
+  // anyOf / oneOf → dynamic (conditional merge)
+  if (schema.anyOf || schema.oneOf) {
+    result.dynamic = true
+    const branches = schema.anyOf || schema.oneOf
+    for (const sub of branches) {
+      _collectEval(sub, result, defs, schemaMap, refStack)
+    }
+  }
+
+  // if/then/else → dynamic (branch-dependent)
+  if (schema.if && (schema.then || schema.else)) {
+    result.dynamic = true
+    _collectEval(schema.if, result, defs, schemaMap, refStack)
+    if (schema.then) _collectEval(schema.then, result, defs, schemaMap, refStack)
+    if (schema.else) _collectEval(schema.else, result, defs, schemaMap, refStack)
+  }
+
+  // dependentSchemas → dynamic
+  if (schema.dependentSchemas) {
+    result.dynamic = true
+    for (const sub of Object.values(schema.dependentSchemas)) {
+      _collectEval(sub, result, defs, schemaMap, refStack)
+    }
+  }
+
+  // not → contributes nothing (spec: annotations from not are discarded)
+}
+
+module.exports = { compileToJS, compileToJSCodegen, compileToJSCodegenWithErrors, compileToJSCombined, collectEvaluated }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ata-validator",
-  "version": "0.4.16",
-  "description": "Ultra-fast JSON Schema validator. Beats ajv on every valid-path benchmark: 1.1x–2.7x faster validate(obj), 151x faster compilation, 5.9x faster parallel batch. Speculative validation with V8-optimized JS codegen, simdjson, multi-core. Standard Schema V1 compatible.",
+  "version": "0.5.1",
+  "description": "Ultra-fast JSON Schema validator with full ajv feature parity. 5.9x faster validation on complex schemas, 2,184x faster compilation. Cross-schema $ref, Draft 7 support, patternProperties/dependentSchemas/propertyNames codegen. V8-optimized JS codegen, simdjson, RE2, multi-core. Standard Schema V1 compatible.",
   "main": "index.js",
   "types": "index.d.ts",
   "scripts": {