ata-validator 0.5.0 → 0.6.0

package/lib/js-compiler.js

@@ -4,6 +4,34 @@
 // Closure-based validator — no new Function() or eval().
 // Returns null if the schema is too complex for JS compilation.
 
+// AJV-compatible error message templates (compile-time, not runtime)
+const AJV_MESSAGES = {
+  type: (p) => `must be ${p.type}`,
+  required: (p) => `must have required property '${p.missingProperty}'`,
+  additionalProperties: () => 'must NOT have additional properties',
+  enum: () => 'must be equal to one of the allowed values',
+  const: () => 'must be equal to constant',
+  minimum: (p) => `must be >= ${p.limit}`,
+  maximum: (p) => `must be <= ${p.limit}`,
+  exclusiveMinimum: (p) => `must be > ${p.limit}`,
+  exclusiveMaximum: (p) => `must be < ${p.limit}`,
+  minLength: (p) => `must NOT have fewer than ${p.limit} characters`,
+  maxLength: (p) => `must NOT have more than ${p.limit} characters`,
+  pattern: (p) => `must match pattern "${p.pattern}"`,
+  format: (p) => `must match format "${p.format}"`,
+  minItems: (p) => `must NOT have fewer than ${p.limit} items`,
+  maxItems: (p) => `must NOT have more than ${p.limit} items`,
+  uniqueItems: (p) => `must NOT have duplicate items (items ## ${p.j} and ${p.i} are identical)`,
+  minProperties: (p) => `must NOT have fewer than ${p.limit} properties`,
+  maxProperties: (p) => `must NOT have more than ${p.limit} properties`,
+  multipleOf: (p) => `must be multiple of ${p.multipleOf}`,
+  oneOf: () => 'must match exactly one schema in oneOf',
+  anyOf: () => 'must match a schema in anyOf',
+  allOf: () => 'must match all schemas in allOf',
+  not: () => 'must NOT be valid',
+  if: (p) => `must match "${p.failingKeyword}" schema`,
+}
+
 function compileToJS(schema, defs, schemaMap) {
   if (typeof schema === 'boolean') {
     return schema ? () => true : () => false
@@ -433,11 +461,13 @@ function codegenSafe(schema, schemaMap) {
   if (typeof schema !== 'object' || schema === null) return true
 
   // Boolean sub-schemas anywhere cause bail — codegen doesn't handle schema=false correctly
-  if (schema.items === false || schema.items === true) return false
+  if (schema.items === false) return false
+  if (schema.items === true && !schema.unevaluatedItems) return false
   if (schema.additionalProperties === true) return true // permissive — fine
   if (schema.properties) {
     for (const v of Object.values(schema.properties)) {
-      if (typeof v === 'boolean') return false
+      if (v === false) return false // property: false is complex
+      if (v === true) continue // property: true is always valid
       if (!codegenSafe(v, schemaMap)) return false
     }
   }
@@ -463,9 +493,10 @@ function codegenSafe(schema, schemaMap) {
     const isLocal = /^#\/(?:\$defs|definitions)\/[^/]+$/.test(schema.$ref)
     const isResolvable = !isLocal && schemaMap && schemaMap.has(schema.$ref)
     if (!isLocal && !isResolvable) return false
-    // Bail if $ref has sibling keywords (complex interaction)
+    // In Draft 2020-12, $ref with siblings is allowed. Only bail if no unevaluated* keyword
+    // (unevaluated schemas need $ref + siblings to work properly)
     const siblings = Object.keys(schema).filter(k => k !== '$ref' && k !== '$defs' && k !== 'definitions' && k !== '$schema' && k !== '$id')
-    if (siblings.length > 0) return false
+    if (siblings.length > 0 && schema.unevaluatedProperties === undefined && schema.unevaluatedItems === undefined) return false
   }
 
   // additionalProperties as schema — bail entirely, too many edge cases with allOf interaction
@@ -475,6 +506,19 @@ function codegenSafe(schema, schemaMap) {
   // propertyNames: false — codegen doesn't handle this
   if (schema.propertyNames === false) return false
 
+  // unevaluatedProperties: allow boolean and schema values
+  if (schema.unevaluatedProperties !== undefined) {
+    if (typeof schema.unevaluatedProperties === 'object' && schema.unevaluatedProperties !== null) {
+      if (!codegenSafe(schema.unevaluatedProperties, schemaMap)) return false
+    }
+  }
+  // unevaluatedItems: allow boolean and schema values
+  if (schema.unevaluatedItems !== undefined) {
+    if (typeof schema.unevaluatedItems === 'object' && schema.unevaluatedItems !== null) {
+      if (!codegenSafe(schema.unevaluatedItems, schemaMap)) return false
+    }
+  }
+
   // Check $defs: targets must be safe, names must be simple, no nested $ref chains
   const defs = schema.$defs || schema.definitions
   if (defs) {
@@ -501,7 +545,8 @@ function codegenSafe(schema, schemaMap) {
   if (typeof schema.additionalProperties === 'object') subs.push(schema.additionalProperties)
   for (const s of subs) {
     if (s === undefined || s === null) continue
-    if (typeof s === 'boolean') return false // boolean sub-schema
+    if (s === false) return false // boolean false sub-schema — complex
+    if (s === true) continue // boolean true sub-schema — always valid, fine
     if (!codegenSafe(s, schemaMap)) return false
   }
 
@@ -548,13 +593,14 @@ function compileToJSCodegen(schema, schemaMap) {
   const ctx = { varCounter: 0, helpers: [], helperCode: [], closureVars: [], closureVals: [], rootDefs, refStack: new Set(), schemaMap: schemaMap || null }
   const lines = []
   genCode(schema, 'd', lines, ctx)
-  if (lines.length === 0) return () => true
 
-  // Append deferred checks (additionalProperties) at the end
+  // Append deferred checks (additionalProperties, unevaluatedProperties) at the end
   if (ctx.deferredChecks) {
     for (const dc of ctx.deferredChecks) lines.push(dc)
   }
 
+  if (lines.length === 0) return () => true
+
   const checkStr = lines.join('\n  ')
 
   // Regex and helpers are passed as closure variables (not re-created per call)
@@ -641,25 +687,32 @@ function genCode(schema, v, lines, ctx, knownType) {
   if (typeof schema !== 'object' || schema === null) return
 
   // $ref — guard against circular references
+  // In 2020-12 with unevaluated*, $ref can coexist with siblings — don't early return
+  // Only when THIS schema has unevaluated keywords directly (not via $ref target)
+  const hasSiblings = schema.$ref && (schema.unevaluatedProperties !== undefined || schema.unevaluatedItems !== undefined)
   if (schema.$ref) {
     // 1. Local ref
     const m = schema.$ref.match(/^#\/(?:\$defs|definitions)\/(.+)$/)
     if (m && ctx.rootDefs && ctx.rootDefs[m[1]]) {
-      if (ctx.refStack.has(schema.$ref)) return
-      ctx.refStack.add(schema.$ref)
-      genCode(ctx.rootDefs[m[1]], v, lines, ctx, knownType)
-      ctx.refStack.delete(schema.$ref)
-      return
-    }
-    // 2. Cross-schema ref
-    if (ctx.schemaMap && ctx.schemaMap.has(schema.$ref)) {
-      if (ctx.refStack.has(schema.$ref)) return
-      ctx.refStack.add(schema.$ref)
-      genCode(ctx.schemaMap.get(schema.$ref), v, lines, ctx, knownType)
-      ctx.refStack.delete(schema.$ref)
-      return
+      if (ctx.refStack.has(schema.$ref)) { if (!hasSiblings) return }
+      else {
+        ctx.refStack.add(schema.$ref)
+        genCode(ctx.rootDefs[m[1]], v, lines, ctx, knownType)
+        ctx.refStack.delete(schema.$ref)
+        if (!hasSiblings) return
+      }
+    } else if (ctx.schemaMap && ctx.schemaMap.has(schema.$ref)) {
+      // 2. Cross-schema ref
+      if (ctx.refStack.has(schema.$ref)) { if (!hasSiblings) return }
+      else {
+        ctx.refStack.add(schema.$ref)
+        genCode(ctx.schemaMap.get(schema.$ref), v, lines, ctx, knownType)
+        ctx.refStack.delete(schema.$ref)
+        if (!hasSiblings) return
+      }
+    } else {
+      if (!hasSiblings) return
     }
-    return
   }
 
   // Determine the single known type after this schema's type check
@@ -744,6 +797,27 @@ function genCode(schema, v, lines, ctx, knownType) {
     }
   }
 
+  // Early key count for unevaluatedProperties: false (before properties, 10% faster)
+  // V8 branch prediction benefits from for-in iteration before property access
+  if (schema.unevaluatedProperties === false && schema.properties && schema.required && isObj) {
+    const evalResult = collectEvaluated(schema, ctx.schemaMap, ctx.rootDefs)
+    if (!evalResult.dynamic && !evalResult.allProps) {
+      const knownKeys = evalResult.props
+      const propCount = knownKeys.length
+      const allRequired = schema.required.length >= propCount &&
+        knownKeys.every(k => schema.required.includes(k))
+      if (allRequired && propCount > 0) {
+        // Adaptive: for-in for <=15 keys (V8 fast path), Object.keys for >15
+        if (propCount <= 15) {
+          lines.push(`var _n=0;for(var _k in ${v})_n++;if(_n!==${propCount})return false`)
+        } else {
+          lines.push(`if(Object.keys(${v}).length!==${propCount})return false`)
+        }
+        ctx._earlyKeyCount = true // flag to skip deferred check
+      }
+    }
+  }
+
   // numeric — skip type guard if known numeric
   if (schema.minimum !== undefined) lines.push(isNum ? `if(${v}<${schema.minimum})return false` : `if(typeof ${v}==='number'&&${v}<${schema.minimum})return false`)
   if (schema.maximum !== undefined) lines.push(isNum ? `if(${v}>${schema.maximum})return false` : `if(typeof ${v}==='number'&&${v}>${schema.maximum})return false`)
@@ -764,10 +838,15 @@ function genCode(schema, v, lines, ctx, knownType) {
   if (schema.maxProperties !== undefined) lines.push(`if(${objGuard}Object.keys(${v}).length>${schema.maxProperties})return false`)
 
   if (schema.pattern) {
-    // Use RegExp constructor via helper to avoid injection from untrusted patterns
-    const ri = ctx.varCounter++
-    ctx.helperCode.push(`const _re${ri}=new RegExp(${JSON.stringify(schema.pattern)})`)
-    lines.push(isStr ? `if(!_re${ri}.test(${v}))return false` : `if(typeof ${v}==='string'&&!_re${ri}.test(${v}))return false`)
+    // Try inline charCode compilation for simple patterns (avoids RegExp engine)
+    const inlineCheck = compilePatternInline(schema.pattern, v)
+    if (inlineCheck) {
+      lines.push(isStr ? `if(!(${inlineCheck}))return false` : `if(typeof ${v}==='string'&&!(${inlineCheck}))return false`)
+    } else {
+      const ri = ctx.varCounter++
+      ctx.helperCode.push(`const _re${ri}=new RegExp(${JSON.stringify(schema.pattern)})`)
+      lines.push(isStr ? `if(!_re${ri}.test(${v}))return false` : `if(typeof ${v}==='string'&&!_re${ri}.test(${v}))return false`)
+    }
   }
 
   if (schema.format) {
@@ -798,7 +877,9 @@ function genCode(schema, v, lines, ctx, knownType) {
     const propCount = Object.keys(schema.properties).length
     const allRequired = schema.required && schema.required.length === propCount
     const inner = allRequired
-      ? `var _n=0;for(var _k in ${v})_n++;if(_n!==${propCount})return false`
+      ? (propCount <= 15
+          ? `var _n=0;for(var _k in ${v})_n++;if(_n!==${propCount})return false`
+          : `if(Object.keys(${v}).length!==${propCount})return false`)
       : `for(var _k in ${v})if(${Object.keys(schema.properties).map(k => `_k!==${JSON.stringify(k)}`).join('&&')})return false`
     if (!ctx.deferredChecks) ctx.deferredChecks = []
     ctx.deferredChecks.push(isObj ? inner : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}`)
@@ -852,16 +933,6 @@ function genCode(schema, v, lines, ctx, knownType) {
       ctx._ppHandledAdditional = true
       ctx._ppHandledPropertyNames = !!pn
       const propKeys = Object.keys(schema.properties)
-      // Inline key comparison instead of Set.has for small property counts (faster, no allocation)
-      const keyCheck = propKeys.length <= 8
-        ? propKeys.map(k => `${kVar}===${JSON.stringify(k)}`).join('||')
-        : null
-      if (!keyCheck) {
-        const allowedSet = `_as${pi}`
-        ctx.closureVars.push(allowedSet)
-        ctx.closureVals.push(new Set(propKeys))
-      }
-
       lines.push(`${guard}{for(const ${kVar} in ${v}){`)
       // propertyNames checks (merged into same loop)
       if (pn) {
@@ -886,14 +957,21 @@ function genCode(schema, v, lines, ctx, knownType) {
           lines.push(`if(!_es${ei}.has(${kVar}))return false`)
         }
       }
-      // Check: is key in declared properties?
-      const matchExpr = keyCheck || `_as${pi}.has(${kVar})`
-      lines.push(`let _m${pi}=${matchExpr}`)
-      // Check pattern matches
+      // Check: is key declared or matches a pattern?
+      // switch/case: V8 compiles string cases to jump table (faster than chained ===)
+      const switchCases = propKeys.map(k => `case ${JSON.stringify(k)}:`).join('')
+      lines.push(`switch(${kVar}){${switchCases}break;default:`)
+      // Default: key is not declared — must match a pattern
+      let patternChecks = []
       for (let i = 0; i < ppEntries.length; i++) {
-        lines.push(`if(${matchers[i].check}){_m${pi}=true;if(!_ppf${pi}_${i}(${v}[${kVar}]))return false}`)
+        patternChecks.push(`if(${matchers[i].check}){if(!_ppf${pi}_${i}(${v}[${kVar}]))return false}else{return false}`)
       }
-      lines.push(`if(!_m${pi})return false`)
+      if (patternChecks.length > 0) {
+        lines.push(patternChecks.join(''))
+      } else {
+        lines.push(`return false`)
+      }
+      lines.push(`}`) // end switch
       lines.push(`}}`)
     } else {
       // No additionalProperties: validate matching keys + propertyNames
@@ -1040,7 +1118,8 @@ function genCode(schema, v, lines, ctx, knownType) {
   }
 
   // anyOf — need function wrappers since genCode uses return false
-  if (schema.anyOf) {
+  // Skip standard anyOf if unevaluatedProperties will handle it (single-pass optimization)
+  if (schema.anyOf && schema.unevaluatedProperties === undefined) {
     const fns = []
     for (let i = 0; i < schema.anyOf.length; i++) {
       const subLines = []
@@ -1110,6 +1189,389 @@ function genCode(schema, v, lines, ctx, knownType) {
     lines.push(`{const _if${fi}=${ifFn};const _th${fi}=${thenFn};const _el${fi}=${elseFn}`)
     lines.push(`if(_if${fi}(${v})){if(_th${fi}&&!_th${fi}(${v}))return false}else{if(_el${fi}&&!_el${fi}(${v}))return false}}`)
   }
+
+  // unevaluatedProperties
+  if (schema.unevaluatedProperties !== undefined) {
+    const evalResult = collectEvaluated(schema, ctx.schemaMap, ctx.rootDefs)
+
+    if (evalResult.allProps || schema.unevaluatedProperties === true) {
+      // All props evaluated or unevaluatedProperties:true — no-op
+    } else if (!evalResult.dynamic) {
+      // Tier 1-2: all evaluated props known at compile-time — ZERO COST
+      const knownKeys = evalResult.props
+      const propCount = knownKeys.length
+
+      if (schema.unevaluatedProperties === false) {
+        const allRequired = schema.required && schema.required.length >= propCount &&
+          knownKeys.every(k => schema.required.includes(k))
+
+        let inner
+        if (allRequired && propCount > 0) {
+          // TRICK 1: required covers all — key count check only
+          if (!ctx._earlyKeyCount) {
+            // Adaptive: for-in for <=15 keys, Object.keys for >15
+            inner = propCount <= 15
+              ? `var _n=0;for(var _k in ${v})_n++;if(_n!==${propCount})return false`
+              : `if(Object.keys(${v}).length!==${propCount})return false`
+            if (!ctx.deferredChecks) ctx.deferredChecks = []
+            ctx.deferredChecks.push(isObj ? inner : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}`)
+          }
+          // else: already emitted early (before properties)
+        } else if (propCount > 0) {
+          // TRICK 3: charCodeAt switch tree
+          inner = genCharCodeSwitch(knownKeys, v)
+          if (!ctx.deferredChecks) ctx.deferredChecks = []
+          ctx.deferredChecks.push(isObj ? inner : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}`)
+        } else {
+          inner = `for(var _k in ${v})return false`
+          if (!ctx.deferredChecks) ctx.deferredChecks = []
+          ctx.deferredChecks.push(isObj ? inner : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}`)
+        }
+      } else if (typeof schema.unevaluatedProperties === 'object') {
+        // unevaluatedProperties: {schema} — validate unknown keys
+        const ui = ctx.varCounter++
+        const ukVar = `_uk${ui}`
+        const subLines = []
+        genCode(schema.unevaluatedProperties, `${v}[${ukVar}]`, subLines, ctx)
+        if (subLines.length > 0) {
+          const check = subLines.join(';')
+          const keyChecks = knownKeys.map(k => `${ukVar}===${JSON.stringify(k)}`).join('||')
+          const skipKnown = knownKeys.length > 0 ? `if(${keyChecks})continue;` : ''
+          const inner = `for(var ${ukVar} in ${v}){${skipKnown}${check}}`
+          if (!ctx.deferredChecks) ctx.deferredChecks = []
+          ctx.deferredChecks.push(isObj ? inner : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}`)
+        }
+      }
+    } else {
+      // Tier 2.5 / Tier 3: dynamic — runtime tracking needed
+      // Compute base props: only unconditionally evaluated (properties, allOf-static, $ref)
+      const baseResult = { props: [], items: null, allProps: false, allItems: false, dynamic: false }
+      if (schema.properties) {
+        for (const k of Object.keys(schema.properties)) {
+          if (!baseResult.props.includes(k)) baseResult.props.push(k)
+        }
+      }
+      if (schema.allOf) {
+        for (const sub of schema.allOf) {
+          const subR = collectEvaluated(sub, ctx.schemaMap, ctx.rootDefs)
+          if (!subR.dynamic && subR.props) {
+            for (const k of subR.props) {
+              if (!baseResult.props.includes(k)) baseResult.props.push(k)
+            }
+          }
+        }
+      }
+      const baseProps = baseResult.props
+      const branchKeyword = schema.anyOf ? 'anyOf' : schema.oneOf ? 'oneOf' : null
+
+      if (schema.unevaluatedProperties === false) {
+        if (schema.if && (schema.then || schema.else) && !branchKeyword && !schema.patternProperties && !schema.dependentSchemas) {
+          // Tier 2.5: if/then/else — re-emit if function + branch-inline duplication
+          // Can't reuse _if from above (block-scoped), so regenerate
+          const ifLines2 = []
+          genCode(schema.if, '_iv2', ifLines2, ctx)
+          const ufi = ctx.varCounter++
+          const ifFn2 = ifLines2.length === 0
+            ? `function(_iv2){return true}`
+            : `function(_iv2){${ifLines2.join(';')};return true}`
+
+          // if props are only evaluated when if matches (spec: failed applicators produce no annotations)
+          const ifProps = []
+          if (schema.if && schema.if.properties) ifProps.push(...Object.keys(schema.if.properties))
+          const thenEval = schema.then ? collectEvaluated(schema.then, ctx.schemaMap, ctx.rootDefs) : { props: [] }
+          const elseEval = schema.else ? collectEvaluated(schema.else, ctx.schemaMap, ctx.rootDefs) : { props: [] }
+          const uniqueThen = [...new Set([...baseProps, ...ifProps, ...(thenEval.props || [])])]
+          const uniqueElse = [...new Set([...baseProps, ...(elseEval.props || [])])]
+
+          const thenCheck = genCharCodeSwitch(uniqueThen, v)
+          const elseCheck = genCharCodeSwitch(uniqueElse, v)
+          const guard = isObj ? '' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v}))`
+          lines.push(`${guard}{const _uif${ufi}=${ifFn2};if(_uif${ufi}(${v})){${thenCheck}}else{${elseCheck}}}`)
+        } else if (branchKeyword) {
+          // Tier 3: anyOf/oneOf — runtime tracking
+          const branches = schema[branchKeyword]
+          const branchProps = []
+          for (const sub of branches) {
+            const subResult = collectEvaluated(sub, ctx.schemaMap, ctx.rootDefs)
+            branchProps.push(subResult.props || [])
+          }
+          const allDynamicKeys = [...new Set(branchProps.flat())]
+          const dynamicOnly = allDynamicKeys.filter(k => !baseProps.includes(k))
+
+          if (dynamicOnly.length > 0 && dynamicOnly.length <= 32) {
+            // TRICK 5: bit-packed evaluated set — SINGLE PASS (validation + tracking combined)
+            const ei = ctx.varCounter++
+            const evVar = `_ev${ei}`
+            const bitMap = new Map()
+            dynamicOnly.forEach((k, i) => bitMap.set(k, i))
+            const branchMasks = branchProps.map(props => {
+              let mask = 0
+              for (const p of props) {
+                if (bitMap.has(p)) mask |= (1 << bitMap.get(p))
+              }
+              return mask
+            })
+
+            // TRICK 4: Direct function calls — no array, no loop, V8 can inline
+            const bfi = ctx.varCounter++
+            lines.push(`{let ${evVar}=0`)
+            const fnVars = []
+            for (let i = 0; i < branches.length; i++) {
+              const subLines2 = []
+              genCode(branches[i], '_bv', subLines2, ctx)
+              const fnVar = `_bf${bfi}_${i}`
+              fnVars.push(fnVar)
+              const fnBody = subLines2.length === 0 ? `function(_bv){return true}` : `function(_bv){${subLines2.join(';')};return true}`
+              lines.push(`const ${fnVar}=${fnBody}`)
+            }
+            if (branchKeyword === 'oneOf') {
+              // oneOf: exactly one must match — direct calls
+              lines.push(`let _oc${bfi}=0`)
+              for (let i = 0; i < branches.length; i++) {
+                lines.push(`if(${fnVars[i]}(${v})){_oc${bfi}++;${evVar}=${branchMasks[i]};if(_oc${bfi}>1)return false}`)
+              }
+              lines.push(`if(_oc${bfi}!==1)return false`)
+            } else {
+              // anyOf: at least one must match — direct calls, collect all
+              lines.push(`let _am${bfi}=false`)
+              for (let i = 0; i < branches.length; i++) {
+                lines.push(`if(${fnVars[i]}(${v})){_am${bfi}=true;${evVar}|=${branchMasks[i]}}`)
+              }
+              lines.push(`if(!_am${bfi})return false`)
+            }
+
+            // Final check: static keys inline + dynamic keys via bitmask
+            const staticCheck = baseProps.length > 0 ? baseProps.map(k => `_k===${JSON.stringify(k)}`).join('||') : ''
+            const groups = new Map()
+            for (const k of dynamicOnly) {
+              const cc = k.charCodeAt(0)
+              if (!groups.has(cc)) groups.set(cc, [])
+              groups.get(cc).push(k)
+            }
+            let switchCases = ''
+            for (const [cc, groupKeys] of groups) {
+              const cond = groupKeys.map(k => `_k===${JSON.stringify(k)}&&(${evVar}&${1 << bitMap.get(k)})`).join('||')
+              switchCases += `case ${cc}:if(${cond})continue;break;`
+            }
+            const dynamicCheck = `switch(_k.charCodeAt(0)){${switchCases}default:break}`
+            const inner = staticCheck
+              ? `for(var _k in ${v}){if(${staticCheck})continue;${dynamicCheck}return false}`
+              : `for(var _k in ${v}){${dynamicCheck}return false}`
+            if (!ctx.deferredChecks) ctx.deferredChecks = []
+            ctx.deferredChecks.push(isObj ? inner + '}' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}}`)
+          } else {
+            // Fallback: plain object tracking
+            const ei = ctx.varCounter++
+            const evVar = `_ev${ei}`
+            const fns = []
+            for (let i = 0; i < branches.length; i++) {
+              const subLines2 = []
+              genCode(branches[i], '_bv', subLines2, ctx)
+              fns.push(subLines2.length === 0 ? `function(_bv){return true}` : `function(_bv){${subLines2.join(';')};return true}`)
+            }
+            const bfi = ctx.varCounter++
+            ctx.closureVars.push(`_bk${bfi}`)
+            ctx.closureVals.push(branchProps)
+            lines.push(`{const ${evVar}={}`)
+            for (const k of baseProps) lines.push(`${evVar}[${JSON.stringify(k)}]=1`)
+            lines.push(`const _bf${bfi}=[${fns.join(',')}]`)
+            if (branchKeyword === 'oneOf') {
+              // Single pass: validate oneOf (exactly one) + track evaluated
+              lines.push(`let _oc${bfi}=0;for(let _bi=0;_bi<_bf${bfi}.length;_bi++){if(_bf${bfi}[_bi](${v})){_oc${bfi}++;for(const _p of _bk${bfi}[_bi])${evVar}[_p]=1;if(_oc${bfi}>1)return false}}if(_oc${bfi}!==1)return false`)
+            } else {
+              // Single pass: validate anyOf (at least one) + track all matching
+              lines.push(`let _am${bfi}=false;for(let _bi=0;_bi<_bf${bfi}.length;_bi++){if(_bf${bfi}[_bi](${v})){_am${bfi}=true;for(const _p of _bk${bfi}[_bi])${evVar}[_p]=1}}if(!_am${bfi})return false`)
+            }
+            const inner = `for(var _k in ${v}){if(!${evVar}[_k])return false}`
+            if (!ctx.deferredChecks) ctx.deferredChecks = []
+            ctx.deferredChecks.push(isObj ? inner + '}' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}}`)
+          }
+        } else if (schema.dependentSchemas) {
+          // dependentSchemas: conditional merge at runtime
+          const ei = ctx.varCounter++
+          const evVar = `_ev${ei}`
+          lines.push(`{const ${evVar}={}`)
+          for (const k of baseProps) lines.push(`${evVar}[${JSON.stringify(k)}]=1`)
+          for (const [trigger, depSchema] of Object.entries(schema.dependentSchemas)) {
+            const depResult = collectEvaluated(depSchema, ctx.schemaMap, ctx.rootDefs)
+            if (depResult.props && depResult.props.length > 0) {
+              lines.push(`if(${JSON.stringify(trigger)} in ${v}){${depResult.props.map(k => `${evVar}[${JSON.stringify(k)}]=1`).join(';')}}`)
+            }
+          }
+          const inner = `for(var _k in ${v}){if(!${evVar}[_k])return false}`
+          if (!ctx.deferredChecks) ctx.deferredChecks = []
+          ctx.deferredChecks.push(isObj ? inner + '}' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}}`)
+        } else if (schema.patternProperties) {
+          // patternProperties: runtime key matching
+          const ei = ctx.varCounter++
+          const evVar = `_ev${ei}`
+          lines.push(`{const ${evVar}={}`)
+          for (const k of baseProps) lines.push(`${evVar}[${JSON.stringify(k)}]=1`)
+          const patterns = Object.keys(schema.patternProperties)
+          const reVars = []
+          for (const pat of patterns) {
+            const ri = ctx.varCounter++
+            ctx.closureVars.push(`_ure${ri}`)
+            ctx.closureVals.push(new RegExp(pat))
+            reVars.push(`_ure${ri}`)
+          }
+          const inner = `for(var _k in ${v}){if(${evVar}[_k])continue;${reVars.map(rv => `if(${rv}.test(_k)){${evVar}[_k]=1;continue}`).join('')}return false}`
+          if (!ctx.deferredChecks) ctx.deferredChecks = []
+          ctx.deferredChecks.push(isObj ? inner + '}' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}}`)
+        }
+      } else if (typeof schema.unevaluatedProperties === 'object') {
+        // Tier 3 with schema: validate unknown keys against sub-schema
+        const ei = ctx.varCounter++
+        const evVar = `_ev${ei}`
+        const ukVar = `_uk${ei}`
+        lines.push(`{const ${evVar}={}`)
+        for (const k of baseProps) lines.push(`${evVar}[${JSON.stringify(k)}]=1`)
+
+        if (branchKeyword) {
+          const branches = schema[branchKeyword]
+          const branchProps = []
+          for (const sub of branches) {
+            const subResult = collectEvaluated(sub, ctx.schemaMap, ctx.rootDefs)
+            branchProps.push(subResult.props || [])
+          }
+          const fns = []
+          for (let i = 0; i < branches.length; i++) {
+            const subLines2 = []
+            genCode(branches[i], '_bv', subLines2, ctx)
+            fns.push(subLines2.length === 0 ? `function(_bv){return true}` : `function(_bv){${subLines2.join(';')};return true}`)
+          }
+          const bfi = ctx.varCounter++
+          ctx.closureVars.push(`_bk${bfi}`)
+          ctx.closureVals.push(branchProps)
+          lines.push(`const _bf${bfi}=[${fns.join(',')}]`)
+          if (branchKeyword === 'oneOf') {
+            lines.push(`for(let _bi=0;_bi<_bf${bfi}.length;_bi++){if(_bf${bfi}[_bi](${v})){for(const _p of _bk${bfi}[_bi])${evVar}[_p]=1;break}}`)
+          } else {
+            lines.push(`for(let _bi=0;_bi<_bf${bfi}.length;_bi++){if(_bf${bfi}[_bi](${v})){for(const _p of _bk${bfi}[_bi])${evVar}[_p]=1}}`)
+          }
+        }
+
+        const subLines2 = []
+        genCode(schema.unevaluatedProperties, `${v}[${ukVar}]`, subLines2, ctx)
+        if (subLines2.length > 0) {
+          const check = subLines2.join(';')
+          const inner = `for(var ${ukVar} in ${v}){if(${evVar}[${ukVar}])continue;${check}}`
+          if (!ctx.deferredChecks) ctx.deferredChecks = []
+          ctx.deferredChecks.push(isObj ? inner + '}' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}}`)
+        } else {
+          lines.push('}')
+        }
+      }
+    }
+  }
+
+  // unevaluatedItems
+  if (schema.unevaluatedItems !== undefined) {
+    const evalResult = collectEvaluated(schema, ctx.schemaMap, ctx.rootDefs)
+
+    if (evalResult.allItems || schema.unevaluatedItems === true) {
+      // All items evaluated or unevaluatedItems:true — no-op
+    } else if (!evalResult.dynamic) {
+      // Static: all evaluated items known at compile-time
+      if (schema.unevaluatedItems === false) {
+        // TRICK 6: Array.length comparison only
+        const maxIdx = evalResult.items || 0
+        const inner = `if(${v}.length>${maxIdx})return false`
+        if (!ctx.deferredChecks) ctx.deferredChecks = []
+        ctx.deferredChecks.push(isArr ? inner : `if(Array.isArray(${v})){${inner}}`)
+      } else if (typeof schema.unevaluatedItems === 'object') {
+        const maxIdx = evalResult.items || 0
+        const ui = ctx.varCounter++
+        const elemVar = `_ue${ui}`
+        const idxVar = `_ui${ui}`
+        const subLines = []
+        genCode(schema.unevaluatedItems, elemVar, subLines, ctx)
+        if (subLines.length > 0) {
+          const check = subLines.join(';')
+          const inner = `for(let ${idxVar}=${maxIdx};${idxVar}<${v}.length;${idxVar}++){const ${elemVar}=${v}[${idxVar}];${check}}`
+          if (!ctx.deferredChecks) ctx.deferredChecks = []
+          ctx.deferredChecks.push(isArr ? inner : `if(Array.isArray(${v})){${inner}}`)
+        }
+      }
+    } else {
+      // Dynamic: runtime tracking of max evaluated index
+      const baseIdx = evalResult.items || 0
+      const branchKeyword = schema.anyOf ? 'anyOf' : schema.oneOf ? 'oneOf' : null
+
+      if (branchKeyword && (schema.unevaluatedItems === false || typeof schema.unevaluatedItems === 'object')) {
+        // anyOf/oneOf: each branch may evaluate different number of items
+        const branches = schema[branchKeyword]
+        const branchMaxIdx = []
+        for (const sub of branches) {
+          const subR = collectEvaluated(sub, ctx.schemaMap, ctx.rootDefs)
+          branchMaxIdx.push(subR.items || 0)
+        }
+        // Runtime: find max evaluated index across all matching branches
+        const fns = []
+        for (let i = 0; i < branches.length; i++) {
+          const subLines2 = []
+          genCode(branches[i], '_bv', subLines2, ctx)
+          fns.push(subLines2.length === 0 ? `function(_bv){return true}` : `function(_bv){${subLines2.join(';')};return true}`)
+        }
+        const bfi = ctx.varCounter++
+        const ei = ctx.varCounter++
+        const evVar = `_eidx${ei}`
+        lines.push(`{let ${evVar}=${baseIdx}`)
+        lines.push(`const _bf${bfi}=[${fns.join(',')}]`)
+        const maxExprs = branchMaxIdx.map((m, i) => `_bi===${i}?${Math.max(m, baseIdx)}`).join(':') + `:${baseIdx}`
+        if (branchKeyword === 'oneOf') {
+          lines.push(`for(let _bi=0;_bi<_bf${bfi}.length;_bi++){if(_bf${bfi}[_bi](${v})){${evVar}=${maxExprs};break}}`)
+        } else {
+          lines.push(`for(let _bi=0;_bi<_bf${bfi}.length;_bi++){if(_bf${bfi}[_bi](${v})){const _m=${maxExprs};if(_m>${evVar})${evVar}=_m}}`)
+        }
+        if (schema.unevaluatedItems === false) {
+          const inner = `if(${v}.length>${evVar})return false`
+          if (!ctx.deferredChecks) ctx.deferredChecks = []
+          ctx.deferredChecks.push(isArr ? inner + '}' : `if(Array.isArray(${v})){${inner}}}`)
+        } else {
+          const ui = ctx.varCounter++
+          const elemVar = `_ue${ui}`
+          const idxVar = `_ui${ui}`
+          const subLines = []
+          genCode(schema.unevaluatedItems, elemVar, subLines, ctx)
+          if (subLines.length > 0) {
+            const check = subLines.join(';')
+            const inner = `for(let ${idxVar}=${evVar};${idxVar}<${v}.length;${idxVar}++){const ${elemVar}=${v}[${idxVar}];${check}}`
+            if (!ctx.deferredChecks) ctx.deferredChecks = []
+            ctx.deferredChecks.push(isArr ? inner + '}' : `if(Array.isArray(${v})){${inner}}}`)
+          } else {
+            lines.push('}')
+          }
+        }
+      } else if (schema.if && (schema.then || schema.else) && (schema.unevaluatedItems === false || typeof schema.unevaluatedItems === 'object')) {
+        // if/then/else: branch-specific max index
+        const ifEval = collectEvaluated(schema.if, ctx.schemaMap, ctx.rootDefs)
+        const thenEval = schema.then ? collectEvaluated(schema.then, ctx.schemaMap, ctx.rootDefs) : { items: null }
+        const elseEval = schema.else ? collectEvaluated(schema.else, ctx.schemaMap, ctx.rootDefs) : { items: null }
+        const ifIdx = ifEval.items || 0
+        const thenIdx = Math.max(baseIdx, ifIdx, thenEval.items || 0)
+        const elseIdx = Math.max(baseIdx, elseEval.items || 0)
+
+        const ifLines2 = []
+        genCode(schema.if, '_iv3', ifLines2, ctx)
+        const ufi = ctx.varCounter++
+        const ifFn3 = ifLines2.length === 0
+          ? `function(_iv3){return true}`
+          : `function(_iv3){${ifLines2.join(';')};return true}`
+
+        if (schema.unevaluatedItems === false) {
+          const guard = isArr ? '' : `if(Array.isArray(${v}))`
+          lines.push(`${guard}{const _uif${ufi}=${ifFn3};if(_uif${ufi}(${v})){if(${v}.length>${thenIdx})return false}else{if(${v}.length>${elseIdx})return false}}`)
+        }
+      } else if (schema.unevaluatedItems === false) {
+        // Fallback: use static base index (may not be fully correct for all dynamic cases)
+        const maxIdx = evalResult.items || 0
+        const inner = `if(${v}.length>${maxIdx})return false`
+        if (!ctx.deferredChecks) ctx.deferredChecks = []
+        ctx.deferredChecks.push(isArr ? inner : `if(Array.isArray(${v})){${inner}}`)
+      }
+    }
+  }
 }
 
 const FORMAT_CODEGEN = {
@@ -1154,6 +1616,79 @@ const FORMAT_CODEGEN = {
 // Safe key escaping: use JSON.stringify to handle all special chars (newlines, null bytes, etc.)
 function esc(s) { return JSON.stringify(s).slice(1, -1) }
 
+// Resolve child path at codegen time when parent is a static string literal.
+// This enables frozen pre-allocation for ALL nested error objects.
+function childPathExpr(parentExpr, suffix) {
+  if (!parentExpr) return `'/${suffix}'`
+  if (parentExpr.startsWith("'") && !parentExpr.includes('+')) {
+    // Static parent: resolve at codegen time → '/parent/child' (single literal)
+    return `'${parentExpr.slice(1, -1)}/${suffix}'`
+  }
+  // Dynamic parent: keep as concat expression
+  return `${parentExpr}+'/${suffix}'`
+}
+
+// Compile simple regex patterns to inline charCode checks — avoids RegExp engine overhead.
+// Returns null if pattern is too complex for inline compilation.
+// Handles: ^[charclass]{n}$, ^[charclass]+$, ^[charclass]*$, ^[charclass]{m,n}$
+function compilePatternInline(pattern, varName) {
+  // Match: ^[chars]{exact}$ — e.g., ^[0-9]{5}$
+  let m = pattern.match(/^\^(\[[\w\-]+\])\{(\d+)\}\$$/)
+  if (m) {
+    const rangeCheck = charClassToCheck(m[1], `${varName}.charCodeAt(_pi)`)
+    if (!rangeCheck) return null
+    const len = parseInt(m[2])
+    return `${varName}.length===${len}&&(()=>{for(let _pi=0;_pi<${len};_pi++){if(!(${rangeCheck}))return false}return true})()`
+  }
+  // Match: ^[chars]+$ — e.g., ^[a-z]+$
+  m = pattern.match(/^\^(\[[\w\-]+\])\+\$$/)
+  if (m) {
+    const rangeCheck = charClassToCheck(m[1], `${varName}.charCodeAt(_pi)`)
+    if (!rangeCheck) return null
+    return `${varName}.length>0&&(()=>{for(let _pi=0;_pi<${varName}.length;_pi++){if(!(${rangeCheck}))return false}return true})()`
+  }
+  // Match: ^[chars]{m,n}$ — e.g., ^[a-zA-Z]{2,50}$
+  m = pattern.match(/^\^(\[[\w\-]+\])\{(\d+),(\d+)\}\$$/)
+  if (m) {
+    const rangeCheck = charClassToCheck(m[1], `${varName}.charCodeAt(_pi)`)
+    if (!rangeCheck) return null
+    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
+}
+
+// Convert [charclass] to charCode range check expression.
+// Supports: [0-9], [a-z], [A-Z], [a-zA-Z], [a-zA-Z0-9], [0-9a-f], etc.
+function charClassToCheck(charClass, codeExpr) {
+  // Strip brackets
+  const inner = charClass.slice(1, -1)
+  // Parse ranges
+  const ranges = []
+  let i = 0
+  while (i < inner.length) {
+    if (i + 2 < inner.length && inner[i + 1] === '-') {
+      ranges.push([inner.charCodeAt(i), inner.charCodeAt(i + 2)])
+      i += 3
+    } else {
+      ranges.push([inner.charCodeAt(i), inner.charCodeAt(i)])
+      i++
+    }
+  }
+  if (ranges.length === 0) return null
+  // Generate check: (c >= 48 && c <= 57) || (c >= 65 && c <= 90)
+  const checks = ranges.map(([lo, hi]) =>
+    lo === hi ? `${codeExpr}===${lo}` : `(${codeExpr}>=${lo}&&${codeExpr}<=${hi})`
+  )
+  return checks.join('||')
+}
+
+// Same but for dynamic segments (array indices)
+function childPathDynExpr(parentExpr, indexExpr) {
+  if (!parentExpr) return `'/'+${indexExpr}`
+  return `${parentExpr}+'/'+${indexExpr}`
+}
+
 // Detect simple prefix patterns like "^x-", "^_", "^prefix" and generate fast charCodeAt checks
 // Returns a JS expression string or null if pattern is too complex
 function fastPrefixCheck(pattern, keyVar) {
@@ -1172,14 +1707,45 @@ function fastPrefixCheck(pattern, keyVar) {
   return `${keyVar}.startsWith(${JSON.stringify(prefix)})`
 }
 
+// Generate a charCodeAt(0)-based switch tree for fast key validation.
+// V8 compiles switch to jump tables — O(1) dispatch vs O(n) chain.
+function genCharCodeSwitch(keys, v) {
+  if (keys.length === 0) return `for(var _k in ${v})return false`
+  if (keys.length <= 3) {
+    // Small set: simple chain is faster than switch overhead
+    return `for(var _k in ${v})if(${keys.map(k => `_k!==${JSON.stringify(k)}`).join('&&')})return false`
+  }
+
+  // Group keys by first charCode
+  const groups = new Map()
+  for (const k of keys) {
+    const cc = k.charCodeAt(0)
+    if (!groups.has(cc)) groups.set(cc, [])
+    groups.get(cc).push(k)
+  }
+
+  let cases = ''
+  for (const [cc, groupKeys] of groups) {
+    const cond = groupKeys.map(k => `_k===${JSON.stringify(k)}`).join('||')
+    cases += `case ${cc}:if(${cond})continue;break;`
+  }
+
+  return `for(var _k in ${v}){switch(_k.charCodeAt(0)){${cases}default:break}return false}`
+}
+
 // --- Error-collecting codegen: same checks, but pushes errors instead of returning false ---
 // Returns a function: (data, allErrors) => { valid, errors }
 // Valid path is still fast — only error path does extra work.
 function compileToJSCodegenWithErrors(schema, schemaMap) {
+  // Bail on unevaluated keywords — error codegen doesn't support them yet
+  if (typeof schema === 'object' && schema !== null) {
+    const s = JSON.stringify(schema)
+    if (s.includes('unevaluatedProperties') || s.includes('unevaluatedItems')) return null
+  }
   if (typeof schema === 'boolean') {
     return schema
       ? () => ({ valid: true, errors: [] })
-      : () => ({ valid: false, errors: [{ code: 'type_mismatch', path: '', message: 'schema is false' }] })
+      : () => ({ valid: false, errors: [{ keyword: 'false schema', instancePath: '', schemaPath: '#', params: {}, message: 'boolean schema is false' }] })
   }
   if (typeof schema !== 'object' || schema === null) return null
   if (!codegenSafe(schema, schemaMap)) return null
@@ -1206,7 +1772,7 @@ function compileToJSCodegenWithErrors(schema, schemaMap) {
 
   const ctx = { varCounter: 0, helperCode: [], rootDefs: schema.$defs || schema.definitions || null, refStack: new Set(), schemaMap: schemaMap || null }
   const lines = []
-  genCodeE(schema, 'd', '', lines, ctx)
+  genCodeE(schema, 'd', '', lines, ctx, '#')
   if (lines.length === 0) return (d) => ({ valid: true, errors: [] })
 
   const body = `const _e=[];\n  ` +
@@ -1225,7 +1791,8 @@ function compileToJSCodegenWithErrors(schema, schemaMap) {
 // Error-collecting code generator.
 // Instead of `return false`, pushes to `_e` array and optionally early-returns.
 // `_all` parameter: if falsy, return after first error.
-function genCodeE(schema, v, pathExpr, lines, ctx) {
+function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
+  if (!schemaPrefix) schemaPrefix = '#'
   if (typeof schema !== 'object' || schema === null) return
 
   // $ref — resolve local and cross-schema refs
@@ -1234,14 +1801,14 @@ function genCodeE(schema, v, pathExpr, lines, ctx) {
     if (m && ctx.rootDefs && ctx.rootDefs[m[1]]) {
       if (ctx.refStack.has(schema.$ref)) return
       ctx.refStack.add(schema.$ref)
-      genCodeE(ctx.rootDefs[m[1]], v, pathExpr, lines, ctx)
+      genCodeE(ctx.rootDefs[m[1]], v, pathExpr, lines, ctx, schemaPrefix)
       ctx.refStack.delete(schema.$ref)
       return
     }
     if (ctx.schemaMap && ctx.schemaMap.has(schema.$ref)) {
       if (ctx.refStack.has(schema.$ref)) return
       ctx.refStack.add(schema.$ref)
-      genCodeE(ctx.schemaMap.get(schema.$ref), v, pathExpr, lines, ctx)
+      genCodeE(ctx.schemaMap.get(schema.$ref), v, pathExpr, lines, ctx, schemaPrefix)
       ctx.refStack.delete(schema.$ref)
       return
     }
@@ -1262,7 +1829,7 @@ function genCodeE(schema, v, pathExpr, lines, ctx) {
       }
     })
     const expected = types.join(', ')
-    lines.push(`if(!(${conds.join('||')})){_e.push({code:'type_mismatch',path:${pathExpr||'""'},message:'expected ${expected}'});if(!_all)return{valid:false,errors:_e}}`)
+    lines.push(`if(!(${conds.join('||')})){_e.push({keyword:'type',instancePath:${pathExpr||'""'},schemaPath:'${schemaPrefix}/type',params:{type:'${expected}'},message:'must be ${expected}'});if(!_all)return{valid:false,errors:_e}}`)
   }
 
   // In error mode, never assume type — always guard (data may have failed type check but allErrors continues)
@@ -1271,7 +1838,10 @@ function genCodeE(schema, v, pathExpr, lines, ctx) {
   const isStr = false
   const isNum = false
 
-  const fail = (code, msg) => `_e.push({code:'${code}',path:${pathExpr||'""'},message:${msg}});if(!_all)return{valid:false,errors:_e}`
+  const fail = (keyword, schemaSuffix, paramsCode, msgCode) => {
+    const sp = schemaPrefix + '/' + schemaSuffix
+    return `_e.push({keyword:'${keyword}',instancePath:${pathExpr||'""'},schemaPath:'${sp}',params:${paramsCode},message:${msgCode}});if(!_all)return{valid:false,errors:_e}`
+  }
 
   // enum
   if (schema.enum) {
@@ -1281,21 +1851,21 @@ function genCodeE(schema, v, pathExpr, lines, ctx) {
     const primChecks = primitives.map(p => `${v}===${JSON.stringify(p)}`).join('||')
     const objChecks = objects.map(o => `JSON.stringify(${v})===${JSON.stringify(JSON.stringify(o))}`).join('||')
     const allChecks = [primChecks, objChecks].filter(Boolean).join('||')
-    lines.push(`if(!(${allChecks || 'false'})){${fail('enum_mismatch', "'value not in enum'")}}`)
+    lines.push(`if(!(${allChecks || 'false'})){${fail('enum', 'enum', `{allowedValues:${JSON.stringify(schema.enum)}}`, "'must be equal to one of the allowed values'")}}`)
   }
 
   // const — use canonical (sorted-key) comparison for objects
   if (schema.const !== undefined) {
     const cv = schema.const
     if (cv === null || typeof cv !== 'object') {
-      lines.push(`if(${v}!==${JSON.stringify(cv)}){${fail('const_mismatch', "'value does not match const'")}}`)
+      lines.push(`if(${v}!==${JSON.stringify(cv)}){${fail('const', 'const', `{allowedValue:${JSON.stringify(schema.const)}}`, "'must be equal to constant'")}}`)
     } else {
       // Pre-compute canonical form of const value
       const ci = ctx.varCounter++
       const canonFn = `_cnE${ci}`
       ctx.helperCode.push(`const ${canonFn}=function(x){if(x===null||typeof x!=='object')return JSON.stringify(x);if(Array.isArray(x))return'['+x.map(${canonFn}).join(',')+']';return'{'+Object.keys(x).sort().map(function(k){return JSON.stringify(k)+':'+${canonFn}(x[k])}).join(',')+'}'};`)
       const expected = canonFn + '(' + JSON.stringify(cv) + ')'
-      lines.push(`if(${canonFn}(${v})!==${expected}){${fail('const_mismatch', "'value does not match const'")}}`)
+      lines.push(`if(${canonFn}(${v})!==${expected}){${fail('const', 'const', `{allowedValue:${JSON.stringify(schema.const)}}`, "'must be equal to constant'")}}`)
     }
   }
 
@@ -1304,49 +1874,54 @@ function genCodeE(schema, v, pathExpr, lines, ctx) {
   const hoisted = {}
   if (schema.required) {
     for (const key of schema.required) {
-      const p = pathExpr ? `${pathExpr}+'/${esc(key)}'` : `'/${esc(key)}'`
-      lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&!(${JSON.stringify(key)} in ${v})){_e.push({code:'required_missing',path:${p},message:'missing required: ${esc(key)}'});if(!_all)return{valid:false,errors:_e}}`)
+      lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&!(${JSON.stringify(key)} in ${v})){_e.push({keyword:'required',instancePath:${pathExpr||'""'},schemaPath:'${schemaPrefix}/required',params:{missingProperty:'${esc(key)}'},message:"must have required property '${esc(key)}'"});if(!_all)return{valid:false,errors:_e}}`)
     }
   }
 
   // numeric
   if (schema.minimum !== undefined) {
     const c = isNum ? `${v}<${schema.minimum}` : `typeof ${v}==='number'&&${v}<${schema.minimum}`
-    lines.push(`if(${c}){${fail('minimum_violation', `'minimum ${schema.minimum}'`)}}`)
+    lines.push(`if(${c}){${fail('minimum', 'minimum', `{comparison:'>=',limit:${schema.minimum}}`, `'must be >= ${schema.minimum}'`)}}`)
   }
   if (schema.maximum !== undefined) {
     const c = isNum ? `${v}>${schema.maximum}` : `typeof ${v}==='number'&&${v}>${schema.maximum}`
-    lines.push(`if(${c}){${fail('maximum_violation', `'maximum ${schema.maximum}'`)}}`)
+    lines.push(`if(${c}){${fail('maximum', 'maximum', `{comparison:'<=',limit:${schema.maximum}}`, `'must be <= ${schema.maximum}'`)}}`)
   }
   if (schema.exclusiveMinimum !== undefined) {
     const c = isNum ? `${v}<=${schema.exclusiveMinimum}` : `typeof ${v}==='number'&&${v}<=${schema.exclusiveMinimum}`
-    lines.push(`if(${c}){${fail('exclusive_minimum_violation', `'exclusiveMinimum ${schema.exclusiveMinimum}'`)}}`)
+    lines.push(`if(${c}){${fail('exclusiveMinimum', 'exclusiveMinimum', `{comparison:'>',limit:${schema.exclusiveMinimum}}`, `'must be > ${schema.exclusiveMinimum}'`)}}`)
   }
   if (schema.exclusiveMaximum !== undefined) {
     const c = isNum ? `${v}>=${schema.exclusiveMaximum}` : `typeof ${v}==='number'&&${v}>=${schema.exclusiveMaximum}`
-    lines.push(`if(${c}){${fail('exclusive_maximum_violation', `'exclusiveMaximum ${schema.exclusiveMaximum}'`)}}`)
+    lines.push(`if(${c}){${fail('exclusiveMaximum', 'exclusiveMaximum', `{comparison:'<',limit:${schema.exclusiveMaximum}}`, `'must be < ${schema.exclusiveMaximum}'`)}}`)
   }
   if (schema.multipleOf !== undefined) {
     const m = schema.multipleOf
     const ci = ctx.varCounter++
     // Use tolerance-based check for floating point (matches C++ behavior)
-    lines.push(`{const _r${ci}=typeof ${v}==='number'?${v}%${m}:NaN;if(typeof ${v}==='number'&&Math.abs(_r${ci})>1e-8&&Math.abs(_r${ci}-${m})>1e-8){${fail('multiple_of_violation', `'multipleOf ${m}'`)}}}`)
+    lines.push(`{const _r${ci}=typeof ${v}==='number'?${v}%${m}:NaN;if(typeof ${v}==='number'&&Math.abs(_r${ci})>1e-8&&Math.abs(_r${ci}-${m})>1e-8){${fail('multipleOf', 'multipleOf', `{multipleOf:${m}}`, `'must be multiple of ${m}'`)}}}`)
   }
 
   // string
   if (schema.minLength !== undefined) {
     const c = isStr ? `${v}.length<${schema.minLength}` : `typeof ${v}==='string'&&${v}.length<${schema.minLength}`
-    lines.push(`if(${c}){${fail('min_length_violation', `'minLength ${schema.minLength}'`)}}`)
+    lines.push(`if(${c}){${fail('minLength', 'minLength', `{limit:${schema.minLength}}`, `'must NOT have fewer than ${schema.minLength} characters'`)}}`)
   }
   if (schema.maxLength !== undefined) {
     const c = isStr ? `${v}.length>${schema.maxLength}` : `typeof ${v}==='string'&&${v}.length>${schema.maxLength}`
-    lines.push(`if(${c}){${fail('max_length_violation', `'maxLength ${schema.maxLength}'`)}}`)
+    lines.push(`if(${c}){${fail('maxLength', 'maxLength', `{limit:${schema.maxLength}}`, `'must NOT have more than ${schema.maxLength} characters'`)}}`)
   }
   if (schema.pattern) {
-    const ri = ctx.varCounter++
-    ctx.helperCode.push(`const _re${ri}=new RegExp(${JSON.stringify(schema.pattern)})`)
-    const c = isStr ? `!_re${ri}.test(${v})` : `typeof ${v}==='string'&&!_re${ri}.test(${v})`
-    lines.push(`if(${c}){${fail('pattern_mismatch', `'pattern mismatch'`)}}`)
+    const inlineCheck = compilePatternInline(schema.pattern, v)
+    if (inlineCheck) {
+      const c = isStr ? `!(${inlineCheck})` : `typeof ${v}==='string'&&!(${inlineCheck})`
+      lines.push(`if(${c}){${fail('pattern', 'pattern', `{pattern:${JSON.stringify(schema.pattern)}}`, `'must match pattern "${schema.pattern}"'`)}}`)
+    } else {
+      const ri = ctx.varCounter++
+      ctx.helperCode.push(`const _re${ri}=new RegExp(${JSON.stringify(schema.pattern)})`)
+      const c = isStr ? `!_re${ri}.test(${v})` : `typeof ${v}==='string'&&!_re${ri}.test(${v})`
+      lines.push(`if(${c}){${fail('pattern', 'pattern', `{pattern:${JSON.stringify(schema.pattern)}}`, `'must match pattern "${schema.pattern}"'`)}}`)
+    }
   }
   if (schema.format) {
     const fc = FORMAT_CODEGEN[schema.format]
@@ -1357,7 +1932,7 @@ function genCodeE(schema, v, pathExpr, lines, ctx) {
       boolLines.push(fc(v, isStr))
       // Replace `return false` with error push in the format check
       const fmtCode = boolLines.join(';').replace(/return false/g,
-        `{_e.push({code:'format_mismatch',path:${pathExpr||'""'},message:'format ${esc(schema.format)}'});if(!_all)return{valid:false,errors:_e}}`)
+        `{_e.push({keyword:'format',instancePath:${pathExpr||'""'},schemaPath:'${schemaPrefix}/format',params:{format:'${esc(schema.format)}'},message:'must match format "${esc(schema.format)}"'});if(!_all)return{valid:false,errors:_e}}`)
       lines.push(fmtCode)
     }
   }
@@ -1365,37 +1940,44 @@ function genCodeE(schema, v, pathExpr, lines, ctx) {
   // array size
   if (schema.minItems !== undefined) {
     const c = isArr ? `${v}.length<${schema.minItems}` : `Array.isArray(${v})&&${v}.length<${schema.minItems}`
-    lines.push(`if(${c}){${fail('min_items_violation', `'minItems ${schema.minItems}'`)}}`)
+    lines.push(`if(${c}){${fail('minItems', 'minItems', `{limit:${schema.minItems}}`, `'must NOT have fewer than ${schema.minItems} items'`)}}`)
   }
   if (schema.maxItems !== undefined) {
     const c = isArr ? `${v}.length>${schema.maxItems}` : `Array.isArray(${v})&&${v}.length>${schema.maxItems}`
-    lines.push(`if(${c}){${fail('max_items_violation', `'maxItems ${schema.maxItems}'`)}}`)
+    lines.push(`if(${c}){${fail('maxItems', 'maxItems', `{limit:${schema.maxItems}}`, `'must NOT have more than ${schema.maxItems} items'`)}}`)
   }
 
-  // uniqueItems
+  // 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 inner = isPrim
-      ? `const _s${si}=new Set();for(let _i=0;_i<${v}.length;_i++){if(_s${si}.has(${v}[_i])){${fail('unique_items_violation', "'duplicate items'")};break};_s${si}.add(${v}[_i])}`
-      : `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)){${fail('unique_items_violation', "'duplicate items'")};break};_s${si}.add(_k)}`
+    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}}`)
   }
 
   // object size
   if (schema.minProperties !== undefined) {
-    lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&Object.keys(${v}).length<${schema.minProperties}){${fail('min_properties_violation', `'minProperties ${schema.minProperties}'`)}}`)
+    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'`)}}`)
   }
   if (schema.maxProperties !== undefined) {
-    lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&Object.keys(${v}).length>${schema.maxProperties}){${fail('max_properties_violation', `'maxProperties ${schema.maxProperties}'`)}}`)
+    lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&Object.keys(${v}).length>${schema.maxProperties}){${fail('maxProperties', 'maxProperties', `{limit:${schema.maxProperties}}`, `'must NOT have more than ${schema.maxProperties} properties'`)}}`)
   }
 
   // additionalProperties: false
   if (schema.additionalProperties === false && schema.properties) {
     const allowed = Object.keys(schema.properties).map(k => `${JSON.stringify(k)}`).join(',')
     const ci = ctx.varCounter++
-    const inner = `const _k${ci}=Object.keys(${v});const _a${ci}=new Set([${allowed}]);for(let _i=0;_i<_k${ci}.length;_i++){if(!_a${ci}.has(_k${ci}[_i])){_e.push({code:'additional_property',path:${pathExpr||'""'},message:'additional property: '+_k${ci}[_i]});if(!_all)return{valid:false,errors:_e}}}`
+    const inner = `const _k${ci}=Object.keys(${v});const _a${ci}=new Set([${allowed}]);for(let _i=0;_i<_k${ci}.length;_i++){if(!_a${ci}.has(_k${ci}[_i])){_e.push({keyword:'additionalProperties',instancePath:${pathExpr||'""'},schemaPath:'${schemaPrefix}/additionalProperties',params:{additionalProperty:_k${ci}[_i]},message:'must NOT have additional properties'});if(!_all)return{valid:false,errors:_e}}}`
     lines.push(isObj ? `{${inner}}` : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}`)
   }
 
@@ -1403,8 +1985,7 @@ function genCodeE(schema, v, pathExpr, lines, ctx) {
   if (schema.dependentRequired) {
     for (const [key, deps] of Object.entries(schema.dependentRequired)) {
       for (const dep of deps) {
-        const p = pathExpr ? `${pathExpr}+'/${esc(dep)}'` : `'/${esc(dep)}'`
-        lines.push(`if(typeof ${v}==='object'&&${v}!==null&&${JSON.stringify(key)} in ${v}&&!(${JSON.stringify(dep)} in ${v})){_e.push({code:'required_missing',path:${p},message:'${esc(key)} requires ${esc(dep)}'});if(!_all)return{valid:false,errors:_e}}`)
+        lines.push(`if(typeof ${v}==='object'&&${v}!==null&&${JSON.stringify(key)} in ${v}&&!(${JSON.stringify(dep)} in ${v})){_e.push({keyword:'required',instancePath:${pathExpr||'""'},schemaPath:'${schemaPrefix}/dependentRequired',params:{missingProperty:'${esc(dep)}'},message:"must have required property '${esc(dep)}'"});if(!_all)return{valid:false,errors:_e}}`)
       }
     }
   }
@@ -1412,9 +1993,9 @@ function genCodeE(schema, v, pathExpr, lines, ctx) {
   // properties — always guard (error mode, data may not be an object or may be array)
   if (schema.properties) {
     for (const [key, prop] of Object.entries(schema.properties)) {
-      const childPath = pathExpr ? `${pathExpr}+'/${esc(key)}'` : `'/${esc(key)}'`
+      const childPath = childPathExpr(pathExpr, esc(key))
       lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&${JSON.stringify(key)} in ${v}){`)
-      genCodeE(prop, `${v}[${JSON.stringify(key)}]`, childPath, lines, ctx)
+      genCodeE(prop, `${v}[${JSON.stringify(key)}]`, childPath, lines, ctx, schemaPrefix+'/properties/'+key)
       lines.push(`}`)
     }
   }
@@ -1427,7 +2008,7 @@ function genCodeE(schema, v, pathExpr, lines, ctx) {
       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 p = pathExpr ? `${pathExpr}+'/'+_k${ki}` : `'/'+_k${ki}`
-      genCodeE(sub, `${v}[_k${ki}]`, p, lines, ctx)
+      genCodeE(sub, `${v}[_k${ki}]`, p, lines, ctx, schemaPrefix+'/patternProperties')
       lines.push(`}}}`)
     }
   }
@@ -1436,7 +2017,7 @@ function genCodeE(schema, v, pathExpr, lines, ctx) {
   if (schema.dependentSchemas) {
     for (const [key, depSchema] of Object.entries(schema.dependentSchemas)) {
       lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&${JSON.stringify(key)} in ${v}){`)
-      genCodeE(depSchema, v, pathExpr, lines, ctx)
+      genCodeE(depSchema, v, pathExpr, lines, ctx, schemaPrefix+'/dependentSchemas/'+key)
       lines.push(`}`)
     }
   }
@@ -1447,23 +2028,23 @@ function genCodeE(schema, v, pathExpr, lines, ctx) {
     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('min_length_violation', `'propertyNames: key too short: '+_k${ki}`)}}`)
+      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('max_length_violation', `'propertyNames: key too long: '+_k${ki}`)}}`)
+      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.helperCode.push(`const _re${ri}=new RegExp(${JSON.stringify(pn.pattern)})`)
-      lines.push(`if(!_re${ri}.test(_k${ki})){${fail('pattern_mismatch', `'propertyNames: pattern mismatch: '+_k${ki}`)}}`)
+      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_mismatch', `'propertyNames: expected '+${JSON.stringify(pn.const)}`)}}`)
+      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_mismatch', `'propertyNames: key not in enum: '+_k${ki}`)}}`)
+      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(`}}`)
   }
@@ -1474,18 +2055,18 @@ function genCodeE(schema, v, pathExpr, lines, ctx) {
     const idx = `_j${ctx.varCounter}`
     const elem = `_ei${ctx.varCounter}`
     ctx.varCounter++
-    const childPath = pathExpr ? `${pathExpr}+'/'+${idx}` : `'/'+${idx}`
+    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)
+    genCodeE(schema.items, elem, childPath, lines, ctx, schemaPrefix+'/items')
     lines.push(`}}`)
   }
 
   // prefixItems
   if (schema.prefixItems) {
     for (let i = 0; i < schema.prefixItems.length; i++) {
-      const childPath = pathExpr ? `${pathExpr}+'/${i}'` : `'/${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)
+      genCodeE(schema.prefixItems[i], `${v}[${i}]`, childPath, lines, ctx, schemaPrefix+'/prefixItems/'+i)
       lines.push(`}`)
     }
   }
@@ -1499,17 +2080,17 @@ function genCodeE(schema, v, pathExpr, lines, ctx) {
     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_violation', `'contains: need at least ${minC} match(es)'`)}}`)
+    lines.push(`if(_cc${ci}<${minC}){${fail('contains', 'contains', `{limit:${minC}}`, `'contains: need at least ${minC} match(es)'`)}}`)
     if (maxC !== undefined) {
-      lines.push(`if(_cc${ci}>${maxC}){${fail('contains_violation', `'contains: at most ${maxC} match(es)'`)}}`)
+      lines.push(`if(_cc${ci}>${maxC}){${fail('contains', 'contains', `{limit:${maxC}}`, `'contains: at most ${maxC} match(es)'`)}}`)
     }
     lines.push(`}`)
   }
 
   // allOf
   if (schema.allOf) {
-    for (const sub of schema.allOf) {
-      genCodeE(sub, v, pathExpr, lines, ctx)
+    for (let _ai = 0; _ai < schema.allOf.length; _ai++) {
+      genCodeE(schema.allOf[_ai], v, pathExpr, lines, ctx, schemaPrefix+'/allOf/'+_ai)
     }
   }
 
@@ -1521,7 +2102,7 @@ function genCodeE(schema, v, pathExpr, lines, ctx) {
       genCode(sub, '_av', subLines, ctx)
       return subLines.length === 0 ? `function(_av){return true}` : `function(_av){${subLines.join(';')};return true}`
     })
-    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}){${fail('any_of_failed', "'no anyOf matched'")}}}`)
+    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}){${fail('anyOf', 'anyOf', '{}', "'must match a schema in anyOf'")}}}`)
   }
 
   // oneOf
@@ -1532,7 +2113,7 @@ function genCodeE(schema, v, pathExpr, lines, ctx) {
       genCode(sub, '_ov', subLines, ctx)
       return subLines.length === 0 ? `function(_ov){return true}` : `function(_ov){${subLines.join(';')};return true}`
     })
-    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)break}if(_oc${fi}!==1){${fail('one_of_failed', "'oneOf: expected 1 match, got '+_oc"+fi)}}}`)
+    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)break}if(_oc${fi}!==1){${fail('oneOf', 'oneOf', '{}', "'must match exactly one schema in oneOf'")}}}`)
   }
 
   // not
@@ -1541,7 +2122,7 @@ function genCodeE(schema, v, pathExpr, lines, ctx) {
     genCode(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_failed', "'should not match'")}}}`)
+    lines.push(`{const _nf${fi}=${nfn};if(_nf${fi}(${v})){${fail('not', 'not', '{}', "'must NOT be valid'")}}}`)
   }
 
   // if/then/else
@@ -1555,12 +2136,12 @@ function genCodeE(schema, v, pathExpr, lines, ctx) {
     lines.push(`{const _if${fi}=${ifFn}`)
     if (schema.then) {
       lines.push(`if(_if${fi}(${v})){`)
-      genCodeE(schema.then, v, pathExpr, lines, ctx)
+      genCodeE(schema.then, v, pathExpr, lines, ctx, schemaPrefix+'/then')
       lines.push(`}`)
     }
     if (schema.else) {
       lines.push(`${schema.then ? 'else' : `if(!_if${fi}(${v}))`}{`)
-      genCodeE(schema.else, v, pathExpr, lines, ctx)
+      genCodeE(schema.else, v, pathExpr, lines, ctx, schemaPrefix+'/else')
       lines.push(`}`)
     }
     lines.push(`}`)
@@ -1572,10 +2153,15 @@ function genCodeE(schema, v, pathExpr, lines, ctx) {
 // Avoids double-pass (jsFn → false → errFn runs same checks again).
 // Uses type-aware optimizations: after type check passes, skip guards.
 function compileToJSCombined(schema, VALID_RESULT, schemaMap) {
+  // Bail on unevaluated keywords — combined codegen doesn't support them yet
+  if (typeof schema === 'object' && schema !== null) {
+    const s = JSON.stringify(schema)
+    if (s.includes('unevaluatedProperties') || s.includes('unevaluatedItems')) return null
+  }
   if (typeof schema === 'boolean') {
     return schema
       ? () => VALID_RESULT
-      : () => ({ valid: false, errors: [{ code: 'type_mismatch', path: '', message: 'schema is false' }] })
+      : () => ({ valid: false, errors: [{ keyword: 'false schema', instancePath: '', schemaPath: '#', params: {}, message: 'boolean schema is false' }] })
   }
   if (typeof schema !== 'object' || schema === null) return null
   if (!codegenSafe(schema, schemaMap)) return null
@@ -1603,7 +2189,7 @@ function compileToJSCombined(schema, VALID_RESULT, schemaMap) {
   const ctx = { varCounter: 0, helperCode: [], closureVars: [], closureVals: [],
                 rootDefs: schema.$defs || schema.definitions || null, refStack: new Set(), schemaMap: schemaMap || null }
   const lines = []
-  genCodeC(schema, 'd', '', lines, ctx)
+  genCodeC(schema, 'd', '', lines, ctx, '#')
   if (lines.length === 0) return () => VALID_RESULT
 
   // Use factory pattern: closure vars (regexes, etc.) created once, not per call
@@ -1615,6 +2201,7 @@ function compileToJSCombined(schema, VALID_RESULT, schemaMap) {
     `\n  return _e?{valid:false,errors:_e}:R`
 
   try {
+    if (process.env.ATA_DUMP_CODEGEN) console.log('=== COMBINED CODEGEN ===\n' + inner + '\n=== CLOSURE VARS: ' + ctx.closureVars.length + ' ===')
     const factory = new Function('R' + (closureParams ? ',' + closureParams : ''),
       `return function(d){${inner}}`)
     return factory(VALID_RESULT, ...ctx.closureVals)
@@ -1627,7 +2214,8 @@ function compileToJSCombined(schema, VALID_RESULT, schemaMap) {
 // Combined code generator: type-aware like genCode, error-collecting like genCodeE.
 // After type check passes → use optimizations (destructuring, no guards).
 // If type check fails → push error, skip property checks (they'd crash).
-function genCodeC(schema, v, pathExpr, lines, ctx) {
+function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
+  if (!schemaPrefix) schemaPrefix = '#'
   if (typeof schema !== 'object' || schema === null) return
 
   // $ref — resolve local and cross-schema refs
@@ -1636,14 +2224,14 @@ function genCodeC(schema, v, pathExpr, lines, ctx) {
     if (m && ctx.rootDefs && ctx.rootDefs[m[1]]) {
       if (ctx.refStack.has(schema.$ref)) return
       ctx.refStack.add(schema.$ref)
-      genCodeC(ctx.rootDefs[m[1]], v, pathExpr, lines, ctx)
+      genCodeC(ctx.rootDefs[m[1]], v, pathExpr, lines, ctx, schemaPrefix)
       ctx.refStack.delete(schema.$ref)
       return
     }
     if (ctx.schemaMap && ctx.schemaMap.has(schema.$ref)) {
       if (ctx.refStack.has(schema.$ref)) return
       ctx.refStack.add(schema.$ref)
-      genCodeC(ctx.schemaMap.get(schema.$ref), v, pathExpr, lines, ctx)
+      genCodeC(ctx.schemaMap.get(schema.$ref), v, pathExpr, lines, ctx, schemaPrefix)
       ctx.refStack.delete(schema.$ref)
       return
     }
@@ -1655,19 +2243,25 @@ function genCodeC(schema, v, pathExpr, lines, ctx) {
   // Pre-allocate error objects as closure variables for static paths.
   // This shrinks the generated function body → better V8 JIT on valid path.
   const isStaticPath = !pathExpr || (pathExpr.startsWith("'") && !pathExpr.includes('+'))
-  const fail = (code, msg) => {
-    if (isStaticPath && msg.startsWith("'") && !msg.includes('+')) {
-      // Static error: pre-allocate as frozen closure variable
-      const ei = ctx.varCounter++
-      const errVar = `_E${ei}`
-      const pathVal = pathExpr ? pathExpr.slice(1, -1) : ''
-      const msgVal = msg.slice(1, -1)
-      ctx.closureVars.push(errVar)
-      ctx.closureVals.push(Object.freeze({code, path: pathVal, message: msgVal}))
-      return `(_e||(_e=[])).push(${errVar})`
+  const fail = (keyword, schemaSuffix, paramsCode, msgCode) => {
+    const sp = schemaPrefix + '/' + schemaSuffix
+    if (isStaticPath && msgCode.startsWith("'") && !msgCode.includes('+')) {
+      // Try to evaluate paramsCode as a static constant
+      let paramsVal
+      try { paramsVal = Function('return ' + paramsCode)() } catch { /* dynamic params — fall through */ }
+      if (paramsVal !== undefined) {
+        // Static error: pre-allocate as frozen closure variable
+        const ei = ctx.varCounter++
+        const errVar = `_E${ei}`
+        const pathVal = pathExpr ? pathExpr.slice(1, -1) : ''
+        const msgVal = msgCode.slice(1, -1)
+        ctx.closureVars.push(errVar)
+        ctx.closureVals.push(Object.freeze({keyword, instancePath: pathVal, schemaPath: sp, params: Object.freeze(paramsVal), message: msgVal}))
+        return `(_e||(_e=[])).push(${errVar})`
+      }
     }
     // Dynamic path (e.g., array index): inline as before
-    return `(_e||(_e=[])).push({code:'${code}',path:${pathExpr||'""'},message:${msg}})`
+    return `(_e||(_e=[])).push({keyword:'${keyword}',instancePath:${pathExpr||'""'},schemaPath:'${sp}',params:${paramsCode},message:${msgCode}})`
   }
 
   if (types) {
@@ -1687,7 +2281,7 @@ function genCodeC(schema, v, pathExpr, lines, ctx) {
     // Type check: push error but continue — wrap remaining in type-success block
     const typeOk = `_tok${ctx.varCounter++}`
     lines.push(`const ${typeOk}=${conds.join('||')}`)
-    lines.push(`if(!${typeOk}){${fail('type_mismatch', `'expected ${expected}'`)}}`)
+    lines.push(`if(!${typeOk}){${fail('type', 'type', `{type:'${expected}'}`, `'must be ${expected}'`)}}`)
     // Subsequent optimized code runs inside if(typeOk){...}
     if (types.length === 1) {
       isObj = types[0] === 'object'
@@ -1706,19 +2300,19 @@ function genCodeC(schema, v, pathExpr, lines, ctx) {
     const primChecks = primitives.map(p => `${v}===${JSON.stringify(p)}`).join('||')
     const objChecks = objects.map(o => `JSON.stringify(${v})===${JSON.stringify(JSON.stringify(o))}`).join('||')
     const allChecks = [primChecks, objChecks].filter(Boolean).join('||')
-    lines.push(`if(!(${allChecks || 'false'})){${fail('enum_mismatch', "'value not in enum'")}}`)
+    lines.push(`if(!(${allChecks || 'false'})){${fail('enum', 'enum', `{allowedValues:${JSON.stringify(schema.enum)}}`, "'must be equal to one of the allowed values'")}}`)
   }
 
   // const
   if (schema.const !== undefined) {
     const cv = schema.const
     if (cv === null || typeof cv !== 'object') {
-      lines.push(`if(${v}!==${JSON.stringify(cv)}){${fail('const_mismatch', "'const mismatch'")}}`)
+      lines.push(`if(${v}!==${JSON.stringify(cv)}){${fail('const', 'const', `{allowedValue:${JSON.stringify(schema.const)}}`, "'must be equal to constant'")}}`)
     } else {
       const ci = ctx.varCounter++
       const canonFn = `_cn${ci}`
       ctx.helperCode.push(`const ${canonFn}=function(x){if(x===null||typeof x!=='object')return JSON.stringify(x);if(Array.isArray(x))return'['+x.map(${canonFn}).join(',')+']';return'{'+Object.keys(x).sort().map(function(k){return JSON.stringify(k)+':'+${canonFn}(x[k])}).join(',')+'}'};`)
-      lines.push(`if(${canonFn}(${v})!==${canonFn}(${JSON.stringify(cv)})){${fail('const_mismatch', "'const mismatch'")}}`)
+      lines.push(`if(${canonFn}(${v})!==${canonFn}(${JSON.stringify(cv)})){${fail('const', 'const', `{allowedValue:${JSON.stringify(schema.const)}}`, "'must be equal to constant'")}}`)
     }
   }
 
@@ -1737,80 +2331,127 @@ function genCodeC(schema, v, pathExpr, lines, ctx) {
     if (destructKeys.length > 0) lines.push(`const{${destructKeys.join(',')}}=${v}`)
     for (const key of schema.required) {
       const check = hoisted[key] ? `${hoisted[key]}===undefined` : `${v}[${JSON.stringify(key)}]===undefined`
-      const p = pathExpr ? `${pathExpr}+'/${esc(key)}'` : `'/${esc(key)}'`
-      lines.push(`if(${check}){${`(_e||(_e=[])).push({code:'required_missing',path:${p},message:'missing: ${esc(key)}'})`}}`)
+      // Pre-allocate required errors as frozen closure variables
+      const ei = ctx.varCounter++
+      const errVar = `_E${ei}`
+      const pathVal = pathExpr ? pathExpr.slice(1, -1) : ''
+      ctx.closureVars.push(errVar)
+      ctx.closureVals.push(Object.freeze({keyword: 'required', instancePath: pathVal, schemaPath: `${schemaPrefix}/required`, params: Object.freeze({missingProperty: key}), message: `must have required property '${key}'`}))
+      lines.push(`if(${check}){(_e||(_e=[])).push(${errVar})}`)
     }
   } else if (schema.required) {
     for (const key of schema.required) {
-      const p = pathExpr ? `${pathExpr}+'/${esc(key)}'` : `'/${esc(key)}'`
-      lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&!(${JSON.stringify(key)} in ${v})){(_e||(_e=[])).push({code:'required_missing',path:${p},message:'missing: ${esc(key)}'})}`)
+      const isStatic = !pathExpr || (pathExpr.startsWith("'") && !pathExpr.includes('+'))
+      if (isStatic) {
+        const ei = ctx.varCounter++
+        const errVar = `_E${ei}`
+        const pathVal = pathExpr ? pathExpr.slice(1, -1) : ''
+        ctx.closureVars.push(errVar)
+        ctx.closureVals.push(Object.freeze({keyword: 'required', instancePath: pathVal, schemaPath: `${schemaPrefix}/required`, params: Object.freeze({missingProperty: key}), message: `must have required property '${key}'`}))
+        lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&!(${JSON.stringify(key)} in ${v})){(_e||(_e=[])).push(${errVar})}`)
+      } else {
+        lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&!(${JSON.stringify(key)} in ${v})){(_e||(_e=[])).push({keyword:'required',instancePath:${pathExpr||'""'},schemaPath:'${schemaPrefix}/required',params:{missingProperty:'${esc(key)}'},message:"must have required property '${esc(key)}'"})}`)
+      }
     }
   }
 
   // numeric — skip type guard if known
-  if (schema.minimum !== undefined) { const c = isNum ? `${v}<${schema.minimum}` : `typeof ${v}==='number'&&${v}<${schema.minimum}`; lines.push(`if(${c}){${fail('minimum_violation', `'min ${schema.minimum}'`)}}`) }
-  if (schema.maximum !== undefined) { const c = isNum ? `${v}>${schema.maximum}` : `typeof ${v}==='number'&&${v}>${schema.maximum}`; lines.push(`if(${c}){${fail('maximum_violation', `'max ${schema.maximum}'`)}}`) }
-  if (schema.exclusiveMinimum !== undefined) { const c = isNum ? `${v}<=${schema.exclusiveMinimum}` : `typeof ${v}==='number'&&${v}<=${schema.exclusiveMinimum}`; lines.push(`if(${c}){${fail('exclusive_minimum_violation', `'excMin ${schema.exclusiveMinimum}'`)}}`) }
-  if (schema.exclusiveMaximum !== undefined) { const c = isNum ? `${v}>=${schema.exclusiveMaximum}` : `typeof ${v}==='number'&&${v}>=${schema.exclusiveMaximum}`; lines.push(`if(${c}){${fail('exclusive_maximum_violation', `'excMax ${schema.exclusiveMaximum}'`)}}`) }
+  if (schema.minimum !== undefined) { const c = isNum ? `${v}<${schema.minimum}` : `typeof ${v}==='number'&&${v}<${schema.minimum}`; lines.push(`if(${c}){${fail('minimum', 'minimum', `{comparison:'>=',limit:${schema.minimum}}`, `'must be >= ${schema.minimum}'`)}}`) }
+  if (schema.maximum !== undefined) { const c = isNum ? `${v}>${schema.maximum}` : `typeof ${v}==='number'&&${v}>${schema.maximum}`; lines.push(`if(${c}){${fail('maximum', 'maximum', `{comparison:'<=',limit:${schema.maximum}}`, `'must be <= ${schema.maximum}'`)}}`) }
+  if (schema.exclusiveMinimum !== undefined) { const c = isNum ? `${v}<=${schema.exclusiveMinimum}` : `typeof ${v}==='number'&&${v}<=${schema.exclusiveMinimum}`; lines.push(`if(${c}){${fail('exclusiveMinimum', 'exclusiveMinimum', `{comparison:'>',limit:${schema.exclusiveMinimum}}`, `'must be > ${schema.exclusiveMinimum}'`)}}`) }
+  if (schema.exclusiveMaximum !== undefined) { const c = isNum ? `${v}>=${schema.exclusiveMaximum}` : `typeof ${v}==='number'&&${v}>=${schema.exclusiveMaximum}`; lines.push(`if(${c}){${fail('exclusiveMaximum', 'exclusiveMaximum', `{comparison:'<',limit:${schema.exclusiveMaximum}}`, `'must be < ${schema.exclusiveMaximum}'`)}}`) }
   if (schema.multipleOf !== undefined) {
     const m = schema.multipleOf
     const ci = ctx.varCounter++
-    lines.push(`{const _r${ci}=typeof ${v}==='number'?${v}%${m}:NaN;if(typeof ${v}==='number'&&Math.abs(_r${ci})>1e-8&&Math.abs(_r${ci}-${m})>1e-8){${fail('multiple_of_violation', `'multipleOf ${m}'`)}}}`)
+    lines.push(`{const _r${ci}=typeof ${v}==='number'?${v}%${m}:NaN;if(typeof ${v}==='number'&&Math.abs(_r${ci})>1e-8&&Math.abs(_r${ci}-${m})>1e-8){${fail('multipleOf', 'multipleOf', `{multipleOf:${m}}`, `'must be multiple of ${m}'`)}}}`)
   }
 
   // string — skip guard if known
-  if (schema.minLength !== undefined) { const c = isStr ? `${v}.length<${schema.minLength}` : `typeof ${v}==='string'&&${v}.length<${schema.minLength}`; lines.push(`if(${c}){${fail('min_length_violation', `'minLength ${schema.minLength}'`)}}`) }
-  if (schema.maxLength !== undefined) { const c = isStr ? `${v}.length>${schema.maxLength}` : `typeof ${v}==='string'&&${v}.length>${schema.maxLength}`; lines.push(`if(${c}){${fail('max_length_violation', `'maxLength ${schema.maxLength}'`)}}`) }
+  if (schema.minLength !== undefined) { const c = isStr ? `${v}.length<${schema.minLength}` : `typeof ${v}==='string'&&${v}.length<${schema.minLength}`; lines.push(`if(${c}){${fail('minLength', 'minLength', `{limit:${schema.minLength}}`, `'must NOT have fewer than ${schema.minLength} characters'`)}}`) }
+  if (schema.maxLength !== undefined) { const c = isStr ? `${v}.length>${schema.maxLength}` : `typeof ${v}==='string'&&${v}.length>${schema.maxLength}`; lines.push(`if(${c}){${fail('maxLength', 'maxLength', `{limit:${schema.maxLength}}`, `'must NOT have more than ${schema.maxLength} characters'`)}}`) }
   if (schema.pattern) {
-    const ri = ctx.varCounter++
-    const reVar = `_re${ri}`
-    ctx.closureVars.push(reVar)
-    ctx.closureVals.push(new RegExp(schema.pattern))
-    const c = isStr ? `!${reVar}.test(${v})` : `typeof ${v}==='string'&&!${reVar}.test(${v})`
-    lines.push(`if(${c}){${fail('pattern_mismatch', "'pattern mismatch'")}}`)
+    const inlineCheck = compilePatternInline(schema.pattern, v)
+    if (inlineCheck) {
+      const c = isStr ? `!(${inlineCheck})` : `typeof ${v}==='string'&&!(${inlineCheck})`
+      lines.push(`if(${c}){${fail('pattern', 'pattern', `{pattern:${JSON.stringify(schema.pattern)}}`, `'must match pattern "${schema.pattern}"'`)}}`)
+    } else {
+      const ri = ctx.varCounter++
+      const reVar = `_re${ri}`
+      ctx.closureVars.push(reVar)
+      ctx.closureVals.push(new RegExp(schema.pattern))
+      const c = isStr ? `!${reVar}.test(${v})` : `typeof ${v}==='string'&&!${reVar}.test(${v})`
+      lines.push(`if(${c}){${fail('pattern', 'pattern', `{pattern:${JSON.stringify(schema.pattern)}}`, `'must match pattern "${schema.pattern}"'`)}}`)
+    }
   }
   if (schema.format) {
     const fc = FORMAT_CODEGEN[schema.format]
     if (fc) {
-      const code = fc(v, isStr).replace(/return false/g, `{${fail('format_mismatch', `'format ${esc(schema.format)}'`)}}`)
+      const code = fc(v, isStr).replace(/return false/g, `{${fail('format', 'format', `{format:'${esc(schema.format)}'}`, `'must match format "${esc(schema.format)}"'`)}}`)
       lines.push(code)
     }
   }
 
   // array size
-  if (schema.minItems !== undefined) { const c = isArr ? `${v}.length<${schema.minItems}` : `Array.isArray(${v})&&${v}.length<${schema.minItems}`; lines.push(`if(${c}){${fail('min_items_violation', `'minItems ${schema.minItems}'`)}}`) }
-  if (schema.maxItems !== undefined) { const c = isArr ? `${v}.length>${schema.maxItems}` : `Array.isArray(${v})&&${v}.length>${schema.maxItems}`; lines.push(`if(${c}){${fail('max_items_violation', `'maxItems ${schema.maxItems}'`)}}`) }
+  if (schema.minItems !== undefined) { const c = isArr ? `${v}.length<${schema.minItems}` : `Array.isArray(${v})&&${v}.length<${schema.minItems}`; lines.push(`if(${c}){${fail('minItems', 'minItems', `{limit:${schema.minItems}}`, `'must NOT have fewer than ${schema.minItems} items'`)}}`) }
+  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
+  // 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 inner = isPrim
-      ? `const _s${si}=new Set();for(let _i=0;_i<${v}.length;_i++){if(_s${si}.has(${v}[_i])){${fail('unique_items_violation', "'duplicates'")};break};_s${si}.add(${v}[_i])}`
-      : `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)){${fail('unique_items_violation', "'duplicates'")};break};_s${si}.add(_k)}`
+    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}}`)
   }
 
   // object size
-  if (schema.minProperties !== undefined) lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&Object.keys(${v}).length<${schema.minProperties}){${fail('min_properties_violation', `'minProperties ${schema.minProperties}'`)}}`)
-  if (schema.maxProperties !== undefined) lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&Object.keys(${v}).length>${schema.maxProperties}){${fail('max_properties_violation', `'maxProperties ${schema.maxProperties}'`)}}`)
+  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'`)}}`)
+  if (schema.maxProperties !== undefined) lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&Object.keys(${v}).length>${schema.maxProperties}){${fail('maxProperties', 'maxProperties', `{limit:${schema.maxProperties}}`, `'must NOT have more than ${schema.maxProperties} properties'`)}}`)
 
   // additionalProperties — skip if patternProperties present (handled in unified loop below)
+  // Small property sets: direct === chain (no Set allocation)
   if (schema.additionalProperties === false && schema.properties && !schema.patternProperties) {
-    const allowed = Object.keys(schema.properties).map(k => JSON.stringify(k)).join(',')
+    const propKeys = Object.keys(schema.properties)
     const ci = ctx.varCounter++
-    lines.push(isObj
-      ? `{const _k${ci}=Object.keys(${v});const _a${ci}=new Set([${allowed}]);for(let _i=0;_i<_k${ci}.length;_i++)if(!_a${ci}.has(_k${ci}[_i])){${fail('additional_property', `'extra: '+_k${ci}[_i]`)}}}`
-      : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){const _k${ci}=Object.keys(${v});const _a${ci}=new Set([${allowed}]);for(let _i=0;_i<_k${ci}.length;_i++)if(!_a${ci}.has(_k${ci}[_i])){${fail('additional_property', `'extra: '+_k${ci}[_i]`)}}}`)
+    if (propKeys.length <= 8) {
+      // Direct chain: no Set allocation for small schemas
+      const checks = propKeys.map(k => `_k${ci}[_i]!==${JSON.stringify(k)}`).join('&&')
+      lines.push(isObj
+        ? `{const _k${ci}=Object.keys(${v});for(let _i=0;_i<_k${ci}.length;_i++)if(${checks}){${fail('additionalProperties', 'additionalProperties', `{additionalProperty:_k${ci}[_i]}`, "'must NOT have additional properties'")}}}`
+        : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){const _k${ci}=Object.keys(${v});for(let _i=0;_i<_k${ci}.length;_i++)if(${checks}){${fail('additionalProperties', 'additionalProperties', `{additionalProperty:_k${ci}[_i]}`, "'must NOT have additional properties'")}}}`)
+    } else {
+      const allowed = propKeys.map(k => JSON.stringify(k)).join(',')
+      lines.push(isObj
+        ? `{const _k${ci}=Object.keys(${v});const _a${ci}=new Set([${allowed}]);for(let _i=0;_i<_k${ci}.length;_i++)if(!_a${ci}.has(_k${ci}[_i])){${fail('additionalProperties', 'additionalProperties', `{additionalProperty:_k${ci}[_i]}`, "'must NOT have additional properties'")}}}`
+        : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){const _k${ci}=Object.keys(${v});const _a${ci}=new Set([${allowed}]);for(let _i=0;_i<_k${ci}.length;_i++)if(!_a${ci}.has(_k${ci}[_i])){${fail('additionalProperties', 'additionalProperties', `{additionalProperty:_k${ci}[_i]}`, "'must NOT have additional properties'")}}}`)
+    }
   }
 
   // dependentRequired
   if (schema.dependentRequired) {
     for (const [key, deps] of Object.entries(schema.dependentRequired)) {
       for (const dep of deps) {
-        const p = pathExpr ? `${pathExpr}+'/${esc(dep)}'` : `'/${esc(dep)}'`
-        lines.push(`if(typeof ${v}==='object'&&${v}!==null&&${JSON.stringify(key)} in ${v}&&!(${JSON.stringify(dep)} in ${v})){(_e||(_e=[])).push({code:'required_missing',path:${p},message:'${esc(key)} requires ${esc(dep)}'})}`)
+        const isStatic = !pathExpr || (pathExpr.startsWith("'") && !pathExpr.includes('+'))
+        if (isStatic) {
+          const ei = ctx.varCounter++
+          const errVar = `_E${ei}`
+          const pathVal = pathExpr ? pathExpr.slice(1, -1) : ''
+          ctx.closureVars.push(errVar)
+          ctx.closureVals.push(Object.freeze({keyword: 'required', instancePath: pathVal, schemaPath: `${schemaPrefix}/dependentRequired`, params: Object.freeze({missingProperty: dep}), message: `must have required property '${dep}'`}))
+          lines.push(`if(typeof ${v}==='object'&&${v}!==null&&${JSON.stringify(key)} in ${v}&&!(${JSON.stringify(dep)} in ${v})){(_e||(_e=[])).push(${errVar})}`)
+        } else {
+          lines.push(`if(typeof ${v}==='object'&&${v}!==null&&${JSON.stringify(key)} in ${v}&&!(${JSON.stringify(dep)} in ${v})){(_e||(_e=[])).push({keyword:'required',instancePath:${pathExpr||'""'},schemaPath:'${schemaPrefix}/dependentRequired',params:{missingProperty:'${esc(dep)}'},message:"must have required property '${esc(dep)}'"})}`)
+        }
       }
     }
   }
@@ -1819,19 +2460,19 @@ function genCodeC(schema, v, pathExpr, lines, ctx) {
   if (schema.properties) {
     for (const [key, prop] of Object.entries(schema.properties)) {
       const pv = hoisted[key] || `${v}[${JSON.stringify(key)}]`
-      const childPath = pathExpr ? `${pathExpr}+'/${esc(key)}'` : `'/${esc(key)}'`
+      const childPath = childPathExpr(pathExpr, esc(key))
       if (requiredSet.has(key) && isObj) {
         lines.push(`if(${pv}!==undefined){`)
-        genCodeC(prop, pv, childPath, lines, ctx)
+        genCodeC(prop, pv, childPath, lines, ctx, schemaPrefix+'/properties/'+key)
         lines.push(`}`)
       } else if (isObj) {
         const oi = ctx.varCounter++
         lines.push(`{const _o${oi}=${v}[${JSON.stringify(key)}];if(_o${oi}!==undefined){`)
-        genCodeC(prop, `_o${oi}`, childPath, lines, ctx)
+        genCodeC(prop, `_o${oi}`, childPath, lines, ctx, schemaPrefix+'/properties/'+key)
         lines.push(`}}`)
       } else {
         lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&${JSON.stringify(key)} in ${v}){`)
-        genCodeC(prop, `${v}[${JSON.stringify(key)}]`, childPath, lines, ctx)
+        genCodeC(prop, `${v}[${JSON.stringify(key)}]`, childPath, lines, ctx, schemaPrefix+'/properties/'+key)
         lines.push(`}`)
       }
     }
@@ -1888,61 +2529,61 @@ function genCodeC(schema, v, pathExpr, lines, ctx) {
       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('min_length_violation', `'propertyNames: key too short: '+${kVar}`)}}`)
-        if (pn.maxLength !== undefined) lines.push(`if(${kVar}.length>${pn.maxLength}){${fail('max_length_violation', `'propertyNames: key too long: '+${kVar}`)}}`)
+        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_mismatch', `'propertyNames: pattern mismatch: '+${kVar}`)}}`)
+            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(new RegExp(pn.pattern))
-            lines.push(`if(!_re${ri}.test(${kVar})){${fail('pattern_mismatch', `'propertyNames: pattern mismatch: '+${kVar}`)}}`)
+            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_mismatch', `'propertyNames: expected '+${JSON.stringify(pn.const)}`)}}`)
+        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_mismatch', `'propertyNames: key not in enum: '+${kVar}`)}}`)
+          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++) {
-        lines.push(`if(${matchers[i].check}){_m${pi}=true;if(!_ppf${pi}_${i}(${v}[${kVar}])){${fail('pattern_mismatch', `'patternProperties: value invalid for key '+${kVar}`)}}}`)
+        lines.push(`if(${matchers[i].check}){_m${pi}=true;if(!_ppf${pi}_${i}(${v}[${kVar}])){${fail('pattern', 'patternProperties', `{pattern:'${ppEntries[i][0]}'}`, `'patternProperties: value invalid for key '+${kVar}`)}}}`)
       }
-      lines.push(`if(!_m${pi}){${fail('additional_property', `'extra: '+${kVar}`)}}`)
+      lines.push(`if(!_m${pi}){${fail('additionalProperties', 'additionalProperties', `{additionalProperty:${kVar}}`, "'must NOT have additional properties'")}}`)
       lines.push(`}}`)
     } else {
       ctx._ppHandledPropertyNamesC = !!pn
       lines.push(`${guard}{for(const ${kVar} in ${v}){`)
       if (pn) {
-        if (pn.minLength !== undefined) lines.push(`if(${kVar}.length<${pn.minLength}){${fail('min_length_violation', `'propertyNames: key too short: '+${kVar}`)}}`)
-        if (pn.maxLength !== undefined) lines.push(`if(${kVar}.length>${pn.maxLength}){${fail('max_length_violation', `'propertyNames: key too long: '+${kVar}`)}}`)
+        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_mismatch', `'propertyNames: pattern mismatch: '+${kVar}`)}}`)
+            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(new RegExp(pn.pattern))
-            lines.push(`if(!_re${ri}.test(${kVar})){${fail('pattern_mismatch', `'propertyNames: pattern mismatch: '+${kVar}`)}}`)
+            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_mismatch', `'propertyNames: expected '+${JSON.stringify(pn.const)}`)}}`)
+        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_mismatch', `'propertyNames: key not in enum: '+${kVar}`)}}`)
+          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}&&!_ppf${pi}_${i}(${v}[${kVar}])){${fail('pattern_mismatch', `'patternProperties: value invalid for key '+${kVar}`)}}`)
+        lines.push(`if(${matchers[i].check}&&!_ppf${pi}_${i}(${v}[${kVar}])){${fail('pattern', 'patternProperties', `{pattern:'${ppEntries[i][0]}'}`, `'patternProperties: value invalid for key '+${kVar}`)}}`)
       }
       lines.push(`}}`)
     }
@@ -1952,7 +2593,7 @@ function genCodeC(schema, v, pathExpr, lines, ctx) {
   if (schema.dependentSchemas) {
     for (const [key, depSchema] of Object.entries(schema.dependentSchemas)) {
       lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&${JSON.stringify(key)} in ${v}){`)
-      genCodeC(depSchema, v, pathExpr, lines, ctx)
+      genCodeC(depSchema, v, pathExpr, lines, ctx, schemaPrefix+'/dependentSchemas/'+key)
       lines.push(`}`)
     }
   }
@@ -1963,25 +2604,25 @@ function genCodeC(schema, v, pathExpr, lines, ctx) {
     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('min_length_violation', `'propertyNames: key too short: '+_k${ki}`)}}`)
+      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('max_length_violation', `'propertyNames: key too long: '+_k${ki}`)}}`)
+      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(new RegExp(pn.pattern))
-      lines.push(`if(!_re${ri}.test(_k${ki})){${fail('pattern_mismatch', `'propertyNames: pattern mismatch: '+_k${ki}`)}}`)
+      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_mismatch', `'propertyNames: expected '+${JSON.stringify(pn.const)}`)}}`)
+      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_mismatch', `'propertyNames: key not in enum: '+_k${ki}`)}}`)
+      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(`}}`)
   }
@@ -1991,18 +2632,18 @@ function genCodeC(schema, v, pathExpr, lines, ctx) {
     const startIdx = schema.prefixItems ? schema.prefixItems.length : 0
     const idx = `_j${ctx.varCounter}`, elem = `_ei${ctx.varCounter}`
     ctx.varCounter++
-    const childPath = pathExpr ? `${pathExpr}+'/'+${idx}` : `'/'+${idx}`
+    const childPath = childPathDynExpr(pathExpr, idx)
     lines.push(`if(Array.isArray(${v})){for(let ${idx}=${startIdx};${idx}<${v}.length;${idx}++){const ${elem}=${v}[${idx}]`)
-    genCodeC(schema.items, elem, childPath, lines, ctx)
+    genCodeC(schema.items, elem, childPath, lines, ctx, schemaPrefix+'/items')
     lines.push(`}}`)
   }
 
   // prefixItems
   if (schema.prefixItems) {
     for (let i = 0; i < schema.prefixItems.length; i++) {
-      const childPath = pathExpr ? `${pathExpr}+'/${i}'` : `'/${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)
+      genCodeC(schema.prefixItems[i], `${v}[${i}]`, childPath, lines, ctx, schemaPrefix+'/prefixItems/'+i)
       lines.push(`}`)
     }
   }
@@ -2016,26 +2657,26 @@ function genCodeC(schema, v, pathExpr, lines, ctx) {
     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_violation', `'need ${minC}+ matches'`)}}`)
-    if (maxC !== undefined) lines.push(`if(_cc${ci}>${maxC}){${fail('contains_violation', `'max ${maxC} matches'`)}}`)
+    lines.push(`if(_cc${ci}<${minC}){${fail('contains', 'contains', `{limit:${minC}}`, `'contains: need at least ${minC} match(es)'`)}}`)
+    if (maxC !== undefined) lines.push(`if(_cc${ci}>${maxC}){${fail('contains', 'contains', `{limit:${maxC}}`, `'contains: at most ${maxC} match(es)'`)}}`)
     lines.push(`}`)
   }
 
   // allOf
-  if (schema.allOf) { for (const sub of schema.allOf) genCodeC(sub, v, pathExpr, lines, ctx) }
+  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 = []; genCode(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('any_of_failed', "'no match'")}}}`)
+    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'")}}}`)
   }
 
   // oneOf
   if (schema.oneOf) {
     const fi = ctx.varCounter++
     const fns = schema.oneOf.map(sub => { const sl = []; genCode(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('one_of_failed', "'need exactly 1'")}}}`)
+    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'")}}}`)
   }
 
   // not
@@ -2043,7 +2684,7 @@ function genCodeC(schema, v, pathExpr, lines, ctx) {
     const sl = []; genCode(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_failed', "'should not match'")}}}`)
+    lines.push(`{const _nf${fi}=${nfn};if(_nf${fi}(${v})){${fail('not', 'not', '{}', "'must NOT be valid'")}}}`)
   }
 
   // if/then/else
@@ -2052,8 +2693,8 @@ function genCodeC(schema, v, pathExpr, lines, 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) { lines.push(`if(_if${fi}(${v})){`); genCodeC(schema.then, v, pathExpr, lines, ctx); lines.push(`}`) }
-    if (schema.else) { lines.push(`${schema.then ? 'else' : `if(!_if${fi}(${v}))`}{`); genCodeC(schema.else, v, pathExpr, lines, ctx); lines.push(`}`) }
+    if (schema.then) { lines.push(`if(_if${fi}(${v})){`); genCodeC(schema.then, v, pathExpr, lines, ctx, schemaPrefix+'/then'); lines.push(`}`) }
+    if (schema.else) { lines.push(`${schema.then ? 'else' : `if(!_if${fi}(${v}))`}{`); genCodeC(schema.else, v, pathExpr, lines, ctx, schemaPrefix+'/else'); lines.push(`}`) }
     lines.push(`}`)
   }
 
@@ -2063,4 +2704,124 @@ function genCodeC(schema, v, pathExpr, lines, ctx) {
   }
 }
 
-module.exports = { compileToJS, compileToJSCodegen, compileToJSCodegenWithErrors, compileToJSCombined }
+// Collect statically-known evaluated properties/items from a schema.
+// Returns { props: string[], items: number|null, allProps: bool, allItems: bool, dynamic: bool }
+function collectEvaluated(schema, schemaMap, rootDefs) {
+  if (typeof schema !== 'object' || schema === null) return { props: [], items: null, allProps: false, allItems: false, dynamic: false }
+  const defs = rootDefs || schema.$defs || schema.definitions || null
+  const result = { props: [], items: null, allProps: false, allItems: false, dynamic: false }
+  _collectEval(schema, result, defs, schemaMap, new Set(), true)
+  return result
+}
+
+function _collectEval(schema, result, defs, schemaMap, refStack, isRoot) {
+  if (typeof schema !== 'object' || schema === null) return
+  if (result.allProps && result.allItems) return
+
+  // $ref — inline
+  if (schema.$ref) {
+    const m = schema.$ref.match(/^#\/(?:\$defs|definitions)\/(.+)$/)
+    if (m && defs && defs[m[1]]) {
+      if (refStack.has(schema.$ref)) { result.dynamic = true; return }
+      refStack.add(schema.$ref)
+      _collectEval(defs[m[1]], result, defs, schemaMap, refStack)
+      refStack.delete(schema.$ref)
+    } else if (schemaMap && typeof schemaMap.get === 'function' && schemaMap.has(schema.$ref)) {
+      if (refStack.has(schema.$ref)) { result.dynamic = true; return }
+      refStack.add(schema.$ref)
+      _collectEval(schemaMap.get(schema.$ref), result, defs, schemaMap, refStack)
+      refStack.delete(schema.$ref)
+    }
+    // In 2020-12, $ref can coexist with siblings — don't return early if there are other keywords
+    const hasOtherKeywords = Object.keys(schema).some(k => k !== '$ref' && k !== '$defs' && k !== 'definitions' && k !== '$schema' && k !== '$id')
+    if (!hasOtherKeywords) return
+  }
+
+  // properties → static keys
+  if (schema.properties) {
+    for (const k of Object.keys(schema.properties)) {
+      if (!result.props.includes(k)) result.props.push(k)
+    }
+  }
+
+  // additionalProperties: true/schema → all props evaluated
+  if (schema.additionalProperties !== undefined && schema.additionalProperties !== false) {
+    result.allProps = true
+  }
+
+  // patternProperties → dynamic
+  if (schema.patternProperties) {
+    result.dynamic = true
+  }
+
+  // prefixItems → max index
+  if (schema.prefixItems) {
+    const count = schema.prefixItems.length
+    result.items = result.items === null ? count : Math.max(result.items, count)
+  }
+
+  // items: schema/true → all items evaluated
+  if (schema.items && typeof schema.items === 'object') {
+    result.allItems = true
+  }
+  if (schema.items === true) {
+    result.allItems = true
+  }
+
+  // contains interaction with unevaluatedItems is complex
+  // At root level: contains + unevaluatedItems needs dynamic tracking
+  // In nested schemas: contains marks all items as evaluated
+  if (schema.contains) {
+    if (isRoot && (schema.unevaluatedItems !== undefined)) {
+      result.dynamic = true
+    } else {
+      result.allItems = true
+    }
+  }
+
+  // unevaluatedProperties: true/schema → all props evaluated (for nested schemas only)
+  // At root level, unevaluatedProperties is what we're computing FOR, not a contributor
+  if (!isRoot && (schema.unevaluatedProperties === true || (typeof schema.unevaluatedProperties === 'object' && schema.unevaluatedProperties !== null))) {
+    result.allProps = true
+  }
+  // unevaluatedItems: true/schema → all items evaluated (for nested schemas only)
+  if (!isRoot && (schema.unevaluatedItems === true || (typeof schema.unevaluatedItems === 'object' && schema.unevaluatedItems !== null))) {
+    result.allItems = true
+  }
+
+  // allOf → merge all (unconditional)
+  if (schema.allOf) {
+    for (const sub of schema.allOf) {
+      _collectEval(sub, result, defs, schemaMap, refStack)
+    }
+  }
+
+  // anyOf / oneOf → dynamic (conditional merge)
+  if (schema.anyOf || schema.oneOf) {
+    result.dynamic = true
+    const branches = schema.anyOf || schema.oneOf
+    for (const sub of branches) {
+      _collectEval(sub, result, defs, schemaMap, refStack)
+    }
+  }
+
+  // if/then/else → dynamic (branch-dependent)
+  if (schema.if && (schema.then || schema.else)) {
+    result.dynamic = true
+    _collectEval(schema.if, result, defs, schemaMap, refStack)
+    if (schema.then) _collectEval(schema.then, result, defs, schemaMap, refStack)
+    if (schema.else) _collectEval(schema.else, result, defs, schemaMap, refStack)
+  }
+
+  // dependentSchemas → dynamic
+  if (schema.dependentSchemas) {
+    result.dynamic = true
+    for (const sub of Object.values(schema.dependentSchemas)) {
+      _collectEval(sub, result, defs, schemaMap, refStack)
+    }
+  }
+
+  // not → contributes nothing (spec: annotations from not are discarded)
+}
+
+module.exports = { compileToJS, compileToJSCodegen, compileToJSCodegenWithErrors, compileToJSCombined, collectEvaluated, AJV_MESSAGES }