ata-validator 1.52.0 → 1.54.0

package/lib/compat-errors.js

@@ -31,6 +31,8 @@ const REFERENCE_ORDER = [
   'maxLength', 'minLength', 'pattern', 'format',
   'maxItems', 'minItems', 'additionalItems', 'prefixItems', 'items', 'contains', 'uniqueItems', 'maxContains', 'minContains', 'unevaluatedItems',
   'maxProperties', 'minProperties', 'required', 'propertyNames', 'additionalProperties', 'dependencies', 'dependentRequired', 'dependentSchemas', 'properties', 'patternProperties', 'unevaluatedProperties',
+  // The reference's `discriminator` option adds the keyword last.
+  'discriminator',
 ];
 const REFERENCE_RANK = new Map(REFERENCE_ORDER.map((k, i) => [k, i]));
 
@@ -78,13 +80,26 @@ function classify(segs) {
 // segments, and each segment's kind. Everything below used to re-derive these
 // wherever it needed them, which for one shaped rejection meant splitting the
 // same pointer three times per error.
+// Memoized by schemaPath: a schema reports a fixed set of paths, and a
+// rejection reshaped every error's path from scratch, which was a third of the
+// compat error path. The key is read, never written, by its users. Bounded so
+// a schema with paths that grow with the data (recursion) cannot fill memory.
+const _keys = new Map();
 function keyFor(e) {
-  const rel = pointerOf(e && e.schemaPath ? e.schemaPath : '#');
+  const sp = e && e.schemaPath ? e.schemaPath : '#';
+  let k = _keys.get(sp);
+  if (k !== undefined) return k;
+  const rel = pointerOf(sp);
   const segs = segments(rel);
-  return { rel, segs, kinds: classify(segs) };
+  k = { rel, segs, kinds: classify(segs) };
+  if (_keys.size >= 4096) _keys.clear();
+  _keys.set(sp, k);
+  return k;
 }
 
-function sortByKeys(errors, keys) {
+// `rankAt(segs, i)`, when given, can rank a keyword by where it sits: a
+// oneOf the discriminator decides is reported where the discriminator is.
+function sortByKeys(errors, keys, rankAt) {
   if (errors.length < 2) return errors.slice();
   const keyed = errors.map((e) => ({ e, k: keys.get(e) }));
   keyed.sort((A, B) => {
@@ -93,8 +108,8 @@ function sortByKeys(errors, keys) {
     for (let i = 0; i < n; i++) {
       if (pa[i] === pb[i]) continue;
       if (ka[i] !== 'kw') return 0;
-      const ra = REFERENCE_RANK.get(pa[i]);
-      const rb = REFERENCE_RANK.get(pb[i]);
+      const ra = rankAt ? rankAt(pa, i) : REFERENCE_RANK.get(pa[i]);
+      const rb = rankAt ? rankAt(pb, i) : REFERENCE_RANK.get(pb[i]);
       if (ra === undefined || rb === undefined) return 0;
       return ra - rb;
     }
@@ -143,7 +158,22 @@ function asReferenceKeyword(e) {
   return e.keyword === 'not' && e.message === 'boolean schema is false' ? { ...e, keyword: 'false schema' } : e;
 }
 
-function createShaper({ Validator, rootId, rootDoc, schemas, options, allErrors, macroKeywords }) {
+const FRAGMENT = 'ata-compat:fragment:';
+
+// Whether a schema holds a reference anywhere, the reference's test for
+// compiling a `$ref` target as a function of its own instead of inlining it.
+const REF_KEYWORDS = new Set(['$ref', '$recursiveRef', '$recursiveAnchor', '$dynamicRef', '$dynamicAnchor']);
+function hasRef(schema) {
+  if (schema === null || typeof schema !== 'object') return false;
+  for (const key in schema) {
+    if (REF_KEYWORDS.has(key)) return true;
+    const sch = schema[key];
+    if (Array.isArray(sch) ? sch.some(hasRef) : (sch !== null && typeof sch === 'object' && hasRef(sch))) return true;
+  }
+  return false;
+}
+
+function createShaper({ Validator, rootId, rootDoc, schemas, options, allErrors, macroKeywords, discriminator }) {
   const branchCache = new Map();
   const branchValidator = (pointer) => {
     let v = branchCache.get(pointer);
@@ -156,6 +186,74 @@ function createShaper({ Validator, rootId, rootDoc, schemas, options, allErrors,
   const wrappers = new Set(WRAPPERS);
   for (const k of macroKeywords) wrappers.add(k);
 
+  // Where a schema path really points. ata reports a keyword reached through
+  // a local `$ref` at the referring node (`#/properties/s/maxLength`), the
+  // reference at the node the `$ref` names (`#/definitions/S/maxLength`).
+  // Walking the document, a segment the node does not have, on a node with a
+  // `#/...` `$ref`, continues at the target. Anything else stays as it is.
+  // Under the discriminator option a oneOf beside a `discriminator` is the
+  // discriminator's: its branch errors come where that keyword runs.
+  const discriminated = discriminator === true;
+  const rankAt = (segs, i) => {
+    if (segs[i] === 'oneOf') {
+      const node = walkPointer(rootDoc, canonical(segs.length && i > 0 ? '/' + segs.slice(0, i).join('/') : ''));
+      if (node !== null && typeof node === 'object' && node.discriminator && typeof node.discriminator.propertyName === 'string') return REFERENCE_RANK.get('discriminator');
+    }
+    return REFERENCE_RANK.get(segs[i]);
+  };
+  const canonCache = new Map();
+  const reportCache = new Map();
+  // `reported` false: the pointer of the node itself, to read the schema at.
+  // `reported` true: the path the reference reports, which differs after a
+  // `$ref` it compiles as a function of its own rather than inlining (one
+  // whose target holds a `$ref`): errors from there carry the path from
+  // that target, `#/...`, as if it were a root.
+  function follow(pointer, reported) {
+    const cache = reported ? reportCache : canonCache;
+    let out = cache.get(pointer);
+    if (out !== undefined) return out;
+    out = pointer;
+    let node = rootDoc, path = '', moved = false, ok = true;
+    for (const raw of segments(pointer)) {
+      const seg = unescape(raw);
+      let first = null, hops = 0;
+      for (; hops < 32 && node !== null && typeof node === 'object' && !Array.isArray(node) &&
+          !Object.prototype.hasOwnProperty.call(node, seg) && typeof node.$ref === 'string' &&
+          (node.$ref.startsWith('#/') || node.$ref.startsWith(FRAGMENT)); hops++) {
+        // A schema registered under a fragment-only key (see fragmentKey in
+        // compat.js) is named by that key, as the reference names it.
+        const registered = node.$ref.startsWith(FRAGMENT);
+        if (registered && !reported) { ok = false; break; }
+        let target;
+        try { target = decodeURIComponent(registered ? node.$ref.slice(FRAGMENT.length) : node.$ref.slice(1)); } catch { target = null; }
+        if (target === null) { ok = false; break; }
+        node = registered ? (schemas ? schemas[node.$ref] : undefined) : walkPointer(rootDoc, target);
+        if (first === null) first = target;
+        if (!reported) path = target;
+        moved = true;
+      }
+      if (!ok) break;
+      // A `$ref` to a `$ref` is reported at the first target, as the
+      // reference reports it, unless the reference compiled the last one on
+      // its own.
+      if (reported && first !== null) path = hasRef(node) ? '' : first;
+      if (node === null || typeof node !== 'object') { ok = false; break; }
+      node = Array.isArray(node) ? node[Number(seg)] : node[seg];
+      path += '/' + raw;
+    }
+    if (ok && moved && node !== undefined) out = path;
+    if (cache.size >= 4096) cache.clear();
+    cache.set(pointer, out);
+    return out;
+  }
+  const canonical = (pointer) => follow(pointer, false);
+  function canonicalError(e) {
+    const sp = e.schemaPath;
+    if (typeof sp !== 'string' || !sp.startsWith('#')) return e;
+    const c = follow(sp.slice(1), true);
+    return c === sp.slice(1) ? e : { ...e, schemaPath: '#' + c };
+  }
+
   // Errors whose schemaPath is already absolute (from the root), as opposed
   // to relative to the branch validator that produced them.
   const absolute = new WeakSet();
@@ -163,14 +261,16 @@ function createShaper({ Validator, rootId, rootDoc, schemas, options, allErrors,
   // Returns the shaped errors of `value` against the subschema at `pointer`
   // (absolute), with schemaPath made absolute and instancePath rebased onto
   // the caller's.
-  function subErrors(pointer, value, schemaPrefix, instancePrefix) {
+  // `pointer` is where the subschema is; `at`, when given, is the path its
+  // errors are reported under, the referring one ata's own errors use.
+  function subErrors(pointer, value, schemaPrefix, instancePrefix, at) {
     const r = branchValidator(pointer).validate(value);
     if (r.valid) return null;
     const shaped = shape(r.errors, value, pointer);
     return shaped.map((e) => {
       const out = {
         ...e,
-        schemaPath: absolute.has(e) ? e.schemaPath : schemaPrefix + pointer + pointerOf(e.schemaPath || '#'),
+        schemaPath: absolute.has(e) ? e.schemaPath : schemaPrefix + (at === undefined ? pointer : at) + pointerOf(e.schemaPath || '#'),
         instancePath: instancePrefix + (e.instancePath || ''),
       };
       absolute.add(out);
@@ -187,7 +287,7 @@ function createShaper({ Validator, rootId, rootDoc, schemas, options, allErrors,
   function shape(errors, data, basePointer) {
     const keys = new Map();
     for (const e of errors) keys.set(e, keyFor(e));
-    const sorted = sortByKeys(errors, keys);
+    const sorted = sortByKeys(errors, keys, discriminated ? rankAt : undefined);
     const out = [];
     const consumed = new Set();
     let thenGroup = null; // { prefix, which } for the pending `if` wrapper
@@ -208,7 +308,8 @@ function createShaper({ Validator, rootId, rootDoc, schemas, options, allErrors,
       if (consumed.has(e)) continue;
       const K = keys.get(e);
       const rel = K.rel;
-      const abs = basePointer + rel;
+      const raw = basePointer + rel;
+      const abs = canonical(raw);
       const segs = K.segs;
       const kinds = K.kinds;
       const schemaPrefix = (e.schemaPath || '#').slice(0, (e.schemaPath || '#').indexOf('#') + 1);
@@ -241,14 +342,25 @@ function createShaper({ Validator, rootId, rootDoc, schemas, options, allErrors,
           const value = walkData(data, e.instancePath || '');
           const branchErrors = [];
           const passing = [];
+          // The validator kept every branch's errors when keywords may have
+          // changed the data: validating a branch again would see the change.
+          const kept = basePointer === '' && Array.isArray(e._branches) && e._branches.length === branches.length ? e._branches : null;
           for (let i = 0; i < branches.length; i++) {
-            const errs = subErrors(abs + '/' + i, value, schemaPrefix, e.instancePath || '');
+            let errs;
+            if (kept !== null) {
+              errs = kept[i].valid ? null : shape(kept[i].errors, data, '');
+              if (errs !== null) for (const x of errs) absolute.add(x);
+            } else errs = subErrors(abs + '/' + i, value, schemaPrefix, e.instancePath || '', raw + '/' + i);
             if (errs === null) passing.push(i);
             else branchErrors.push(allErrors ? errs : errs.slice(0, groupEnd(errs)));
           }
           if (passing.length === 0) {
             for (const errs of branchErrors) out.push(...errs);
-            out.push(e);
+            // The reference's own wording and params for no branch passing;
+            // the collapsed error validate() reports names the count instead.
+            out.push(kw === 'oneOf'
+              ? keywordError('oneOf', e.instancePath || '', e.schemaPath, { passingSchemas: null }, 'must match exactly one schema in oneOf')
+              : keywordError('anyOf', e.instancePath || '', e.schemaPath, {}, 'must match a schema in anyOf'));
           } else if (kw === 'oneOf') {
             out.push({ ...e, params: { passingSchemas: passing }, message: 'must match exactly one schema in oneOf' });
           } else {
@@ -291,7 +403,7 @@ function createShaper({ Validator, rootId, rootDoc, schemas, options, allErrors,
         const items = walkData(data, e.instancePath || '');
         if (Array.isArray(items)) {
           for (let i = 0; i < items.length; i++) {
-            const errs = subErrors(abs, items[i], schemaPrefix, (e.instancePath || '') + '/' + i);
+            const errs = subErrors(abs, items[i], schemaPrefix, (e.instancePath || '') + '/' + i, raw);
             if (errs !== null) out.push(...errs);
           }
           out.push(e);
@@ -304,7 +416,7 @@ function createShaper({ Validator, rootId, rootDoc, schemas, options, allErrors,
       const depIndex = segs.findIndex((s, i) => kinds[i] === 'kw' && (s === 'dependentRequired' || s === 'dependentSchemas'));
       if (depIndex >= 0) {
         const nodePointer = basePointer + (depIndex === 0 ? '' : '/' + segs.slice(0, depIndex).join('/'));
-        const node = walkPointer(rootDoc, nodePointer);
+        const node = walkPointer(rootDoc, canonical(nodePointer));
         if (node && typeof node === 'object' && node.dependencies && typeof node.dependencies === 'object') {
           const rewritten = segs.slice();
           rewritten[depIndex] = 'dependencies';
@@ -379,7 +491,7 @@ function createShaper({ Validator, rootId, rootDoc, schemas, options, allErrors,
     if (e.keyword !== 'type' || typeof e.message !== 'string' || !e.message.startsWith('must be ')) return e;
     const ptr = pointerOf(e.schemaPath || '');
     if (!ptr.endsWith('/type')) return e;
-    const node = walkPointer(rootDoc, ptr.slice(0, -'/type'.length));
+    const node = walkPointer(rootDoc, canonical(ptr.slice(0, -'/type'.length)));
     let t = node && typeof node === 'object' && node.type !== undefined ? node.type : e.params && e.params.type;
     if (t === undefined) return e;
     if (node && node.nullable === true && Array.isArray(t) && !t.includes('null')) t = [...t, 'null'];
@@ -387,10 +499,12 @@ function createShaper({ Validator, rootId, rootDoc, schemas, options, allErrors,
   }
 
   return function shapeErrors(errors, data) {
+    // Paths are made the reference's last: the grouping above reads them as
+    // ata reports them, through the referring node.
     const shaped = shape(errors, data, '').map(asReferenceKeyword).map(asReferenceType);
-    if (allErrors) return shaped;
+    if (allErrors) return shaped.map(canonicalError);
     const n = groupEnd(shaped);
-    return shaped.slice(0, n);
+    return shaped.slice(0, n).map(canonicalError);
   };
 }
 

package/lib/dialect.js

@@ -28,4 +28,39 @@ function isV1Dialect(schema) {
   return V1_DIALECTS.has(uri);
 }
 
-module.exports = { isV1Dialect, V1_DIALECTS };
+// The earlier dialects by their meta-schema URIs. draftCode is asked of every
+// schema, so it lives here, in a file every validator loads, and the
+// normalizers in draft7.js load only for a schema that declares one of these.
+// draft-06 is read through the draft-07 rules (see draft7.js).
+const DRAFT7_SCHEMAS = new Set([
+  'http://json-schema.org/draft-07/schema#',
+  'http://json-schema.org/draft-07/schema',
+  'http://json-schema.org/draft-06/schema#',
+  'http://json-schema.org/draft-06/schema',
+]);
+const DRAFT6_SCHEMAS = new Set([
+  'http://json-schema.org/draft-06/schema#',
+  'http://json-schema.org/draft-06/schema',
+]);
+// draft-04 is read through the draft-06 rules plus its own: `id` for `$id`,
+// and no `const`, `contains` or `propertyNames` (see draft7.js).
+const DRAFT4_SCHEMAS = new Set([
+  'http://json-schema.org/draft-04/schema#',
+  'http://json-schema.org/draft-04/schema',
+]);
+const DRAFT2019_SCHEMAS = new Set([
+  'https://json-schema.org/draft/2019-09/schema',
+  'https://json-schema.org/draft/2019-09/schema#',
+]);
+
+// 0 for 2020-12 and later, 1 draft-07, 2 draft-06, 3 2019-09, 4 draft-04.
+function draftCode(uri) {
+  if (typeof uri !== 'string') return 0;
+  if (DRAFT4_SCHEMAS.has(uri)) return 4;
+  if (DRAFT6_SCHEMAS.has(uri)) return 2;
+  if (DRAFT7_SCHEMAS.has(uri)) return 1;
+  if (DRAFT2019_SCHEMAS.has(uri)) return 3;
+  return 0;
+}
+
+module.exports = { isV1Dialect, V1_DIALECTS, DRAFT7_SCHEMAS, DRAFT6_SCHEMAS, DRAFT4_SCHEMAS, DRAFT2019_SCHEMAS, draftCode };

package/lib/draft7.js

@@ -6,16 +6,7 @@
 // this, a draft-06 schema was read under 2020-12 and its tuple `items`,
 // `additionalItems` and `dependencies` were not applied: 30 cases of the
 // official draft-06 suite accepted documents they must reject.
-const DRAFT7_SCHEMAS = new Set([
-  'http://json-schema.org/draft-07/schema#',
-  'http://json-schema.org/draft-07/schema',
-  'http://json-schema.org/draft-06/schema#',
-  'http://json-schema.org/draft-06/schema',
-])
-const DRAFT6_SCHEMAS = new Set([
-  'http://json-schema.org/draft-06/schema#',
-  'http://json-schema.org/draft-06/schema',
-])
+const { DRAFT7_SCHEMAS, DRAFT6_SCHEMAS, DRAFT4_SCHEMAS, DRAFT2019_SCHEMAS, draftCode } = require('./dialect')
 
 function isDraft7(schema) {
   return !!(schema && typeof schema.$schema === 'string' && DRAFT7_SCHEMAS.has(schema.$schema))
@@ -28,9 +19,11 @@ function isDraft6(schema) {
 // `force` applies the draft-07 rules to a document that declares no dialect
 // of its own, which is how a retrieved schema inherits the root's draft.
 // `draft6` says the document, or the root it inherits from, is draft-06.
-function normalizeDraft7(schema, force, draft6) {
+// `draft4`: draft-04, read as draft-06 plus its own differences (below).
+function normalizeDraft7(schema, force, draft6, draft4) {
   if (!force && !isDraft7(schema)) return schema
-  _normalize(schema, draft6 === true || isDraft6(schema))
+  const d4 = draft4 === true || (typeof schema.$schema === 'string' && DRAFT4_SCHEMAS.has(schema.$schema))
+  _normalize(schema, d4 || draft6 === true || isDraft6(schema), d4)
   return schema
 }
 
@@ -38,13 +31,21 @@ function normalizeDraft7(schema, force, draft6) {
 // definitions are addressable by pointer, annotations are inert.
 const REF_SIBLINGS_KEPT = new Set(['$ref', '$defs', 'definitions', '$schema', '$comment', 'title', 'description', 'examples', 'default', 'readOnly', 'writeOnly'])
 
-function _normalize(schema, d6) {
+function _normalize(schema, d6, d4) {
   if (typeof schema !== 'object' || schema === null) return
 
   // draft-06 has no conditional: `if`, `then` and `else` are unknown keywords
   // there, so they are dropped rather than applied.
   if (d6) { delete schema.if; delete schema.then; delete schema.else }
 
+  // draft-04 names a schema's identifier `id`, and has none of draft-06's
+  // `const`, `contains` or `propertyNames`: unknown keywords there.
+  if (d4) {
+    delete schema.const; delete schema.contains; delete schema.propertyNames
+    if (typeof schema.id === 'string' && schema.$id === undefined && typeof schema.$ref !== 'string') schema.$id = schema.id
+    delete schema.id
+  }
+
   // In draft-07 an object with `$ref` is that reference and nothing else:
   // sibling keywords, `$id` included, are ignored. Dropping them here gives
   // every engine the same reading without each having to know the draft.
@@ -91,34 +92,38 @@ function _normalize(schema, d6) {
   }
 
   // Recurse into object-valued sub-schemas
-  const objSubs = ['properties', 'patternProperties', '$defs', 'definitions', 'dependentSchemas']
-  for (const key of objSubs) {
-    if (schema[key] && typeof schema[key] === 'object') {
-      for (const v of Object.values(schema[key])) {
-        if (typeof v === 'object' && v !== null) _normalize(v, d6)
+  for (const key of D7_OBJ_SUBS) {
+    const m = schema[key]
+    if (m && typeof m === 'object') {
+      for (const k in m) {
+        if (!Object.prototype.hasOwnProperty.call(m, k)) continue
+        const v = m[k]
+        if (typeof v === 'object' && v !== null) _normalize(v, d6, d4)
       }
     }
   }
 
   // Recurse into array-valued sub-schemas
-  const arrSubs = ['allOf', 'anyOf', 'oneOf', 'prefixItems']
-  for (const key of arrSubs) {
-    if (Array.isArray(schema[key])) {
-      for (const s of schema[key]) {
-        if (typeof s === 'object' && s !== null) _normalize(s, d6)
+  for (const key of D7_ARR_SUBS) {
+    const a = schema[key]
+    if (Array.isArray(a)) {
+      for (let i = 0; i < a.length; i++) {
+        const v = a[i]
+        if (typeof v === 'object' && v !== null) _normalize(v, d6, d4)
       }
     }
   }
 
   // Recurse into single sub-schemas
-  const singleSubs = ['items', 'contains', 'not', 'if', 'then', 'else',
-                       'additionalProperties', 'propertyNames']
-  for (const key of singleSubs) {
-    if (typeof schema[key] === 'object' && schema[key] !== null) {
-      _normalize(schema[key], d6)
-    }
+  for (const key of D7_SINGLE_SUBS) {
+    const v = schema[key]
+    if (typeof v === 'object' && v !== null) _normalize(v, d6, d4)
   }
 }
+// The schema-bearing keywords _normalize walks, built once rather than per node.
+const D7_OBJ_SUBS = ['properties', 'patternProperties', '$defs', 'definitions', 'dependentSchemas']
+const D7_ARR_SUBS = ['allOf', 'anyOf', 'oneOf', 'prefixItems']
+const D7_SINGLE_SUBS = ['items', 'contains', 'not', 'if', 'then', 'else', 'additionalProperties', 'propertyNames']
 
 // OpenAPI `nullable: true` is not JSON Schema. Convert it to a union with
 // 'null' (`{ type: 'X', nullable: true }` -> `{ type: ['X', 'null'] }`), the
@@ -170,12 +175,36 @@ function _walkExclusive(node, seen) {
 
 function normalizeNullable(schema) {
   if (typeof schema !== 'object' || schema === null) return schema
-  _normalizeNullable(schema)
+  const st = { seen: new Set(), refs: [] }
+  _normalizeNullable(schema, st)
+  // A local `$ref` can point anywhere in the document, an OpenAPI
+  // `components` section among them, where the walk over subschema keywords
+  // does not go. A schema reached that way is a schema all the same, and its
+  // `nullable` is folded too.
+  while (st.refs.length > 0) {
+    const target = _localTarget(schema, st.refs.pop())
+    if (typeof target === 'object' && target !== null && !Array.isArray(target)) _normalizeNullable(target, st)
+  }
   return schema
 }
 
-function _normalizeNullable(schema) {
+function _localTarget(root, ref) {
+  if (ref === '#') return root
+  if (!ref.startsWith('#/')) return undefined
+  let node = root
+  for (const raw of ref.slice(2).split('/')) {
+    let seg = raw.replace(/~1/g, '/').replace(/~0/g, '~')
+    if (seg.includes('%')) { try { seg = decodeURIComponent(seg) } catch { return undefined } }
+    if (node === null || typeof node !== 'object' || !Object.prototype.hasOwnProperty.call(node, seg)) return undefined
+    node = node[seg]
+  }
+  return node
+}
+
+function _normalizeNullable(schema, st) {
   if (typeof schema !== 'object' || schema === null) return
+  if (st.seen.has(schema)) return
+  st.seen.add(schema)
 
   if (schema.nullable === true && schema.type !== undefined) {
     if (Array.isArray(schema.type)) {
@@ -195,37 +224,39 @@ function _normalizeNullable(schema) {
   // alone: the engines decode once more, and `100%` must not be decoded twice.
   // This walk is the one every normalization runs, so it costs no second pass;
   // a reference it does not reach keeps the old behaviour, the interpreter.
-  if (/^#.*%/.test(schema.$ref)) {
+  if (typeof schema.$ref === 'string' && schema.$ref.charCodeAt(0) === 35 && schema.$ref.indexOf('%') > 0) {
     try {
       const decoded = decodeURIComponent(schema.$ref)
       if (!decoded.includes('%')) schema.$ref = decoded
     } catch {}
   }
-
-  const objSubs = ['properties', 'patternProperties', '$defs', 'definitions', 'dependentSchemas']
-  for (const key of objSubs) {
-    if (schema[key] && typeof schema[key] === 'object') {
-      for (const v of Object.values(schema[key])) {
-        if (typeof v === 'object' && v !== null) _normalizeNullable(v)
+  if (typeof schema.$ref === 'string' && schema.$ref.charCodeAt(0) === 35) st.refs.push(schema.$ref)
+
+  for (const key of D7_OBJ_SUBS) {
+    const m = schema[key]
+    if (m && typeof m === 'object') {
+      for (const k in m) {
+        if (!Object.prototype.hasOwnProperty.call(m, k)) continue
+        const v = m[k]
+        if (typeof v === 'object' && v !== null) _normalizeNullable(v, st)
       }
     }
   }
-  const arrSubs = ['allOf', 'anyOf', 'oneOf', 'prefixItems']
-  for (const key of arrSubs) {
-    if (Array.isArray(schema[key])) {
-      for (const s of schema[key]) {
-        if (typeof s === 'object' && s !== null) _normalizeNullable(s)
+  for (const key of D7_ARR_SUBS) {
+    const a = schema[key]
+    if (Array.isArray(a)) {
+      for (let i = 0; i < a.length; i++) {
+        const v = a[i]
+        if (typeof v === 'object' && v !== null) _normalizeNullable(v, st)
       }
     }
   }
-  const singleSubs = ['items', 'contains', 'not', 'if', 'then', 'else',
-                       'additionalProperties', 'propertyNames', 'unevaluatedItems', 'unevaluatedProperties']
-  for (const key of singleSubs) {
-    if (typeof schema[key] === 'object' && schema[key] !== null) {
-      _normalizeNullable(schema[key])
-    }
+  for (const key of NULLABLE_SINGLE_SUBS) {
+    const v = schema[key]
+    if (typeof v === 'object' && v !== null) _normalizeNullable(v, st)
   }
 }
+const NULLABLE_SINGLE_SUBS = ['items', 'contains', 'not', 'if', 'then', 'else', 'additionalProperties', 'propertyNames', 'unevaluatedItems', 'unevaluatedProperties']
 
 // Draft 2020-12 treats `format` as an annotation unless the assertion
 // vocabulary is in use. Removing the keyword is exactly that reading, and it
@@ -283,10 +314,6 @@ function _stripFormat(schema, seen) {
 // carries the anchor, and a plain `$ref: "#"` when it does not, which is what
 // 2019-09 says it means then. The outward search for the outermost anchored
 // resource is the same rule in both drafts.
-const DRAFT2019_SCHEMAS = new Set([
-  'https://json-schema.org/draft/2019-09/schema',
-  'https://json-schema.org/draft/2019-09/schema#',
-])
 const RECURSIVE_ANCHOR = '__ata_recursive_anchor'
 
 function isDraft2019(schema) {
@@ -338,12 +365,4 @@ function _normalize2019(node, resourceRoot, isRoot) {
 // The draft a `$schema` value names, for the normalizers: 2 draft-06,
 // 1 draft-07, 3 2019-09, 0 anything else. Takes the string so the caller
 // reads the property once.
-function draftCode(uri) {
-  if (typeof uri !== 'string') return 0
-  if (DRAFT6_SCHEMAS.has(uri)) return 2
-  if (DRAFT7_SCHEMAS.has(uri)) return 1
-  if (DRAFT2019_SCHEMAS.has(uri)) return 3
-  return 0
-}
-
 module.exports = { draftCode, isDraft7, isDraft6, isDraft2019, normalizeDraft2019, normalizeDraft7, normalizeNullable, normalizeExclusiveBounds, stripFormatAssertions }

package/lib/enrich-site.js

@@ -16,9 +16,31 @@ const { reprValue, expectedFor, detailFor, rankFor, MISSING, DOC_BASE } = requir
 // output. A module of its own because only the code generator reaches it, and
 // ata-validator/lite, which enriches through `enrich`, should not carry it.
 const NO_EXPECTED = {};
+// `detail` (see detailFor in lib/enrich-error.js), worked out at the site as
+// far as the site allows: the whole string when it depends only on the
+// params, its fixed head when only the received value is left to append, and
+// neither when it depends on the value (type) or the params are not fixed.
+const DETAIL_AT_RUN = 0;
+const DETAIL_FIXED = 1;
+const DETAIL_HEAD = 2;
+const RANGE_KEYWORDS = new Set(['minimum', 'maximum', 'exclusiveMinimum', 'exclusiveMaximum', 'minLength', 'maxLength']);
+function siteDetail (keyword, params, expected) {
+  if (params === undefined || keyword === 'type') return [DETAIL_AT_RUN, undefined];
+  switch (keyword) {
+    case 'required': return [DETAIL_FIXED, `missing required property "${params.missingProperty}"`];
+    case 'additionalProperties': return [DETAIL_FIXED, `unknown property "${params.additionalProperty}"`];
+    case 'unevaluatedProperties': return [DETAIL_FIXED, `unevaluated property "${params.unevaluatedProperty}"`];
+    case 'format': return [DETAIL_HEAD, `not a valid ${params.format}: `];
+  }
+  if (RANGE_KEYWORDS.has(keyword) || expected) return [DETAIL_HEAD, `expected ${expected}, found `];
+  return [DETAIL_FIXED, undefined];
+}
+
 function errorSite (keyword, schemaPath, params, format) {
   const dependent = keyword === 'required' && typeof schemaPath === 'string' && schemaPath.endsWith('/dependentRequired');
   const code = (dependent && 'ATA7005') || codeFor(keyword, format) || 'ATA9001';
+  const expected = params === undefined ? NO_EXPECTED : expectedFor({ keyword, params });
+  const [detailKind, detail] = siteDetail(keyword, params, expected);
   return {
     code,
     keyword,
@@ -26,7 +48,9 @@ function errorSite (keyword, schemaPath, params, format) {
     docUrl: DOC_BASE + code,
     rank: rankFor(keyword),
     headline: (CODES[code] && CODES[code].headline) || 'validation failed',
-    expected: params === undefined ? NO_EXPECTED : expectedFor({ keyword, params }),
+    expected,
+    detailKind,
+    detail,
   };
 }
 
@@ -49,7 +73,10 @@ function makeRich (site, path, params, message, value, root, spPrefix) {
   };
   const sugg = suggestFor(out, root, at === MISSING ? undefined : at);
   if (sugg) out.suggestion = sugg;
-  const detail = detailFor({ keyword: site.keyword, params }, out, at);
+  const kind = site.detailKind;
+  const detail = kind === DETAIL_FIXED ? site.detail
+    : kind === DETAIL_HEAD ? site.detail + out.received
+      : detailFor({ keyword: site.keyword, params }, out, at);
   if (detail !== undefined) out.detail = detail;
   out.rank = site.rank;
   return out;

package/lib/error-runtime.js

@@ -23,6 +23,8 @@ const FILES = [
   'safe-regex',
   'unique-items',
   'formats',
+  // The URI walk formats.js loads; left out with formats (see OPTIONAL).
+  'uri-core',
 ];
 // The parts a build can leave out when none of its schemas needs them. The
 // decision is made on the schemas the runtime walks (as embedded, see
@@ -91,8 +93,10 @@ function errorRuntimeSource(format, version, features, schemaMode) {
   if (hit !== undefined) return hit;
   const defs = [];
   for (const name of schemaMode ? FILES.concat(SCHEMA_FILES) : FILES) {
-    const src = OPTIONAL[name] !== undefined && !want(name)
-      ? OPTIONAL[name].stub
+    // uri-core goes with formats: only formats.js requires it.
+    const part = name === 'uri-core' ? 'formats' : name;
+    const src = OPTIONAL[part] !== undefined && !want(part)
+      ? (name === 'uri-core' ? 'module.exports = {};' : OPTIONAL[part].stub)
       : dropCommentLines(fs.readFileSync(path.join(__dirname, name + '.js'), 'utf8'), name);
     // The files' own require('./x') calls go to the table under another name:
     // a tool that reads the runtime without scope (knip, a lint rule) took a