ata-validator 1.38.0 → 1.39.1

package/README.md

@@ -32,13 +32,13 @@ npm install --save-dev ata-validator
 npx ata build 'schemas/*.json' --out-dir src/generated
 ```
 
-The `ata-validator` package itself is pure JavaScript. The native accelerator (simdjson parsing, parallel NDJSON, buffer APIs) ships as per-platform optional packages that npm installs automatically where they fit, the same pattern Vite uses for esbuild. Seven targets are built: macOS on arm64 and x64, Linux on x64 and arm64 against both glibc and musl, and Windows on x64. A platform without a prebuild still installs and validates, on the pure-JS engine. For a guaranteed zero-binary install:
+The `ata-validator` package itself is pure JavaScript. The native accelerator (simdjson parsing, parallel NDJSON, buffer APIs) ships as per-platform optional packages that npm installs automatically where they fit, the same pattern Vite uses for esbuild. Seven targets are built: macOS on arm64 and x64, Linux on x64 and arm64 against both glibc (2.17 or later, below the 2.28 Node itself needs) and musl, and Windows on x64. A platform without a prebuild still installs and validates, on the pure-JS engine. For a guaranteed zero-binary install:
 
 ```bash
 npm install ata-validator --omit=optional
 ```
 
-or set `ATA_NO_NATIVE=1` at runtime. Typical schemas compile to specialized JS; shapes the compiler cannot represent (some `$dynamicRef`, cyclic `$ref`, unusual keyword interactions) fall back to an interpreted engine, so every schema validates in every environment. The pure-JS setup scores the same on the official suite as the native one, 1301 of 1301 Draft 2020-12 cases. Only the buffer and parallel APIs (`isValid` on raw buffers, `countValid`, `batchIsValid`, `validateAndParse`) need the native engine and say so with a clear error.
+or set `ATA_NO_NATIVE=1` at runtime. Typical schemas compile to specialized JS; shapes the compiler cannot represent (some `$dynamicRef`, cyclic `$ref`, unusual keyword interactions) fall back to an interpreted engine, so every schema validates in every environment. The pure-JS setup scores the same on the official suite as the native one, 1301 of 1301 Draft 2020-12 cases. The buffer and parallel APIs (`isValid` on raw buffers, `isValidPrepadded`, `isValidNDJSON`, `isValidParallel`, `countValid`, `batchIsValid`, `validateAndParse`) work without the addon too, answering through the same checks as `isValidJSON()`, slower than the addon: 177 ns against 92 for a small document on Node 25. In a browser, which has no `Buffer`, they throw and name the methods to use instead.
 
 Those four now agree with `validate()` on every case of the official suite, 3365 across three dialects. The native walker behind them does not handle every shape (`contains`, `unevaluatedProperties`, `patternProperties`, tuple `items`, cross-document `$ref`, a few formats), so for schemas using one of those the buffer APIs parse the bytes and answer through `validate()`; the list is in `lib/buffer-gate.js`. Typical request schemas stay on the zero-copy path. `npm test` holds the disagreement count at zero.
 

package/index.d.ts

@@ -439,7 +439,8 @@ export interface ValidatorOptions {
    * answers `validate()`, `isValidObject()` and `validateJSON()`. For a schema
    * that arrives from outside the trust boundary. The verdict is the same on
    * every engine; the cost is not. The buffer APIs (`isValid`, `countValid`,
-   * `batchIsValid`) are native-only and unaffected.
+   * `batchIsValid`) use the native addon where it loads, which this option
+   * does not affect; without it they answer through the engine it picks.
    */
   engine?: 'auto' | 'interpreter';
 }

package/lib/aot-impl.js

@@ -17,7 +17,7 @@ const { compileToJSCodegenWithErrors, compileToJSCodegen, unevalContributions }
 const { buildTargetedPositionMap } = require('./data-positions');
 const { schemaHash } = require('./schema-hash');
 const ATA_VERSION = require('./version');
-const SAFE_REGEX_SOURCE = require('./safe-regex-source');
+const { engineSource: safeRegexEngineSource } = require('./safe-regex');
 
 // Embedded verbatim in standalone modules so the output file has no runtime
 // dependency on ata-validator. ASCII fast-path plus surrogate-aware slow path.
@@ -31,21 +31,16 @@ const _CP_LEN_SOURCE = `function _cpLen(s) {
   return len;
 }`;
 
-// The linear-time regex engine, inlined verbatim into standalone output so a
-// compiled module that uses safe `pattern` matchers has no runtime dependency
-// on ata-validator. The engine source is baked into `lib/safe-regex-source.js`
-// at build time (see `scripts/regen-safe-regex-source.js`), so this path has
-// no `fs`/`path`/`__dirname` reads — safe in browser bundles too. The embed
-// strips the strict directive and CommonJS exports and adds the `__ataSafeRe`
-// alias the emitted code calls. The engine has no eval/new Function, so the
+// The linear-time regex engine, embedded in standalone modules whose patterns
+// need it so the output does not depend on ata-validator at run time. The text
+// is the engine's own function (lib/safe-regex.js), called once for the
+// `__ataSafeRe` the emitted code uses. No fs, path or __dirname, so this is
+// safe in browser bundles, and the engine has no eval or new Function, so the
 // embed is CSP-safe.
 let _safeRegexEmbed = null;
 function getSafeRegexEmbed() {
   if (_safeRegexEmbed === null) {
-    const body = SAFE_REGEX_SOURCE
-      .replace(/^'use strict'\s*\n/, '')
-      .replace(/\nmodule\.exports[^\n]*\n?/, '\n');
-    _safeRegexEmbed = body.trimEnd() + '\nconst __ataSafeRe = compileSafe;';
+    _safeRegexEmbed = 'const __ataSafeRe = (' + safeRegexEngineSource() + ')().compileSafe;';
   }
   return _safeRegexEmbed;
 }
@@ -213,7 +208,18 @@ function toStandaloneModule(validator, opts) {
       (source && sourceMap && schemaFile) ? { sourceMap, schemaFile } : null,
     );
     const errSrc = jsErrFn && jsErrFn._errSource ? jsErrFn._errSource : '';
-    if (errSrc) {
+    if (errSrc && jsErrFn._errFactory) {
+      // The helpers (patterns, name sets, definition and branch functions) are
+      // built once, not on every call. With $defs the
+      // cycle guard's state sits beside them, so a call made while one is
+      // running takes a function from a fresh factory call.
+      // Built on the first error read rather than at import, so a page that
+      // only ever accepts pays nothing for them at load.
+      const fac = jsErrFn._errFactory;
+      errCore = jsErrFn._errGuarded
+        ? `const _mkErr = function() {\n  ${fac}\n};\nlet _errMain = null;\nlet _errBusy = false;\nconst errFn = function(d, _all) { if (_errBusy) return _mkErr()(d, _all); if (_errMain === null) _errMain = _mkErr(); _errBusy = true; try { return _errMain(d, _all); } finally { _errBusy = false; } };\n`
+        : `const _mkErr = function() {\n  ${fac}\n};\nlet _errMain = null;\nconst errFn = function(d, _all) { return (_errMain || (_errMain = _mkErr()))(d, _all); };\n`;
+    } else if (errSrc) {
       errCore = `const errFn = function(d, _all) {\n  ${errSrc}\n};\n`;
     } else if (opts && typeof opts.onWarning === 'function') {
       // The caller asked for error detail and is not getting it: the error

package/lib/buffer-gate.js

@@ -122,14 +122,13 @@ function toText(input, name) {
   throw new TypeError(`${name}() requires a Buffer, Uint8Array, or string. For parsed objects, use isValidObject().`);
 }
 
-// Replaces the instance's buffer APIs with versions that parse and call
-// validate(). Installed after compilation, so `validator.validate` is final.
+// Replaces the instance's buffer APIs with versions that decode the bytes and
+// ask isValidJSON(), which answers as validate() does on the parsed value and
+// reads text the scanner covers without parsing it (a small document went from
+// 350 to 155 ns without the addon). Its own native route is behind this same
+// gate, so a schema routed here never reaches the walker through it.
 function installSlowBufferApis(validator) {
-  const isValidText = (text) => {
-    let value;
-    try { value = JSON.parse(text); } catch { return false; }
-    return validator.validate(value).valid;
-  };
+  const isValidText = (text) => validator.isValidJSON(text);
   validator.isValid = (input) => isValidText(toText(input, 'isValid'));
   validator.isValidPrepadded = (paddedBuffer, jsonLength) =>
     isValidText(Buffer.from(paddedBuffer.buffer, paddedBuffer.byteOffset, jsonLength).toString('utf8'));

package/lib/enrich-error.js

@@ -233,8 +233,10 @@ function enrich (rawErr, opts) {
   if ('schema' in rawErr) out.schema = rawErr.schema;
 
   // oneOf/anyOf collapse: preserve the nested branch errors so the pretty
-  // renderer can surface the closest variant's diagnostics.
-  if (rawErr.branchErrors) out.branchErrors = rawErr.branchErrors;
+  // renderer can surface the closest variant's diagnostics. They are enriched
+  // like any other error: passed through raw, they carried whatever the engine
+  // that answered wrote, the generator's internal ordering key included.
+  if (rawErr.branchErrors) out.branchErrors = rawErr.branchErrors.map((b) => enrich(b, data !== undefined ? { data } : null));
 
   if (positions && positions[path]) {
     const p = positions[path];

package/lib/js-compiler.js

@@ -286,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.
@@ -1300,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
@@ -1416,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
@@ -1754,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
@@ -2562,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`
@@ -2670,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.
@@ -3203,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)
 
@@ -3481,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') {
@@ -4194,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.
@@ -4219,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) {
@@ -4249,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.
@@ -4589,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}}`)
   }
 
@@ -4745,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}}`)
 }
 
@@ -4787,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 || {})) {
@@ -5160,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) {
@@ -5186,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)