ata-validator 1.37.1 → 1.39.1

package/lib/js-compiler.js

@@ -135,12 +135,26 @@ function enumCondition(ctx, vals, v) {
 const { codeFor } = require('./error-codes')
 const { ordinalFor } = require('./schema-order')
 const { compileSafe, patternIsSafe } = require('./safe-regex')
+// Whether a pattern goes to the linear-time engine. A pattern the platform
+// RegExp also runs in linear time (nativeIsLinear) takes the RegExp: it answers
+// the same, runs faster, and a compiled module that needs no other pattern
+// does not carry the engine. Patterns the engine cannot represent keep the
+// RegExp, as before.
+// Loaded on the first pattern, so a schema without one does not pay for it.
+let _nativeIsLinear = null
+// The linearity check only parses; it runs first so a pattern bound for the
+// RegExp is never compiled for the engine just to be told it could have been.
+const useSafeEngine = (src) => {
+  if (_nativeIsLinear === null) _nativeIsLinear = require('./regex-linear').nativeIsLinear
+  if (_nativeIsLinear(src)) return false
+  return patternIsSafe(src)
+}
 
 // Closure value for a patternProperties/propertyNames regex: the linear-time
 // safe matcher when the pattern is in the supported subset (and flag the ctx so
 // standalone embeds the engine), else a plain RegExp. Both expose `.test`.
 function safeReClosure (ctx, src) {
-  if (patternIsSafe(src)) { ctx.usesSafeRe = true; return compileSafe(src) }
+  if (useSafeEngine(src)) { ctx.usesSafeRe = true; return compileSafe(src) }
   return new RegExp(src)
 }
 
@@ -272,6 +286,9 @@ function compileToJS(schema, defs, schemaMap) {
 
   if (!defs && needsBaseTracking(schema, schemaMap, new Set())) return null
   if (!defs && externalDocsNeedInterpreter(schema, schemaMap)) return null
+  // A $ref cycle on one value recurses here as it does in generated code; see
+  // hasSameInstanceRefCycle.
+  if (!defs && hasSameInstanceRefCycle(schema)) return null
 
   // unevaluatedProperties / unevaluatedItems need annotation tracking this
   // path does not do. Decline so the schema reaches an engine that does.
@@ -523,7 +540,7 @@ function compileToJS(schema, defs, schemaMap) {
   }
   if (schema.pattern) {
     try {
-      const re = patternIsSafe(schema.pattern) ? compileSafe(schema.pattern) : new RegExp(schema.pattern)
+      const re = useSafeEngine(schema.pattern) ? compileSafe(schema.pattern) : new RegExp(schema.pattern)
       checks.push((d) => typeof d !== 'string' || re.test(d))
     } catch {
       return null
@@ -1188,6 +1205,31 @@ function emitGuardedRun (attempt, reset, defSets) {
   )
 }
 
+// Definitions referenced from more than one place whose body is large enough
+// that repeating its error code at every reference costs more than a call.
+function sharedDefNames (root, defs) {
+  const out = new Set()
+  if (!defs || typeof defs !== 'object') return out
+  const counts = new Map()
+  const seen = new WeakSet()
+  const walk = (node) => {
+    if (node === null || typeof node !== 'object' || seen.has(node)) return
+    seen.add(node)
+    if (typeof node.$ref === 'string') {
+      const m = /^#\/(?:\$defs|definitions)\/([^/]+)$/.exec(node.$ref)
+      if (m) counts.set(m[1], (counts.get(m[1]) || 0) + 1)
+    }
+    for (const v of Object.values(node)) walk(v)
+  }
+  walk(root)
+  for (const [name, n] of counts) {
+    const def = defs[name]
+    if (n >= 2 && def && typeof def === 'object' && JSON.stringify(def).length >= SHARED_DEF_MIN_CHARS) out.add(name)
+  }
+  return out
+}
+const SHARED_DEF_MIN_CHARS = 120
+
 function cyclicDefNames (defs) {
   const out = new Set()
   if (!defs || typeof defs !== 'object') return out
@@ -1261,6 +1303,76 @@ function aliasChainEnds(def, defs) {
   return true
 }
 
+// When the properties a schema evaluates depend on which subschemas pass,
+// genUnevaluatedPropertiesNode picks one of a few runtime models: if/then/else,
+// one anyOf or oneOf, dependentSchemas, or patterns (root, allOf and a lone
+// if). Each model reads only the keywords it was written for. A schema whose
+// evaluated set comes from anything else was compiled with that part ignored,
+// and a lone `if` with properties emitted no check at all, which accepted every
+// object. This says whether the model the emitter will pick covers every
+// source of evaluated properties the schema has; when it does not, the
+// schema is not generated and the interpreter answers.
+function unevalPropsModeled(schema, schemaMap) {
+  const own = Object.assign({}, schema)
+  delete own.$defs
+  delete own.definitions
+  if (/"\$(?:ref|dynamicRef|recursiveRef)"/.test(JSON.stringify(own))) return false
+  // A subschema whose evaluated names are a fixed list, which is all the
+  // branch, dependentSchemas and if/then/else models can represent.
+  const fixed = (s) => {
+    if (typeof s === 'boolean') return true
+    if (typeof s !== 'object' || s === null) return false
+    const r = collectEvaluated(s, schemaMap)
+    const j = JSON.stringify(s)
+    return !r.dynamic && !r.allProps && !j.includes('"patternProperties"') && !j.includes('"unevaluatedProperties"')
+  }
+  const allOf = Array.isArray(schema.allOf) ? schema.allOf : []
+  for (const sub of allOf) {
+    if (typeof sub === 'boolean') continue
+    if (typeof sub !== 'object' || sub === null) return false
+    const r = collectEvaluated(sub, schemaMap)
+    if (r.dynamic || r.allProps) return false
+    const rest = Object.assign({}, sub)
+    delete rest.patternProperties
+    const j = JSON.stringify(rest)
+    if (j.includes('"patternProperties"') || j.includes('"unevaluatedProperties"')) return false
+  }
+  const patterns = !!schema.patternProperties || allOf.some((s) => s && typeof s === 'object' && s.patternProperties)
+  const branch = schema.anyOf || schema.oneOf
+  if (schema.anyOf && schema.oneOf) return false
+  const hasIf = schema.if !== undefined
+  const hasTE = schema.then !== undefined || schema.else !== undefined
+  const dep = schema.dependentSchemas
+  if (schema.unevaluatedProperties !== false) {
+    // The schema-valued model reads the fixed names and one branch keyword.
+    if (hasIf || hasTE || dep || patterns) return false
+    return !branch || branch.every(fixed)
+  }
+  if (hasIf && hasTE && !branch && !schema.patternProperties && !dep) {
+    if (patterns) return false
+    if (!fixed(schema.if) || (schema.then !== undefined && !fixed(schema.then)) || (schema.else !== undefined && !fixed(schema.else))) return false
+    // The model credits the if's own `properties` names, and only those.
+    const ifNames = typeof schema.if === 'object' ? collectEvaluated(schema.if, schemaMap).props : []
+    const declared = typeof schema.if === 'object' && schema.if.properties ? Object.keys(schema.if.properties) : []
+    return ifNames.length === declared.length && ifNames.every((k) => declared.includes(k))
+  }
+  if (branch) return !hasIf && !hasTE && !dep && !patterns && branch.every(fixed)
+  if (dep) return !hasIf && !hasTE && !patterns && Object.values(dep).every(fixed)
+  if (hasTE) return false
+  if (hasIf) {
+    // A lone if contributes through its top-level patternProperties only.
+    if (typeof schema.if === 'boolean') return true
+    if (typeof schema.if !== 'object' || schema.if === null) return false
+    const r = collectEvaluated(schema.if, schemaMap)
+    if (r.dynamic || r.allProps || r.props.length) return false
+    const rest = Object.assign({}, schema.if)
+    delete rest.patternProperties
+    const j = JSON.stringify(rest)
+    if (j.includes('"patternProperties"') || j.includes('"unevaluatedProperties"')) return false
+  }
+  return true
+}
+
 function codegenSafe(schema, schemaMap) {
   if (typeof schema === 'boolean') return true
   if (typeof schema !== 'object' || schema === null) return true
@@ -1377,6 +1489,7 @@ function codegenSafe(schema, schemaMap) {
     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
     }
   }
   // unevaluatedItems: allow boolean and schema values
@@ -1715,8 +1828,85 @@ function externalDocsNeedInterpreter(schema, schemaMap) {
   return false
 }
 
+// A local $ref cycle that returns to a schema without moving to another value,
+// such as `A: { oneOf: [{ $ref: '#/$defs/A' }, ...] }`, never terminates on its
+// own. The interpreter stops it and answers; generated code recursed until the
+// stack ran out and threw a RangeError into the caller, on primitives, where
+// the cycle guard has no object to recognise. Cycles that pass through
+// properties, items or any other keyword that moves to a child value are
+// ordinary recursion and are not affected.
+const SAME_INSTANCE_LISTS = ['allOf', 'anyOf', 'oneOf']
+const SAME_INSTANCE_ONE = ['not', 'if', 'then', 'else']
+function localPointerTarget(root, ref) {
+  if (typeof ref !== 'string' || ref.charCodeAt(0) !== 35) return null
+  if (ref === '#') return root
+  if (ref.charCodeAt(1) !== 47) return null
+  let t = root
+  for (let seg of ref.slice(2).split('/')) {
+    if (seg.indexOf('%') >= 0) { try { seg = decodeURIComponent(seg) } catch { return null } }
+    seg = seg.replace(/~1/g, '/').replace(/~0/g, '~')
+    if (t === null || typeof t !== 'object') return null
+    if (!Object.prototype.hasOwnProperty.call(t, seg)) {
+      const alias = seg === 'definitions' ? '$defs' : seg === '$defs' ? 'definitions' : null
+      if (alias === null || !Object.prototype.hasOwnProperty.call(t, alias)) return null
+      seg = alias
+    }
+    t = t[seg]
+  }
+  return t !== null && typeof t === 'object' ? t : null
+}
+function sameInstanceEdges(root, node) {
+  const out = []
+  for (const k of SAME_INSTANCE_LISTS) if (Array.isArray(node[k])) for (const x of node[k]) if (x && typeof x === 'object') out.push(x)
+  for (const k of SAME_INSTANCE_ONE) if (node[k] && typeof node[k] === 'object') out.push(node[k])
+  if (node.dependentSchemas && typeof node.dependentSchemas === 'object') for (const x of Object.values(node.dependentSchemas)) if (x && typeof x === 'object') out.push(x)
+  if (typeof node.$ref === 'string') { const t = localPointerTarget(root, node.$ref); if (t) out.push(t) }
+  return out
+}
+const _sameInstanceCycleCache = new WeakMap()
+function hasSameInstanceRefCycle(root) {
+  if (root === null || typeof root !== 'object') return false
+  const hit = _sameInstanceCycleCache.get(root)
+  if (hit !== undefined) return hit
+  let found = false
+  if (JSON.stringify(root).includes('"$ref"')) {
+    // Only what validation can reach: definitions are entered through the
+    // references that name them, so a broken definition nothing uses (a real
+    // SchemaStore schema has one that includes itself) does not cost the
+    // whole schema its generated code.
+    const nodes = []
+    const seen = new Set()
+    const collect = (n) => {
+      if (n === null || typeof n !== 'object' || seen.has(n)) return
+      seen.add(n)
+      if (Array.isArray(n)) { for (const v of n) collect(v); return }
+      nodes.push(n)
+      for (const [k, v] of Object.entries(n)) {
+        if (k === '$defs' || k === 'definitions' || k === 'enum' || k === 'const' || k === 'default' || k === 'examples') continue
+        collect(v)
+      }
+      if (typeof n.$ref === 'string') collect(localPointerTarget(root, n.$ref))
+    }
+    collect(root)
+    const state = new Map() // 1 on the stack, 2 done
+    const visit = (n) => {
+      const st = state.get(n)
+      if (st === 1) return true
+      if (st === 2) return false
+      state.set(n, 1)
+      for (const m of sameInstanceEdges(root, n)) if (visit(m)) return true
+      state.set(n, 2)
+      return false
+    }
+    for (const n of nodes) if (visit(n)) { found = true; break }
+  }
+  _sameInstanceCycleCache.set(root, found)
+  return found
+}
+
 function sharedCodegenGate(schema, schemaMap) {
   if (typeof schema !== 'object' || schema === null) return true
+  if (hasSameInstanceRefCycle(schema)) return false
   if (!codegenSafe(schema, schemaMap)) return false
   if (needsBaseTracking(schema, schemaMap, new Set())) return false
   if (externalDocsNeedInterpreter(schema, schemaMap)) return false
@@ -1725,16 +1915,10 @@ function sharedCodegenGate(schema, schemaMap) {
 
 // --- Codegen mode: generates a single Function (NOT CSP-safe) ---
 // This matches ajv's approach: one monolithic function, V8 JIT fully inlines it
-// `propertyNames` as the generators read it. They express maxLength,
-// minLength, pattern, const and enum, and the gate declines anything else, so
-// a schema that writes `propertyNames: { $ref: '#/definitions/Key' }` or adds
-// `type: 'string'` went to the interpreted engine. Both are rewritten here, on
-// a copy of the nodes that change: a local reference, through aliases, is
-// replaced by what it names, `type: 'string'` is dropped since every property
-// name is a string, and annotations go. Where what is left is still not all
-// supported keys, the node is left as written and the gate declines as before.
-// Errors keep the path the interpreted engine reports, which runs through the
-// reference without naming it.
+// `propertyNames` as the generators read it (maxLength, minLength, pattern,
+// const, enum): a local $ref, through aliases, becomes what it names, and
+// `type: 'string'` and annotations go, on a copy. Anything else is left as
+// written and the gate declines. Errors keep the interpreted engine's path.
 const PN_SUPPORTED = new Set(['maxLength', 'minLength', 'pattern', 'const', 'enum'])
 const PN_ANNOTATIONS = new Set(['$schema', '$comment', 'title', 'description', 'examples', 'default', 'deprecated', 'readOnly', 'writeOnly'])
 function simplePropertyNames(pn, defs) {
@@ -2476,7 +2660,7 @@ function genCodeNode(schema, v, lines, ctx, knownType) {
       if (!ctx.regExpMap.has(pattern)) {
         const ri = ctx.varCounter++
         ctx.regExpMap.set(pattern, ri)
-        if (patternIsSafe(schema.pattern)) {
+        if (useSafeEngine(schema.pattern)) {
           ctx.helperCode.push(`const _re${ri}=__ataSafeRe(${pattern})`);
           ctx.usesSafeRe = true
         } else {
@@ -2529,8 +2713,14 @@ function genCodeNode(schema, v, lines, ctx, knownType) {
     // No `properties` means nothing is declared, so every key is additional.
     // The generators used to emit nothing for that shape, and the safety gate
     // declined it everywhere; at any depth it now compiles.
-    const propCount = Object.keys(schema.properties || {}).length
-    const allRequired = schema.required && schema.required.length === propCount
+    const declaredKeys = Object.keys(schema.properties || {})
+    const propCount = declaredKeys.length
+    // Counting keys proves there is no extra key only when every declared
+    // name is required. Comparing the list lengths was not that: with
+    // `properties: {c}` and `required: ['b']` the counts matched, and `{b: 1}`
+    // was accepted although `b` is an additional property.
+    const req = new Set(schema.required || [])
+    const allRequired = !!schema.required && declaredKeys.every((k) => req.has(k))
     const inner = allRequired
       ? (propCount <= 15
           ? `var _n=0;for(var _k in ${v})_n++;if(_n!==${propCount})return false`
@@ -2637,8 +2827,12 @@ function genCodeNode(schema, v, lines, ctx, knownType) {
   }
 
   // anyOf — branch fns hoisted when safe, inline fallback when recursive.
-  // Skip standard anyOf if unevaluatedProperties will handle it (single-pass optimization)
-  if (schema.anyOf && schema.unevaluatedProperties === undefined) genAnyOfNode(schema, v, lines, ctx, knownType)
+  // The anyOf model in genUnevaluatedPropertiesNode checks that a branch
+  // passes while it records what the branches evaluate, so anyOf is emitted
+  // once, there. Only that model does: with unevaluatedProperties true or a
+  // schema, skipping it here left anyOf unchecked and accepted a document no
+  // branch matched.
+  if (schema.anyOf && !unevalChecksAnyOf(schema, ctx)) genAnyOfNode(schema, v, lines, ctx, knownType)
 
   // oneOf — branch fns hoisted to factory scope when safe (no recursion/ref).
   // Falls back to inline closures if any branch touches recursive validation.
@@ -3170,6 +3364,12 @@ function genPatternPropertiesNode(schema, v, lines, ctx, knownType, isObj) {
   return handledPropertyNames
 }
 
+function unevalChecksAnyOf(schema, ctx) {
+  if (schema.unevaluatedProperties !== false) return false
+  const r = collectEvaluated(schema, ctx.schemaMap, ctx.rootDefs)
+  return r.dynamic && !r.allProps
+}
+
 function genUnevaluatedPropertiesNode(schema, v, lines, ctx, knownType, isObj, hoisted, earlyKeyCount) {
   const evalResult = collectEvaluated(schema, ctx.schemaMap, ctx.rootDefs)
 
@@ -3448,6 +3648,16 @@ function genUnevaluatedPropertiesNode(schema, v, lines, ctx, knownType, isObj, h
             const inner = `for(var _k in ${v}){if(${evVar}[_k])continue;${reVars.map(rv => `if(${rv}.test(_k)){${evVar}[_k]=1;continue}`).join('')}return false}`
                           _deferOrInline(ctx, lines, v, isObj ? inner + '}' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}}`)
           }
+        } else {
+          // Nothing dynamic contributes a name (a lone if with no properties
+          // or patterns, say): only the fixed names are evaluated. This branch
+          // used to emit nothing, and nothing read as valid.
+          const ei = ctx.varCounter++
+          const evVar = `_ev${ei}`
+          lines.push(`{const ${evVar}={}`)
+          for (const k of baseProps) lines.push(`${evVar}[${JSON.stringify(k)}]=1`)
+          const inner = `for(var _k in ${v}){if(!${evVar}[_k])return false}`
+          _deferOrInline(ctx, lines, v, isObj ? inner + '}' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}}`)
         }
       }
     } else if (typeof schema.unevaluatedProperties === 'object') {
@@ -4161,17 +4371,44 @@ function compileToJSCodegenWithErrors(schema, schemaMap, userFormats, sourceOpts
     // function and were rebuilt on every call, which on a product schema with
     // six URLs and one anyOf cost about 450 ns before a single check ran, more
     // than every check and every error together. Here they run once, in a
-    // factory, as the verdict function's preamble does. Only for the plain
-    // shape: with $defs or recursion the helpers include functions that read
-    // the per-call guard state declared in the body, so those keep `body` as
-    // it is. `_errSource` below stays `body` either way, for the emitters.
-    const hoistable = !ctx.usesRecursion && defSetsE.length === 0 && helpersE !== ''
-    if (hoistable) {
-      const factoryBody = helpersE + 'return function(d,_all){const _e=[];\n  ' + checkStr +
+    // factory, as the verdict function's preamble does; with $defs or
+    // recursion too, below. `_errSource` stays `body` either way, for the
+    // emitters.
+    // The factory builds the helpers once and returns the error function.
+    // With $defs or recursion the helpers are the definitions' functions and
+    // the cycle guard's state lives beside them; the guarded run resets that
+    // state at its start, and a call made while one is running (a custom
+    // keyword validating with the same validator) gets a function from a fresh
+    // factory call instead of sharing it. `_errFactory` carries the same text
+    // to the standalone emitter.
+    let factoryBody
+    if (needsGuardE) {
+      const attempt = ctx.usesRecursion ? '_validateE(d,_all,_e)' : '_bodyE(d,_all,_e)'
+      const runner = ctx.usesRecursion
+        ? emitRootGuard('_validateE', 'd,_all,_e', '') + `function _validateE_b(d,_all,_e){\n  ${checkStr}\n  }\n  `
+        : `function _bodyE(d,_all,_e){\n  ${checkStr}\n  }\n  `
+      factoryBody = guardStrE + helpersE + runner + `return function(d,_all){const _e=[];\n  ` +
+        emitGuardedRun(attempt, '_e.length=0;', defSetsE) + `return{valid:_e.length===0,errors:_e}}`
+    } else {
+      factoryBody = helpersE + 'return function(d,_all){const _e=[];\n  ' + checkStr +
         '\n  return{valid:_e.length===0,errors:_e}}'
-      const params = ctx.usesSafeRe ? [...cvars, '__ataSafeRe'] : [...cvars]
-      const args = ctx.usesSafeRe ? [...cvals, compileSafe] : [...cvals]
-      fn = new Function(...params, factoryBody)(...args)
+    }
+    const hoistable = !ctx.usesRecursion && defSetsE.length === 0 && helpersE !== ''
+    if (hoistable || needsGuardE) {
+      const params = [...cvars, '__ataSafeRe']
+      const args = [...cvals, compileSafe]
+      const make = new Function(...params, factoryBody)
+      const main = make(...args)
+      if (needsGuardE) {
+        let busy = false
+        fn = (d, _all) => {
+          if (busy) return make(...args)(d, _all)
+          busy = true
+          try { return main(d, _all) } finally { busy = false }
+        }
+      } else {
+        fn = main
+      }
     } else if (ctx.usesSafeRe) {
       // Inlined helperCode references __ataSafeRe; bind the safe-regex factory.
       // Standalone keeps the inline _errSource — the embed defines __ataSafeRe.
@@ -4186,6 +4423,8 @@ function compileToJSCodegenWithErrors(schema, schemaMap, userFormats, sourceOpts
       fn = new Function('d', '_all', body)
     }
     fn._errSource = body
+    fn._errFactory = factoryBody
+    fn._errGuarded = needsGuardE
     fn._sharedHelpers = ctx.shared ? ctx.shared.slice() : []
     fn._usesSafeRe = !!ctx.usesSafeRe
     if (cvars.length) {
@@ -4216,32 +4455,65 @@ function emitBranchCollapse (branches, keyword, v, pathExpr, lines, ctx, schemaP
   const branchKw = keyword
   const branchSp = schemaPrefix + '/' + branchKw
   // Per-branch error-collecting functions, each returning {valid,errors}.
+  // They take the value, its instance path, `_all` and, inside a definition
+  // written once for all its references, that reference's schema path, so
+  // they can be built once per call of the error function rather than each
+  // time the keyword is reached: on a list of 1723 tokens that is thousands
+  // of closure arrays per validation.
   const fns = []
   const titles = []
+  let usesSp = false
   for (let i = 0; i < branches.length; i++) {
     const sub = branches[i]
     const subLines = []
     const subSp = branchSp + '/' + i
     if (typeof sub === 'object' && sub !== null) {
-      genCodeE(sub, '_bv', pathExpr, subLines, ctx, subSp)
+      genCodeE(sub, '_bv', '_bpth', subLines, ctx, subSp)
     } else if (sub === false) {
       // A false branch never matches; it reports the same error the
       // interpreter attaches to a false schema.
-      subLines.push(`_e.push({keyword:'not',instancePath:${pathExpr||'""'},schemaPath:'${subSp}'${ordinalField(ctx, `${subSp}`)},params:{},message:'boolean schema is false'})`)
+      subLines.push(`_e.push({keyword:'not',instancePath:_bpth,schemaPath:'${subSp}'${ordinalField(ctx, `${subSp}`)},params:{},message:'boolean schema is false'})`)
     }
     const title = (sub && typeof sub === 'object' && typeof sub.title === 'string') ? sub.title : ''
     titles.push(title)
-    const body = subLines.length === 0
-      ? `function(_bv){return{valid:true,errors:[]}}`
-      : `function(_bv){const _e=[];${subLines.join(';')};return{valid:_e.length===0,errors:_e}}`
+    let body = subLines.length === 0 ? '' : `const _e=[];${subLines.join(';')};return{valid:_e.length===0,errors:_e}`
+    if (body.includes(SP_PLACEHOLDER)) {
+      body = body.split(`'${SP_PLACEHOLDER}`).join(`_sp+'`).split(`"${SP_PLACEHOLDER}`).join(`_sp+"`)
+      if (body.includes(SP_PLACEHOLDER)) throw DECLINE
+      usesSp = true
+    }
     fns.push(body)
   }
+  const params = usesSp ? '_bv,_bpth,_all,_sp' : '_bv,_bpth,_all'
   const fnArr = `_brf${fi}`
   const resArr = `_brr${fi}`
   const titleArr = JSON.stringify(titles)
   const collapsed = `_brc${fi}`
   const pp = pathExpr || '""'
-  lines.push(`{const ${fnArr}=[${fns.join(',')}];const _bt${fi}=${titleArr};const ${resArr}=[];for(let _bi=0;_bi<${fnArr}.length;_bi++){const _br=${fnArr}[_bi](${v});${resArr}.push({valid:_br.valid,errors:_br.errors,title:_bt${fi}[_bi]})}const ${collapsed}=__ataCollapse('${branchKw}',${resArr},${pp},'${branchSp}',${(() => { const o = ordinalFor(ctx.rootSchema, branchSp); return o === null ? 'null' : o })()});if(${collapsed}){_e.push(${collapsed});if(!_all)return{valid:false,errors:_e}}}`)
+  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}}`
+  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
+    // third value next to true (collect everything) and false (stop at the
+    // first error, for abortEarly): every check reads it as `!_all` and stops
+    // at its first error, and an anyOf reached that way that fails returns
+    // at once instead of collecting its branches and collapsing them, since
+    // the caller only wants to know. An object tried against a branch that is
+    // an anyOf of primitive types used to collapse that anyOf in full and then
+    // pass the next branch, which on a list of 1723 tokens was 2353 collapses
+    // 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}}}`)
+  } 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}}}`)
+  }
 }
 
 // Error-collecting code generator.
@@ -4277,9 +4549,14 @@ function genCodeENode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     if (m && ctx.rootDefs && ctx.rootDefs[m[1]]) {
       const defName = m[1]
       if (!ctx.cyclicDefs) ctx.cyclicDefs = cyclicDefNames(ctx.rootDefs)
-      if (ctx.cyclicDefs.has(defName)) {
-        // Named helper for a def on a cycle; the path comes in as an
-        // argument because every call site has its own.
+      if (!ctx.sharedDefs) ctx.sharedDefs = sharedDefNames(ctx.rootSchema, ctx.rootDefs)
+      if (ctx.cyclicDefs.has(defName) || ctx.sharedDefs.has(defName)) {
+        // Named helper for a def on a cycle, and for one referenced from
+        // several places, which inlined would repeat its whole error code at
+        // each: Uniswap's token-list schema has 16 references to 10
+        // definitions. The path comes in as an argument because every call
+        // site has its own. Only the error path runs these; the verdict
+        // function, which answers valid documents, is unchanged.
         if (!ctx.defFns) ctx.defFns = new Map()
         let fnName = ctx.defFns.get(defName)
         if (!fnName) {
@@ -4459,7 +4736,7 @@ function genCodeENode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
       if (!ctx.regExpMap.has(pattern)) {
         const ri = ctx.varCounter++
         ctx.regExpMap.set(pattern, ri)
-        if (patternIsSafe(schema.pattern)) {
+        if (useSafeEngine(schema.pattern)) {
           ctx.helperCode.push(`const _re${ri}=__ataSafeRe(${pattern})`)
           ctx.usesSafeRe = true
         } else {
@@ -4534,7 +4811,7 @@ function genCodeENode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
       if (!ctx.regExpMap.has(pattern)) {
         const ri = ctx.varCounter++
         ctx.regExpMap.set(pattern, ri)
-        if (patternIsSafe(pat)) {
+        if (useSafeEngine(pat)) {
           ctx.helperCode.push(`const _re${ri}=__ataSafeRe(${pattern})`)
           ctx.usesSafeRe = true
         } else {
@@ -4551,7 +4828,10 @@ function genCodeENode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     const gateChecks = patChecks.map((c) => c.split(`_k${ci}[_i]`).join(`_f${ci}`))
     const gateTest = gateChecks.length ? `!_a${ci}.has(_f${ci})&&!(${gateChecks.join('||')})` : `!_a${ci}.has(_f${ci})`
     const detail = `const _k${ci}=Object.keys(${v});for(let _i=0;_i<_k${ci}.length;_i++){if(${isAdditional}){_e.push({code:'${apLit.codeStr}',keyword:'additionalProperties',instancePath:${pathExpr||'""'},schemaPath:'${apSp}'${ordinalField(ctx, `${apSp}`)},params:{additionalProperty:_k${ci}[_i]},message:'must NOT have additional properties',docUrl:'${apLit.docUrl}'${apLit.frame}});if(!_all)return{valid:false,errors:_e}}}`
-    const inner = `const _a${ci}=new Set([${allowed}]);let _x${ci}=0;for(const _f${ci} in ${v}){if(${gateTest}){_x${ci}=1;break}}if(_x${ci}){${detail}}`
+    // The name set is built once per call of the error function, not at every
+    // object it checks: on a list of 1723 tokens it was 1723 Sets.
+    ctx.helperCode.push(`const _a${ci}=new Set([${allowed}])`)
+    const inner = `let _x${ci}=0;for(const _f${ci} in ${v}){if(${gateTest}){_x${ci}=1;break}}if(_x${ci}){${detail}}`
     lines.push(isObj ? `{${inner}}` : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}`)
   }
 
@@ -4697,7 +4977,7 @@ function genUnevaluatedFalseE(schema, v, pathExpr, lines, ctx, schemaPrefix, isO
     if (!ctx.regExpMap.has(pattern)) {
       const ri = ctx.varCounter++
       ctx.regExpMap.set(pattern, ri)
-      if (patternIsSafe(pat)) {
+      if (useSafeEngine(pat)) {
         ctx.helperCode.push(`const _re${ri}=__ataSafeRe(${pattern})`)
         ctx.usesSafeRe = true
       } else {
@@ -4707,7 +4987,8 @@ function genUnevaluatedFalseE(schema, v, pathExpr, lines, ctx, schemaPrefix, isO
     patChecksU.push(`_re${ctx.regExpMap.get(pattern)}.test(_k${ui}[_i])`)
   }
   const isUneval = patChecksU.length ? `!_a${ui}.has(_k${ui}[_i])&&!(${patChecksU.join('||')})` : `!_a${ui}.has(_k${ui}[_i])`
-  const innerU = `const _k${ui}=Object.keys(${v});const _a${ui}=new Set([${allowedU}]);for(let _i=0;_i<_k${ui}.length;_i++){if(${isUneval}){_e.push({code:'${upLit.codeStr}',keyword:'unevaluatedProperties',instancePath:${pathExpr||'""'},schemaPath:'${upSp}'${ordinalField(ctx, `${upSp}`)},params:{unevaluatedProperty:_k${ui}[_i]},message:'must NOT have unevaluated properties',docUrl:'${upLit.docUrl}'${upLit.frame}});if(!_all)return{valid:false,errors:_e}}}`
+  ctx.helperCode.push(`const _a${ui}=new Set([${allowedU}])`)
+  const innerU = `const _k${ui}=Object.keys(${v});for(let _i=0;_i<_k${ui}.length;_i++){if(${isUneval}){_e.push({code:'${upLit.codeStr}',keyword:'unevaluatedProperties',instancePath:${pathExpr||'""'},schemaPath:'${upSp}'${ordinalField(ctx, `${upSp}`)},params:{unevaluatedProperty:_k${ui}[_i]},message:'must NOT have unevaluated properties',docUrl:'${upLit.docUrl}'${upLit.frame}});if(!_all)return{valid:false,errors:_e}}}`
   lines.push(isObj ? `{${innerU}}` : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${innerU}}`)
 }
 
@@ -4728,7 +5009,7 @@ function genPatternPropertiesE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     if (!ctx.regExpMap.has(pattern)) {
       const ri = ctx.varCounter++
       ctx.regExpMap.set(pattern, ri)
-      if (patternIsSafe(pat)) {
+      if (useSafeEngine(pat)) {
         ctx.helperCode.push(`const _re${ri}=__ataSafeRe(${pattern})`);
         ctx.usesSafeRe = true
       } else {
@@ -4749,7 +5030,8 @@ function genPatternPropertiesE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
 function genAdditionalSchemaE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   const ki = ctx.varCounter++
   const known = Object.keys(schema.properties || {})
-  const guard = known.length ? `const _ak${ki}=new Set([${known.map((k) => JSON.stringify(k)).join(',')}]);` : ''
+  if (known.length) ctx.helperCode.push(`const _ak${ki}=new Set([${known.map((k) => JSON.stringify(k)).join(',')}])`)
+  const guard = ''
   // A key matched by any patternProperties entry is not additional.
   const patTests = []
   for (const pat of Object.keys(schema.patternProperties || {})) {
@@ -4757,7 +5039,7 @@ function genAdditionalSchemaE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     if (!ctx.regExpMap.has(pattern)) {
       const ri = ctx.varCounter++
       ctx.regExpMap.set(pattern, ri)
-      if (patternIsSafe(pat)) {
+      if (useSafeEngine(pat)) {
         ctx.helperCode.push(`const _re${ri}=__ataSafeRe(${pattern})`)
         ctx.usesSafeRe = true
       } else {
@@ -4809,7 +5091,7 @@ function genPropertyNamesE(schema, v, pathExpr, lines, ctx, schemaPrefix, fail)
     if (!ctx.regExpMap.has(pattern)) {
       const ri = ctx.varCounter++
       ctx.regExpMap.set(pattern, ri)
-      if (patternIsSafe(pn.pattern)) {
+      if (useSafeEngine(pn.pattern)) {
         ctx.helperCode.push(`const _re${ri}=__ataSafeRe(${pattern})`);
         ctx.usesSafeRe = true
       } else {
@@ -5122,6 +5404,27 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     return `(_e||(_e=[])).push({keyword:'${keyword}',instancePath:${pathExpr||'""'},schemaPath:'${sp}',params:${paramsCode},message:${msgCode}${ordinalField(ctx, sp)}})`
   }
 
+  // enum and const apply to a value of any type, so a value that fails
+  // `type` is still checked against them, as the other engines do. They sat
+  // inside the type-success block, and `{type: 'number', enum: [1]}` reported
+  // only `type` for 'x' where the interpreter reports both.
+  const emitEnumConst = () => {
+    // enum
+    if (schema.enum) {
+      lines.push(`if(!(${enumCondition(ctx, schema.enum, v)})){${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', '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'")}}`)
+      }
+    }
+  }
+
   if (types) {
     const conds = types.map(t => {
       switch (t) {
@@ -5148,22 +5451,10 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
       isStr = types[0] === 'string'
       isNum = types[0] === 'number' || types[0] === 'integer'
     }
+    emitEnumConst()
     lines.push(`if(${typeOk}){`)
-  }
-
-  // enum
-  if (schema.enum) {
-    lines.push(`if(!(${enumCondition(ctx, schema.enum, v)})){${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', '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'")}}`)
-    }
+  } else {
+    emitEnumConst()
   }
 
   // required — use destructuring when type is object (SAFE because type check already passed)
@@ -5248,7 +5539,7 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
       const ri = ctx.varCounter++
       const reVar = `_re${ri}`
       ctx.closureVars.push(reVar)
-      ctx.closureVals.push(patternIsSafe(schema.pattern) ? compileSafe(schema.pattern) : new RegExp(schema.pattern))
+      ctx.closureVals.push(useSafeEngine(schema.pattern) ? compileSafe(schema.pattern) : 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)}}`, JSON.stringify(`must match pattern "${schema.pattern}"`))}}`)
     }