ata-validator 1.57.0 → 1.58.1

package/README.md

@@ -53,8 +53,9 @@ interpreted engine, which gives the same answers, and a validator called a thous
 a second loads the generator in the background, through a dynamic import that Vite, webpack and
 Rollup put in a chunk of their own, and is rebuilt on generated code when the page is idle. A
 form, checked as the user types, never loads it. On a react-jsonschema-form page this takes the validator's
-share of the first load from 134.7 KB to about 57 KB gzipped; the generator chunk is about 78 KB
-more when it does load. Where `unsafe-eval` is blocked, on a page with a strict
+share of the first load from 134.7 KB to about 55 KB gzipped; the generator chunk is about 78 KB
+more when it does load, and the plan compiler, which speeds up a schema the interpreted engine checks
+often, comes in a 6 KB chunk once the page is idle. Where `unsafe-eval` is blocked, on a page with a strict
 Content-Security-Policy or in a Manifest V3 extension, it is never fetched and every schema
 stays on the interpreted engine. To have generated code from the first call, import
 `ata-validator/codegen` once; it also makes `parse()` available in the browser, which otherwise

package/lib/aot-impl.js

@@ -355,9 +355,20 @@ const ABORT_SHAPE = Object.freeze({ valid: false, errors: Object.freeze([Object.
 // default, or where the pass declines it (a schema object containing itself).
 function defaultsDecl(validator) {
   const { resolveSchemaForPreprocess } = require('./validator-core')._internals;
+  const schema = resolveSchemaForPreprocess(validator._schemaObj, validator._schemaMap);
   let src = null;
-  try { src = require('./codegen-engine').preprocessSource(resolveSchemaForPreprocess(validator._schemaObj, validator._schemaMap), { useDefaults: true }); } catch {}
-  return src === null ? '' : `function applyDefaults(d) {\n${src}\n}\n`;
+  try { src = require('./codegen-engine').preprocessSource(schema, { useDefaults: true }); } catch {}
+  if (src !== null) return `function applyDefaults(d) {\n${src}\n}\n`;
+  // The generated pass declines a recursive reference and keys matched by
+  // patterns; the runtime fills those with the closure pass, so the module
+  // carries it, as its own text (lib/defaults.js), with its schema less the
+  // descriptive keywords, `default` kept. Built on the first call.
+  const defaults = require('./defaults');
+  if (defaults.buildDefaultsApplier(schema) === null) return '';
+  const embedded = require('./schema-strip').stripAnnotationsKeepingDefaults(schema);
+  const text = JSON.stringify(JSON.stringify(embedded)).replace(/</g, '\\u003c');
+  return `const _ataDefaults = (function () {\nconst MAX_DEPTH = ${defaults.MAX_DEPTH};\n${require(AOT_ORDER_MODULE).take('defaults.js', defaults.EMBED)}\nreturn buildDefaultsApplier;\n})();\n` +
+    `let _ataFill;\nfunction applyDefaults(d) { (_ataFill || (_ataFill = _ataDefaults(JSON.parse(${text}))))(d); }\n`;
 }
 
 function toStandaloneModule(validator, opts) {

package/lib/aot-order.js

@@ -112,4 +112,4 @@ function _ataAfter(a, b) {
 ${ORDER('rank', '_ataAfter(keys[j], k)')}`;
 }
 
-module.exports = { orderDecl, wantsOrdinals };
+module.exports = { orderDecl, wantsOrdinals, take };

package/lib/buffer-gate.js

@@ -61,7 +61,39 @@ function re2Diverges(pattern) {
   return false;
 }
 
+// The walker gives up past a depth of its own (100 schema frames, about 50
+// levels of data under a recursive schema) and rejects the document there. A
+// schema that refers back into itself, or that is nested that deep, can reach
+// it with a document validate() accepts, so it is answered through validate(),
+// which has no such limit.
+const NATIVE_DEPTH = 40;
+
+// Whether a `$ref` into this document leads back to a schema it is inside.
+function refersBack(root) {
+  const { localRef } = require('./defaults.js');
+  const done = new Set();
+  const onPath = new Set();
+  const visit = (node) => {
+    if (node === null || typeof node !== 'object') return false;
+    if (onPath.has(node)) return true;
+    if (done.has(node)) return false;
+    onPath.add(node);
+    let back = false;
+    for (const key of Object.keys(node)) {
+      const v = node[key];
+      if (key === '$ref' && typeof v === 'string' && v.startsWith('#')) back = visit(localRef(root, v));
+      else if (key !== 'enum' && key !== 'const' && key !== 'default' && key !== 'examples' && v !== null && typeof v === 'object') back = visit(v);
+      if (back) break;
+    }
+    onPath.delete(node);
+    done.add(node);
+    return back;
+  };
+  return visit(root);
+}
+
 function walk(schema, depth) {
+  if (depth > NATIVE_DEPTH) return true;
   if (schema === true || schema === false) {
     // A boolean root is answered wrong by the walker; nested booleans are
     // handled where they appear (items and prefixItems below).
@@ -110,6 +142,7 @@ function walk(schema, depth) {
 function bufferNeedsSlowPath(schema, schemaMap, keywords) {
   if (keywords && schemaUsesKeywords(schema, keywords)) return true;
   if (walk(schema, 0)) return true;
+  if (refersBack(schema)) return true;
   if (schemaMap && schemaMap.size > 0) {
     for (const s of schemaMap.values()) if (walk(s, 1)) return true;
   }

package/lib/clone-emit.js

@@ -50,12 +50,13 @@ const _INLINE_ANNOTATIONS = new Set(['$ref', 'title', 'description', '$comment',
 const _INLINE_DATA_KEYS = new Set(['default', 'const', 'enum', 'examples']);
 function inlineRefsForClone(root) {
   const state = { budget: 512 };
-  // `inRef` marks content brought in from behind a reference. The runtime's
-  // useDefaults fills a default written next to the $ref, and does not fill
-  // defaults written inside the referenced definition, so the inlined copy
-  // keeps the first and drops the second. parse() must stay exactly as
-  // generous as validate(); a parse that fills more is a disagreement, not a
-  // feature.
+  // The runtime's useDefaults fills a property's default from the schema
+  // written under the property, the $ref node with any default next to it,
+  // and then the defaults inside the referenced definition, as it fills them
+  // inline. The definition's own top-level default is not the property's, so
+  // the inlined copy drops that one and keeps everything below it. parse()
+  // must stay exactly as generous as validate(); a parse that fills more, or
+  // less, is a disagreement.
   const walk = (node, active, inRef) => {
     if (!node || typeof node !== 'object') return node;
     if (Array.isArray(node)) return node.map((n) => walk(n, active, inRef));
@@ -73,14 +74,13 @@ function inlineRefsForClone(root) {
       cur = target;
       entered = true;
     }
-    const strip = inRef || entered;
     const out = {};
     for (const k of Object.keys(cur)) {
-      if (strip && k === 'default') continue;
+      if (entered && k === 'default') continue;
       const v = cur[k];
       // A property named "__proto__" is an own key of the copy: assigned, it
       // set the copy's prototype and the property was gone from parse().
-      const w = (_INLINE_DATA_KEYS.has(k) || k === '$defs' || k === 'definitions') ? v : walk(v, active, strip);
+      const w = (_INLINE_DATA_KEYS.has(k) || k === '$defs' || k === 'definitions') ? v : walk(v, active, false);
       if (k === '__proto__') Object.defineProperty(out, k, { value: w, writable: true, enumerable: true, configurable: true });
       else out[k] = w;
     }
@@ -197,7 +197,7 @@ function emitClone(node, access, depth) {
   if (apSchema) {
     const kVar = `_k${depth}`;
     const vVar = `_v${depth}`;
-    const valueExpr = emitValueExpr(stripDefaultsDeep(apSchema), vVar, depth);
+    const valueExpr = emitValueExpr(apSchema, vVar, depth);
     if (valueExpr === null) return null;
     let skip = '';
     let declSet = '';
@@ -255,20 +255,6 @@ function emitClone(node, access, depth) {
 // carry keys this code cannot see, and copying the reference would smuggle
 // them into a value that claims to be sanitised, so the caller declines the
 // whole clone instead.
-// Drop every schema-position `default` in a subtree, leaving data positions
-// (const, enum, examples) untouched. Used on a record's value schema, where
-// the runtime's useDefaults fills nothing.
-function stripDefaultsDeep(node) {
-  if (!node || typeof node !== 'object') return node;
-  if (Array.isArray(node)) return node.map(stripDefaultsDeep);
-  const out = {};
-  for (const k of Object.keys(node)) {
-    if (k === 'default') continue;
-    out[k] = _INLINE_DATA_KEYS.has(k) ? node[k] : stripDefaultsDeep(node[k]);
-  }
-  return out;
-}
-
 const _CLONE_PRIMITIVE = new Set(['string', 'number', 'integer', 'boolean', 'null']);
 // Whether every value this schema accepts is a primitive, so a copy has
 // nothing inside it to strip and takes the value as it is. A primitive type
@@ -329,4 +315,4 @@ function cloneExprFor(schema) {
   return emitClone(inlineRefsForClone(schema), 'data', 0);
 }
 
-module.exports = { cloneExprFor, emitClone, inlineRefsForClone, stripDefaultsDeep, resolveLocalPointer };
+module.exports = { cloneExprFor, emitClone, inlineRefsForClone, resolveLocalPointer };

package/lib/codegen-engine.js

@@ -236,6 +236,10 @@ function installCodegenPaths (ctx) {
   // The boolean engine is the verdict authority for these paths; the
   // final lazy wrapper uses it to skip error construction entirely.
   if (!hasDynRef || _isCodegen) this._fastVerdict = preprocess ? null : jsFn;
+  // With a preprocess pass the verdict runs it first, for the lazy layer in
+  // lib/validator-core.js, which then builds the errors only when they are
+  // read, from the document as the pass left it.
+  if ((!hasDynRef || _isCodegen) && preprocess && !fusedRemove) { ctx.preVerdict = (data) => { preprocess(data); return jsFn(data) }; ctx.rawVerdict = jsFn; }
 
   if (options.abortEarly && jsFn && !hasDynRef) {
     // abortEarly: do NOT enrich. Skip position lookups, suggestions, source maps.
@@ -319,7 +323,7 @@ function installCodegenPaths (ctx) {
     // deciding again: the lazy layer in lib/validator-core.js has its verdict
     // and used to call validate() to get the errors, which ran the verdict a
     // second time and built a second rejection around it.
-    if (!preprocess) ctx.rejectBase = onReject;
+    ctx.rejectBase = onReject;
     // The rich combined function, for a validator whose errors are being read
     // with richErrors on. See _ensureCompiled.
     if (!preprocess) {
@@ -360,7 +364,7 @@ function installCodegenPaths (ctx) {
       this.validate = preprocess
         ? (data) => { preprocess(data); return safeCombinedFn(data); }
         : safeCombinedFn;
-      if (!preprocess) ctx.rejectBase = (data) => _mustReject(safeCombinedFn(data));
+      ctx.rejectBase = (data) => _mustReject(safeCombinedFn(data));
     } else {
       this.validate = preprocess
         ? (data) => {
@@ -368,7 +372,7 @@ function installCodegenPaths (ctx) {
             return jsFn(data) ? VALID_RESULT : errOnly(data);
           }
         : (data) => (jsFn(data) ? VALID_RESULT : errOnly(data));
-      if (!preprocess) ctx.rejectBase = errOnly;
+      ctx.rejectBase = errOnly;
     }
   }
   // Verbose mode: populate parentSchema, schema and data on each error, the
@@ -803,18 +807,88 @@ function emitCoercions(node, ov, lines, st, depth) {
   }
   st.seen.delete(node);
 }
-function hasDefaultsInside(node, seen) {
-  if (!node || typeof node !== 'object' || !node.properties || seen.has(node)) return false;
-  seen.add(node);
-  let found = false;
-  for (const prop of Object.values(node.properties)) {
-    if (prop && typeof prop === 'object' && (prop.default !== undefined || hasDefaultsInside(prop, seen))) { found = true; break; }
+// From the closure pass, on the first reference a defaults walk meets: loaded
+// with this module it joined every process's cold start.
+let _localRef = null;
+const localRef = (root, ref) => (_localRef || (_localRef = require('./defaults').localRef))(root, ref);
+// Whether a default is reachable from a schema through the places the pass
+// goes (lib/defaults.js reachesDefault, which this pass is held to): the
+// same walk, with answers kept per schema object for the whole pass, except
+// one that rests on a schema still being decided (a recursive reference). It
+// started over for every property, quadratic in the depth of the schema.
+function reachState(root) { return { root, memo: new Map() }; }
+function hasDefaultsInside(node, rs) { return reachDefault(node, rs, new Set()) === 1; }
+function reachDefault(node, rs, stack) {
+  if (!node || typeof node !== 'object') return 0;
+  const known = rs.memo.get(node);
+  if (known !== undefined) return known;
+  if (stack.has(node)) return 2;
+  stack.add(node);
+  let open = false;
+  const check = (n) => { const r = reachDefault(n, rs, stack); if (r === 2) open = true; return r === 1; };
+  let yes = false;
+  if (node.properties && typeof node.properties === 'object') {
+    for (const prop of Object.values(node.properties)) {
+      if (prop && typeof prop === 'object' && (prop.default !== undefined || check(prop))) { yes = true; break; }
+    }
   }
-  seen.delete(node);
-  return found;
+  if (!yes && typeof node.$ref === 'string') yes = check(localRef(rs.root, node.$ref));
+  if (!yes) for (const list of [node.allOf, node.prefixItems]) { if (Array.isArray(list) && list.some(check)) { yes = true; break; } }
+  if (!yes) for (const one of [node.items, node.additionalProperties]) { if (check(one)) { yes = true; break; } }
+  if (!yes) for (const map of [node.patternProperties, node.dependentSchemas]) { if (map && typeof map === 'object' && Object.keys(map).some((k) => check(map[k]))) { yes = true; break; } }
+  stack.delete(node);
+  if (yes) { rs.memo.set(node, 1); return 1; }
+  if (!open) { rs.memo.set(node, 0); return 0; }
+  return 2;
+}
+// Which keys `additionalProperties` covers depends on the patterns of
+// `patternProperties`, which this pass does not test (a RegExp built on
+// every call would cost more than the pass): a schema whose defaults depend
+// on one is left to the closure pass.
+function defaultsNeedPatterns(node, rs) {
+  const pp = node.patternProperties;
+  if (!pp || typeof pp !== 'object' || Object.keys(pp).length === 0) return false;
+  for (const k of Object.keys(pp)) if (hasDefaultsInside(pp[k], rs)) return true;
+  return hasDefaultsInside(node.additionalProperties, rs);
+}
+// The defaults of `schema` filled into the value of `expr`, when it holds an
+// object (an array included), as the closure pass fills them.
+function emitDefaultsAt(schema, expr, lines, st) {
+  const n = '_d' + st.n++;
+  lines.push(`{const ${n}=${expr};if(typeof ${n}==='object'&&${n}!==null){`);
+  emitDefaults(schema, n, lines, st);
+  lines.push('}}');
+}
+// A pass that would expand to more than this many lines (references written
+// out again at every use) is left to the closure pass.
+const DEFAULTS_MAX_LINES = 4000;
+// How many schema objects emitDefaults would write out, references expanded
+// at every use, or Infinity where it would decline (a cycle, or defaults
+// under patternProperties). Each writes at least one line, so a count over
+// DEFAULTS_MAX_LINES declines where emitDefaults would, before writing
+// anything: SARIF's schema wrote 4000 lines in 2.7 ms and threw them away.
+function defaultsVisits(node, st, stack) {
+  const known = st.visits.get(node);
+  if (known !== undefined) return known;
+  if (stack.has(node)) return Infinity;
+  stack.add(node);
+  let n = 1;
+  const add = (x) => { if (n <= DEFAULTS_MAX_LINES && hasDefaultsInside(x, st.reach)) n += defaultsVisits(x, st, stack); };
+  if (defaultsNeedPatterns(node, st.reach)) n = Infinity;
+  for (const prop of Object.values(node.properties || {})) if (prop && typeof prop === 'object') add(prop);
+  if (Array.isArray(node.prefixItems)) node.prefixItems.forEach(add);
+  add(node.items);
+  add(node.additionalProperties);
+  if (node.dependentSchemas && typeof node.dependentSchemas === 'object') Object.values(node.dependentSchemas).forEach(add);
+  if (typeof node.$ref === 'string') add(localRef(st.root, node.$ref));
+  if (Array.isArray(node.allOf)) node.allOf.forEach(add);
+  stack.delete(node);
+  if (n > DEFAULTS_MAX_LINES) n = Infinity;
+  st.visits.set(node, n);
+  return n;
 }
 function emitDefaults(node, ov, lines, st) {
-  if (st.seen.has(node)) { st.cycle = true; return; }
+  if (st.seen.has(node) || lines.length > DEFAULTS_MAX_LINES) { st.cycle = true; return; }
   st.seen.add(node);
   // A default is written only where the key is not an own property, and the
   // own-property test used to be Object.hasOwn for every default on every
@@ -846,7 +920,7 @@ function emitDefaults(node, ov, lines, st) {
     // closure pass walks it. Object.prototype's own properties are functions
     // apart from the __proto__ accessor, so on a plain object a read that
     // gives an object is an own property for every other key.
-    if (prop.properties && hasDefaultsInside(prop, new Set())) {
+    if (hasDefaultsInside(prop, st.reach)) {
       const n = '_d' + st.n++;
       const own = inherited ? `Object.hasOwn(${ov},${k})` : `(${pk}||Object.hasOwn(${ov},${k}))`;
       lines.push(`{const ${n}=${ov}[${k}];if(typeof ${n}==='object'&&${n}!==null&&${own}){`);
@@ -854,6 +928,56 @@ function emitDefaults(node, ov, lines, st) {
       lines.push('}}');
     }
   }
+  if (defaultsNeedPatterns(node, st.reach)) { st.cycle = true; st.seen.delete(node); return; }
+  // Elements of an array: `prefixItems` by position, `items` after them.
+  const has = (x) => hasDefaultsInside(x, st.reach);
+  const tuple = Array.isArray(node.prefixItems) ? node.prefixItems : [];
+  const tupleHas = tuple.map(has);
+  const itemsHas = has(node.items);
+  if (tupleHas.some(Boolean) || itemsHas) {
+    lines.push(`if(Array.isArray(${ov})){`);
+    for (let i = 0; i < tuple.length; i++) {
+      if (!tupleHas[i]) continue;
+      lines.push(`if(${ov}.length>${i})`);
+      emitDefaultsAt(tuple[i], `${ov}[${i}]`, lines, st);
+    }
+    if (itemsHas) {
+      const i = '_i' + st.n++;
+      lines.push(`for(let ${i}=${tuple.length};${i}<${ov}.length;${i}++)`);
+      emitDefaultsAt(node.items, `${ov}[${i}]`, lines, st);
+    }
+    lines.push('}');
+  }
+  // Keys of an object that `properties` does not name (no patterns here,
+  // see defaultsNeedPatterns).
+  if (has(node.additionalProperties)) {
+    const k = '_k' + st.n++;
+    const declared = Object.keys(node.properties || {});
+    lines.push(`if(!Array.isArray(${ov}))for(const ${k} of Object.keys(${ov})){`);
+    if (declared.length) lines.push(`if(${declared.map((d) => `${k}===${JSON.stringify(d)}`).join('||')})continue;`);
+    emitDefaultsAt(node.additionalProperties, `${ov}[${k}]`, lines, st);
+    lines.push('}');
+  }
+  // A schema for the same object, for each key present.
+  if (node.dependentSchemas && typeof node.dependentSchemas === 'object') {
+    for (const key of Object.keys(node.dependentSchemas)) {
+      const dep = node.dependentSchemas[key];
+      if (!has(dep)) continue;
+      lines.push(`if(!Array.isArray(${ov})&&Object.hasOwn(${ov},${JSON.stringify(key)})){`);
+      emitDefaults(dep, ov, lines, st);
+      lines.push('}');
+    }
+  }
+  // The schemas applied to the same value: a `$ref` into the same document,
+  // written out here (one back into what is being written is a cycle, left
+  // to the closure pass), then each `allOf` member, in the closure pass's order.
+  if (typeof node.$ref === 'string') {
+    const target = localRef(st.root, node.$ref);
+    if (target && hasDefaultsInside(target, st.reach)) emitDefaults(target, ov, lines, st);
+  }
+  if (Array.isArray(node.allOf)) {
+    for (const sub of node.allOf) if (hasDefaultsInside(sub, st.reach)) emitDefaults(sub, ov, lines, st);
+  }
   st.seen.delete(node);
 }
 
@@ -861,7 +985,11 @@ function emitDefaults(node, ov, lines, st) {
 // the closure passes must take the schema. A module written ahead of time
 // embeds it as applyDefaults (lib/aot-impl.js), so it runs the runtime's code.
 function preprocessSource(schema, options) {
-  if (typeof schema !== 'object' || schema === null || !schema.properties) return null;
+  if (typeof schema !== 'object' || schema === null) return null;
+  // Defaults reach through `$ref` and `allOf` from the root too; the other
+  // passes start at `properties`.
+  const reach = reachState(schema);
+  if (!schema.properties && !(options.useDefaults !== false && hasDefaultsInside(schema, reach))) return null;
   const lines = [];
 
   // removeAdditional: strip unknown keys at every level the schema describes,
@@ -880,11 +1008,14 @@ function preprocessSource(schema, options) {
   // used to stop at the top-level properties. A schema object that contains
   // itself declines here, and the closure passes, which carry a guard for it,
   // take the schema.
-  const st = { n: 0, seen: new Set(), cycle: false, arrayMode: options.coerceTypes === 'array', memo: new Map() };
+  const st = { n: 0, seen: new Set(), cycle: false, arrayMode: options.coerceTypes === 'array', memo: new Map(), root: schema, reach, visits: new Map() };
   if (options.coerceTypes) emitCoercions(schema, 'd', lines, st, 0);
   // hasDefaultsInside answers without emitting; most schemas have no default,
   // and the emitting walk allocates for every property it visits.
-  if (options.useDefaults !== false && hasDefaultsInside(schema, new Set())) emitDefaults(schema, 'd', lines, st);
+  if (options.useDefaults !== false && hasDefaultsInside(schema, reach)) {
+    if (defaultsVisits(schema, st, new Set()) > DEFAULTS_MAX_LINES) return null;
+    emitDefaults(schema, 'd', lines, st);
+  }
   if (st.cycle) return null;
 
   if (lines.length === 0) return null;

package/lib/defaults.js

@@ -2,19 +2,32 @@
 
 // The closure pass that fills `default` values, shared by the validator core
 // and by the wrapper around a compiled module, so both fill defaults the same
-// way. The generated pass in index.js is held to this one by
+// way. The generated pass in lib/codegen-engine.js is held to this one by
 // tests/test_nested_defaults_engines.js.
+//
+// A default is filled in every schema applied to the value at that place, as
+// ajv's `useDefaults` fills one: the schemas under `properties`, through a
+// `$ref` into the same document (recursive ones included), each `allOf`
+// member, `items` for every element and `prefixItems` by position,
+// `patternProperties` for the keys they match, `additionalProperties` for the
+// rest, and `dependentSchemas` for the keys present. The pass stopped at
+// `properties`, so a default behind a reference or in an array element was
+// not filled, and a `required` property with one was rejected where ajv
+// accepts it. `anyOf`, `oneOf` and `not` fill nothing, as with ajv;
+// `if`/`then`/`else` fill nothing here, since which branch applies is only
+// known once the value has been checked.
 
-// Extract default values from a schema tree. Returns a function that applies
-// defaults to an object in-place (mutates), or null if no defaults exist.
+// Below a value nested this deep the pass stops: data that contains itself,
+// under a recursive schema, would otherwise never end.
+const MAX_DEPTH = 512;
+
+// Build the pass for a schema: a function that fills defaults into a value in
+// place (mutates), or null when no default is reachable from the schema.
 function buildDefaultsApplier(schema) {
   if (typeof schema !== "object" || schema === null) return null;
-  const actions = [];
-  collectDefaults(schema, actions);
-  if (actions.length === 0) return null;
-  return (data) => {
-    for (let i = 0; i < actions.length; i++) actions[i](data);
-  };
+  const path = [];
+  const fn = compileNode(schema, schema, new Map(), new Map(), path);
+  return fn === null ? null : (data) => { path.length = 0; fn(data, 0, null); };
 }
 
 // Write an own property. Plain assignment of a key named `__proto__` does
@@ -34,55 +47,199 @@ function setOwn(obj, key, val) {
   }
 }
 
-function collectDefaults(schema, actions, path) {
-  if (typeof schema !== "object" || schema === null) return;
-  const props = schema.properties;
-  if (!props) return;
-  for (const [key, prop] of Object.entries(props)) {
-    if (prop && typeof prop === "object" && prop.default !== undefined) {
-      const defaultVal = prop.default;
-      if (!path) {
-        actions.push((data) => {
-          if (typeof data === "object" && data !== null && !Object.hasOwn(data, key)) {
-            setOwn(data,
-              key,
-              typeof defaultVal === "object" && defaultVal !== null
-                ? JSON.parse(JSON.stringify(defaultVal))
-                : defaultVal);
-          }
-        });
-      } else {
-        const parentPath = path;
-        actions.push((data) => {
-          let target = data;
-          for (let j = 0; j < parentPath.length; j++) {
-            if (typeof target !== "object" || target === null) return;
-            // Own keys only. `target[key]` for an inherited name walks the
-            // prototype chain: a parent named `__proto__` that the instance
-            // does not carry resolved to Object.prototype, and the child
-            // defaults were written onto it, for every object in the realm.
-            if (!Object.hasOwn(target, parentPath[j])) return;
-            target = target[parentPath[j]];
-          }
-          if (
-            typeof target === "object" &&
-            target !== null &&
-            !Object.hasOwn(target, key)
-          ) {
-            setOwn(target,
-              key,
-              typeof defaultVal === "object" && defaultVal !== null
-                ? JSON.parse(JSON.stringify(defaultVal))
-                : defaultVal);
-          }
-        });
-      }
+// The schema a `$ref` names in the same document: `#`, or a JSON pointer
+// after it. Null for anything else (another document, an anchor), which the
+// pass leaves alone. Normalization renames draft-07 `definitions` to `$defs`
+// and leaves the pointers as written, so either name reads as the other.
+function localRef(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; } }
+    if (seg.indexOf("~") >= 0) seg = seg.replace(/~1/g, "/").replace(/~0/g, "~");
+    if (t === null || typeof t !== "object") return null;
+    if (!Object.hasOwn(t, seg)) {
+      const alias = seg === "definitions" ? "$defs" : seg === "$defs" ? "definitions" : null;
+      if (alias === null || !Object.hasOwn(t, alias)) return null;
+      seg = alias;
+    }
+    t = t[seg];
+  }
+  return t !== null && typeof t === "object" ? t : null;
+}
+
+// Whether a default is reachable from a schema, through the same places the
+// pass goes: 1 yes, 0 no, 2 not known yet because the walk came back to a
+// schema it is still deciding (a recursive reference). Answers are kept per
+// schema object in `memo`, except one that rests on an undecided schema,
+// which is worked out again when asked; the walk used to start over for every
+// schema object it compiled, quadratic in the depth of the schema.
+function reachesDefault(node, root, memo, stack) {
+  if (node === null || typeof node !== "object") return 0;
+  const known = memo.get(node);
+  if (known !== undefined) return known;
+  if (stack.has(node)) return 2;
+  stack.add(node);
+  const props = valuesOf(node.properties);
+  let yes = props.some((p) => p && typeof p === "object" && p.default !== undefined);
+  let open = false;
+  const below = props.concat(localRef(root, node.$ref), listOf(node.allOf), listOf(node.prefixItems), node.items, node.additionalProperties, valuesOf(node.patternProperties), valuesOf(node.dependentSchemas));
+  for (let i = 0; !yes && i < below.length; i++) {
+    const r = reachesDefault(below[i], root, memo, stack);
+    if (r === 1) yes = true;
+    else if (r === 2) open = true;
+  }
+  stack.delete(node);
+  if (yes || !open) memo.set(node, yes ? 1 : 0);
+  return yes ? 1 : open ? 2 : 0;
+}
+function valuesOf(m) {
+  return m && typeof m === "object" && !Array.isArray(m) ? Object.values(m) : [];
+}
+function listOf(a) {
+  return Array.isArray(a) ? a : [];
+}
+
+// A pattern of `patternProperties` as the validator reads one.
+function keyPattern(src) {
+  try { return new RegExp(src, "u"); } catch { try { return new RegExp(src); } catch { return null; } }
+}
+
+// A fresh copy of a default for each value it fills. `[]`, the most common
+// object default (2916 of the 4130 SARIF's schema fills into one log), skips
+// the JSON round trip.
+function copyOf(v) {
+  return typeof v !== "object" || v === null ? v : Array.isArray(v) && v.length === 0 ? [] : JSON.parse(JSON.stringify(v));
+}
+
+// The pass for one schema object, built once: its own defaults, then the
+// schemas below its properties, then its `$ref` and its `allOf` members, each
+// applied to the same value. A schema reached again (a recursive reference)
+// takes the function being built for it, so a cycle in the schema is a loop
+// in the calls, bounded by the depth of the data.
+function compileNode(node, root, memo, reach, path) {
+  if (node === null || typeof node !== "object") return null;
+  if (memo.has(node)) return memo.get(node);
+  if (reachesDefault(node, root, reach, new Set()) !== 1) { memo.set(node, null); return null; }
+  let body = null;
+  // `path`: the schemas applied to the enclosing values, outermost first.
+  // `made`: inside a value the pass itself made from a default, the same as a
+  // set, and null elsewhere. There a schema already applied to an enclosing
+  // value is not applied again: one that refers back to an enclosing schema,
+  // with an object default, would otherwise make a value, fill it, make the
+  // next one inside it, and never stop. ajv throws a RangeError on such a
+  // schema, and Renovate's took this pass to the heap limit.
+  const fn = (data, depth, made) => {
+    if (depth > MAX_DEPTH) return;
+    if (made !== null) {
+      if (made.has(node)) return;
+      made.add(node);
+      body(data, depth, made);
+      made.delete(node);
+      return;
     }
-    // Recurse into nested object schemas
-    if (prop && typeof prop === "object" && prop.properties) {
-      collectDefaults(prop, actions, (path || []).concat(key));
+    path.push(node);
+    body(data, depth, null);
+    path.pop();
+  };
+  memo.set(node, fn);
+
+  const own = [];
+  const below = [];
+  const props = node.properties;
+  if (props && typeof props === "object") {
+    for (const key of Object.keys(props)) {
+      const p = props[key];
+      if (!p || typeof p !== "object") continue;
+      if (p.default !== undefined) own.push([key, p.default]);
+      const child = compileNode(p, root, memo, reach, path);
+      if (child !== null) below.push([key, child]);
+    }
+  }
+  // Arrays: every element under `items`, the elements `prefixItems` names by
+  // position (then `items` covers only the ones after them).
+  const tuple = Array.isArray(node.prefixItems) ? node.prefixItems.map((s) => compileNode(s, root, memo, reach, path)) : [];
+  const each = compileNode(node.items, root, memo, reach, path);
+  // Objects: keys a pattern matches, and the keys neither `properties` nor a
+  // pattern names; and a schema for each key present.
+  const patterns = [];
+  if (node.patternProperties && typeof node.patternProperties === "object") {
+    for (const src of Object.keys(node.patternProperties)) {
+      const re = keyPattern(src);
+      const t = compileNode(node.patternProperties[src], root, memo, reach, path);
+      if (re === null) continue;
+      patterns.push([re, t]);
+    }
+  }
+  const extra = compileNode(node.additionalProperties, root, memo, reach, path);
+  const declared = props && typeof props === "object" ? props : null;
+  const dependent = [];
+  if (node.dependentSchemas && typeof node.dependentSchemas === "object") {
+    for (const key of Object.keys(node.dependentSchemas)) {
+      const t = compileNode(node.dependentSchemas[key], root, memo, reach, path);
+      if (t !== null) dependent.push([key, t]);
+    }
+  }
+  const keyed = extra !== null || patterns.some((p) => p[1] !== null);
+
+  const also = [];
+  if (typeof node.$ref === "string") {
+    const t = compileNode(localRef(root, node.$ref), root, memo, reach, path);
+    if (t !== null) also.push(t);
+  }
+  if (Array.isArray(node.allOf)) {
+    for (const s of node.allOf) {
+      const t = compileNode(s, root, memo, reach, path);
+      if (t !== null) also.push(t);
     }
   }
+
+  body = (data, depth, made) => {
+    let fresh = null;
+    if (typeof data === "object" && data !== null) {
+      for (let i = 0; i < own.length; i++) {
+        const key = own[i][0];
+        if (!Object.hasOwn(data, key)) {
+          const v = copyOf(own[i][1]);
+          setOwn(data, key, v);
+          if (made === null && typeof v === "object" && v !== null) (fresh || (fresh = [])).push(key);
+        }
+      }
+      for (let i = 0; i < below.length; i++) {
+        // Own keys only. `data[key]` for an inherited name walks the
+        // prototype chain: a property named `__proto__` that the value does
+        // not carry resolved to Object.prototype, and the defaults below it
+        // were written onto it, for every object in the realm.
+        const key = below[i][0];
+        if (Object.hasOwn(data, key)) below[i][1](data[key], depth + 1, fresh !== null && fresh.includes(key) ? new Set(path) : made);
+      }
+      if (Array.isArray(data)) {
+        for (let i = 0; i < data.length; i++) {
+          const t = i < tuple.length ? tuple[i] : each;
+          if (t !== null && t !== undefined) t(data[i], depth + 1, made);
+        }
+      } else if (keyed) {
+        for (const key of Object.keys(data)) {
+          let matched = false;
+          for (let i = 0; i < patterns.length; i++) {
+            if (patterns[i][0].test(key)) { matched = true; if (patterns[i][1] !== null) patterns[i][1](data[key], depth + 1, made); }
+          }
+          if (extra !== null && !matched && !(declared !== null && Object.hasOwn(declared, key))) extra(data[key], depth + 1, made);
+        }
+      }
+      if (!Array.isArray(data)) {
+        for (let i = 0; i < dependent.length; i++) if (Object.hasOwn(data, dependent[i][0])) dependent[i][1](data, depth + 1, made);
+      }
+    }
+    for (let i = 0; i < also.length; i++) also[i](data, depth + 1, made);
+  };
+  return fn;
 }
 
-module.exports = { buildDefaultsApplier, setOwn };
+// The functions a module written ahead of time embeds as its applyDefaults
+// where the generated pass declines a schema (lib/aot-impl.js).
+const EMBED = ['buildDefaultsApplier', 'setOwn', 'localRef', 'reachesDefault', 'valuesOf', 'listOf', 'keyPattern', 'copyOf', 'compileNode'];
+
+module.exports = { buildDefaultsApplier, setOwn, localRef, MAX_DEPTH, EMBED };

package/lib/error-codes.js

@@ -136,6 +136,7 @@ const NATIVE_KEYWORDS = [
   'not',                    // 25 not_failed
   '$ref',                   // 26 ref_not_found
   'if',                     // 27 if_then_else_failed
+  '__depth__',              // 28 depth_exceeded
 ]
 
 // Keyword and public code for a native ordinal, or null when the ordinal is
@@ -147,6 +148,11 @@ function fromNative (ordinal, format) {
   // codeFor('format') answers with the first format code, which names a
   // specific format. Without knowing which format failed, the generic one is
   // the honest answer.
+  // The walker stopped at its depth limit and rejected the document. No
+  // public code names that: the APIs that ask the walker route schemas deep or
+  // recursive enough to reach it to validate() first (lib/buffer-gate.js), so
+  // it is the generic failure.
+  if (keyword === '__depth__') return { keyword, code: 'ATA9000' }
   const code = keyword === 'format'
     ? (format ? codeFor('format', format) || 'ATA3099' : 'ATA3099')
     : codeFor(keyword) || 'ATA9001'

package/lib/formats-source.js

@@ -304,4 +304,4 @@ function durationSource (v, isStr) {
   const inner = `if(!${_formats().DURATION_RE.toString()}.test(${v}))return false`;
   return isStr ? inner : `if(typeof ${v}==='string'&&${inner.slice(3)}`;
 }
-module.exports = { uriHelperSource, uriHelperCompactSource, uriSource, uriReferenceSource, iriSource, iriReferenceSource, idnEmailSource, dateSource, ipv4Source, dateTimeSource, ipv6Source, hostnameSource, uriSource, uuidSource, timeSource, noReservedSource, jsonPointerSource, relativeJsonPointerSource, uriTemplateSource, emailSource, durationSource };
+module.exports = { uriHelperSource, uriHelperCompactSource, uriSource, uriReferenceSource, iriSource, iriReferenceSource, idnEmailSource, dateSource, ipv4Source, dateTimeSource, ipv6Source, hostnameSource, uuidSource, timeSource, noReservedSource, jsonPointerSource, relativeJsonPointerSource, uriTemplateSource, emailSource, durationSource };

package/lib/interpreter-core.js

@@ -903,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;
@@ -1530,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) {

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/validator-core.js

@@ -1098,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
@@ -1200,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).
@@ -1220,6 +1220,8 @@ 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
@@ -1237,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
@@ -1251,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);
@@ -1442,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
@@ -1453,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
@@ -1461,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([]);
@@ -1553,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);
         };

package/lib/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "1.57.0",
+  "version": "1.58.1",
   "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.57.0",
-    "@ata-validator/native-darwin-x64": "1.57.0",
-    "@ata-validator/native-linux-arm64-gnu": "1.57.0",
-    "@ata-validator/native-linux-arm64-musl": "1.57.0",
-    "@ata-validator/native-linux-x64-gnu": "1.57.0",
-    "@ata-validator/native-linux-x64-musl": "1.57.0",
-    "@ata-validator/native-win32-x64": "1.57.0"
+    "@ata-validator/native-darwin-arm64": "1.58.1",
+    "@ata-validator/native-darwin-x64": "1.58.1",
+    "@ata-validator/native-linux-arm64-gnu": "1.58.1",
+    "@ata-validator/native-linux-arm64-musl": "1.58.1",
+    "@ata-validator/native-linux-x64-gnu": "1.58.1",
+    "@ata-validator/native-linux-x64-musl": "1.58.1",
+    "@ata-validator/native-win32-x64": "1.58.1"
   },
   "peerDependencies": {
     "yaml": "^2.0.0"