ata-validator 1.61.3 → 1.62.0

package/lib/clone-emit.js

@@ -50,6 +50,12 @@ 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 };
+  // A schema that embeds another resource (a subschema with its own `$id`)
+  // reads a fragment `$ref` inside it against that resource, not against
+  // this root, so the pointer resolved here could name a different schema
+  // from the one validation applies. No $ref is inlined there; emitClone
+  // then declines the $ref as it stands.
+  if (embedsResource(root, root, new Set())) return root;
   // 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
@@ -90,11 +96,83 @@ function inlineRefsForClone(root) {
   return walk(root, new Set(), false);
 }
 
+function embedsResource(node, root, seen) {
+  if (!node || typeof node !== 'object' || seen.has(node)) return false;
+  seen.add(node);
+  if (Array.isArray(node)) return node.some((n) => embedsResource(n, root, seen));
+  if (node !== root && typeof node.$id === 'string' && !node.$id.startsWith('#')) return true;
+  for (const k of Object.keys(node)) {
+    if (_INLINE_DATA_KEYS.has(k)) continue;
+    if (embedsResource(node[k], root, seen)) return true;
+  }
+  return false;
+}
+
+// The names a node requires through itself and the in-place applicators
+// below it (allOf, anyOf, oneOf, if, then, else, dependentRequired and the
+// array form of dependencies). Every one has to be a declared property, or
+// the copy, which keeps only declared keys, drops a key the schema demands
+// and hands back a value validate() refuses. `not` is left out: a name
+// required under it is one the value must not carry. Returns false where
+// the walk cannot tell: dependentSchemas, the schema form of dependencies,
+// or a $ref inside an applicator.
+function requiredNames(node, out, depth) {
+  if (!node || typeof node !== 'object' || Array.isArray(node)) return true;
+  if (depth > 16) return false;
+  if (depth > 0 && node.$ref !== undefined) return false;
+  if (node.dependentSchemas !== undefined) return false;
+  if (Array.isArray(node.required)) for (const n of node.required) out.add(n);
+  if (node.dependentRequired && typeof node.dependentRequired === 'object') {
+    for (const k of Object.keys(node.dependentRequired)) {
+      out.add(k);
+      const list = node.dependentRequired[k];
+      if (Array.isArray(list)) for (const n of list) out.add(n);
+    }
+  }
+  if (node.dependencies !== undefined) {
+    if (!node.dependencies || typeof node.dependencies !== 'object') return false;
+    for (const k of Object.keys(node.dependencies)) {
+      const v = node.dependencies[k];
+      if (!Array.isArray(v)) return false;
+      out.add(k);
+      for (const n of v) out.add(n);
+    }
+  }
+  for (const k of ['allOf', 'anyOf', 'oneOf']) {
+    if (node[k] === undefined) continue;
+    if (!Array.isArray(node[k])) return false;
+    for (const b of node[k]) if (!requiredNames(b, out, depth + 1)) return false;
+  }
+  for (const k of ['if', 'then', 'else']) {
+    if (node[k] !== undefined && !requiredNames(node[k], out, depth + 1)) return false;
+  }
+  return true;
+}
+
+// The source budget for default values written into one copy. A shared
+// definition is inlined at every $ref to it, and its default with it: 200
+// references to a 50 KB default made 10 MB of source. Past the budget the
+// copy declines, as it does for anything else it cannot do well.
+const DEFAULT_SOURCE_BUDGET = 256 * 1024;
+
+// A default as source that builds it fresh on every parse. An object literal
+// reads a "__proto__" key as the prototype slot, so a default holding one (an
+// own key, as JSON.parse writes it) is rebuilt by JSON.parse from its text:
+// as a literal, the filled value had no such key and inherited from the
+// default's inner object. Null past the source budget.
+function defaultSource(v, budget) {
+  const text = JSON.stringify(v);
+  const src = v !== null && typeof v === 'object' && text.includes('"__proto__"') ? `JSON.parse(${JSON.stringify(text)})` : text;
+  budget.left -= src.length;
+  return budget.left < 0 ? null : src;
+}
+
 const PROTO_KEY_NAMES = new Set([...Object.getOwnPropertyNames(Object.prototype), '__proto__']);
 
-function emitClone(node, access, depth) {
+function emitClone(node, access, depth, budget) {
   if (!node || typeof node !== 'object') return null;
   if (depth > 12) return null;
+  if (budget === undefined) budget = { left: DEFAULT_SOURCE_BUDGET };
   // Only plain object nodes are cloneable, and only when the schema names
   // every property it keeps. A $ref means the set of allowed keys is not
   // this node's to decide. In-place applicators (allOf, anyOf, oneOf,
@@ -151,6 +229,13 @@ function emitClone(node, access, depth) {
     for (const n of names) if (!Object.prototype.hasOwnProperty.call(node.properties, n)) return null;
   }
   const required = new Set(Array.isArray(node.required) ? node.required : []);
+  // Outside the record shape, where every key is kept, every name the
+  // schema requires must be one the copy keeps.
+  if (!apSchema) {
+    const demanded = new Set();
+    if (!requiredNames(node, demanded, 0)) return null;
+    for (const n of demanded) if (!node.properties || !Object.prototype.hasOwnProperty.call(node.properties, n)) return null;
+  }
 
   const fixed = [];
   const conditional = [];
@@ -174,7 +259,7 @@ function emitClone(node, access, depth) {
       if (!probe || !probe(prop.default)) return null;
     }
     const read = `${access}[${JSON.stringify(key)}]`;
-    const value = emitValueExpr(prop, read, depth);
+    const value = emitValueExpr(prop, read, depth, budget);
     if (value === null) return null;
     // A plain `"__proto__":` in an object literal is the prototype slot, not
     // a property; `["__proto__"]:` is a property. Only that key is written as
@@ -197,7 +282,7 @@ function emitClone(node, access, depth) {
   if (apSchema) {
     const kVar = `_k${depth}`;
     const vVar = `_v${depth}`;
-    const valueExpr = emitValueExpr(apSchema, vVar, depth);
+    const valueExpr = emitValueExpr(apSchema, vVar, depth, budget);
     if (valueExpr === null) return null;
     let skip = '';
     let declSet = '';
@@ -217,8 +302,15 @@ function emitClone(node, access, depth) {
   if (conditional.length === 0 && !recordLoop) return literal;
   // Optional properties are added only when present, so the result never
   // gains a key the input did not have.
+  const dfltSrc = [];
+  for (const c of conditional) {
+    if (c.dflt === undefined) { dfltSrc.push(null); continue; }
+    const src = defaultSource(c.dflt, budget);
+    if (src === null) return null;
+    dfltSrc.push(src);
+  }
   const adds = conditional
-    .map(({ key, value, dflt }) => {
+    .map(({ key, value, dflt }, i) => {
       // Object.hasOwn, not `in`: `in` also answers for what the instance
       // inherits, so a property named `constructor` would copy the inherited
       // function into the output that validate().data does not carry. And a
@@ -235,12 +327,12 @@ function emitClone(node, access, depth) {
         ? `Object.prototype.hasOwnProperty.call(${access}, ${k})`
         : `(${k} in ${access} && (${access}.__proto__ === Object.prototype || Object.prototype.hasOwnProperty.call(${access}, ${k})))`;
       const set = `if (${own}) ${assign}`;
-      // The default is emitted as a literal inside the call, so an object or
+      // The default is emitted as source inside the call, so an object or
       // array default is a fresh value on every parse, never shared state.
       if (dflt === undefined) return set;
       const setDflt = key === '__proto__'
-        ? `Object.defineProperty(${tmp}, ${JSON.stringify(key)}, { value: ${JSON.stringify(dflt)}, writable: true, enumerable: true, configurable: true });`
-        : `${tmp}[${JSON.stringify(key)}] = ${JSON.stringify(dflt)};`;
+        ? `Object.defineProperty(${tmp}, ${JSON.stringify(key)}, { value: ${dfltSrc[i]}, writable: true, enumerable: true, configurable: true });`
+        : `${tmp}[${JSON.stringify(key)}] = ${dfltSrc[i]};`;
       return `${set} else ${setDflt}`;
     })
     .join(' ');
@@ -278,9 +370,22 @@ function isPrimitiveOnly(s) {
   return false;
 }
 
-function emitValueExpr(prop, read, depth) {
+function emitValueExpr(prop, read, depth, budget) {
   if (!prop || typeof prop !== 'object') return null;
   if (prop.$ref) return null;
+  // Positions named by prefixItems (or the array form of items, which
+  // normalization turns into prefixItems) each have their own schema, and
+  // copying them all with the strategy for `items` handed back an object in
+  // a prefix slot as the input's own reference, its undeclared keys kept.
+  // A tuple of primitives, with nothing or primitives after it, has nowhere
+  // to hide a key, and is copied as a fresh array like any other.
+  if (prop.prefixItems !== undefined || Array.isArray(prop.items)) {
+    const tuple = Array.isArray(prop.prefixItems) ? prop.prefixItems : prop.items;
+    const rest = Array.isArray(prop.items) ? prop.additionalItems : prop.items;
+    if (prop.type === 'array' && Array.isArray(tuple) && tuple.every(isPrimitiveOnly) &&
+        (rest === false || (rest !== undefined && isPrimitiveOnly(rest)))) return `${read}.slice()`;
+    return null;
+  }
   if (isPrimitiveOnly(prop)) return read;
   // A value checked with `instanceof` (the keyword @ata-project/keywords adds)
   // is an instance of a class, such as a Date, not a JSON object whose keys
@@ -290,7 +395,7 @@ function emitValueExpr(prop, read, depth) {
   const isRecordable = (s) => s.properties ||
     (s.additionalProperties && typeof s.additionalProperties === 'object');
   if (prop.type === 'object' && isRecordable(prop)) {
-    return emitClone(prop, read, depth + 1);
+    return emitClone(prop, read, depth + 1, budget);
   }
   if (prop.type === 'array' && prop.items && typeof prop.items === 'object' &&
       !Array.isArray(prop.items)) {
@@ -300,7 +405,7 @@ function emitValueExpr(prop, read, depth) {
     if (isPrimitiveOnly(it)) return `${read}.slice()`;
     if (it.type === 'object' && isRecordable(it)) {
       const el = '_e' + depth;
-      const inner = emitClone(it, el, depth + 1);
+      const inner = emitClone(it, el, depth + 1, budget);
       if (!inner) return null;
       return `${read}.map((${el}) => (${inner}))`;
     }

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