ata-validator 1.61.0 → 1.61.1

package/lib/error-codes.js

@@ -26,16 +26,10 @@ const CODES = Object.freeze({
   ATA2013: { keyword: 'pattern', category: 'constraint', headline: 'string does not match pattern' },
 
   // ATA3xxx — format
-  ATA3001: { keyword: 'format', format: 'email', category: 'format', headline: 'value does not match format "email"' },
-  ATA3002: { keyword: 'format', format: 'date', category: 'format', headline: 'value does not match format "date"' },
-  ATA3003: { keyword: 'format', format: 'date-time', category: 'format', headline: 'value does not match format "date-time"' },
-  ATA3004: { keyword: 'format', format: 'time', category: 'format', headline: 'value does not match format "time"' },
-  ATA3005: { keyword: 'format', format: 'uri', category: 'format', headline: 'value does not match format "uri"' },
-  ATA3006: { keyword: 'format', format: 'uri-reference', category: 'format', headline: 'value does not match format "uri-reference"' },
-  ATA3007: { keyword: 'format', format: 'ipv4', category: 'format', headline: 'value does not match format "ipv4"' },
-  ATA3008: { keyword: 'format', format: 'ipv6', category: 'format', headline: 'value does not match format "ipv6"' },
-  ATA3009: { keyword: 'format', format: 'uuid', category: 'format', headline: 'value does not match format "uuid"' },
-  ATA3010: { keyword: 'format', format: 'hostname', category: 'format', headline: 'value does not match format "hostname"' },
+  // One entry per built-in format the engines name, in this order: the same
+  // object for each, so it is written once.
+  ...Object.fromEntries(['email', 'date', 'date-time', 'time', 'uri', 'uri-reference', 'ipv4', 'ipv6', 'uuid', 'hostname']
+    .map((format, i) => [`ATA30${String(i + 1).padStart(2, '0')}`, { keyword: 'format', format, category: 'format', headline: `value does not match format "${format}"` }])),
   ATA3099: { keyword: 'format', category: 'format', headline: 'value does not match user-defined format' },
 
   // ATA4xxx — composition
@@ -69,14 +63,6 @@ const CODES = Object.freeze({
   ATA9002: { keyword: '__compile__', category: 'system', headline: 'schema failed to compile' },
 });
 
-function get (code) {
-  return CODES[code];
-}
-
-function all () {
-  return Object.keys(CODES).sort();
-}
-
 // Reverse lookups, built once. codeFor runs per error on every failing
 // validation, so walking the table there showed up as most of the cost of
 // enriching a rejected payload. Insertion follows sorted code order, so the
@@ -101,62 +87,6 @@ function codeFor (keyword, format) {
 }
 
 
-// The native engine reports its own `error_code` enum from include/ata.h as an
-// ordinal. Nothing outside the addon should ever see one: an error that came
-// from there carries the same public code and keyword as the same failure from
-// the JavaScript engines. Ordinals are positional, so this table follows the
-// enum's declaration order and `tests/test_native_error_codes.js` fails if the
-// two drift apart.
-const NATIVE_KEYWORDS = [
-  null,                     // 0 ok
-  '__parse__',              // 1 invalid_json
-  '__compile__',            // 2 invalid_schema
-  'type',                   // 3 type_mismatch
-  'required',               // 4 required_property_missing
-  'additionalProperties',   // 5 additional_property_not_allowed
-  'enum',                   // 6 enum_mismatch
-  'const',                  // 7 const_mismatch
-  'minimum',                // 8 minimum_violation
-  'maximum',                // 9 maximum_violation
-  'exclusiveMinimum',       // 10 exclusive_minimum_violation
-  'exclusiveMaximum',       // 11 exclusive_maximum_violation
-  'minLength',              // 12 min_length_violation
-  'maxLength',              // 13 max_length_violation
-  'pattern',                // 14 pattern_mismatch
-  'format',                 // 15 format_mismatch
-  'minItems',               // 16 min_items_violation
-  'maxItems',               // 17 max_items_violation
-  'uniqueItems',            // 18 unique_items_violation
-  'minProperties',          // 19 min_properties_violation
-  'maxProperties',          // 20 max_properties_violation
-  'multipleOf',             // 21 multiple_of_violation
-  'allOf',                  // 22 all_of_failed
-  'anyOf',                  // 23 any_of_failed
-  'oneOf',                  // 24 one_of_failed
-  'not',                    // 25 not_failed
-  '$ref',                   // 26 ref_not_found
-  'if',                     // 27 if_then_else_failed
-  '__depth__',              // 28 depth_exceeded
-]
-
-// Keyword and public code for a native ordinal, or null when the ordinal is
-// outside the enum, which would mean the addon is newer than this table.
-function fromNative (ordinal, format) {
-  if (typeof ordinal !== 'number' || !Number.isInteger(ordinal)) return null
-  const keyword = NATIVE_KEYWORDS[ordinal]
-  if (!keyword) return null
-  // codeFor('format') answers with the first format code, which names a
-  // specific format. Without knowing which format failed, the generic one is
-  // the honest answer.
-  // The walker stopped at its depth limit and rejected the document. No
-  // public code names that: the APIs that ask the walker route schemas deep or
-  // recursive enough to reach it to validate() first (lib/buffer-gate.js), so
-  // it is the generic failure.
-  if (keyword === '__depth__') return { keyword, code: 'ATA9000' }
-  const code = keyword === 'format'
-    ? (format ? codeFor('format', format) || 'ATA3099' : 'ATA3099')
-    : codeFor(keyword) || 'ATA9001'
-  return { keyword, code }
-}
+// The native engine's ordinals are translated in lib/native-codes.js.
 
-module.exports = { CODES, get, all, codeFor, fromNative, NATIVE_KEYWORDS };
+module.exports = { CODES, codeFor };

package/lib/formats-source.js

@@ -263,6 +263,21 @@ const EMAIL_LOCAL_SRC = (v) => `(${v}>32&&${v}<127&&${v}!==34&&${v}!==40&&${v}!=
 // functions by their source text, so anything reaching a free variable would
 // not survive the trip. The domain half reuses hostnameSource, which keeps
 // one hostname implementation for both halves of this file.
+// The check of an email address literal's inside (`_in`, between the
+// brackets). Where code is written for a module, by expression
+// (lib/email-literal.js), which is a fraction of the bytes of the parsers. A
+// browser build maps that module to nothing: its generator writes code for the
+// page alone, so it uses the parsers it carries anyway and the expression's
+// builder stays out of the page. tests/test_ipv6_expression.js holds both forms
+// to the same answers.
+const _literalByParsers = () =>
+  `if((_in.charCodeAt(0)|32)===105&&(_in.charCodeAt(1)|32)===112&&(_in.charCodeAt(2)|32)===118&&_in.charCodeAt(3)===54&&_in.charCodeAt(4)===58){const _i6=_in.slice(5);${ipv6Source('_i6', true)}}` +
+  `else{${ipv4Source('_in', true)}}`;
+const _emailLiteral = () => {
+  const byExpression = require('./email-literal');
+  return typeof byExpression === 'function' ? byExpression() : _literalByParsers();
+};
+
 function emailSource (v, isStr) {
   const inner =
     // One forward pass, and neither half sliced out. '@' is not a local-part
@@ -294,8 +309,10 @@ function emailSource (v, isStr) {
       `const _dm=${v}.slice(_at+1);` +
       `if(_dm.charCodeAt(_dm.length-1)!==93||_dm.length<=2)return false;` +
       `const _in=_dm.slice(1,-1);` +
-      `if((_in.charCodeAt(0)|32)===105&&(_in.charCodeAt(1)|32)===112&&(_in.charCodeAt(2)|32)===118&&_in.charCodeAt(3)===54&&_in.charCodeAt(4)===58){const _i6=_in.slice(5);${ipv6Source('_i6', true)}}` +
-      `else{${ipv4Source('_in', true)}}` +
+      // The literal is rare, and checked by expression rather than by the
+      // IPv6 and IPv4 parsers, which made it 72% of this check's source:
+      // the same answers (tests/test_ipv6_expression.js), a fraction of the bytes.
+      _emailLiteral() +
     `}` +
     `else{${hostnameRangeSource(v, '_at+1', `${v}.length`)}}`;
   return isStr ? `{${inner}}` : `if(typeof ${v}==='string'){${inner}}`;
@@ -304,4 +321,4 @@ function durationSource (v, isStr) {
   const inner = `if(!${_formats().DURATION_RE.toString()}.test(${v}))return false`;
   return isStr ? inner : `if(typeof ${v}==='string'&&${inner.slice(3)}`;
 }
-module.exports = { uriHelperSource, uriHelperCompactSource, uriSource, uriReferenceSource, iriSource, iriReferenceSource, idnEmailSource, dateSource, ipv4Source, dateTimeSource, ipv6Source, hostnameSource, uuidSource, timeSource, noReservedSource, jsonPointerSource, relativeJsonPointerSource, uriTemplateSource, emailSource, durationSource };
+module.exports = { _literalByParsers, uriHelperSource, uriHelperCompactSource, uriSource, uriReferenceSource, iriSource, iriReferenceSource, idnEmailSource, dateSource, ipv4Source, dateTimeSource, ipv6Source, hostnameSource, uuidSource, timeSource, noReservedSource, jsonPointerSource, relativeJsonPointerSource, uriTemplateSource, emailSource, durationSource };

package/lib/js-compiler-errors.js

@@ -2028,6 +2028,10 @@ const NOT_VALIDATING = new Set(['$schema', '$id', '$anchor', '$comment', '$defs'
 function typeMismatchRest(schema, types) {
   const drop = new Set(['type', 'enum', 'const', 'anyOf', 'oneOf'])
   for (const t of types) for (const k of (TYPE_KEYWORDS[t] || [])) drop.add(k)
+  // A built-in format is written for strings only (`typeof v==='string'&&`
+  // off the string path), so for a value that failed `type: string` it can
+  // never fire: carried here it was dead code in every module that checks one.
+  if (types.includes('string') && typeof schema.format === 'string' && FORMAT_CODEGEN[schema.format]) drop.add('format')
   // A non-integer number reaches the type block already (numberToo).
   let rest = null
   for (const k of Object.keys(schema)) {

package/lib/json-rejections.js

@@ -0,0 +1,159 @@
+'use strict';
+
+// The rejection validateJSON() returns, and the position map behind an error's
+// frame in the JSON text. Apart from lib/rejections.js so that code with no
+// JSON entry point (validate() through a compiled wrapper) does not bundle it.
+
+const { needsOrdering, sortErrorsBySchemaOrder, attachRelated, _setPositionsFor } = require('./rejections');
+const { setDiagnosticSource: attachDiagnosticSource } = require('./diagnostic-source');
+
+// The rejection validateJSON returns. Everything the text path adds over
+// validate(data), the value tree enrichment needs, the position map, the
+// diagnostic payload, happens on first access to `.errors`. Reading `.valid`
+// touches none of it. The JSON text is held here rather than read back off the
+// validator, so the result does not depend on what the instance does next.
+class LazyJsonRejection {
+  // `parsed`, when given, is the document the inner path parsed from
+  // `jsonStr` and validated, after defaults, coercion and removal: reading the
+  // errors uses it instead of parsing the text again, which on a 5 MB
+  // document was a third of what reading them cost.
+  constructor(result, jsonStr, self, enrich, parsed) {
+    this.valid = false;
+    this._result = result;
+    this._jsonStr = jsonStr;
+    this._self = self;
+    this._enrich = enrich;
+    this._cached = null;
+    this._parsed = parsed;
+  }
+  toJSON() {
+    return { valid: false, errors: this.errors };
+  }
+}
+Object.defineProperty(LazyJsonRejection.prototype, 'errors', {
+  enumerable: true,
+  configurable: true,
+  get() {
+    if (this._cached !== null) return this._cached;
+    const self = this._self;
+    const enrich = this._enrich;
+    const jsonStr = this._jsonStr;
+    // Reading the inner errors realizes the inner lazy layer, if there was one.
+    const raw = this._result.errors || [];
+    if (!raw.length) { this._cached = raw; return raw; }
+
+    // The enrich pass plucks `received` from the value tree and the suggestion
+    // engine (required-typo, format hints, coercion nudges) walks it too.
+    let parsedData = this._parsed;
+    if (parsedData === undefined) {
+      try { parsedData = JSON.parse(jsonStr); } catch { parsedData = undefined; }
+      // What was checked is the document after defaults, coercion and removal,
+      // so `received` has to come from that, as it does for validate(). A
+      // default that failed its own schema has no value in the text at all.
+      if (parsedData !== undefined && self._preprocess) self._preprocess(parsedData);
+    }
+
+    // Errors the inner path already enriched carry a `received` key: enrich()
+    // always sets one, even when there is no value to show. `code` is not a
+    // safe signal, because branch-collapse attaches codes to raw errors, and
+    // `docUrl` is not either, because the generated error functions stamp it
+    // on raw errors; taking it as the signal left those errors without
+    // `received` or a suggestion on the text path while validate() had both.
+    if (!raw[0] || !('received' in raw[0])) {
+      // Declaration order, as validate() applies it; the text path used to
+      // enrich in emission order.
+      const ordered = needsOrdering(raw) ? sortErrorsBySchemaOrder(self._schemaObj, raw) : raw;
+      // The position map waits for the first read of a frame (lib/enrich-error
+      // defineLazyFrames); until then reading the list costs the enrichment alone.
+      const lazyPositions = lazyPositionsFor(self, jsonStr, ordered);
+      const enrichOpts = {
+        data: parsedData,
+        positions: null,
+        lazyPositions,
+        schemaPositions: self._schemaPositions,
+        schemaFile: self._source ? self._source.path : undefined,
+      };
+      const enriched = ordered.map((e) => enrich(e, enrichOpts));
+      if (enriched.length > 1) attachRelated(enriched);
+      attachDiagnosticSource(enriched, {
+        data: parsedData,
+        text: jsonStr,
+        // Read by the diagnostic renderer only, which resolves the same map.
+        get positions () { return lazyPositions(); },
+        schema: self._schemaObj,
+        mutatesInput: self._mutatesInput === true,
+      });
+      this._cached = enriched;
+      return enriched;
+    }
+
+    // Already enriched, so the frames are usually attached too. Only a gap in
+    // them is worth another walk of the document: resolving the map to discover
+    // there was nothing to fill cost a second full walk on every rejection.
+    if (raw.some((e) => e && !e.dataFrame)) {
+      const positions = self._pos().targeted(jsonStr, wantedPointersFor(raw.filter((e) => e && !e.dataFrame)));
+      if (positions) {
+        for (const e of raw) {
+          if (e && !e.dataFrame) {
+            const path = e.path != null ? e.path : (e.instancePath || '');
+            const p = positions[path];
+            if (p) e.dataFrame = { byteOffset: p.byteOffset, length: p.length, line: p.line, col: p.col, text: p.text };
+          }
+        }
+        self._posCache.reset();
+      }
+    }
+    if (raw.length > 1) attachRelated(raw);
+    attachDiagnosticSource(raw, {
+      data: parsedData,
+      text: jsonStr,
+      schema: self._schemaObj,
+      mutatesInput: self._mutatesInput === true,
+    });
+    this._cached = raw;
+    return raw;
+  },
+});
+
+// The targeted position map for a list, built on the first call and shared
+// by every error's frame accessor (lib/enrich-error defineLazyFrames).
+function lazyPositionsFor (self, text, errors) {
+  let done = false;
+  let positions = null;
+  return () => {
+    if (done) return positions;
+    done = true;
+    positions = self._pos().targeted(text, wantedPointersFor(errors));
+    if (positions) self._posCache.reset();
+    return positions;
+  };
+}
+
+// The pointers a set of errors will ask the position map about. lib/enrich-error
+// looks up the error's own path, and for an additional or unevaluated property
+// the child pointer named in `params`, unescaped, which is the form it asks for.
+// The escaped form goes in too: including a pointer that is never read costs
+// nothing, and the cache answers anything outside this set from the full map
+// rather than reporting no position.
+function wantedPointersFor (errors) {
+  const wanted = new Set();
+  for (const e of errors) {
+    if (!e) continue;
+    const path = e.path != null ? e.path : (e.instancePath || '');
+    wanted.add(path);
+    if (e.instancePath != null && e.instancePath !== path) wanted.add(e.instancePath);
+    const params = e.params;
+    const named = params && (params.additionalProperty || params.unevaluatedProperty);
+    if (typeof named === 'string') {
+      wanted.add(path + '/' + named);
+      if (named.indexOf('~') !== -1 || named.indexOf('/') !== -1) {
+        wanted.add(path + '/' + named.replace(/~/g, '~0').replace(/\//g, '~1'));
+      }
+    }
+  }
+  return wanted;
+}
+
+_setPositionsFor(lazyPositionsFor);
+
+module.exports = { LazyJsonRejection };

package/lib/native-codes.js

@@ -0,0 +1,67 @@
+'use strict';
+
+// A module of its own so the browser build, which has no native engine
+// (lib/native-load.browser.js), maps it to lib/native-codes.browser.js and
+// carries no table for ordinals that never reach it.
+
+const { codeFor } = require('./error-codes');
+
+// The native engine reports its own `error_code` enum from include/ata.h as an
+// ordinal. Nothing outside the addon should ever see one: an error that came
+// from there carries the same public code and keyword as the same failure from
+// the JavaScript engines. Ordinals are positional, so this table follows the
+// enum's declaration order and `tests/test_native_error_codes.js` fails if the
+// two drift apart.
+const NATIVE_KEYWORDS = [
+  null,                     // 0 ok
+  '__parse__',              // 1 invalid_json
+  '__compile__',            // 2 invalid_schema
+  'type',                   // 3 type_mismatch
+  'required',               // 4 required_property_missing
+  'additionalProperties',   // 5 additional_property_not_allowed
+  'enum',                   // 6 enum_mismatch
+  'const',                  // 7 const_mismatch
+  'minimum',                // 8 minimum_violation
+  'maximum',                // 9 maximum_violation
+  'exclusiveMinimum',       // 10 exclusive_minimum_violation
+  'exclusiveMaximum',       // 11 exclusive_maximum_violation
+  'minLength',              // 12 min_length_violation
+  'maxLength',              // 13 max_length_violation
+  'pattern',                // 14 pattern_mismatch
+  'format',                 // 15 format_mismatch
+  'minItems',               // 16 min_items_violation
+  'maxItems',               // 17 max_items_violation
+  'uniqueItems',            // 18 unique_items_violation
+  'minProperties',          // 19 min_properties_violation
+  'maxProperties',          // 20 max_properties_violation
+  'multipleOf',             // 21 multiple_of_violation
+  'allOf',                  // 22 all_of_failed
+  'anyOf',                  // 23 any_of_failed
+  'oneOf',                  // 24 one_of_failed
+  'not',                    // 25 not_failed
+  '$ref',                   // 26 ref_not_found
+  'if',                     // 27 if_then_else_failed
+  '__depth__',              // 28 depth_exceeded
+]
+
+// Keyword and public code for a native ordinal, or null when the ordinal is
+// outside the enum, which would mean the addon is newer than this table.
+function fromNative (ordinal, format) {
+  if (typeof ordinal !== 'number' || !Number.isInteger(ordinal)) return null
+  const keyword = NATIVE_KEYWORDS[ordinal]
+  if (!keyword) return null
+  // codeFor('format') answers with the first format code, which names a
+  // specific format. Without knowing which format failed, the generic one is
+  // the honest answer.
+  // The walker stopped at its depth limit and rejected the document. No
+  // public code names that: the APIs that ask the walker route schemas deep or
+  // recursive enough to reach it to validate() first (lib/buffer-gate.js), so
+  // it is the generic failure.
+  if (keyword === '__depth__') return { keyword, code: 'ATA9000' }
+  const code = keyword === 'format'
+    ? (format ? codeFor('format', format) || 'ATA3099' : 'ATA3099')
+    : codeFor(keyword) || 'ATA9001'
+  return { keyword, code }
+}
+
+module.exports = { fromNative, NATIVE_KEYWORDS };

package/lib/native-message.js

@@ -0,0 +1,8 @@
+'use strict';
+
+// The words for an error the native engine reported without a message (it
+// reports numeric codes): the enrich pass knows them. A module of its own so
+// the browser build, which has no native engine (lib/native-load.browser.js),
+// maps it to lib/native-message.browser.js and leaves the enrichment out of
+// bundles that only reach it from here, such as ata-validator/compiled-plain.
+module.exports = (err) => require('./enrich-error').enrich(err, {}).message;

package/lib/native.browser.js

@@ -0,0 +1,11 @@
+'use strict';
+
+// Browser build of lib/native-message.js, lib/native-codes.js and
+// lib/native-positions.js, one file for all three so a page carries one module
+// for them: there is no native engine in a browser (lib/native-load.browser.js
+// returns null), so no error arrives without a message or with a native
+// ordinal, and no position is found by the addon. Kept total all the same.
+const message = (err) => (err && err.message) || 'validation failed';
+message.fromNative = message.nativeTargeted = () => null;
+message.NATIVE_KEYWORDS = [];
+module.exports = message;

package/lib/rejections.js

@@ -1,13 +1,12 @@
 'use strict';
 
-// The rejection objects validate() and validateJSON() return, and the helpers
+// The rejection objects validate() returns, and the helpers
 // that build their errors on first read: declaration-order sorting,
 // enrichment, typo correlation and source frames. Shared by the validator core
 // and by the wrapper around a compiled module, so both report errors through
-// the same code.
+// the same code. The one validateJSON() returns is in lib/json-rejections.js.
 
 const { ordinalFor: schemaOrdinal, rankFor: schemaRank } = require('./schema-order');
-const { setDiagnosticSource: attachDiagnosticSource } = require('./diagnostic-source');
 
 // Rejection result with errors materialized on first read. The accessor
 // lives on the prototype so constructing one is a plain allocation; an
@@ -80,6 +79,15 @@ class RichRejection {
     return raw;
   }
 }
+// The position map builder of lib/json-rejections.js, which sets it when it
+// loads. Only validateJSON passes JSON text here, and the code that calls it
+// loads that module first (were it not, the call below throws, it does not
+// skip the frames); validate() and a compiled wrapper without the JSON
+// entry points never load it, so their bundles carry neither it nor the
+// rejection validateJSON returns (532 bytes gzipped of the wrapper).
+let _positionsFor = null;
+function _setPositionsFor (fn) { _positionsFor = fn; }
+
 // Orders a raw error list and gives it the shape the caller asked for: the
 // legacy key set, or enriched. Shared by both rejection classes below.
 function presentErrors(raw, data, rawInput, self, root, enrich) {
@@ -87,7 +95,7 @@ function presentErrors(raw, data, rawInput, self, root, enrich) {
   // The position map, resolved on the first read of an error's frame (see
   // defineLazyFrames in lib/enrich-error.js): a walk of the document that a
   // caller reading messages and paths never needs.
-  const lazyPositions = enrich && raw.length && rawInput != null ? lazyPositionsFor(self, rawInput, raw) : null;
+  const lazyPositions = enrich && raw.length && rawInput != null ? _positionsFor(self, rawInput, raw) : null;
   // One options object for the whole list, not one per error.
   const opts = enrich && raw.length
     ? {
@@ -126,153 +134,6 @@ Object.defineProperty(RichRejection.prototype, 'errors', {
 });
 
 
-// The rejection validateJSON returns. Everything the text path adds over
-// validate(data), the value tree enrichment needs, the position map, the
-// diagnostic payload, happens on first access to `.errors`. Reading `.valid`
-// touches none of it. The JSON text is held here rather than read back off the
-// validator, so the result does not depend on what the instance does next.
-class LazyJsonRejection {
-  // `parsed`, when given, is the document the inner path parsed from
-  // `jsonStr` and validated, after defaults, coercion and removal: reading the
-  // errors uses it instead of parsing the text again, which on a 5 MB
-  // document was a third of what reading them cost.
-  constructor(result, jsonStr, self, enrich, parsed) {
-    this.valid = false;
-    this._result = result;
-    this._jsonStr = jsonStr;
-    this._self = self;
-    this._enrich = enrich;
-    this._cached = null;
-    this._parsed = parsed;
-  }
-  toJSON() {
-    return { valid: false, errors: this.errors };
-  }
-}
-Object.defineProperty(LazyJsonRejection.prototype, 'errors', {
-  enumerable: true,
-  configurable: true,
-  get() {
-    if (this._cached !== null) return this._cached;
-    const self = this._self;
-    const enrich = this._enrich;
-    const jsonStr = this._jsonStr;
-    // Reading the inner errors realizes the inner lazy layer, if there was one.
-    const raw = this._result.errors || [];
-    if (!raw.length) { this._cached = raw; return raw; }
-
-    // The enrich pass plucks `received` from the value tree and the suggestion
-    // engine (required-typo, format hints, coercion nudges) walks it too.
-    let parsedData = this._parsed;
-    if (parsedData === undefined) {
-      try { parsedData = JSON.parse(jsonStr); } catch { parsedData = undefined; }
-      // What was checked is the document after defaults, coercion and removal,
-      // so `received` has to come from that, as it does for validate(). A
-      // default that failed its own schema has no value in the text at all.
-      if (parsedData !== undefined && self._preprocess) self._preprocess(parsedData);
-    }
-
-    // Errors the inner path already enriched carry a `received` key: enrich()
-    // always sets one, even when there is no value to show. `code` is not a
-    // safe signal, because branch-collapse attaches codes to raw errors, and
-    // `docUrl` is not either, because the generated error functions stamp it
-    // on raw errors; taking it as the signal left those errors without
-    // `received` or a suggestion on the text path while validate() had both.
-    if (!raw[0] || !('received' in raw[0])) {
-      // Declaration order, as validate() applies it; the text path used to
-      // enrich in emission order.
-      const ordered = needsOrdering(raw) ? sortErrorsBySchemaOrder(self._schemaObj, raw) : raw;
-      // The position map waits for the first read of a frame (lib/enrich-error
-      // defineLazyFrames); until then reading the list costs the enrichment alone.
-      const lazyPositions = lazyPositionsFor(self, jsonStr, ordered);
-      const enrichOpts = {
-        data: parsedData,
-        positions: null,
-        lazyPositions,
-        schemaPositions: self._schemaPositions,
-        schemaFile: self._source ? self._source.path : undefined,
-      };
-      const enriched = ordered.map((e) => enrich(e, enrichOpts));
-      if (enriched.length > 1) attachRelated(enriched);
-      attachDiagnosticSource(enriched, {
-        data: parsedData,
-        text: jsonStr,
-        // Read by the diagnostic renderer only, which resolves the same map.
-        get positions () { return lazyPositions(); },
-        schema: self._schemaObj,
-        mutatesInput: self._mutatesInput === true,
-      });
-      this._cached = enriched;
-      return enriched;
-    }
-
-    // Already enriched, so the frames are usually attached too. Only a gap in
-    // them is worth another walk of the document: resolving the map to discover
-    // there was nothing to fill cost a second full walk on every rejection.
-    if (raw.some((e) => e && !e.dataFrame)) {
-      const positions = self._pos().targeted(jsonStr, wantedPointersFor(raw.filter((e) => e && !e.dataFrame)));
-      if (positions) {
-        for (const e of raw) {
-          if (e && !e.dataFrame) {
-            const path = e.path != null ? e.path : (e.instancePath || '');
-            const p = positions[path];
-            if (p) e.dataFrame = { byteOffset: p.byteOffset, length: p.length, line: p.line, col: p.col, text: p.text };
-          }
-        }
-        self._posCache.reset();
-      }
-    }
-    if (raw.length > 1) attachRelated(raw);
-    attachDiagnosticSource(raw, {
-      data: parsedData,
-      text: jsonStr,
-      schema: self._schemaObj,
-      mutatesInput: self._mutatesInput === true,
-    });
-    this._cached = raw;
-    return raw;
-  },
-});
-
-// The targeted position map for a list, built on the first call and shared
-// by every error's frame accessor (lib/enrich-error defineLazyFrames).
-function lazyPositionsFor (self, text, errors) {
-  let done = false;
-  let positions = null;
-  return () => {
-    if (done) return positions;
-    done = true;
-    positions = self._pos().targeted(text, wantedPointersFor(errors));
-    if (positions) self._posCache.reset();
-    return positions;
-  };
-}
-
-// The pointers a set of errors will ask the position map about. lib/enrich-error
-// looks up the error's own path, and for an additional or unevaluated property
-// the child pointer named in `params`, unescaped, which is the form it asks for.
-// The escaped form goes in too: including a pointer that is never read costs
-// nothing, and the cache answers anything outside this set from the full map
-// rather than reporting no position.
-function wantedPointersFor (errors) {
-  const wanted = new Set();
-  for (const e of errors) {
-    if (!e) continue;
-    const path = e.path != null ? e.path : (e.instancePath || '');
-    wanted.add(path);
-    if (e.instancePath != null && e.instancePath !== path) wanted.add(e.instancePath);
-    const params = e.params;
-    const named = params && (params.additionalProperty || params.unevaluatedProperty);
-    if (typeof named === 'string') {
-      wanted.add(path + '/' + named);
-      if (named.indexOf('~') !== -1 || named.indexOf('/') !== -1) {
-        wanted.add(path + '/' + named.replace(/~/g, '~0').replace(/\//g, '~1'));
-      }
-    }
-  }
-  return wanted;
-}
-
 // A raw error in the legacy shape. The error generator writes `code` and
 // `docUrl` into its literals because a standalone module returns them as they
 // are; the runtime's legacy shape never had them, and the interpreter leaves
@@ -411,4 +272,4 @@ function attachRelated (errors) {
   return errors;
 }
 
-module.exports = { LazyRejection, RichRejection, presentErrors, needsOrdering, LazyJsonRejection, _enrichLazy, attachRelated, sortErrorsBySchemaOrder, stripOrdinal, wantedPointersFor };
+module.exports = { LazyRejection, RichRejection, presentErrors, needsOrdering, _enrichLazy, attachRelated, sortErrorsBySchemaOrder, stripOrdinal, _setPositionsFor };

package/lib/standard-schema.js

@@ -117,7 +117,7 @@ function standardSchemaFor(self, getSchema, validate) {
         if (!message) {
           // The native engine reports numeric codes without a message; the
           // enrich pass knows how to word those. Rare, so required lazily.
-          message = require('./enrich-error').enrich(err, {}).message;
+          message = require('./native-message')(err);
         }
         issues[i] = { message, path: parsePointerPath(path) };
       }

package/lib/validator-core.js

@@ -353,7 +353,14 @@ function resolveSchemaByPath(rootSchema, schemaPath) {
 // by every page that loads the package, validating or not.
 let LazyRejection, RichRejection, LazyJsonRejection, _enrichLazy, presentErrors, needsOrdering, sortErrorsBySchemaOrder, stripOrdinal;
 function _loadRejections() {
-  ({ LazyRejection, RichRejection, LazyJsonRejection, _enrichLazy, presentErrors, needsOrdering, sortErrorsBySchemaOrder, stripOrdinal } = require('./rejections'));
+  ({ LazyRejection, RichRejection, _enrichLazy, presentErrors, needsOrdering, sortErrorsBySchemaOrder, stripOrdinal } = require('./rejections'));
+}
+// The rejection validateJSON returns, and the position map an error's frame
+// reads, loaded with the first rejection that carries JSON text: a process
+// that only ever calls validate() never parses them (lib/json-rejections.js,
+// lib/diagnostic-source.js).
+function _loadJsonRejections() {
+  if (LazyJsonRejection === undefined) ({ LazyJsonRejection } = require('./json-rejections'));
 }
 
 // Text that does not parse, reported the same way on every path and platform:
@@ -1284,6 +1291,7 @@ class Validator {
           // literal with a getter here cost a closure plus an accessor
           // definition on every rejection, several hundred nanoseconds
           // before any error was read.
+          if (rawInput != null) _loadJsonRejections();
           return new RichRejection(result, data, rawInput, self, root, enrich);
         }
         return result;
@@ -1320,6 +1328,7 @@ class Validator {
           // and on the codegen path that realizes the inner lazy layer, which is
           // the document walk this exists to avoid.
           if (result && result.valid === false) {
+            _loadJsonRejections();
             return new LazyJsonRejection(result, jsonStr, this, enrich, parsed);
           }
           return result;