ata-validator 1.41.0 → 1.43.0

package/lib/plan-compiler.js

@@ -135,10 +135,15 @@ function install(deps) {
   // Rollback marks: the two array lengths and the contiguous count.
   function pLen(rec) { return rec.props === null ? 0 : rec.props.length; }
   function xLen(rec) { return rec.x === null ? 0 : rec.x.length; }
+  // Writing an array's length is a slow path in V8 even when it does not
+  // change it, and most undos change nothing: a branch that failed before
+  // marking anything. So the length is written only when it moves.
   function undo(rec, pl, n0, xl) {
-    if (rec.props !== null) rec.props.length = pl;
+    const p = rec.props;
+    if (p !== null && p.length !== pl) p.length = pl;
     rec.n = n0;
-    if (rec.x !== null) rec.x.length = xl;
+    const x = rec.x;
+    if (x !== null && x.length !== xl) x.length = xl;
   }
 
   // The value-level keywords of one node, compiled. evalLeafV() answers the

package/lib/rejections.js

@@ -261,9 +261,26 @@ const COLLAPSE_CODES = new Set(['ATA4001', 'ATA4002', 'ATA4003']);
 function stripOrdinal(e) {
   if (e === null || typeof e !== 'object') return e;
   // Generated code keeps errors at a fixed path as frozen literals shared by
-  // every call. The caller gets its own copy, as it always has, so an error it
-  // edits (a translated message) is its own and editing it does not throw.
-  if (e._o === undefined && e.docUrl === undefined && (e.code === undefined || COLLAPSE_CODES.has(e.code)) && !e.branchErrors) return Object.isFrozen(e) ? { ...e } : e;
+  // every call, marked with a non-enumerable `_s` (see sharedErr in
+  // lib/js-compiler.js). The caller gets its own copy, as it always has, so an
+  // error it edits (a translated message) is its own and editing it does not
+  // throw. Those literals hold the five keys of this shape and nothing else
+  // enumerable, so a literal of the same shape copies them: spreading one cost
+  // twice as much, and Object.isFrozen, which used to pick them out, more than
+  // the copy itself.
+  if (e._s === true && e.code === undefined && e.docUrl === undefined && e.branchErrors === undefined) {
+    return { keyword: e.keyword, instancePath: e.instancePath, schemaPath: e.schemaPath, params: e.params, message: e.message };
+  }
+  // A collapsed oneOf/anyOf error has one of the two shapes __ataCollapse in
+  // lib/branch-collapse.js builds, the only place these codes come from. Its
+  // fields are copied by name, in that order, without the ordinal: walking
+  // its keys with for-in was most of the cost of reading such an error.
+  if (e.path !== undefined && e.docUrl === undefined && COLLAPSE_CODES.has(e.code)) {
+    const out = { code: e.code, keyword: e.keyword, instancePath: e.instancePath, path: e.path, schemaPath: e.schemaPath, message: e.message, params: e.params };
+    if ('branchErrors' in e) out.branchErrors = Array.isArray(e.branchErrors) ? e.branchErrors.map(stripOrdinal) : e.branchErrors;
+    return out;
+  }
+  if (e._o === undefined && e.docUrl === undefined && (e.code === undefined || COLLAPSE_CODES.has(e.code)) && !e.branchErrors) return e._s === true ? { ...e } : e;
   const out = {};
   for (const k in e) {
     if (k === '_o' || k === 'docUrl') continue;

package/lib/scan-compiler.js

@@ -90,6 +90,22 @@ const BASE_CHANGING = new Set(['$id', '$anchor', '$dynamicAnchor', '$dynamicRef'
 // it. Sized for a node per declared property of a large generated schema,
 // not just for hand-written ones.
 const MAX_NODES = 8192;
+// See the size checks in compileScanner. One function past 64 KB is what V8's
+// Maglev tier aborted on: SchemaStore scanners of 0.5 to 1 MB, single
+// functions before references became calls. The total bounds the memory a
+// scanner takes.
+const MAX_FUNCTION_SOURCE = 64 * 1024;
+const MAX_SOURCE = 2 * 1024 * 1024;
+// A reference target is expanded at each reference while its expansions
+// together are at most this much source, and called otherwise.
+const INLINE_REF_MAX = 4096;
+// An object member whose scan is more than this much source is moved into a
+// function of its own (emitMember).
+const SPLIT_MIN = 4 * 1024;
+// The member source an object keeps inline before the rest move out.
+const SPLIT_OBJECT = 16 * 1024;
+// Declared names at least this long on average find a key's end with indexOf.
+const INDEX_KEY_MIN_AVG = 10;
 
 // Each position in a tuple emits its own branch inside the element loop, so a
 // long one is both a lot of source and a linear test per element.
@@ -155,9 +171,19 @@ function resolveLocalRef(root, ref) {
   if (ref === '#') return root;
   if (!ref.startsWith('#/')) decline('$ref:not-local');
   let node = root;
+  let first = true;
   for (const rawToken of ref.slice(2).split('/')) {
-    const token = decodeURIComponent(rawToken).split('~1').join('/').split('~0').join('~');
+    let token = decodeURIComponent(rawToken).split('~1').join('/').split('~0').join('~');
     if (node === null || typeof node !== 'object') decline('$ref:unresolved');
+    // Draft 7 schemas reach the scanner with `definitions` renamed to `$defs`
+    // (lib/draft7.js) and their references as written; the other engines
+    // read either name, and so does this. Without it no draft 7 schema that
+    // used a definition got a scanner.
+    if (first && node === root && !Array.isArray(node) && !Object.prototype.hasOwnProperty.call(node, token)) {
+      if (token === 'definitions' && Object.prototype.hasOwnProperty.call(node, '$defs')) token = '$defs';
+      else if (token === '$defs' && Object.prototype.hasOwnProperty.call(node, 'definitions')) token = 'definitions';
+    }
+    first = false;
     if (Array.isArray(node)) {
       if (!/^\d+$/.test(token)) decline('$ref:unresolved');
       node = node[Number(token)];
@@ -387,11 +413,45 @@ function spanHash(name) {
 // is a jump table.
 const HASH_DISPATCH_MIN = 48;
 
+// The scan is first emitted as one function with every reference expanded
+// where it is used, which is the fastest form: a call per member measured
+// about twice the cost of csslintrc's scan, a small enum referenced thirty
+// times. Only when a function would pass MAX_FUNCTION_SOURCE is it emitted
+// again with large reference targets and large object members moved into
+// functions of their own, so the source grows with the schema rather than
+// with the number of references to it.
 function compileScanner(schema, options) {
   const opts = options || {};
+  const whole = build(schema, opts, false);
+  if (whole !== null || declineReason !== 'size') return finish(whole, opts);
+  return finish(build(schema, opts, true), opts);
+}
+
+function finish(built, opts) {
+  if (built === null) {
+    if (opts.onDecline) opts.onDecline(declineReason);
+    return null;
+  }
+  const { ctx, body } = built;
+  let fn;
+  try {
+    // eslint-disable-next-line no-new-func
+    fn = new Function('_h', '_r', ctx.subSource.join('\n') + '\nreturn function scan(s){\n' + body + '\n}')(ctx.helpers, require('./scan-runtime'));
+  } catch {
+    return null; // a runtime without code generation has no scanner, by design
+  }
+  return { scan: fn, source: body, helpers: ctx.helpers.length, functions: [body, ...ctx.subSource] };
+}
+
+function build(schema, opts, split) {
   const ctx = {
     uid: 0, helpers: [], userFormats: opts.userFormats || null,
     root: schema, refStack: [], nodes: 0,
+    // With `split`, reference targets map to null when expanded in place,
+    // else to the name of the function in subSource that scans one (see the
+    // $ref case in emitValue), and large members move out too (emitMember).
+    split, subs: new Map(), subSource: [], refCounts: split ? countRefs(schema) : null,
+    inlineBytes: new Map(),
   };
   declineReason = null;
   let body;
@@ -404,21 +464,19 @@ function compileScanner(schema, options) {
     out.push('if(i<len)return 0;');
     out.push('return 1;');
     body = out.join('\n');
+    // A function this large is a cost of its own, and V8's Maglev tier
+    // aborted the process compiling scanners of 500 KB and more (traefik,
+    // detekt from SchemaStore), in plain JavaScript, on Node 24 and 25, after
+    // about a hundred calls. Unsplit, past the bound the scan is emitted
+    // split; split, past either bound the schema has no scanner and the text
+    // path parses as it does without one.
+    if (body.length > MAX_FUNCTION_SOURCE || ctx.subSource.some((x) => x.length > MAX_FUNCTION_SOURCE)) decline('size');
+    if (body.length + ctx.subSource.reduce((n, x) => n + x.length, 0) > MAX_SOURCE) decline('size');
   } catch (e) {
-    if (e === DECLINE) {
-      if (opts.onDecline) opts.onDecline(declineReason);
-      return null;
-    }
+    if (e === DECLINE) return null;
     throw e;
   }
-  let fn;
-  try {
-    // eslint-disable-next-line no-new-func
-    fn = new Function('_h', '_r', 'return function scan(s){\n' + body + '\n}')(ctx.helpers, require('./scan-runtime'));
-  } catch {
-    return null; // a runtime without code generation has no scanner, by design
-  }
-  return { scan: fn, source: body, helpers: ctx.helpers.length };
+  return { ctx, body };
 }
 
 function emitValue(schema, ctx, out, depth) {
@@ -443,9 +501,51 @@ function emitValue(schema, ctx, out, depth) {
     const ref = schema.$ref;
     if (ctx.refStack.includes(ref)) decline('$ref:recursive');
     const target = resolveLocalRef(ctx.root, ref);
+    if (!ctx.split) {
+      ctx.refStack.push(ref);
+      emitValue(target, ctx, out, depth);
+      ctx.refStack.pop();
+      return;
+    }
+    // Split (see compileScanner): a target whose expansions add up to more
+    // than a little source is emitted once, as a function of its own, and
+    // called wherever it is referenced. Expanded at every reference, the
+    // source grows with the number of references rather than with the
+    // schema: SchemaStore's traefik and detekt reach the same definitions
+    // from hundreds of places, and their scanners came to 0.5 to 1 MB, which
+    // V8's Maglev tier aborted the process compiling.
+    const sub = ctx.subs.get(target);
+    if (sub !== undefined) {
+      if (sub === null) {
+        ctx.refStack.push(ref);
+        emitValue(target, ctx, out, depth);
+        ctx.refStack.pop();
+      } else {
+        emitSubCall(sub, ctx, out);
+      }
+      return;
+    }
+    const body = [];
     ctx.refStack.push(ref);
-    emitValue(target, ctx, out, depth);
+    emitValue(target, ctx, body, depth);
     ctx.refStack.pop();
+    const text = body.join('\n');
+    // Expanded in place only while all its expansions together stay small:
+    // a small definition referenced from hundreds of places is source in
+    // hundreds of places.
+    if (text.length * (ctx.refCounts.get(ref) || 1) <= INLINE_REF_MAX) {
+      ctx.subs.set(target, null);
+      for (const line of body) out.push(line);
+      return;
+    }
+    const name = '_s' + (ctx.subSource.length + ctx.subs.size + ctx.uid++);
+    ctx.subs.set(target, name);
+    // The emitted scan of a value starts with `i` at its first character and
+    // `c` holding it, and ends with `i` past it; it answers 0 (invalid) or -1
+    // (bail) by returning. Here it returns the new position instead, which is
+    // at least 1, so the three cannot be confused.
+    ctx.subSource.push('function ' + name + '(s,i){var len=s.length,c=s.charCodeAt(i);\n' + text + '\nreturn i;}');
+    emitSubCall(name, ctx, out);
     return;
   }
 
@@ -478,6 +578,12 @@ function emitValue(schema, ctx, out, depth) {
   // present, not that it lists anything.
   let compositeAllowed = true;
   let compositeDelegate = null;
+  // The kinds the listed values have. A value of any other kind equals none
+  // of them, so its branch is left out and the value falls to the final
+  // `return 0`: csslintrc's `enum: [2, true, false]` used to scan strings
+  // only to reject them, at thirty references, and the dead branches alone
+  // pushed its scan past the size bound into calls.
+  let listedKinds = null;
   if (has('const') || has('enum')) {
     compositeAllowed = false;
     const listed = [];
@@ -486,6 +592,7 @@ function emitValue(schema, ctx, out, depth) {
       if (!Array.isArray(schema.enum)) decline('enum:not-array');
       for (const v of schema.enum) listed.push(v);
     }
+    listedKinds = new Set(listed.map((v) => (v === null ? 'null' : Array.isArray(v) ? 'array' : typeof v)));
     // An object or an array can only be compared as a whole. The scan steps
     // over that one subtree, parses its own text, and hands it to the check
     // the validator itself runs, so the document around it is still never
@@ -508,7 +615,7 @@ function emitValue(schema, ctx, out, depth) {
       + 'if(!' + compositeDelegate + '(_cv' + k + '))return 0;'
       + 'i=_ce' + k + ';c=s.charCodeAt(i);'];
   };
-  if (allows(types, 'object')) {
+  if (allows(types, 'object') && (listedKinds === null || listedKinds.has('object'))) {
     if (compositeDelegate) branches.push(['c===123', compositeBranch()]);
     else if (!compositeAllowed) branches.push(['c===123', ['return 0;']]);
     else {
@@ -517,7 +624,7 @@ function emitValue(schema, ctx, out, depth) {
       branches.push(['c===123', b]);
     }
   }
-  if (allows(types, 'array')) {
+  if (allows(types, 'array') && (listedKinds === null || listedKinds.has('array'))) {
     if (compositeDelegate) branches.push(['c===91', compositeBranch()]);
     else if (!compositeAllowed) branches.push(['c===91', ['return 0;']]);
     else {
@@ -526,22 +633,22 @@ function emitValue(schema, ctx, out, depth) {
       branches.push(['c===91', b]);
     }
   }
-  if (allows(types, 'string')) {
+  if (allows(types, 'string') && (listedKinds === null || listedKinds.has('string'))) {
     const b = [];
     emitString(schema, ctx, b);
     branches.push(['c===34', b]);
   }
-  if (allows(types, 'number')) {
+  if (allows(types, 'number') && (listedKinds === null || listedKinds.has('number'))) {
     const b = [];
     emitNumber(schema, ctx, b, types);
     branches.push(['c===45||(c>=48&&c<=57)', b]);
   }
-  if (allows(types, 'boolean')) {
+  if (allows(types, 'boolean') && (listedKinds === null || listedKinds.has('boolean'))) {
     const b = [];
     emitLiteral(schema, ctx, b, 'boolean');
     branches.push(['c===116||c===102', b]);
   }
-  if (allows(types, 'null')) {
+  if (allows(types, 'null') && (listedKinds === null || listedKinds.has('null'))) {
     const b = [];
     emitLiteral(schema, ctx, b, 'null');
     branches.push(['c===110', b]);
@@ -558,6 +665,42 @@ function emitValue(schema, ctx, out, depth) {
   out.push(parts.join('\n'));
 }
 
+// How many times each `$ref` string occurs in the schema, for the expand or
+// call decision. Schema positions and other values alike: a string that is not
+// a reference is never looked up.
+function countRefs(root) {
+  const counts = new Map();
+  const seen = new Set();
+  const walk = (n) => {
+    if (n === null || typeof n !== 'object' || seen.has(n)) return;
+    seen.add(n);
+    if (Array.isArray(n)) { for (const x of n) walk(x); return; }
+    if (typeof n.$ref === 'string') counts.set(n.$ref, (counts.get(n.$ref) || 0) + 1);
+    for (const k of Object.keys(n)) walk(n[k]);
+  };
+  walk(root);
+  return counts;
+}
+
+// A name with no character a JSON string would have to escape, so its raw
+// text in a document is the name itself.
+function plainName(name) {
+  for (let k = 0; k < name.length; k++) {
+    const c = name.charCodeAt(k);
+    if (c < 32 || c === 34 || c === 92) return false;
+  }
+  return true;
+}
+
+// A call answers invalid with the literal `return 0;`, as inline code does:
+// an object member rewrites that text into its own failure path, which goes on
+// scanning (a later duplicate key can replace the value), and a different
+// spelling would end the whole scan instead.
+function emitSubCall(name, ctx, out) {
+  const r = '_rq' + (ctx.uid++);
+  out.push('{var ' + r + '=' + name + '(s,i);if(' + r + '===-1)return -1;if(' + r + '===0)return 0;i=' + r + ';c=s.charCodeAt(i);}');
+}
+
 // Any JSON value, validated as JSON and stepped over.
 function emitSkip(out) {
   out.push('{var _j=_r.skipValue(s,i);if(_j===-2)return -1;if(_j<0)return 0;i=_j;c=s.charCodeAt(i);}');
@@ -749,8 +892,27 @@ function emitArray(schema, ctx, out, depth) {
 // the rule reaches nested objects: an inner object's own verdict is a value
 // failure at the level above it.
 function emitMember(sub, ctx, out, depth, objId) {
-  const lines = [];
+  let lines = [];
   emitValue(sub, ctx, lines, depth + 1);
+  // A large member value becomes a function of its own, so no one function
+  // grows with the whole schema: detekt nests hundreds of rule objects inline,
+  // no references involved. The value's code keeps its own labels and
+  // variables, so it moves as it is; the call answers invalid with
+  // `return 0;`, which the rewrite below turns into this member's failure.
+  // An object's members are judged together as well as one by one: thirty
+  // members just under SPLIT_MIN each would stay inline and add up to a
+  // function past the bound, so once the members kept inline in this object
+  // pass SPLIT_OBJECT, the rest move out whatever their size.
+  const size = lines.join('\n').length;
+  const kept = ctx.split ? (ctx.inlineBytes.get(objId) || 0) : 0;
+  if (ctx.split && (size > SPLIT_MIN || kept + size > SPLIT_OBJECT)) {
+    const name = '_s' + (ctx.subSource.length + ctx.subs.size + ctx.uid++);
+    ctx.subSource.push('function ' + name + '(s,i){var len=s.length,c=s.charCodeAt(i);\n' + lines.join('\n') + '\nreturn i;}');
+    lines = [];
+    emitSubCall(name, ctx, lines);
+  } else if (ctx.split) {
+    ctx.inlineBytes.set(objId, kept + size);
+  }
   const body = lines.join('\n');
   if (!body.includes('return 0;')) { out.push(body); return; }
   const label = '_mb' + (ctx.uid++);
@@ -828,10 +990,32 @@ function emitObject(schema, ctx, out, depth) {
       hashById = '_h[' + (ctx.helpers.length - 1) + ']';
     }
   }
-  emitStringSpan(ctx, out, kn, false, hashById !== null);
-  // A key written with an escape decodes to a name the raw span does not show,
-  // so the dispatch below would read it as a different property.
-  out.push('if(_x' + kn + ')return -1;');
+  // A key's end is found with indexOf, which is native, where the character
+  // loop below costs three compares a character: on csslintrc's 35 keys of
+  // twenty-odd characters the loop was most of the scan and made it slower
+  // than parsing. Every declared name is plain text, so a key that compares
+  // equal to one, character by character, is that name as written, and a
+  // key that does not is checked for an escape or a control character before
+  // it is read as additional. Either one bails, and so does a span that ends
+  // on a backslash, since that quote may be escaped: the parser decides what
+  // the key really is.
+  // indexOf costs about the same whatever the key's length, the loop about a
+  // nanosecond a character: on short keys the loop wins (problem-object's
+  // `type`, `title`, `status` measured 10 to 15 percent slower by indexOf),
+  // and from ten characters indexOf wins by 40 percent and more, so the
+  // choice follows the declared names' average length.
+  const indexKey = !useHash && names.length > 0 && names.every(plainName)
+    && names.reduce((n, x) => n + x.length, 0) >= INDEX_KEY_MIN_AVG * names.length;
+  if (indexKey) {
+    // A quote with a backslash before it may be escaped, and then the key
+    // goes on past it: bail before reading what follows as the colon.
+    out.push('var _p' + kn + '=++i,_e' + kn + '=s.indexOf(\'"\',i);if(_e' + kn + '<0)return 0;if(s.charCodeAt(_e' + kn + '-1)===92)return -1;i=_e' + kn + ';c=s.charCodeAt(++i);');
+  } else {
+    emitStringSpan(ctx, out, kn, false, hashById !== null);
+    // A key written with an escape decodes to a name the raw span does not
+    // show, so the dispatch below would read it as a different property.
+    out.push('if(_x' + kn + ')return -1;');
+  }
   out.push(WS);
   out.push('if(c!==58)return 0;');
   out.push('c=s.charCodeAt(++i);');
@@ -958,6 +1142,7 @@ function emitObject(schema, ctx, out, depth) {
     additional.push(lines.join('\n').split('return 0;').join('return -1;'));
   }
 
+  if (indexKey) additional.unshift('if(!_r.plainKey(s,_p' + kn + ',_e' + kn + '))return -1;');
   out.push('switch(_kl' + kn + '){');
   for (const [len, group] of byLen) {
     out.push('case ' + len + ':{');

package/lib/scan-runtime.js

@@ -155,4 +155,16 @@ function span(s, p, e, escaped) {
   return JSON.parse(s.slice(p - 1, e + 1));
 }
 
-module.exports = { hex4, skipValue, skipString, skipNumber, span, MALFORMED, TOO_DEEP, MAX_SKIP_DEPTH };
+// Whether the raw text of a key between `p` and `e` is its name as written:
+// no escape, no control character. A scanner that found the key's end with
+// indexOf calls this for a name it did not recognise; one it recognised was
+// compared character by character against a name that has neither.
+function plainKey(s, p, e) {
+  for (let k = p; k < e; k++) {
+    const c = s.charCodeAt(k);
+    if (c < 32 || c === 92) return false;
+  }
+  return true;
+}
+
+module.exports = { hex4, skipValue, skipString, skipNumber, span, plainKey, MALFORMED, TOO_DEEP, MAX_SKIP_DEPTH };

package/lib/validator-core.js

@@ -215,8 +215,27 @@ function codegenAvailable() {
   return _codegenAvailable;
 }
 
-// Schema compilation cache: same schema string -> reuse compiled functions
+// Schema compilation cache: same schema string -> reuse compiled functions.
+// It and the preprocess cache below are bounded, oldest out first. Unbounded,
+// they held every schema's text, compiled functions and their sources for the
+// life of the process: after compiling each of SchemaStore's schemas once and
+// dropping the validators, 1.2 GB stayed on the heap. A schema compiled again
+// after its entry left is compiled again, the cost of a miss and no more.
+const CACHE_ENTRIES = 128;
+const CACHE_KEY_CHARS = 16 * 1024 * 1024;
 const _compileCache = new Map();
+// Adds an entry and drops the oldest past either bound. The key characters
+// are counted on the map itself.
+function _boundedSet(map, key, entry) {
+  if (!map.has(key)) map._chars = (map._chars || 0) + key.length;
+  map.set(key, entry);
+  while (map.size > CACHE_ENTRIES || (map._chars > CACHE_KEY_CHARS && map.size > 1)) {
+    const oldest = map.keys().next().value;
+    map.delete(oldest);
+    map._chars -= oldest.length;
+  }
+}
+function _compileCacheSet(key, entry) { _boundedSet(_compileCache, key, entry); }
 // Generated preprocess passes, keyed like _compileCache plus the options that
 // shape the pass. Only passes that exist are kept: a schema with nothing to
 // rewrite answers `null` quickly, and keeping that answer held its key, the
@@ -232,9 +251,16 @@ const VALID_RESULT = Object.freeze({ valid: true, errors: Object.freeze([]) });
 // How many calls a validator answers through its verdict function before its
 // validate() and validateJSON() compile the single-function hybrid.
 const HYBRID_TIER_CALLS = 64;
+// A frozen error object shared between calls carries a non-enumerable `_s`, so
+// the reader that hands errors out copies it (lib/rejections.js stripOrdinal)
+// without asking Object.isFrozen, which costs more than the copy.
+function _sharedError(e) {
+  Object.defineProperty(e, '_s', { value: true });
+  return Object.freeze(e);
+}
 const ABORT_EARLY_RESULT = Object.freeze({
   valid: false,
-  errors: Object.freeze([Object.freeze({
+  errors: Object.freeze([_sharedError({
     code: 'ATA9000',
     message: 'validation failed',
     keyword: '__abort_early__',
@@ -292,7 +318,7 @@ function resolveSchemaByPath(rootSchema, schemaPath) {
 //
 // A failing route sees the same handful of schemaPaths over and over, which is
 // what makes the first one worth having.
-const { LazyRejection, RichRejection, LazyJsonRejection, _enrichLazy, presentErrors, needsOrdering, sortErrorsBySchemaOrder } = require('./rejections');
+const { LazyRejection, RichRejection, LazyJsonRejection, _enrichLazy, presentErrors, needsOrdering, sortErrorsBySchemaOrder, stripOrdinal } = require('./rejections');
 
 // Text that does not parse, reported the same way on every path and platform:
 // ATA9001 with the parser's own message. The native addon used to say only
@@ -904,7 +930,7 @@ class Validator {
       // A function bound to this validator's keyword functions or formats is
       // not the schema's alone, so it is not shared through the cache.
       if (!uf && !this._keywords) {
-        _compileCache.set(mapKey, { jsFn, combined: undefined, errFn: undefined, isCodegen: _isCodegen, full: false });
+        _compileCacheSet(mapKey, { jsFn, combined: undefined, errFn: undefined, isCodegen: _isCodegen, full: false });
       }
     }
     this._jsFn = jsFn;
@@ -931,7 +957,7 @@ class Validator {
       if (hit !== undefined) preprocess = hit;
       else {
         preprocess = _codegen.buildPreprocess(preprocessSchema, options) || null;
-        if (ppKey !== null && preprocess !== null) _preprocessCache.set(ppKey, preprocess);
+        if (ppKey !== null && preprocess !== null) _boundedSet(_preprocessCache, ppKey, preprocess);
       }
     }
     if (!preprocess) {
@@ -1026,14 +1052,27 @@ class Validator {
     // locals and on this object rather than on the instance: every call reads
     // `validate` off the instance, and three more own properties made that
     // read slower across the suite's validators.
-    let _rejectBase = null, _rejectPresented = null, _rejectPlain = false;
+    let _rejectBase = null, _rejectPresented = null, _rejectPlain = false, _oneShotRich = null, _richBuilder = null, _oneShotPlain = false, _isCleanShape = null, _onePassOf = null, _isCombined = null;
     if (jsFn) {
       const _cg = {
         jsFn, _isCodegen, preprocess, fusedRemove, options, schemaObj, useSimdjsonForLarge, _buildCombined, _buildErr,
-        combined: () => jsCombinedFn, err: () => jsErrFn, rejectBase: null,
+        combined: () => jsCombinedFn, err: () => jsErrFn, rejectBase: null, richBuilder: null, oneShotPlain: false, isCleanShape: null, isCombined: null, onePassOf: null,
+        // The combined function with errors built enriched where they happen,
+        // for a validator whose errors are read with richErrors on and no
+        // schema source to attach frames from (see makeRich).
+        buildRich: (this._richErrors && !this._schemaPositions && !this._usesKeywords)
+          ? () => compileToJSCombined(schemaObj, VALID_RESULT, sm, this._userFormats, { runtimeShape: true, rich: true }) || null
+          : null,
+        oneShotRich: null,
       };
       _codegen.installPaths.call(this, _cg);
       _rejectBase = _cg.rejectBase;
+      _oneShotRich = _cg.oneShotRich;
+      _richBuilder = _cg.richBuilder;
+      _oneShotPlain = _cg.oneShotPlain;
+      _isCleanShape = _cg.isCleanShape;
+      _onePassOf = _cg.onePassOf;
+      _isCombined = _cg.isCombined;
     } else {
       // No JS codegen: the interpreted engine, with or without the addon. The
       // buffer APIs come from _installBufferApis on first use, as they do on
@@ -1264,10 +1303,67 @@ class Validator {
         }
         return _withExtra(raw, data);
       };
-      this.validate = (data) => {
+      // validate() answers from the verdict and builds the errors when they
+      // are read. What builds them improves once they are being read: from
+      // the third read the combined function is called directly, without the
+      // rejection layers, and with richErrors on it builds the errors
+      // enriched where they fail (see makeRich in lib/enrich-site.js) rather
+      // than plain and enriched afterwards. Built on the second read, not the
+      // first, so a first rejection still compiles one generator. The rejection
+      // holds `_errorsOf`, which dispatches to whichever builder is current.
+      let _errorsNow = _buildErrors;
+      let _onePass = null;
+      let _richLater = (_plain !== null && _oneShotRich !== null && _richBuilder !== null && !_extra) ? 1 : 0;
+      const _errorsOf = (data) => {
+        if (_richLater !== 0 && ++_richLater > 2) {
+          _richLater = 0;
+          const combRich = _oneShotRich();
+          if (combRich) {
+            const clean = !this._richErrors && _isCleanShape !== null && _isCleanShape(combRich);
+            _errorsNow = _richBuilder(combRich, this._schemaObj, (raw, d) => presentErrors(raw, d, null, this, this._schemaObj, this._richErrors ? _enrichLazy : null), _verdictFallback, _oneShotPlain, clean);
+            _errorsOf.final = !_oneShotPlain;
+            // Plain errors from the combined function: from here validate()
+            // is that function in its result shape, one pass that decides,
+            // collects and returns, instead of a verdict now and a second
+            // pass when the errors are read. A caller reading only `.valid`
+            // pays the collecting pass (about twice the verdict on a document
+            // that fails); with richErrors on the errors stay lazy, since
+            // enriching costs far more.
+            // Collapsed branches are presented inside the one-pass function
+            // (see onePassOf), so any plain combined function qualifies.
+            // Plain errors only. With richErrors on, enriching is most of what
+            // a read costs and the lazy path answers an accepted document from
+            // the verdict, so one pass measured no faster on rejections and
+            // slower on acceptances.
+            const onePass = !this._richErrors && _onePassOf !== null && _isCombined !== null && _isCombined(combRich) ? _onePassOf(EMPTY_ERRORS, _plainValidate) : null;
+            if (onePass) { _onePass = onePass; self.validate = onePass; }
+          }
+        }
+        return _errorsNow(data);
+      };
+      _errorsOf.final = false;
+      const _plainValidate = (data) => {
         if (_fast(data)) return { valid: true, data, errors: EMPTY_ERRORS };
-        return new LazyRejection(_buildErrors, data, _buildRawErrors);
+        return new LazyRejection(_errorsOf, data, _buildRawErrors);
       };
+      // Past its first calls, validate() is the generated checks returning
+      // these same results directly (jsFn._resultFactory): no wrapper between
+      // the caller and the checks, and allocation sites of its own. Compiled
+      // only once the validator is in use, as the hybrid is.
+      const self = this;
+      const _factory = (_vx === null && _fast === this._fastVerdict && typeof _fast._resultFactory === 'function') ? _fast._resultFactory : null;
+      if (_factory !== null) {
+        let calls = 0;
+        this.validate = (data) => {
+          if (++calls === HYBRID_TIER_CALLS && _onePass === null) {
+            const gen = _factory(LazyRejection, _errorsOf, _buildRawErrors, EMPTY_ERRORS);
+            if (gen) self.validate = gen;
+          }
+          return _plainValidate(data);
+        };
+      } else {
+        this.validate = _plainValidate;
+      }
     }
     if (_vx && !_vxApplied && this.validate) {
       const inner = this.validate;
@@ -1751,7 +1847,7 @@ Object.defineProperty(Validator.prototype, "~standard", {
 // reported as a generic failure rather than hidden.
 const _VERDICT_DISAGREES = Object.freeze({
   valid: false,
-  errors: Object.freeze([Object.freeze({ keyword: 'validation', instancePath: '', schemaPath: '#', params: Object.freeze({}), message: 'schema validation failed' })]),
+  errors: Object.freeze([_sharedError({ keyword: 'validation', instancePath: '', schemaPath: '#', params: Object.freeze({}), message: 'schema validation failed' })]),
 });
 // The error builders of the common rejection path (see _ensureCompiled): run
 // the error function behind `reject` for a document the verdict rejected, and
@@ -1764,9 +1860,12 @@ function _plainBuilders(reject, enrich, root, self, fallback) {
   };
   return {
     errors: (data) => presentErrors(rawOf(data), data, null, self, root, enrich),
+    // The raw list in the plain shape: a collapsed branch error carried its
+    // ordering key out to `_ataRaw()` callers, and a shared literal was
+    // handed out as it is.
     raw: (data) => {
       const raw = rawOf(data);
-      return needsOrdering(raw) ? sortErrorsBySchemaOrder(root, raw) : raw;
+      return (needsOrdering(raw) ? sortErrorsBySchemaOrder(root, raw) : raw).map(stripOrdinal);
     },
   };
 }
@@ -1859,7 +1958,7 @@ function _jsonEntryWrappers({ check, errors }) {
     },
   };
 }
-const _EXT_FALLBACK = Object.freeze({ keyword: 'validation', instancePath: '', schemaPath: '#', params: {}, message: 'schema validation failed' });
+const _EXT_FALLBACK = _sharedError({ keyword: 'validation', instancePath: '', schemaPath: '#', params: {}, message: 'schema validation failed' });
 
 // A verdict function that also runs `tail` on what it accepts. The generated
 // function can take the check in place of its final `return true`, one call
@@ -2089,7 +2188,15 @@ _defineLazyMethod('validate', (self) => (data) => {
   self._ensureCompiled();
   return self.validate(data);
 });
-_defineLazyMethod('isValidObject', (self) => (data) => {
+_defineLazyMethod('isValidObject', (self) => {
+  // A caller can hold this stub itself: `const check = v.isValidObject`, or a
+  // bound copy, taken before the first call. Once the first call has bound the
+  // real method, the stub hands straight to it; it used to classify the schema
+  // again on every call, about 200 ns, ten times the check.
+  let bound = false;
+  return (data) => {
+  if (bound) return self.isValidObject(data);
+  bound = true;
   // A validator that rewrites its input goes through the full compile, which
   // binds a verdict method that runs the rewrite first. So does one whose
   // schema uses a custom keyword: neither the tier-0 plan nor the code
@@ -2124,6 +2231,7 @@ _defineLazyMethod('isValidObject', (self) => (data) => {
     if (!self._jsFn) self._ensureCompiled();
   }
   return self.isValidObject(data);
+  };
 });
 _defineLazyMethod('validateJSON', (self) => (jsonStr) => {
   self._ensureCompiled();
@@ -2170,4 +2278,4 @@ module.exports = {
 // surface of `require('ata-validator')` is what it was.
 Object.defineProperty(module.exports, '_registerCodegen', { value: _registerCodegen, enumerable: false });
 // What the compiled paths in index.js need from this module.
-Object.defineProperty(module.exports, '_internals', { value: { _jsonSyntaxRejection, ABORT_EARLY_RESULT, HYBRID_TIER_CALLS, SIMDJSON_THRESHOLD, VALID_RESULT, _bindEntry, _bindVerdict, _compileCache, _mustReject, _rememberInstance, _verboseWrap, compileCacheKey, getNative, isV1Dialect, resolveSchemaByPath }, enumerable: false });
+Object.defineProperty(module.exports, '_internals', { value: { _jsonSyntaxRejection, ABORT_EARLY_RESULT, HYBRID_TIER_CALLS, SIMDJSON_THRESHOLD, VALID_RESULT, _bindEntry, _bindVerdict, _compileCache, _compileCacheSet, _mustReject, _rememberInstance, _verboseWrap, compileCacheKey, getNative, isV1Dialect, resolveSchemaByPath }, enumerable: false });