ata-validator 1.56.0 → 1.58.0

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,12 +928,68 @@ 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);
 }
 
-// Generate a fast preprocess function via codegen instead of closure arrays
-function buildPreprocessCodegen(schema, options) {
-  if (typeof schema !== 'object' || schema === null || !schema.properties) return null;
+// The source of the preprocess pass, or null when there is nothing to do or
+// 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) 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,
@@ -878,24 +1008,33 @@ function buildPreprocessCodegen(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;
   // Data may legitimately be null or a non-object (e.g. a `['object','null']`
   // schema), so the per-property mutations must not run on it.
   lines.unshift(`if(d===null||typeof d!=='object')return`);
+  return lines.join('\n');
+}
+
+// Generate a fast preprocess function via codegen instead of closure arrays
+function buildPreprocessCodegen(schema, options) {
+  const src = preprocessSource(schema, options);
+  if (src === null) return null;
   // The pass depends on property names, types, defaults and which objects
   // are closed, not on the constraints the verdict checks, so routes that
   // take the same shape with different limits (a page/limit querystring, an
   // id param) emit the same source. Compiling it is most of what building the
   // pass costs, so the function is kept by its source and compiled once. It
   // holds no state: it rewrites the object it is given and nothing else.
-  const src = lines.join('\n');
   let fn = _preprocessBySource.get(src);
   if (fn === undefined) {
     try {
@@ -1020,6 +1159,7 @@ module.exports = {
   compileVerdict: installCodegenPaths.compileVerdict,
   installScanner: installCodegenPaths.installScanner,
   buildPreprocess: buildPreprocessCodegen,
+  preprocessSource,
   buildParse,
   aot: () => require('./aot.js'),
 };

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 };