ata-validator 1.32.2 → 1.33.0

package/lib/js-compiler.js

@@ -1961,6 +1961,17 @@ function replaceTopLevel(code, onTrue = 'return R', onFalse = 'return E(d)') {
 
 // Returns true if a property sub-schema will generate 2+ lines that each access v,
 // meaning a local variable hoist is worthwhile.
+// A required object or array whose checks read it many times: into a local,
+// once. Reading \`d["customer"]\` afresh on every line cost a plain order
+// verdict 42 percent, since a helper call between two reads (a prototype
+// check, a length count) keeps V8 from reusing the first. Composition keeps
+// the direct access, the same line needsLocal draws.
+function isPlainContainer(schema) {
+  if (typeof schema !== 'object' || schema === null) return false
+  if (schema.$ref || schema.$dynamicRef || schema.allOf || schema.anyOf || schema.oneOf || schema.if || schema.not) return false
+  return !!(schema.properties || schema.items || schema.prefixItems)
+}
+
 function needsLocal(schema) {
   if (typeof schema !== 'object' || schema === null) return false
   // If it has $ref, allOf, anyOf etc., genCode handles it — don't hoist
@@ -2109,121 +2120,11 @@ function genCodeNode(schema, v, lines, ctx, knownType) {
   // 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) {
-    // Self-reference "#" — recursive call to root validator
-    if (schema.$ref === '#') {
-      if (ctx.nestedBoolean) throw DECLINE
-      ctx.usesRecursion = true
-      lines.push(`if(!_validate(${v}))return false`)
-      if (!hasSiblings) return
-    }
-    // 1. Local ref
-    const m = schema.$ref !== '#' && schema.$ref.match(/^#\/(?:\$defs|definitions)\/(.+)$/)
-    if (m && ctx.rootDefs && ctx.rootDefs[m[1]]) {
-      const defName = m[1]
-      if (!ctx.cyclicDefs) ctx.cyclicDefs = cyclicDefNames(ctx.rootDefs)
-      if (ctx.cyclicDefs.has(defName) && ctx.preamble) {
-        // A def on a cycle is a named function in the preamble, emitted once
-        // and called by name, so recursion terminates the way `$ref: "#"`
-        // does at the root. The name is registered before the body is
-        // generated so a self-reference inside it becomes a call.
-        if (!ctx.defFns) ctx.defFns = new Map()
-        let fnName = ctx.defFns.get(defName)
-        if (!fnName) {
-          fnName = '_def' + ctx.defFns.size + '_' + defName.replace(/[^A-Za-z0-9_]/g, '_')
-          ctx.defFns.set(defName, fnName)
-          const bodyLines = []
-          // The def is compiled as its own function over its own `d`, so the
-          // checks _deferOrInline holds back belong at the end of this body.
-          // The list hangs off ctx, so without the swap they are flushed into
-          // whatever function is compiling, carrying this def's key set.
-          const outerDeferred = ctx.deferredChecks
-          ctx.deferredChecks = null
-          genCode(ctx.rootDefs[defName], 'd', bodyLines, ctx)
-          if (ctx.deferredChecks) for (const dc of ctx.deferredChecks) bodyLines.push(dc)
-          ctx.deferredChecks = outerDeferred
-          // Entered through the cycle guard: see emitGuardState. In the fast
-          // pass the wrapper only counts depth; the set is used by the second,
-          // guarded pass that runs when data turns out to point back at
-          // itself.
-          ctx.preamble.push(
-            `const ${fnName}_s=new Set()\n  function ${fnName}(d){\n  ` +
-              `if(_sg){if(typeof d!=='object'||d===null)return ${fnName}_b(d);if(${fnName}_s.has(d))return true;${fnName}_s.add(d);try{return ${fnName}_b(d)}finally{${fnName}_s.delete(d)}}\n  ` +
-              `if(++_sd>${CYCLE_DEPTH})throw _CYC\n  const _r=${fnName}_b(d)\n  _sd--\n  return _r\n  }\n  ` +
-              `function ${fnName}_b(d){${bodyLines.join('\n  ')}\n  return true}`,
-          )
-        }
-        lines.push(`if(!${fnName}(${v}))return false`)
-        if (!hasSiblings) return
-      } else if (ctx.refStack.has(schema.$ref)) { if (ctx.nestedBoolean) throw DECLINE; if (!hasSiblings) return }
-      else {
-        ctx.refStack.add(schema.$ref)
-        genCode(ctx.rootDefs[defName], v, lines, ctx, knownType)
-        ctx.refStack.delete(schema.$ref)
-        if (!hasSiblings) return
-      }
-    } else if (schema.$ref !== '#' && !m && schema.$ref.startsWith('#') && !schema.$ref.startsWith('#/')) {
-      // Anchor ref: "#foo" — resolve via rootDefs or anchors map
-      const entry = ctx.rootDefs && ctx.rootDefs[schema.$ref]
-      const anchorTarget = entry && entry.raw ? entry.raw : (ctx.anchors && ctx.anchors[schema.$ref])
-      if (anchorTarget) {
-        if (ctx.refStack.has(schema.$ref)) { if (ctx.nestedBoolean) throw DECLINE; if (!hasSiblings) return }
-        else {
-          ctx.refStack.add(schema.$ref)
-          genCode(anchorTarget, v, lines, ctx, knownType)
-          ctx.refStack.delete(schema.$ref)
-          if (!hasSiblings) return
-        }
-      }
-    } else if (schema.$ref !== '#' && ctx.schemaMap) {
-      // 2. Cross-schema ref (exact match, relative URI, or JSON pointer fragment)
-      let resolved = ctx.schemaMap.get(schema.$ref)
-      if (!resolved && !schema.$ref.includes('://') && !schema.$ref.startsWith('#')) {
-        for (const [id, s] of ctx.schemaMap) {
-          if (id.endsWith('/' + schema.$ref)) { resolved = s; break }
-        }
-      }
-      if (!resolved && schema.$ref.includes('#') && !schema.$ref.startsWith('#')) {
-        const r = resolveCrossSchemaRef(schema.$ref, ctx.schemaMap)
-        if (r) resolved = r.schema
-      }
-      if (resolved) {
-        if (ctx.refStack.has(schema.$ref)) { if (!hasSiblings) return }
-        else {
-          ctx.refStack.add(schema.$ref)
-          genCode(resolved, v, lines, ctx, knownType)
-          ctx.refStack.delete(schema.$ref)
-          if (!hasSiblings) return
-        }
-      } else {
-        if (!hasSiblings) return
-      }
-    } else {
-      if (!hasSiblings) return
-    }
+    if (genRefNode(schema, v, lines, ctx, knownType, hasSiblings)) return
   }
 
   // $dynamicRef — resolve via anchors map
-  if (schema.$dynamicRef) {
-    const anchorKey = schema.$dynamicRef.startsWith('#') ? schema.$dynamicRef : '#' + schema.$dynamicRef
-    if (ctx.anchors && ctx.anchors[anchorKey]) {
-      const target = ctx.anchors[anchorKey]
-      if (target === ctx.rootSchema) {
-        // Self-recursive: generate _validate(v) call
-        if (ctx.nestedBoolean) throw DECLINE
-        ctx.usesRecursion = true
-        lines.push(`if(!_validate(${v}))return false`)
-      } else {
-        // Different schema: inline the target validation
-        const refKey = '$dynamicRef:' + anchorKey
-        if (ctx.refStack.has(refKey) && ctx.nestedBoolean) throw DECLINE
-        if (!ctx.refStack.has(refKey)) {
-          ctx.refStack.add(refKey)
-          genCode(target, v, lines, ctx, knownType)
-          ctx.refStack.delete(refKey)
-        }
-      }
-    }
-  }
+  if (schema.$dynamicRef) genDynamicRefNode(schema, v, lines, ctx, knownType)
 
   // Determine the single known type after this schema's type check
   const types = schema.type ? (Array.isArray(schema.type) ? schema.type : [schema.type]) : null
@@ -2316,7 +2217,11 @@ function genCodeNode(schema, v, lines, ctx, knownType) {
       // Read directly: the object type is already established here, and a
       // flag declared for this alone costs more than it saves. The list is
       // built only on that path, which an ordinary object never takes.
-      lines.push(`if(!${protoIs(ctx, v)}&&!_hall(${v},${JSON.stringify(typed)}))return false`)
+      // When withPlain already holds the answer for this object in a flag,
+      // read the flag: the prototype test is an accessor call, and making it
+      // twice per object was a tenth of a plain order's verdict.
+      const pk = ctx.plainOf ? ctx.plainOf.get(v) : undefined
+      lines.push(`if(!${pk || protoIs(ctx, v)}&&!_hall(${v},${JSON.stringify(typed)}))return false`)
     }
   } else if (schema.required && schema.required.length > 0) {
     const checks = schema.required.map(key => `!${ownKeyExpr(ctx, v, key)}`)
@@ -2447,31 +2352,7 @@ function genCodeNode(schema, v, lines, ctx, knownType) {
   }
 
   // uniqueItems — tiered strategy based on expected array size
-  if (schema.uniqueItems) {
-    const si = ctx.varCounter++
-    const itemType = schema.items && typeof schema.items === 'object' && schema.items.type
-    const isPrimItems = itemType === 'string' || itemType === 'number' || itemType === 'integer'
-    const maxItems = schema.maxItems
-    // Small primitive arrays (maxItems <= 16): nested loop is 6x faster than Set
-    // No allocation, no hash computation — just direct === comparison
-    let inner
-    if (isPrimItems && maxItems && maxItems <= 16) {
-      inner = `for(let _i=1;_i<${v}.length;_i++){for(let _k=0;_k<_i;_k++){if(${v}[_i]===${v}[_k])return false}}`
-    } else if (isPrimItems) {
-      inner = `const _s${si}=new Set();for(let _i=0;_i<${v}.length;_i++){if(_s${si}.has(${v}[_i]))return false;_s${si}.add(${v}[_i])}`
-    } else if (ctx.preamble) {
-      // Unknown item types: one hoisted helper per compiled function. Short
-      // arrays compare pairwise with a structural equality that ignores key
-      // order and allocates nothing; longer ones fall back to a Set of
-      // primitives, or to sorted-key canonical strings once an object shows
-      // up. The previous form built the canonical closure and a Set on
-      // every call, even for [1, 2, 3].
-      inner = `if(!${emitUq(ctx)}(${v}))return false`
-    } else {
-      inner = `const _cn${si}=function(x){if(x===null||typeof x!=='object')return typeof x+':'+x;if(Array.isArray(x))return'['+x.map(_cn${si}).join(',')+']';return'{'+Object.keys(x).sort().map(function(k){return JSON.stringify(k)+':'+_cn${si}(x[k])}).join(',')+'}'};const _s${si}=new Set();for(let _i=0;_i<${v}.length;_i++){const _k=_cn${si}(${v}[_i]);if(_s${si}.has(_k))return false;_s${si}.add(_k)}`
-    }
-    lines.push(isArr ? `{${inner}}` : `if(Array.isArray(${v})){${inner}}`)
-  }
+  if (schema.uniqueItems) genUniqueItemsNode(schema, v, lines, ctx, knownType, hoisted, isArr, types)
 
   // additionalProperties -- deferred to end of function for better V8 optimization
   // (type checks run first in hot path, expensive prop count check last)
@@ -2504,28 +2385,7 @@ function genCodeNode(schema, v, lines, ctx, knownType) {
   // additionalProperties as a schema: validate every non-declared property
   // against that sub-schema. Skip if patternProperties is present (handled by
   // the unified loop). Composition cases are filtered out by codegenSafe.
-  if (typeof schema.additionalProperties === 'object' && schema.additionalProperties !== null && !schema.patternProperties) {
-    // The loop variables carry a unique suffix: a record whose values are
-    // themselves records nests this loop inside itself, and a fixed `_av`
-    // made the inner `const _av=_av[_k]` a self-reference that threw at
-    // validation time.
-    const apId = ctx._apLoopId = (ctx._apLoopId || 0) + 1
-    const kVar = `_k${apId}`
-    const avVar = `_av${apId}`
-    const declared = schema.properties ? Object.keys(schema.properties) : []
-    const skipCheck = declared.length === 0
-      ? null
-      : declared.map(k => `${kVar}===${JSON.stringify(k)}`).join('||')
-    const subLines = []
-    genCode(schema.additionalProperties, avVar, subLines, ctx)
-    if (subLines.length > 0) {
-      const body = subLines.join(';')
-      const loop = skipCheck
-        ? `for(var ${kVar} in ${v}){if(${skipCheck})continue;const ${avVar}=${v}[${kVar}];${body}}`
-        : `for(var ${kVar} in ${v}){const ${avVar}=${v}[${kVar}];${body}}`
-      _deferOrInline(ctx, lines, v, isObj ? loop : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${loop}}`)
-    }
-  }
+  if (typeof schema.additionalProperties === 'object' && schema.additionalProperties !== null && !schema.patternProperties) genAdditionalSchemaNode(schema, v, lines, ctx, knownType, isObj)
 
   // dependentRequired
   if (schema.dependentRequired) {
@@ -2538,143 +2398,11 @@ function genCodeNode(schema, v, lines, ctx, knownType) {
   // patternProperties + propertyNames + additionalProperties — unified key iteration
   // Merges up to 3 separate for..in loops into one pass.
   if (schema.patternProperties) {
-    const ppEntries = Object.entries(schema.patternProperties)
-    const pn = schema.propertyNames && typeof schema.propertyNames === 'object' ? schema.propertyNames : null
-    const pi = ctx.varCounter++
-    const kVar = `_ppk${pi}`
-
-    // Build pattern matchers: prefer charCodeAt for simple prefixes, fall back to regex
-    const matchers = []
-    for (const [pat] of ppEntries) {
-      const fast = fastPrefixCheck(pat, kVar)
-      if (fast) {
-        matchers.push({ check: fast })
-      } else {
-        const ri = ctx.varCounter++
-        ctx.closureVars.push(`_re${ri}`)
-        ctx.closureVals.push(safeReClosure(ctx, pat))
-        matchers.push({ check: `_re${ri}.test(${kVar})` })
-      }
-    }
-
-    // Build sub-schema checks inline so they share the parent helper scope.
-    const subChecks = []
-    for (let i = 0; i < ppEntries.length; i++) {
-      const [, sub] = ppEntries[i]
-      const subLines = []
-      genCode(sub, `_ppv${pi}`, subLines, ctx)
-      subChecks.push(subLines.join(';'))
-    }
-
-    const guard = isObj ? '' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v}))`
-
-    const apSchema = typeof schema.additionalProperties === 'object' && schema.additionalProperties !== null ? schema.additionalProperties : null
-    if ((schema.additionalProperties === false && schema.properties) || apSchema) {
-      // Unified loop: properties + patterns + propertyNames + additionalProperties.
-      // A key that is neither declared nor matched by any pattern is
-      // additional: rejected outright, or run through the additionalProperties
-      // schema when there is one.
-      ppHandledPropertyNames = !!pn
-      const propKeys = Object.keys(schema.properties || {})
-      let apCheck = null
-      if (apSchema) {
-        const apLines = []
-        genCode(apSchema, `_apv${pi}`, apLines, ctx)
-        apCheck = apLines.join(';')
-      }
-      lines.push(`${guard}{for(const ${kVar} in ${v}){`)
-      // propertyNames checks (merged into same loop)
-      if (pn) {
-        if (pn.minLength !== undefined) lines.push(`if(${kVar}.length<${pn.minLength})return false`)
-        if (pn.maxLength !== undefined) lines.push(`if(${kVar}.length>${pn.maxLength})return false`)
-        if (pn.pattern) {
-          const fast = fastPrefixCheck(pn.pattern, kVar)
-          if (fast) {
-            lines.push(`if(!(${fast}))return false`)
-          } else {
-            const ri = ctx.varCounter++
-            ctx.closureVars.push(`_re${ri}`)
-            ctx.closureVals.push(safeReClosure(ctx, pn.pattern))
-            lines.push(`if(!_re${ri}.test(${kVar}))return false`)
-          }
-        }
-        if (pn.const !== undefined) lines.push(`if(${kVar}!==${JSON.stringify(pn.const)})return false`)
-        if (pn.enum) {
-          const ei = ctx.varCounter++
-          ctx.closureVars.push(`_es${ei}`)
-          ctx.closureVals.push(new Set(pn.enum))
-          lines.push(`if(!_es${ei}.has(${kVar}))return false`)
-        }
-      }
-      // Every matching pattern applies to every key, declared or not: a
-      // declared key that also matches a pattern is validated by both (the
-      // properties emitter handles its own subschema). A flag rather than an
-      // if/else chain, because a chain returned false at the first pattern
-      // that missed and wrongly rejected a key only a later pattern matched.
-      if (ppEntries.length > 0) {
-        lines.push(`let _pm${pi}=false`)
-        for (let i = 0; i < ppEntries.length; i++) {
-          lines.push(`if(${matchers[i].check}){_pm${pi}=true;const _ppv${pi}=${v}[${kVar}];${subChecks[i]}}`)
-        }
-      }
-      // A key that is neither declared nor matched is additional. switch on
-      // the declared names (V8 compiles string cases to a jump table); no
-      // switch at all when nothing is declared, since a switch with no case
-      // clause is a syntax error.
-      const additional = apCheck !== null ? `const _apv${pi}=${v}[${kVar}];${apCheck}` : `return false`
-      const notMatched = ppEntries.length > 0 ? `if(!_pm${pi}){${additional}}` : additional
-      if (propKeys.length) {
-        const switchCases = propKeys.map(k => `case ${JSON.stringify(k)}:`).join('')
-        lines.push(`switch(${kVar}){${switchCases}break;default:{${notMatched}}}`)
-      } else {
-        lines.push(notMatched)
-      }
-      lines.push(`}}`)
-    } else {
-      // No additionalProperties: validate matching keys + propertyNames
-      ppHandledPropertyNames = !!pn
-      lines.push(`${guard}{for(const ${kVar} in ${v}){`)
-      // propertyNames checks (merged)
-      if (pn) {
-        if (pn.minLength !== undefined) lines.push(`if(${kVar}.length<${pn.minLength})return false`)
-        if (pn.maxLength !== undefined) lines.push(`if(${kVar}.length>${pn.maxLength})return false`)
-        if (pn.pattern) {
-          const fast = fastPrefixCheck(pn.pattern, kVar)
-          if (fast) {
-            lines.push(`if(!(${fast}))return false`)
-          } else {
-            const ri = ctx.varCounter++
-            ctx.closureVars.push(`_re${ri}`)
-            ctx.closureVals.push(safeReClosure(ctx, pn.pattern))
-            lines.push(`if(!_re${ri}.test(${kVar}))return false`)
-          }
-        }
-        if (pn.const !== undefined) lines.push(`if(${kVar}!==${JSON.stringify(pn.const)})return false`)
-        if (pn.enum) {
-          const ei = ctx.varCounter++
-          ctx.closureVars.push(`_es${ei}`)
-          ctx.closureVals.push(new Set(pn.enum))
-          lines.push(`if(!_es${ei}.has(${kVar}))return false`)
-        }
-      }
-      for (let i = 0; i < ppEntries.length; i++) {
-        lines.push(`if(${matchers[i].check}){const _ppv${pi}=${v}[${kVar}];${subChecks[i]}}`)
-      }
-      lines.push(`}}`)
-    }
+    if (genPatternPropertiesNode(schema, v, lines, ctx, knownType, isObj)) ppHandledPropertyNames = true
   }
 
   // dependentSchemas
-  if (schema.dependentSchemas) {
-    for (const [key, depSchema] of Object.entries(schema.dependentSchemas)) {
-      const guard = isObj ? '' : `typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&`
-      lines.push(`if(${guard}${ownKeyExpr(ctx, v, key)}){`)
-      ctx.condDepth = (ctx.condDepth || 0) + 1
-      genCode(depSchema, v, lines, ctx, effectiveType)
-      ctx.condDepth--
-      lines.push(`}`)
-    }
-  }
+  if (schema.dependentSchemas) genDependentSchemasNode(schema, v, lines, ctx, knownType, effectiveType, isObj)
 
   // propertyNames: false rejects any key at all; true constrains nothing.
   if (schema.propertyNames === false) {
@@ -2684,33 +2412,7 @@ function genCodeNode(schema, v, lines, ctx, knownType) {
   }
 
   // propertyNames — only emit if not already merged into patternProperties loop
-  if (schema.propertyNames && typeof schema.propertyNames === 'object' && !ppHandledPropertyNames) {
-    const pn = schema.propertyNames
-    const ki = ctx.varCounter++
-    const guard = isObj ? '' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v}))`
-    lines.push(`${guard}{for(const _k${ki} in ${v}){`)
-    if (pn.minLength !== undefined) lines.push(`if(_k${ki}.length<${pn.minLength})return false`)
-    if (pn.maxLength !== undefined) lines.push(`if(_k${ki}.length>${pn.maxLength})return false`)
-    if (pn.pattern) {
-      const fast = fastPrefixCheck(pn.pattern, `_k${ki}`)
-      if (fast) {
-        lines.push(`if(!(${fast}))return false`)
-      } else {
-        const ri = ctx.varCounter++
-        ctx.closureVars.push(`_re${ri}`)
-        ctx.closureVals.push(safeReClosure(ctx, pn.pattern))
-        lines.push(`if(!_re${ri}.test(_k${ki}))return false`)
-      }
-    }
-    if (pn.const !== undefined) lines.push(`if(_k${ki}!==${JSON.stringify(pn.const)})return false`)
-    if (pn.enum) {
-      const ei = ctx.varCounter++
-      ctx.closureVars.push(`_es${ei}`)
-      ctx.closureVals.push(new Set(pn.enum))
-      lines.push(`if(!_es${ei}.has(_k${ki}))return false`)
-    }
-    lines.push(`}}`)
-  }
+  if (schema.propertyNames && typeof schema.propertyNames === 'object' && !ppHandledPropertyNames) genPropertyNamesNode(schema, v, lines, ctx, knownType, isObj)
 
   // properties — use hoisted vars for required props, hoist optional to locals too
   if (schema.properties) {
@@ -2721,7 +2423,7 @@ function genCodeNode(schema, v, lines, ctx, knownType) {
         const combined = tryGenCombined(prop, access, ctx)
         if (combined) {
           lines.push(combined)
-        } else if (needsLocal(prop)) {
+        } else if (needsLocal(prop) || isPlainContainer(prop)) {
           const oi = ctx.varCounter++
           const local = `_r${oi}`
           lines.push(`{const ${local}=${access}`)
@@ -2765,35 +2467,10 @@ function genCodeNode(schema, v, lines, ctx, knownType) {
   }
 
   // prefixItems
-  if (schema.prefixItems) {
-    const pfxVar = ctx.varCounter++
-    for (let i = 0; i < schema.prefixItems.length; i++) {
-      const elem = `_p${pfxVar}_${i}`
-      lines.push(isArr
-        ? `if(${v}.length>${i}){const ${elem}=${v}[${i}]`
-        : `if(Array.isArray(${v})&&${v}.length>${i}){const ${elem}=${v}[${i}]`)
-      genCode(schema.prefixItems[i], elem, lines, ctx)
-      lines.push(`}`)
-    }
-  }
+  if (schema.prefixItems) genPrefixItemsNode(schema, v, lines, ctx, knownType, isArr)
 
   // contains — use helper function to avoid try/catch overhead
-  if (schema.contains !== undefined) {
-    const ci = ctx.varCounter++
-    const minC = schema.minContains !== undefined ? schema.minContains : 1
-    const maxC = schema.maxContains !== undefined ? schema.maxContains : Infinity
-    const subLines = []
-    genCode(schema.contains, `_cv`, subLines, ctx)
-    const fnBody = subLines.length === 0 ? `return true` : `${subLines.join(';')};return true`
-    const guard = isArr ? '' : `if(!Array.isArray(${v})){}else `
-    lines.push(`${guard}{const _cf${ci}=function(_cv){${fnBody}};let _cc${ci}=0`)
-    lines.push(`for(let _ci${ci}=0;_ci${ci}<${v}.length;_ci${ci}++){if(_cf${ci}(${v}[_ci${ci}]))_cc${ci}++}`)
-    if (maxC === Infinity) {
-      lines.push(`if(_cc${ci}<${minC})return false}`)
-    } else {
-      lines.push(`if(_cc${ci}<${minC}||_cc${ci}>${maxC})return false}`)
-    }
-  }
+  if (schema.contains !== undefined) genContainsNode(schema, v, lines, ctx, knownType, isArr)
 
   // allOf — pass known type through
   if (schema.allOf) {
@@ -2804,445 +2481,887 @@ function genCodeNode(schema, v, lines, ctx, knownType) {
 
   // anyOf — branch fns hoisted when safe, inline fallback when recursive.
   // Skip standard anyOf if unevaluatedProperties will handle it (single-pass optimization)
-  if (schema.anyOf && schema.unevaluatedProperties === undefined) {
-    const fi = ctx.varCounter++
-    const branchBodies = []
-    let canHoist = !!ctx.preamble
-    for (let i = 0; i < schema.anyOf.length; i++) {
-      const subLines = []
-      genCode(schema.anyOf[i], '_av', subLines, ctx)
-      const body = subLines.length === 0 ? 'return true' : `${subLines.join(';')};return true`
-      if (/\b_validate\b/.test(body)) canHoist = false
-      branchBodies.push(body)
-    }
-    if (canHoist) {
-      const names = branchBodies.map((body, i) => {
-        const name = `_af${fi}_b${i}`
-        ctx.preamble.push(`function ${name}(_av){${body}}`)
-        return name
-      })
-      const checks = names.map(n => `${n}(${v})`).join('||')
-      lines.push(`if(!(${checks}))return false`)
-    } else {
-      const fns = branchBodies.map(body => `function(_av){${body}}`)
-      lines.push(`{const _af${fi}=[${fns.join(',')}];let _am${fi}=false;for(let _ai=0;_ai<_af${fi}.length;_ai++){if(_af${fi}[_ai](${v})){_am${fi}=true;break}}if(!_am${fi})return false}`)
-    }
-  }
+  if (schema.anyOf && schema.unevaluatedProperties === undefined) genAnyOfNode(schema, v, lines, ctx, knownType)
 
   // oneOf — branch fns hoisted to factory scope when safe (no recursion/ref).
   // Falls back to inline closures if any branch touches recursive validation.
-  if (schema.oneOf) {
-    const fi = ctx.varCounter++
-    const branchBodies = []
-    let canHoist = !!ctx.preamble
-    for (let i = 0; i < schema.oneOf.length; i++) {
-      const subLines = []
-      genCode(schema.oneOf[i], '_ov', subLines, ctx)
-      const body = subLines.length === 0 ? 'return true' : `${subLines.join(';')};return true`
-      // _validate is the recursive entry — hoisting branches above it breaks scope.
-      if (/\b_validate\b/.test(body)) canHoist = false
-      branchBodies.push(body)
-    }
-    if (canHoist) {
-      const names = branchBodies.map((body, i) => {
-        const name = `_of${fi}_b${i}`
-        ctx.preamble.push(`function ${name}(_ov){${body}}`)
-        return name
-      })
-      const calls = names.map(n => `if(${n}(${v})){_oc${fi}++;if(_oc${fi}>1)return false}`).join(';')
-      lines.push(`{let _oc${fi}=0;${calls};if(_oc${fi}!==1)return false}`)
+  if (schema.oneOf) genOneOfNode(schema, v, lines, ctx, knownType)
+
+  // not
+  if (schema.not !== undefined) genNotNode(schema, v, lines, ctx, knownType)
+
+  // if/then/else
+  if (schema.if !== undefined) genIfNode(schema, v, lines, ctx, knownType)
+
+  // unevaluatedProperties
+  if (schema.unevaluatedProperties !== undefined) genUnevaluatedPropertiesNode(schema, v, lines, ctx, knownType, isObj, hoisted, earlyKeyCount)
+
+  // unevaluatedItems
+  if (schema.unevaluatedItems !== undefined) genUnevaluatedItemsNode(schema, v, lines, ctx, knownType, isArr)
+}
+
+// The rarely used keyword families live outside genCodeNode, so a schema that
+// never uses them does not pay V8 to compile them on its first check. Each is
+// called with the locals it reads; genRefNode returns true when the node is done.
+
+function genDynamicRefNode(schema, v, lines, ctx, knownType) {
+  const anchorKey = schema.$dynamicRef.startsWith('#') ? schema.$dynamicRef : '#' + schema.$dynamicRef
+  if (ctx.anchors && ctx.anchors[anchorKey]) {
+    const target = ctx.anchors[anchorKey]
+    if (target === ctx.rootSchema) {
+      // Self-recursive: generate _validate(v) call
+      if (ctx.nestedBoolean) throw DECLINE
+      ctx.usesRecursion = true
+      lines.push(`if(!_validate(${v}))return false`)
     } else {
-      const fns = branchBodies.map(body => `function(_ov){${body}}`)
-      lines.push(`{const _of${fi}=[${fns.join(',')}];let _oc${fi}=0;for(let _oi=0;_oi<_of${fi}.length;_oi++){if(_of${fi}[_oi](${v}))_oc${fi}++;if(_oc${fi}>1)return false}if(_oc${fi}!==1)return false}`)
+      // Different schema: inline the target validation
+      const refKey = '$dynamicRef:' + anchorKey
+      if (ctx.refStack.has(refKey) && ctx.nestedBoolean) throw DECLINE
+      if (!ctx.refStack.has(refKey)) {
+        ctx.refStack.add(refKey)
+        genCode(target, v, lines, ctx, knownType)
+        ctx.refStack.delete(refKey)
+      }
     }
   }
+}
 
-  // not
-  if (schema.not !== undefined) {
-    const subLines = []
-    genCode(schema.not, '_nv', subLines, ctx)
-    if (subLines.length === 0) {
-      lines.push(`return false`) // not:{} means nothing is valid
+function genUniqueItemsNode(schema, v, lines, ctx, knownType, hoisted, isArr, types) {
+  const si = ctx.varCounter++
+  const itemType = schema.items && typeof schema.items === 'object' && schema.items.type
+  const isPrimItems = itemType === 'string' || itemType === 'number' || itemType === 'integer'
+  const maxItems = schema.maxItems
+  // Small primitive arrays (maxItems <= 16): nested loop is 6x faster than Set
+  // No allocation, no hash computation — just direct === comparison
+  let inner
+  if (isPrimItems && maxItems && maxItems <= 16) {
+    inner = `for(let _i=1;_i<${v}.length;_i++){for(let _k=0;_k<_i;_k++){if(${v}[_i]===${v}[_k])return false}}`
+  } else if (isPrimItems) {
+    inner = `const _s${si}=new Set();for(let _i=0;_i<${v}.length;_i++){if(_s${si}.has(${v}[_i]))return false;_s${si}.add(${v}[_i])}`
+  } else if (ctx.preamble) {
+    // Unknown item types: one hoisted helper per compiled function. Short
+    // arrays compare pairwise with a structural equality that ignores key
+    // order and allocates nothing; longer ones fall back to a Set of
+    // primitives, or to sorted-key canonical strings once an object shows
+    // up. The previous form built the canonical closure and a Set on
+    // every call, even for [1, 2, 3].
+    inner = `if(!${emitUq(ctx)}(${v}))return false`
+  } else {
+    inner = `const _cn${si}=function(x){if(x===null||typeof x!=='object')return typeof x+':'+x;if(Array.isArray(x))return'['+x.map(_cn${si}).join(',')+']';return'{'+Object.keys(x).sort().map(function(k){return JSON.stringify(k)+':'+_cn${si}(x[k])}).join(',')+'}'};const _s${si}=new Set();for(let _i=0;_i<${v}.length;_i++){const _k=_cn${si}(${v}[_i]);if(_s${si}.has(_k))return false;_s${si}.add(_k)}`
+  }
+  lines.push(isArr ? `{${inner}}` : `if(Array.isArray(${v})){${inner}}`)
+}
+
+function genAdditionalSchemaNode(schema, v, lines, ctx, knownType, isObj) {
+  // The loop variables carry a unique suffix: a record whose values are
+  // themselves records nests this loop inside itself, and a fixed `_av`
+  // made the inner `const _av=_av[_k]` a self-reference that threw at
+  // validation time.
+  const apId = ctx._apLoopId = (ctx._apLoopId || 0) + 1
+  const kVar = `_k${apId}`
+  const avVar = `_av${apId}`
+  const declared = schema.properties ? Object.keys(schema.properties) : []
+  const skipCheck = declared.length === 0
+    ? null
+    : declared.map(k => `${kVar}===${JSON.stringify(k)}`).join('||')
+  const subLines = []
+  genCode(schema.additionalProperties, avVar, subLines, ctx)
+  if (subLines.length > 0) {
+    const body = subLines.join(';')
+    const loop = skipCheck
+      ? `for(var ${kVar} in ${v}){if(${skipCheck})continue;const ${avVar}=${v}[${kVar}];${body}}`
+      : `for(var ${kVar} in ${v}){const ${avVar}=${v}[${kVar}];${body}}`
+    _deferOrInline(ctx, lines, v, isObj ? loop : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${loop}}`)
+  }
+}
+
+function genDependentSchemasNode(schema, v, lines, ctx, knownType, effectiveType, isObj) {
+  for (const [key, depSchema] of Object.entries(schema.dependentSchemas)) {
+    const guard = isObj ? '' : `typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&`
+    lines.push(`if(${guard}${ownKeyExpr(ctx, v, key)}){`)
+    ctx.condDepth = (ctx.condDepth || 0) + 1
+    genCode(depSchema, v, lines, ctx, effectiveType)
+    ctx.condDepth--
+    lines.push(`}`)
+  }
+}
+
+function genPropertyNamesNode(schema, v, lines, ctx, knownType, isObj) {
+  const pn = schema.propertyNames
+  const ki = ctx.varCounter++
+  const guard = isObj ? '' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v}))`
+  lines.push(`${guard}{for(const _k${ki} in ${v}){`)
+  if (pn.minLength !== undefined) lines.push(`if(_k${ki}.length<${pn.minLength})return false`)
+  if (pn.maxLength !== undefined) lines.push(`if(_k${ki}.length>${pn.maxLength})return false`)
+  if (pn.pattern) {
+    const fast = fastPrefixCheck(pn.pattern, `_k${ki}`)
+    if (fast) {
+      lines.push(`if(!(${fast}))return false`)
     } else {
-      const fi = ctx.varCounter++
-      lines.push(`{const _nf${fi}=(function(_nv){${subLines.join(';')};return true});if(_nf${fi}(${v}))return false}`)
+      const ri = ctx.varCounter++
+      ctx.closureVars.push(`_re${ri}`)
+      ctx.closureVals.push(safeReClosure(ctx, pn.pattern))
+      lines.push(`if(!_re${ri}.test(_k${ki}))return false`)
     }
   }
+  if (pn.const !== undefined) lines.push(`if(_k${ki}!==${JSON.stringify(pn.const)})return false`)
+  if (pn.enum) {
+    const ei = ctx.varCounter++
+    ctx.closureVars.push(`_es${ei}`)
+    ctx.closureVals.push(new Set(pn.enum))
+    lines.push(`if(!_es${ei}.has(_k${ki}))return false`)
+  }
+  lines.push(`}}`)
+}
 
-  // if/then/else
-  if (schema.if !== undefined) {
-    const ifLines = []
-    genCode(schema.if, '_iv', ifLines, ctx)
+function genPrefixItemsNode(schema, v, lines, ctx, knownType, isArr) {
+  const pfxVar = ctx.varCounter++
+  for (let i = 0; i < schema.prefixItems.length; i++) {
+    const elem = `_p${pfxVar}_${i}`
+    lines.push(isArr
+      ? `if(${v}.length>${i}){const ${elem}=${v}[${i}]`
+      : `if(Array.isArray(${v})&&${v}.length>${i}){const ${elem}=${v}[${i}]`)
+    genCode(schema.prefixItems[i], elem, lines, ctx)
+    lines.push(`}`)
+  }
+}
+
+function genContainsNode(schema, v, lines, ctx, knownType, isArr) {
+  const ci = ctx.varCounter++
+  const minC = schema.minContains !== undefined ? schema.minContains : 1
+  const maxC = schema.maxContains !== undefined ? schema.maxContains : Infinity
+  const subLines = []
+  genCode(schema.contains, `_cv`, subLines, ctx)
+  const fnBody = subLines.length === 0 ? `return true` : `${subLines.join(';')};return true`
+  const guard = isArr ? '' : `if(!Array.isArray(${v})){}else `
+  lines.push(`${guard}{const _cf${ci}=function(_cv){${fnBody}};let _cc${ci}=0`)
+  lines.push(`for(let _ci${ci}=0;_ci${ci}<${v}.length;_ci${ci}++){if(_cf${ci}(${v}[_ci${ci}]))_cc${ci}++}`)
+  if (maxC === Infinity) {
+    lines.push(`if(_cc${ci}<${minC})return false}`)
+  } else {
+    lines.push(`if(_cc${ci}<${minC}||_cc${ci}>${maxC})return false}`)
+  }
+}
+
+function genAnyOfNode(schema, v, lines, ctx, knownType) {
+  const fi = ctx.varCounter++
+  const branchBodies = []
+  let canHoist = !!ctx.preamble
+  for (let i = 0; i < schema.anyOf.length; i++) {
+    const subLines = []
+    genCode(schema.anyOf[i], '_av', subLines, ctx)
+    const body = subLines.length === 0 ? 'return true' : `${subLines.join(';')};return true`
+    if (/\b_validate\b/.test(body)) canHoist = false
+    branchBodies.push(body)
+  }
+  if (canHoist) {
+    const names = branchBodies.map((body, i) => {
+      const name = `_af${fi}_b${i}`
+      ctx.preamble.push(`function ${name}(_av){${body}}`)
+      return name
+    })
+    const checks = names.map(n => `${n}(${v})`).join('||')
+    lines.push(`if(!(${checks}))return false`)
+  } else {
+    const fns = branchBodies.map(body => `function(_av){${body}}`)
+    lines.push(`{const _af${fi}=[${fns.join(',')}];let _am${fi}=false;for(let _ai=0;_ai<_af${fi}.length;_ai++){if(_af${fi}[_ai](${v})){_am${fi}=true;break}}if(!_am${fi})return false}`)
+  }
+}
+
+function genOneOfNode(schema, v, lines, ctx, knownType) {
+  const fi = ctx.varCounter++
+  const branchBodies = []
+  let canHoist = !!ctx.preamble
+  for (let i = 0; i < schema.oneOf.length; i++) {
+    const subLines = []
+    genCode(schema.oneOf[i], '_ov', subLines, ctx)
+    const body = subLines.length === 0 ? 'return true' : `${subLines.join(';')};return true`
+    // _validate is the recursive entry — hoisting branches above it breaks scope.
+    if (/\b_validate\b/.test(body)) canHoist = false
+    branchBodies.push(body)
+  }
+  if (canHoist) {
+    const names = branchBodies.map((body, i) => {
+      const name = `_of${fi}_b${i}`
+      ctx.preamble.push(`function ${name}(_ov){${body}}`)
+      return name
+    })
+    const calls = names.map(n => `if(${n}(${v})){_oc${fi}++;if(_oc${fi}>1)return false}`).join(';')
+    lines.push(`{let _oc${fi}=0;${calls};if(_oc${fi}!==1)return false}`)
+  } else {
+    const fns = branchBodies.map(body => `function(_ov){${body}}`)
+    lines.push(`{const _of${fi}=[${fns.join(',')}];let _oc${fi}=0;for(let _oi=0;_oi<_of${fi}.length;_oi++){if(_of${fi}[_oi](${v}))_oc${fi}++;if(_oc${fi}>1)return false}if(_oc${fi}!==1)return false}`)
+  }
+}
+
+function genNotNode(schema, v, lines, ctx, knownType) {
+  const subLines = []
+  genCode(schema.not, '_nv', subLines, ctx)
+  if (subLines.length === 0) {
+    lines.push(`return false`) // not:{} means nothing is valid
+  } else {
     const fi = ctx.varCounter++
-    const ifFn = ifLines.length === 0
-      ? `function(_iv){return true}`
-      : `function(_iv){${ifLines.join(';')};return true}`
+    lines.push(`{const _nf${fi}=(function(_nv){${subLines.join(';')};return true});if(_nf${fi}(${v}))return false}`)
+  }
+}
+
+function genIfNode(schema, v, lines, ctx, knownType) {
+  const ifLines = []
+  genCode(schema.if, '_iv', ifLines, ctx)
+  const fi = ctx.varCounter++
+  const ifFn = ifLines.length === 0
+    ? `function(_iv){return true}`
+    : `function(_iv){${ifLines.join(';')};return true}`
+
+  let thenFn = 'null', elseFn = 'null'
+  if (schema.then !== undefined) {
+    const thenLines = []
+    genCode(schema.then, '_tv', thenLines, ctx)
+    thenFn = thenLines.length === 0
+      ? `function(_tv){return true}`
+      : `function(_tv){${thenLines.join(';')};return true}`
+  }
+  if (schema.else !== undefined) {
+    const elseLines = []
+    genCode(schema.else, '_ev', elseLines, ctx)
+    elseFn = elseLines.length === 0
+      ? `function(_ev){return true}`
+      : `function(_ev){${elseLines.join(';')};return true}`
+  }
+  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}}`)
+}
 
-    let thenFn = 'null', elseFn = 'null'
-    if (schema.then !== undefined) {
-      const thenLines = []
-      genCode(schema.then, '_tv', thenLines, ctx)
-      thenFn = thenLines.length === 0
-        ? `function(_tv){return true}`
-        : `function(_tv){${thenLines.join(';')};return true}`
+function genRefNode(schema, v, lines, ctx, knownType, hasSiblings) {
+  // Self-reference "#" — recursive call to root validator
+  if (schema.$ref === '#') {
+    if (ctx.nestedBoolean) throw DECLINE
+    ctx.usesRecursion = true
+    lines.push(`if(!_validate(${v}))return false`)
+    if (!hasSiblings) return true
+  }
+  // 1. Local ref
+  const m = schema.$ref !== '#' && schema.$ref.match(/^#\/(?:\$defs|definitions)\/(.+)$/)
+  if (m && ctx.rootDefs && ctx.rootDefs[m[1]]) {
+    const defName = m[1]
+    if (!ctx.cyclicDefs) ctx.cyclicDefs = cyclicDefNames(ctx.rootDefs)
+    if (ctx.cyclicDefs.has(defName) && ctx.preamble) {
+      // A def on a cycle is a named function in the preamble, emitted once
+      // and called by name, so recursion terminates the way `$ref: "#"`
+      // does at the root. The name is registered before the body is
+      // generated so a self-reference inside it becomes a call.
+      if (!ctx.defFns) ctx.defFns = new Map()
+      let fnName = ctx.defFns.get(defName)
+      if (!fnName) {
+        fnName = '_def' + ctx.defFns.size + '_' + defName.replace(/[^A-Za-z0-9_]/g, '_')
+        ctx.defFns.set(defName, fnName)
+        const bodyLines = []
+        // The def is compiled as its own function over its own `d`, so the
+        // checks _deferOrInline holds back belong at the end of this body.
+        // The list hangs off ctx, so without the swap they are flushed into
+        // whatever function is compiling, carrying this def's key set.
+        const outerDeferred = ctx.deferredChecks
+        ctx.deferredChecks = null
+        genCode(ctx.rootDefs[defName], 'd', bodyLines, ctx)
+        if (ctx.deferredChecks) for (const dc of ctx.deferredChecks) bodyLines.push(dc)
+        ctx.deferredChecks = outerDeferred
+        // Entered through the cycle guard: see emitGuardState. In the fast
+        // pass the wrapper only counts depth; the set is used by the second,
+        // guarded pass that runs when data turns out to point back at
+        // itself.
+        ctx.preamble.push(
+          `const ${fnName}_s=new Set()\n  function ${fnName}(d){\n  ` +
+            `if(_sg){if(typeof d!=='object'||d===null)return ${fnName}_b(d);if(${fnName}_s.has(d))return true;${fnName}_s.add(d);try{return ${fnName}_b(d)}finally{${fnName}_s.delete(d)}}\n  ` +
+            `if(++_sd>${CYCLE_DEPTH})throw _CYC\n  const _r=${fnName}_b(d)\n  _sd--\n  return _r\n  }\n  ` +
+            `function ${fnName}_b(d){${bodyLines.join('\n  ')}\n  return true}`,
+        )
+      }
+      lines.push(`if(!${fnName}(${v}))return false`)
+      if (!hasSiblings) return true
+    } else if (ctx.refStack.has(schema.$ref)) { if (ctx.nestedBoolean) throw DECLINE; if (!hasSiblings) return true }
+    else {
+      ctx.refStack.add(schema.$ref)
+      genCode(ctx.rootDefs[defName], v, lines, ctx, knownType)
+      ctx.refStack.delete(schema.$ref)
+      if (!hasSiblings) return true
+    }
+  } else if (schema.$ref !== '#' && !m && schema.$ref.startsWith('#') && !schema.$ref.startsWith('#/')) {
+    // Anchor ref: "#foo" — resolve via rootDefs or anchors map
+    const entry = ctx.rootDefs && ctx.rootDefs[schema.$ref]
+    const anchorTarget = entry && entry.raw ? entry.raw : (ctx.anchors && ctx.anchors[schema.$ref])
+    if (anchorTarget) {
+      if (ctx.refStack.has(schema.$ref)) { if (ctx.nestedBoolean) throw DECLINE; if (!hasSiblings) return true }
+      else {
+        ctx.refStack.add(schema.$ref)
+        genCode(anchorTarget, v, lines, ctx, knownType)
+        ctx.refStack.delete(schema.$ref)
+        if (!hasSiblings) return true
+      }
     }
-    if (schema.else !== undefined) {
-      const elseLines = []
-      genCode(schema.else, '_ev', elseLines, ctx)
-      elseFn = elseLines.length === 0
-        ? `function(_ev){return true}`
-        : `function(_ev){${elseLines.join(';')};return true}`
+  } else if (schema.$ref !== '#' && ctx.schemaMap) {
+    // 2. Cross-schema ref (exact match, relative URI, or JSON pointer fragment)
+    let resolved = ctx.schemaMap.get(schema.$ref)
+    if (!resolved && !schema.$ref.includes('://') && !schema.$ref.startsWith('#')) {
+      for (const [id, s] of ctx.schemaMap) {
+        if (id.endsWith('/' + schema.$ref)) { resolved = s; break }
+      }
     }
-    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}}`)
+    if (!resolved && schema.$ref.includes('#') && !schema.$ref.startsWith('#')) {
+      const r = resolveCrossSchemaRef(schema.$ref, ctx.schemaMap)
+      if (r) resolved = r.schema
+    }
+    if (resolved) {
+      if (ctx.refStack.has(schema.$ref)) { if (!hasSiblings) return true }
+      else {
+        ctx.refStack.add(schema.$ref)
+        genCode(resolved, v, lines, ctx, knownType)
+        ctx.refStack.delete(schema.$ref)
+        if (!hasSiblings) return true
+      }
+    } else {
+      if (!hasSiblings) return true
+    }
+  } else {
+    if (!hasSiblings) return true
   }
+  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
+function genPatternPropertiesNode(schema, v, lines, ctx, knownType, isObj) {
+  let handledPropertyNames = false
+  const ppEntries = Object.entries(schema.patternProperties)
+  const pn = schema.propertyNames && typeof schema.propertyNames === 'object' ? schema.propertyNames : null
+  const pi = ctx.varCounter++
+  const kVar = `_ppk${pi}`
+
+  // Build pattern matchers: prefer charCodeAt for simple prefixes, fall back to regex
+  const matchers = []
+  for (const [pat] of ppEntries) {
+    const fast = fastPrefixCheck(pat, kVar)
+    if (fast) {
+      matchers.push({ check: fast })
+    } else {
+      const ri = ctx.varCounter++
+      ctx.closureVars.push(`_re${ri}`)
+      ctx.closureVals.push(safeReClosure(ctx, pat))
+      matchers.push({ check: `_re${ri}.test(${kVar})` })
+    }
+  }
 
-      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 (!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`
-                        _deferOrInline(ctx, lines, v, 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. Above the lookup threshold it is
-          // the additionalProperties quadratic wearing a disguise: keys that
-          // share a first character, ENV_0 through ENV_999 say, all land in
-          // one case whose body is a chain of every name, per key of the
-          // document. The hoisted name lookup is the same cure it was there.
-          inner = propCount >= AP_LOOKUP_MIN
-            ? apMembershipCheck(ctx, knownKeys, v)
-            : genCharCodeSwitch(knownKeys, v)
-                    _deferOrInline(ctx, lines, v, isObj ? inner : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}`)
+  // Build sub-schema checks inline so they share the parent helper scope.
+  const subChecks = []
+  for (let i = 0; i < ppEntries.length; i++) {
+    const [, sub] = ppEntries[i]
+    const subLines = []
+    genCode(sub, `_ppv${pi}`, subLines, ctx)
+    subChecks.push(subLines.join(';'))
+  }
+
+  const guard = isObj ? '' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v}))`
+
+  const apSchema = typeof schema.additionalProperties === 'object' && schema.additionalProperties !== null ? schema.additionalProperties : null
+  if ((schema.additionalProperties === false && schema.properties) || apSchema) {
+    // Unified loop: properties + patterns + propertyNames + additionalProperties.
+    // A key that is neither declared nor matched by any pattern is
+    // additional: rejected outright, or run through the additionalProperties
+    // schema when there is one.
+    handledPropertyNames = !!pn
+    const propKeys = Object.keys(schema.properties || {})
+    let apCheck = null
+    if (apSchema) {
+      const apLines = []
+      genCode(apSchema, `_apv${pi}`, apLines, ctx)
+      apCheck = apLines.join(';')
+    }
+    lines.push(`${guard}{for(const ${kVar} in ${v}){`)
+    // propertyNames checks (merged into same loop)
+    if (pn) {
+      if (pn.minLength !== undefined) lines.push(`if(${kVar}.length<${pn.minLength})return false`)
+      if (pn.maxLength !== undefined) lines.push(`if(${kVar}.length>${pn.maxLength})return false`)
+      if (pn.pattern) {
+        const fast = fastPrefixCheck(pn.pattern, kVar)
+        if (fast) {
+          lines.push(`if(!(${fast}))return false`)
         } else {
-          inner = `for(var _k in ${v})return false`
-                    _deferOrInline(ctx, lines, v, 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(';')
-          let skipKnown = ''
-          if (knownKeys.length >= AP_LOOKUP_MIN) {
-            const id = emitNameLookup(ctx, knownKeys)
-            skipKnown = id !== null ? `if(${id}[${ukVar}]!==undefined)continue;` : `if(${knownKeys.map(k => `${ukVar}===${JSON.stringify(k)}`).join('||')})continue;`
-          } else if (knownKeys.length > 0) {
-            skipKnown = `if(${knownKeys.map(k => `${ukVar}===${JSON.stringify(k)}`).join('||')})continue;`
-          }
-          const inner = `for(var ${ukVar} in ${v}){${skipKnown}${check}}`
-                    _deferOrInline(ctx, lines, v, isObj ? inner : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}`)
+          const ri = ctx.varCounter++
+          ctx.closureVars.push(`_re${ri}`)
+          ctx.closureVals.push(safeReClosure(ctx, pn.pattern))
+          lines.push(`if(!_re${ri}.test(${kVar}))return false`)
         }
       }
+      if (pn.const !== undefined) lines.push(`if(${kVar}!==${JSON.stringify(pn.const)})return false`)
+      if (pn.enum) {
+        const ei = ctx.varCounter++
+        ctx.closureVars.push(`_es${ei}`)
+        ctx.closureVals.push(new Set(pn.enum))
+        lines.push(`if(!_es${ei}.has(${kVar}))return false`)
+      }
+    }
+    // Every matching pattern applies to every key, declared or not: a
+    // declared key that also matches a pattern is validated by both (the
+    // properties emitter handles its own subschema). A flag rather than an
+    // if/else chain, because a chain returned false at the first pattern
+    // that missed and wrongly rejected a key only a later pattern matched.
+    if (ppEntries.length > 0) {
+      lines.push(`let _pm${pi}=false`)
+      for (let i = 0; i < ppEntries.length; i++) {
+        lines.push(`if(${matchers[i].check}){_pm${pi}=true;const _ppv${pi}=${v}[${kVar}];${subChecks[i]}}`)
+      }
+    }
+    // A key that is neither declared nor matched is additional. switch on
+    // the declared names (V8 compiles string cases to a jump table); no
+    // switch at all when nothing is declared, since a switch with no case
+    // clause is a syntax error.
+    const additional = apCheck !== null ? `const _apv${pi}=${v}[${kVar}];${apCheck}` : `return false`
+    const notMatched = ppEntries.length > 0 ? `if(!_pm${pi}){${additional}}` : additional
+    if (propKeys.length) {
+      const switchCases = propKeys.map(k => `case ${JSON.stringify(k)}:`).join('')
+      lines.push(`switch(${kVar}){${switchCases}break;default:{${notMatched}}}`)
     } 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)
+      lines.push(notMatched)
+    }
+    lines.push(`}}`)
+  } else {
+    // No additionalProperties: validate matching keys + propertyNames
+    handledPropertyNames = !!pn
+    lines.push(`${guard}{for(const ${kVar} in ${v}){`)
+    // propertyNames checks (merged)
+    if (pn) {
+      if (pn.minLength !== undefined) lines.push(`if(${kVar}.length<${pn.minLength})return false`)
+      if (pn.maxLength !== undefined) lines.push(`if(${kVar}.length>${pn.maxLength})return false`)
+      if (pn.pattern) {
+        const fast = fastPrefixCheck(pn.pattern, kVar)
+        if (fast) {
+          lines.push(`if(!(${fast}))return false`)
+        } else {
+          const ri = ctx.varCounter++
+          ctx.closureVars.push(`_re${ri}`)
+          ctx.closureVals.push(safeReClosure(ctx, pn.pattern))
+          lines.push(`if(!_re${ri}.test(${kVar}))return false`)
         }
       }
-      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)
-            }
-          }
+      if (pn.const !== undefined) lines.push(`if(${kVar}!==${JSON.stringify(pn.const)})return false`)
+      if (pn.enum) {
+        const ei = ctx.varCounter++
+        ctx.closureVars.push(`_es${ei}`)
+        ctx.closureVals.push(new Set(pn.enum))
+        lines.push(`if(!_es${ei}.has(${kVar}))return false`)
+      }
+    }
+    for (let i = 0; i < ppEntries.length; i++) {
+      lines.push(`if(${matchers[i].check}){const _ppv${pi}=${v}[${kVar}];${subChecks[i]}}`)
+    }
+    lines.push(`}}`)
+  }
+  return handledPropertyNames
+}
+
+function genUnevaluatedPropertiesNode(schema, v, lines, ctx, knownType, isObj, hoisted, earlyKeyCount) {
+  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 (!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`
+                      _deferOrInline(ctx, lines, v, 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. Above the lookup threshold it is
+        // the additionalProperties quadratic wearing a disguise: keys that
+        // share a first character, ENV_0 through ENV_999 say, all land in
+        // one case whose body is a chain of every name, per key of the
+        // document. The hoisted name lookup is the same cure it was there.
+        inner = propCount >= AP_LOOKUP_MIN
+          ? apMembershipCheck(ctx, knownKeys, v)
+          : genCharCodeSwitch(knownKeys, v)
+                  _deferOrInline(ctx, lines, v, isObj ? inner : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}`)
+      } else {
+        inner = `for(var _k in ${v})return false`
+                  _deferOrInline(ctx, lines, v, 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(';')
+        let skipKnown = ''
+        if (knownKeys.length >= AP_LOOKUP_MIN) {
+          const id = emitNameLookup(ctx, knownKeys)
+          skipKnown = id !== null ? `if(${id}[${ukVar}]!==undefined)continue;` : `if(${knownKeys.map(k => `${ukVar}===${JSON.stringify(k)}`).join('||')})continue;`
+        } else if (knownKeys.length > 0) {
+          skipKnown = `if(${knownKeys.map(k => `${ukVar}===${JSON.stringify(k)}`).join('||')})continue;`
         }
+        const inner = `for(var ${ukVar} in ${v}){${skipKnown}${check}}`
+                  _deferOrInline(ctx, lines, v, 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)
       }
-      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 || [])
+    }
+    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 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
-            })
+        }
+      }
+    }
+    const baseProps = baseResult.props
+    const branchKeyword = schema.anyOf ? 'anyOf' : schema.oneOf ? 'oneOf' : null
 
-            // 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`)
-            }
+    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))
 
-            // 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)
+        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))
             }
-            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;`
+            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}`)
             }
-            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}`
-                        _deferOrInline(ctx, lines, v, isObj ? inner + '}' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}}`)
+            lines.push(`if(_oc${bfi}!==1)return false`)
           } else {
-            // Fallback: plain object tracking
-            const ei = ctx.varCounter++
-            const evVar = `_ev${ei}`
-            const fns = []
+            // anyOf: at least one must match — direct calls, collect all
+            lines.push(`let _am${bfi}=false`)
             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}`)
+              lines.push(`if(${fnVars[i]}(${v})){_am${bfi}=true;${evVar}|=${branchMasks[i]}}`)
             }
-            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`)
+            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}`
+                      _deferOrInline(ctx, lines, v, 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}`
+                      _deferOrInline(ctx, lines, v, 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(${ownKeyExpr(ctx, v, trigger)}){${depResult.props.map(k => `${evVar}[${JSON.stringify(k)}]=1`).join(';')}}`)
+          }
+        }
+        const inner = `for(var _k in ${v}){if(!${evVar}[_k])return false}`
+                  _deferOrInline(ctx, lines, v, isObj ? inner + '}' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}}`)
+      } else {
+        // General fallback: collect all patternProperties from root + allOf sub-schemas + if
+        // and use runtime regex matching
+        const allPatterns = []
+        if (schema.patternProperties) {
+          allPatterns.push(...Object.keys(schema.patternProperties))
+        }
+        if (schema.allOf) {
+          for (const sub of schema.allOf) {
+            if (sub && sub.patternProperties) {
+              allPatterns.push(...Object.keys(sub.patternProperties))
             }
-            const inner = `for(var _k in ${v}){if(!${evVar}[_k])return false}`
-                        _deferOrInline(ctx, lines, v, isObj ? inner + '}' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}}`)
           }
-        } else if (schema.dependentSchemas) {
-          // dependentSchemas: conditional merge at runtime
+        }
+        // lone if (no then/else) still contributes annotations when it passes
+        if (schema.if && !schema.then && !schema.else && schema.if.patternProperties) {
+          allPatterns.push(...Object.keys(schema.if.patternProperties))
+        }
+        if (allPatterns.length > 0) {
           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(${ownKeyExpr(ctx, v, trigger)}){${depResult.props.map(k => `${evVar}[${JSON.stringify(k)}]=1`).join(';')}}`)
-            }
-          }
-          const inner = `for(var _k in ${v}){if(!${evVar}[_k])return false}`
-                    _deferOrInline(ctx, lines, v, isObj ? inner + '}' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}}`)
-        } else {
-          // General fallback: collect all patternProperties from root + allOf sub-schemas + if
-          // and use runtime regex matching
-          const allPatterns = []
-          if (schema.patternProperties) {
-            allPatterns.push(...Object.keys(schema.patternProperties))
-          }
-          if (schema.allOf) {
-            for (const sub of schema.allOf) {
-              if (sub && sub.patternProperties) {
-                allPatterns.push(...Object.keys(sub.patternProperties))
-              }
-            }
-          }
-          // lone if (no then/else) still contributes annotations when it passes
-          if (schema.if && !schema.then && !schema.else && schema.if.patternProperties) {
-            allPatterns.push(...Object.keys(schema.if.patternProperties))
+          const reVars = []
+          for (const pat of allPatterns) {
+            const ri = ctx.varCounter++
+            ctx.closureVars.push(`_ure${ri}`)
+            ctx.closureVals.push(safeReClosure(ctx, pat))
+            reVars.push(`_ure${ri}`)
           }
-          if (allPatterns.length > 0) {
-            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 reVars = []
-            for (const pat of allPatterns) {
+          if (schema.if && !schema.then && !schema.else) {
+            // Lone if: run the if check first; if it passes, its patternProperties contribute
+            const ifLines2 = []
+            genCode(schema.if, '_iv2', ifLines2, ctx)
+            const ufi = ctx.varCounter++
+            const ifFn = ifLines2.length === 0
+              ? `function(_iv2){return true}`
+              : `function(_iv2){${ifLines2.join(';')};return true}`
+            // Mark keys matching if's patterns as evaluated only when if passes
+            const ifPatterns = schema.if.patternProperties ? Object.keys(schema.if.patternProperties) : []
+            const ifReVars = []
+            for (const pat of ifPatterns) {
               const ri = ctx.varCounter++
               ctx.closureVars.push(`_ure${ri}`)
               ctx.closureVals.push(safeReClosure(ctx, pat))
-              reVars.push(`_ure${ri}`)
+              ifReVars.push(`_ure${ri}`)
             }
-            if (schema.if && !schema.then && !schema.else) {
-              // Lone if: run the if check first; if it passes, its patternProperties contribute
-              const ifLines2 = []
-              genCode(schema.if, '_iv2', ifLines2, ctx)
-              const ufi = ctx.varCounter++
-              const ifFn = ifLines2.length === 0
-                ? `function(_iv2){return true}`
-                : `function(_iv2){${ifLines2.join(';')};return true}`
-              // Mark keys matching if's patterns as evaluated only when if passes
-              const ifPatterns = schema.if.patternProperties ? Object.keys(schema.if.patternProperties) : []
-              const ifReVars = []
-              for (const pat of ifPatterns) {
+            const rootReVars = []
+            if (schema.patternProperties) {
+              for (const pat of Object.keys(schema.patternProperties)) {
                 const ri = ctx.varCounter++
                 ctx.closureVars.push(`_ure${ri}`)
                 ctx.closureVals.push(safeReClosure(ctx, pat))
-                ifReVars.push(`_ure${ri}`)
+                rootReVars.push(`_ure${ri}`)
               }
-              const rootReVars = []
-              if (schema.patternProperties) {
-                for (const pat of Object.keys(schema.patternProperties)) {
-                  const ri = ctx.varCounter++
-                  ctx.closureVars.push(`_ure${ri}`)
-                  ctx.closureVals.push(safeReClosure(ctx, pat))
-                  rootReVars.push(`_ure${ri}`)
-                }
-              }
-              const rootPatCheck = rootReVars.map(rv => `if(${rv}.test(_k))continue;`).join('')
-              const ifPatCheck = ifReVars.map(rv => `if(${rv}.test(_k))continue;`).join('')
-              const inner = `const _uif${ufi}=${ifFn};if(_uif${ufi}(${v})){for(var _k in ${v}){if(${evVar}[_k])continue;${rootPatCheck}${ifPatCheck}return false}}else{for(var _k in ${v}){if(${evVar}[_k])continue;${rootPatCheck}return false}}`
-                            _deferOrInline(ctx, lines, v, isObj ? inner + '}' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}}`)
-            } else {
-              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}`
-                            _deferOrInline(ctx, lines, v, 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}}`)
+            const rootPatCheck = rootReVars.map(rv => `if(${rv}.test(_k))continue;`).join('')
+            const ifPatCheck = ifReVars.map(rv => `if(${rv}.test(_k))continue;`).join('')
+            const inner = `const _uif${ufi}=${ifFn};if(_uif${ufi}(${v})){for(var _k in ${v}){if(${evVar}[_k])continue;${rootPatCheck}${ifPatCheck}return false}}else{for(var _k in ${v}){if(${evVar}[_k])continue;${rootPatCheck}return false}}`
+                          _deferOrInline(ctx, lines, v, isObj ? inner + '}' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}}`)
           } 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 inner = `for(var _k in ${v}){if(${evVar}[_k])continue;${reVars.map(rv => `if(${rv}.test(_k)){${evVar}[_k]=1;continue}`).join('')}return false}`
+                          _deferOrInline(ctx, lines, v, 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`)
 
-        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}}`
-                    _deferOrInline(ctx, lines, v, isObj ? inner + '}' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}}`)
+      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('}')
+          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}}`
+                  _deferOrInline(ctx, lines, v, 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)
-
-    // Check if allItems from anyOf/oneOf branches with `items` keyword needs dynamic tracking
-    const branchKw = schema.anyOf ? 'anyOf' : schema.oneOf ? 'oneOf' : null
-    const hasConditionalItems = evalResult.allItems && evalResult.dynamic && branchKw &&
-      schema[branchKw].some(sub => sub && typeof sub === 'object' && ((sub.items && typeof sub.items === 'object') || sub.items === true))
-
-    if (schema.unevaluatedItems === true || (evalResult.allItems && !hasConditionalItems)) {
-      // All items evaluated or unevaluatedItems:true — no-op
-    } else if (!evalResult.dynamic) {
-      // Static: all evaluated items known at compile-time
+function genUnevaluatedItemsNode(schema, v, lines, ctx, knownType, isArr) {
+  const evalResult = collectEvaluated(schema, ctx.schemaMap, ctx.rootDefs)
+
+  // Check if allItems from anyOf/oneOf branches with `items` keyword needs dynamic tracking
+  const branchKw = schema.anyOf ? 'anyOf' : schema.oneOf ? 'oneOf' : null
+  const hasConditionalItems = evalResult.allItems && evalResult.dynamic && branchKw &&
+    schema[branchKw].some(sub => sub && typeof sub === 'object' && ((sub.items && typeof sub.items === 'object') || sub.items === true))
+
+  if (schema.unevaluatedItems === true || (evalResult.allItems && !hasConditionalItems)) {
+    // 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`
+              _deferOrInline(ctx, lines, v, 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}}`
+                  _deferOrInline(ctx, lines, v, isArr ? inner : `if(Array.isArray(${v})){${inner}}`)
+      }
+    }
+  } else {
+    // Dynamic: runtime tracking of max evaluated index
+    // Compute baseIdx from unconditional sources only (root prefixItems/items, allOf)
+    let baseIdx = 0
+    if (schema.prefixItems) baseIdx = Math.max(baseIdx, schema.prefixItems.length)
+    if (schema.items && typeof schema.items === 'object') baseIdx = Infinity // items: schema → all evaluated
+    if (schema.allOf) {
+      for (const sub of schema.allOf) {
+        const subR = collectEvaluated(sub, ctx.schemaMap, ctx.rootDefs)
+        if (subR.items !== null) baseIdx = Math.max(baseIdx, subR.items)
+        if (subR.allItems) baseIdx = Infinity
+      }
+    }
+    if (baseIdx === Infinity) baseIdx = 0 // allItems already handled above
+    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 = []
+      const branchAllItems = []
+      for (const sub of branches) {
+        const subR = collectEvaluated(sub, ctx.schemaMap, ctx.rootDefs)
+        branchMaxIdx.push(subR.items || 0)
+        branchAllItems.push(subR.allItems)
+      }
+      // 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) => {
+        if (branchAllItems[i]) return `_bi===${i}?${v}.length`
+        return `_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) {
-        // TRICK 6: Array.length comparison only
-        const maxIdx = evalResult.items || 0
-        const inner = `if(${v}.length>${maxIdx})return false`
-                _deferOrInline(ctx, lines, v, isArr ? inner : `if(Array.isArray(${v})){${inner}}`)
-      } else if (typeof schema.unevaluatedItems === 'object') {
-        const maxIdx = evalResult.items || 0
+        const inner = `if(${v}.length>${evVar})return false`
+                  _deferOrInline(ctx, lines, v, isArr ? inner + '}' : `if(Array.isArray(${v})){${inner}}}`)
+      } else {
         const ui = ctx.varCounter++
         const elemVar = `_ue${ui}`
         const idxVar = `_ui${ui}`
@@ -3250,146 +3369,83 @@ function genCodeNode(schema, v, lines, ctx, knownType) {
         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}}`
-                    _deferOrInline(ctx, lines, v, isArr ? inner : `if(Array.isArray(${v})){${inner}}`)
+          const inner = `for(let ${idxVar}=${evVar};${idxVar}<${v}.length;${idxVar}++){const ${elemVar}=${v}[${idxVar}];${check}}`
+                      _deferOrInline(ctx, lines, v, isArr ? inner + '}' : `if(Array.isArray(${v})){${inner}}}`)
+        } else {
+          lines.push('}')
         }
       }
-    } else {
-      // Dynamic: runtime tracking of max evaluated index
-      // Compute baseIdx from unconditional sources only (root prefixItems/items, allOf)
-      let baseIdx = 0
-      if (schema.prefixItems) baseIdx = Math.max(baseIdx, schema.prefixItems.length)
-      if (schema.items && typeof schema.items === 'object') baseIdx = Infinity // items: schema → all evaluated
+    } else if (schema.if && (schema.unevaluatedItems === false || typeof schema.unevaluatedItems === 'object')) {
+      // if/then/else (or lone if): 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.contains || (schema.allOf && schema.allOf.some(s => s && s.contains))) && (schema.unevaluatedItems === false || typeof schema.unevaluatedItems === 'object')) {
+      // contains + unevaluatedItems: per-item tracking of which items are matched by contains
+      // Collect contains from root and allOf sub-schemas
+      const allContains = []
+      if (schema.contains) allContains.push(schema.contains)
       if (schema.allOf) {
         for (const sub of schema.allOf) {
-          const subR = collectEvaluated(sub, ctx.schemaMap, ctx.rootDefs)
-          if (subR.items !== null) baseIdx = Math.max(baseIdx, subR.items)
-          if (subR.allItems) baseIdx = Infinity
+          if (sub && sub.contains) allContains.push(sub.contains)
         }
       }
-      if (baseIdx === Infinity) baseIdx = 0 // allItems already handled above
-      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 = []
-        const branchAllItems = []
-        for (const sub of branches) {
-          const subR = collectEvaluated(sub, ctx.schemaMap, ctx.rootDefs)
-          branchMaxIdx.push(subR.items || 0)
-          branchAllItems.push(subR.allItems)
-        }
-        // 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) => {
-          if (branchAllItems[i]) return `_bi===${i}?${v}.length`
-          return `_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`
-                    _deferOrInline(ctx, lines, v, 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}}`
-                        _deferOrInline(ctx, lines, v, isArr ? inner + '}' : `if(Array.isArray(${v})){${inner}}}`)
-          } else {
-            lines.push('}')
-          }
-        }
-      } else if (schema.if && (schema.unevaluatedItems === false || typeof schema.unevaluatedItems === 'object')) {
-        // if/then/else (or lone if): 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.contains || (schema.allOf && schema.allOf.some(s => s && s.contains))) && (schema.unevaluatedItems === false || typeof schema.unevaluatedItems === 'object')) {
-        // contains + unevaluatedItems: per-item tracking of which items are matched by contains
-        // Collect contains from root and allOf sub-schemas
-        const allContains = []
-        if (schema.contains) allContains.push(schema.contains)
-        if (schema.allOf) {
-          for (const sub of schema.allOf) {
-            if (sub && sub.contains) allContains.push(sub.contains)
-          }
-        }
-        const ci = ctx.varCounter++
-        const evArr = `_cev${ci}`
-        const containsFns = []
-        for (const c of allContains) {
-          const cLines = []
-          genCode(c, '_cv', cLines, ctx)
-          containsFns.push(cLines.length === 0
-            ? `function(_cv){return true}`
-            : `function(_cv){${cLines.join(';')};return true}`)
-        }
-        const cfnArr = `_cfn${ci}`
-        lines.push(`{const ${cfnArr}=[${containsFns.join(',')}]`)
-        // Mark items evaluated by prefixItems
-        lines.push(`const ${evArr}=[]`)
-        if (baseIdx > 0) {
-          lines.push(`for(let _i=0;_i<${Math.min(baseIdx, 1000)};_i++)${evArr}[_i]=true`)
-        }
-        // Mark items matched by each contains function
-        lines.push(`if(Array.isArray(${v})){for(let _ci=0;_ci<${v}.length;_ci++){for(let _cj=0;_cj<${cfnArr}.length;_cj++){if(${cfnArr}[_cj](${v}[_ci])){${evArr}[_ci]=true;break}}}}`)
-        if (schema.unevaluatedItems === false) {
-          const inner = `if(Array.isArray(${v})){for(let _ci=0;_ci<${v}.length;_ci++){if(!${evArr}[_ci])return false}}`
-                    _deferOrInline(ctx, lines, v, inner + '}')
+      const ci = ctx.varCounter++
+      const evArr = `_cev${ci}`
+      const containsFns = []
+      for (const c of allContains) {
+        const cLines = []
+        genCode(c, '_cv', cLines, ctx)
+        containsFns.push(cLines.length === 0
+          ? `function(_cv){return true}`
+          : `function(_cv){${cLines.join(';')};return true}`)
+      }
+      const cfnArr = `_cfn${ci}`
+      lines.push(`{const ${cfnArr}=[${containsFns.join(',')}]`)
+      // Mark items evaluated by prefixItems
+      lines.push(`const ${evArr}=[]`)
+      if (baseIdx > 0) {
+        lines.push(`for(let _i=0;_i<${Math.min(baseIdx, 1000)};_i++)${evArr}[_i]=true`)
+      }
+      // Mark items matched by each contains function
+      lines.push(`if(Array.isArray(${v})){for(let _ci=0;_ci<${v}.length;_ci++){for(let _cj=0;_cj<${cfnArr}.length;_cj++){if(${cfnArr}[_cj](${v}[_ci])){${evArr}[_ci]=true;break}}}}`)
+      if (schema.unevaluatedItems === false) {
+        const inner = `if(Array.isArray(${v})){for(let _ci=0;_ci<${v}.length;_ci++){if(!${evArr}[_ci])return false}}`
+                  _deferOrInline(ctx, lines, v, inner + '}')
+      } else {
+        // unevaluatedItems: {schema}
+        const ui = ctx.varCounter++
+        const elemVar = `_ue${ui}`
+        const subLines = []
+        genCode(schema.unevaluatedItems, elemVar, subLines, ctx)
+        if (subLines.length > 0) {
+          const check = subLines.join(';')
+          const inner = `if(Array.isArray(${v})){for(let _ci=0;_ci<${v}.length;_ci++){if(!${evArr}[_ci]){const ${elemVar}=${v}[_ci];${check}}}}`
+                      _deferOrInline(ctx, lines, v, inner + '}')
         } else {
-          // unevaluatedItems: {schema}
-          const ui = ctx.varCounter++
-          const elemVar = `_ue${ui}`
-          const subLines = []
-          genCode(schema.unevaluatedItems, elemVar, subLines, ctx)
-          if (subLines.length > 0) {
-            const check = subLines.join(';')
-            const inner = `if(Array.isArray(${v})){for(let _ci=0;_ci<${v}.length;_ci++){if(!${evArr}[_ci]){const ${elemVar}=${v}[_ci];${check}}}}`
-                        _deferOrInline(ctx, lines, v, inner + '}')
-          } else {
-            lines.push('}')
-          }
+          lines.push('}')
         }
-      } 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`
-                _deferOrInline(ctx, lines, v, isArr ? inner : `if(Array.isArray(${v})){${inner}}`)
       }
+    } 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`
+              _deferOrInline(ctx, lines, v, isArr ? inner : `if(Array.isArray(${v})){${inner}}`)
     }
   }
 }
@@ -3509,7 +3565,75 @@ function compilePatternInline(pattern, varName) {
     const min = parseInt(m[2]), max = parseInt(m[3])
     return `${varName}.length>=${min}&&${varName}.length<=${max}&&(()=>{for(let _pi=0;_pi<${varName}.length;_pi++){if(!(${rangeCheck}))return false}return true})()`
   }
-  return null
+  return fixedSequenceInline(pattern, varName)
+}
+
+// A pattern that matches exactly one fixed-length sequence of single
+// characters, such as `^[A-Z]{3}-\d{4}$` for a SKU or `^\d{3}-\d{4}$` for a
+// code, unrolled into one character test per position. Each piece is a class
+// of letters, digits, `_` and `-`, a `\d`, or a literal character, repeated a
+// fixed number of times; anything else, including every variable-length
+// quantifier and any negated or escaped class, returns null and keeps the
+// regular path. Each piece matches exactly one UTF-16 unit in the ASCII range,
+// so comparing the length and each code unit is the same test the regex
+// makes. Such patterns went through the safe-regex matcher, which is
+// linear but slower than both this and the native engine: a quarter of the
+// time of an order body with one SKU per line item.
+const FIXED_LITERAL = /[A-Za-z0-9 _\-:@#%&=,;'"<>!~`\/]/
+function fixedSequenceInline(pattern, varName) {
+  if (pattern.length < 3 || pattern[0] !== '^' || pattern[pattern.length - 1] !== '$' || pattern[pattern.length - 2] === '\\') return null
+  const end = pattern.length - 1
+  const pieces = []
+  let i = 1
+  while (i < end) {
+    let piece
+    const c = pattern[i]
+    if (c === '[') {
+      const j = pattern.indexOf(']', i)
+      if (j < 0 || j >= end) return null
+      const cls = pattern.slice(i, j + 1)
+      if (!/^\[[\w-]+\]$/.test(cls)) return null
+      piece = { cls }
+      i = j + 1
+    } else if (c === '\\') {
+      const e = pattern[i + 1]
+      if (e === 'd') piece = { cls: '[0-9]' }
+      // Only the escapes that stay valid under the u flag: an escaped `-`
+      // outside a class is a syntax error there, and the regex path is the
+      // one that decides what to do about it.
+      else if (e !== undefined && './()[]{}+*?^$|\\'.includes(e)) piece = { lit: e }
+      else return null
+      i += 2
+    } else if (FIXED_LITERAL.test(c)) {
+      piece = { lit: c }
+      i += 1
+    } else {
+      return null
+    }
+    let count = 1
+    if (pattern[i] === '{') {
+      const q = /^\{(\d+)\}/.exec(pattern.slice(i))
+      if (!q) return null
+      count = Number(q[1])
+      i += q[0].length
+    } else if (i < end && '*+?'.includes(pattern[i])) {
+      return null
+    }
+    for (let k = 0; k < count; k++) pieces.push(piece)
+    if (pieces.length > 32) return null
+  }
+  if (pieces.length === 0) return null
+  const checks = []
+  for (let k = 0; k < pieces.length; k++) {
+    const at = `${varName}.charCodeAt(${k})`
+    if (pieces[k].lit !== undefined) checks.push(`${at}===${pieces[k].lit.charCodeAt(0)}`)
+    else {
+      const ck = charClassToCheck(pieces[k].cls, at)
+      if (!ck) return null
+      checks.push(`(${ck})`)
+    }
+  }
+  return `${varName}.length===${pieces.length}&&${checks.join('&&')}`
 }
 
 // Convert [charclass] to charCode range check expression.
@@ -3534,7 +3658,10 @@ function charClassToCheck(charClass, codeExpr) {
   const checks = ranges.map(([lo, hi]) =>
     lo === hi ? `${codeExpr}===${lo}` : `(${codeExpr}>=${lo}&&${codeExpr}<=${hi})`
   )
-  return checks.join('||')
+  // Parenthesised as a whole: the unrolled form joins one of these per
+  // position with &&, and a bare a||b there bound as (len&&a)||(b&&...), so
+  // ^[A-Za-z]{2}$ accepted "xyz" and "1a" from 0.12.1 on.
+  return `(${checks.join('||')})`
 }
 
 // Same but for dynamic segments (array indices)
@@ -3993,24 +4120,7 @@ function genCodeENode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   }
 
   // $dynamicRef — resolve via anchors map
-  if (schema.$dynamicRef) {
-    const anchorKey = schema.$dynamicRef.startsWith('#') ? schema.$dynamicRef : '#' + schema.$dynamicRef
-    if (ctx.anchors && ctx.anchors[anchorKey]) {
-      const target = ctx.anchors[anchorKey]
-      if (target === ctx.rootSchema) {
-        // Self-recursive: generate _validateE call
-        ctx.usesRecursion = true
-        lines.push(`_validateE(${v},_all,_e)`)
-      } else {
-        const refKey = '$dynamicRef:' + anchorKey
-        if (!ctx.refStack.has(refKey)) {
-          ctx.refStack.add(refKey)
-          genCodeE(target, v, pathExpr, lines, ctx, schemaPrefix)
-          ctx.refStack.delete(refKey)
-        }
-      }
-    }
-  }
+  if (schema.$dynamicRef) genDynamicRefE(schema, v, pathExpr, lines, ctx, schemaPrefix)
 
   const types = schema.type ? (Array.isArray(schema.type) ? schema.type : [schema.type]) : null
   if (types) {
@@ -4175,22 +4285,7 @@ function genCodeENode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   }
 
   // uniqueItems — tiered: small primitive arrays use nested loop (no allocation)
-  if (schema.uniqueItems) {
-    const si = ctx.varCounter++
-    const itemType = schema.items && typeof schema.items === 'object' && schema.items.type
-    const isPrim = itemType === 'string' || itemType === 'number' || itemType === 'integer'
-    const maxItems = schema.maxItems
-    const failExpr = (iVar, jVar) => fail('uniqueItems', 'uniqueItems', `{i:${iVar},j:${jVar}}`, `'must NOT have duplicate items (items ## '+${jVar}+' and '+${iVar}+' are identical)'`)
-    let inner
-    if (isPrim && maxItems && maxItems <= 16) {
-      inner = `for(let _i=1;_i<${v}.length;_i++){for(let _k=0;_k<_i;_k++){if(${v}[_i]===${v}[_k]){${failExpr('_k', '_i')};break}}}`
-    } else if (isPrim) {
-      inner = `const _s${si}=new Map();for(let _i=0;_i<${v}.length;_i++){const _prev=_s${si}.get(${v}[_i]);if(_prev!==undefined){${failExpr('_prev', '_i')};break};_s${si}.set(${v}[_i],_i)}`
-    } else {
-      inner = `const _cn${si}=function(x){if(x===null||typeof x!=='object')return typeof x+':'+x;if(Array.isArray(x))return'['+x.map(_cn${si}).join(',')+']';return'{'+Object.keys(x).sort().map(function(k){return JSON.stringify(k)+':'+_cn${si}(x[k])}).join(',')+'}'};const _s${si}=new Map();for(let _i=0;_i<${v}.length;_i++){const _k=_cn${si}(${v}[_i]);const _prev=_s${si}.get(_k);if(_prev!==undefined){${failExpr('_prev', '_i')};break};_s${si}.set(_k,_i)}`
-    }
-    lines.push(isArr ? `{${inner}}` : `if(Array.isArray(${v})){${inner}}`)
-  }
+  if (schema.uniqueItems) genUniqueItemsE(schema, v, pathExpr, lines, ctx, schemaPrefix, fail, isArr)
 
   // object size
   if (schema.minProperties !== undefined) {
@@ -4240,45 +4335,13 @@ function genCodeENode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   // to emit. The error keeps the keyword's own identity: the interpreted
   // engine reports these as unevaluatedProperties with the key named, and the
   // two engines are pinned to identical output.
-  if (schema.unevaluatedProperties === false && schema.additionalProperties === undefined) {
-    const allowedU = Object.keys(schema.properties || {}).map(k => `${JSON.stringify(k)}`).join(',')
-    const ui = ctx.varCounter++
-    const upSp = `${schemaPrefix}/unevaluatedProperties`
-    const upLit = buildErrorLiteral({ keyword: 'unevaluatedProperties', schemaPath: upSp, sourceMap: ctx.sourceMap })
-    const patChecksU = []
-    for (const pat of Object.keys(schema.patternProperties || {})) {
-      const pattern = JSON.stringify(pat)
-      if (!ctx.regExpMap.has(pattern)) {
-        const ri = ctx.varCounter++
-        ctx.regExpMap.set(pattern, ri)
-        if (patternIsSafe(pat)) {
-          ctx.helperCode.push(`const _re${ri}=__ataSafeRe(${pattern})`)
-          ctx.usesSafeRe = true
-        } else {
-          ctx.helperCode.push(`const _re${ri}=new RegExp(${pattern})`)
-        }
-      }
-      patChecksU.push(`_re${ctx.regExpMap.get(pattern)}.test(_k${ui}[_i])`)
-    }
-    const isUneval = patChecksU.length ? `!_a${ui}.has(_k${ui}[_i])&&!(${patChecksU.join('||')})` : `!_a${ui}.has(_k${ui}[_i])`
-    const innerU = `const _k${ui}=Object.keys(${v});const _a${ui}=new Set([${allowedU}]);for(let _i=0;_i<_k${ui}.length;_i++){if(${isUneval}){_e.push({code:'${upLit.codeStr}',keyword:'unevaluatedProperties',instancePath:${pathExpr||'""'},schemaPath:'${upSp}'${ordinalField(ctx, `${upSp}`)},params:{unevaluatedProperty:_k${ui}[_i]},message:'must NOT have unevaluated properties',docUrl:'${upLit.docUrl}'${upLit.frame}});if(!_all)return{valid:false,errors:_e}}}`
-    lines.push(isObj ? `{${innerU}}` : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${innerU}}`)
-  }
+  if (schema.unevaluatedProperties === false && schema.additionalProperties === undefined) genUnevaluatedFalseE(schema, v, pathExpr, lines, ctx, schemaPrefix, isObj)
 
   // unevaluatedItems: false under the same rule. The interpreted engine
   // reports one error for the array with the first unevaluated position as
   // the limit; with adjacent `items` everything is evaluated. The draft-07
   // array form of items acts as the prefix.
-  if (schema.unevaluatedItems === false) {
-    const itemsIsPrefix = Array.isArray(schema.items)
-    const allEval = schema.items !== undefined && !itemsIsPrefix
-    if (!allEval) {
-      const plen = itemsIsPrefix ? schema.items.length : (Array.isArray(schema.prefixItems) ? schema.prefixItems.length : 0)
-      const uiSp = `${schemaPrefix}/unevaluatedItems`
-      const uiLit = buildErrorLiteral({ keyword: 'unevaluatedItems', schemaPath: uiSp, sourceMap: ctx.sourceMap })
-      lines.push(`if(Array.isArray(${v})&&${v}.length>${plen}){_e.push({code:'${uiLit.codeStr}',keyword:'unevaluatedItems',instancePath:${pathExpr||'""'},schemaPath:'${uiSp}'${ordinalField(ctx, `${uiSp}`)},params:{limit:${plen}},message:'must NOT have more than ${plen} items',docUrl:'${uiLit.docUrl}'${uiLit.frame}});if(!_all)return{valid:false,errors:_e}}`)
-    }
-  }
+  if (schema.unevaluatedItems === false) genUnevaluatedItemsFalseE(schema, v, pathExpr, lines, ctx, schemaPrefix)
 
   // dependentRequired
   if (schema.dependentRequired) {
@@ -4302,207 +4365,304 @@ function genCodeENode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   }
 
   // patternProperties
-  if (schema.patternProperties) {
-    for (const [pat, sub] of Object.entries(schema.patternProperties)) {
-      const pattern = JSON.stringify(pat);
-      if (!ctx.regExpMap.has(pattern)) {
-        const ri = ctx.varCounter++
-        ctx.regExpMap.set(pattern, ri)
-        if (patternIsSafe(pat)) {
-          ctx.helperCode.push(`const _re${ri}=__ataSafeRe(${pattern})`);
-          ctx.usesSafeRe = true
-        } else {
-          ctx.helperCode.push(`const _re${ri}=new RegExp(${pattern})`);
-        }
-      }
-      const ri = ctx.regExpMap.get(pattern);
-      const ki = ctx.varCounter++
-      lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){for(const _k${ki} in ${v}){if(_re${ri}.test(_k${ki})){`)
-      const _peFn = emitPtrEsc(ctx)
-      const p = pathExpr ? `${pathExpr}+'/'+${_peFn}(_k${ki})` : `'/'+${_peFn}(_k${ki})`
-      // The real pointer, so source maps can locate the failing keyword.
-      genCodeE(sub, `${v}[_k${ki}]`, p, lines, ctx, schemaPrefix + '/patternProperties/' + pat.replace(/~/g, '~0').replace(/\//g, '~1'))
-      lines.push(`}}}`)
-    }
-  }
+  if (schema.patternProperties) genPatternPropertiesE(schema, v, pathExpr, lines, ctx, schemaPrefix)
 
   // additionalProperties as a schema — validate each property not declared in
   // `properties` against the subschema, with a dynamic /<key> path. codegenSafe
   // guarantees no patternProperties or composition here, so "additional" is
   // simply "not declared".
-  if (typeof schema.additionalProperties === 'object' && schema.additionalProperties !== null) {
-    const ki = ctx.varCounter++
-    const known = Object.keys(schema.properties || {})
-    const guard = known.length ? `const _ak${ki}=new Set([${known.map((k) => JSON.stringify(k)).join(',')}]);` : ''
-    // A key matched by any patternProperties entry is not additional.
-    const patTests = []
-    for (const pat of Object.keys(schema.patternProperties || {})) {
-      const pattern = JSON.stringify(pat)
-      if (!ctx.regExpMap.has(pattern)) {
-        const ri = ctx.varCounter++
-        ctx.regExpMap.set(pattern, ri)
-        if (patternIsSafe(pat)) {
-          ctx.helperCode.push(`const _re${ri}=__ataSafeRe(${pattern})`)
-          ctx.usesSafeRe = true
-        } else {
-          ctx.helperCode.push(`const _re${ri}=new RegExp(${pattern})`)
-        }
-      }
-      patTests.push(`_re${ctx.regExpMap.get(pattern)}.test(_k${ki})`)
-    }
-    const conds = []
-    if (known.length) conds.push(`!_ak${ki}.has(_k${ki})`)
-    if (patTests.length) conds.push(`!(${patTests.join('||')})`)
-    const keep = conds.length ? `if(${conds.join('&&')}){` : `{`
-    lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${guard}for(const _k${ki} in ${v}){${keep}`)
-    const _peFn = emitPtrEsc(ctx)
-    const p = pathExpr ? `${pathExpr}+'/'+${_peFn}(_k${ki})` : `'/'+${_peFn}(_k${ki})`
-    genCodeE(schema.additionalProperties, `${v}[_k${ki}]`, p, lines, ctx, schemaPrefix + '/additionalProperties')
-    lines.push(`}}}`)
-  }
+  if (typeof schema.additionalProperties === 'object' && schema.additionalProperties !== null) genAdditionalSchemaE(schema, v, pathExpr, lines, ctx, schemaPrefix)
 
   // dependentSchemas
-  if (schema.dependentSchemas) {
-    for (const [key, depSchema] of Object.entries(schema.dependentSchemas)) {
-      lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&${ownKeyExpr(ctx, v, key)}){`)
-      genCodeE(depSchema, v, pathExpr, lines, ctx, schemaPrefix+'/dependentSchemas/'+ptrSeg(key))
-      lines.push(`}`)
-    }
-  }
+  if (schema.dependentSchemas) genDependentSchemasE(schema, v, pathExpr, lines, ctx, schemaPrefix)
 
   // propertyNames: false reports every key, at the key's own path, the way the
   // interpreter does (plan-compiler: instancePath + '/' + key).
-  if (schema.propertyNames === false) {
-    const ki = ctx.varCounter++
-    // The subschema is applied to the property NAME, so the failure belongs to
-    // the object that carries the name, not to `/<key>`, which is where the
-    // value lives. Same placement as the object-valued propertyNames branch.
-    const p = pathExpr || '""'
-    lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){for(const _k${ki} in ${v}){_e.push({keyword:'not',instancePath:${p},schemaPath:'${schemaPrefix}/propertyNames'${ordinalField(ctx, `${schemaPrefix}/propertyNames`)},params:{},message:'boolean schema is false'});if(!_all)return{valid:false,errors:_e}}}`)
-  }
+  if (schema.propertyNames === false) genPropertyNamesFalseE(schema, v, pathExpr, lines, ctx, schemaPrefix)
 
   // propertyNames
-  if (schema.propertyNames && typeof schema.propertyNames === 'object') {
-    const pn = schema.propertyNames
-    const ki = ctx.varCounter++
-    lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){for(const _k${ki} in ${v}){`)
-    if (pn.minLength !== undefined) {
-      lines.push(`if(_k${ki}.length<${pn.minLength}){${fail('minLength', 'propertyNames/minLength', `{limit:${pn.minLength}}`, `'must NOT have fewer than ${pn.minLength} characters'`)}}`)
+  if (schema.propertyNames && typeof schema.propertyNames === 'object') genPropertyNamesE(schema, v, pathExpr, lines, ctx, schemaPrefix, fail)
+
+  // items — starts after prefixItems (Draft 2020-12 semantics)
+  if (schema.items !== undefined && schema.items !== true) {
+    const startIdx = schema.prefixItems ? schema.prefixItems.length : 0
+    const idx = `_j${ctx.varCounter}`
+    const elem = `_ei${ctx.varCounter}`
+    ctx.varCounter++
+    const childPath = childPathDynExpr(pathExpr, idx)
+    lines.push(`if(Array.isArray(${v})){for(let ${idx}=${startIdx};${idx}<${v}.length;${idx}++){const ${elem}=${v}[${idx}]`)
+    genCodeE(schema.items, elem, childPath, lines, ctx, schemaPrefix+'/items')
+    lines.push(`}}`)
+  }
+
+  // prefixItems
+  if (schema.prefixItems) genPrefixItemsE(schema, v, pathExpr, lines, ctx, schemaPrefix)
+
+  // contains
+  if (schema.contains !== undefined) genContainsE(schema, v, pathExpr, lines, ctx, schemaPrefix, fail)
+
+  // allOf
+  if (schema.allOf) {
+    for (let _ai = 0; _ai < schema.allOf.length; _ai++) {
+      genCodeE(schema.allOf[_ai], v, pathExpr, lines, ctx, schemaPrefix+'/allOf/'+_ai)
     }
-    if (pn.maxLength !== undefined) {
-      lines.push(`if(_k${ki}.length>${pn.maxLength}){${fail('maxLength', 'propertyNames/maxLength', `{limit:${pn.maxLength}}`, `'must NOT have more than ${pn.maxLength} characters'`)}}`)
+  }
+
+  // anyOf - collapse to single best-branch error via __ataCollapse
+  if (schema.anyOf) genAnyOfE(schema, v, pathExpr, lines, ctx, schemaPrefix)
+
+  // oneOf - collapse to single best-branch error via __ataCollapse
+  if (schema.oneOf) genOneOfE(schema, v, pathExpr, lines, ctx, schemaPrefix)
+
+  // not
+  if (schema.not !== undefined) genNotE(schema, v, pathExpr, lines, ctx, schemaPrefix, fail)
+
+  // if/then/else
+  if (schema.if !== undefined) genIfE(schema, v, pathExpr, lines, ctx, schemaPrefix)
+}
+
+// Rarely used keyword families of genCodeENode, kept out of it so their compile is
+// paid only by schemas that use them.
+
+function genDynamicRefE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
+  const anchorKey = schema.$dynamicRef.startsWith('#') ? schema.$dynamicRef : '#' + schema.$dynamicRef
+  if (ctx.anchors && ctx.anchors[anchorKey]) {
+    const target = ctx.anchors[anchorKey]
+    if (target === ctx.rootSchema) {
+      // Self-recursive: generate _validateE call
+      ctx.usesRecursion = true
+      lines.push(`_validateE(${v},_all,_e)`)
+    } else {
+      const refKey = '$dynamicRef:' + anchorKey
+      if (!ctx.refStack.has(refKey)) {
+        ctx.refStack.add(refKey)
+        genCodeE(target, v, pathExpr, lines, ctx, schemaPrefix)
+        ctx.refStack.delete(refKey)
+      }
     }
-    if (pn.pattern) {
-      const pattern = JSON.stringify(pn.pattern);
-      if (!ctx.regExpMap.has(pattern)) {
-        const ri = ctx.varCounter++
-        ctx.regExpMap.set(pattern, ri)
-        if (patternIsSafe(pn.pattern)) {
-          ctx.helperCode.push(`const _re${ri}=__ataSafeRe(${pattern})`);
-          ctx.usesSafeRe = true
-        } else {
-          ctx.helperCode.push(`const _re${ri}=new RegExp(${pattern})`);
-        }
+  }
+}
+
+function genUniqueItemsE(schema, v, pathExpr, lines, ctx, schemaPrefix, fail, isArr) {
+  const si = ctx.varCounter++
+  const itemType = schema.items && typeof schema.items === 'object' && schema.items.type
+  const isPrim = itemType === 'string' || itemType === 'number' || itemType === 'integer'
+  const maxItems = schema.maxItems
+  const failExpr = (iVar, jVar) => fail('uniqueItems', 'uniqueItems', `{i:${iVar},j:${jVar}}`, `'must NOT have duplicate items (items ## '+${jVar}+' and '+${iVar}+' are identical)'`)
+  let inner
+  if (isPrim && maxItems && maxItems <= 16) {
+    inner = `for(let _i=1;_i<${v}.length;_i++){for(let _k=0;_k<_i;_k++){if(${v}[_i]===${v}[_k]){${failExpr('_k', '_i')};break}}}`
+  } else if (isPrim) {
+    inner = `const _s${si}=new Map();for(let _i=0;_i<${v}.length;_i++){const _prev=_s${si}.get(${v}[_i]);if(_prev!==undefined){${failExpr('_prev', '_i')};break};_s${si}.set(${v}[_i],_i)}`
+  } else {
+    inner = `const _cn${si}=function(x){if(x===null||typeof x!=='object')return typeof x+':'+x;if(Array.isArray(x))return'['+x.map(_cn${si}).join(',')+']';return'{'+Object.keys(x).sort().map(function(k){return JSON.stringify(k)+':'+_cn${si}(x[k])}).join(',')+'}'};const _s${si}=new Map();for(let _i=0;_i<${v}.length;_i++){const _k=_cn${si}(${v}[_i]);const _prev=_s${si}.get(_k);if(_prev!==undefined){${failExpr('_prev', '_i')};break};_s${si}.set(_k,_i)}`
+  }
+  lines.push(isArr ? `{${inner}}` : `if(Array.isArray(${v})){${inner}}`)
+}
+
+function genUnevaluatedFalseE(schema, v, pathExpr, lines, ctx, schemaPrefix, isObj) {
+  const allowedU = Object.keys(schema.properties || {}).map(k => `${JSON.stringify(k)}`).join(',')
+  const ui = ctx.varCounter++
+  const upSp = `${schemaPrefix}/unevaluatedProperties`
+  const upLit = buildErrorLiteral({ keyword: 'unevaluatedProperties', schemaPath: upSp, sourceMap: ctx.sourceMap })
+  const patChecksU = []
+  for (const pat of Object.keys(schema.patternProperties || {})) {
+    const pattern = JSON.stringify(pat)
+    if (!ctx.regExpMap.has(pattern)) {
+      const ri = ctx.varCounter++
+      ctx.regExpMap.set(pattern, ri)
+      if (patternIsSafe(pat)) {
+        ctx.helperCode.push(`const _re${ri}=__ataSafeRe(${pattern})`)
+        ctx.usesSafeRe = true
+      } else {
+        ctx.helperCode.push(`const _re${ri}=new RegExp(${pattern})`)
       }
-      const ri = ctx.regExpMap.get(pattern);
-      lines.push(`if(!_re${ri}.test(_k${ki})){${fail('pattern', 'propertyNames/pattern', `{pattern:${JSON.stringify(pn.pattern)}}`, `'must match pattern "${pn.pattern}"'`)}}`)
-    }
-    if (pn.const !== undefined) {
-      lines.push(`if(_k${ki}!==${JSON.stringify(pn.const)}){${fail('const', 'propertyNames/const', `{allowedValue:${JSON.stringify(pn.const)}}`, "'must be equal to constant'")}}`)
-    }
-    if (pn.enum) {
-      const ei = ctx.varCounter++
-      ctx.helperCode.push(`const _es${ei}=new Set(${JSON.stringify(pn.enum)})`)
-      lines.push(`if(!_es${ei}.has(_k${ki})){${fail('enum', 'propertyNames/enum', `{allowedValues:${JSON.stringify(pn.enum)}}`, "'must be equal to one of the allowed values'")}}`)
     }
-    lines.push(`}}`)
+    patChecksU.push(`_re${ctx.regExpMap.get(pattern)}.test(_k${ui}[_i])`)
   }
+  const isUneval = patChecksU.length ? `!_a${ui}.has(_k${ui}[_i])&&!(${patChecksU.join('||')})` : `!_a${ui}.has(_k${ui}[_i])`
+  const innerU = `const _k${ui}=Object.keys(${v});const _a${ui}=new Set([${allowedU}]);for(let _i=0;_i<_k${ui}.length;_i++){if(${isUneval}){_e.push({code:'${upLit.codeStr}',keyword:'unevaluatedProperties',instancePath:${pathExpr||'""'},schemaPath:'${upSp}'${ordinalField(ctx, `${upSp}`)},params:{unevaluatedProperty:_k${ui}[_i]},message:'must NOT have unevaluated properties',docUrl:'${upLit.docUrl}'${upLit.frame}});if(!_all)return{valid:false,errors:_e}}}`
+  lines.push(isObj ? `{${innerU}}` : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${innerU}}`)
+}
 
-  // items — starts after prefixItems (Draft 2020-12 semantics)
-  if (schema.items !== undefined && schema.items !== true) {
-    const startIdx = schema.prefixItems ? schema.prefixItems.length : 0
-    const idx = `_j${ctx.varCounter}`
-    const elem = `_ei${ctx.varCounter}`
-    ctx.varCounter++
-    const childPath = childPathDynExpr(pathExpr, idx)
-    lines.push(`if(Array.isArray(${v})){for(let ${idx}=${startIdx};${idx}<${v}.length;${idx}++){const ${elem}=${v}[${idx}]`)
-    genCodeE(schema.items, elem, childPath, lines, ctx, schemaPrefix+'/items')
-    lines.push(`}}`)
+function genUnevaluatedItemsFalseE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
+  const itemsIsPrefix = Array.isArray(schema.items)
+  const allEval = schema.items !== undefined && !itemsIsPrefix
+  if (!allEval) {
+    const plen = itemsIsPrefix ? schema.items.length : (Array.isArray(schema.prefixItems) ? schema.prefixItems.length : 0)
+    const uiSp = `${schemaPrefix}/unevaluatedItems`
+    const uiLit = buildErrorLiteral({ keyword: 'unevaluatedItems', schemaPath: uiSp, sourceMap: ctx.sourceMap })
+    lines.push(`if(Array.isArray(${v})&&${v}.length>${plen}){_e.push({code:'${uiLit.codeStr}',keyword:'unevaluatedItems',instancePath:${pathExpr||'""'},schemaPath:'${uiSp}'${ordinalField(ctx, `${uiSp}`)},params:{limit:${plen}},message:'must NOT have more than ${plen} items',docUrl:'${uiLit.docUrl}'${uiLit.frame}});if(!_all)return{valid:false,errors:_e}}`)
   }
+}
 
-  // prefixItems
-  if (schema.prefixItems) {
-    for (let i = 0; i < schema.prefixItems.length; i++) {
-      const childPath = childPathExpr(pathExpr, String(i))
-      lines.push(`if(Array.isArray(${v})&&${v}.length>${i}){`)
-      genCodeE(schema.prefixItems[i], `${v}[${i}]`, childPath, lines, ctx, schemaPrefix+'/prefixItems/'+i)
-      lines.push(`}`)
+function genPatternPropertiesE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
+  for (const [pat, sub] of Object.entries(schema.patternProperties)) {
+    const pattern = JSON.stringify(pat);
+    if (!ctx.regExpMap.has(pattern)) {
+      const ri = ctx.varCounter++
+      ctx.regExpMap.set(pattern, ri)
+      if (patternIsSafe(pat)) {
+        ctx.helperCode.push(`const _re${ri}=__ataSafeRe(${pattern})`);
+        ctx.usesSafeRe = true
+      } else {
+        ctx.helperCode.push(`const _re${ri}=new RegExp(${pattern})`);
+      }
     }
+    const ri = ctx.regExpMap.get(pattern);
+    const ki = ctx.varCounter++
+    lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){for(const _k${ki} in ${v}){if(_re${ri}.test(_k${ki})){`)
+    const _peFn = emitPtrEsc(ctx)
+    const p = pathExpr ? `${pathExpr}+'/'+${_peFn}(_k${ki})` : `'/'+${_peFn}(_k${ki})`
+    // The real pointer, so source maps can locate the failing keyword.
+    genCodeE(sub, `${v}[_k${ki}]`, p, lines, ctx, schemaPrefix + '/patternProperties/' + pat.replace(/~/g, '~0').replace(/\//g, '~1'))
+    lines.push(`}}}`)
   }
+}
 
-  // contains
-  if (schema.contains !== undefined) {
-    const ci = ctx.varCounter++
-    const subLines = []
-    nestedGenCode(schema.contains, `_cv`, subLines, ctx)
-    const fnBody = subLines.length === 0 ? `return true` : `${subLines.join(';')};return true`
-    const minC = schema.minContains !== undefined ? schema.minContains : 1
-    const maxC = schema.maxContains
-    lines.push(`if(Array.isArray(${v})){const _cf${ci}=function(_cv){${fnBody}};let _cc${ci}=0;for(let _ci${ci}=0;_ci${ci}<${v}.length;_ci${ci}++){if(_cf${ci}(${v}[_ci${ci}]))_cc${ci}++}`)
-    lines.push(`if(_cc${ci}<${minC}){${fail('contains', 'contains', `{minContains:${minC}}`, `'contains: need at least ${minC} match(es)'`)}}`)
-    if (maxC !== undefined) {
-      lines.push(`if(_cc${ci}>${maxC}){${fail('contains', 'contains', `{minContains:${minC},maxContains:${maxC}}`, `'contains: at most ${maxC} match(es)'`)}}`)
+function genAdditionalSchemaE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
+  const ki = ctx.varCounter++
+  const known = Object.keys(schema.properties || {})
+  const guard = known.length ? `const _ak${ki}=new Set([${known.map((k) => JSON.stringify(k)).join(',')}]);` : ''
+  // A key matched by any patternProperties entry is not additional.
+  const patTests = []
+  for (const pat of Object.keys(schema.patternProperties || {})) {
+    const pattern = JSON.stringify(pat)
+    if (!ctx.regExpMap.has(pattern)) {
+      const ri = ctx.varCounter++
+      ctx.regExpMap.set(pattern, ri)
+      if (patternIsSafe(pat)) {
+        ctx.helperCode.push(`const _re${ri}=__ataSafeRe(${pattern})`)
+        ctx.usesSafeRe = true
+      } else {
+        ctx.helperCode.push(`const _re${ri}=new RegExp(${pattern})`)
+      }
     }
+    patTests.push(`_re${ctx.regExpMap.get(pattern)}.test(_k${ki})`)
+  }
+  const conds = []
+  if (known.length) conds.push(`!_ak${ki}.has(_k${ki})`)
+  if (patTests.length) conds.push(`!(${patTests.join('||')})`)
+  const keep = conds.length ? `if(${conds.join('&&')}){` : `{`
+  lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${guard}for(const _k${ki} in ${v}){${keep}`)
+  const _peFn = emitPtrEsc(ctx)
+  const p = pathExpr ? `${pathExpr}+'/'+${_peFn}(_k${ki})` : `'/'+${_peFn}(_k${ki})`
+  genCodeE(schema.additionalProperties, `${v}[_k${ki}]`, p, lines, ctx, schemaPrefix + '/additionalProperties')
+  lines.push(`}}}`)
+}
+
+function genDependentSchemasE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
+  for (const [key, depSchema] of Object.entries(schema.dependentSchemas)) {
+    lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&${ownKeyExpr(ctx, v, key)}){`)
+    genCodeE(depSchema, v, pathExpr, lines, ctx, schemaPrefix+'/dependentSchemas/'+ptrSeg(key))
     lines.push(`}`)
   }
+}
 
-  // allOf
-  if (schema.allOf) {
-    for (let _ai = 0; _ai < schema.allOf.length; _ai++) {
-      genCodeE(schema.allOf[_ai], v, pathExpr, lines, ctx, schemaPrefix+'/allOf/'+_ai)
+function genPropertyNamesFalseE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
+  const ki = ctx.varCounter++
+  // The subschema is applied to the property NAME, so the failure belongs to
+  // the object that carries the name, not to `/<key>`, which is where the
+  // value lives. Same placement as the object-valued propertyNames branch.
+  const p = pathExpr || '""'
+  lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){for(const _k${ki} in ${v}){_e.push({keyword:'not',instancePath:${p},schemaPath:'${schemaPrefix}/propertyNames'${ordinalField(ctx, `${schemaPrefix}/propertyNames`)},params:{},message:'boolean schema is false'});if(!_all)return{valid:false,errors:_e}}}`)
+}
+
+function genPropertyNamesE(schema, v, pathExpr, lines, ctx, schemaPrefix, fail) {
+  const pn = schema.propertyNames
+  const ki = ctx.varCounter++
+  lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){for(const _k${ki} in ${v}){`)
+  if (pn.minLength !== undefined) {
+    lines.push(`if(_k${ki}.length<${pn.minLength}){${fail('minLength', 'propertyNames/minLength', `{limit:${pn.minLength}}`, `'must NOT have fewer than ${pn.minLength} characters'`)}}`)
+  }
+  if (pn.maxLength !== undefined) {
+    lines.push(`if(_k${ki}.length>${pn.maxLength}){${fail('maxLength', 'propertyNames/maxLength', `{limit:${pn.maxLength}}`, `'must NOT have more than ${pn.maxLength} characters'`)}}`)
+  }
+  if (pn.pattern) {
+    const pattern = JSON.stringify(pn.pattern);
+    if (!ctx.regExpMap.has(pattern)) {
+      const ri = ctx.varCounter++
+      ctx.regExpMap.set(pattern, ri)
+      if (patternIsSafe(pn.pattern)) {
+        ctx.helperCode.push(`const _re${ri}=__ataSafeRe(${pattern})`);
+        ctx.usesSafeRe = true
+      } else {
+        ctx.helperCode.push(`const _re${ri}=new RegExp(${pattern})`);
+      }
     }
+    const ri = ctx.regExpMap.get(pattern);
+    lines.push(`if(!_re${ri}.test(_k${ki})){${fail('pattern', 'propertyNames/pattern', `{pattern:${JSON.stringify(pn.pattern)}}`, `'must match pattern "${pn.pattern}"'`)}}`)
   }
-
-  // anyOf - collapse to single best-branch error via __ataCollapse
-  if (schema.anyOf) {
-    emitBranchCollapse(schema.anyOf, 'anyOf', v, pathExpr, lines, ctx, schemaPrefix)
+  if (pn.const !== undefined) {
+    lines.push(`if(_k${ki}!==${JSON.stringify(pn.const)}){${fail('const', 'propertyNames/const', `{allowedValue:${JSON.stringify(pn.const)}}`, "'must be equal to constant'")}}`)
   }
-
-  // oneOf - collapse to single best-branch error via __ataCollapse
-  if (schema.oneOf) {
-    emitBranchCollapse(schema.oneOf, 'oneOf', v, pathExpr, lines, ctx, schemaPrefix)
+  if (pn.enum) {
+    const ei = ctx.varCounter++
+    ctx.helperCode.push(`const _es${ei}=new Set(${JSON.stringify(pn.enum)})`)
+    lines.push(`if(!_es${ei}.has(_k${ki})){${fail('enum', 'propertyNames/enum', `{allowedValues:${JSON.stringify(pn.enum)}}`, "'must be equal to one of the allowed values'")}}`)
   }
+  lines.push(`}}`)
+}
 
-  // not
-  if (schema.not !== undefined) {
-    const subLines = []
-    nestedGenCode(schema.not, '_nv', subLines, ctx)
-    const nfn = subLines.length === 0 ? `function(_nv){return true}` : `function(_nv){${subLines.join(';')};return true}`
-    const fi = ctx.varCounter++
-    lines.push(`{const _nf${fi}=${nfn};if(_nf${fi}(${v})){${fail('not', 'not', '{}', "'must NOT be valid'")}}}`)
+function genPrefixItemsE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
+  for (let i = 0; i < schema.prefixItems.length; i++) {
+    const childPath = childPathExpr(pathExpr, String(i))
+    lines.push(`if(Array.isArray(${v})&&${v}.length>${i}){`)
+    genCodeE(schema.prefixItems[i], `${v}[${i}]`, childPath, lines, ctx, schemaPrefix+'/prefixItems/'+i)
+    lines.push(`}`)
   }
+}
 
-  // if/then/else
-  if (schema.if !== undefined) {
-    const ifLines = []
-    nestedGenCode(schema.if, '_iv', ifLines, ctx)
-    const fi = ctx.varCounter++
-    const ifFn = ifLines.length === 0
-      ? `function(_iv){return true}`
-      : `function(_iv){${ifLines.join(';')};return true}`
-    lines.push(`{const _if${fi}=${ifFn}`)
-    if (schema.then !== undefined) {
-      lines.push(`if(_if${fi}(${v})){`)
-      genCodeE(schema.then, v, pathExpr, lines, ctx, schemaPrefix+'/then')
-      lines.push(`}`)
-    }
-    if (schema.else !== undefined) {
-      lines.push(`${schema.then !== undefined ? 'else' : `if(!_if${fi}(${v}))`}{`)
-      genCodeE(schema.else, v, pathExpr, lines, ctx, schemaPrefix+'/else')
-      lines.push(`}`)
-    }
+function genContainsE(schema, v, pathExpr, lines, ctx, schemaPrefix, fail) {
+  const ci = ctx.varCounter++
+  const subLines = []
+  nestedGenCode(schema.contains, `_cv`, subLines, ctx)
+  const fnBody = subLines.length === 0 ? `return true` : `${subLines.join(';')};return true`
+  const minC = schema.minContains !== undefined ? schema.minContains : 1
+  const maxC = schema.maxContains
+  lines.push(`if(Array.isArray(${v})){const _cf${ci}=function(_cv){${fnBody}};let _cc${ci}=0;for(let _ci${ci}=0;_ci${ci}<${v}.length;_ci${ci}++){if(_cf${ci}(${v}[_ci${ci}]))_cc${ci}++}`)
+  lines.push(`if(_cc${ci}<${minC}){${fail('contains', 'contains', `{minContains:${minC}}`, `'contains: need at least ${minC} match(es)'`)}}`)
+  if (maxC !== undefined) {
+    lines.push(`if(_cc${ci}>${maxC}){${fail('contains', 'contains', `{minContains:${minC},maxContains:${maxC}}`, `'contains: at most ${maxC} match(es)'`)}}`)
+  }
+  lines.push(`}`)
+}
+
+function genAnyOfE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
+  emitBranchCollapse(schema.anyOf, 'anyOf', v, pathExpr, lines, ctx, schemaPrefix)
+}
+
+function genOneOfE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
+  emitBranchCollapse(schema.oneOf, 'oneOf', v, pathExpr, lines, ctx, schemaPrefix)
+}
+
+function genNotE(schema, v, pathExpr, lines, ctx, schemaPrefix, fail) {
+  const subLines = []
+  nestedGenCode(schema.not, '_nv', subLines, ctx)
+  const nfn = subLines.length === 0 ? `function(_nv){return true}` : `function(_nv){${subLines.join(';')};return true}`
+  const fi = ctx.varCounter++
+  lines.push(`{const _nf${fi}=${nfn};if(_nf${fi}(${v})){${fail('not', 'not', '{}', "'must NOT be valid'")}}}`)
+}
+
+function genIfE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
+  const ifLines = []
+  nestedGenCode(schema.if, '_iv', ifLines, ctx)
+  const fi = ctx.varCounter++
+  const ifFn = ifLines.length === 0
+    ? `function(_iv){return true}`
+    : `function(_iv){${ifLines.join(';')};return true}`
+  lines.push(`{const _if${fi}=${ifFn}`)
+  if (schema.then !== undefined) {
+    lines.push(`if(_if${fi}(${v})){`)
+    genCodeE(schema.then, v, pathExpr, lines, ctx, schemaPrefix+'/then')
+    lines.push(`}`)
+  }
+  if (schema.else !== undefined) {
+    lines.push(`${schema.then !== undefined ? 'else' : `if(!_if${fi}(${v}))`}{`)
+    genCodeE(schema.else, v, pathExpr, lines, ctx, schemaPrefix+'/else')
     lines.push(`}`)
   }
+  lines.push(`}`)
 }
 
 // --- Combined validator: single pass, validates + collects errors ---
@@ -4688,23 +4848,7 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   }
 
   // $dynamicRef — resolve via anchors map
-  if (schema.$dynamicRef) {
-    const anchorKey = schema.$dynamicRef.startsWith('#') ? schema.$dynamicRef : '#' + schema.$dynamicRef
-    if (ctx.anchors && ctx.anchors[anchorKey]) {
-      const target = ctx.anchors[anchorKey]
-      // This generator has no named functions, so it cannot follow a reference
-      // back to the root or around a cycle. It used to emit nothing in both
-      // cases, which the function then answered as valid: a document the other
-      // generators reject passed through validateJSON. It declines instead,
-      // and the schema takes the error generator.
-      if (target === ctx.rootSchema) throw DECLINE
-      const refKey = '$dynamicRef:' + anchorKey
-      if (ctx.refStack.has(refKey)) throw DECLINE
-      ctx.refStack.add(refKey)
-      genCodeC(target, v, pathExpr, lines, ctx, schemaPrefix)
-      ctx.refStack.delete(refKey)
-    }
-  }
+  if (schema.$dynamicRef) genDynamicRefC(schema, v, pathExpr, lines, ctx, schemaPrefix)
 
   const types = schema.type ? (Array.isArray(schema.type) ? schema.type : [schema.type]) : null
   let isObj = false, isArr = false, isStr = false, isNum = false
@@ -4906,23 +5050,7 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   if (schema.maxItems !== undefined) { const c = isArr ? `${v}.length>${schema.maxItems}` : `Array.isArray(${v})&&${v}.length>${schema.maxItems}`; lines.push(`if(${c}){${fail('maxItems', 'maxItems', `{limit:${schema.maxItems}}`, `'must NOT have more than ${schema.maxItems} items'`)}}`) }
 
   // uniqueItems — tiered: small primitive arrays use nested loop (no allocation)
-  if (schema.uniqueItems) {
-    const si = ctx.varCounter++
-    const itemType = schema.items && typeof schema.items === 'object' && schema.items.type
-    const isPrim = itemType === 'string' || itemType === 'number' || itemType === 'integer'
-    const maxItems = schema.maxItems
-    const failExpr = (iVar, jVar) => fail('uniqueItems', 'uniqueItems', `{i:${iVar},j:${jVar}}`, `'must NOT have duplicate items (items ## '+${jVar}+' and '+${iVar}+' are identical)'`)
-    let inner
-    if (isPrim && maxItems && maxItems <= 16) {
-      // Small primitive arrays: O(n²) nested loop, zero allocation
-      inner = `for(let _i=1;_i<${v}.length;_i++){for(let _k=0;_k<_i;_k++){if(${v}[_i]===${v}[_k]){${failExpr('_k', '_i')};break}}}`
-    } else if (isPrim) {
-      inner = `const _s${si}=new Map();for(let _i=0;_i<${v}.length;_i++){const _prev=_s${si}.get(${v}[_i]);if(_prev!==undefined){${failExpr('_prev', '_i')};break};_s${si}.set(${v}[_i],_i)}`
-    } else {
-      inner = `const _cn${si}=function(x){if(x===null||typeof x!=='object')return typeof x+':'+x;if(Array.isArray(x))return'['+x.map(_cn${si}).join(',')+']';return'{'+Object.keys(x).sort().map(function(k){return JSON.stringify(k)+':'+_cn${si}(x[k])}).join(',')+'}'};const _s${si}=new Map();for(let _i=0;_i<${v}.length;_i++){const _k=_cn${si}(${v}[_i]);const _prev=_s${si}.get(_k);if(_prev!==undefined){${failExpr('_prev', '_i')};break};_s${si}.set(_k,_i)}`
-    }
-    lines.push(isArr ? `{${inner}}` : `if(Array.isArray(${v})){${inner}}`)
-  }
+  if (schema.uniqueItems) genUniqueItemsC(schema, v, pathExpr, lines, ctx, schemaPrefix, fail, isArr)
 
   // object size
   if (schema.minProperties !== undefined) lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&Object.keys(${v}).length<${schema.minProperties}){${fail('minProperties', 'minProperties', `{limit:${schema.minProperties}}`, `'must NOT have fewer than ${schema.minProperties} properties'`)}}`)
@@ -4975,35 +5103,12 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   // unevaluatedProperties: false where it is provably additionalProperties
   // (the entry bail guaranteed that), keeping the keyword's own identity so
   // the two engines report the same error.
-  if (schema.unevaluatedProperties === false && schema.additionalProperties === undefined && !schema.patternProperties) {
-    const propKeysU = Object.keys(schema.properties || {})
-    const ui = ctx.varCounter++
-    const failU = fail('unevaluatedProperties', 'unevaluatedProperties', `{unevaluatedProperty:_k${ui}[_i]}`, "'must NOT have unevaluated properties'")
-    let innerU
-    if (propKeysU.length === 0) {
-      innerU = `const _k${ui}=Object.keys(${v});for(let _i=0;_i<_k${ui}.length;_i++){${failU}}`
-    } else if (propKeysU.length <= 8) {
-      const checksU = propKeysU.map(k => `_k${ui}[_i]!==${JSON.stringify(k)}`).join('&&')
-      innerU = `const _k${ui}=Object.keys(${v});for(let _i=0;_i<_k${ui}.length;_i++)if(${checksU}){${failU}}`
-    } else {
-      const allowedU = propKeysU.map(k => JSON.stringify(k)).join(',')
-      innerU = `const _k${ui}=Object.keys(${v});const _a${ui}=new Set([${allowedU}]);for(let _i=0;_i<_k${ui}.length;_i++)if(!_a${ui}.has(_k${ui}[_i])){${failU}}`
-    }
-    lines.push(isObj ? `{${innerU}}` : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${innerU}}`)
-  }
+  if (schema.unevaluatedProperties === false && schema.additionalProperties === undefined && !schema.patternProperties) genUnevaluatedFalseC(schema, v, pathExpr, lines, ctx, schemaPrefix, fail, isObj)
 
   // unevaluatedItems: false under the same rule: one error for the array,
   // the first uncovered position as the limit. Adjacent schema-form `items`
   // evaluates everything; the draft-07 array form acts as the prefix.
-  if (schema.unevaluatedItems === false) {
-    const itemsIsPrefixC = Array.isArray(schema.items)
-    const allEvalC = schema.items !== undefined && !itemsIsPrefixC
-    if (!allEvalC) {
-      const plenC = itemsIsPrefixC ? schema.items.length : (Array.isArray(schema.prefixItems) ? schema.prefixItems.length : 0)
-      const failI = fail('unevaluatedItems', 'unevaluatedItems', `{limit:${plenC}}`, `'must NOT have more than ${plenC} items'`)
-      lines.push(`if(Array.isArray(${v})&&${v}.length>${plenC}){${failI}}`)
-    }
-  }
+  if (schema.unevaluatedItems === false) genUnevaluatedItemsFalseC(schema, v, pathExpr, lines, ctx, schemaPrefix, fail)
 
   // dependentRequired
   if (schema.dependentRequired) {
@@ -5049,153 +5154,16 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
 
   // patternProperties — same optimizations as genCode: charCodeAt + inline key comparison + merged propertyNames
   if (schema.patternProperties) {
-    const ppEntries = Object.entries(schema.patternProperties)
-    const pn = schema.propertyNames && typeof schema.propertyNames === 'object' ? schema.propertyNames : null
-    const pi = ctx.varCounter++
-
-    // Build pattern matchers: prefer charCodeAt for simple prefixes
-    const matchers = []
-    for (const [pat] of ppEntries) {
-      const kVar = `_k${pi}`
-      const fast = fastPrefixCheck(pat, kVar)
-      if (fast) {
-        matchers.push({ check: fast })
-      } else {
-        const ri = ctx.varCounter++
-        ctx.closureVars.push(`_re${ri}`)
-        ctx.closureVals.push(safeReClosure(ctx, pat))
-        matchers.push({ check: `_re${ri}.test(_k${pi})` })
-      }
-    }
-
-    const guard = isObj ? '' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v}))`
-    const kVar = `_k${pi}`
-
-    if (schema.additionalProperties === false && schema.properties) {
-      ppHandledPropertyNames = !!pn
-      const propKeys = Object.keys(schema.properties)
-      // Inline key comparison for small property sets
-      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)
-      if (pn) {
-        if (pn.minLength !== undefined) lines.push(`if(${kVar}.length<${pn.minLength}){${fail('minLength', 'propertyNames/minLength', `{limit:${pn.minLength}}`, `'must NOT have fewer than ${pn.minLength} characters'`)}}`)
-        if (pn.maxLength !== undefined) lines.push(`if(${kVar}.length>${pn.maxLength}){${fail('maxLength', 'propertyNames/maxLength', `{limit:${pn.maxLength}}`, `'must NOT have more than ${pn.maxLength} characters'`)}}`)
-        if (pn.pattern) {
-          const fast = fastPrefixCheck(pn.pattern, kVar)
-          if (fast) {
-            lines.push(`if(!(${fast})){${fail('pattern', 'propertyNames/pattern', `{pattern:${JSON.stringify(pn.pattern)}}`, `'must match pattern "${pn.pattern}"'`)}}`)
-          } else {
-            const ri = ctx.varCounter++
-            ctx.closureVars.push(`_re${ri}`)
-            ctx.closureVals.push(safeReClosure(ctx, pn.pattern))
-            lines.push(`if(!_re${ri}.test(${kVar})){${fail('pattern', 'propertyNames/pattern', `{pattern:${JSON.stringify(pn.pattern)}}`, `'must match pattern "${pn.pattern}"'`)}}`)
-          }
-        }
-        if (pn.const !== undefined) lines.push(`if(${kVar}!==${JSON.stringify(pn.const)}){${fail('const', 'propertyNames/const', `{allowedValue:${JSON.stringify(pn.const)}}`, "'must be equal to constant'")}}`)
-        if (pn.enum) {
-          const ei = ctx.varCounter++
-          ctx.closureVars.push(`_es${ei}`)
-          ctx.closureVals.push(new Set(pn.enum))
-          lines.push(`if(!_es${ei}.has(${kVar})){${fail('enum', 'propertyNames/enum', `{allowedValues:${JSON.stringify(pn.enum)}}`, "'must be equal to one of the allowed values'")}}`)
-        }
-      }
-      const matchExpr = keyCheck || `_as${pi}.has(${kVar})`
-      lines.push(`let _m${pi}=${matchExpr}`)
-      for (let i = 0; i < ppEntries.length; i++) {
-        // The subschema is generated in place so its own keywords report
-        // the real instance path and schema pointer.
-        lines.push(`if(${matchers[i].check}){_m${pi}=true;{const _ppv${pi}_${i}=${v}[${kVar}]`)
-        genCodeC(ppEntries[i][1], `_ppv${pi}_${i}`, childPathDynExpr(pathExpr, `${emitPtrEsc(ctx)}(${kVar})`), lines, ctx, schemaPrefix + '/patternProperties/' + ptrSeg(ppEntries[i][0]))
-        lines.push(`}}`)
-      }
-      lines.push(`if(!_m${pi}){${fail('additionalProperties', 'additionalProperties', `{additionalProperty:${kVar}}`, "'must NOT have additional properties'")}}`)
-      lines.push(`}}`)
-    } else {
-      ppHandledPropertyNames = !!pn
-      lines.push(`${guard}{for(const ${kVar} in ${v}){`)
-      if (pn) {
-        if (pn.minLength !== undefined) lines.push(`if(${kVar}.length<${pn.minLength}){${fail('minLength', 'propertyNames/minLength', `{limit:${pn.minLength}}`, `'must NOT have fewer than ${pn.minLength} characters'`)}}`)
-        if (pn.maxLength !== undefined) lines.push(`if(${kVar}.length>${pn.maxLength}){${fail('maxLength', 'propertyNames/maxLength', `{limit:${pn.maxLength}}`, `'must NOT have more than ${pn.maxLength} characters'`)}}`)
-        if (pn.pattern) {
-          const fast = fastPrefixCheck(pn.pattern, kVar)
-          if (fast) {
-            lines.push(`if(!(${fast})){${fail('pattern', 'propertyNames/pattern', `{pattern:${JSON.stringify(pn.pattern)}}`, `'must match pattern "${pn.pattern}"'`)}}`)
-          } else {
-            const ri = ctx.varCounter++
-            ctx.closureVars.push(`_re${ri}`)
-            ctx.closureVals.push(safeReClosure(ctx, pn.pattern))
-            lines.push(`if(!_re${ri}.test(${kVar})){${fail('pattern', 'propertyNames/pattern', `{pattern:${JSON.stringify(pn.pattern)}}`, `'must match pattern "${pn.pattern}"'`)}}`)
-          }
-        }
-        if (pn.const !== undefined) lines.push(`if(${kVar}!==${JSON.stringify(pn.const)}){${fail('const', 'propertyNames/const', `{allowedValue:${JSON.stringify(pn.const)}}`, "'must be equal to constant'")}}`)
-        if (pn.enum) {
-          const ei = ctx.varCounter++
-          ctx.closureVars.push(`_es${ei}`)
-          ctx.closureVals.push(new Set(pn.enum))
-          lines.push(`if(!_es${ei}.has(${kVar})){${fail('enum', 'propertyNames/enum', `{allowedValues:${JSON.stringify(pn.enum)}}`, "'must be equal to one of the allowed values'")}}`)
-        }
-      }
-      for (let i = 0; i < ppEntries.length; i++) {
-        lines.push(`if(${matchers[i].check}){const _ppv${pi}_${i}=${v}[${kVar}]`)
-        genCodeC(ppEntries[i][1], `_ppv${pi}_${i}`, childPathDynExpr(pathExpr, `${emitPtrEsc(ctx)}(${kVar})`), lines, ctx, schemaPrefix + '/patternProperties/' + ptrSeg(ppEntries[i][0]))
-        lines.push(`}`)
-      }
-      lines.push(`}}`)
-    }
+    if (genPatternPropertiesC(schema, v, pathExpr, lines, ctx, schemaPrefix, fail, isObj)) ppHandledPropertyNames = true
   }
 
   // dependentSchemas
-  if (schema.dependentSchemas) {
-    for (const [key, depSchema] of Object.entries(schema.dependentSchemas)) {
-      lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&${ownKeyExpr(ctx, v, key)}){`)
-      genCodeC(depSchema, v, pathExpr, lines, ctx, schemaPrefix+'/dependentSchemas/'+ptrSeg(key))
-      lines.push(`}`)
-    }
-  }
+  if (schema.dependentSchemas) genDependentSchemasC(schema, v, pathExpr, lines, ctx, schemaPrefix)
 
-  if (schema.propertyNames === false) {
-    const ki = ctx.varCounter++
-    const p = pathExpr || '""'
-    lines.push(`;if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){for(const _k${ki} in ${v}){(_e||(_e=[])).push({keyword:'not',instancePath:${p},schemaPath:'${schemaPrefix}/propertyNames'${ordinalField(ctx, `${schemaPrefix}/propertyNames`)},params:{},message:'boolean schema is false'})}}`)
-  }
+  if (schema.propertyNames === false) genPropertyNamesFalseC(schema, v, pathExpr, lines, ctx, schemaPrefix)
 
   // propertyNames — skip if already merged into patternProperties loop
-  if (schema.propertyNames && typeof schema.propertyNames === 'object' && !ppHandledPropertyNames) {
-    const pn = schema.propertyNames
-    const ki = ctx.varCounter++
-    lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){for(const _k${ki} in ${v}){`)
-    if (pn.minLength !== undefined) {
-      lines.push(`if(_k${ki}.length<${pn.minLength}){${fail('minLength', 'propertyNames/minLength', `{limit:${pn.minLength}}`, `'must NOT have fewer than ${pn.minLength} characters'`)}}`)
-    }
-    if (pn.maxLength !== undefined) {
-      lines.push(`if(_k${ki}.length>${pn.maxLength}){${fail('maxLength', 'propertyNames/maxLength', `{limit:${pn.maxLength}}`, `'must NOT have more than ${pn.maxLength} characters'`)}}`)
-    }
-    if (pn.pattern) {
-      const ri = ctx.varCounter++
-      ctx.closureVars.push(`_re${ri}`)
-      ctx.closureVals.push(safeReClosure(ctx, pn.pattern))
-      lines.push(`if(!_re${ri}.test(_k${ki})){${fail('pattern', 'propertyNames/pattern', `{pattern:${JSON.stringify(pn.pattern)}}`, `'must match pattern "${pn.pattern}"'`)}}`)
-    }
-    if (pn.const !== undefined) {
-      lines.push(`if(_k${ki}!==${JSON.stringify(pn.const)}){${fail('const', 'propertyNames/const', `{allowedValue:${JSON.stringify(pn.const)}}`, "'must be equal to constant'")}}`)
-    }
-    if (pn.enum) {
-      const ei = ctx.varCounter++
-      ctx.closureVars.push(`_es${ei}`)
-      ctx.closureVals.push(new Set(pn.enum))
-      lines.push(`if(!_es${ei}.has(_k${ki})){${fail('enum', 'propertyNames/enum', `{allowedValues:${JSON.stringify(pn.enum)}}`, "'must be equal to one of the allowed values'")}}`)
-    }
-    lines.push(`}}`)
-  }
+  if (schema.propertyNames && typeof schema.propertyNames === 'object' && !ppHandledPropertyNames) genPropertyNamesC(schema, v, pathExpr, lines, ctx, schemaPrefix, fail)
 
   // items
   if (schema.items !== undefined && schema.items !== true) {
@@ -5209,64 +5177,25 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   }
 
   // prefixItems
-  if (schema.prefixItems) {
-    for (let i = 0; i < schema.prefixItems.length; i++) {
-      const childPath = childPathExpr(pathExpr, String(i))
-      lines.push(`if(Array.isArray(${v})&&${v}.length>${i}){`)
-      genCodeC(schema.prefixItems[i], `${v}[${i}]`, childPath, lines, ctx, schemaPrefix+'/prefixItems/'+i)
-      lines.push(`}`)
-    }
-  }
+  if (schema.prefixItems) genPrefixItemsC(schema, v, pathExpr, lines, ctx, schemaPrefix)
 
   // contains
-  if (schema.contains !== undefined) {
-    const ci = ctx.varCounter++
-    const subLines = []
-    nestedGenCode(schema.contains, `_cv`, subLines, ctx)
-    const fnBody = subLines.length === 0 ? `return true` : `${subLines.join(';')};return true`
-    const minC = schema.minContains !== undefined ? schema.minContains : 1
-    const maxC = schema.maxContains
-    lines.push(`if(Array.isArray(${v})){const _cf${ci}=function(_cv){${fnBody}};let _cc${ci}=0;for(let _ci${ci}=0;_ci${ci}<${v}.length;_ci${ci}++){if(_cf${ci}(${v}[_ci${ci}]))_cc${ci}++}`)
-    lines.push(`if(_cc${ci}<${minC}){${fail('contains', 'contains', `{minContains:${minC}}`, `'contains: need at least ${minC} match(es)'`)}}`)
-    if (maxC !== undefined) lines.push(`if(_cc${ci}>${maxC}){${fail('contains', 'contains', `{minContains:${minC},maxContains:${maxC}}`, `'contains: at most ${maxC} match(es)'`)}}`)
-    lines.push(`}`)
-  }
+  if (schema.contains !== undefined) genContainsC(schema, v, pathExpr, lines, ctx, schemaPrefix, fail)
 
   // allOf
   if (schema.allOf) { for (let _ai = 0; _ai < schema.allOf.length; _ai++) genCodeC(schema.allOf[_ai], v, pathExpr, lines, ctx, schemaPrefix+'/allOf/'+_ai) }
 
   // anyOf
-  if (schema.anyOf) {
-    const fi = ctx.varCounter++
-    const fns = schema.anyOf.map(sub => { const sl = []; nestedGenCode(sub, '_av', sl, ctx); return sl.length === 0 ? `function(_av){return true}` : `function(_av){${sl.join(';')};return true}` })
-    lines.push(`{const _af${fi}=[${fns.join(',')}];let _am=false;for(let _ai=0;_ai<_af${fi}.length;_ai++){if(_af${fi}[_ai](${v})){_am=true;break}}if(!_am){${fail('anyOf', 'anyOf', '{}', "'must match a schema in anyOf'")}}}`)
-  }
+  if (schema.anyOf) genAnyOfC(schema, v, pathExpr, lines, ctx, schemaPrefix, fail)
 
   // oneOf
-  if (schema.oneOf) {
-    const fi = ctx.varCounter++
-    const fns = schema.oneOf.map(sub => { const sl = []; nestedGenCode(sub, '_ov', sl, ctx); return sl.length === 0 ? `function(_ov){return true}` : `function(_ov){${sl.join(';')};return true}` })
-    lines.push(`{const _of${fi}=[${fns.join(',')}];let _oc=0;for(let _oi=0;_oi<_of${fi}.length;_oi++){if(_of${fi}[_oi](${v}))_oc++;if(_oc>1)break}if(_oc!==1){${fail('oneOf', 'oneOf', '{}', "'must match exactly one schema in oneOf'")}}}`)
-  }
+  if (schema.oneOf) genOneOfC(schema, v, pathExpr, lines, ctx, schemaPrefix, fail)
 
   // not
-  if (schema.not !== undefined) {
-    const sl = []; nestedGenCode(schema.not, '_nv', sl, ctx)
-    const nfn = sl.length === 0 ? `function(_nv){return true}` : `function(_nv){${sl.join(';')};return true}`
-    const fi = ctx.varCounter++
-    lines.push(`{const _nf${fi}=${nfn};if(_nf${fi}(${v})){${fail('not', 'not', '{}', "'must NOT be valid'")}}}`)
-  }
+  if (schema.not !== undefined) genNotC(schema, v, pathExpr, lines, ctx, schemaPrefix, fail)
 
   // if/then/else
-  if (schema.if !== undefined) {
-    const sl = []; nestedGenCode(schema.if, '_iv', sl, ctx)
-    const fi = ctx.varCounter++
-    const ifFn = sl.length === 0 ? `function(_iv){return true}` : `function(_iv){${sl.join(';')};return true}`
-    lines.push(`{const _if${fi}=${ifFn}`)
-    if (schema.then !== undefined) { lines.push(`if(_if${fi}(${v})){`); genCodeC(schema.then, v, pathExpr, lines, ctx, schemaPrefix+'/then'); lines.push(`}`) }
-    if (schema.else !== undefined) { lines.push(`${schema.then !== undefined ? 'else' : `if(!_if${fi}(${v}))`}{`); genCodeC(schema.else, v, pathExpr, lines, ctx, schemaPrefix+'/else'); lines.push(`}`) }
-    lines.push(`}`)
-  }
+  if (schema.if !== undefined) genIfC(schema, v, pathExpr, lines, ctx, schemaPrefix)
 
   // Close type-success block if opened
   if (types) {
@@ -5274,6 +5203,272 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   }
 }
 
+// Rarely used keyword families of genCodeCNode, kept out of it so their compile is
+// paid only by schemas that use them.
+
+function genDynamicRefC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
+  const anchorKey = schema.$dynamicRef.startsWith('#') ? schema.$dynamicRef : '#' + schema.$dynamicRef
+  if (ctx.anchors && ctx.anchors[anchorKey]) {
+    const target = ctx.anchors[anchorKey]
+    // This generator has no named functions, so it cannot follow a reference
+    // back to the root or around a cycle. It used to emit nothing in both
+    // cases, which the function then answered as valid: a document the other
+    // generators reject passed through validateJSON. It declines instead,
+    // and the schema takes the error generator.
+    if (target === ctx.rootSchema) throw DECLINE
+    const refKey = '$dynamicRef:' + anchorKey
+    if (ctx.refStack.has(refKey)) throw DECLINE
+    ctx.refStack.add(refKey)
+    genCodeC(target, v, pathExpr, lines, ctx, schemaPrefix)
+    ctx.refStack.delete(refKey)
+  }
+}
+
+function genUniqueItemsC(schema, v, pathExpr, lines, ctx, schemaPrefix, fail, isArr) {
+  const si = ctx.varCounter++
+  const itemType = schema.items && typeof schema.items === 'object' && schema.items.type
+  const isPrim = itemType === 'string' || itemType === 'number' || itemType === 'integer'
+  const maxItems = schema.maxItems
+  const failExpr = (iVar, jVar) => fail('uniqueItems', 'uniqueItems', `{i:${iVar},j:${jVar}}`, `'must NOT have duplicate items (items ## '+${jVar}+' and '+${iVar}+' are identical)'`)
+  let inner
+  if (isPrim && maxItems && maxItems <= 16) {
+    // Small primitive arrays: O(n²) nested loop, zero allocation
+    inner = `for(let _i=1;_i<${v}.length;_i++){for(let _k=0;_k<_i;_k++){if(${v}[_i]===${v}[_k]){${failExpr('_k', '_i')};break}}}`
+  } else if (isPrim) {
+    inner = `const _s${si}=new Map();for(let _i=0;_i<${v}.length;_i++){const _prev=_s${si}.get(${v}[_i]);if(_prev!==undefined){${failExpr('_prev', '_i')};break};_s${si}.set(${v}[_i],_i)}`
+  } else {
+    inner = `const _cn${si}=function(x){if(x===null||typeof x!=='object')return typeof x+':'+x;if(Array.isArray(x))return'['+x.map(_cn${si}).join(',')+']';return'{'+Object.keys(x).sort().map(function(k){return JSON.stringify(k)+':'+_cn${si}(x[k])}).join(',')+'}'};const _s${si}=new Map();for(let _i=0;_i<${v}.length;_i++){const _k=_cn${si}(${v}[_i]);const _prev=_s${si}.get(_k);if(_prev!==undefined){${failExpr('_prev', '_i')};break};_s${si}.set(_k,_i)}`
+  }
+  lines.push(isArr ? `{${inner}}` : `if(Array.isArray(${v})){${inner}}`)
+}
+
+function genUnevaluatedFalseC(schema, v, pathExpr, lines, ctx, schemaPrefix, fail, isObj) {
+  const propKeysU = Object.keys(schema.properties || {})
+  const ui = ctx.varCounter++
+  const failU = fail('unevaluatedProperties', 'unevaluatedProperties', `{unevaluatedProperty:_k${ui}[_i]}`, "'must NOT have unevaluated properties'")
+  let innerU
+  if (propKeysU.length === 0) {
+    innerU = `const _k${ui}=Object.keys(${v});for(let _i=0;_i<_k${ui}.length;_i++){${failU}}`
+  } else if (propKeysU.length <= 8) {
+    const checksU = propKeysU.map(k => `_k${ui}[_i]!==${JSON.stringify(k)}`).join('&&')
+    innerU = `const _k${ui}=Object.keys(${v});for(let _i=0;_i<_k${ui}.length;_i++)if(${checksU}){${failU}}`
+  } else {
+    const allowedU = propKeysU.map(k => JSON.stringify(k)).join(',')
+    innerU = `const _k${ui}=Object.keys(${v});const _a${ui}=new Set([${allowedU}]);for(let _i=0;_i<_k${ui}.length;_i++)if(!_a${ui}.has(_k${ui}[_i])){${failU}}`
+  }
+  lines.push(isObj ? `{${innerU}}` : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${innerU}}`)
+}
+
+function genUnevaluatedItemsFalseC(schema, v, pathExpr, lines, ctx, schemaPrefix, fail) {
+  const itemsIsPrefixC = Array.isArray(schema.items)
+  const allEvalC = schema.items !== undefined && !itemsIsPrefixC
+  if (!allEvalC) {
+    const plenC = itemsIsPrefixC ? schema.items.length : (Array.isArray(schema.prefixItems) ? schema.prefixItems.length : 0)
+    const failI = fail('unevaluatedItems', 'unevaluatedItems', `{limit:${plenC}}`, `'must NOT have more than ${plenC} items'`)
+    lines.push(`if(Array.isArray(${v})&&${v}.length>${plenC}){${failI}}`)
+  }
+}
+
+function genPatternPropertiesC(schema, v, pathExpr, lines, ctx, schemaPrefix, fail, isObj) {
+  let handledPropertyNames = false
+  const ppEntries = Object.entries(schema.patternProperties)
+  const pn = schema.propertyNames && typeof schema.propertyNames === 'object' ? schema.propertyNames : null
+  const pi = ctx.varCounter++
+
+  // Build pattern matchers: prefer charCodeAt for simple prefixes
+  const matchers = []
+  for (const [pat] of ppEntries) {
+    const kVar = `_k${pi}`
+    const fast = fastPrefixCheck(pat, kVar)
+    if (fast) {
+      matchers.push({ check: fast })
+    } else {
+      const ri = ctx.varCounter++
+      ctx.closureVars.push(`_re${ri}`)
+      ctx.closureVals.push(safeReClosure(ctx, pat))
+      matchers.push({ check: `_re${ri}.test(_k${pi})` })
+    }
+  }
+
+  const guard = isObj ? '' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v}))`
+  const kVar = `_k${pi}`
+
+  if (schema.additionalProperties === false && schema.properties) {
+    handledPropertyNames = !!pn
+    const propKeys = Object.keys(schema.properties)
+    // Inline key comparison for small property sets
+    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)
+    if (pn) {
+      if (pn.minLength !== undefined) lines.push(`if(${kVar}.length<${pn.minLength}){${fail('minLength', 'propertyNames/minLength', `{limit:${pn.minLength}}`, `'must NOT have fewer than ${pn.minLength} characters'`)}}`)
+      if (pn.maxLength !== undefined) lines.push(`if(${kVar}.length>${pn.maxLength}){${fail('maxLength', 'propertyNames/maxLength', `{limit:${pn.maxLength}}`, `'must NOT have more than ${pn.maxLength} characters'`)}}`)
+      if (pn.pattern) {
+        const fast = fastPrefixCheck(pn.pattern, kVar)
+        if (fast) {
+          lines.push(`if(!(${fast})){${fail('pattern', 'propertyNames/pattern', `{pattern:${JSON.stringify(pn.pattern)}}`, `'must match pattern "${pn.pattern}"'`)}}`)
+        } else {
+          const ri = ctx.varCounter++
+          ctx.closureVars.push(`_re${ri}`)
+          ctx.closureVals.push(safeReClosure(ctx, pn.pattern))
+          lines.push(`if(!_re${ri}.test(${kVar})){${fail('pattern', 'propertyNames/pattern', `{pattern:${JSON.stringify(pn.pattern)}}`, `'must match pattern "${pn.pattern}"'`)}}`)
+        }
+      }
+      if (pn.const !== undefined) lines.push(`if(${kVar}!==${JSON.stringify(pn.const)}){${fail('const', 'propertyNames/const', `{allowedValue:${JSON.stringify(pn.const)}}`, "'must be equal to constant'")}}`)
+      if (pn.enum) {
+        const ei = ctx.varCounter++
+        ctx.closureVars.push(`_es${ei}`)
+        ctx.closureVals.push(new Set(pn.enum))
+        lines.push(`if(!_es${ei}.has(${kVar})){${fail('enum', 'propertyNames/enum', `{allowedValues:${JSON.stringify(pn.enum)}}`, "'must be equal to one of the allowed values'")}}`)
+      }
+    }
+    const matchExpr = keyCheck || `_as${pi}.has(${kVar})`
+    lines.push(`let _m${pi}=${matchExpr}`)
+    for (let i = 0; i < ppEntries.length; i++) {
+      // The subschema is generated in place so its own keywords report
+      // the real instance path and schema pointer.
+      lines.push(`if(${matchers[i].check}){_m${pi}=true;{const _ppv${pi}_${i}=${v}[${kVar}]`)
+      genCodeC(ppEntries[i][1], `_ppv${pi}_${i}`, childPathDynExpr(pathExpr, `${emitPtrEsc(ctx)}(${kVar})`), lines, ctx, schemaPrefix + '/patternProperties/' + ptrSeg(ppEntries[i][0]))
+      lines.push(`}}`)
+    }
+    lines.push(`if(!_m${pi}){${fail('additionalProperties', 'additionalProperties', `{additionalProperty:${kVar}}`, "'must NOT have additional properties'")}}`)
+    lines.push(`}}`)
+  } else {
+    handledPropertyNames = !!pn
+    lines.push(`${guard}{for(const ${kVar} in ${v}){`)
+    if (pn) {
+      if (pn.minLength !== undefined) lines.push(`if(${kVar}.length<${pn.minLength}){${fail('minLength', 'propertyNames/minLength', `{limit:${pn.minLength}}`, `'must NOT have fewer than ${pn.minLength} characters'`)}}`)
+      if (pn.maxLength !== undefined) lines.push(`if(${kVar}.length>${pn.maxLength}){${fail('maxLength', 'propertyNames/maxLength', `{limit:${pn.maxLength}}`, `'must NOT have more than ${pn.maxLength} characters'`)}}`)
+      if (pn.pattern) {
+        const fast = fastPrefixCheck(pn.pattern, kVar)
+        if (fast) {
+          lines.push(`if(!(${fast})){${fail('pattern', 'propertyNames/pattern', `{pattern:${JSON.stringify(pn.pattern)}}`, `'must match pattern "${pn.pattern}"'`)}}`)
+        } else {
+          const ri = ctx.varCounter++
+          ctx.closureVars.push(`_re${ri}`)
+          ctx.closureVals.push(safeReClosure(ctx, pn.pattern))
+          lines.push(`if(!_re${ri}.test(${kVar})){${fail('pattern', 'propertyNames/pattern', `{pattern:${JSON.stringify(pn.pattern)}}`, `'must match pattern "${pn.pattern}"'`)}}`)
+        }
+      }
+      if (pn.const !== undefined) lines.push(`if(${kVar}!==${JSON.stringify(pn.const)}){${fail('const', 'propertyNames/const', `{allowedValue:${JSON.stringify(pn.const)}}`, "'must be equal to constant'")}}`)
+      if (pn.enum) {
+        const ei = ctx.varCounter++
+        ctx.closureVars.push(`_es${ei}`)
+        ctx.closureVals.push(new Set(pn.enum))
+        lines.push(`if(!_es${ei}.has(${kVar})){${fail('enum', 'propertyNames/enum', `{allowedValues:${JSON.stringify(pn.enum)}}`, "'must be equal to one of the allowed values'")}}`)
+      }
+    }
+    for (let i = 0; i < ppEntries.length; i++) {
+      lines.push(`if(${matchers[i].check}){const _ppv${pi}_${i}=${v}[${kVar}]`)
+      genCodeC(ppEntries[i][1], `_ppv${pi}_${i}`, childPathDynExpr(pathExpr, `${emitPtrEsc(ctx)}(${kVar})`), lines, ctx, schemaPrefix + '/patternProperties/' + ptrSeg(ppEntries[i][0]))
+      lines.push(`}`)
+    }
+    lines.push(`}}`)
+  }
+  return handledPropertyNames
+}
+
+function genDependentSchemasC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
+  for (const [key, depSchema] of Object.entries(schema.dependentSchemas)) {
+    lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&${ownKeyExpr(ctx, v, key)}){`)
+    genCodeC(depSchema, v, pathExpr, lines, ctx, schemaPrefix+'/dependentSchemas/'+ptrSeg(key))
+    lines.push(`}`)
+  }
+}
+
+function genPropertyNamesFalseC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
+  const ki = ctx.varCounter++
+  const p = pathExpr || '""'
+  lines.push(`;if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){for(const _k${ki} in ${v}){(_e||(_e=[])).push({keyword:'not',instancePath:${p},schemaPath:'${schemaPrefix}/propertyNames'${ordinalField(ctx, `${schemaPrefix}/propertyNames`)},params:{},message:'boolean schema is false'})}}`)
+}
+
+function genPropertyNamesC(schema, v, pathExpr, lines, ctx, schemaPrefix, fail) {
+  const pn = schema.propertyNames
+  const ki = ctx.varCounter++
+  lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){for(const _k${ki} in ${v}){`)
+  if (pn.minLength !== undefined) {
+    lines.push(`if(_k${ki}.length<${pn.minLength}){${fail('minLength', 'propertyNames/minLength', `{limit:${pn.minLength}}`, `'must NOT have fewer than ${pn.minLength} characters'`)}}`)
+  }
+  if (pn.maxLength !== undefined) {
+    lines.push(`if(_k${ki}.length>${pn.maxLength}){${fail('maxLength', 'propertyNames/maxLength', `{limit:${pn.maxLength}}`, `'must NOT have more than ${pn.maxLength} characters'`)}}`)
+  }
+  if (pn.pattern) {
+    const ri = ctx.varCounter++
+    ctx.closureVars.push(`_re${ri}`)
+    ctx.closureVals.push(safeReClosure(ctx, pn.pattern))
+    lines.push(`if(!_re${ri}.test(_k${ki})){${fail('pattern', 'propertyNames/pattern', `{pattern:${JSON.stringify(pn.pattern)}}`, `'must match pattern "${pn.pattern}"'`)}}`)
+  }
+  if (pn.const !== undefined) {
+    lines.push(`if(_k${ki}!==${JSON.stringify(pn.const)}){${fail('const', 'propertyNames/const', `{allowedValue:${JSON.stringify(pn.const)}}`, "'must be equal to constant'")}}`)
+  }
+  if (pn.enum) {
+    const ei = ctx.varCounter++
+    ctx.closureVars.push(`_es${ei}`)
+    ctx.closureVals.push(new Set(pn.enum))
+    lines.push(`if(!_es${ei}.has(_k${ki})){${fail('enum', 'propertyNames/enum', `{allowedValues:${JSON.stringify(pn.enum)}}`, "'must be equal to one of the allowed values'")}}`)
+  }
+  lines.push(`}}`)
+}
+
+function genPrefixItemsC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
+  for (let i = 0; i < schema.prefixItems.length; i++) {
+    const childPath = childPathExpr(pathExpr, String(i))
+    lines.push(`if(Array.isArray(${v})&&${v}.length>${i}){`)
+    genCodeC(schema.prefixItems[i], `${v}[${i}]`, childPath, lines, ctx, schemaPrefix+'/prefixItems/'+i)
+    lines.push(`}`)
+  }
+}
+
+function genContainsC(schema, v, pathExpr, lines, ctx, schemaPrefix, fail) {
+  const ci = ctx.varCounter++
+  const subLines = []
+  nestedGenCode(schema.contains, `_cv`, subLines, ctx)
+  const fnBody = subLines.length === 0 ? `return true` : `${subLines.join(';')};return true`
+  const minC = schema.minContains !== undefined ? schema.minContains : 1
+  const maxC = schema.maxContains
+  lines.push(`if(Array.isArray(${v})){const _cf${ci}=function(_cv){${fnBody}};let _cc${ci}=0;for(let _ci${ci}=0;_ci${ci}<${v}.length;_ci${ci}++){if(_cf${ci}(${v}[_ci${ci}]))_cc${ci}++}`)
+  lines.push(`if(_cc${ci}<${minC}){${fail('contains', 'contains', `{minContains:${minC}}`, `'contains: need at least ${minC} match(es)'`)}}`)
+  if (maxC !== undefined) lines.push(`if(_cc${ci}>${maxC}){${fail('contains', 'contains', `{minContains:${minC},maxContains:${maxC}}`, `'contains: at most ${maxC} match(es)'`)}}`)
+  lines.push(`}`)
+}
+
+function genAnyOfC(schema, v, pathExpr, lines, ctx, schemaPrefix, fail) {
+  const fi = ctx.varCounter++
+  const fns = schema.anyOf.map(sub => { const sl = []; nestedGenCode(sub, '_av', sl, ctx); return sl.length === 0 ? `function(_av){return true}` : `function(_av){${sl.join(';')};return true}` })
+  lines.push(`{const _af${fi}=[${fns.join(',')}];let _am=false;for(let _ai=0;_ai<_af${fi}.length;_ai++){if(_af${fi}[_ai](${v})){_am=true;break}}if(!_am){${fail('anyOf', 'anyOf', '{}', "'must match a schema in anyOf'")}}}`)
+}
+
+function genOneOfC(schema, v, pathExpr, lines, ctx, schemaPrefix, fail) {
+  const fi = ctx.varCounter++
+  const fns = schema.oneOf.map(sub => { const sl = []; nestedGenCode(sub, '_ov', sl, ctx); return sl.length === 0 ? `function(_ov){return true}` : `function(_ov){${sl.join(';')};return true}` })
+  lines.push(`{const _of${fi}=[${fns.join(',')}];let _oc=0;for(let _oi=0;_oi<_of${fi}.length;_oi++){if(_of${fi}[_oi](${v}))_oc++;if(_oc>1)break}if(_oc!==1){${fail('oneOf', 'oneOf', '{}', "'must match exactly one schema in oneOf'")}}}`)
+}
+
+function genNotC(schema, v, pathExpr, lines, ctx, schemaPrefix, fail) {
+  const sl = []; nestedGenCode(schema.not, '_nv', sl, ctx)
+  const nfn = sl.length === 0 ? `function(_nv){return true}` : `function(_nv){${sl.join(';')};return true}`
+  const fi = ctx.varCounter++
+  lines.push(`{const _nf${fi}=${nfn};if(_nf${fi}(${v})){${fail('not', 'not', '{}', "'must NOT be valid'")}}}`)
+}
+
+function genIfC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
+  const sl = []; nestedGenCode(schema.if, '_iv', sl, ctx)
+  const fi = ctx.varCounter++
+  const ifFn = sl.length === 0 ? `function(_iv){return true}` : `function(_iv){${sl.join(';')};return true}`
+  lines.push(`{const _if${fi}=${ifFn}`)
+  if (schema.then !== undefined) { lines.push(`if(_if${fi}(${v})){`); genCodeC(schema.then, v, pathExpr, lines, ctx, schemaPrefix+'/then'); lines.push(`}`) }
+  if (schema.else !== undefined) { lines.push(`${schema.then !== undefined ? 'else' : `if(!_if${fi}(${v}))`}{`); genCodeC(schema.else, v, pathExpr, lines, ctx, schemaPrefix+'/else'); lines.push(`}`) }
+  lines.push(`}`)
+}
+
 // 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) {