ata-validator 1.19.0 → 1.20.0

package/index.js

@@ -1461,9 +1461,18 @@ class Validator {
       });
       this._engine = 'interpreter';
       if (!preprocess) this._fastVerdict = (d) => interp.isValid(d);
-      const run = preprocess
-        ? (data) => { preprocess(data); return interp.validate(data); }
-        : (data) => interp.validate(data);
+      // 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
+      // without code generation. Taking the verdict path here also skips
+      // building the errors the caller said it did not want.
+      const run = options.abortEarly
+        ? (preprocess
+            ? (data) => { preprocess(data); return interp.isValid(data) ? VALID_RESULT : ABORT_EARLY_RESULT; }
+            : (data) => (interp.isValid(data) ? VALID_RESULT : ABORT_EARLY_RESULT))
+        : (preprocess
+            ? (data) => { preprocess(data); return interp.validate(data); }
+            : (data) => interp.validate(data));
       this.validate = run;
       this.isValidObject = this._fastVerdict
         ? this._fastVerdict
@@ -2039,6 +2048,7 @@ function compile(schema, opts) {
 const { toTypeScript } = require("./lib/ts-gen");
 const { renderPretty } = require("./lib/render-pretty");
 const { renderCompact } = require("./lib/render-compact");
+const { toOutput } = require("./lib/output-format");
 const { renderJSON } = require("./lib/render-json");
 const { suggestFor } = require("./lib/suggestions");
 const { reprValue } = require("./lib/enrich-error");
@@ -2212,7 +2222,12 @@ _defineLazyMethod('isValidObject', (self) => (data) => {
       return r;
     };
   } else {
-    self._ensureCodegen();
+    // `new Function` is a property of the realm, not of the schema: under a
+    // strict CSP or `--disallow-code-generation-from-strings` this throws
+    // rather than declining, and the EvalError reached the caller of a verdict
+    // method. The full compile can answer without code generation, so fall
+    // through to it. The tier-0 branch above already guarded its own call.
+    try { self._ensureCodegen(); } catch { /* no codegen in this realm */ }
     // Codegen can bail on shapes it cannot represent; the full compile
     // binds the native path or the unsupported thrower instead of
     // leaving this stub to re-dispatch to itself.
@@ -2263,6 +2278,7 @@ module.exports = {
   defineSchema,
   renderPretty,
   renderCompact,
+  toOutput,
   renderJSON,
   attachSuggestions, // internal: used by the renderers; not public API
 };

package/lib/aot-impl.js

@@ -54,13 +54,26 @@ function safeRePrelude(...fns) {
   return fns.some((f) => f && f._usesSafeRe) ? getSafeRegexEmbed() + '\n' : '';
 }
 
+// A validator can enforce more than its schema says. `withKeywords` from
+// @ata-project/keywords wraps an instance's entry points, and a wrapper
+// declares that by setting `_externalChecks`. The emitters below build their
+// module from the compiled schema alone, so a wrapped instance would emit a
+// module that accepts documents the validator itself rejects. Refuse instead.
+// Declining to compile is recoverable. A module that wrongly accepts is not.
+function assertEmittable(validator, fnName) {
+  if (validator._usesKeywords) {
+    throw new Error(fnName + ': a schema that uses custom keywords cannot be compiled into a standalone module (option "keywords")');
+  }
+  if (validator._externalChecks) {
+    throw new Error(fnName + ': this validator enforces checks that are not in its schema, so a standalone module would be weaker than the validator it came from. Those checks come from a wrapper such as withKeywords() from @ata-project/keywords, and JSON Schema has no spelling for them. Compile the unwrapped validator if the extra checks are not needed.');
+  }
+}
+
 // --- Standalone pre-compilation ---
 // Generate a JS module string that can be written to a file.
 // On next startup, load with Validator.fromStandalone() -- zero compile time.
 function toStandalone(validator) {
-  if (validator._usesKeywords) {
-    throw new Error('toStandalone: a schema that uses custom keywords cannot be compiled into a standalone module (option "keywords")');
-  }
+  assertEmittable(validator, 'toStandalone');
   validator._ensureCompiled();
   const jsFn = validator._jsFn;
   if (!jsFn || !jsFn._source) return null;
@@ -233,9 +246,7 @@ function emitClone(node, access, depth) {
 }
 
 function toStandaloneModule(validator, opts) {
-  if (validator._usesKeywords) {
-    throw new Error('toStandaloneModule: a schema that uses custom keywords cannot be compiled into a standalone module (option "keywords")');
-  }
+  assertEmittable(validator, 'toStandaloneModule');
   validator._ensureCompiled();
   const jsFn = validator._jsFn;
   if (!jsFn || !jsFn._source) return null;
@@ -299,10 +310,39 @@ function toStandaloneModule(validator, opts) {
     if (lines.length) closureDecls = lines.join('\n') + '\n';
   }
 
+  // A few helpers are self-contained and named the same wherever they appear,
+  // the email check being the big one at about 2.7 KB. The boolean function
+  // and the error function each hoisted their own copy, so every module that
+  // used a format carried it twice. They are declared once at module scope
+  // here and removed from both bodies. Everything else in the preamble stays
+  // where it is: emitConstant and the generated branch checks name things per
+  // compilation, and two of them at module scope would collide.
+  const sharedDecls = [];
+  {
+    const seen = new Set();
+    for (const fn of [jsFn, jsErrFn]) {
+      if (!fn || !fn._sharedHelpers) continue;
+      for (const h of fn._sharedHelpers) if (!seen.has(h)) { seen.add(h); sharedDecls.push(h); }
+    }
+    if (sharedDecls.length && errCore) {
+      for (const h of sharedDecls) errCore = errCore.split(h).join('');
+    }
+  }
+  const sharedBlock = sharedDecls.length ? sharedDecls.join('\n') + '\n' : '';
+
   // Hoisted oneOf/anyOf branch checks live in the boolean fn's preamble (the
   // runtime emits them before the function). The standalone module must declare
   // them at module scope too, or _fn references undefined names (e.g. _af1_b0).
-  const preambleDecls = jsFn._preambleSource ? jsFn._preambleSource + '\n' : '';
+  const sharedSet = new Set(sharedDecls);
+  const preambleParts = jsFn._preambleParts
+    ? jsFn._preambleParts.filter((part) => !sharedSet.has(part))
+    : null;
+  const preambleBody = preambleParts !== null
+    ? (preambleParts.length ? preambleParts.join('\n  ') + '\n  ' : '')
+    : (jsFn._preambleSource || '');
+  const preambleDecls = preambleBody || (jsFn._preambleGuard || '')
+    ? (jsFn._preambleParts ? (jsFn._preambleGuard || '') + preambleBody : preambleBody) + '\n'
+    : '';
 
   // User-supplied format functions are referenced as _uf_<name> by both the
   // boolean (_fn) and error (errFn) bodies. Embed them via Function#toString
@@ -353,7 +393,7 @@ const ABORT = Object.freeze({
     path: '',
   })]),
 });
-${closureDecls}${preambleDecls}${formatDecls}const _fn = function(d) {
+${closureDecls}${sharedBlock}${preambleDecls}${formatDecls}const _fn = function(d) {
   ${src}
 };
 ${errCore}function isValid(data) { return _fn(data); }
@@ -404,11 +444,14 @@ function bundleStandalone(Validator, schemas, opts) {
   const R = 'Object.freeze({valid:true,errors:Object.freeze([])})';
   let bundleUsesSafeRe = false;
   let bundleInjects = false;
-  const fns = schemas.map((schema) => {
+  // Pass one compiles; pass two emits. The helpers that several schemas hoist
+  // are the same text declaring the same name, so the bundle keeps one copy at
+  // module scope, and pass two needs to know the set before it writes anything.
+  const compiledEntries = schemas.map((schema) => {
     const v = new Validator(schema, bundleOpts);
     v._ensureCompiled();
     const jsFn = v._jsFn;
-    if (!jsFn || !jsFn._hybridSource) return 'null';
+    if (!jsFn || !jsFn._hybridSource) return null;
     // The schema the validator compiled, not the one the caller passed. They
     // differ whenever anything prepared the schema: draft-07 normalization,
     // `format` removed under assertFormat: false, keywords outside the
@@ -420,10 +463,30 @@ function bundleStandalone(Validator, schemas, opts) {
       v._userFormats,
     );
     if (jsFn._usesSafeRe || (jsErrFn && jsErrFn._usesSafeRe)) bundleUsesSafeRe = true;
-    const errBody =
+    return { v, jsFn, jsErrFn };
+  });
+
+  const sharedDecls = [];
+  {
+    const seen = new Set();
+    for (const e of compiledEntries) {
+      if (!e) continue;
+      for (const fn of [e.jsFn, e.jsErrFn]) {
+        if (!fn || !fn._sharedHelpers) continue;
+        for (const h of fn._sharedHelpers) if (!seen.has(h)) { seen.add(h); sharedDecls.push(h); }
+      }
+    }
+  }
+  const sharedSet = new Set(sharedDecls);
+
+  const fns = compiledEntries.map((e) => {
+    if (!e) return 'null';
+    const { v, jsFn, jsErrFn } = e;
+    let errBody =
       jsErrFn && jsErrFn._errSource
         ? jsErrFn._errSource
         : "return{valid:false,errors:[{code:'error',path:'',message:'validation failed'}]}";
+    for (const h of sharedDecls) errBody = errBody.split(h).join('');
     // Custom format closures: embedded, or bound to the bundle-level
     // registry when opts.formats is 'inject'.
     let preamble = '';
@@ -433,11 +496,14 @@ function bundleStandalone(Validator, schemas, opts) {
       if (f.exportsSetFormats) bundleInjects = true;
     }
     // Include hoisted anyOf/oneOf branch helpers (e.g. `_af1_b0`) so the
-    // bundle output is self-contained. `toStandalone` emits this same source
-    // for single-schema standalone output.
-    if (jsFn._preambleSource) {
-      preamble = preamble ? `${preamble}\n${jsFn._preambleSource}` : jsFn._preambleSource;
-    }
+    // bundle output is self-contained, minus anything lifted to module scope.
+    const kept = jsFn._preambleParts
+      ? jsFn._preambleParts.filter((part) => !sharedSet.has(part))
+      : null;
+    const preambleSrc = kept !== null
+      ? (jsFn._preambleGuard || '') + (kept.length ? kept.join('\n  ') + '\n  ' : '')
+      : (jsFn._preambleSource || '');
+    if (preambleSrc) preamble = preamble ? `${preamble}\n${preambleSrc}` : preambleSrc;
     if (opts && opts.verbose) {
       // Embed the schema and a small resolver so errors carry parentSchema.
       const schemaLit = JSON.stringify(v._schemaObj);
@@ -446,7 +512,8 @@ function bundleStandalone(Validator, schemas, opts) {
     return `(function(R){${preamble}var E=function(d){var _all=true;${errBody}};return function(d){${jsFn._hybridSource}}})(R)`;
   });
   const arr = `[${fns.join(',')}]`;
-  const safeEmbed = bundleUsesSafeRe ? getSafeRegexEmbed() + '\n' : '';
+  const safeEmbed = (bundleUsesSafeRe ? getSafeRegexEmbed() + '\n' : '') +
+    (sharedDecls.length ? sharedDecls.join('\n') + '\n' : '');
   const registry = bundleInjects
     ? `var __formats=Object.create(null);\nfunction setFormats(map){for(var k in map)__formats[k]=map[k]}\n`
     : '';
@@ -489,16 +556,43 @@ function bundleCompact(Validator, schemas, opts) {
     // Hoisted anyOf/oneOf branch helpers (e.g. `_af1_b0`) must travel with the
     // hybrid body or it references undefined names. Prepending keeps dedup honest:
     // schemas with different branch sets no longer collide on body alone.
-    const hybrid = jsFn._preambleSource
-      ? `${jsFn._preambleSource}\n${jsFn._hybridSource}`
-      : jsFn._hybridSource;
     return {
-      hybrid,
+      guard: jsFn._preambleGuard || '',
+      parts: jsFn._preambleParts || null,
+      preamble: jsFn._preambleSource || '',
+      hybridBody: jsFn._hybridSource,
       err: jsErrFn && jsErrFn._errSource ? jsErrFn._errSource : null,
       fmt: jsFn._formatClosures || null,
+      shared: [
+        ...(jsFn._sharedHelpers || []),
+        ...((jsErrFn && jsErrFn._sharedHelpers) || []),
+      ],
     };
   });
 
+  // A helper hoisted by several schemas is the same text declaring the same
+  // name, so the bundle holds one copy at module scope rather than one per
+  // schema. The rest of each preamble stays with its schema: those names are
+  // per compilation and would collide.
+  const sharedDecls = [];
+  {
+    const seen = new Set();
+    for (const e of entries) {
+      if (!e) continue;
+      for (const h of e.shared) if (!seen.has(h)) { seen.add(h); sharedDecls.push(h); }
+    }
+  }
+  const sharedSet = new Set(sharedDecls);
+  for (const e of entries) {
+    if (!e) continue;
+    const kept = e.parts ? e.parts.filter((part) => !sharedSet.has(part)) : null;
+    const preamble = kept !== null
+      ? e.guard + (kept.length ? kept.join('\n  ') + '\n  ' : '')
+      : e.preamble;
+    e.hybrid = preamble ? `${preamble}\n${e.hybridBody}` : e.hybridBody;
+    if (e.err) for (const h of sharedDecls) e.err = e.err.split(h).join('');
+  }
+
   // Deduplicate function bodies — many schemas produce identical or near-identical code
   const bodyMap = new Map(); // body → index
   const bodies = [];
@@ -531,6 +625,7 @@ function bundleCompact(Validator, schemas, opts) {
     ? '// Auto-generated by ata-validator — do not edit\n'
     : "'use strict';\n";
   if (bundleUsesSafeRe) out += getSafeRegexEmbed() + '\n';
+  if (sharedDecls.length) out += sharedDecls.join('\n') + '\n';
   const declKW = isEsm ? 'const' : 'var';
   out += `${declKW} R=Object.freeze({valid:true,errors:Object.freeze([])});\n`;
 

package/lib/branch-collapse.js

@@ -1,6 +1,23 @@
 'use strict';
 
-const SEVERITY = {
+// Branch collapse: when no branch of an anyOf or oneOf matches, listing every
+// branch's errors tells a reader that nothing fit without telling them which
+// branch they meant. This scores the branches, reports the one that came
+// closest, and keeps its errors under `branchErrors` for the pretty renderer.
+//
+// There is one implementation, and it is `__ataCollapse` below. A standalone
+// module imports nothing, so the generated code cannot require this file; it
+// carries a copy emitted by `embedSource()` from these very functions instead
+// of a second hand-written one. That is why the internals are written in the
+// positional form the generated code calls, and why `__ataCollapse` may close
+// over nothing but `__ataScore` and the severity table: whatever it reaches
+// has to be in the embed too.
+
+// How much a failing keyword says about intent. A branch that fails on `type`
+// was probably not the branch the author meant; one that fails on `minLength`
+// probably was, and is the better thing to show. The error count dominates, so
+// a branch with one complaint always beats a branch with three.
+const __ATA_SEVERITY = {
   type: 10,
   const: 8,
   enum: 8,
@@ -15,61 +32,69 @@ const SEVERITY = {
   unevaluatedProperties: 2,
   unevaluatedItems: 2,
 };
-const DEFAULT_SEVERITY = 4;
 
-function scoreBranch (errors) {
-  if (!errors || errors.length === 0) return 0;
-  let sum = 0;
-  for (const e of errors) sum += SEVERITY[e.keyword] || DEFAULT_SEVERITY;
-  return errors.length * 100 + sum; // primary: count, secondary: severity
+function __ataScore (errs) {
+  if (!errs || !errs.length) return 0;
+  let s = 0;
+  for (const e of errs) s += __ATA_SEVERITY[e.keyword] || 4;
+  return errs.length * 100 + s; // primary: count, secondary: severity
 }
 
-/**
- * Given an array of branch result objects ({ valid, errors }) for a oneOf
- * or anyOf, pick the best branch and emit a single user-facing error.
- *
- * @param keyword 'oneOf' | 'anyOf'
- * @param branchResults Array<{ valid, errors, title? }>
- * @param parentPath JSON pointer to the data location
- * @param parentSchemaPath JSON pointer to the keyword in the schema
- * @returns A ValidationError-shaped object, or null if branch passed (caller treats as success).
- */
-function collapseBranches ({ keyword, branchResults, parentPath, parentSchemaPath }) {
-  const passing = branchResults.filter(b => b.valid);
-  if (keyword === 'oneOf') {
-    if (passing.length === 1) return null;
-    if (passing.length > 1) {
+// `br` is one entry per branch in declaration order: {valid, errors, title}.
+// Returns the single error to report, or null when the keyword is satisfied.
+function __ataCollapse (kw, br, pp, sp, o) {
+  const pass = br.filter((b) => b.valid);
+  if (kw === 'oneOf') {
+    if (pass.length === 1) return null;
+    if (pass.length > 1) {
+      const passIdx = [];
+      for (let i = 0; i < br.length; i++) if (br[i].valid) passIdx.push(i);
       return {
-        code: 'ATA4002', keyword: 'oneOf', path: parentPath || '',
-        message: `value matched ${passing.length} of ${branchResults.length} oneOf variants, expected exactly one`,
-        schemaPath: parentSchemaPath,
-        params: { matched: passing.length, total: branchResults.length },
+        code: 'ATA4002',
+        keyword: 'oneOf',
+        instancePath: pp || '',
+        path: pp || '',
+        schemaPath: sp,
+        _o: o,
+        message: 'value matched ' + pass.length + ' of ' + br.length + ' oneOf variants, expected exactly one',
+        params: { passingSchemas: passIdx },
       };
     }
-    // 0 matched, find best
-    return buildBranchError('ATA4001', 'oneOf', branchResults, parentPath, parentSchemaPath);
+  } else if (pass.length >= 1) {
+    return null;
   }
-  // anyOf
-  if (passing.length >= 1) return null;
-  return buildBranchError('ATA4003', 'anyOf', branchResults, parentPath, parentSchemaPath);
-}
-
-function buildBranchError (code, keyword, branchResults, parentPath, parentSchemaPath) {
-  let bestIdx = 0;
-  let bestScore = Infinity;
-  for (let i = 0; i < branchResults.length; i++) {
-    const s = scoreBranch(branchResults[i].errors);
-    if (s < bestScore) { bestScore = s; bestIdx = i; }
+  let bi = 0;
+  let bs = Infinity;
+  for (let i = 0; i < br.length; i++) {
+    const s = __ataScore(br[i].errors);
+    if (s < bs) { bs = s; bi = i; }
   }
-  const best = branchResults[bestIdx];
-  const variantName = best.title || `variant ${bestIdx + 1}`;
+  const best = br[bi];
   return {
-    code, keyword, path: parentPath || '',
-    message: `value matched 0 of ${branchResults.length} ${keyword} variants`,
-    schemaPath: parentSchemaPath,
-    params: { variants: branchResults.length, closest: bestIdx, closestName: variantName },
-    branchErrors: best.errors, // surfaced in pretty render
+    code: kw === 'oneOf' ? 'ATA4001' : 'ATA4003',
+    keyword: kw,
+    instancePath: pp || '',
+    path: pp || '',
+    schemaPath: sp,
+    _o: o,
+    message: 'value matched 0 of ' + br.length + ' ' + kw + ' variants',
+    params: { variants: br.length, closest: bi, closestName: best.title || ('variant ' + (bi + 1)) },
+    branchErrors: best.errors,
   };
 }
 
-module.exports = { collapseBranches, scoreBranch, SEVERITY };
+// The named-argument form the interpreter and the tests call.
+function collapseBranches ({ keyword, branchResults, parentPath, parentSchemaPath, ordinal }) {
+  return __ataCollapse(keyword, branchResults, parentPath, parentSchemaPath, ordinal === undefined ? null : ordinal);
+}
+
+// The three declarations as source, for the generated code to carry. Derived
+// from the functions above rather than written out again, so a fix to one
+// cannot miss the other. `tests/test_branch_collapse.js` runs both.
+function embedSource () {
+  return 'const __ATA_SEVERITY=' + JSON.stringify(__ATA_SEVERITY) + ';' +
+    'const __ataScore=' + __ataScore.toString() + ';' +
+    'const __ataCollapse=' + __ataCollapse.toString() + ';';
+}
+
+module.exports = { collapseBranches, scoreBranch: __ataScore, SEVERITY: __ATA_SEVERITY, embedSource };

package/lib/interpreter.js

@@ -1,4 +1,5 @@
 'use strict';
+const { collapseBranches } = require('./branch-collapse');
 
 // Interpreted draft 2020-12 engine. This is the correctness fallback for
 // schemas the JS codegen cannot represent when the native engine is absent
@@ -866,7 +867,7 @@ class Interpreter {
         valid = false;
       } else {
         const sub = collect ? { props: null, items: null } : DISCARD;
-        if (!this.eval(child, data, refBase, dynScope, errors, instancePath, schemaPath + '/$ref', stack, sub)) valid = false;
+        if (!this.eval(child, data, refBase, dynScope, errors, instancePath, schemaPath, stack, sub)) valid = false;
         else if (collect) mergeAnnotations(local, sub);
       }
     }
@@ -905,7 +906,7 @@ class Interpreter {
         valid = false;
       } else {
         const sub = collect ? { props: null, items: null } : DISCARD;
-        if (!this.eval(this.node(node), data, refBase, dynScope, errors, instancePath, schemaPath + '/$dynamicRef', stack, sub)) valid = false;
+        if (!this.eval(this.node(node), data, refBase, dynScope, errors, instancePath, schemaPath, stack, sub)) valid = false;
         else if (collect) mergeAnnotations(local, sub);
       }
     }
@@ -985,7 +986,7 @@ class Interpreter {
         }
         const minC = P.minContains !== undefined ? P.minContains : 1;
         if (matched.length < minC) { errors === NOERRORS || errors.push(err('contains', 'contains', instancePath, schemaPath + '/contains', { minContains: minC }, `must contain at least ${minC} valid item(s)`)); valid = false; }
-        if (P.maxContains !== undefined && matched.length > P.maxContains) { errors === NOERRORS || errors.push(err('maxContains', 'maxContains', instancePath, schemaPath + '/maxContains', { limit: P.maxContains }, `must NOT contain more than ${P.maxContains} valid item(s)`)); valid = false; }
+        if (P.maxContains !== undefined && matched.length > P.maxContains) { errors === NOERRORS || errors.push(err('contains', 'contains', instancePath, schemaPath + '/contains', { minContains: minC, maxContains: P.maxContains }, `must NOT contain more than ${P.maxContains} valid item(s)`)); valid = false; }
         if (collect && matched.length) {
           if (!local.items) local.items = new Set();
           for (const i of matched) local.items.add(i);
@@ -1016,7 +1017,7 @@ class Interpreter {
       }
       if (P.propertyNames !== undefined) {
         for (const key of keys) {
-          if (!this.eval(P.propertyNames, key, base, dynScope, errors, instancePath + '/' + escapePointer(key), schemaPath + '/propertyNames', stack, DISCARD)) valid = false;
+          if (!this.eval(P.propertyNames, key, base, dynScope, errors, instancePath, schemaPath + '/propertyNames', stack, DISCARD)) valid = false;
         }
       }
       const props = P.properties;
@@ -1039,7 +1040,13 @@ class Interpreter {
           }
         }
         if (!evaluated && P.additionalProperties !== undefined) {
-          if (!this.eval(P.additionalProperties, data[key], base, dynScope, errors, instancePath + '/' + escapePointer(key), schemaPath + '/additionalProperties', stack, DISCARD)) valid = false;
+          // `additionalProperties: false` keeps its own keyword and names the
+          // property it turned away. Running it as a plain false subschema
+          // reported `not` at the key's path, which drops both.
+          if (P.additionalProperties === false) {
+            valid = false;
+            if (errors !== NOERRORS) errors.push(err('additionalProperties', 'additionalProperties', instancePath, schemaPath + '/additionalProperties', { additionalProperty: key }, 'must NOT have additional properties'));
+          } else if (!this.eval(P.additionalProperties, data[key], base, dynScope, errors, instancePath + '/' + escapePointer(key), schemaPath + '/additionalProperties', stack, DISCARD)) valid = false;
           evaluated = true;
         }
         if (evaluated && collect) {
@@ -1098,16 +1105,24 @@ class Interpreter {
       if (P.anyOf !== null) {
         let any = false;
         const scratch = errors === NOERRORS ? NOERRORS : [];
+        // Per-branch errors, taken as a slice of the shared scratch rather than
+        // an array each, so a branch that passes costs nothing extra.
+        const branches = errors === NOERRORS ? null : [];
         for (let i = 0; i < P.anyOf.length; i++) {
           const sub = collect ? { props: null, items: null } : DISCARD;
-          if (this.eval(P.anyOf[i], data, base, dynScope, scratch, instancePath, schemaPath + '/anyOf/' + i, stack, sub)) {
+          const mark = branches === null ? 0 : scratch.length;
+          const ok = this.eval(P.anyOf[i], data, base, dynScope, scratch, instancePath, schemaPath + '/anyOf/' + i, stack, sub);
+          if (branches !== null) branches.push({ valid: ok, errors: scratch.slice(mark), title: branchTitle(P.anyOf[i]) });
+          if (ok) {
             any = true;
             if (collect) mergeAnnotations(local, sub);
           }
         }
         if (!any) {
-          if (errors !== NOERRORS) for (const e of scratch) errors.push(e);
-          if (errors !== NOERRORS) errors.push(err('anyOf', 'anyOf', instancePath, schemaPath + '/anyOf', {}, 'must match a schema in anyOf'));
+          if (branches !== null) {
+            const collapsed = collapseBranches({ keyword: 'anyOf', branchResults: branches, parentPath: instancePath, parentSchemaPath: schemaPath + '/anyOf' });
+            if (collapsed !== null) errors.push(collapsed);
+          }
           valid = false;
         }
       }
@@ -1115,17 +1130,25 @@ class Interpreter {
         let count = 0;
         let winner = null;
         const scratch = errors === NOERRORS ? NOERRORS : [];
+        // Per-branch results, so a failing oneOf collapses to the branch that
+        // came closest instead of every branch's complaints at once.
+        const branches = errors === NOERRORS ? null : [];
         for (let i = 0; i < P.oneOf.length; i++) {
           const sub = collect ? { props: null, items: null } : DISCARD;
-          if (this.eval(P.oneOf[i], data, base, dynScope, scratch, instancePath, schemaPath + '/oneOf/' + i, stack, sub)) {
+          const mark = branches === null ? 0 : scratch.length;
+          const ok = this.eval(P.oneOf[i], data, base, dynScope, scratch, instancePath, schemaPath + '/oneOf/' + i, stack, sub);
+          if (branches !== null) branches.push({ valid: ok, errors: scratch.slice(mark), title: branchTitle(P.oneOf[i]) });
+          if (ok) {
             count++;
             winner = sub;
           }
         }
         if (count === 1) { if (collect) mergeAnnotations(local, winner); }
         else {
-          if (count === 0) for (const e of scratch) errors.push(e);
-          if (errors !== NOERRORS) errors.push(err('oneOf', 'oneOf', instancePath, schemaPath + '/oneOf', { passingSchemas: count }, 'must match exactly one schema in oneOf'));
+          if (branches !== null) {
+            const collapsed = collapseBranches({ keyword: 'oneOf', branchResults: branches, parentPath: instancePath, parentSchemaPath: schemaPath + '/oneOf' });
+            if (collapsed !== null) errors.push(collapsed);
+          }
           valid = false;
         }
       }
@@ -1182,6 +1205,12 @@ class Interpreter {
   }
 }
 
+// One branch title, for the collapsed anyOf/oneOf error. The compiled node
+// keeps the schema it came from, which is where a `title` lives.
+function branchTitle (node) {
+  return node && node.schema && typeof node.schema.title === 'string' ? node.schema.title : '';
+}
+
 function escapePointer(s) {
   if (typeof s !== 'string') s = String(s);
   // Keys almost never contain `~` or `/`; skip the two regex passes when so.

package/lib/js-compiler.js

@@ -25,6 +25,12 @@ const UQ_HELPERS = "function _cn(x){if(x===null||typeof x!=='object')return type
 function hoistOnce(ctx, key, code) {
   if (ctx[key]) return
   ctx[key] = true
+  // Recorded as shared: the text is a constant and the name it declares is
+  // fixed, so several compiled schemas in one bundle can use one copy. The
+  // rest of the preamble cannot move, because emitConstant and the generated
+  // branch checks name things per compilation (_kv0, _av3) and two schemas
+  // would collide.
+  if (ctx.shared) ctx.shared.push(code)
   if (ctx.preamble) ctx.preamble.push(code)
   else if (ctx.helperCode) ctx.helperCode.push(code)
 }
@@ -34,6 +40,18 @@ function emitDeq(ctx) {
   return '_deq'
 }
 
+// RFC 6901: a property key reaching an instancePath has to have `~` and `/`
+// escaped, or the pointer splits into the wrong segments. Static keys are
+// escaped at compile time with ptrSeg; a key only known at run time needs
+// this. It mirrors interpreter.js escapePointer, including skipping the two
+// regex passes for the keys that need nothing, which is almost all of them.
+const PTR_ESC_HELPER = "function _pe(s){for(let i=0;i<s.length;i++){const c=s.charCodeAt(i);if(c===126||c===47)return s.replace(/~/g,'~0').replace(/\\//g,'~1')}return s}"
+
+function emitPtrEsc(ctx) {
+  hoistOnce(ctx, '_peHoisted', PTR_ESC_HELPER)
+  return '_pe'
+}
+
 // `_uq` compares items with `_deq`, so it can never be hoisted alone.
 function emitUq(ctx) {
   emitDeq(ctx)
@@ -1474,7 +1492,7 @@ function compileToJSCodegen(schema, schemaMap, userFormats) {
   if (hasUnresolvableRef(schema, rootDefs, anchors, schemaMap, new Set())) return null
   if (needsBaseTracking(schema, schemaMap, new Set())) return null
 
-  const ctx = { varCounter: 0, helpers: [], helperCode: [], preamble: [], closureVars: ['_cpLen'], closureVals: [_cpLen], rootDefs, refStack: new Set(), schemaMap: schemaMap || null, anchors, rootSchema: schema, userFormats: userFormats || null }
+  const ctx = { varCounter: 0, helpers: [], helperCode: [], preamble: [], shared: [], closureVars: ['_cpLen'], closureVals: [_cpLen], rootDefs, refStack: new Set(), schemaMap: schemaMap || null, anchors, rootSchema: schema, userFormats: userFormats || null }
   const lines = []
   genCode(schema, 'd', lines, ctx)
 
@@ -1556,6 +1574,9 @@ function compileToJSCodegen(schema, schemaMap, userFormats) {
     const helperStr = ctx.helperCode.length ? ctx.helperCode.join('\n  ') + '\n  ' : ''
     boolFn._source = helperStr + body
     boolFn._preambleSource = preambleStr
+    boolFn._preambleGuard = guardStr
+    boolFn._preambleParts = ctx.preamble ? ctx.preamble.slice() : []
+    boolFn._sharedHelpers = ctx.shared ? ctx.shared.slice() : []
     boolFn._hybridSource = helperStr + hybridBody
     boolFn._usesSafeRe = !!ctx.usesSafeRe
     // Custom-format closure entries that the bundle output needs to recreate.
@@ -3244,7 +3265,7 @@ function compileToJSCodegenWithErrors(schema, schemaMap, userFormats, sourceOpts
   if (hasUnresolvableRef(schema, eRootDefs, eAnchors, schemaMap, new Set())) return null
   if (needsBaseTracking(schema, schemaMap, new Set())) return null
 
-  const ctx = { varCounter: 0, helperCode: [], rootDefs: eRootDefs, refStack: new Set(), schemaMap: schemaMap || null, anchors: eAnchors, rootSchema: schema, userFormats: userFormats || null,
+  const ctx = { varCounter: 0, helperCode: [], rootDefs: eRootDefs, shared: [], refStack: new Set(), schemaMap: schemaMap || null, anchors: eAnchors, rootSchema: schema, userFormats: userFormats || null,
                 // Custom format checkers referenced by the body, bound as
                 // closure parameters below the way the other entry points do.
                 closureVars: [], closureVals: [],
@@ -3264,7 +3285,7 @@ function compileToJSCodegenWithErrors(schema, schemaMap, userFormats, sourceOpts
   // AOT output small for schemas that don't compose. Standalone modules can't
   // require('./branch-collapse'), so the helper body is embedded verbatim.
   if (ctx.usesBranchCollapse) {
-    ctx.helperCode.push("const __ATA_SEVERITY={type:10,const:8,enum:8,required:5,format:3,minLength:3,maxLength:3,minimum:3,maximum:3,pattern:3,additionalProperties:2,unevaluatedProperties:2,unevaluatedItems:2};function __ataScore(errs){if(!errs||!errs.length)return 0;let s=0;for(const e of errs)s+=__ATA_SEVERITY[e.keyword]||4;return errs.length*100+s}function __ataCollapse(kw,br,pp,sp,o){const pass=br.filter(b=>b.valid);if(kw==='oneOf'){if(pass.length===1)return null;if(pass.length>1)return{code:'ATA4002',keyword:'oneOf',instancePath:pp||'',path:pp||'',schemaPath:sp,_o:o,message:'value matched '+pass.length+' of '+br.length+' oneOf variants, expected exactly one',params:{matched:pass.length,total:br.length}}}else{if(pass.length>=1)return null}let bi=0,bs=Infinity;for(let i=0;i<br.length;i++){const s=__ataScore(br[i].errors);if(s<bs){bs=s;bi=i}}const code=kw==='oneOf'?'ATA4001':'ATA4003';const best=br[bi];return{code,keyword:kw,instancePath:pp||'',path:pp||'',schemaPath:sp,_o:o,message:'value matched 0 of '+br.length+' '+kw+' variants',params:{variants:br.length,closest:bi,closestName:best.title||('variant '+(bi+1))},branchErrors:best.errors}}")
+        ctx.helperCode.push(require('./branch-collapse').embedSource())
   }
   if (lines.length === 0) return (d) => ({ valid: true, errors: [] })
 
@@ -3314,6 +3335,7 @@ function compileToJSCodegenWithErrors(schema, schemaMap, userFormats, sourceOpts
       fn = new Function('d', '_all', body)
     }
     fn._errSource = body
+    fn._sharedHelpers = ctx.shared ? ctx.shared.slice() : []
     fn._usesSafeRe = !!ctx.usesSafeRe
     if (cvars.length) {
       fn._formatClosures = cvars.map((name, i) => {
@@ -3490,10 +3512,11 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
       }
     })
     const expected = types.join(', ')
+    const expectedParam = types.length === 1 ? `'${types[0]}'` : JSON.stringify(types)
     {
       const typeSp = `${schemaPrefix}/type`
       const lit = buildErrorLiteral({ keyword: 'type', schemaPath: typeSp, sourceMap: ctx.sourceMap })
-      lines.push(`if(!(${conds.join('||')})){_e.push({code:'${lit.codeStr}',keyword:'type',instancePath:${pathExpr||'""'},schemaPath:'${typeSp}'${ordinalField(ctx, `${typeSp}`)},params:{type:'${expected}'},message:'must be ${expected}',docUrl:'${lit.docUrl}'${lit.frame}});if(!_all)return{valid:false,errors:_e}}`)
+      lines.push(`if(!(${conds.join('||')})){_e.push({code:'${lit.codeStr}',keyword:'type',instancePath:${pathExpr||'""'},schemaPath:'${typeSp}'${ordinalField(ctx, `${typeSp}`)},params:{type:${expectedParam}},message:'must be ${expected}',docUrl:'${lit.docUrl}'${lit.frame}});if(!_all)return{valid:false,errors:_e}}`)
     }
   }
 
@@ -3703,9 +3726,9 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   // properties — always guard (error mode, data may not be an object or may be array)
   if (schema.properties) {
     for (const [key, prop] of Object.entries(schema.properties)) {
-      const childPath = childPathExpr(pathExpr, esc(key))
+      const childPath = childPathExpr(pathExpr, ptrSeg(key))
       lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&${JSON.stringify(key)} in ${v}){`)
-      genCodeE(prop, `${v}[${JSON.stringify(key)}]`, childPath, lines, ctx, schemaPrefix+'/properties/'+key)
+      genCodeE(prop, `${v}[${JSON.stringify(key)}]`, childPath, lines, ctx, schemaPrefix+'/properties/'+ptrSeg(key))
       lines.push(`}`)
     }
   }
@@ -3727,7 +3750,8 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
       const ri = ctx.regExpMap.get(pattern);
       const ki = ctx.varCounter++
       lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){for(const _k${ki} in ${v}){if(_re${ri}.test(_k${ki})){`)
-      const p = pathExpr ? `${pathExpr}+'/'+_k${ki}` : `'/'+_k${ki}`
+      const _peFn = emitPtrEsc(ctx)
+      const p = pathExpr ? `${pathExpr}+'/'+${_peFn}(_k${ki})` : `'/'+${_peFn}(_k${ki})`
       // The real pointer, so source maps can locate the failing keyword.
       genCodeE(sub, `${v}[_k${ki}]`, p, lines, ctx, schemaPrefix + '/patternProperties/' + pat.replace(/~/g, '~0').replace(/\//g, '~1'))
       lines.push(`}}}`)
@@ -3763,7 +3787,8 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     if (patTests.length) conds.push(`!(${patTests.join('||')})`)
     const keep = conds.length ? `if(${conds.join('&&')}){` : `{`
     lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${guard}for(const _k${ki} in ${v}){${keep}`)
-    const p = pathExpr ? `${pathExpr}+'/'+_k${ki}` : `'/'+_k${ki}`
+    const _peFn = emitPtrEsc(ctx)
+    const p = pathExpr ? `${pathExpr}+'/'+${_peFn}(_k${ki})` : `'/'+${_peFn}(_k${ki})`
     genCodeE(schema.additionalProperties, `${v}[_k${ki}]`, p, lines, ctx, schemaPrefix + '/additionalProperties')
     lines.push(`}}}`)
   }
@@ -3772,7 +3797,7 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   if (schema.dependentSchemas) {
     for (const [key, depSchema] of Object.entries(schema.dependentSchemas)) {
       lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&${JSON.stringify(key)} in ${v}){`)
-      genCodeE(depSchema, v, pathExpr, lines, ctx, schemaPrefix+'/dependentSchemas/'+key)
+      genCodeE(depSchema, v, pathExpr, lines, ctx, schemaPrefix+'/dependentSchemas/'+ptrSeg(key))
       lines.push(`}`)
     }
   }
@@ -3781,7 +3806,10 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   // interpreter does (plan-compiler: instancePath + '/' + key).
   if (schema.propertyNames === false) {
     const ki = ctx.varCounter++
-    const p = pathExpr ? `${pathExpr}+'/'+_k${ki}` : `'/'+_k${ki}`
+    // The subschema is applied to the property NAME, so the failure belongs to
+    // the object that carries the name, not to `/<key>`, which is where the
+    // value lives. Same placement as the object-valued propertyNames branch.
+    const p = pathExpr || '""'
     lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){for(const _k${ki} in ${v}){_e.push({keyword:'not',instancePath:${p},schemaPath:'${schemaPrefix}/propertyNames'${ordinalField(ctx, `${schemaPrefix}/propertyNames`)},params:{},message:'boolean schema is false'});if(!_all)return{valid:false,errors:_e}}}`)
   }
 
@@ -3853,9 +3881,9 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     const minC = schema.minContains !== undefined ? schema.minContains : 1
     const maxC = schema.maxContains
     lines.push(`if(Array.isArray(${v})){const _cf${ci}=function(_cv){${fnBody}};let _cc${ci}=0;for(let _ci${ci}=0;_ci${ci}<${v}.length;_ci${ci}++){if(_cf${ci}(${v}[_ci${ci}]))_cc${ci}++}`)
-    lines.push(`if(_cc${ci}<${minC}){${fail('contains', 'contains', `{limit:${minC}}`, `'contains: need at least ${minC} match(es)'`)}}`)
+    lines.push(`if(_cc${ci}<${minC}){${fail('contains', 'contains', `{minContains:${minC}}`, `'contains: need at least ${minC} match(es)'`)}}`)
     if (maxC !== undefined) {
-      lines.push(`if(_cc${ci}>${maxC}){${fail('contains', 'contains', `{limit:${maxC}}`, `'contains: at most ${maxC} match(es)'`)}}`)
+      lines.push(`if(_cc${ci}>${maxC}){${fail('contains', 'contains', `{minContains:${minC},maxContains:${maxC}}`, `'contains: at most ${maxC} match(es)'`)}}`)
     }
     lines.push(`}`)
   }
@@ -3991,7 +4019,7 @@ function compileToJSCombined(schema, VALID_RESULT, schemaMap, userFormats) {
   if (hasUnresolvableRef(schema, cRootDefs, cAnchors, schemaMap, new Set())) return null
   if (needsBaseTracking(schema, schemaMap, new Set())) return null
 
-  const ctx = { varCounter: 0, helperCode: [], closureVars: ['_cpLen'], closureVals: [_cpLen],
+  const ctx = { varCounter: 0, helperCode: [], shared: [], closureVars: ['_cpLen'], closureVals: [_cpLen],
                 rootDefs: cRootDefs, refStack: new Set(), schemaMap: schemaMap || null, anchors: cAnchors, rootSchema: schema, userFormats: userFormats || null }
   const lines = []
   genCodeC(schema, 'd', '', lines, ctx, '#')
@@ -4137,10 +4165,11 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
       }
     })
     const expected = types.join(', ')
+    const expectedParam = types.length === 1 ? `'${types[0]}'` : JSON.stringify(types)
     // Type check: push error but continue — wrap remaining in type-success block
     const typeOk = `_tok${ctx.varCounter++}`
     lines.push(`const ${typeOk}=${conds.join('||')}`)
-    lines.push(`if(!${typeOk}){${fail('type', 'type', `{type:'${expected}'}`, `'must be ${expected}'`)}}`)
+    lines.push(`if(!${typeOk}){${fail('type', 'type', `{type:${expectedParam}}`, `'must be ${expected}'`)}}`)
     // Subsequent optimized code runs inside if(typeOk){...}
     if (types.length === 1) {
       isObj = types[0] === 'object'
@@ -4335,19 +4364,19 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   if (schema.properties) {
     for (const [key, prop] of Object.entries(schema.properties)) {
       const pv = hoisted[key] || `${v}[${JSON.stringify(key)}]`
-      const childPath = childPathExpr(pathExpr, esc(key))
+      const childPath = childPathExpr(pathExpr, ptrSeg(key))
       if (requiredSet.has(key) && isObj) {
         lines.push(`if(${pv}!==undefined){`)
-        genCodeC(prop, pv, childPath, lines, ctx, schemaPrefix+'/properties/'+key)
+        genCodeC(prop, pv, childPath, lines, ctx, schemaPrefix+'/properties/'+ptrSeg(key))
         lines.push(`}`)
       } else if (isObj) {
         const oi = ctx.varCounter++
         lines.push(`{const _o${oi}=${v}[${JSON.stringify(key)}];if(_o${oi}!==undefined){`)
-        genCodeC(prop, `_o${oi}`, childPath, lines, ctx, schemaPrefix+'/properties/'+key)
+        genCodeC(prop, `_o${oi}`, childPath, lines, ctx, schemaPrefix+'/properties/'+ptrSeg(key))
         lines.push(`}}`)
       } else {
         lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&${JSON.stringify(key)} in ${v}){`)
-        genCodeC(prop, `${v}[${JSON.stringify(key)}]`, childPath, lines, ctx, schemaPrefix+'/properties/'+key)
+        genCodeC(prop, `${v}[${JSON.stringify(key)}]`, childPath, lines, ctx, schemaPrefix+'/properties/'+ptrSeg(key))
         lines.push(`}`)
       }
     }
@@ -4420,7 +4449,7 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
         // The subschema is generated in place so its own keywords report
         // the real instance path and schema pointer.
         lines.push(`if(${matchers[i].check}){_m${pi}=true;{const _ppv${pi}_${i}=${v}[${kVar}]`)
-        genCodeC(ppEntries[i][1], `_ppv${pi}_${i}`, childPathDynExpr(pathExpr, kVar), lines, ctx, schemaPrefix + '/patternProperties/' + ptrSeg(ppEntries[i][0]))
+        genCodeC(ppEntries[i][1], `_ppv${pi}_${i}`, childPathDynExpr(pathExpr, `${emitPtrEsc(ctx)}(${kVar})`), lines, ctx, schemaPrefix + '/patternProperties/' + ptrSeg(ppEntries[i][0]))
         lines.push(`}}`)
       }
       lines.push(`if(!_m${pi}){${fail('additionalProperties', 'additionalProperties', `{additionalProperty:${kVar}}`, "'must NOT have additional properties'")}}`)
@@ -4452,7 +4481,7 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
       }
       for (let i = 0; i < ppEntries.length; i++) {
         lines.push(`if(${matchers[i].check}){const _ppv${pi}_${i}=${v}[${kVar}]`)
-        genCodeC(ppEntries[i][1], `_ppv${pi}_${i}`, childPathDynExpr(pathExpr, kVar), lines, ctx, schemaPrefix + '/patternProperties/' + ptrSeg(ppEntries[i][0]))
+        genCodeC(ppEntries[i][1], `_ppv${pi}_${i}`, childPathDynExpr(pathExpr, `${emitPtrEsc(ctx)}(${kVar})`), lines, ctx, schemaPrefix + '/patternProperties/' + ptrSeg(ppEntries[i][0]))
         lines.push(`}`)
       }
       lines.push(`}}`)
@@ -4463,14 +4492,14 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   if (schema.dependentSchemas) {
     for (const [key, depSchema] of Object.entries(schema.dependentSchemas)) {
       lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&${JSON.stringify(key)} in ${v}){`)
-      genCodeC(depSchema, v, pathExpr, lines, ctx, schemaPrefix+'/dependentSchemas/'+key)
+      genCodeC(depSchema, v, pathExpr, lines, ctx, schemaPrefix+'/dependentSchemas/'+ptrSeg(key))
       lines.push(`}`)
     }
   }
 
   if (schema.propertyNames === false) {
     const ki = ctx.varCounter++
-    const p = pathExpr ? `${pathExpr}+'/'+_k${ki}` : `'/'+_k${ki}`
+    const p = pathExpr || '""'
     lines.push(`;if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){for(const _k${ki} in ${v}){(_e||(_e=[])).push({keyword:'not',instancePath:${p},schemaPath:'${schemaPrefix}/propertyNames'${ordinalField(ctx, `${schemaPrefix}/propertyNames`)},params:{},message:'boolean schema is false'})}}`)
   }
 
@@ -4533,8 +4562,8 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     const minC = schema.minContains !== undefined ? schema.minContains : 1
     const maxC = schema.maxContains
     lines.push(`if(Array.isArray(${v})){const _cf${ci}=function(_cv){${fnBody}};let _cc${ci}=0;for(let _ci${ci}=0;_ci${ci}<${v}.length;_ci${ci}++){if(_cf${ci}(${v}[_ci${ci}]))_cc${ci}++}`)
-    lines.push(`if(_cc${ci}<${minC}){${fail('contains', 'contains', `{limit:${minC}}`, `'contains: need at least ${minC} match(es)'`)}}`)
-    if (maxC !== undefined) lines.push(`if(_cc${ci}>${maxC}){${fail('contains', 'contains', `{limit:${maxC}}`, `'contains: at most ${maxC} match(es)'`)}}`)
+    lines.push(`if(_cc${ci}<${minC}){${fail('contains', 'contains', `{minContains:${minC}}`, `'contains: need at least ${minC} match(es)'`)}}`)
+    if (maxC !== undefined) lines.push(`if(_cc${ci}>${maxC}){${fail('contains', 'contains', `{minContains:${minC},maxContains:${maxC}}`, `'contains: at most ${maxC} match(es)'`)}}`)
     lines.push(`}`)
   }
 

package/lib/output-format.js

@@ -0,0 +1,140 @@
+'use strict';
+
+// The standardised output format from draft 2019-09 and 2020-12.
+//
+// ata reports errors in its own shape, the one consumers and the compat entry
+// expect. The specification also defines an output format of its own, with
+// `keywordLocation`, `absoluteKeywordLocation` and `instanceLocation`, and the
+// official test suite has a small set of tests for it under `output-tests/`.
+// This produces that shape from a validation, so those tests can be run and so
+// a caller that wants spec output can have it.
+//
+// `flag` and `basic` are implemented. `detailed` and `verbose` are not: they
+// need the full applicator tree, including the subschemas that passed, which
+// the engines do not keep. The v1 `list` format is not implemented either; it
+// is still moving, and the suite's own v1 output schema does not yet define it.
+//
+// Annotations are collected only when validation succeeded. That is not a
+// shortcut: a subschema that fails contributes no annotations, and the output
+// is rooted at the root schema, so a failing root drops all of them.
+
+// Keywords whose value is the annotation they produce.
+const METADATA_KEYWORDS = [
+  'title', 'description', 'default', 'deprecated', 'readOnly', 'writeOnly',
+  'examples', 'format', 'contentEncoding', 'contentMediaType', 'contentSchema',
+];
+
+function pointerSegment (s) {
+  return String(s).replace(/~/g, '~0').replace(/\//g, '~1');
+}
+
+// The root $id, which absoluteKeywordLocation is resolved against.
+function baseUri (schema) {
+  if (schema && typeof schema === 'object' && typeof schema.$id === 'string') {
+    return schema.$id.split('#')[0];
+  }
+  return null;
+}
+
+function unitFor (error, base) {
+  const keywordLocation = typeof error.schemaPath === 'string' && error.schemaPath.charAt(0) === '#'
+    ? error.schemaPath.slice(1)
+    : (error.schemaPath || '');
+  const unit = {
+    valid: false,
+    keywordLocation,
+    instanceLocation: error.instancePath || '',
+  };
+  if (base) unit.absoluteKeywordLocation = base + '#' + keywordLocation;
+  if (typeof error.message === 'string') unit.error = error.message;
+  return unit;
+}
+
+// Walk the schema beside the instance, collecting metadata annotations from
+// the subschemas that applied. Only reached when the whole validation passed,
+// so every applicator followed here is one that succeeded, except the
+// alternatives of anyOf/oneOf/if, which are checked before being followed.
+function collectAnnotations (schema, data, keywordLocation, instanceLocation, base, out, isValid, depth) {
+  if (schema === true || schema === false || schema === null || typeof schema !== 'object' || depth > 64) return;
+
+  for (const kw of METADATA_KEYWORDS) {
+    if (Object.prototype.hasOwnProperty.call(schema, kw)) {
+      const unit = {
+        valid: true,
+        keywordLocation: keywordLocation + '/' + kw,
+        instanceLocation,
+        annotation: schema[kw],
+      };
+      if (base) unit.absoluteKeywordLocation = base + '#' + keywordLocation + '/' + kw;
+      out.push(unit);
+    }
+  }
+
+  const down = (sub, kwSeg, value, instSeg) => collectAnnotations(
+    sub, value, keywordLocation + kwSeg, instanceLocation + (instSeg || ''), base, out, isValid, depth + 1,
+  );
+
+  if (schema.properties && data !== null && typeof data === 'object' && !Array.isArray(data)) {
+    for (const key of Object.keys(schema.properties)) {
+      if (Object.prototype.hasOwnProperty.call(data, key)) {
+        down(schema.properties[key], '/properties/' + pointerSegment(key), data[key], '/' + pointerSegment(key));
+      }
+    }
+  }
+  if (Array.isArray(schema.prefixItems) && Array.isArray(data)) {
+    for (let i = 0; i < schema.prefixItems.length && i < data.length; i++) {
+      down(schema.prefixItems[i], '/prefixItems/' + i, data[i], '/' + i);
+    }
+  }
+  if (schema.items && typeof schema.items === 'object' && Array.isArray(data)) {
+    const start = Array.isArray(schema.prefixItems) ? schema.prefixItems.length : 0;
+    for (let i = start; i < data.length; i++) down(schema.items, '/items', data[i], '/' + i);
+  }
+  if (Array.isArray(schema.allOf)) {
+    for (let i = 0; i < schema.allOf.length; i++) down(schema.allOf[i], '/allOf/' + i, data, '');
+  }
+  for (const kw of ['anyOf', 'oneOf']) {
+    if (Array.isArray(schema[kw])) {
+      for (let i = 0; i < schema[kw].length; i++) {
+        if (isValid(schema[kw][i], data)) down(schema[kw][i], '/' + kw + '/' + i, data, '');
+      }
+    }
+  }
+  if (schema.if !== undefined) {
+    const taken = isValid(schema.if, data);
+    if (taken && schema.then !== undefined) down(schema.then, '/then', data, '');
+    if (!taken && schema.else !== undefined) down(schema.else, '/else', data, '');
+  }
+}
+
+// Produce spec output for `data` under `validator`.
+//   format: 'flag' | 'basic' (default 'basic')
+function toOutput (validator, data, opts) {
+  const format = (opts && opts.format) || 'basic';
+  const result = validator.validate(data);
+  if (format === 'flag') return { valid: result.valid };
+  if (format !== 'basic') {
+    throw new Error(`toOutput: unsupported format "${format}". Supported: "flag", "basic".`);
+  }
+
+  const schema = validator._schemaObj !== undefined ? validator._schemaObj : validator._rawSchema;
+  const base = baseUri(schema);
+  const out = { valid: result.valid };
+
+  if (!result.valid) {
+    const errors = [];
+    for (const e of result.errors) errors.push(unitFor(e, base));
+    out.errors = errors;
+    return out;
+  }
+
+  const annotations = [];
+  const isValid = (sub, value) => {
+    try { return new validator.constructor(sub).isValidObject(value); } catch { return false; }
+  };
+  collectAnnotations(schema, data, '', '', base, annotations, isValid, 0);
+  if (annotations.length) out.annotations = annotations;
+  return out;
+}
+
+module.exports = { toOutput, METADATA_KEYWORDS };

package/lib/plan-compiler.js

@@ -1,4 +1,9 @@
 'use strict';
+const { collapseBranches } = require('./branch-collapse');
+
+// One branch title, for the collapsed anyOf/oneOf error. The compiled node
+// keeps the schema it came from, which is where a `title` lives.
+const branchTitle = (n) => (n && n.schema && typeof n.schema.title === 'string' ? n.schema.title : '');
 
 // Compiles interpreter Plans into a tree of specialized closures. No source
 // generation, no `new Function`: this is plain closure composition, so it
@@ -334,13 +339,13 @@ function install(deps) {
       if (collect) {
         cstep = (data, errors, instancePath, schemaPath, stack, rec) => {
           const pl = pLen(rec), n0 = rec.n, xl = xLen(rec);
-          const ok = target.c(data, errors, instancePath, schemaPath + seg, stack, rec);
+          const ok = target.c(data, errors, instancePath, schemaPath, stack, rec);
           if (!ok) undo(rec, pl, n0, xl);
           return ok;
         };
         vstep = (data, stack, rec) => target.v(data, stack, rec);
       } else {
-        cstep = (data, errors, instancePath, schemaPath, stack) => target.c(data, errors, instancePath, schemaPath + seg, stack);
+        cstep = (data, errors, instancePath, schemaPath, stack) => target.c(data, errors, instancePath, schemaPath, stack);
         vstep = target.v;
       }
       if (ctx.guard) {
@@ -447,7 +452,10 @@ function install(deps) {
           ok = false;
         }
         if (maxC !== undefined && matched > maxC) {
-          if (errors !== NOERRORS) errors.push(err('maxContains', 'maxContains', instancePath, schemaPath + '/maxContains', { limit: maxC }, `must NOT contain more than ${maxC} valid item(s)`));
+          // Reported as `contains` at `#/contains`, the way the generated code
+          // and the reference implementation both do it: maxContains bounds the
+          // same keyword rather than being one of its own.
+          if (errors !== NOERRORS) errors.push(err('contains', 'contains', instancePath, schemaPath + '/contains', { minContains: minC, maxContains: maxC }, `must NOT contain more than ${maxC} valid item(s)`));
           ok = false;
         }
         return ok;
@@ -493,6 +501,13 @@ function install(deps) {
         ? P.patternProperties.map((e) => ({ re: e.re, src: e.src, fn: child(e.node) }))
         : null;
       const apFn = P.additionalProperties !== undefined ? child(P.additionalProperties) : null;
+      // `additionalProperties: false` is a boolean subschema, but its error is
+      // not the generic "boolean schema is false": every consumer switches on
+      // keyword === 'additionalProperties' and reads params.additionalProperty
+      // to learn which key was rejected. Reporting it as `not` at the key's own
+      // path loses both, and that shape is what the generated code emits, so
+      // the two engines have to agree here.
+      const apFalse = P.additionalProperties === false;
       const pnFn = P.propertyNames !== undefined ? child(P.propertyNames) : null;
       steps.push((data, errors, instancePath, schemaPath, stack, rec) => {
         if (dataBits(data) !== T_OBJECT) return true;
@@ -500,7 +515,12 @@ function install(deps) {
         const keys = collect ? keysOf(rec, data) : Object.keys(data);
         if (pnFn !== null) {
           for (const k of keys) {
-            if (!pnFn.c(k, errors, instancePath + '/' + escapePointer(k), schemaPath + '/propertyNames', stack)) {
+            // propertyNames applies its subschema to the property NAME, not to
+            // the value sitting at that key, so the failure is reported against
+            // the object that carries the name rather than against `/<key>`.
+            // The generated code and the compat shim both do it this way, and
+            // the shim has to because that is where the reference puts it.
+            if (!pnFn.c(k, errors, instancePath, schemaPath + '/propertyNames', stack)) {
               ok = false;
               if (errors === NOERRORS) return false;
             }
@@ -530,7 +550,11 @@ function install(deps) {
             }
           }
           if (!evaluated && apFn !== null) {
-            if (!apFn.c(data[key], errors, instancePath + '/' + escapePointer(key), schemaPath + '/additionalProperties', stack)) {
+            if (apFalse) {
+              ok = false;
+              if (errors === NOERRORS) return false;
+              errors.push(err('additionalProperties', 'additionalProperties', instancePath, schemaPath + '/additionalProperties', { additionalProperty: key }, 'must NOT have additional properties'));
+            } else if (!apFn.c(data[key], errors, instancePath + '/' + escapePointer(key), schemaPath + '/additionalProperties', stack)) {
               ok = false;
               if (errors === NOERRORS) return false;
             }
@@ -717,20 +741,31 @@ function install(deps) {
     }
     if (P.anyOf !== null) {
       const fns = P.anyOf.map((v) => inPlace(v, base));
+      const titles = P.anyOf.map(branchTitle);
       steps.push((data, errors, instancePath, schemaPath, stack, rec) => {
         const scratch = errors === NOERRORS ? NOERRORS : [];
         let any = false;
+        // Per-branch errors, taken as slices of the shared scratch rather than
+        // an array each, so a branch that passes costs nothing extra.
+        const branches = errors === NOERRORS ? null : [];
         for (let i = 0; i < fns.length; i++) {
+          const mark = branches === null ? 0 : scratch.length;
+          let ok;
           if (collect) {
             const pl = pLen(rec), n0 = rec.n, xl = xLen(rec);
-            if (fns[i].c(data, scratch, instancePath, schemaPath + '/anyOf/' + i, stack, rec)) any = true;
+            ok = fns[i].c(data, scratch, instancePath, schemaPath + '/anyOf/' + i, stack, rec);
+            if (ok) any = true;
             else undo(rec, pl, n0, xl);
-          } else if (fns[i].c(data, scratch, instancePath, schemaPath + '/anyOf/' + i, stack)) any = true;
+          } else {
+            ok = fns[i].c(data, scratch, instancePath, schemaPath + '/anyOf/' + i, stack);
+            if (ok) any = true;
+          }
+          if (branches !== null) branches.push({ valid: ok, errors: scratch.slice(mark), title: titles[i] });
         }
         if (!any) {
-          if (errors !== NOERRORS) {
-            for (const e of scratch) errors.push(e);
-            errors.push(err('anyOf', 'anyOf', instancePath, schemaPath + '/anyOf', {}, 'must match a schema in anyOf'));
+          if (branches !== null) {
+            const collapsed = collapseBranches({ keyword: 'anyOf', branchResults: branches, parentPath: instancePath, parentSchemaPath: schemaPath + '/anyOf' });
+            if (collapsed !== null) errors.push(collapsed);
           }
           return false;
         }
@@ -756,25 +791,36 @@ function install(deps) {
     }
     if (P.oneOf !== null) {
       const fns = P.oneOf.map((v) => inPlace(v, base));
+      const titles = P.oneOf.map(branchTitle);
       steps.push((data, errors, instancePath, schemaPath, stack, rec) => {
         const scratch = errors === NOERRORS ? NOERRORS : [];
         let count = 0;
+        // Per-branch results, so a failing oneOf collapses to the branch that
+        // came closest instead of every branch's complaints at once.
+        const branches = errors === NOERRORS ? null : [];
         // With a record: the winner's annotations stay, every other branch's
         // are undone, and a second winner undoes everything since the node
         // fails and merges nothing.
         const pl0 = collect ? pLen(rec) : 0, n00 = collect ? rec.n : 0, xl0 = collect ? xLen(rec) : 0;
         for (let i = 0; i < fns.length; i++) {
+          const mark = branches === null ? 0 : scratch.length;
+          let ok;
           if (collect) {
             const pl = pLen(rec), n0 = rec.n, xl = xLen(rec);
-            if (fns[i].c(data, scratch, instancePath, schemaPath + '/oneOf/' + i, stack, rec)) count++;
+            ok = fns[i].c(data, scratch, instancePath, schemaPath + '/oneOf/' + i, stack, rec);
+            if (ok) count++;
             else undo(rec, pl, n0, xl);
-          } else if (fns[i].c(data, scratch, instancePath, schemaPath + '/oneOf/' + i, stack)) count++;
+          } else {
+            ok = fns[i].c(data, scratch, instancePath, schemaPath + '/oneOf/' + i, stack);
+            if (ok) count++;
+          }
+          if (branches !== null) branches.push({ valid: ok, errors: scratch.slice(mark), title: titles[i] });
         }
         if (count !== 1) {
           if (collect) undo(rec, pl0, n00, xl0);
-          if (errors !== NOERRORS) {
-            if (count === 0) for (const e of scratch) errors.push(e);
-            errors.push(err('oneOf', 'oneOf', instancePath, schemaPath + '/oneOf', { passingSchemas: count }, 'must match exactly one schema in oneOf'));
+          if (branches !== null) {
+            const collapsed = collapseBranches({ keyword: 'oneOf', branchResults: branches, parentPath: instancePath, parentSchemaPath: schemaPath + '/oneOf' });
+            if (collapsed !== null) errors.push(collapsed);
           }
           return false;
         }

package/lib/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "1.19.0",
+  "version": "1.20.0",
   "description": "JSON Schema validation with first-class TypeScript and zero runtime cost. AOT compile to per-schema ESM modules with zero validator dependency. Generic Validator<T> for TypeBox/Zod/Valibot composition. Optional runtime API. Standard Schema V1 compatible.",
   "main": "index.js",
   "module": "index.mjs",
@@ -51,7 +51,7 @@
     "release:check": "node scripts/regen-safe-regex-source.js && node tests/test_pack_purity.js && node scripts/check-doc-coverage.js && node tests/test_error_codes_lock.js && node tests/test_safe_regex_source_sync.js && node tests/test_version_sync.js",
     "build": "cmake-js build --target ata",
     "rebuild": "cmake-js rebuild --target ata",
-    "test": "node test.js && node tests/test_removed_aot_methods.js && node tests/test_no_native.js && node tests/test_no_eval.js && node tests/test_property_dependencies.js && node tests/test_v1_dialect.js && node tests/test_buffer_path_parity.js && node tests/test_buffer_gate.js && node tests/test_buffer_reject_cost.js && node tests/test_nan_verdict.js && node tests/test_remove_additional_nested.js && node tests/test_exclusive_bounds.js && node tests/test_engine_differential.js && node tests/test_aot_parse.js && node tests/test_draft7_semantics.js && node tests/test_metaschema_ref.js && node tests/test_pure_js_unsupported.js && node tests/test_native_load_order.js && node tests/test_pack_purity.js && node tests/test_make_native_package.js && node tests/test_browser_nofs.js && node tests/test_browser_imports_guard.js && node tests/test_version_sync.js && node tests/test_native_loaded.js && node tests/test_safe_regex_source_sync.js && node tests/test_t_builder.js && node tests/test_async_refine.js && node tests/test_safe_regex.js && node tests/test_safe_regex_integration.js && node tests/test_aot_build.js && node tests/test_aot_differential.js && node tests/test_aot_cli_build.js && node tests/test_aot_cli_smoke.js && node tests/test_bundle_standalone.js && node tests/test_standalone_anyof.js && node tests/test_standalone_formats.js && node tests/test_aot_format_mode.js && node tests/test_aot_additional_props_errors.js && node tests/test_id_anchor_refs.js && node tests/test_engine_routing.js && node tests/test_engine_diagnostic.js && node tests/test_format_engine_parity.js && node tests/test_formats_single_pass.js && node tests/test_format_single_error.js && node tests/test_defs_pointer_alias.js && node tests/test_cross_doc_root_ref.js && node tests/test_codegen_entrypoint_agreement.js && node tests/test_hybrid_agreement.js && node tests/test_codegen_edge_shapes.js && node tests/test_ajv_errors.js && node tests/test_custom_keywords.js && node tests/test_ajv_parity.js && node tests/test_user_format_error_path.js && node tests/test_unevaluated_error_path.js && node tests/test_pattern_properties_errors.js && node tests/test_no_input_mutation.js && node tests/test_typed_validator_runner.js && node tests/test_define_schema.js && node tests/test_error_codes_lock.js && node tests/test_error_code_lookup.js && node tests/test_error_order.js && node tests/test_error_order_ordinal.js && node tests/test_rejection_shape.js && node tests/test_lazy_normalization.js && node tests/test_value_equality.js && node tests/test_vocabulary.js && node tests/test_schema_scan.js && node tests/test_lazy_errors.js && node tests/test_lazy_instance.js && node tests/test_cyclic_input.js && node tests/test_native_error_codes.js && node tests/test_verdict_preprocess.js && node tests/test_plan_compiler.js && node tests/test_nullable.js && node tests/test_validate_and_parse.js && node tests/test_validate_data.js && node tests/test_enrich_error.js && node tests/test_enrich_received.js && node tests/test_rich_errors_optout.js && node tests/test_error_messages.js && node tests/test_source_positions.js && node tests/fuzz_positions.js && node tests/test_data_positions.js && node tests/test_render_shared.js && node tests/test_renderers.js && node tests/test_additive_fields.js && node tests/test_diagnostic_source.js && node tests/test_diagnose.js && node tests/test_correlate.js && node tests/test_diagnostics_score.js && node tests/test_runtime_error_dx.js && node tests/test_aot_error_dx.js && node tests/test_abort_early.js && node tests/test_branch_collapse.js && node tests/test_suggestions.js && node tests/test_cli_validate.js && node tests/test_cli_version.js && node benchmark/bench_aot_size.mjs",
+    "test": "node test.js && node tests/test_removed_aot_methods.js && node tests/test_no_native.js && node tests/test_no_eval.js && node tests/test_property_dependencies.js && node tests/test_v1_dialect.js && node tests/test_buffer_path_parity.js && node tests/test_buffer_gate.js && node tests/test_buffer_reject_cost.js && node tests/test_nan_verdict.js && node tests/test_remove_additional_nested.js && node tests/test_exclusive_bounds.js && node tests/test_engine_differential.js && node tests/test_error_shape_differential.js && node tests/test_output_format.js && node tests/test_aot_parse.js && node tests/test_draft7_semantics.js && node tests/test_metaschema_ref.js && node tests/test_pure_js_unsupported.js && node tests/test_native_load_order.js && node tests/test_pack_purity.js && node tests/test_make_native_package.js && node tests/test_browser_nofs.js && node tests/test_browser_imports_guard.js && node tests/test_version_sync.js && node tests/test_native_loaded.js && node tests/test_safe_regex_source_sync.js && node tests/test_t_builder.js && node tests/test_async_refine.js && node tests/test_safe_regex.js && node tests/test_safe_regex_integration.js && node tests/test_aot_build.js && node tests/test_aot_differential.js && node tests/test_aot_cli_build.js && node tests/test_aot_cli_smoke.js && node tests/test_bundle_standalone.js && node tests/test_standalone_anyof.js && node tests/test_standalone_formats.js && node tests/test_aot_format_mode.js && node tests/test_aot_additional_props_errors.js && node tests/test_id_anchor_refs.js && node tests/test_engine_routing.js && node tests/test_engine_diagnostic.js && node tests/test_format_engine_parity.js && node tests/test_formats_single_pass.js && node tests/test_format_single_error.js && node tests/test_defs_pointer_alias.js && node tests/test_cross_doc_root_ref.js && node tests/test_codegen_entrypoint_agreement.js && node tests/test_hybrid_agreement.js && node tests/test_codegen_edge_shapes.js && node tests/test_ajv_errors.js && node tests/test_custom_keywords.js && node tests/test_aot_external_checks.js && node tests/test_ajv_parity.js && node tests/test_user_format_error_path.js && node tests/test_unevaluated_error_path.js && node tests/test_pattern_properties_errors.js && node tests/test_no_input_mutation.js && node tests/test_typed_validator_runner.js && node tests/test_define_schema.js && node tests/test_error_codes_lock.js && node tests/test_error_code_lookup.js && node tests/test_error_order.js && node tests/test_error_order_ordinal.js && node tests/test_rejection_shape.js && node tests/test_lazy_normalization.js && node tests/test_value_equality.js && node tests/test_vocabulary.js && node tests/test_schema_scan.js && node tests/test_lazy_errors.js && node tests/test_lazy_instance.js && node tests/test_cyclic_input.js && node tests/test_native_error_codes.js && node tests/test_verdict_preprocess.js && node tests/test_plan_compiler.js && node tests/test_nullable.js && node tests/test_validate_and_parse.js && node tests/test_validate_data.js && node tests/test_enrich_error.js && node tests/test_enrich_received.js && node tests/test_rich_errors_optout.js && node tests/test_error_messages.js && node tests/test_source_positions.js && node tests/fuzz_positions.js && node tests/test_data_positions.js && node tests/test_render_shared.js && node tests/test_renderers.js && node tests/test_additive_fields.js && node tests/test_diagnostic_source.js && node tests/test_diagnose.js && node tests/test_correlate.js && node tests/test_diagnostics_score.js && node tests/test_runtime_error_dx.js && node tests/test_aot_error_dx.js && node tests/test_abort_early.js && node tests/test_branch_collapse.js && node tests/test_suggestions.js && node tests/test_cli_validate.js && node tests/test_cli_version.js && node benchmark/bench_aot_size.mjs",
     "bench:size": "node benchmark/bench_aot_size.mjs",
     "test:suite": "node tests/run_suite.js && node tests/run_suite.js draft7 && node tests/run_suite.js v1",
     "test:compat": "node tests/test_compat.js",
@@ -122,13 +122,13 @@
     "LICENSE"
   ],
   "optionalDependencies": {
-    "@ata-validator/native-darwin-arm64": "1.19.0",
-    "@ata-validator/native-darwin-x64": "1.19.0",
-    "@ata-validator/native-linux-arm64-gnu": "1.19.0",
-    "@ata-validator/native-linux-arm64-musl": "1.19.0",
-    "@ata-validator/native-linux-x64-gnu": "1.19.0",
-    "@ata-validator/native-linux-x64-musl": "1.19.0",
-    "@ata-validator/native-win32-x64": "1.19.0"
+    "@ata-validator/native-darwin-arm64": "1.20.0",
+    "@ata-validator/native-darwin-x64": "1.20.0",
+    "@ata-validator/native-linux-arm64-gnu": "1.20.0",
+    "@ata-validator/native-linux-arm64-musl": "1.20.0",
+    "@ata-validator/native-linux-x64-gnu": "1.20.0",
+    "@ata-validator/native-linux-x64-musl": "1.20.0",
+    "@ata-validator/native-win32-x64": "1.20.0"
   },
   "peerDependencies": {
     "yaml": "^2.0.0"