ata-validator 1.61.2 → 1.62.0

package/lib/codegen-engine.js

@@ -440,7 +440,7 @@ function installCodegenPaths (ctx) {
   let nativeText; // undefined until the first large document
   const nativeVerdict = (jsonStr) => {
     if (nativeText === undefined) {
-      nativeText = !!getNative() && !require('./buffer-gate.js').bufferNeedsSlowPath(schemaObj, this._schemaMap, this._keywords);
+      nativeText = !!getNative() && !require('./buffer-gate.js').bufferNeedsSlowPath(schemaObj, this._schemaMap, this._keywords, this._userFormats);
       if (nativeText) {
         this._ensureNative();
         if (!(this._fastSlot >= 0)) nativeText = false;
@@ -715,7 +715,7 @@ installCodegenPaths.installScanner = function installScanner (schemaObj, options
 // access expression read through a parent that could be absent or null:
 // `{ c: { properties: { d: { additionalProperties: false } } } }` threw a
 // TypeError from validate({}) whenever the optional `c` was missing.
-function emitRemovals(node, access, lines, depth, seen) {
+function emitRemovals(node, access, lines, depth, seen, own) {
   if (!node || typeof node !== 'object' || !node.properties) return;
   if (seen.has(node)) return;
   seen.add(node);
@@ -733,13 +733,15 @@ function emitRemovals(node, access, lines, depth, seen) {
   for (const key of keys) {
     const prop = node.properties[key];
     if (prop && typeof prop === 'object' && prop.properties) {
-      emitRemovals(prop, `${access}[${JSON.stringify(key)}]`, body, depth + 1, seen);
+      // Into own keys only: a nested object the document inherits is not
+      // part of it, and deleting from it would strip a shared object.
+      emitRemovals(prop, `${access}[${JSON.stringify(key)}]`, body, depth + 1, seen, `Object.hasOwn(${access},${JSON.stringify(key)})&&`);
     }
   }
   seen.delete(node);
   if (body.length === 0) return;
   if (depth === 0) lines.push(...body);
-  else lines.push(`if(${access}!==null&&typeof ${access}==='object'&&!Array.isArray(${access})){${body.join('\n')}}`);
+  else lines.push(`if(${own}${access}!==null&&typeof ${access}==='object'&&!Array.isArray(${access})){${body.join('\n')}}`);
 }
 
 // The coercions the closure pass applies, emitted. Values: `number` and
@@ -779,6 +781,15 @@ function emitCoercions(node, ov, lines, st, depth) {
   if (st.seen.has(node)) { st.cycle = true; return; }
   st.seen.add(node);
   if (node.properties) {
+    // Own properties only, as the closure pass has it: a value the object
+    // inherits belongs to some other object, and `k in o` once wrapped
+    // Object.prototype's own `constructor` into an own array key. On a plain
+    // object (prototype Object.prototype) a read that gives a primitive or
+    // an object is own for every key but the ones Object.prototype has, so
+    // the flag settles the common case and hasOwn is consulted otherwise.
+    const pk = '_pk' + st.n++;
+    let flagged = false;
+    const flag = () => { if (!flagged) { flagged = true; lines.push(`const ${pk}=Object.getPrototypeOf(${ov})===Object.prototype`); } };
     for (const [key, prop] of Object.entries(node.properties)) {
       // Coercion writes with plain assignment, which for a key named
       // __proto__ rewrites the prototype instead. The raw value still goes
@@ -786,13 +797,15 @@ function emitCoercions(node, ov, lines, st, depth) {
       if (key === '__proto__' || !prop || typeof prop !== 'object') continue;
       const k = JSON.stringify(key);
       const a = `${ov}[${k}]`;
-      if (isScalarCoercible(prop)) lines.push(...scalarCoercion(a, prop.type));
+      const own = key in Object.prototype ? `Object.hasOwn(${ov},${k})` : `(${pk}||Object.hasOwn(${ov},${k}))`;
+      if (isScalarCoercible(prop)) { flag(); lines.push(`if(${own}){`, ...scalarCoercion(a, prop.type), '}'); }
       // Wrapping a lone value in an array is a top-level rule only, as it was.
-      else if (depth === 0 && prop.type === 'array' && st.arrayMode) lines.push(`if(${k} in ${ov}&&${a}!==undefined&&!Array.isArray(${a}))${a}=[${a}]`);
+      else if (depth === 0 && prop.type === 'array' && st.arrayMode) { flag(); lines.push(`if(${own}&&${a}!==undefined&&!Array.isArray(${a}))${a}=[${a}]`); }
       // A leaf, the common case, has nothing below it to coerce.
       if ((prop.properties || prop.items) && coercesInside(prop, new Set(), st.memo)) {
+        flag();
         const n = '_c' + st.n++;
-        lines.push(`{const ${n}=${a};if(typeof ${n}==='object'&&${n}!==null){`);
+        lines.push(`{const ${n}=${a};if(typeof ${n}==='object'&&${n}!==null&&${own}){`);
         emitCoercions(prop, n, lines, st, depth + 1);
         lines.push('}}');
       }
@@ -815,14 +828,23 @@ function emitCoercions(node, ov, lines, st, depth) {
 }
 // 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);
+// A fragment `$ref` is read against the resource its node belongs to (an
+// embedded `$id`), as validation and the closure pass read it.
+let _defaultsMod = null;
+const defaultsMod = () => _defaultsMod || (_defaultsMod = require('./defaults'));
+const refOf = (rs, node) => {
+  if (typeof node.$ref !== 'string') return null;
+  if (rs.res === undefined) rs.res = defaultsMod().resourceRoots(rs.root);
+  return defaultsMod().refTarget(rs.root, rs.res, node);
+};
 // 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() }; }
+// `res`, the resources map, is built on the first `$ref` the walk follows:
+// most schemas have none, and the walk over the schema is not worth making.
+function reachState(root) { return { root, memo: new Map(), res: undefined }; }
 function hasDefaultsInside(node, rs) { return reachDefault(node, rs, new Set()) === 1; }
 function reachDefault(node, rs, stack) {
   if (!node || typeof node !== 'object') return 0;
@@ -838,7 +860,7 @@ function reachDefault(node, rs, stack) {
       if (prop && typeof prop === 'object' && (prop.default !== undefined || check(prop))) { yes = true; break; }
     }
   }
-  if (!yes && typeof node.$ref === 'string') yes = check(localRef(rs.root, node.$ref));
+  if (!yes && typeof node.$ref === 'string') yes = check(refOf(rs, node));
   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; } }
@@ -868,6 +890,8 @@ function emitDefaultsAt(schema, expr, lines, st) {
 // 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;
+// The most default-value source the generated pass writes, in characters.
+const DEFAULTS_MAX_BYTES = 256 * 1024;
 // 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
@@ -886,13 +910,22 @@ function defaultsVisits(node, st, stack) {
   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 (typeof node.$ref === 'string') add(refOf(st.reach, node));
   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;
 }
+// A default as source that rebuilds it fresh on every fill. An object
+// literal reads a "__proto__" key as the prototype slot, so a default that
+// holds one (own, as JSON.parse writes it) is rebuilt by JSON.parse from its
+// text instead: as a literal the filled value had no such key and inherited
+// from the default's inner object.
+function defaultLiteral(v) {
+  const text = JSON.stringify(v);
+  return v !== null && typeof v === 'object' && text.includes('"__proto__"') ? `JSON.parse(${JSON.stringify(text)})` : text;
+}
 function emitDefaults(node, ov, lines, st) {
   if (st.seen.has(node) || lines.length > DEFAULTS_MAX_LINES) { st.cycle = true; return; }
   st.seen.add(node);
@@ -915,7 +948,13 @@ function emitDefaults(node, ov, lines, st) {
     const inherited = key in Object.prototype;
     const absent = inherited ? `!Object.hasOwn(${ov},${k})` : `(${ov}[${k}]===undefined||!${pk})&&!Object.hasOwn(${ov},${k})`;
     if (prop.default !== undefined) {
-      const def = JSON.stringify(prop.default);
+      const def = defaultLiteral(prop.default);
+      // A shared definition is written out at every reference to it, its
+      // defaults with it: 200 references to a 50 KB default made 10 MB of
+      // source. Past the budget the closure pass, which holds each default
+      // once, takes the schema.
+      st.defaultBytes = (st.defaultBytes || 0) + def.length;
+      if (st.defaultBytes > DEFAULTS_MAX_BYTES) { st.cycle = true; st.seen.delete(node); return; }
       // Assignment to a key named __proto__ hits the prototype setter
       // instead of creating a property; defineProperty writes an own key.
       lines.push(key === '__proto__'
@@ -978,7 +1017,7 @@ function emitDefaults(node, ov, lines, st) {
   // 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);
+    const target = refOf(st.reach, node);
     if (target && hasDefaultsInside(target, st.reach)) emitDefaults(target, ov, lines, st);
   }
   if (Array.isArray(node.allOf)) {
@@ -1075,8 +1114,15 @@ function buildParse (self, decline, extended) {
   self._ensureCompiled();
   const verdict = extended ? (d) => self.isValidObject(d) : self._jsFn;
   if (typeof self._jsFn !== 'function') return decline('the schema has no generated verdict function');
-  return (data) => {
-    if (!verdict(data)) {
+  // With a preprocess pass (defaults, removeAdditional), validate() checks
+  // the document after the pass has run, and a check of the raw input can
+  // answer the other way: a default can make a conditional apply. The
+  // verdict is then taken on a filled clone of the input, the caller's
+  // object left alone, and the copy handed back is checked as well, so
+  // parse() never returns a value validate() would refuse.
+  const fill = self._preprocess;
+  const filled = typeof fill === 'function';
+  const reject = (data) => {
       const e = new Error('validation failed');
       e.name = 'AtaValidationError';
       let target = data;
@@ -1099,8 +1145,28 @@ function buildParse (self, decline, extended) {
         set (v) { Object.defineProperty(e, 'errors', { value: v, writable: true, configurable: true, enumerable: true }); },
       });
       throw e;
+  };
+  if (!filled) {
+    return (data) => {
+      if (!verdict(data)) reject(data);
+      return copy(data);
+    };
+  }
+  return (data) => {
+    let doc;
+    try { doc = structuredClone(data); } catch { doc = undefined; }
+    if (doc === undefined && data !== undefined) {
+      throw new TypeError('parse() is not available for this value: it cannot be copied to fill its defaults before the check. Use validate() instead.');
+    }
+    if (doc !== null && typeof doc === 'object') fill(doc);
+    if (!verdict(doc)) reject(data);
+    // The copy is built from the input, filling its defaults as written, as
+    // it is without a preprocess pass.
+    const out = copy(data);
+    if (!verdict(out)) {
+      throw new TypeError('parse() is not available for this value: the copy that keeps the declared properties is not one the schema accepts. Use validate() instead.');
     }
-    return copy(data);
+    return out;
   };
 }
 
@@ -1147,7 +1213,17 @@ function coldTwin (self, Validator) {
   if (t === undefined) {
     t = null;
     if (!self._interpretOnly && !self._initialized && mayExpandPast(self, COLD_MIN)) {
-      try { t = new Validator(self._rawSchema, Object.assign({}, self._options, { engine: 'interpreter' })); } catch { t = null; }
+      try {
+        t = new Validator(self._rawSchema, Object.assign({}, self._options, { engine: 'interpreter' }));
+        // The registry as it is now, not as the constructor options had it:
+        // a schema registered with addSchema() after construction is in the
+        // live map only, and a twin without it answered against the schema
+        // the registry had replaced.
+        if (self._schemaMap && self._schemaMap.size > 0) {
+          t._schemaMap = new Map(self._schemaMap);
+          t._schemaMapShared = false;
+        }
+      } catch { t = null; }
     }
     self._twin = t;
   }

package/lib/compiled-common.js

@@ -109,13 +109,20 @@ function combine(a, b) {
   };
 }
 
-// The JSON entry points under a check, as the runtime has them.
-function extendJSON(base, { check, errors }) {
+// The JSON entry points under a check, as the runtime has them. `fill` is
+// the wrapper's defaults pass, or null: the check sees the document the
+// schema checked, defaults filled, not the raw text.
+function extendJSON(base, { check, errors }, fill) {
+  const prepared = (text) => {
+    const p = parse(text);
+    if (!p.error && fill) fill(p.value);
+    return p;
+  };
   return {
     validateJSON: base.validateJSON && ((text) => {
       const res = base.validateJSON(text);
       if (!res.valid) return res;
-      const p = parse(text);
+      const p = prepared(text);
       if (p.error) return res;
       if (check(p.value)) return res;
       const e = errors(p.value);
@@ -123,7 +130,7 @@ function extendJSON(base, { check, errors }) {
     }),
     isValidJSON: (text) => {
       if (!base.isValidJSON(text)) return false;
-      const p = parse(text);
+      const p = prepared(text);
       return p.error ? true : check(p.value);
     },
   };

package/lib/compiled-standard.js

@@ -0,0 +1,33 @@
+'use strict';
+
+// bareStandard: the compiled-module wrapper for a validator that is only ever
+// handed to a Standard Schema consumer (a router's validator middleware, a
+// form library, an RPC layer) and never called by its own code. Such a
+// consumer reads `~standard` and nothing else, and an issue carries a message
+// and a path, so the wrapper is built on a module written with
+// `plainErrors: true`, whose errors are those two things in schema order, and
+// carries no error pipeline, no Standard Schema install and no extension hook.
+// The issues are the runtime's (tests/test_compiled_standard.js). A bundler
+// plugin puts this in place of `new Validator(schema)` where it sees that use.
+
+const { standardSchemaFor } = require('./standard-schema');
+
+const VALID = Object.freeze({ valid: true, errors: Object.freeze([]) });
+// When the module's error function answers valid where its verdict said no,
+// the disagreement is reported rather than turned into an acceptance.
+const VERDICT_DISAGREES = Object.freeze({ valid: false, errors: Object.freeze([Object.freeze({ keyword: 'validation', instancePath: '', schemaPath: '#', params: Object.freeze({}), message: 'schema validation failed' })]) });
+
+function bareStandard(mod, schema, useDefaults) {
+  const fill = useDefaults !== false && typeof mod.applyDefaults === 'function' ? mod.applyDefaults : null;
+  const isValid = mod.isValid;
+  const errFn = mod.validate;
+  const validate = (data) => {
+    if (fill !== null) fill(data);
+    if (isValid(data)) return VALID;
+    const r = errFn(data);
+    return r && r.valid === false ? r : VERDICT_DISAGREES;
+  };
+  return { '~standard': standardSchemaFor(null, () => schema, (_, value) => validate(value)) };
+}
+
+module.exports = { bareStandard };

package/lib/compiled-verdict.js

@@ -10,7 +10,7 @@
 const { prepare, parse, installExtension, extendJSON } = require('./compiled-common');
 
 function fromCompiledVerdict(mod, schema, options) {
-  const { isValid } = prepare(mod, schema, options, 'fromCompiledVerdict');
+  const { fill, isValid } = prepare(mod, schema, options, 'fromCompiledVerdict');
   const api = {
     isValidObject(data) {
       return isValid(data);
@@ -22,7 +22,7 @@ function fromCompiledVerdict(mod, schema, options) {
   };
   installExtension(api, schema, (base, ext) => ({
     isValidObject: (d) => base.isValidObject(d) && ext.check(d),
-    isValidJSON: extendJSON(base, ext).isValidJSON,
+    isValidJSON: extendJSON(base, ext, fill).isValidJSON,
   }));
   return api;
 }

package/lib/compiled.js

@@ -87,7 +87,7 @@ function fromCompiled(mod, schema, options) {
     },
   };
   installExtension(api, schema, (base, ext) => {
-    const json = extendJSON(base, ext);
+    const json = extendJSON(base, ext, fill);
     return {
       // The verdict is the schema's and the check's. A failure lists the
       // schema's errors, then the check's, read when somebody asks.

package/lib/data-positions.js

@@ -1,5 +1,6 @@
 'use strict';
 
+
 /**
  * Build pointer → { byteOffset, length, line, col, text } from a JSON
  * input buffer. Called only when validation fails AND richErrors is on
@@ -156,6 +157,16 @@ function buildDataPositionMap (input) {
       col: off - lineStart[line] + 1,
       text: lines[line] || '',
     };
+    // A minified document is one line, and each error carried all of it:
+    // 4000 errors on a 100 KB line serialized to 800 MB. A long line is cut
+    // to 200 characters from 60 before the value, and textCol says where the
+    // value starts in the cut text; col stays the column in the line.
+    if (entry.text.length > 200) {
+      let s = entry.col > 61 ? entry.col - 61 : 0;
+      if (s + 200 > entry.text.length) s = entry.text.length - 200;
+      entry.text = entry.text.slice(s, s + 200);
+      entry.textCol = entry.col - s;
+    }
     if (keyStarts[k] >= 0) {
       const keyLine = lineOf(keyStarts[k]);
       entry.keyOffset = keyStarts[k];
@@ -355,6 +366,13 @@ function buildTargetedPositionMap (input, wanted) {
       col: off - lineStart[line] + 1,
       text: lines[line] || '',
     };
+    // A long line is cut around the value, as in buildDataPositionMap.
+    if (entry.text.length > 200) {
+      let s = entry.col > 61 ? entry.col - 61 : 0;
+      if (s + 200 > entry.text.length) s = entry.text.length - 200;
+      entry.text = entry.text.slice(s, s + 200);
+      entry.textCol = entry.col - s;
+    }
     if (keyStarts[k] >= 0) {
       const keyLine = lineOf(keyStarts[k]);
       entry.keyOffset = keyStarts[k];

package/lib/defaults.js

@@ -23,11 +23,21 @@ 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) {
+// `keyMatcher` turns a patternProperties pattern into something with a
+// `test` method; without one the platform RegExp is used. The runtime hands
+// in the matcher validation uses (see safeKeyMatcher below), so a key that
+// makes a backtracking pattern run for seconds costs no more here than it
+// does to validate. A module written ahead of time embeds this function as
+// text and calls it without one.
+function buildDefaultsApplier(schema, keyMatcher) {
   if (typeof schema !== "object" || schema === null) return null;
-  const path = [];
-  const fn = compileNode(schema, schema, new Map(), new Map(), path);
-  return fn === null ? null : (data) => { path.length = 0; fn(data, 0, null); };
+  // `visits`: per call, the schemas already applied to each object through a
+  // `$ref` or an `allOf` member. Applying one twice to the same object fills
+  // nothing new, and following every edge of a chain such as
+  // n_i = allOf [n_(i-1), n_(i-1)] cost 2^n applications of one schema.
+  const ctx = { root: schema, memo: new Map(), reach: new Map(), path: [], res: resourceRoots(schema), match: keyMatcher || keyPattern, visits: null };
+  const fn = compileNode(schema, ctx);
+  return fn === null ? null : (data) => { ctx.path.length = 0; ctx.visits = null; fn(data, 0, null); };
 }
 
 // Write an own property. Plain assignment of a key named `__proto__` does
@@ -70,13 +80,45 @@ function localRef(root, ref) {
   return t !== null && typeof t === "object" ? t : null;
 }
 
+// For a schema that embeds other resources (a subschema with its own `$id`),
+// the resource each schema object belongs to: a fragment `$ref` inside one
+// is read against that resource, as validation reads it, not against the
+// outer root. Null when nothing is embedded, which is nearly always. An `$id`
+// that is only a fragment (`#foo`, a draft-07 anchor) starts no resource.
+// Values under `default`, `const`, `enum` and `examples` are data, not
+// schemas, and are not walked.
+function resourceRoots(root) {
+  if (root === null || typeof root !== "object") return null;
+  const map = new Map();
+  let embedded = false;
+  const walk = (node, res) => {
+    if (node === null || typeof node !== "object" || map.has(node)) return;
+    if (Array.isArray(node)) { map.set(node, res); for (let i = 0; i < node.length; i++) walk(node[i], res); return; }
+    if (node !== root && typeof node.$id === "string" && node.$id.charCodeAt(0) !== 35) { res = node; embedded = true; }
+    map.set(node, res);
+    for (const k of Object.keys(node)) {
+      if (k === "default" || k === "const" || k === "enum" || k === "examples") continue;
+      walk(node[k], res);
+    }
+  };
+  walk(root, root);
+  return embedded ? map : null;
+}
+
+// The schema a `$ref` on `node` names, read against the resource `node`
+// belongs to.
+function refTarget(root, res, node) {
+  const base = res !== null ? res.get(node) : undefined;
+  return localRef(base !== undefined ? base : root, node.$ref);
+}
+
 // 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) {
+function reachesDefault(node, root, memo, stack, res) {
   if (node === null || typeof node !== "object") return 0;
   const known = memo.get(node);
   if (known !== undefined) return known;
@@ -85,9 +127,9 @@ function reachesDefault(node, root, memo, stack) {
   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));
+  const below = props.concat(refTarget(root, res, node), 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);
+    const r = reachesDefault(below[i], root, memo, stack, res);
     if (r === 1) yes = true;
     else if (r === 2) open = true;
   }
@@ -119,10 +161,11 @@ function copyOf(v) {
 // 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) {
+function compileNode(node, ctx) {
   if (node === null || typeof node !== "object") return null;
+  const memo = ctx.memo, path = ctx.path;
   if (memo.has(node)) return memo.get(node);
-  if (reachesDefault(node, root, reach, new Set()) !== 1) { memo.set(node, null); return null; }
+  if (reachesDefault(node, ctx.root, ctx.reach, new Set(), ctx.res) !== 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
@@ -133,6 +176,16 @@ function compileNode(node, root, memo, reach, path) {
   // schema, and Renovate's took this pass to the heap limit.
   const fn = (data, depth, made) => {
     if (depth > MAX_DEPTH) return;
+    // Only what is applied through a `$ref` or `allOf` is counted (fn.shared,
+    // set below), and only outside a made value, where every application
+    // does the same work.
+    if (fn.shared === true && made === null && typeof data === "object" && data !== null) {
+      const visits = ctx.visits || (ctx.visits = new Map());
+      let done = visits.get(data);
+      if (done === undefined) visits.set(data, (done = new Set()));
+      if (done.has(node)) return;
+      done.add(node);
+    }
     if (made !== null) {
       if (made.has(node)) return;
       made.add(node);
@@ -154,31 +207,31 @@ function compileNode(node, root, memo, reach, path) {
       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);
+      const child = compileNode(p, ctx);
       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);
+  const tuple = Array.isArray(node.prefixItems) ? node.prefixItems.map((s) => compileNode(s, ctx)) : [];
+  const each = compileNode(node.items, ctx);
   // 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);
+      const re = ctx.match(src);
+      const t = compileNode(node.patternProperties[src], ctx);
       if (re === null) continue;
       patterns.push([re, t]);
     }
   }
-  const extra = compileNode(node.additionalProperties, root, memo, reach, path);
+  const extra = compileNode(node.additionalProperties, ctx);
   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);
+      const t = compileNode(node.dependentSchemas[key], ctx);
       if (t !== null) dependent.push([key, t]);
     }
   }
@@ -186,19 +239,22 @@ function compileNode(node, root, memo, reach, path) {
 
   const also = [];
   if (typeof node.$ref === "string") {
-    const t = compileNode(localRef(root, node.$ref), root, memo, reach, path);
-    if (t !== null) also.push(t);
+    const t = compileNode(refTarget(ctx.root, ctx.res, node), ctx);
+    if (t !== null) { t.shared = true; 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);
+      const t = compileNode(s, ctx);
+      if (t !== null) { t.shared = true; also.push(t); }
     }
   }
 
   body = (data, depth, made) => {
+    // A value that is not an object has nothing to fill, here or in any
+    // schema applied to it.
+    if (typeof data !== "object" || data === null) return;
     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)) {
@@ -240,6 +296,28 @@ function compileNode(node, root, memo, reach, path) {
 
 // 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'];
+const EMBED = ['buildDefaultsApplier', 'setOwn', 'localRef', 'resourceRoots', 'refTarget', 'reachesDefault', 'valuesOf', 'listOf', 'keyPattern', 'copyOf', 'compileNode'];
+
+// patternProperties keys tested in linear time: the linear-time engine
+// (lib/safe-regex.js, which validation uses for these patterns too) for a
+// pattern in its subset, the platform RegExp otherwise, as validation does.
+// A key that makes a backtracking pattern run for seconds then costs no more
+// here than it does to validate. lib/js-compiler.js also hands patterns the
+// RegExp runs in linear time to the RegExp, for speed; that check is left
+// out here so the closure pass, which lite carries, does not pull it in.
+// Loaded on the first pattern; most schemas have none.
+const PROP_ESCAPE = /\\[pP]\{/;
+function safeKeyMatcher(src) {
+  if (!PROP_ESCAPE.test(src)) {
+    try {
+      const safe = require("./safe-regex");
+      if (safe.patternIsSafe(src)) return safe.compileSafe(src);
+    } catch {}
+  }
+  return keyPattern(src);
+}
 
-module.exports = { buildDefaultsApplier, setOwn, localRef, MAX_DEPTH, EMBED };
+module.exports = {
+  buildDefaultsApplier: (schema) => buildDefaultsApplier(schema, safeKeyMatcher),
+  setOwn, localRef, resourceRoots, refTarget, safeKeyMatcher, MAX_DEPTH, EMBED,
+};

package/lib/describe-schema.js

@@ -26,6 +26,10 @@
 // $defs. Anything else is described as `any` rather than guessed at.
 
 const MAX_DEPTH = 12;
+// anyOf branches that each lead to the same next definition describe
+// width^layers lines, 16 million for 4 wide and 12 deep. A prompt has no use
+// for more than this; past it the description stops and says so.
+const MAX_LINES = 2000;
 
 function lit (v) {
   try { return JSON.stringify(v); } catch (_) { return String(v); }
@@ -95,6 +99,7 @@ function describeObjectBody (schema, depth, defs, lines) {
 }
 
 function describeNode (schema, label, depth, defs, lines) {
+  if (lines.length >= MAX_LINES) return;
   const pad = '  '.repeat(depth);
   if (schema === true || schema === undefined) { lines.push(`${pad}${label}: any`); return; }
   if (schema === false) { lines.push(`${pad}${label}: nothing is allowed here`); return; }
@@ -103,19 +108,43 @@ function describeNode (schema, label, depth, defs, lines) {
     return;
   }
 
-  const target = schema.$ref ? resolveRef(schema, defs) : null;
-  if (target) { describeNode(target, label, depth, defs, lines); return; }
+  // A chain of references is followed here, each definition once: one that
+  // leads back to itself without a property in between describes no value.
+  let target = schema.$ref ? resolveRef(schema, defs) : null;
+  if (target) {
+    const chain = new Set([schema]);
+    while (target && typeof target === 'object' && target.$ref && !chain.has(target)) {
+      chain.add(target);
+      const next = resolveRef(target, defs);
+      if (!next) break;
+      target = next;
+    }
+    if (chain.has(target)) { lines.push(`${pad}${label}: any`); return; }
+    describeNode(target, label, depth, defs, lines);
+    return;
+  }
 
-  // allOf is the intersection, so its parts describe the same value.
+  // allOf is the intersection, so its parts describe the same value. The
+  // parts' own allOf are merged in the same pass, each schema once: a part
+  // that led back to this schema copied its allOf back in and the merge
+  // recursed until the stack ran out.
   if (Array.isArray(schema.allOf) && schema.allOf.length) {
     const merged = Object.assign({}, schema);
     delete merged.allOf;
-    for (const part of schema.allOf) {
+    const seen = new Set([schema]);
+    const queue = schema.allOf.slice();
+    while (queue.length) {
+      const part = queue.shift();
       const resolved = part && part.$ref ? resolveRef(part, defs) || part : part;
-      if (resolved && typeof resolved === 'object') Object.assign(merged, resolved, {
+      if (!resolved || typeof resolved !== 'object' || seen.has(resolved)) continue;
+      seen.add(resolved);
+      if (Array.isArray(resolved.allOf)) queue.push(...resolved.allOf);
+      Object.assign(merged, resolved, {
         properties: Object.assign({}, merged.properties, resolved.properties),
         required: [].concat(merged.required || [], resolved.required || []),
       });
+      delete merged.allOf;
+      if (resolved.$ref !== undefined && resolved !== part) delete merged.$ref;
     }
     if (!merged.properties) delete merged.properties;
     if (!merged.required || !merged.required.length) delete merged.required;
@@ -170,6 +199,10 @@ function describeSchema (schema, opts) {
   const defs = (schema && (schema.$defs || schema.definitions)) || null;
   const lines = [];
   describeNode(schema, name, 0, defs, lines);
+  if (lines.length >= MAX_LINES) {
+    lines.length = MAX_LINES;
+    lines.push(`(description cut at ${MAX_LINES} lines)`);
+  }
   return lines.join('\n');
 }