ata-validator 1.56.0 → 1.58.0

package/lib/interpreter-core.js

@@ -13,6 +13,34 @@
 let _safeRe = null;
 const compileSafe = (src) => (_safeRe || (_safeRe = require('./safe-regex'))).compileSafe(src);
 
+// A pattern with no group or alternation, few bounded choices in all, and at
+// most one unbounded repeat, on one character or class and only when the
+// pattern starts with `^`, runs in linear time on a backtracking RegExp, so it
+// takes the platform's: built in about a microsecond where the linear engine's
+// automaton took 40 to 100, and faster to test. Every pattern accepted here
+// also gets a RegExp from the code generator (lib/regex-linear.js), so both
+// engines answer with the same matcher; tests/test_regex_plain_linear.js holds
+// that and the answers.
+const PLAIN_ATOM = /(?:\\[dDwWsS\\/.^$|?*+()[\]{}-]|\[\^?(?:[^\\\][^\ud800-\udfff]|\\[dws\\/.^$[\]-])(?:[^\\\][\ud800-\udfff]|\\[dws\\/.^$[\]-])*\]|[^\\[\](){}|*+?^$\ud800-\udfff])(\?|[*+]|\{(\d{1,3})(?:,(\d{1,3}))?\})?/y;
+function plainLinear(src) {
+  const n = src.length, anchored = src[0] === '^';
+  if (n > 256) return false;
+  let i = anchored ? 1 : 0, choices = 1, loops = 0;
+  while (i < n) {
+    if (src[i] === '$' && i === n - 1) return true;
+    PLAIN_ATOM.lastIndex = i;
+    const m = PLAIN_ATOM.exec(src);
+    if (m === null) return false;
+    i = PLAIN_ATOM.lastIndex;
+    const q = m[1];
+    if (q === '?') choices *= 2;
+    else if (q === '*' || q === '+') { if (!anchored || ++loops > 1) return false; }
+    else if (q !== undefined) { const lo = +m[2], hi = m[3] === undefined ? lo : +m[3]; if (hi < lo) return false; choices *= hi - lo + 1; }
+    if (choices > 64) return false;
+  }
+  return true;
+}
+
 const SCHEMA_KEYWORDS = {
   single: ['additionalProperties', 'contains', 'propertyNames', 'if', 'then', 'else', 'not', 'items', 'unevaluatedItems', 'unevaluatedProperties'],
   maps: ['$defs', 'definitions', 'properties', 'patternProperties', 'dependentSchemas'],
@@ -875,7 +903,10 @@ class Interpreter {
   _fastRoot() {
     if (this._fast === undefined) {
       const compile = planCompiler();
-      if (compile === null) this._fast = null;
+      // Still on its way (the browser build loads it after the page's first
+      // checks, lib/interpreter.browser.js): the plain walk answers, and the
+      // next call asks again.
+      if (compile === null) { if (planPending) return null; this._fast = null; }
       else {
         try { this._fast = compile(this); } catch (e) {
           // The plain walk answers instead, which tests cannot tell apart;
@@ -912,6 +943,8 @@ class Interpreter {
         // Unicode property escapes need a real RegExp in unicode mode; the
         // linear engine does not understand them.
         try { re = new RegExp(src, 'u'); } catch { re = new RegExp(src); }
+      } else if (plainLinear(src)) {
+        re = new RegExp(src);
       } else {
         try {
           re = compileSafe(src);
@@ -1500,9 +1533,12 @@ function err(code, keyword, instancePath, schemaPath, params, message) {
 const TIER = 1000;
 let loadPlanCompiler = null;
 let compileInterpreter = null;
-function setPlanCompiler(load) {
+// True while a plan compiler is being loaded and none is set yet.
+let planPending = false;
+function setPlanCompiler(load, pending) {
   loadPlanCompiler = load;
   compileInterpreter = null;
+  planPending = load === null && pending === true;
 }
 function planCompiler() {
   if (compileInterpreter === null && loadPlanCompiler !== null) {
@@ -1534,6 +1570,7 @@ function createInterpreter(schema, options) {
 }
 
 module.exports = { createInterpreter };
+Object.defineProperty(module.exports, '_plainLinear', { value: plainLinear, enumerable: false });
 Object.defineProperty(module.exports, '_setPlanCompiler', { value: setPlanCompiler, enumerable: false });
 Object.defineProperty(module.exports, '_setCompat', { value: setCompat, enumerable: false });
 // The resolver, for the code generator: it resolves references at compile

package/lib/interpreter.browser.js

@@ -0,0 +1,34 @@
+'use strict';
+
+// The interpreted engine for the browser build (the package.json browser
+// field maps lib/interpreter.js here). The plan compiler, the closure tree
+// that makes the engine fast on a schema checked many times, is not in the
+// page's first load: it comes through the dynamic import below, which
+// bundlers split into a chunk of its own, once the page is idle after its
+// first validator. Until then the plain walk answers, as it does for every
+// schema's first thousand calls (TIER in lib/interpreter-core.js), with the
+// same answers. Without a bundler that splits, the chunk is inlined and
+// nothing changes.
+const core = require('./interpreter-core');
+
+core._setPlanCompiler(null, true);
+let asked = false;
+const idle = (f) => {
+  if (typeof requestIdleCallback === 'function') return requestIdleCallback(f, { timeout: 2000 });
+  const t = setTimeout(f, 200);
+  if (t && typeof t.unref === 'function') t.unref();
+};
+function load() {
+  import('./plan-compiler.js').then((m) => {
+    const mod = m && m.install ? m : m.default;
+    core._setPlanCompiler(() => mod.install);
+  }, () => core._setPlanCompiler(null));
+}
+
+// The first engine built asks for it, when the page is next idle.
+const create = core.createInterpreter;
+core.createInterpreter = (schema, opts) => {
+  if (!asked) { asked = true; idle(load); }
+  return create(schema, opts);
+};
+module.exports = core;

package/lib/schema-strip.js

@@ -63,24 +63,24 @@ function refsIntoDropped(node, seen) {
 
 // keepTitle: the node is a branch of anyOf or oneOf, whose title names the
 // branch in the collapsed error (params.closestName).
-function stripSchema(node, keepTitle) {
+function stripSchema(node, keepTitle, keepDefault) {
   if (node === null || typeof node !== 'object' || Array.isArray(node)) return node;
   const out = {};
   for (const k of Object.keys(node)) {
-    if (dropped(k) && !(keepTitle === true && k === 'title')) continue;
+    if (dropped(k) && !(keepTitle === true && k === 'title') && !(keepDefault === true && k === 'default')) continue;
     const v = node[k];
     if (SINGLE.has(k)) {
-      setOwn(out, k, Array.isArray(v) ? v.map((x) => stripSchema(x, false)) : stripSchema(v, false));
+      setOwn(out, k, Array.isArray(v) ? v.map((x) => stripSchema(x, false, keepDefault)) : stripSchema(v, false, keepDefault));
     } else if (MAPS.has(k) && v !== null && typeof v === 'object' && !Array.isArray(v)) {
       const m = {};
-      for (const name of Object.keys(v)) setOwn(m, name, stripSchema(v[name], false));
+      for (const name of Object.keys(v)) setOwn(m, name, stripSchema(v[name], false, keepDefault));
       setOwn(out, k, m);
     } else if (LISTS.has(k) && Array.isArray(v)) {
       const branches = k === 'anyOf' || k === 'oneOf';
-      setOwn(out, k, v.map((x) => stripSchema(x, branches)));
+      setOwn(out, k, v.map((x) => stripSchema(x, branches, keepDefault)));
     } else if (k === 'dependencies' && v !== null && typeof v === 'object' && !Array.isArray(v)) {
       const m = {};
-      for (const name of Object.keys(v)) setOwn(m, name, Array.isArray(v[name]) ? v[name] : stripSchema(v[name], false));
+      for (const name of Object.keys(v)) setOwn(m, name, Array.isArray(v[name]) ? v[name] : stripSchema(v[name], false, keepDefault));
       setOwn(out, k, m);
     } else if (k === 'propertyDependencies' && v !== null && typeof v === 'object' && !Array.isArray(v)) {
       const m = {};
@@ -88,7 +88,7 @@ function stripSchema(node, keepTitle) {
         const inner = v[name];
         if (inner === null || typeof inner !== 'object' || Array.isArray(inner)) { setOwn(m, name, inner); continue; }
         const mi = {};
-        for (const val of Object.keys(inner)) setOwn(mi, val, stripSchema(inner[val], false));
+        for (const val of Object.keys(inner)) setOwn(mi, val, stripSchema(inner[val], false, keepDefault));
         setOwn(m, name, mi);
       }
       setOwn(out, k, m);
@@ -112,4 +112,11 @@ function stripAnnotations(schema) {
   return out;
 }
 
-module.exports = { stripAnnotations };
+// The same copy with every `default` kept, for a module that fills defaults
+// from its embedded schema (lib/aot-impl.js).
+function stripAnnotationsKeepingDefaults(schema) {
+  if (schema === null || typeof schema !== 'object') return schema;
+  return refsIntoDropped(schema, new Set()) ? schema : stripSchema(schema, false, true);
+}
+
+module.exports = { stripAnnotations, stripAnnotationsKeepingDefaults };

package/lib/tiering.js

@@ -111,6 +111,7 @@ function createTiering (load) {
   // A call counter for one validator: the TIER_CALLS-th call asks for the
   // generator and has the validator rebuilt once it is in.
   function counter (v) {
+    if (warm === 1) warm = 2;
     let calls = 0, start = 0;
     return () => {
       if (++calls < TIER_CALLS) { if (calls === 1) start = now(); return; }
@@ -123,8 +124,94 @@ function createTiering (load) {
     };
   }
 
+  // A page's first check pays for V8 compiling the engine and the error
+  // builders (3.1 ms of an eight-field form's first submit, 0.4 ms once any
+  // other schema had been checked) and for building its own schema's engine.
+  // Both move to when the page is idle, or 200 ms later where there is no
+  // requestIdleCallback (Safari, workers): one check of a small schema, once
+  // per page and dropped when a validator compiles first, then the engine for
+  // each validator built since, at most eight, kept aside. A validator adopts
+  // it at its first check only if every input is still the same, its schema
+  // text included, so addSchema() or a change to the schema in between is
+  // honored as before.
+  // warm: 0 none, 1 scheduled, 2 done or dropped.
+  let warm = 0, scheduled = false, warming = false, adopted = 0;
+  const pending = [];
+  const shadows = new WeakMap();
+  const idle = (f) => {
+    if (typeof requestIdleCallback === 'function') return requestIdleCallback(f, { timeout: 2000 });
+    const t = setTimeout(f, 200);
+    if (t && typeof t.unref === 'function') t.unref();
+  };
+  function built (v) {
+    if (warming) return;
+    if (warm === 0) warm = 1;
+    if (pending.length < 8 && typeof WeakRef === 'function') pending.push(new WeakRef(v));
+    if (!scheduled) { scheduled = true; idle(run); }
+  }
+  function run (deadline) {
+    scheduled = false;
+    if (warm === 1) {
+      warm = 2;
+      warming = true;
+      try { warmUp(); } catch { /* a warm-up never reaches the page */ }
+      warming = false;
+    }
+    while (pending.length > 0) {
+      if (deadline !== undefined && deadline.timeRemaining() < 1) { scheduled = true; idle(run); return; }
+      const v = pending.shift().deref();
+      if (v === undefined || core._codegenRegistered()) continue;
+      let s = null;
+      try { s = prebuild(v); } catch { /* built as usual at the first check */ }
+      if (s !== null) shadows.set(v, s);
+    }
+  }
+
+  // One check of a small schema, rejected and accepted, compiles the engine's
+  // code for the page: the plan builder, the walk, the regex and format
+  // checks, the error builders.
+  function warmUp () {
+    const v = new core.Validator({
+      type: 'object',
+      properties: {
+        a: { type: 'string', minLength: 2, maxLength: 9, pattern: '^[a-z]+$', format: 'email' },
+        b: { type: 'integer', minimum: 1, maximum: 9 },
+        c: { type: 'array', items: { type: 'string' }, maxItems: 3 },
+        d: { const: true },
+        e: { type: 'object', properties: { f: { type: 'string' } }, required: ['f'] },
+      },
+      required: ['a', 'b'],
+    });
+    void v.validate({ a: '1', b: 0, c: [1], d: false, e: {} }).errors.length;
+    v.validate({ a: 'ab@c.de', b: 2, c: ['x'], d: true, e: { f: 'x' } });
+  }
+
+  // The engine a validator will build at its first check, built now from the
+  // same inputs and kept aside; null where something besides the schema object
+  // decides the build: custom keywords (their compile functions are the
+  // caller's code), registered schemas, a schema that needs rewriting.
+  function prebuild (v) {
+    if (v._initialized || v._keywords !== null || v._schemaMap.size !== 0) return null;
+    const raw = v._rawSchema;
+    const { _interpArgs, _normalizeCallerSchemaUncached } = core._internals;
+    if (raw === null || typeof raw !== 'object' || _normalizeCallerSchemaUncached(raw) !== raw) return null;
+    const args = _interpArgs(v, raw);
+    return { schema: raw, text: JSON.stringify(raw), args, interp: require('./interpreter').createInterpreter(raw, args) };
+  }
+
+  function adopt (v, schemaObj, args) {
+    const s = shadows.get(v);
+    if (s === undefined) return null;
+    shadows.delete(v);
+    if (s.schema !== schemaObj || s.text !== v._schemaStr) return null;
+    for (const k of Object.keys(args)) if (args[k] !== s.args[k]) return null;
+    adopted++;
+    return s.interp;
+  }
+
   // Count the interpreted engine's calls for this validator.
   function watch (v, interp) {
+    if (warm === 1) warm = 2;
     const v0 = interp.validate, i0 = interp.isValid;
     const tick = counter(v);
     interp.validate = (d) => { tick(); return v0.call(interp, d); };
@@ -143,7 +230,7 @@ function createTiering (load) {
     while (draining !== null) await draining;
   }
 
-  return { watch, counter, aotStub, loadCodegen, tierUp, settled, TIER_CALLS, WINDOW_MS, get loading () { return loading; } };
+  return { watch, counter, built, aotStub, loadCodegen, settled, TIER_CALLS, WINDOW_MS, get loading () { return loading; }, get warm () { return warm; }, get adopted () { return adopted; }, adopt };
 }
 
 module.exports = { createTiering, TIER_CALLS };

package/lib/ts-gen.js

@@ -197,6 +197,8 @@ function renderJsDoc(schema, indent) {
 function toTypeScript(schema, opts) {
   const options = opts || {};
   const rootName = toTypeName(options.name || 'Data');
+  // Whether the module beside these types exports applyDefaults (lib/aot-impl.js).
+  const fill = options.applyDefaults === true;
   const defs = schema && (schema.$defs || schema.definitions);
 
   const defLines = [];
@@ -240,9 +242,11 @@ export type Result = ValidResult | InvalidResult;
 
 export declare function isValid(data: unknown): data is ${rootName};
 export declare function validate(data: unknown): Result;
-export declare const schemaHash: string;
+${fill ? `/** Fills in the schema's \`default\` values where a key is missing, as the runtime Validator does before checking. Call it before validate() for the runtime's answer. */
+export declare function applyDefaults(data: unknown): void;
+` : ''}export declare const schemaHash: string;
 export declare const ataVersion: string;
-declare const _default: { validate: typeof validate; isValid: typeof isValid; schemaHash: typeof schemaHash; ataVersion: typeof ataVersion };
+declare const _default: { validate: typeof validate; isValid: typeof isValid; ${fill ? 'applyDefaults: typeof applyDefaults; ' : ''}schemaHash: typeof schemaHash; ataVersion: typeof ataVersion };
 export default _default;
 `;
 }

package/lib/validator-core.js

@@ -333,7 +333,13 @@ 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, stripOrdinal } = require('./rejections');
+// Loaded at the first compile, where every use below is, rather than with the
+// core: with it came the schema order and diagnostic modules, run at import
+// by every page that loads the package, validating or not.
+let LazyRejection, RichRejection, LazyJsonRejection, _enrichLazy, presentErrors, needsOrdering, sortErrorsBySchemaOrder, stripOrdinal;
+function _loadRejections() {
+  ({ 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
@@ -716,6 +722,21 @@ function resolveSchemaForPreprocess(schema, schemaMap) {
 // touched), `format` stripped under `assertFormat: false`, and the custom
 // keyword scan. The accessors then step aside for own data properties, so
 // every later read is a plain field.
+// What the interpreted engine is built from, besides the schema.
+function _interpArgs(self, schemaObj) {
+  const options = self._options;
+  return {
+    schemaMap: self._schemaMap.size > 0 ? self._schemaMap : null,
+    formats: self._userFormats,
+    v1: isV1Dialect(schemaObj),
+    keywords: self._keywords,
+    // compat's coercion where each type is checked (see the interpreter).
+    coerce: self._interpretOnly ? options._coerceInWalk : undefined,
+    discriminator: self._interpretOnly && options._discriminator === true,
+    numberFormats: self._interpretOnly ? options._numberFormats : undefined,
+  };
+}
+
 function _materializeSchema(self) {
   const raw = self._rawSchema;
   const options = self._options;
@@ -895,6 +916,8 @@ class Validator {
     this._verdictTail = null;
     this._validateTail = null;
     this._entryExt = null;
+    // The browser build warms the engine once, when the page is idle (lib/tiering.js).
+    if (_tiering !== null) _tiering.built(this);
 
     // Public methods start as memoized accessors on the prototype; nothing is
     // allocated per instance until one is first read. See _defineLazyMethod
@@ -947,6 +970,7 @@ class Validator {
 
   _ensureCompiled() {
     if (this._initialized) return;
+    if (LazyRejection === undefined) _loadRejections();
     this._ensureVocabularies();
     this._initialized = true;
     // Errors behind a reference into a registered document are ordered as
@@ -1074,22 +1098,22 @@ class Validator {
     // routes, and generating and compiling the pass again for each was most of
     // what a repeated schema cost to set up.
     let preprocess = null;
+    // A root schema whose text has no `default` has none to fill, and neither
+    // pass looks for one. One reached through a reference into another
+    // document is walked, since its defaults are not in this text.
+    const mayHaveDefaults = preprocessSchema !== schemaObj || this._schemaStr.includes('"default"');
     if (!this._interpretOnly && _codegen !== null) {
       const cacheable = !this._userFormats && !this._usesKeywords;
       const ppKey = cacheable ? mapKey + '\u0000' + String(options.coerceTypes) + '|' + (options.useDefaults !== false) + '|' + String(options.removeAdditional) : null;
       const hit = ppKey !== null ? _preprocessCache.get(ppKey) : undefined;
       if (hit !== undefined) preprocess = hit;
       else {
-        preprocess = _codegen.buildPreprocess(preprocessSchema, options) || null;
+        preprocess = _codegen.buildPreprocess(preprocessSchema, mayHaveDefaults || options.useDefaults === false ? options : { ...options, useDefaults: false }) || null;
         if (ppKey !== null && preprocess !== null) _boundedSet(_preprocessCache, ppKey, preprocess);
       }
     }
     if (!preprocess) {
-      // A root schema whose text has no `default` has none to fill, and the
-      // defaults module then stays unloaded. One reached through a reference
-      // into another document is walked, since its defaults are not in this
-      // text.
-      const mayHaveDefaults = preprocessSchema !== schemaObj || this._schemaStr.includes('"default"');
+      // Without a `default` in the text the defaults module stays unloaded.
       const applyDefaults = options.useDefaults === false || !mayHaveDefaults ? null : buildDefaultsApplier(preprocessSchema);
       const applyCoerce = options.coerceTypes ? buildCoercer(preprocessSchema) : null;
       const applyRemove = options.removeAdditional
@@ -1176,11 +1200,11 @@ 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, _oneShotRich = null, _richBuilder = null, _oneShotPlain = false, _isCleanShape = null, _onePassOf = null, _isCombined = null;
+    let _rejectBase = null, _rejectPresented = null, _rejectPlain = false, _oneShotRich = null, _richBuilder = null, _oneShotPlain = false, _isCleanShape = null, _onePassOf = null, _isCombined = null, _preVerdict = null, _rawVerdict = null;
     if (jsFn) {
       const _cg = {
         jsFn, _isCodegen, preprocess, fusedRemove, options, schemaObj, useSimdjsonForLarge, _buildCombined, _buildErr,
-        combined: () => jsCombinedFn, err: () => jsErrFn, rejectBase: null, richBuilder: null, oneShotPlain: false, isCleanShape: null, isCombined: null, onePassOf: null,
+        combined: () => jsCombinedFn, err: () => jsErrFn, rejectBase: null, richBuilder: null, oneShotPlain: false, isCleanShape: null, isCombined: null, onePassOf: null, preVerdict: null, rawVerdict: 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).
@@ -1196,22 +1220,17 @@ class Validator {
       _oneShotPlain = _cg.oneShotPlain;
       _isCleanShape = _cg.isCleanShape;
       _onePassOf = _cg.onePassOf;
+      _preVerdict = _cg.preVerdict;
+      _rawVerdict = _cg.rawVerdict;
       _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
       // every other path.
-      const { createInterpreter } = require('./interpreter');
-      const interp = createInterpreter(schemaObj, {
-        schemaMap: this._schemaMap.size > 0 ? this._schemaMap : null,
-        formats: this._userFormats,
-        v1: isV1Dialect(schemaObj),
-        keywords: this._keywords,
-        // compat's coercion where each type is checked (see the interpreter).
-        coerce: this._interpretOnly ? options._coerceInWalk : undefined,
-        discriminator: this._interpretOnly && options._discriminator === true,
-        numberFormats: this._interpretOnly ? options._numberFormats : undefined,
-      });
+      const iargs = _interpArgs(this, schemaObj);
+      // The browser build may have built it while the page was idle, from
+      // the same inputs (lib/tiering.js).
+      const interp = (_tiering !== null && _tiering.adopt(this, schemaObj, iargs)) || require('./interpreter').createInterpreter(schemaObj, iargs);
       this._engine = 'interpreter';
       if (_codegen === null && _tiering !== null && !_forceNapi && !this._v1Dynamic) _tiering.watch(this, interp);
       // A keyword that reads its data's context may also change the data (a
@@ -1220,6 +1239,7 @@ class Validator {
       // run the keyword twice, the second time on what the first left.
       const once = interp.dataContext === true;
       if (!preprocess && !once) this._fastVerdict = (d) => interp.isValid(d);
+      if (preprocess && !once) _preVerdict = (d) => { preprocess(d); return interp.isValid(d); };
       // abortEarly is a documented contract, not a property of whichever engine
       // answered: it promises the frozen ATA9000 stub instead of a detailed
       // error, so code that branches on it has to behave the same with and
@@ -1234,7 +1254,7 @@ class Validator {
             : (data) => interp.validate(data));
       this.validate = this._verbose ? _verboseWrap(run, schemaObj) : run;
       // Reading errors runs the interpreter once, directly; see _rejectBase.
-      if (!preprocess && !options.abortEarly && !this._verbose && !once) _rejectBase = (data) => interp.validate(data);
+      if (!options.abortEarly && !this._verbose && !once) _rejectBase = (data) => interp.validate(data);
       _bindVerdict(this, this._fastVerdict
         ? this._fastVerdict
         : (data) => run(data).valid);
@@ -1425,10 +1445,14 @@ class Validator {
     // engine and materializes `errors` through a getter on first access.
     // A caller that only reads `.valid`, which is every gateway check and
     // every benchmark, skips error construction entirely; a caller that
-    // reads `.errors` pays once and the result is cached. Skipped when the
-    // schema coerces or defaults (preprocess mutates before the verdict),
-    // under abortEarly (already a frozen stub), and for $dynamicRef (the
-    // boolean engine is not the authority there).
+    // reads `.errors` pays once and the result is cached. A schema that
+    // coerces or defaults takes it too, with a verdict that runs the
+    // preprocess pass first; the errors are then built from the document as
+    // the pass left it. It built them on every rejection, read or not, which
+    // on a large schema was 25 ms of a first validate() spent ordering
+    // errors nobody asked for. Skipped under abortEarly (already a frozen
+    // stub), for $dynamicRef (the boolean engine is not the authority
+    // there), and with removeAdditional's fused pass.
     // A check registered through _extendValidate joins here when it can: the
     // verdict comes from the generated function with the check compiled in,
     // and the check's own errors are appended when somebody reads them. A
@@ -1436,7 +1460,8 @@ class Validator {
     // is not installed, the end of this method wraps validate() instead.
     const _vx = this._validateTail !== null ? this._validateTail() : null;
     let _vxApplied = false;
-    if (this._fastVerdict && !preprocess && !options.abortEarly && this.validate) {
+    const _verdict0 = preprocess ? _preVerdict : this._fastVerdict;
+    if (_verdict0 && !options.abortEarly && this.validate) {
       // The errors of a document the verdict rejected come from the rejection
       // path directly, not from validate() deciding a second time. Not with a
       // check from _extendValidate: that check can reject what the schema
@@ -1444,7 +1469,7 @@ class Validator {
       // Not with removeAdditional's fused pass either, which edits the
       // document before the errors are read.
       const _full = (_vx === null && !fusedRemove && _rejectPresented) ? _rejectPresented : this.validate;
-      const _fast = _vx ? _fuseTail(this._fastVerdict, _vx.check) : this._fastVerdict;
+      const _fast = _vx ? _fuseTail(_verdict0, _vx.check) : _verdict0;
       const _extra = _vx ? _vx.errors : null;
       _vxApplied = true;
       const EMPTY_ERRORS = Object.freeze([]);
@@ -1536,13 +1561,16 @@ class Validator {
       // 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;
+      // With a preprocess pass the factory's function runs after it, as the
+      // verdict does.
+      const _gv = preprocess ? _rawVerdict : _fast === this._fastVerdict ? _fast : null;
+      const _factory = (_vx === null && _gv !== null && typeof _gv._resultFactory === 'function') ? _gv._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;
+            if (gen) self.validate = preprocess ? (data) => { preprocess(data); return gen(data); } : gen;
           }
           return _plainValidate(data);
         };
@@ -2506,4 +2534,4 @@ Object.defineProperty(module.exports, '_codegenRegistered', { value: () => _code
 Object.defineProperty(module.exports, '_tiering', { get: () => _tiering, enumerable: false });
 Object.defineProperty(module.exports, '_registerAot', { value: _registerAot, 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, _compileCacheSet, _mustReject, _rememberInstance, _verboseWrap, compileCacheKey, getNative, isV1Dialect, resolveSchemaByPath }, enumerable: false });
+Object.defineProperty(module.exports, '_internals', { value: { _interpArgs, _normalizeCallerSchemaUncached, resolveSchemaForPreprocess, _jsonSyntaxRejection, ABORT_EARLY_RESULT, HYBRID_TIER_CALLS, SIMDJSON_THRESHOLD, VALID_RESULT, _bindEntry, _bindVerdict, _compileCache, _compileCacheSet, _mustReject, _rememberInstance, _verboseWrap, compileCacheKey, getNative, isV1Dialect, resolveSchemaByPath }, enumerable: false });

package/lib/version.js

@@ -7,4 +7,4 @@
 //
 // Kept in lockstep with package.json by `tests/test_version_sync.js`.
 
-module.exports = '1.56.0';
+module.exports = '1.58.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "1.56.0",
+  "version": "1.58.0",
   "description": "JSON Schema validator that compiles to plain JavaScript, still runs where code generation is blocked, and can be compiled away at build time. Passes the full official test suite.",
   "type": "commonjs",
   "main": "index.js",
@@ -87,7 +87,8 @@
   "browser": {
     "./lib/native-load.js": "./lib/native-load.browser.js",
     "./lib/aot.js": "./lib/aot.browser.js",
-    "./lib/buffer-gate.js": "./lib/buffer-gate.browser.js"
+    "./lib/buffer-gate.js": "./lib/buffer-gate.browser.js",
+    "./lib/interpreter.js": "./lib/interpreter.browser.js"
   },
   "scripts": {
     "prepublishOnly": "node tests/test_pack_purity.js && ATA_ALLOW_DOC_PLACEHOLDERS=1 node scripts/check-doc-coverage.js && node tests/test_error_codes_lock.js && node tests/test_safe_regex_embed.js && node tests/test_version_sync.js",
@@ -185,13 +186,13 @@
     "codegen.d.ts"
   ],
   "optionalDependencies": {
-    "@ata-validator/native-darwin-arm64": "1.56.0",
-    "@ata-validator/native-darwin-x64": "1.56.0",
-    "@ata-validator/native-linux-arm64-gnu": "1.56.0",
-    "@ata-validator/native-linux-arm64-musl": "1.56.0",
-    "@ata-validator/native-linux-x64-gnu": "1.56.0",
-    "@ata-validator/native-linux-x64-musl": "1.56.0",
-    "@ata-validator/native-win32-x64": "1.56.0"
+    "@ata-validator/native-darwin-arm64": "1.58.0",
+    "@ata-validator/native-darwin-x64": "1.58.0",
+    "@ata-validator/native-linux-arm64-gnu": "1.58.0",
+    "@ata-validator/native-linux-arm64-musl": "1.58.0",
+    "@ata-validator/native-linux-x64-gnu": "1.58.0",
+    "@ata-validator/native-linux-x64-musl": "1.58.0",
+    "@ata-validator/native-win32-x64": "1.58.0"
   },
   "peerDependencies": {
     "yaml": "^2.0.0"