ata-validator 1.61.0 → 1.61.2

package/lib/enrich-error.js

@@ -1,6 +1,10 @@
 'use strict';
 
-const { CODES, codeFor, fromNative } = require('./error-codes');
+const { CODES, codeFor } = require('./error-codes');
+// Only the native engine writes a numeric code, so its table loads with the
+// first such error (lib/native-codes.js), not with every process.
+let _fromNative = null;
+const fromNative = (ordinal, format) => (_fromNative || (_fromNative = require('./native-codes').fromNative))(ordinal, format);
 const { suggestFor } = require('./suggestions');
 const { resolvePointer } = require('./pointer');
 

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/formats.js

@@ -538,4 +538,31 @@ function email(s) {
 const DURATION_RE = /^P(?:\d+W|(?:\d+Y(?:\d+M(?:\d+D)?)?|\d+M(?:\d+D)?|\d+D)(?:T(?:\d+H(?:\d+M(?:\d+S)?)?|\d+M(?:\d+S)?|\d+S))?|T(?:\d+H(?:\d+M(?:\d+S)?)?|\d+M(?:\d+S)?|\d+S))$/;
 function duration (s) { return DURATION_RE.test(s); }
 
-module.exports = { IPV4, DURATION_RE, IPV6_FULL, ipv4Range, URI_FAST, date, ipv4, dateTime, ipv6, hostname, uri, uriReference, uriWalk: _uriWalk, uuid, time, noReserved, jsonPointer, relativeJsonPointer, uriTemplate, email, duration, iri, iriReference, idnEmail, DURATION_RE, URI_TEMPLATE_EXPR };
+// The built-in format checks by name, built on first use. The interpreted
+// engine and the tier-0 verdict (lib/tier0.js) read the same table, so the two
+// cannot answer differently for a format.
+let _checks = null;
+function formatChecks () {
+  return _checks || (_checks = {
+    email,
+    date,
+    'date-time': dateTime,
+    time,
+    duration,
+    uuid,
+    uri,
+    'uri-reference': uriReference,
+    ipv4,
+    ipv6,
+    hostname,
+    regex: (s) => { try { new RegExp(s, 'u'); return true; } catch { return false; } },
+    'json-pointer': jsonPointer,
+    'relative-json-pointer': relativeJsonPointer,
+    'uri-template': uriTemplate,
+    iri,
+    'iri-reference': iriReference,
+    'idn-email': idnEmail,
+  });
+}
+
+module.exports = { formatChecks, IPV4, DURATION_RE, IPV6_FULL, ipv4Range, URI_FAST, date, ipv4, dateTime, ipv6, hostname, uri, uriReference, uriWalk: _uriWalk, uuid, time, noReserved, jsonPointer, relativeJsonPointer, uriTemplate, email, duration, iri, iriReference, idnEmail, DURATION_RE, URI_TEMPLATE_EXPR };

package/lib/interpreter-core.js

@@ -288,33 +288,9 @@ function multipleOfOk(d, m) {
   return Math.abs(q - Math.round(q)) < 1e-9;
 }
 
-// The built-in format checks, built on the first schema that names a format:
-// the engine loads without lib/formats.js, which schemas without `format`
-// never need.
-let _formatChecks = null;
-function buildFormatChecks() {
-  const _formats = require('./formats');
-  return {
-  email: _formats.email,
-  date: _formats.date,
-  'date-time': _formats.dateTime,
-  time: _formats.time,
-  duration: _formats.duration,
-  uuid: _formats.uuid,
-  uri: _formats.uri,
-  'uri-reference': _formats.uriReference,
-  ipv4: _formats.ipv4,
-  ipv6: _formats.ipv6,
-  hostname: _formats.hostname,
-  regex: (s) => { try { new RegExp(s, 'u'); return true; } catch { return false; } },
-  'json-pointer': _formats.jsonPointer,
-  'relative-json-pointer': _formats.relativeJsonPointer,
-  'uri-template': _formats.uriTemplate,
-  iri: _formats.iri,
-  'iri-reference': _formats.iriReference,
-  'idn-email': _formats.idnEmail,
-  };
-}
+// The built-in format checks come from lib/formats.js (formatChecks), loaded
+// on the first schema that names a format: the engine loads without it, which
+// schemas without `format` never need.
 
 // ---------- evaluation ----------
 
@@ -454,7 +430,7 @@ class Plan {
     this.formatFn = null;
     if (schema.format !== undefined) {
       const uf = interp.userFormats;
-      const fc = (uf && typeof uf[schema.format] === 'function') ? uf[schema.format] : (_formatChecks || (_formatChecks = buildFormatChecks()))[schema.format];
+      const fc = (uf && typeof uf[schema.format] === 'function') ? uf[schema.format] : require('./formats').formatChecks()[schema.format];
       this.formatFn = fc || null;
     }
     this.hasString = this.minLength !== undefined || this.maxLength !== undefined || this.pattern !== null || this.formatFn !== null;

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;