ata-validator 1.40.1 → 1.42.0

package/lib/js-compiler.js

@@ -101,6 +101,38 @@ function emitUq(ctx) {
   return '_uq'
 }
 
+// The error and combined generators need the duplicate pair, not only the
+// verdict. `_uqp` returns the index of the duplicate (-1 when every item is
+// distinct) and leaves the item it repeats in `_uqpI`: the first item that has
+// a later equal, paired with its first later equal. That is the pair the
+// interpreted engine reports, and the generators used to report a different
+// one (the earliest repeat, paired with what it repeats), so the same document
+// named a different pair depending on the engine that answered. Short arrays
+// compare pairwise and allocate nothing; longer ones key a Map by value, or by
+// canonical string once an object appears. Building a canonical string for
+// every item on every call, as the generators did, made reading a uniqueItems
+// error up to ten times the cost of the verdict.
+const UQP_HELPER = "var _uqpI=0;function _uqp(a){var n=a.length,i,k;if(n<2)return -1;if(n<=12){for(i=0;i<n-1;i++)for(k=i+1;k<n;k++)if(_deq(a[i],a[k])){_uqpI=i;return k}return -1}var prim=true;for(i=0;i<n;i++){var x=a[i];if(x!==null&&typeof x==='object'){prim=false;break}}var m=new Map(),bi=-1,bj=-1;for(i=0;i<n;i++){var c=prim?a[i]:_cn(a[i]);var p=m.get(c);if(p===undefined)m.set(c,i);else if(p>=0){if(bi<0||p<bi){bi=p;bj=i}m.set(c,-1)}}if(bi<0)return -1;_uqpI=bi;return bj}"
+function emitUqp(ctx) {
+  emitUq(ctx)
+  hoistOnce(ctx, '_uqpHoisted', UQP_HELPER)
+  return '_uqp'
+}
+
+// An object or array a const error reports as `allowedValue`, parsed once per
+// compiled function rather than on every error: parsing it per error made
+// reading a const error two to five times what the check costs. A copy of its
+// own, not the compared constant, so an error a caller edits cannot change
+// what the validator compares against. Declared in the function's helper
+// code, so standalone output carries it the same way.
+function emitParamConstant(ctx, value) {
+  const name = `_pc${ctx.varCounter++}`
+  const decl = `const ${name}=JSON.parse(${JSON.stringify(JSON.stringify(value))})`
+  if (ctx.preamble) ctx.preamble.push(decl)
+  else ctx.helperCode.push(decl)
+  return name
+}
+
 // The compared value, parsed once at compile time. `JSON.parse` rather than a
 // JS object literal so a `__proto__` member stays an ordinary property.
 function emitConstant(ctx, value) {
@@ -1390,6 +1422,25 @@ function unevalPropsModeled(schema, schemaMap) {
   return true
 }
 
+// Every `$ref` string under a node, once per node.
+const _refStrings = new WeakMap()
+function refStringsOf(node) {
+  let set = _refStrings.get(node)
+  if (set !== undefined) return set
+  set = new Set()
+  const seen = new Set()
+  const walk = (n) => {
+    if (n === null || typeof n !== 'object' || seen.has(n)) return
+    seen.add(n)
+    if (Array.isArray(n)) { for (const x of n) walk(x); return }
+    if (typeof n.$ref === 'string') set.add(n.$ref)
+    for (const k of Object.keys(n)) if (k !== 'enum' && k !== 'const' && k !== 'default' && k !== 'examples') walk(n[k])
+  }
+  walk(node)
+  _refStrings.set(node, set)
+  return set
+}
+
 function codegenSafe(schema, schemaMap) {
   if (typeof schema === 'boolean') return true
   if (typeof schema !== 'object' || schema === null) return true
@@ -1505,8 +1556,9 @@ function codegenSafe(schema, schemaMap) {
     // that only the interpreted engine provides.
     if (schema.unevaluatedProperties === false || (typeof schema.unevaluatedProperties === 'object' && schema.unevaluatedProperties !== null)) {
       const evalResult = collectEvaluated(schema, schemaMap)
-      if (evalResult.dynamic && evalResult.allProps) return false
-      if (evalResult.dynamic && !unevalPropsModeled(schema, schemaMap)) return false
+      // What the static model cannot represent is built at run time
+      // (genUnevalDynamicVerdict); shapes that cannot be (dynamic references,
+      // reference cycles) decline there.
     }
   }
   // unevaluatedItems: allow boolean and schema values
@@ -1527,7 +1579,12 @@ function codegenSafe(schema, schemaMap) {
     // Defs on a $ref cycle compile as named functions (see genCode); nothing
     // to decline here. cyclicDefNames() is the walk that used to bail.
     for (const [name, def] of Object.entries(defs)) {
-      if (/[~/"']/.test(name)) return false // special chars in def name
+      // A name the generators would have to spell inside a path or an
+      // identifier. Only a problem when a reference names it: tsconfig.json
+      // keeps a comment object under the definition `//`, which nothing
+      // references, and declined whole for it. A definition reached through
+      // a deeper pointer was renamed by normalizeDeepRefs.
+      if (/[~/"']/.test(name) && refStringsOf(schema).has('#/' + (schema.$defs === defs ? '$defs' : 'definitions') + '/' + name.replace(/~/g, '~0').replace(/\//g, '~1'))) return false
       if (typeof def === 'boolean') return false
       if (typeof def === 'object' && def !== null) {
         // A non-fragment $id (e.g. 'sub.json', 'http://...') opens a new base URI
@@ -1587,37 +1644,6 @@ function codegenSafe(schema, schemaMap) {
   return true
 }
 
-// Returns true if the schema (or any nested sub-schema reachable through the
-// usual keywords) has additionalProperties as a schema value. Used by the
-// combined-codegen bail since that path does not emit the per-key loop yet.
-function hasAdditionalPropertiesSchema(schema) {
-  if (typeof schema !== 'object' || schema === null) return false
-  if (typeof schema.additionalProperties === 'object' && schema.additionalProperties !== null) return true
-  const objSubs = ['properties', 'patternProperties', '$defs', 'definitions', 'dependentSchemas']
-  for (const key of objSubs) {
-    if (schema[key] && typeof schema[key] === 'object') {
-      for (const v of Object.values(schema[key])) {
-        if (hasAdditionalPropertiesSchema(v)) return true
-      }
-    }
-  }
-  const arrSubs = ['allOf', 'anyOf', 'oneOf', 'prefixItems']
-  for (const key of arrSubs) {
-    if (Array.isArray(schema[key])) {
-      for (const s of schema[key]) {
-        if (hasAdditionalPropertiesSchema(s)) return true
-      }
-    }
-  }
-  const singleSubs = ['items', 'contains', 'not', 'if', 'then', 'else', 'propertyNames']
-  for (const key of singleSubs) {
-    if (typeof schema[key] === 'object' && schema[key] !== null) {
-      if (hasAdditionalPropertiesSchema(schema[key])) return true
-    }
-  }
-  return false
-}
-
 // Schema-bearing keywords, so the walk below never mistakes a property named
 // "$ref" for an actual reference.
 const SUBSCHEMA_MAPS = ['properties', 'patternProperties', '$defs', 'definitions', 'dependentSchemas']
@@ -2020,9 +2046,239 @@ function normalizePropertyNamesWalk(root) {
   return walk(root)
 }
 
+// A local `$ref` that is a JSON pointer to anything other than a top-level
+// definition (`#/definitions/item/properties/id`, `#/properties/foo`,
+// `#/$defs/a/items`) became the generators' own definition reference: the
+// pointer is resolved here, at compile time, and its target added as a
+// definition under a name of its own, so every path that already handles
+// `#/$defs/name` handles it, cycles included. The generators knew only the
+// top-level form and declined the rest, which kept 40 of 980 SchemaStore
+// schemas, tsconfig.json among them, on the interpreted engine for every
+// document. Left alone, as before: a pointer that does not resolve to a
+// schema, one that passes through a subschema with its own `$id` (another
+// base, whose pointers mean something else), and every `$ref` inside such a
+// subschema. Copy on write; errors keep their paths, which name the place of
+// the reference, not of its target, and are ordered against the schema as
+// the caller wrote it.
+const DEF_REF = /^#\/(?:\$defs|definitions)\/[^/]+$/
+const _deepRefsNormalized = new WeakMap()
+function normalizeDeepRefs(root) {
+  if (!root || typeof root !== 'object' || Array.isArray(root)) return root
+  const hit = _deepRefsNormalized.get(root)
+  if (hit !== undefined) return hit
+  const out = normalizeDeepRefsWalk(root)
+  _deepRefsNormalized.set(root, out)
+  return out
+}
+function resolveLocalPointer(root, ref) {
+  let node = root
+  const segs = ref.slice(2).split('/')
+  for (let i = 0; i < segs.length; i++) {
+    let seg = segs[i].replace(/~1/g, '/').replace(/~0/g, '~')
+    // Draft 7 schemas reach the generators with `definitions` renamed to
+    // `$defs` (lib/draft7.js) and their references as written, which the
+    // top-level form already reads either way; so does this.
+    if (i === 0 && (seg === 'definitions' || seg === '$defs') && !Object.prototype.hasOwnProperty.call(node, seg)) seg = seg === 'definitions' ? '$defs' : 'definitions'
+    if (node === null || typeof node !== 'object') return undefined
+    if (Array.isArray(node)) {
+      if (!/^(?:0|[1-9]\d*)$/.test(seg) || +seg >= node.length) return undefined
+      node = node[+seg]
+    } else {
+      if (!Object.prototype.hasOwnProperty.call(node, seg)) return undefined
+      node = node[seg]
+    }
+    if (node !== null && typeof node === 'object' && !Array.isArray(node) && typeof node.$id === 'string') return undefined
+  }
+  if (typeof node === 'boolean') return node
+  if (node === null || typeof node !== 'object' || Array.isArray(node)) return undefined
+  return node
+}
+function normalizeDeepRefsWalk(root) {
+  // First pass: the deep pointers used outside any nested `$id`, and their
+  // targets.
+  const targets = new Map()
+  const scan = (node, nested, seen) => {
+    if (node === null || typeof node !== 'object') return
+    if (seen.has(node)) return
+    seen.add(node)
+    if (Array.isArray(node)) { for (const n of node) scan(n, nested, seen); return }
+    const inner = nested || (node !== root && typeof node.$id === 'string')
+    if (!inner && typeof node.$ref === 'string' && node.$ref.startsWith('#/') && !DEF_REF.test(node.$ref) && !targets.has(node.$ref)) {
+      const t = resolveLocalPointer(root, node.$ref)
+      if (t !== undefined) targets.set(node.$ref, t)
+    }
+    for (const k of Object.keys(node)) if (k !== 'enum' && k !== 'const' && k !== 'default' && k !== 'examples') scan(node[k], inner, seen)
+  }
+  scan(root, false, new Set())
+  if (targets.size === 0) return root
+  const defsKey = root.$defs && typeof root.$defs === 'object' ? '$defs' : (root.definitions && typeof root.definitions === 'object' ? 'definitions' : '$defs')
+  const existing = root[defsKey] && typeof root[defsKey] === 'object' ? root[defsKey] : {}
+  const names = new Map()
+  let n = 0
+  for (const ref of targets.keys()) {
+    let name
+    do { name = '__ata_ptr_' + n++ } while (Object.prototype.hasOwnProperty.call(existing, name))
+    names.set(ref, name)
+  }
+  // Second pass: the references rewritten, copy on write, sharing one copy
+  // per node so a target reached twice stays one object.
+  const memo = new Map()
+  const walk = (node, nested) => {
+    if (node === null || typeof node !== 'object') return node
+    const key = nested ? null : node
+    if (key !== null && memo.has(key)) return memo.get(key)
+    if (Array.isArray(node)) {
+      let out = node
+      if (key !== null) memo.set(key, out)
+      for (let i = 0; i < node.length; i++) {
+        const w = walk(node[i], nested)
+        if (w !== node[i]) { if (out === node) { out = node.slice(); if (key !== null) memo.set(key, out) } out[i] = w }
+      }
+      return out
+    }
+    const inner = nested || (node !== root && typeof node.$id === 'string')
+    if (inner) return node
+    let out = node
+    memo.set(node, out)
+    const own = (k, v) => { if (out === node) { out = { ...node }; memo.set(node, out) } out[k] = v }
+    if (typeof node.$ref === 'string' && names.has(node.$ref)) own('$ref', '#/' + defsKey + '/' + names.get(node.$ref))
+    for (const k of Object.keys(node)) {
+      if (k === '$ref' || k === 'enum' || k === 'const' || k === 'default' || k === 'examples') continue
+      const v = node[k]
+      if (v === null || typeof v !== 'object') continue
+      const w = walk(v, false)
+      if (w !== v) own(k, w)
+    }
+    return out
+  }
+  const rewritten = walk(root, false)
+  const out = rewritten === root ? { ...root } : rewritten
+  const defs = { ...(out[defsKey] && typeof out[defsKey] === 'object' ? out[defsKey] : {}) }
+  for (const [ref, name] of names) {
+    const t = targets.get(ref)
+    defs[name] = typeof t === 'boolean' ? t : walk(t, false)
+  }
+  out[defsKey] = defs
+  return out
+}
+
+// Every reference the interpreted engine can resolve becomes a definition
+// reference the generators handle: URNs, `$id`-relative and absolute URIs,
+// anchors, pointers into a resource with its own `$id`, names with characters
+// the generators cannot spell, documents registered through `schemas`. The
+// target of each is found by the interpreter's own resolver (indexSchemas and
+// resolveRef in lib/interpreter.js), so the two engines cannot resolve a
+// reference differently, and is added under a name of its own as with
+// normalizeDeepRefs. Once every reference names a definition, nested `$id`s
+// no longer change what anything means and are dropped from the copy, which
+// is what kept those schemas from compiling. Left to normalizeDeepRefs, as
+// before: a schema with dynamic references (their meaning depends on the
+// resources at run time), one with an embedded resource in another dialect,
+// and one with any reference the resolver cannot resolve.
+const _refsNormalized = new WeakMap()
+function normalizeRefs(root, schemaMap) {
+  if (!root || typeof root !== 'object' || Array.isArray(root)) return root
+  let byMap = _refsNormalized.get(root)
+  const mapKey = schemaMap || _refsNormalized
+  if (byMap !== undefined && byMap.has(mapKey)) return byMap.get(mapKey)
+  let out
+  try { out = normalizeRefsWalk(root, schemaMap) } catch { out = null }
+  if (out === null) out = normalizeDeepRefs(root)
+  if (byMap === undefined) { byMap = new Map(); _refsNormalized.set(root, byMap) }
+  byMap.set(mapKey, out)
+  return out
+}
+const SKIP_VALUE_KEYS = new Set(['enum', 'const', 'default', 'examples'])
+function normalizeRefsWalk(root, schemaMap) {
+  const text = JSON.stringify(root)
+  if (!text.includes('"$ref"')) return root
+  if (/"\$(?:dynamicRef|recursiveRef|dynamicAnchor|recursiveAnchor)"/.test(text)) return null
+  const { indexSchemas, resolveRef } = require('./interpreter')._refInternals
+  const state = indexSchemas(root, schemaMap && schemaMap.size ? schemaMap : null)
+  const rootDialect = typeof root.$schema === 'string' ? root.$schema.replace(/#$/, '') : null
+  // Resolve every reference reachable from the root, following into targets
+  // in other documents.
+  const names = new Map() // target node -> synthetic name
+  const refTarget = new Map() // reference site node -> target node
+  const visited = new Set()
+  let fail = false
+  const visit = (node) => {
+    if (fail || node === null || typeof node !== 'object' || visited.has(node)) return
+    visited.add(node)
+    if (Array.isArray(node)) { for (const n of node) visit(n); return }
+    if (node !== root && typeof node.$schema === 'string' && rootDialect !== null && node.$schema.replace(/#$/, '') !== rootDialect) { fail = true; return }
+    // A dynamic reference reached through another document means the same as
+    // one in the root: its target depends on the resources at run time.
+    if (node.$dynamicRef !== undefined || node.$dynamicAnchor !== undefined || node.$recursiveRef !== undefined || node.$recursiveAnchor !== undefined) { fail = true; return }
+    if (typeof node.$ref === 'string' && state.nodeBase.has(node)) {
+      const base = state.nodeBase.get(node)
+      const ref = node.$ref
+      const local = base === state.rootBase && (ref === '#' || (DEF_REF.test(ref) && !/[~%]/.test(ref)))
+      if (!local) {
+        const { node: t } = resolveRef(ref, base, state)
+        if (t === undefined || (typeof t !== 'boolean' && (t === null || typeof t !== 'object' || Array.isArray(t)))) { fail = true; return }
+        refTarget.set(node, t)
+        // The root, however it is spelled, is `#`: a copy of it under its own
+        // definitions would contain itself.
+        if (t === root) { /* named '#' below */ }
+        else if (typeof t === 'object' && !names.has(t)) { names.set(t, null); visit(t) }
+        if (typeof t === 'boolean' && !names.has(t)) names.set(t, null)
+      }
+    }
+    for (const k of Object.keys(node)) if (!SKIP_VALUE_KEYS.has(k)) visit(node[k])
+  }
+  visit(root)
+  if (fail) return null
+  if (refTarget.size === 0) return root
+  const defsKey = root.$defs && typeof root.$defs === 'object' ? '$defs' : (root.definitions && typeof root.definitions === 'object' ? 'definitions' : '$defs')
+  const existing = root[defsKey] && typeof root[defsKey] === 'object' ? root[defsKey] : {}
+  let n = 0
+  for (const t of names.keys()) {
+    let name
+    do { name = '__ata_ref_' + n++ } while (Object.prototype.hasOwnProperty.call(existing, name))
+    names.set(t, name)
+  }
+  // The copy: references renamed, nested `$id`s dropped.
+  const memo = new Map()
+  const walk = (node) => {
+    if (node === null || typeof node !== 'object') return node
+    if (memo.has(node)) return memo.get(node)
+    if (Array.isArray(node)) {
+      const out = []
+      memo.set(node, out)
+      for (const x of node) out.push(walk(x))
+      return out
+    }
+    const out = {}
+    memo.set(node, out)
+    for (const k of Object.keys(node)) {
+      if (k === '$id' && node !== root) continue
+      if (k === '$ref' && refTarget.has(node)) {
+        const t = refTarget.get(node)
+        out.$ref = t === root ? '#' : '#/' + defsKey + '/' + names.get(t)
+        continue
+      }
+      out[k] = SKIP_VALUE_KEYS.has(k) ? node[k] : walk(node[k])
+    }
+    return out
+  }
+  const out = walk(root)
+  const defs = { ...(out[defsKey] && typeof out[defsKey] === 'object' ? out[defsKey] : {}) }
+  for (const [t, name] of names) defs[name] = typeof t === 'boolean' ? t : walk(t)
+  out[defsKey] = defs
+  return out
+}
+
+// What the three generators compile from: the schema with deep local pointers
+// turned into definition references, then propertyNames normalized. The same
+// for all three, so they decline and agree on the same schemas.
+function prepareForCodegen(schema, schemaMap) {
+  return normalizePropertyNames(normalizeRefs(schema, schemaMap))
+}
+
 function compileToJSCodegen(schema, schemaMap, userFormats, opts) {
   const inputSchema = schema
-  schema = normalizePropertyNames(schema)
+  schema = prepareForCodegen(schema, schemaMap)
   if (typeof schema === 'boolean') return schema ? () => true : () => false
   if (typeof schema !== 'object' || schema === null) return null
   // removeAdditional: a verdict function that deletes the keys the remover
@@ -2093,7 +2349,14 @@ function compileToJSCodegen(schema, schemaMap, userFormats, opts) {
   if (hasUnresolvableRef(schema, rootDefs, anchors, schemaMap, new Set())) return null
   if (needsBaseTracking(schema, schemaMap, new Set())) return null
 
-  const ctx = { varCounter: 0, helpers: [], helperCode: [], preamble: [], shared: [], closureVars: ['_cpLen'], closureVals: [_cpLen], rootDefs, refStack: new Set(), schemaMap: schemaMap || null, anchors, rootSchema: inputSchema, userFormats: userFormats || null, removeNodes }
+  const ctx = { varCounter: 0, helpers: [], helperCode: [], preamble: [], shared: [], closureVars: ['_cpLen'], closureVals: [_cpLen], rootDefs, refStack: new Set(), schemaMap: schemaMap || null, anchors, rootSchema: inputSchema, userFormats: userFormats || null, removeNodes,
+    keywords: (opts && opts.keywords) || null, kwEmitted: null }
+  if (ctx.keywords) {
+    // Macro keywords expand into a schema of their own, which this generator
+    // does not apply; such a schema stays on the interpreted engine.
+    if (usesMacroKeyword(schema, schemaMap, ctx.keywords)) return null
+    ctx.kwEmitted = new Set()
+  }
   const lines = []
   try {
     genCode(schema, 'd', lines, ctx)
@@ -2101,6 +2364,16 @@ function compileToJSCodegen(schema, schemaMap, userFormats, opts) {
     if (e === DECLINE) return null
     throw e
   }
+  // Every schema node that carries a custom keyword must have had its check
+  // written. A path that inlined a node without going through genCodeNode
+  // would drop the keyword and accept what it should reject, so a node that
+  // was not reached declines the whole schema to the interpreted engine
+  // instead. Unreferenced definitions decline too: slower, never wrong.
+  if (ctx.keywords) {
+    for (const node of keywordNodes(schema, schemaMap, ctx.keywords)) {
+      if (!ctx.kwEmitted.has(node)) return null
+    }
+  }
 
   // Append deferred checks (additionalProperties, unevaluatedProperties) at the end
   if (ctx.deferredChecks) {
@@ -2137,7 +2410,7 @@ function compileToJSCodegen(schema, schemaMap, userFormats, opts) {
   // are built when first asked for, not here: most validators never call
   // validateJSON or get extended, and rewriting and compiling the source twice
   // more on every schema was about a third of what a first call cost.
-  let body, hybridThunk, tailThunk
+  let body, hybridThunk, tailThunk, resultThunk
   if (ctx.usesRecursion) {
     // Self-recursive: a named body reached through the cycle guard, so data
     // that points back at itself settles instead of exhausting the stack.
@@ -2147,6 +2420,7 @@ function compileToJSCodegen(schema, schemaMap, userFormats, opts) {
     body = `${decl}function _run(d){\n  ${run}\n  }\n  return _run(d)`
     // Hybrid: keep the boolean answer, wrap only the outer call
     hybridThunk = () => `${decl}function _run(d){\n  ${run}\n  }\n  return _run(d)?R:E(d)`
+    resultThunk = () => `${decl}function _run(d){\n  ${run}\n  }\n  return _run(d)?${RESULT_TRUE}:${RESULT_FALSE}`
     tailThunk = () => `${decl}function _run(d){\n  ${run}\n  }\n  return _run(d)&&__ataTail(d)`
   } else if (defSets.length > 0) {
     // No self-reference at the root, but a def on a cycle can still be
@@ -2154,10 +2428,12 @@ function compileToJSCodegen(schema, schemaMap, userFormats, opts) {
     const run = emitGuardedRun(`return _body(d)`, '', defSets)
     body = `function _body(d){\n  ${checkStr}\n  return true\n  }\n  function _run(d){\n  ${run}\n  }\n  return _run(d)`
     hybridThunk = () => `function _body(d){\n  ${checkStr}\n  return true\n  }\n  function _run(d){\n  ${run}\n  }\n  return _run(d)?R:E(d)`
+    resultThunk = () => `function _body(d){\n  ${checkStr}\n  return true\n  }\n  function _run(d){\n  ${run}\n  }\n  return _run(d)?${RESULT_TRUE}:${RESULT_FALSE}`
     tailThunk = () => `function _body(d){\n  ${checkStr}\n  return true\n  }\n  function _run(d){\n  ${run}\n  }\n  return _run(d)&&__ataTail(d)`
   } else {
     body = checkStr + '\n  return true'
     hybridThunk = () => replaceTopLevel(checkStr + '\n  return R')
+    resultThunk = () => replaceTopLevel(checkStr + '\n  return true', `return ${RESULT_TRUE}`, `return ${RESULT_FALSE}`)
     // An early accept inside the checks has to reach the tail too, so every
     // top-level `return true` becomes the tail call, by the same rewrite the
     // hybrid above relies on and test_hybrid_agreement holds to the suite.
@@ -2197,6 +2473,25 @@ function compileToJSCodegen(schema, schemaMap, userFormats, opts) {
       return hybridFactory === null ? null : hybridFactory(...closureValues, R, E)
     }
 
+    // validate() itself: the same checks returning the result objects, for a
+    // validator past its first calls (see validator-core). One function per
+    // schema means the result is built at an allocation site of its own and
+    // nothing between the caller and the checks is shared with other schemas.
+    // Shared wrappers are what made reading results slow across many schemas:
+    // every validator's calls went through the same few call sites. The
+    // rejection is the lazy one, built from the arguments.
+    let resultFactory
+    boolFn._resultFactory = (LR, B, W, EE) => {
+      if (resultFactory === undefined) {
+        try {
+          resultFactory = new Function(...closureNames, '__ataLR', '__ataB', '__ataW', '__ataEE', `${preambleStr}return function(d){${resultThunk()}}`)
+        } catch {
+          resultFactory = null
+        }
+      }
+      return resultFactory === null ? null : resultFactory(...closureValues, LR, B, W, EE)
+    }
+
     // The same function with one more check where it would return true, for a
     // wrapper that enforces something the schema does not carry (see
     // Validator#_extendVerdict). Calling the check from here rather than from a
@@ -2274,40 +2569,75 @@ function compileToJSCodegen(schema, schemaMap, userFormats, opts) {
 
 // Replace top-level `return false` → `return E(d)` and `return true` → `return R`.
 // Tracks function nesting depth to preserve nested function internals.
+const RESULT_TRUE = '{valid:true,data:d,errors:__ataEE}'
+const RESULT_FALSE = 'new __ataLR(__ataB,d,__ataW)'
+// The end of the string literal that starts at `i` (a quote character), or
+// the end of the code when it does not close.
+function skipString(code, i) {
+  const q = code[i]
+  let j = i + 1
+  while (j < code.length) {
+    const c = code[j]
+    if (c === '\\') { j += 2; continue }
+    if (c === q) return j + 1
+    j++
+  }
+  return code.length
+}
+
 function replaceTopLevel(code, onTrue = 'return R', onFalse = 'return E(d)') {
   let fnDepth = 0, result = '', i = 0
   while (i < code.length) {
+    // String literals are copied as they are. A property called `function`
+    // reads `d["function"]`, and the scan took the word for a nested function
+    // and left every return after it alone, so the hybrid returned a bare
+    // `false` where a result was due: validateJSON answered `false` instead
+    // of a rejection for such schemas. Text such as `return false` or a brace
+    // inside a string is not code either.
+    const ch = code[i]
+    if (ch === '"' || ch === "'" || ch === '`') {
+      const j = skipString(code, i)
+      result += code.slice(i, j)
+      i = j
+      continue
+    }
     // A nested closure keeps its own returns. Both spellings count: a
     // `function` keyword and an arrow with a block body. The inline pattern
     // compiler emits `(()=>{...return false...return true})()` and rewriting
     // those returns turned the arrow's boolean into an object, which made
     // `!(cond && obj)` false and let the hybrid accept what the boolean
     // program rejected.
-    const isFunctionKw = code.startsWith('function', i) && (i === 0 || /[^a-zA-Z_$]/.test(code[i - 1]))
+    const isFunctionKw = code.startsWith('function', i) && (i === 0 || /[^a-zA-Z_$]/.test(code[i - 1])) && !/[a-zA-Z0-9_$]/.test(code[i + 8] || '')
     const isArrowBlock = code.startsWith('=>{', i)
     if (isFunctionKw || isArrowBlock) {
-      // Skip to the opening brace, then track all braces inside the body.
+      // Skip to the opening brace, then track all braces inside the body,
+      // strings skipped as above.
       let j = isArrowBlock ? i + 2 : i + 8
       while (j < code.length && code[j] !== '{') j++
       result += code.slice(i, j + 1)
       i = j + 1
-      // Track braces inside this function body
       let braceDepth = 1
       while (i < code.length && braceDepth > 0) {
-        if (code[i] === '{') braceDepth++
-        else if (code[i] === '}') braceDepth--
-        if (braceDepth > 0) result += code[i]
-        else result += '}'  // closing brace of function
+        const c = code[i]
+        if (c === '"' || c === "'" || c === '`') {
+          const k = skipString(code, i)
+          result += code.slice(i, k)
+          i = k
+          continue
+        }
+        if (c === '{') braceDepth++
+        else if (c === '}') braceDepth--
+        result += c
         i++
       }
-    } else if (code.startsWith('return false', i)) {
+    } else if (code.startsWith('return false', i) && (i + 12 >= code.length || !/[a-zA-Z0-9_$]/.test(code[i + 12]))) {
       result += onFalse
       i += 12
-    } else if (code.startsWith('return true', i) && (i + 11 >= code.length || !/[a-zA-Z_$]/.test(code[i + 11]))) {
+    } else if (code.startsWith('return true', i) && (i + 11 >= code.length || !/[a-zA-Z0-9_$]/.test(code[i + 11]))) {
       result += onTrue
       i += 11
     } else {
-      result += code[i]
+      result += ch
       i++
     }
   }
@@ -2449,6 +2779,115 @@ function _deferOrInline(ctx, lines, v, check) {
 // 'object' = we know v is a non-null non-array object
 // 'array'  = we know v is an array
 // 'string' / 'number' / 'integer' = we know the primitive type
+// Custom keywords (the `keywords` option, normalized by lib/keywords.js) as
+// calls into the caller's functions, threaded in as closure variables the way
+// user formats are. Each check is built here with the interpreter's own
+// semantics, so the two engines cannot disagree on one: the keyword is skipped
+// for data outside its declared types (the interpreter's type bits), the
+// compile form is built once per schema node, and any errors the function
+// leaves on itself are cleared after the call, as runCustomV does. Written
+// first in the node, before anything that could return early.
+// The interpreter's type bits (lib/interpreter.js typeBit and dataBits),
+// copied rather than required: loading the interpreter added about a
+// millisecond to the first call of a schema that never needs it.
+// tests/test_custom_keyword_codegen.js holds the copies equal to the originals.
+const KW_T_ANY = 127
+function kwTypeBit (name) {
+  switch (name) {
+    case 'string': return 1
+    case 'number': return 2
+    case 'integer': return 4
+    case 'boolean': return 8
+    case 'null': return 16
+    case 'object': return 32
+    case 'array': return 64
+    default: return KW_T_ANY
+  }
+}
+function kwDataBits (d) {
+  switch (typeof d) {
+    case 'string': return 1
+    case 'number':
+      if (!isFinite(d)) return 0
+      return Number.isInteger(d) ? 2 | 4 : 2
+    case 'boolean': return 8
+    case 'object':
+      if (d === null) return 16
+      return Array.isArray(d) ? 64 : 32
+    default: return 0
+  }
+}
+function genCustomKeywords (schema, v, lines, ctx) {
+  for (const key of Object.keys(schema)) {
+    const def = ctx.keywords[key]
+    if (def === undefined || def.macro !== null) continue
+    const value = schema[key]
+    const dataBits = kwDataBits
+    const T_ANY = KW_T_ANY
+    let mask = T_ANY
+    if (def.types !== null) {
+      mask = 0
+      for (const t of def.types) mask |= kwTypeBit(t)
+    }
+    let fn
+    if (def.compile !== null) {
+      fn = def.compile(value, schema)
+      if (typeof fn !== 'function') throw new Error(`keyword "${key}": compile must return a function`)
+    } else {
+      const validate = def.validate
+      fn = (data) => validate(value, data, schema)
+      fn.source = validate
+    }
+    const holder = () => fn.source || fn
+    const check = mask === T_ANY
+      ? (data) => { const ok = fn(data); const h = holder(); if (h.errors) h.errors = null; return !!ok }
+      : (data) => {
+          if ((dataBits(data) & mask) === 0) return true
+          const ok = fn(data); const h = holder(); if (h.errors) h.errors = null; return !!ok
+        }
+    const name = '_kwc' + ctx.closureVars.length
+    ctx.closureVars.push(name)
+    ctx.closureVals.push(check)
+    lines.push(`if(!${name}(${v}))return false`)
+  }
+  ctx.kwEmitted.add(schema)
+}
+
+// Map keys under these are names, not keywords (lib/keywords.js NAME_MAPS).
+const KW_NAME_MAPS = new Set([
+  'properties', 'patternProperties', '$defs', 'definitions',
+  'dependentSchemas', 'dependentRequired', 'dependencies', 'propertyDependencies',
+])
+function forEachKeywordNode (schema, schemaMap, keywords, visit) {
+  const seen = new Set()
+  const walk = (node, keysAreNames) => {
+    if (node === null || typeof node !== 'object' || seen.has(node)) return
+    seen.add(node)
+    if (Array.isArray(node)) { for (const item of node) walk(item, false); return }
+    let has = false
+    for (const key of Object.keys(node)) {
+      if (!keysAreNames && keywords[key] !== undefined) has = true
+      const val = node[key]
+      if (val !== null && typeof val === 'object') walk(val, !keysAreNames && KW_NAME_MAPS.has(key))
+    }
+    if (has) visit(node)
+  }
+  walk(schema, false)
+  if (schemaMap) for (const s of schemaMap.values()) walk(s, false)
+}
+function keywordNodes (schema, schemaMap, keywords) {
+  const out = []
+  forEachKeywordNode(schema, schemaMap, keywords, (n) => out.push(n))
+  return out
+}
+function usesMacroKeyword (schema, schemaMap, keywords) {
+  let macro = false
+  forEachKeywordNode(schema, schemaMap, keywords, (n) => {
+    for (const key of Object.keys(n)) if (keywords[key] !== undefined && keywords[key].macro !== null) macro = true
+  })
+  return macro
+}
+
 function genCode(schema, v, lines, ctx, knownType) {
   return withPlain(schema, v, lines, ctx, () => genCodeNode(schema, v, lines, ctx, knownType))
 }
@@ -2459,6 +2898,7 @@ function genCodeNode(schema, v, lines, ctx, knownType) {
   if (schema === false) { lines.push('return false'); return }
   if (schema === true) return
   if (typeof schema !== 'object' || schema === null) return
+  if (ctx.keywords) genCustomKeywords(schema, v, lines, ctx)
   if (!ctx.regExpMap) {
     ctx.regExpMap = new Map();
   }
@@ -3381,14 +3821,32 @@ function genPatternPropertiesNode(schema, v, lines, ctx, knownType, isObj) {
   return handledPropertyNames
 }
 
+// Whether the static unevaluatedProperties model checks the anyOf itself, so
+// genCodeNode leaves it out. Not when the set is built at run time
+// (unevalBuiltAtRuntime): that form only collects, and dropping the anyOf
+// there accepted a document no branch matched.
 function unevalChecksAnyOf(schema, ctx) {
   if (schema.unevaluatedProperties !== false) return false
   const r = collectEvaluated(schema, ctx.schemaMap, ctx.rootDefs)
-  return r.dynamic && !r.allProps
+  return r.dynamic && !r.allProps && !unevalBuiltAtRuntime(schema, ctx, r)
+}
+
+// The unevaluatedProperties forms the static model cannot represent; those
+// build the evaluated set at run time (genUnevalDynamicVerdict). Decided in
+// one place so genCodeNode and genUnevaluatedPropertiesNode cannot disagree
+// about which of them checks the node's anyOf.
+function unevalBuiltAtRuntime(schema, ctx, r) {
+  if (schema.unevaluatedProperties === true || schema.unevaluatedProperties === undefined) return false
+  if (r === undefined) r = collectEvaluated(schema, ctx.schemaMap, ctx.rootDefs)
+  return r.dynamic && (r.allProps || !unevalPropsModeled(schema, ctx.schemaMap))
 }
 
 function genUnevaluatedPropertiesNode(schema, v, lines, ctx, knownType, isObj, hoisted, earlyKeyCount) {
   const evalResult = collectEvaluated(schema, ctx.schemaMap, ctx.rootDefs)
+  if (unevalBuiltAtRuntime(schema, ctx, evalResult)) {
+    genUnevalDynamicVerdict(schema, v, lines, ctx, isObj)
+    return
+  }
 
   if (evalResult.allProps || schema.unevaluatedProperties === true) {
     // All props evaluated or unevaluatedProperties:true — no-op
@@ -4204,7 +4662,7 @@ function unevalLocalOk (node, key) {
 // generic and may visit data positions (an enum value, say); judging those is
 // harmless, since a data node that fails the test only makes the answer more
 // conservative and the generators never read data positions as schemas.
-function unevalAllProvablyLocal (root) {
+function unevalAllProvablyLocal (root, only) {
   const seen = new Set()
   const stack = [root]
   while (stack.length) {
@@ -4212,7 +4670,7 @@ function unevalAllProvablyLocal (root) {
     if (n === null || typeof n !== 'object' || seen.has(n)) continue
     seen.add(n)
     if (!Array.isArray(n)) {
-      if (n.unevaluatedProperties !== undefined && !unevalLocalOk(n, 'unevaluatedProperties')) return false
+      if (only !== 'items' && n.unevaluatedProperties !== undefined && !unevalLocalOk(n, 'unevaluatedProperties')) return false
       if (n.unevaluatedItems !== undefined && !unevalLocalOk(n, 'unevaluatedItems')) return false
     }
     for (const k of Array.isArray(n) ? n : Object.values(n)) stack.push(k)
@@ -4269,7 +4727,7 @@ function genCharCodeSwitch(keys, v) {
 // Valid path is still fast — only error path does extra work.
 function compileToJSCodegenWithErrors(schema, schemaMap, userFormats, sourceOpts) {
   const inputSchema = schema
-  schema = normalizePropertyNames(schema)
+  schema = prepareForCodegen(schema, schemaMap)
   // unevaluated* is generated only where it is provably its plain counterpart
   // (see unevalLocalOk); any occurrence that is not keeps the whole schema on
   // the interpreted engine's error path, exactly as before.
@@ -4502,7 +4960,14 @@ function emitBranchCollapse (branches, keyword, v, pathExpr, lines, ctx, schemaP
     const subLines = []
     const subSp = branchSp + '/' + i
     if (typeof sub === 'object' && sub !== null) {
-      genCodeE(sub, '_bv', '_bpth', subLines, ctx, subSp)
+      // A branch is a function of its own with a local `_e`; a collapse
+      // inside it reports there, not into the combined function's lists.
+      ctx.inBranchFn = (ctx.inBranchFn || 0) + 1
+      try {
+        genCodeE(sub, '_bv', '_bpth', subLines, ctx, subSp)
+      } finally {
+        ctx.inBranchFn--
+      }
     } else if (sub === false) {
       // A false branch never matches; it reports the same error the
       // interpreter attaches to a false schema.
@@ -4526,8 +4991,19 @@ function emitBranchCollapse (branches, keyword, v, pathExpr, lines, ctx, schemaP
   const pp = pathExpr || '""'
   ctx.helperCode.push(`const ${fnArr}=[${fns.map((b) => b === '' ? `function(){return{valid:true,errors:[]}}` : `function(${params}){${b}}`).join(',')}];const _bt${fi}=${titleArr}`)
   const call = `${fnArr}[_bi](${v},_pp${fi},_all${usesSp ? ',_sp' : ''})`
-  const ord = (() => { const o = ordinalFor(ctx.rootSchema, branchSp); return o === null ? 'null' : o })()
-  const report = `const ${collapsed}=__ataCollapse('${branchKw}',${resArr},_pp${fi},'${branchSp}',${ord});if(${collapsed}){_e.push(${collapsed});if(!_all)return{valid:false,errors:_e}}`
+  // branchSp is source text for a quoted literal, with backslashes and quotes
+  // escaped; the ordinal is looked up by the path itself. Looked up by the
+  // text, a path through a pattern such as `^\\d+$` found no node, or the
+  // wrong one, and the collapsed error sorted out of place against the other
+  // engines.
+  // In the runtime shape there is no ordering key (the reader looks the path
+  // up), so the collapsed error is in its final shape as it is built.
+  const ord = ctx.noOrdinal ? 'null' : (() => { const o = ordinalFor(ctx.rootSchema, unescapeSp(branchSp)); return o === null ? 'null' : o })()
+  // In the combined function `_e` is created on the first error and every
+  // error is collected (`_all` is true there), so the report only pushes.
+  const report = ctx.inCombined && !ctx.inBranchFn
+    ? `const ${collapsed}=__ataCollapse('${branchKw}',${resArr},_pp${fi},'${branchSp}',${ord},_bt${fi});if(${collapsed})(_e||(_e=[])).push(${collapsed})`
+    : `const ${collapsed}=__ataCollapse('${branchKw}',${resArr},_pp${fi},'${branchSp}',${ord},_bt${fi});if(${collapsed}){_e.push(${collapsed});if(!_all)return{valid:false,errors:_e}}`
   if (keyword === 'anyOf') {
     // anyOf reports nothing once a branch passes, so the branches are first
     // only asked whether they pass. They are called with `_all` set to 0, a
@@ -4541,12 +5017,12 @@ function emitBranchCollapse (branches, keyword, v, pathExpr, lines, ctx, schemaP
     // no one read. Only when no branch passes do they run again with the
     // caller's `_all`, and the collapse sees them all, as before.
     const probe = `${fnArr}[_bi](${v},_pp${fi},0${usesSp ? ',_sp' : ''})`
-    lines.push(`{const _pp${fi}=${pp};let _bp${fi}=false;for(let _bi=0;_bi<${fnArr}.length;_bi++){if(${probe}.valid){_bp${fi}=true;break}}if(!_bp${fi}){if(_all===0){_e.push(null);return{valid:false,errors:_e}}const ${resArr}=[];for(let _bi=0;_bi<${fnArr}.length;_bi++){const _br=${call};${resArr}.push({valid:false,errors:_br.errors,title:_bt${fi}[_bi]})}${report}}}`)
+    lines.push(`{const _pp${fi}=${pp};let _bp${fi}=false;for(let _bi=0;_bi<${fnArr}.length;_bi++){if(${probe}.valid){_bp${fi}=true;break}}if(!_bp${fi}){if(_all===0){_e.push(null);return{valid:false,errors:_e}}const ${resArr}=[];for(let _bi=0;_bi<${fnArr}.length;_bi++){const _br=${call};${resArr}.push(_br.valid?{valid:false,errors:_br.errors}:_br)}${report}}}`)
   } else {
     // Asked only whether it passes (`_all` 0, see anyOf above), oneOf counts
     // the passing branches and answers; the branch errors of a probe are not
     // errors anyone reads and are not collapsed.
-    lines.push(`{const _pp${fi}=${pp};const ${resArr}=[];for(let _bi=0;_bi<${fnArr}.length;_bi++){const _br=${call};${resArr}.push({valid:_br.valid,errors:_br.errors,title:_bt${fi}[_bi]})}if(_all===0){let _n=0;for(const _r of ${resArr})if(_r.valid)_n++;if(_n!==1){_e.push(null);return{valid:false,errors:_e}}}else{${report}}}`)
+    lines.push(`{const _pp${fi}=${pp};const ${resArr}=[];for(let _bi=0;_bi<${fnArr}.length;_bi++)${resArr}.push(${call});if(_all===0){let _n=0;for(const _r of ${resArr})if(_r.valid)_n++;if(_n!==1){_e.push(null);return{valid:false,errors:_e}}}else{${report}}}`)
   }
 }
 
@@ -4574,6 +5050,13 @@ function genCodeENode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   }
   // $ref — resolve local and cross-schema refs
   if (schema.$ref) {
+    // The reference is followed and the rest of the node is not compiled; a
+    // keyword beside it that validates would be dropped, so the node
+    // declines (as in genCodeCNode). Reached since unevaluatedProperties
+    // next to a $ref stopped declining the combined function, whose oneOf
+    // and anyOf branches come from this generator: a branch was taken as
+    // passing with its siblings unchecked.
+    for (const k of Object.keys(schema)) if (!REF_NEUTRAL_SIBLINGS.has(k) && !k.startsWith('x-')) throw DECLINE
     // A self-reference cannot be expressed here yet: the root helper takes no
     // path argument, so errors raised through it would carry the path of the
     // root rather than of the value that failed. This used to fall through as
@@ -4674,7 +5157,9 @@ function genCodeENode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
       }
     })
     const expected = types.join(', ')
-    const expectedParam = types.length === 1 ? `'${types[0]}'` : JSON.stringify(types)
+    // As written: a one-element array stays an array, as the interpreted engine
+    // reports it.
+    const expectedParam = !Array.isArray(schema.type) ? `'${types[0]}'` : JSON.stringify(types)
     {
       const typeSp = `${schemaPrefix}/type`
       const lit = buildErrorLiteral({ keyword: 'type', schemaPath: typeSp, sourceMap: ctx.sourceMap })
@@ -4705,7 +5190,7 @@ function genCodeENode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     if (cv === null || typeof cv !== 'object') {
       lines.push(`if(${v}!==${JSON.stringify(cv)}){${fail('const', 'const', `{allowedValue:${JSON.stringify(schema.const)}}`, "'must be equal to constant'")}}`)
     } else {
-      lines.push(`if(!${emitDeq(ctx)}(${v},${emitConstant(ctx, cv)})){${fail('const', 'const', `{allowedValue:JSON.parse(${JSON.stringify(JSON.stringify(schema.const))})}`, "'must be equal to constant'")}}`)
+      lines.push(`if(!${emitDeq(ctx)}(${v},${emitConstant(ctx, cv)})){${fail('const', 'const', `{allowedValue:${emitParamConstant(ctx, schema.const)}}`, "'must be equal to constant'")}}`)
     }
   }
 
@@ -4875,6 +5360,11 @@ function genCodeENode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   // to emit. The error keeps the keyword's own identity: the interpreted
   // engine reports these as unevaluatedProperties with the key named, and the
   // two engines are pinned to identical output.
+  // Inside the combined function (a oneOf or anyOf branch, see
+  // emitBranchCollapse) this generator only has the static form. A branch
+  // whose evaluated set depends on its own branches would report the wrong
+  // errors, and the collapse would pick the wrong closest branch; declined.
+  if (ctx.inCombined && schema.unevaluatedProperties !== undefined && schema.unevaluatedProperties !== true && !unevalLocalOk(schema, 'unevaluatedProperties')) throw DECLINE
   if (schema.unevaluatedProperties === false && schema.additionalProperties === undefined) genUnevaluatedFalseE(schema, v, pathExpr, lines, ctx, schemaPrefix, isObj)
 
   // unevaluatedItems: false under the same rule. The interpreted engine
@@ -4985,18 +5475,10 @@ function genDynamicRefE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
 
 function genUniqueItemsE(schema, v, pathExpr, lines, ctx, schemaPrefix, fail, isArr) {
   const si = ctx.varCounter++
-  const itemType = schema.items && typeof schema.items === 'object' && schema.items.type
-  const isPrim = itemType === 'string' || itemType === 'number' || itemType === 'integer'
-  const maxItems = schema.maxItems
   const failExpr = (iVar, jVar) => fail('uniqueItems', 'uniqueItems', `{i:${iVar},j:${jVar}}`, `'must NOT have duplicate items (items ## '+${jVar}+' and '+${iVar}+' are identical)'`)
-  let inner
-  if (isPrim && maxItems && maxItems <= 16) {
-    inner = `for(let _i=1;_i<${v}.length;_i++){for(let _k=0;_k<_i;_k++){if(${v}[_i]===${v}[_k]){${failExpr('_k', '_i')};break}}}`
-  } else if (isPrim) {
-    inner = `const _s${si}=new Map();for(let _i=0;_i<${v}.length;_i++){const _prev=_s${si}.get(${v}[_i]);if(_prev!==undefined){${failExpr('_prev', '_i')};break};_s${si}.set(${v}[_i],_i)}`
-  } else {
-    inner = `const _cn${si}=function(x){if(x===null||typeof x!=='object')return typeof x+':'+x;if(Array.isArray(x))return'['+x.map(_cn${si}).join(',')+']';return'{'+Object.keys(x).sort().map(function(k){return JSON.stringify(k)+':'+_cn${si}(x[k])}).join(',')+'}'};const _s${si}=new Map();for(let _i=0;_i<${v}.length;_i++){const _k=_cn${si}(${v}[_i]);const _prev=_s${si}.get(_k);if(_prev!==undefined){${failExpr('_prev', '_i')};break};_s${si}.set(_k,_i)}`
-  }
+  // Only reached once the verdict has rejected, or when errors are wanted, so
+  // one strategy for every item type: the hoisted pair finder. See UQP_HELPER.
+  const inner = `const _j${si}=${emitUqp(ctx)}(${v});if(_j${si}>=0){const _i${si}=_uqpI;${failExpr('_i' + si, '_j' + si)}}`
   lines.push(isArr ? `{${inner}}` : `if(Array.isArray(${v})){${inner}}`)
 }
 
@@ -5211,29 +5693,80 @@ function genIfE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
 // Returns VALID_RESULT for valid data, {valid:false, errors} for invalid.
 // Avoids double-pass (jsFn → false → errFn runs same checks again).
 // Uses type-aware optimizations: after type check passes, skip guards.
+// An error literal the combined function shares between calls, frozen. Two
+// non-enumerable fields ride along, invisible to Object.keys, spread and
+// JSON: `_s` says the object is shared, so the reader copies it before handing
+// it out (Object.isFrozen, the check it replaces, cost more than the copy),
+// and `_o` is its schema ordinal, known here and otherwise looked up by path
+// on every read. An `_o` the literal already carries, for standalone output,
+// is kept. `_t` is an empty slot lib/enrich-error.js fills once.
+function sharedErr (lit, rootSchema) {
+  Object.defineProperty(lit, '_s', { value: true })
+  // A slot the enrichment fills on the first read with the fields that depend
+  // only on this literal (code, expected, rank), so later reads skip them.
+  Object.defineProperty(lit, '_t', { value: {} })
+  if (lit._o === undefined) {
+    const o = ordinalFor(rootSchema, lit.schemaPath)
+    if (typeof o === 'number') Object.defineProperty(lit, '_o', { value: o })
+  }
+  return Object.freeze(lit)
+}
+
+// The push for one error in the combined generator. With `ctx.rich` (the
+// validator's errors are being read and enriched, see validator-core) the
+// error is built in its final enriched shape where it happens, by makeRich in
+// lib/enrich-site.js with a site record made here at compile time; otherwise
+// it is the plain literal `lean` the generator always emitted. `valueExpr` is
+// the value at `pathExpr`, which enrichment otherwise finds again by walking
+// the document. `paramsShared` names a frozen params object hoisted for a
+// static site, so a static error's params stay one shared object as before.
+function errPushC(ctx, keyword, sp, pathExpr, paramsCode, msgCode, valueExpr, lean, paramsShared) {
+  if (!ctx.rich) return `(_e||(_e=[])).push(${lean})`
+  if (!ctx.richMk) {
+    ctx.richMk = true
+    const { makeRich } = require('./enrich-site')
+    ctx.closureVars.push('_mk'); ctx.closureVals.push(makeRich)
+  }
+  let paramsVal
+  try { paramsVal = Function('return ' + paramsCode)() } catch { paramsVal = undefined }
+  const fmt = keyword === 'format' && paramsVal ? paramsVal.format : undefined
+  const { errorSite } = require('./enrich-site')
+  const siteVar = `_S${ctx.varCounter++}`
+  ctx.closureVars.push(siteVar)
+  ctx.closureVals.push(errorSite(keyword, unescapeSp(sp), paramsVal, fmt))
+  return `(_e||(_e=[])).push(_mk(${siteVar},${pathExpr || '""'},${paramsShared || paramsCode},${msgCode},${valueExpr},d))`
+}
+
 function compileToJSCombined(schema, VALID_RESULT, schemaMap, userFormats, opts) {
   const inputSchema = schema
-  schema = normalizePropertyNames(schema)
+  schema = prepareForCodegen(schema, schemaMap)
   // Same provably-local rule as the error generator above.
   if (typeof schema === 'object' && schema !== null) {
     const s = JSON.stringify(schema)
-    if ((s.includes('unevaluatedProperties') || s.includes('unevaluatedItems')) && !unevalAllProvablyLocal(schema)) return null
+    // unevaluatedProperties that is not provably local is built at run time
+    // (genUnevaluatedDynamicC); unevaluatedItems still has to be local.
+    if (s.includes('unevaluatedItems') && !unevalAllProvablyLocal(schema, 'items')) return null
     // Bail on self-referencing schemas — combined codegen doesn't support recursion
     if (s.includes('"$ref":"#"')) return null
     // Defs on a $ref cycle compile as named functions in the boolean and
     // errors generators; this generator has no preamble for them, so it
     // declines and the router uses the errors generator.
     if (cyclicDefNames(schema.$defs || schema.definitions).size) return null
-    // Bail on additionalProperties as a schema — combined path doesn't emit the
-    // per-key sub-schema loop yet. The jsFn + errFn fallback handles it correctly.
-    if (hasAdditionalPropertiesSchema(schema)) return null
     // Bail on oneOf/anyOf — branch-collapse aggregation lives in genCodeE only.
     // Letting genCodeC emit the legacy "must match exactly one" placeholder
     // would short-circuit the ATA4001/ATA4002/ATA4003 contract. The boolean
     // fast path plus errFn fallback handles these schemas with collapse.
-    if (s.includes('"oneOf"') || s.includes('"anyOf"')) return null
+    // Branches are collapsed into one error by the error generator's emitter
+    // (emitBranchCollapse). Its errors are plain, so the rich form, which
+    // builds every error enriched where it fails, declines them.
+    // In the rich form the collapsed error and its branch errors come out
+    // plain (the branches are the error generator's) and are enriched when
+    // presented; every other error is built enriched. See richBuilder.
   }
   if (typeof schema === 'boolean') {
+    // A `false` root has one fixed error; the rich form leaves it to enrich.
+    if (!schema && opts && (opts.rich || opts.resultShape)) return null
+    if (opts && opts.resultShape) return null
     return schema
       ? () => VALID_RESULT
       : () => ({ valid: false, errors: [{ keyword: 'not', instancePath: '', schemaPath: '#', params: {}, message: 'boolean schema is false' }] })
@@ -5292,7 +5825,7 @@ function compileToJSCombined(schema, VALID_RESULT, schemaMap, userFormats, opts)
   if (needsBaseTracking(schema, schemaMap, new Set())) return null
 
   // runtimeShape: errors without the ordinal, see compileToJSCodegenWithErrors.
-  const ctx = { noOrdinal: !!(opts && opts.runtimeShape), varCounter: 0, helperCode: [], shared: [], closureVars: ['_cpLen'], closureVals: [_cpLen],
+  const ctx = { noOrdinal: !!(opts && opts.runtimeShape), rich: !!(opts && opts.rich), inCombined: true, varCounter: 0, helperCode: [], shared: [], closureVars: ['_cpLen'], closureVals: [_cpLen],
                 rootDefs: cRootDefs, refStack: new Set(), schemaMap: schemaMap || null, anchors: cAnchors, rootSchema: inputSchema, userFormats: userFormats || null }
   const lines = []
   try {
@@ -5309,14 +5842,49 @@ function compileToJSCombined(schema, VALID_RESULT, schemaMap, userFormats, opts)
   // helper compiles a pattern through it, which the boolean generator does for
   // subschemas under not/if/contains; without the binding those threw a
   // ReferenceError on the first document that reached them.
+  if (opts && opts.resultShape) {
+    ctx.closureVars.push('_ER', '_EE', '_SRT', '_FB', '_VF')
+    ctx.closureVals.push(opts.resultShape.Rejection, opts.resultShape.empty, opts.resultShape.sort, opts.resultShape.fallback, opts.resultShape.verdict || null)
+  }
   const closureNames = ctx.usesSafeRe ? [...ctx.closureVars, '__ataSafeRe'] : ctx.closureVars
   const closureArgs = ctx.usesSafeRe ? [...ctx.closureVals, compileSafe] : ctx.closureVals
   const closureParams = closureNames.join(',')
+  // A definition the error generator wrote as a named function inside a
+  // branch (one on a cycle, or referenced from several places) reads the
+  // cycle-guard state its own function declares, which this one does not:
+  // the first document to reach it threw a ReferenceError. Declined; the
+  // error function, which has that state, answers instead.
+  if (ctx.usesBranchCollapse && ctx.defFns && ctx.defFns.size) return null
+  // Collapsed oneOf/anyOf: the helper the error generator embeds, `_all` for
+  // the branch functions (this function collects everything), and the
+  // runtime shape the error generator gives its literals, without code and
+  // docUrl. The collapsed error itself keeps its code, as everywhere.
+  if (ctx.usesBranchCollapse) ctx.helperCode.push(require('./branch-collapse').embedSource())
+  if (ctx.usesBranchCollapse && opts && opts.runtimeShape) {
+    const shape = (src) => src.replace(/code:'ATA\d{4}',/g, '').replace(/,docUrl:'https:\/\/ata-validator\.com\/e\/ATA\d{4}'/g, '')
+    for (let i = 0; i < ctx.helperCode.length; i++) ctx.helperCode[i] = shape(ctx.helperCode[i])
+    for (let i = 0; i < lines.length; i++) lines[i] = shape(lines[i])
+  }
   const helpers = ctx.helperCode.length ? ctx.helperCode.join('\n  ') + '\n  ' : ''
   // Lazy error array: no allocation for valid data (the common case)
-  const inner = `let _e;\n  ` +
-    lines.join('\n  ') +
-    `\n  return _e?{valid:false,errors:_e}:R`
+  // resultShape: validate() itself for a validator whose errors are being read
+  // (see validator-core): the result objects built here, so one pass decides,
+  // collects and answers, with nothing between the caller and the checks.
+  const rs = opts && opts.resultShape
+  // In the result shape this function is validate() itself, so a document
+  // that makes it throw is answered by the caller's previous path instead
+  // (`_FB`). A thrown error reaching the caller is the one thing this form
+  // must not add; a try that does not throw costs nothing measurable.
+  const inner = rs
+    // With collapsed branches, collecting runs every branch of every oneOf
+    // and anyOf in full, which an accepted document does not need: the
+    // verdict answers it first.
+    ? `try{${ctx.usesBranchCollapse ? 'if(_VF!==null&&_VF(d))return{valid:true,data:d,errors:_EE};const _all=true;' : ''}let _e;\n  ` + lines.join('\n  ') +
+      // A collapsed branch error is presented even alone (its ordinal and
+      // raw branch errors stay inside); otherwise only a list of two or more
+      // needs ordering.
+      `\n  return _e?new _ER(${ctx.usesBranchCollapse ? '_SRT(_e)' : '_e.length>1?_SRT(_e):_e'}):{valid:true,data:d,errors:_EE}}catch(_x){return _FB(d)}`
+    : (ctx.usesBranchCollapse ? 'const _all=true;' : '') + `let _e;\n  ` + lines.join('\n  ') + `\n  return _e?{valid:false,errors:_e}:R`
 
   try {
     if (typeof process !== 'undefined' && process.env && process.env.ATA_DUMP_CODEGEN) console.log('=== COMBINED CODEGEN ===\n' + helpers + inner + '\n=== CLOSURE VARS: ' + ctx.closureVars.length + ' ===')
@@ -5332,6 +5900,34 @@ function compileToJSCombined(schema, VALID_RESULT, schemaMap, userFormats, opts)
 // 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).
+// What of a node still applies to a value that failed its `type`, for the
+// combined generator: the node without `type`, without what it emits outside
+// the type block anyway (enum, const, anyOf, oneOf), and without the keywords
+// of the declared types, which no value of another type meets. Null when
+// nothing that validates is left.
+const TYPE_KEYWORDS = {
+  object: ['properties', 'patternProperties', 'additionalProperties', 'required', 'propertyNames', 'minProperties', 'maxProperties', 'dependentRequired', 'dependentSchemas', 'dependencies', 'unevaluatedProperties'],
+  array: ['items', 'prefixItems', 'additionalItems', 'contains', 'minContains', 'maxContains', 'minItems', 'maxItems', 'uniqueItems', 'unevaluatedItems'],
+  string: ['minLength', 'maxLength', 'pattern'],
+  number: ['minimum', 'maximum', 'exclusiveMinimum', 'exclusiveMaximum', 'multipleOf'],
+}
+TYPE_KEYWORDS.integer = TYPE_KEYWORDS.number
+const NOT_VALIDATING = new Set(['$schema', '$id', '$anchor', '$comment', '$defs', 'definitions', 'title', 'description', 'default', 'examples', 'deprecated', 'readOnly', 'writeOnly', '$vocabulary'])
+function typeMismatchRest(schema, types) {
+  const drop = new Set(['type', 'enum', 'const', 'anyOf', 'oneOf'])
+  for (const t of types) for (const k of (TYPE_KEYWORDS[t] || [])) drop.add(k)
+  // A non-integer number reaches the type block already (numberToo).
+  let rest = null
+  for (const k of Object.keys(schema)) {
+    if (drop.has(k)) continue
+    if (rest === null) rest = {}
+    rest[k] = schema[k]
+  }
+  if (rest === null) return null
+  for (const k of Object.keys(rest)) if (!NOT_VALIDATING.has(k) && !k.startsWith('x-')) return rest
+  return null
+}
+
 function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   return withPlain(schema, v, lines, ctx, () => genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix))
 }
@@ -5342,7 +5938,7 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   if (schema === false) {
     // Leading semicolon: the previous generated line may end in an
     // expression, and a line starting with `(` would be parsed as a call.
-    lines.push(`;(_e||(_e=[])).push({keyword:'not',instancePath:${pathExpr||'""'},schemaPath:'${schemaPrefix}'${ordinalField(ctx, `${schemaPrefix}`)},params:{},message:'boolean schema is false'})`)
+    lines.push(';' + errPushC(ctx, 'not', schemaPrefix, pathExpr, '{}', "'boolean schema is false'", v, `{keyword:'not',instancePath:${pathExpr||'""'},schemaPath:'${schemaPrefix}'${ordinalField(ctx, `${schemaPrefix}`)},params:{},message:'boolean schema is false'}`))
     return
   }
   if (schema === true) return
@@ -5350,6 +5946,12 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
 
   // $ref — resolve local, anchor, and cross-schema refs
   if (schema.$ref) {
+    // The reference is followed and the rest of the node is not compiled, so
+    // a node with a keyword beside its $ref that validates (2020-12 applies
+    // both) declines: compiled, the sibling was dropped and a document it
+    // rejects was accepted. Only reachable since unevaluatedProperties next
+    // to a $ref stopped declining the whole function.
+    for (const k of Object.keys(schema)) if (!REF_NEUTRAL_SIBLINGS.has(k) && !k.startsWith('x-')) throw DECLINE
     // Self-reference "#" — no-op (permissive) to avoid infinite recursion
     if (schema.$ref === '#') return
     const m = schema.$ref.match(/^#\/(?:\$defs|definitions)\/(.+)$/)
@@ -5403,7 +6005,26 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   const isStaticPath = !pathExpr || (pathExpr.startsWith("'") && !pathExpr.includes('+'))
   const fail = (keyword, schemaSuffix, paramsCode, msgCode) => {
     const sp = schemaPrefix + '/' + schemaSuffix
-    if (isStaticPath && msgCode.startsWith("'") && !msgCode.includes('+')) {
+    if (ctx.rich) {
+      // A static site shares one frozen params object between calls, as its
+      // hoisted literal does below; a dynamic one builds its params per call.
+      let shared = null
+      if (isStaticPath && msgCode.startsWith("'") && !msgCode.includes('+')) {
+        let pv
+        try { pv = Function('return ' + paramsCode)() } catch { pv = undefined }
+        if (pv !== undefined) {
+          shared = `_P${ctx.varCounter++}`
+          ctx.closureVars.push(shared); ctx.closureVals.push(Object.freeze(pv))
+        }
+      }
+      return errPushC(ctx, keyword, sp, pathExpr, paramsCode, msgCode, v, null, shared)
+    }
+    // Hoisting a static error as one shared literal keeps a function that
+    // also answers accepted documents small. In the runtime shape this
+    // function only runs for documents being rejected (the verdict is its own
+    // function), and a shared literal has to be copied for the caller on
+    // every read, so there it is written fresh.
+    if (isStaticPath && !ctx.noOrdinal && msgCode.startsWith("'") && !msgCode.includes('+')) {
       // Try to evaluate paramsCode as a static constant
       let paramsVal
       try { paramsVal = Function('return ' + paramsCode)() } catch { /* dynamic params — fall through */ }
@@ -5430,7 +6051,7 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
         const o = ctx.noOrdinal ? null : ordinalFor(ctx.rootSchema, spVal)
         const lit = {keyword, instancePath: pathVal, schemaPath: spVal, params: Object.freeze(paramsVal), message: msgVal}
         if (o !== null) lit._o = o
-        ctx.closureVals.push(Object.freeze(lit))
+        ctx.closureVals.push(sharedErr(lit, ctx.rootSchema))
         return `(_e||(_e=[])).push(${errVar})`
         }
       }
@@ -5455,7 +6076,7 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
       if (cv === null || typeof cv !== 'object') {
         lines.push(`if(${v}!==${JSON.stringify(cv)}){${fail('const', 'const', `{allowedValue:${JSON.stringify(schema.const)}}`, "'must be equal to constant'")}}`)
       } else {
-        lines.push(`if(!${emitDeq(ctx)}(${v},${emitConstant(ctx, cv)})){${fail('const', 'const', `{allowedValue:JSON.parse(${JSON.stringify(JSON.stringify(schema.const))})}`, "'must be equal to constant'")}}`)
+        lines.push(`if(!${emitDeq(ctx)}(${v},${emitConstant(ctx, cv)})){${fail('const', 'const', `{allowedValue:${emitParamConstant(ctx, schema.const)}}`, "'must be equal to constant'")}}`)
       }
     }
   }
@@ -5474,7 +6095,9 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
       }
     })
     const expected = types.join(', ')
-    const expectedParam = types.length === 1 ? `'${types[0]}'` : JSON.stringify(types)
+    // As written: a one-element array stays an array, as the interpreted engine
+    // reports it.
+    const expectedParam = !Array.isArray(schema.type) ? `'${types[0]}'` : JSON.stringify(types)
     // Type check: push error but continue — wrap remaining in type-success block
     const typeOk = `_tok${ctx.varCounter++}`
     lines.push(`const ${typeOk}=${conds.join('||')}`)
@@ -5487,7 +6110,11 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
       isNum = types[0] === 'number' || types[0] === 'integer'
     }
     emitEnumConst()
-    lines.push(`if(${typeOk}){`)
+    // A number that is not an integer fails `integer` and is still a number:
+    // minimum, multipleOf and the rest apply to it, and the other engines
+    // report them next to the type error. The block opens for any number.
+    const numberToo = types.includes('integer') && !types.includes('number')
+    lines.push(numberToo ? `if(${typeOk}||typeof ${v}==='number'){` : `if(${typeOk}){`)
   } else {
     emitEnumConst()
   }
@@ -5514,29 +6141,29 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     }
     for (const key of schema.required) {
       const check = hoisted[key] ? `${hoisted[key]}===undefined` : `!${ownKeyExpr(ctx, v, key)}`
-      if (isStaticPath) {
+      if (isStaticPath && !ctx.rich && !ctx.noOrdinal) {
         const ei = ctx.varCounter++
         const errVar = `_E${ei}`
         const pathVal = pathExpr ? literalValue(pathExpr) : ''
         ctx.closureVars.push(errVar)
-        ctx.closureVals.push(Object.freeze({keyword: 'required', instancePath: pathVal, schemaPath: unescapeSp(`${schemaPrefix}/required`), params: Object.freeze({missingProperty: key}), message: `must have required property '${key}'`}))
+        ctx.closureVals.push(sharedErr({keyword: 'required', instancePath: pathVal, schemaPath: unescapeSp(`${schemaPrefix}/required`), params: Object.freeze({missingProperty: key}), message: `must have required property '${key}'`}, ctx.rootSchema))
         lines.push(`if(${check}){(_e||(_e=[])).push(${errVar})}`)
       } else {
-        lines.push(`if(${check}){(_e||(_e=[])).push({keyword:'required',instancePath:${pathExpr||'""'},schemaPath:'${schemaPrefix}/required'${ordinalField(ctx, `${schemaPrefix}/required`)},params:{missingProperty:'${esc(key)}'},message:"must have required property '${esc(key)}'"})}`)
+        lines.push(`if(${check}){${errPushC(ctx, 'required', `${schemaPrefix}/required`, pathExpr, `{missingProperty:'${esc(key)}'}`, `"must have required property '${esc(key)}'"`, v, `{keyword:'required',instancePath:${pathExpr||'""'},schemaPath:'${schemaPrefix}/required'${ordinalField(ctx, `${schemaPrefix}/required`)},params:{missingProperty:'${esc(key)}'},message:"must have required property '${esc(key)}'"}`)}}`)
       }
     }
   } else if (schema.required) {
     for (const key of schema.required) {
       const isStatic = !pathExpr || (pathExpr.startsWith("'") && !pathExpr.includes('+'))
-      if (isStatic) {
+      if (isStatic && !ctx.rich && !ctx.noOrdinal) {
         const ei = ctx.varCounter++
         const errVar = `_E${ei}`
         const pathVal = pathExpr ? literalValue(pathExpr) : ''
         ctx.closureVars.push(errVar)
-        ctx.closureVals.push(Object.freeze({keyword: 'required', instancePath: pathVal, schemaPath: unescapeSp(`${schemaPrefix}/required`), params: Object.freeze({missingProperty: key}), message: `must have required property '${key}'`}))
+        ctx.closureVals.push(sharedErr({keyword: 'required', instancePath: pathVal, schemaPath: unescapeSp(`${schemaPrefix}/required`), params: Object.freeze({missingProperty: key}), message: `must have required property '${key}'`}, ctx.rootSchema))
         lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&!${ownKeyExpr(ctx, v, key)}){(_e||(_e=[])).push(${errVar})}`)
       } else {
-        lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&!${ownKeyExpr(ctx, v, key)}){(_e||(_e=[])).push({keyword:'required',instancePath:${pathExpr||'""'},schemaPath:'${schemaPrefix}/required'${ordinalField(ctx, `${schemaPrefix}/required`)},params:{missingProperty:'${esc(key)}'},message:"must have required property '${esc(key)}'"})}`)
+        lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&!${ownKeyExpr(ctx, v, key)}){${errPushC(ctx, 'required', `${schemaPrefix}/required`, pathExpr, `{missingProperty:'${esc(key)}'}`, `"must have required property '${esc(key)}'"`, v, `{keyword:'required',instancePath:${pathExpr||'""'},schemaPath:'${schemaPrefix}/required'${ordinalField(ctx, `${schemaPrefix}/required`)},params:{missingProperty:'${esc(key)}'},message:"must have required property '${esc(key)}'"}`)}}`)
       }
     }
   }
@@ -5659,7 +6286,13 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   // unevaluatedProperties: false where it is provably additionalProperties
   // (the entry bail guaranteed that), keeping the keyword's own identity so
   // the two engines report the same error.
-  if (schema.unevaluatedProperties === false && schema.additionalProperties === undefined && !schema.patternProperties) genUnevaluatedFalseC(schema, v, pathExpr, lines, ctx, schemaPrefix, fail, isObj)
+  if (schema.unevaluatedProperties !== undefined && schema.unevaluatedProperties !== true) {
+    if (unevalLocalOk(schema, 'unevaluatedProperties')) {
+      if (schema.additionalProperties === undefined && !schema.patternProperties) genUnevaluatedFalseC(schema, v, pathExpr, lines, ctx, schemaPrefix, fail, isObj)
+    } else {
+      genUnevaluatedDynamicC(schema, v, pathExpr, lines, ctx, schemaPrefix, fail, isObj)
+    }
+  }
 
   // unevaluatedItems: false under the same rule: one error for the array,
   // the first uncovered position as the limit. Adjacent schema-form `items`
@@ -5671,15 +6304,15 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     for (const [key, deps] of Object.entries(schema.dependentRequired)) {
       for (const dep of deps) {
         const isStatic = !pathExpr || (pathExpr.startsWith("'") && !pathExpr.includes('+'))
-        if (isStatic) {
+        if (isStatic && !ctx.rich && !ctx.noOrdinal) {
           const ei = ctx.varCounter++
           const errVar = `_E${ei}`
           const pathVal = pathExpr ? literalValue(pathExpr) : ''
           ctx.closureVars.push(errVar)
-          ctx.closureVals.push(Object.freeze({keyword: 'required', instancePath: pathVal, schemaPath: unescapeSp(`${schemaPrefix}/dependentRequired`), params: Object.freeze({missingProperty: dep}), message: `must have required property '${dep}'`}))
+          ctx.closureVals.push(sharedErr({keyword: 'required', instancePath: pathVal, schemaPath: unescapeSp(`${schemaPrefix}/dependentRequired`), params: Object.freeze({missingProperty: dep}), message: `must have required property '${dep}'`}, ctx.rootSchema))
           lines.push(`if(typeof ${v}==='object'&&${v}!==null&&${ownKeyExpr(ctx, v, key)}&&!${ownKeyExpr(ctx, v, dep)}){(_e||(_e=[])).push(${errVar})}`)
         } else {
-          lines.push(`if(typeof ${v}==='object'&&${v}!==null&&${ownKeyExpr(ctx, v, key)}&&!${ownKeyExpr(ctx, v, dep)}){(_e||(_e=[])).push({keyword:'required',instancePath:${pathExpr||'""'},schemaPath:'${schemaPrefix}/dependentRequired'${ordinalField(ctx, `${schemaPrefix}/dependentRequired`)},params:{missingProperty:'${esc(dep)}'},message:"must have required property '${esc(dep)}'"})}`)
+          lines.push(`if(typeof ${v}==='object'&&${v}!==null&&${ownKeyExpr(ctx, v, key)}&&!${ownKeyExpr(ctx, v, dep)}){${errPushC(ctx, 'required', `${schemaPrefix}/dependentRequired`, pathExpr, `{missingProperty:'${esc(dep)}'}`, `"must have required property '${esc(dep)}'"`, v, `{keyword:'required',instancePath:${pathExpr||'""'},schemaPath:'${schemaPrefix}/dependentRequired'${ordinalField(ctx, `${schemaPrefix}/dependentRequired`)},params:{missingProperty:'${esc(dep)}'},message:"must have required property '${esc(dep)}'"}`)}}`)
         }
       }
     }
@@ -5712,6 +6345,10 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   if (schema.patternProperties) {
     if (genPatternPropertiesC(schema, v, pathExpr, lines, ctx, schemaPrefix, fail, isObj)) ppHandledPropertyNames = true
   }
+  // additionalProperties as a schema: each key that is neither declared nor
+  // matched by a pattern, validated where it is (see genAdditionalSchemaC).
+  if (typeof schema.additionalProperties === 'object' && schema.additionalProperties !== null) genAdditionalSchemaC(schema, v, pathExpr, lines, ctx, schemaPrefix, isObj)
+
 
   // dependentSchemas
   if (schema.dependentSchemas) genDependentSchemasC(schema, v, pathExpr, lines, ctx, schemaPrefix)
@@ -5741,11 +6378,11 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   // allOf
   if (schema.allOf) { for (let _ai = 0; _ai < schema.allOf.length; _ai++) genCodeC(schema.allOf[_ai], v, pathExpr, lines, ctx, schemaPrefix+'/allOf/'+_ai) }
 
-  // anyOf
-  if (schema.anyOf) genAnyOfC(schema, v, pathExpr, lines, ctx, schemaPrefix, fail)
-
-  // oneOf
-  if (schema.oneOf) genOneOfC(schema, v, pathExpr, lines, ctx, schemaPrefix, fail)
+  // anyOf, oneOf. A collapsed branch applies to a value of any type, as enum
+  // and const do: the other engines report it next to a failed `type`, so
+  // in the combined function it goes after the type-success block below.
+  if (schema.anyOf && !ctx.inCombined) genAnyOfC(schema, v, pathExpr, lines, ctx, schemaPrefix, fail)
+  if (schema.oneOf && !ctx.inCombined) genOneOfC(schema, v, pathExpr, lines, ctx, schemaPrefix, fail)
 
   // not
   if (schema.not !== undefined) genNotC(schema, v, pathExpr, lines, ctx, schemaPrefix, fail)
@@ -5756,7 +6393,22 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   // Close type-success block if opened
   if (types) {
     lines.push(`}`)
+    // A value of another type still meets every keyword that applies to its
+    // own type, and the applicators (allOf, not, if/then/else, $ref): the
+    // other engines report those next to the type error, and the block above
+    // skipped them all. The keywords of the declared types cannot apply to
+    // it and are left out, so the else is small and does not repeat the
+    // declared type's subtree.
+    const rest = typeMismatchRest(schema, types)
+    if (rest !== null) {
+      lines.push(`else{`)
+      genCodeC(rest, v, pathExpr, lines, ctx, schemaPrefix)
+      lines.push(`}`)
+    }
   }
+  if (schema.anyOf && ctx.inCombined) genAnyOfC(schema, v, pathExpr, lines, ctx, schemaPrefix, fail)
+  if (schema.oneOf && ctx.inCombined) genOneOfC(schema, v, pathExpr, lines, ctx, schemaPrefix, fail)
+
 }
 
 // Rarely used keyword families of genCodeCNode, kept out of it so their compile is
@@ -5782,20 +6434,158 @@ function genDynamicRefC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
 
 function genUniqueItemsC(schema, v, pathExpr, lines, ctx, schemaPrefix, fail, isArr) {
   const si = ctx.varCounter++
-  const itemType = schema.items && typeof schema.items === 'object' && schema.items.type
-  const isPrim = itemType === 'string' || itemType === 'number' || itemType === 'integer'
-  const maxItems = schema.maxItems
   const failExpr = (iVar, jVar) => fail('uniqueItems', 'uniqueItems', `{i:${iVar},j:${jVar}}`, `'must NOT have duplicate items (items ## '+${jVar}+' and '+${iVar}+' are identical)'`)
-  let inner
-  if (isPrim && maxItems && maxItems <= 16) {
-    // Small primitive arrays: O(n²) nested loop, zero allocation
-    inner = `for(let _i=1;_i<${v}.length;_i++){for(let _k=0;_k<_i;_k++){if(${v}[_i]===${v}[_k]){${failExpr('_k', '_i')};break}}}`
-  } else if (isPrim) {
-    inner = `const _s${si}=new Map();for(let _i=0;_i<${v}.length;_i++){const _prev=_s${si}.get(${v}[_i]);if(_prev!==undefined){${failExpr('_prev', '_i')};break};_s${si}.set(${v}[_i],_i)}`
+  // Only reached once the verdict has rejected, or when errors are wanted, so
+  // one strategy for every item type: the hoisted pair finder. See UQP_HELPER.
+  const inner = `const _j${si}=${emitUqp(ctx)}(${v});if(_j${si}>=0){const _i${si}=_uqpI;${failExpr('_i' + si, '_j' + si)}}`
+  lines.push(isArr ? `{${inner}}` : `if(Array.isArray(${v})){${inner}}`)
+}
+
+// The verdict form of genUnevaluatedDynamicC: the same set, built the same
+// way, and the answer false at the first key outside it.
+function genUnevalDynamicVerdict(schema, v, lines, ctx, isObj) {
+  if (schema.additionalProperties !== undefined) return
+  const ui = ctx.varCounter++
+  const S = `_ev${ui}`
+  const body = [`const ${S}=new Set()`]
+  addLocalAnnotations(schema, v, S, body, ctx)
+  addApplicatorAnnotations(schema, v, S, body, ctx, true)
+  const kVar = `_uk${ui}`
+  const up = schema.unevaluatedProperties
+  if (up === false) {
+    body.push(`for(const ${kVar} of Object.keys(${v}))if(!${S}.has(${kVar}))return false`)
+  } else if (typeof up === 'object' && up !== null) {
+    const sub = []
+    genCode(up, `${v}[${kVar}]`, sub, ctx)
+    if (sub.length) body.push(`for(const ${kVar} of Object.keys(${v}))if(!${S}.has(${kVar})){${sub.join('\n  ')}\n  }`)
   } 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)}`
+    throw DECLINE
   }
-  lines.push(isArr ? `{${inner}}` : `if(Array.isArray(${v})){${inner}}`)
+  lines.push(isObj ? `{${body.join(';')}}` : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${body.join(';')}}`)
+}
+
+// unevaluatedProperties where what is evaluated depends on which branches
+// pass: the set is built at run time with the interpreted engine's rules.
+// The node's own properties, patternProperties and additionalProperties
+// count whether or not their values pass; an allOf, anyOf or dependentSchemas
+// branch, an if, then or else, or a $ref target counts only when it passes,
+// a oneOf only when exactly one branch passes, and `not` never. Each branch is
+// asked through an annotation function (emitAnnot), which validates first and
+// only then adds what it evaluated, so nothing has to be rolled back.
+function genUnevaluatedDynamicC(schema, v, pathExpr, lines, ctx, schemaPrefix, fail, isObj) {
+  // additionalProperties evaluates every key the others do not, pass or fail.
+  if (schema.additionalProperties !== undefined) return
+  const ui = ctx.varCounter++
+  const S = `_ev${ui}`
+  const body = [`const ${S}=new Set()`]
+  addLocalAnnotations(schema, v, S, body, ctx)
+  addApplicatorAnnotations(schema, v, S, body, ctx, true)
+  const kVar = `_uk${ui}`
+  const up = schema.unevaluatedProperties
+  if (up === false) {
+    body.push(`for(const ${kVar} of Object.keys(${v}))if(!${S}.has(${kVar})){${fail('unevaluatedProperties', 'unevaluatedProperties', `{unevaluatedProperty:${kVar}}`, "'must NOT have unevaluated properties'")}}`)
+  } else if (typeof up === 'object' && up !== null) {
+    const pe = emitPtrEsc(ctx)
+    const p = pathExpr ? `${pathExpr}+'/'+${pe}(${kVar})` : `'/'+${pe}(${kVar})`
+    const sub = []
+    genCodeC(up, `${v}[${kVar}]`, p, sub, ctx, schemaPrefix + '/unevaluatedProperties')
+    if (sub.length) body.push(`for(const ${kVar} of Object.keys(${v}))if(!${S}.has(${kVar})){${sub.join('\n  ')}\n  }`)
+  } else {
+    throw DECLINE
+  }
+  lines.push(isObj ? `{${body.join(';')}}` : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${body.join(';')}}`)
+}
+
+// The names a node's own keywords evaluate, added to `S`: present declared
+// properties, keys matching a pattern.
+function addLocalAnnotations(node, v, S, out, ctx) {
+  for (const k of Object.keys(node.properties || {})) out.push(`if(Object.prototype.hasOwnProperty.call(${v},${JSON.stringify(k)}))${S}.add(${JSON.stringify(k)})`)
+  const pats = Object.keys(node.patternProperties || {})
+  if (pats.length) {
+    const tests = []
+    const kv = `_pk${ctx.varCounter++}`
+    for (const pat of pats) {
+      const fast = fastPrefixCheck(pat, kv)
+      if (fast) { tests.push(fast); continue }
+      const ri = ctx.varCounter++
+      ctx.closureVars.push(`_re${ri}`)
+      ctx.closureVals.push(safeReClosure(ctx, pat))
+      tests.push(`_re${ri}.test(${kv})`)
+    }
+    out.push(`for(const ${kv} in ${v})if(${tests.join('||')})${S}.add(${kv})`)
+  }
+}
+
+// What a node's applicators add to `S`. At the node that owns the
+// unevaluatedProperties (`top`), a oneOf counts only with exactly one passing
+// branch; inside a branch that passed, its oneOf has exactly one.
+function addApplicatorAnnotations(node, v, S, out, ctx, top) {
+  for (const b of node.allOf || []) out.push(`${emitAnnot(b, ctx)}(${v},${S})`)
+  for (const b of node.anyOf || []) out.push(`${emitAnnot(b, ctx)}(${v},${S})`)
+  if (Array.isArray(node.oneOf)) {
+    if (top) {
+      const t = `_one${ctx.varCounter++}`
+      const calls = node.oneOf.map((b, i) => `{const _s=new Set();if(${emitAnnot(b, ctx)}(${v},_s)){${t}c++;${t}s=_s}}`).join('')
+      out.push(`{let ${t}c=0,${t}s=null;${calls}if(${t}c===1)for(const _x of ${t}s)${S}.add(_x)}`)
+    } else {
+      for (const b of node.oneOf) out.push(`${emitAnnot(b, ctx)}(${v},${S})`)
+    }
+  }
+  if (node.if !== undefined) {
+    const thenCall = node.then !== undefined ? `${emitAnnot(node.then, ctx)}(${v},${S})` : ''
+    const elseCall = node.else !== undefined ? `${emitAnnot(node.else, ctx)}(${v},${S})` : ''
+    out.push(`if(${emitAnnot(node.if, ctx)}(${v},${S})){${thenCall}}else{${elseCall}}`)
+  }
+  if (node.dependentSchemas && typeof node.dependentSchemas === 'object') {
+    for (const [k, ds] of Object.entries(node.dependentSchemas)) out.push(`if(Object.prototype.hasOwnProperty.call(${v},${JSON.stringify(k)}))${emitAnnot(ds, ctx)}(${v},${S})`)
+  }
+  if (typeof node.$ref === 'string') out.push(`${emitAnnot(refTargetFor(node.$ref, ctx), ctx)}(${v},${S})`)
+  if (node.$dynamicRef !== undefined || node.$recursiveRef !== undefined || node.dependencies !== undefined) throw DECLINE
+}
+
+function refTargetFor(ref, ctx) {
+  const m = ref.match(/^#\/(?:\$defs|definitions)\/(.+)$/)
+  const t = m && ctx.rootDefs ? ctx.rootDefs[m[1]] : undefined
+  if (t === undefined) throw DECLINE
+  return t
+}
+
+// A function `(value, S) => valid` for one subschema: the subschema's verdict,
+// and when it passes, what it evaluated added to S. One per subschema object.
+function emitAnnot(sub, ctx) {
+  if (sub === true) return '_anT'
+  if (sub === false) return '_anF'
+  if (sub === null || typeof sub !== 'object') throw DECLINE
+  if (!ctx.annFns) {
+    ctx.annFns = new Map()
+    ;(ctx.preamble || ctx.helperCode).push('function _anT(){return true}function _anF(){return false}')
+  }
+  const hit = ctx.annFns.get(sub)
+  if (hit !== undefined) {
+    if (hit === null) throw DECLINE // a reference cycle: not modelled here
+    return hit
+  }
+  ctx.annFns.set(sub, null)
+  const name = `_an${ctx.varCounter++}`
+  const vl = []
+  nestedGenCode(sub, '_av', vl, ctx)
+  const body = []
+  // additionalProperties, or an unevaluatedProperties that passed, evaluate
+  // every remaining key.
+  if (sub.additionalProperties !== undefined || (sub.unevaluatedProperties !== undefined && sub.unevaluatedProperties !== false)) {
+    body.push(`for(const _ka in d)S.add(_ka)`)
+  } else if (sub.unevaluatedProperties === false) {
+    body.push(`for(const _ka in d)S.add(_ka)`)
+  } else {
+    addLocalAnnotations(sub, 'd', 'S', body, ctx)
+    addApplicatorAnnotations(sub, 'd', 'S', body, ctx, false)
+  }
+  // The verdict generator keeps its declarations in the preamble (its
+  // helperCode is only scanned for patterns); the error generators in
+  // helperCode.
+  ;(ctx.preamble || ctx.helperCode).push(`function ${name}_v(_av){${vl.join('\n  ')}\n  return true}function ${name}(d,S){if(!${name}_v(d))return false;if(typeof d!=='object'||d===null||Array.isArray(d))return true;${body.join(';')};return true}`)
+  ctx.annFns.set(sub, name)
+  return name
 }
 
 function genUnevaluatedFalseC(schema, v, pathExpr, lines, ctx, schemaPrefix, fail, isObj) {
@@ -5825,6 +6615,41 @@ function genUnevaluatedItemsFalseC(schema, v, pathExpr, lines, ctx, schemaPrefix
   }
 }
 
+// The error generator's per-key loop (genAdditionalSchemaE), in the combined
+// generator: the subschema compiled by genCodeC at each additional key, with
+// that key's path. Patterns go through the same matchers patternProperties
+// uses here.
+function genAdditionalSchemaC(schema, v, pathExpr, lines, ctx, schemaPrefix, isObj) {
+  const ki = ctx.varCounter++
+  const kVar = `_ak${ki}`
+  const known = Object.keys(schema.properties || {})
+  const conds = []
+  if (known.length) {
+    const set = `_akn${ki}`
+    ctx.closureVars.push(set)
+    ctx.closureVals.push(new Set(known))
+    conds.push(`!${set}.has(${kVar})`)
+  }
+  const pats = []
+  for (const pat of Object.keys(schema.patternProperties || {})) {
+    const fast = fastPrefixCheck(pat, kVar)
+    if (fast) { pats.push(fast); continue }
+    const ri = ctx.varCounter++
+    ctx.closureVars.push(`_re${ri}`)
+    ctx.closureVals.push(safeReClosure(ctx, pat))
+    pats.push(`_re${ri}.test(${kVar})`)
+  }
+  if (pats.length) conds.push(`!(${pats.join('||')})`)
+  const guard = isObj ? '' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v}))`
+  const keep = conds.length ? `if(${conds.join('&&')})` : ''
+  const pe = emitPtrEsc(ctx)
+  const p = pathExpr ? `${pathExpr}+'/'+${pe}(${kVar})` : `'/'+${pe}(${kVar})`
+  const sub = []
+  genCodeC(schema.additionalProperties, `${v}[${kVar}]`, p, sub, ctx, schemaPrefix + '/additionalProperties')
+  if (sub.length === 0) return
+  lines.push(`${guard}{for(const ${kVar} in ${v}){${keep}{${sub.join('\n  ')}\n  }}}`)
+}
+
 function genPatternPropertiesC(schema, v, pathExpr, lines, ctx, schemaPrefix, fail, isObj) {
   let handledPropertyNames = false
   const ppEntries = Object.entries(schema.patternProperties)
@@ -5943,7 +6768,7 @@ function genDependentSchemasC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
 function genPropertyNamesFalseC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   const ki = ctx.varCounter++
   const p = pathExpr || '""'
-  lines.push(`;if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){for(const _k${ki} in ${v}){(_e||(_e=[])).push({keyword:'not',instancePath:${p},schemaPath:'${schemaPrefix}/propertyNames'${ordinalField(ctx, `${schemaPrefix}/propertyNames`)},params:{},message:'boolean schema is false'})}}`)
+  lines.push(`;if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){for(const _k${ki} in ${v}){${errPushC(ctx, 'not', `${schemaPrefix}/propertyNames`, pathExpr, '{}', "'boolean schema is false'", v, `{keyword:'not',instancePath:${p},schemaPath:'${schemaPrefix}/propertyNames'${ordinalField(ctx, `${schemaPrefix}/propertyNames`)},params:{},message:'boolean schema is false'}`)}}}`)
 }
 
 function genPropertyNamesC(schema, v, pathExpr, lines, ctx, schemaPrefix, fail) {
@@ -5997,12 +6822,18 @@ function genContainsC(schema, v, pathExpr, lines, ctx, schemaPrefix, fail) {
 }
 
 function genAnyOfC(schema, v, pathExpr, lines, ctx, schemaPrefix, fail) {
+  // The collapsed branch error the other engines report (ATA4001-4003),
+  // built by the error generator's emitter; see compileToJSCombined.
+  if (ctx.inCombined) return emitBranchCollapse(schema.anyOf, 'anyOf', v, pathExpr, lines, ctx, schemaPrefix)
   const fi = ctx.varCounter++
   const fns = schema.anyOf.map(sub => { const sl = []; nestedGenCode(sub, '_av', sl, ctx); return sl.length === 0 ? `function(_av){return true}` : `function(_av){${sl.join(';')};return true}` })
   lines.push(`{const _af${fi}=[${fns.join(',')}];let _am=false;for(let _ai=0;_ai<_af${fi}.length;_ai++){if(_af${fi}[_ai](${v})){_am=true;break}}if(!_am){${fail('anyOf', 'anyOf', '{}', "'must match a schema in anyOf'")}}}`)
 }
 
 function genOneOfC(schema, v, pathExpr, lines, ctx, schemaPrefix, fail) {
+  // The collapsed branch error the other engines report (ATA4001-4003),
+  // built by the error generator's emitter; see compileToJSCombined.
+  if (ctx.inCombined) return emitBranchCollapse(schema.oneOf, 'oneOf', v, pathExpr, lines, ctx, schemaPrefix)
   const fi = ctx.varCounter++
   const fns = schema.oneOf.map(sub => { const sl = []; nestedGenCode(sub, '_ov', sl, ctx); return sl.length === 0 ? `function(_ov){return true}` : `function(_ov){${sl.join(';')};return true}` })
   lines.push(`{const _of${fi}=[${fns.join(',')}];let _oc=0;for(let _oi=0;_oi<_of${fi}.length;_oi++){if(_of${fi}[_oi](${v}))_oc++;if(_oc>1)break}if(_oc!==1){${fail('oneOf', 'oneOf', '{}', "'must match exactly one schema in oneOf'")}}}`)
@@ -6162,3 +6993,5 @@ function _collectEval(schema, result, defs, schemaMap, refStack, isRoot) {
 }
 
 module.exports = { compileToJS, compileToJSCodegen, compileToJSCodegenWithErrors, compileToJSCombined, collectEvaluated, unevalContributions, AJV_MESSAGES, _setCodeBudget }
+// For tests/test_custom_keyword_codegen.js, which holds these copies to the interpreter's.
+Object.defineProperty(module.exports, '_kwTypeBits', { value: { kwTypeBit, kwDataBits, KW_T_ANY }, enumerable: false })