ata-validator 1.38.0 → 1.39.2

package/lib/js-compiler.js

@@ -173,6 +173,7 @@ const DOC_BASE = 'https://ata-validator.com/e/'
 // reader sorts by without deriving it from the path. Empty when the path is
 // not into the root document.
 function ordinalField (ctx, schemaPath) {
+  if (ctx && ctx.noOrdinal) return ''
   const o = ctx && ctx.rootSchema ? ordinalFor(ctx.rootSchema, unescapeSp(schemaPath)) : null
   return o === null ? '' : `,_o:${o}`
 }
@@ -198,6 +199,8 @@ function unescapeSp (sp) {
   return sp.indexOf('\\') === -1 ? sp : sp.replace(/\\(.)/g, '$1')
 }
 
+const FRAME_INLINE_MAX = 120
+
 function buildErrorLiteral (opts) {
   const { keyword, format, schemaPath, sourceMap } = opts
   let code = (keyword === 'format' && format) ? codeFor('format', format) : codeFor(keyword)
@@ -214,10 +217,24 @@ function buildErrorLiteral (opts) {
       const line = Array.isArray(hit) ? hit[0] : hit.line
       const col = Array.isArray(hit) ? hit[1] : hit.col
       const text = Array.isArray(hit) ? hit[2] : hit.text
-      frame = ',schemaSource:Object.freeze({file:' + JSON.stringify(sourceMap.file) +
-        ',line:' + line +
-        ',col:' + col +
-        ',text:' + JSON.stringify(text) + '})'
+      if (sourceMap.frames && text.length > FRAME_INLINE_MAX) {
+        // A long source line is written once at module scope (see
+        // sourceFrameDecls in aot-impl.js) and the literal names it. Inlined,
+        // every error site carried the whole line, and a schema kept on one
+        // line is one line of all of it: 181 KB minified for a 2 KB schema.
+        // Short lines stay inline: gzip folds the repeats, and measured on
+        // the 50-field fixture the table cost 1206 gzipped bytes where the
+        // inline frames cost 696.
+        const key = line + ':' + col
+        let f = sourceMap.frames.get(key)
+        if (!f) { f = { line, col, text, index: sourceMap.frames.size }; sourceMap.frames.set(key, f) }
+        frame = ',schemaSource:__ataSS[' + f.index + ']'
+      } else {
+        frame = ',schemaSource:Object.freeze({file:' + JSON.stringify(sourceMap.file) +
+          ',line:' + line +
+          ',col:' + col +
+          ',text:' + JSON.stringify(text) + '})'
+      }
     }
   }
   return { codeStr: code, docUrl, frame }
@@ -286,6 +303,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.
@@ -1300,6 +1320,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
@@ -1416,6 +1506,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
@@ -1754,8 +1845,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
@@ -2562,8 +2730,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`
@@ -2670,8 +2844,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.
@@ -3203,6 +3381,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)
 
@@ -3481,6 +3665,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') {
@@ -4138,7 +4332,7 @@ function compileToJSCodegenWithErrors(schema, schemaMap, userFormats, sourceOpts
                 // closure parameters below the way the other entry points do.
                 closureVars: [], closureVals: [],
                 sourceMap: (sourceOpts && sourceOpts.sourceMap && sourceOpts.schemaFile)
-                  ? { file: sourceOpts.schemaFile, map: sourceOpts.sourceMap }
+                  ? { file: sourceOpts.schemaFile, map: sourceOpts.sourceMap, frames: sourceOpts.frames || null }
                   : null }
   ctx.helperCode.push('const _cpLen=s=>{let n=0;for(const _ of s)n++;return n}')
   const lines = []
@@ -4194,17 +4388,56 @@ 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)
+    }
+    // For the runtime, the literals take the legacy shape directly. `code` and
+    // `docUrl` are there for standalone modules, which return errors as they
+    // are; the runtime derives both from the keyword when it enriches, and
+    // orders errors by schemaPath, so the literals carried three fields that
+    // every read then copied the error to remove. The patterns are this
+    // generator's own spelling; the collapse helper writes its fields with a
+    // space and keeps them.
+    if (sourceOpts && sourceOpts.runtimeShape) {
+      const shape = (src) => src.replace(/code:'ATA\d{4}',/g, '').replace(/,docUrl:'https:\/\/ata-validator\.com\/e\/ATA\d{4}'/g, '').replace(/,_o:\d+/g, '')
+      body = shape(body)
+      factoryBody = shape(factoryBody)
+    }
+    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.
@@ -4219,6 +4452,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) {
@@ -4249,32 +4484,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.
@@ -4589,7 +4857,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}}`)
   }
 
@@ -4745,7 +5016,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}}`)
 }
 
@@ -4787,7 +5059,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 || {})) {
@@ -4933,7 +5206,7 @@ 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.
-function compileToJSCombined(schema, VALID_RESULT, schemaMap, userFormats) {
+function compileToJSCombined(schema, VALID_RESULT, schemaMap, userFormats, opts) {
   const inputSchema = schema
   schema = normalizePropertyNames(schema)
   // Same provably-local rule as the error generator above.
@@ -5013,7 +5286,8 @@ function compileToJSCombined(schema, VALID_RESULT, schemaMap, userFormats) {
   if (hasUnresolvableRef(schema, cRootDefs, cAnchors, schemaMap, new Set())) return null
   if (needsBaseTracking(schema, schemaMap, new Set())) return null
 
-  const ctx = { varCounter: 0, helperCode: [], shared: [], closureVars: ['_cpLen'], closureVals: [_cpLen],
+  // runtimeShape: errors without the ordinal, see compileToJSCodegenWithErrors.
+  const ctx = { noOrdinal: !!(opts && opts.runtimeShape), 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 {
@@ -5148,7 +5422,7 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
         if (pathVal !== undefined) {
         const spVal = unescapeSp(sp)
         ctx.closureVars.push(errVar)
-        const o = ordinalFor(ctx.rootSchema, spVal)
+        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))
@@ -5160,6 +5434,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) {
@@ -5186,22 +5481,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)