ata-validator 0.5.1 → 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
@@ -810,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) {
@@ -1583,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) {
@@ -1639,7 +1745,7 @@ function compileToJSCodegenWithErrors(schema, schemaMap) {
   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
@@ -1666,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  ` +
@@ -1685,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
@@ -1694,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
     }
@@ -1722,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)
@@ -1731,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) {
@@ -1741,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'")}}`)
     }
   }
 
@@ -1764,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]
@@ -1817,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)
     }
   }
@@ -1825,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}}`)
   }
 
@@ -1863,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}}`)
       }
     }
   }
@@ -1872,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(`}`)
     }
   }
@@ -1887,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(`}}}`)
     }
   }
@@ -1896,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(`}`)
     }
   }
@@ -1907,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(`}}`)
   }
@@ -1934,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(`}`)
     }
   }
@@ -1959,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)
     }
   }
 
@@ -1981,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
@@ -1992,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
@@ -2001,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
@@ -2015,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(`}`)
@@ -2040,7 +2161,7 @@ function compileToJSCombined(schema, VALID_RESULT, schemaMap) {
   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
@@ -2068,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
@@ -2080,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)
@@ -2092,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
@@ -2101,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
     }
@@ -2120,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) {
@@ -2152,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'
@@ -2171,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'")}}`)
     }
   }
 
@@ -2202,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)}'"})}`)
+        }
       }
     }
   }
@@ -2284,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(`}`)
       }
     }
@@ -2353,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(`}}`)
     }
@@ -2417,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(`}`)
     }
   }
@@ -2428,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(`}}`)
   }
@@ -2456,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(`}`)
     }
   }
@@ -2481,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
@@ -2508,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
@@ -2517,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(`}`)
   }
 
@@ -2648,4 +2824,4 @@ function _collectEval(schema, result, defs, schemaMap, refStack, isRoot) {
   // not → contributes nothing (spec: annotations from not are discarded)
 }
 
-module.exports = { compileToJS, compileToJSCodegen, compileToJSCodegenWithErrors, compileToJSCombined, collectEvaluated }
+module.exports = { compileToJS, compileToJSCodegen, compileToJSCodegenWithErrors, compileToJSCombined, collectEvaluated, AJV_MESSAGES }