ata-validator 1.29.0 → 1.30.1

package/index.js

@@ -500,7 +500,7 @@ Object.defineProperty(RichRejection.prototype, 'errors', {
       // The position map, resolved now that an error is actually being read.
       let positions = null;
       if (enrich && raw.length && this._rawInput != null) {
-        positions = self._pos().get(this._rawInput);
+        positions = self._pos().targeted(this._rawInput, wantedPointersFor(raw));
         if (positions) self._posCache.reset();
       }
       // One options object for the whole list, not one per error.
@@ -571,7 +571,7 @@ Object.defineProperty(LazyJsonRejection.prototype, 'errors', {
     // to raw errors, and detecting on it left every collapsed oneOf/anyOf error
     // unenriched on the text path.
     if (!raw[0] || !raw[0].docUrl) {
-      const positions = self._pos().get(jsonStr);
+      const positions = self._pos().targeted(jsonStr, wantedPointersFor(raw));
       // Declaration order, as validate() applies it; the text path used to
       // enrich in emission order.
       const ordered = raw.length > 1 ? sortErrorsBySchemaOrder(self._schemaObj, raw) : raw;
@@ -599,7 +599,7 @@ Object.defineProperty(LazyJsonRejection.prototype, 'errors', {
     // 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().get(jsonStr);
+      const positions = self._pos().targeted(jsonStr, wantedPointersFor(raw.filter((e) => e && !e.dataFrame)));
       if (positions) {
         for (const e of raw) {
           if (e && !e.dataFrame) {
@@ -623,6 +623,31 @@ Object.defineProperty(LazyJsonRejection.prototype, 'errors', {
   },
 });
 
+// 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 without the `_o` ordering key, for the legacy error shape.
 function stripOrdinal(e) {
   if (e === null || typeof e !== 'object' || e._o === undefined) return e;
@@ -1450,10 +1475,32 @@ class Validator {
         // The factory bakes the error function in as an argument and never
         // calls it for a document that passes, so a resolver here costs the
         // accepted path nothing and keeps the compile off the first call.
-        const hybridFn = jsFn._hybridFactory(VALID_RESULT, errPreferCombined);
+        // Until the first rejection this is the hybrid: the verdict function,
+        // with the error resolver baked in and never called for a document that
+        // passes. That keeps the combined function's compile off the first call,
+        // which is two thirds of what a first call costs.
+        //
+        // From the first rejection on, the combined function answers directly.
+        // It decides and collects in one pass, so the verdict pass in front of it
+        // was validating the document a second time: 134.1 microseconds against
+        // its 45.3 on a 1000-user array. Swapping rather than starting there keeps
+        // the lazy compile, and swapping at all is only free because the combined
+        // function now costs what the verdict function costs on accepted
+        // documents (1.02x on that array, 0.99x on a small body) since
+        // additionalProperties stopped materialising its key array. The
+        // indirection this needs measured inside the noise at both sizes.
+        let impl = null;
+        const onReject = (data) => {
+          const combined = combinedIfSafe();
+          if (combined) { impl = combined; return combined(data); }
+          return errOnly(data);
+        };
+        const hybridFn = jsFn._hybridFactory(VALID_RESULT, onReject);
+        impl = hybridFn;
+        const run = (data) => impl(data);
         this.validate = preprocess
-          ? (data) => { preprocess(data); return hybridFn(data); }
-          : hybridFn;
+          ? (data) => { preprocess(data); return run(data); }
+          : run;
       } else {
         // No hybrid factory, so the assembly needs the function itself rather
         // than a reference it can call later: build it now.
@@ -1530,7 +1577,11 @@ class Validator {
         : jsonValidateInner;
       this.validateJSON = useSimdjsonForLarge && native && !preprocess
         ? (jsonStr) => {
-            if (jsonStr.length >= SIMDJSON_THRESHOLD) {
+            // `_skipNativeFast` is set by the scanner short-circuit below when it
+            // has already decided the document is invalid. The encode and the
+            // native call would run only to return false, and the error path
+            // underneath does not need them.
+            if (jsonStr.length >= SIMDJSON_THRESHOLD && this._skipNativeFast !== true) {
               this._ensureNative();
               const buf = Buffer.from(jsonStr);
               if (native.rawFastValidate(this._fastSlot, buf))
@@ -1979,8 +2030,23 @@ class Validator {
               };
           return self.isValidJSON(jsonStr);
         };
-        if (options.abortEarly) {
+        // validateJSON gets the same short-circuit isValidJSON has. The verdict is
+        // a property of the text, and the scanner reads the text once and
+        // allocates nothing; above the simdjson threshold the path underneath
+        // encoded the whole document to a Buffer and called the native validator
+        // instead, which measured 340 microseconds against the scanner's 191 on a
+        // 149 KB config, the same against the published addon as against a local
+        // build.
+        //
+        // An accepted document stops at the scanner. A rejected one still has to
+        // produce errors, so it goes on to the path below, which is the
+        // rich-errors wrapper and everything under it; the flag only tells that
+        // path to skip an encode and a native call that would return false. Doing
+        // it the other way, returning errors from the inner function directly,
+        // would hand back errors that never passed through enrichment.
+        {
           const validateByParsing = this.validateJSON;
+          const abortEarly = !!options.abortEarly;
           this.validateJSON = (jsonStr) => {
             const scan = self._ensureScanner();
             if (scan === undefined) return validateByParsing(jsonStr);
@@ -1989,7 +2055,15 @@ class Validator {
               if (typeof text === 'string') {
                 const r = scan(text);
                 if (r === 1) return VALID_RESULT;
-                if (r === 0) return ABORT_EARLY_RESULT;
+                if (r === 0) {
+                  if (abortEarly) return ABORT_EARLY_RESULT;
+                  self._skipNativeFast = true;
+                  try {
+                    return validateByParsing(text);
+                  } finally {
+                    self._skipNativeFast = false;
+                  }
+                }
               }
               return validateByParsing(text);
             };

package/lib/aot-impl.js

@@ -14,7 +14,7 @@
 //   loadBundle(Validator, mods, schemas, opts)
 
 const { compileToJSCodegenWithErrors, compileToJSCodegen, unevalContributions } = require('./js-compiler');
-const { buildDataPositionMap } = require('./data-positions');
+const { buildTargetedPositionMap } = require('./data-positions');
 const { schemaHash } = require('./schema-hash');
 const ATA_VERSION = require('./version');
 const SAFE_REGEX_SOURCE = require('./safe-regex-source');
@@ -595,10 +595,15 @@ function toStandaloneModule(validator, opts) {
   // dataFrame (byte offset, line, col, source line) to every error by
   // walking the original text once. Off by default for the same reason as
   // parse(): it costs bytes in every emitted module. Ask for it with
-  // { positions: true }. The walker is the runtime's buildDataPositionMap,
+  // { positions: true }. The walker is the runtime's buildTargetedPositionMap,
   // embedded verbatim via toString so the two cannot drift; that is why the
-  // function in lib/data-positions.js must stay self-contained.
-  const positionsCore = !(opts && opts.positions) ? '' : `const _ataPosMap = ${buildDataPositionMap.toString()};
+  // function in lib/data-positions.js must stay self-contained. It is given the
+  // pointers the errors name, which is the only thing this module looks up, so a
+  // subtree that cannot hold one is scanned to its end and never walked: framing
+  // an error went from 8.02x a JSON.parse of the document to 1.72x, and 3.11x in
+  // the worst case of a pointer at the very end. It is also 125 characters
+  // smaller than the full-map builder it replaces.
+  const positionsCore = !(opts && opts.positions) ? '' : `const _ataPosMap = ${buildTargetedPositionMap.toString()};
 function _ataFrame(p) { return { byteOffset: p.byteOffset, length: p.length, line: p.line, col: p.col, text: p.text }; }
 function validateJSON(text) {
   const s = String(text);
@@ -606,13 +611,15 @@ function validateJSON(text) {
   try { data = JSON.parse(s); } catch (e) {
     const nl = s.indexOf(String.fromCharCode(10));
     let frame = { byteOffset: 0, length: s.length, line: 1, col: 1, text: nl === -1 ? s : s.slice(0, nl) };
-    try { const m = _ataPosMap(s); if (m['']) frame = _ataFrame(m['']); } catch (_) {}
+    try { const m = _ataPosMap(s, new Set([''])); if (m['']) frame = _ataFrame(m['']); } catch (_) {}
     return { valid: false, errors: [{ code: 'ATA9001', message: 'invalid JSON document', keyword: '__parse__', path: '', instancePath: '', dataFrame: frame }] };
   }
   const r = validate(data);
   if (r.valid || !r.errors || !r.errors.length) return r;
   let map;
-  try { map = _ataPosMap(s); } catch (_) { return r; }
+  const _want = new Set();
+  for (const e of r.errors) _want.add(e.instancePath != null ? e.instancePath : (e.path || ''));
+  try { map = _ataPosMap(s, _want); } catch (_) { return r; }
   const errors = r.errors.map((e) => {
     const ptr = e.instancePath != null ? e.instancePath : (e.path || '');
     const p = map[ptr];

package/lib/data-position-cache.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { buildDataPositionMap } = require('./data-positions');
+const { buildDataPositionMap, buildTargetedPositionMap } = require('./data-positions');
 
 /**
  * Memoize the position map for the duration of a single validate() call.
@@ -12,7 +12,50 @@ function createCache () {
   const wm = new WeakMap();
   const sm = new Map(); // strings can't go in WeakMap; clear after each validate
   let lastInput = null;
-  return {
+  const cache = {
+    /**
+     * The entries for a known set of pointers, which is what a rejection needs:
+     * recording one per node in the document was the dominant cost of reading an
+     * error's frame.
+     *
+     * The caller derives `wanted` from the errors, and a derivation that misses a
+     * pointer must not cost a frame, so the result answers any pointer outside
+     * the set by building the full map once and reading from that. A wrong
+     * derivation is then slow rather than silently short of frames, which is the
+     * only acceptable direction for this trade: a missing caret is the failure
+     * nobody reports.
+     */
+    targeted (input, wanted) {
+      if (input == null) return null;
+      if (!wanted || wanted.size === 0) return null;
+      const already = typeof input === 'string'
+        ? sm.get(input)
+        : (Buffer.isBuffer(input) ? wm.get(input) : undefined);
+      if (already) return already;
+      let filtered;
+      try {
+        filtered = buildTargetedPositionMap(input, wanted);
+      } catch {
+        return null;
+      }
+      let full;
+      const fallback = (key) => {
+        if (wanted.has(key)) return undefined; // asked for, absent from the document
+        if (full === undefined) full = cache.get(input) || null;
+        return full ? full[key] : undefined;
+      };
+      return new Proxy(filtered, {
+        get (target, key) {
+          if (typeof key !== 'string') return target[key];
+          if (key in target) return target[key];
+          return fallback(key);
+        },
+        has (target, key) {
+          if (typeof key !== 'string') return key in target;
+          return (key in target) || fallback(key) !== undefined;
+        },
+      });
+    },
     get (input) {
       if (input == null) return null;
       if (typeof input === 'string') {
@@ -38,6 +81,7 @@ function createCache () {
       lastInput = null;
     },
   };
+  return cache;
 }
 
 module.exports = { createCache };

package/lib/data-positions.js

@@ -168,4 +168,203 @@ function buildDataPositionMap (input) {
   return map;
 }
 
-module.exports = { buildDataPositionMap };
+/**
+ * The same map, for a known set of pointers.
+ *
+ * A rejection names two or three pointers and nothing reads any other entry, so
+ * recording one per node in the document is nearly all waste: on a 149 KB config
+ * the full map was 1330 microseconds of a 2457 microsecond error read. Here a
+ * subtree that cannot contain a wanted pointer is scanned to its end and never
+ * walked, and the walk stops once every wanted pointer has been recorded.
+ * Measured against the full map: 11.5x on pointers near the start of the
+ * document, and 3.7x in the worst case for the technique, a single pointer at
+ * the very end.
+ *
+ * Deliberately a second function rather than an option on the first. That one is
+ * embedded verbatim into standalone modules via Function.prototype.toString, and
+ * adding per-node checks to it cost 8% on the full-map path for callers that want
+ * every entry. The price is two walks of the same grammar, which
+ * `tests/test_targeted_positions.js` holds to identical output.
+ *
+ * Entries are identical to the full map's for every pointer in `wanted`. A
+ * pointer absent from the document is absent here too, exactly as it would be.
+ */
+function buildTargetedPositionMap (input, wanted) {
+  const text = (typeof Buffer !== 'undefined' && Buffer.isBuffer(input)) ? input.toString('utf8') : String(input);
+  const map = Object.create(null);
+  const n = text.length;
+
+  // Every prefix of every wanted pointer: the containers worth descending into.
+  const interest = new Set(['']);
+  for (const w of wanted) {
+    let at = 0;
+    for (;;) {
+      const next = w.indexOf('/', at + 1);
+      if (next === -1) break;
+      interest.add(w.slice(0, next));
+      at = next;
+    }
+    interest.add(w);
+  }
+  let remaining = wanted.size;
+
+  const ptrs = [];
+  const starts = [];
+  const lens = [];
+  const keyStarts = [];
+  const keyLens = [];
+
+  let i = 0;
+
+  function skipWs () {
+    while (i < n) {
+      const ch = text.charCodeAt(i);
+      if (ch === 0x20 || ch === 0x09 || ch === 0x0a || ch === 0x0d) i++; else break;
+    }
+  }
+
+  function readString (decode) {
+    const start = i;
+    let simple = text.charCodeAt(i) === 0x22;
+    i++;
+    let closed = false;
+    while (i < n) {
+      const ch = text.charCodeAt(i);
+      if (ch === 0x5c) { simple = false; i += 2; continue; }
+      if (ch === 0x22) { i++; closed = true; break; }
+      if (ch < 0x20) simple = false;
+      i++;
+    }
+    if (!closed) throw new Error('unterminated string at offset ' + start);
+    if (simple) return decode ? text.slice(start + 1, i - 1) : null;
+    const decoded = JSON.parse(text.slice(start, i));
+    return decode ? decoded : null;
+  }
+
+  // Past one value, recording nothing inside it. Strings are consumed through
+  // readString so a brace inside one cannot move the depth.
+  function skipValue () {
+    skipWs();
+    if (i >= n) return;
+    const ch = text.charCodeAt(i);
+    if (ch === 0x22) { readString(false); return; }
+    if (ch === 0x7b || ch === 0x5b) {
+      let depth = 0;
+      while (i < n) {
+        const c = text.charCodeAt(i);
+        if (c === 0x22) { readString(false); continue; }
+        if (c === 0x7b || c === 0x5b) { depth++; i++; continue; }
+        if (c === 0x7d || c === 0x5d) { depth--; i++; if (depth <= 0) return; continue; }
+        i++;
+      }
+      return;
+    }
+    while (i < n) {
+      const c = text.charCodeAt(i);
+      if (c === 0x2c || c === 0x7d || c === 0x5d || c === 0x20 || c === 0x09 || c === 0x0a || c === 0x0d) break;
+      i++;
+    }
+  }
+
+  function walk (ptr, keyStart, keyLen) {
+    skipWs();
+    if (i >= n) return;
+    const start = i;
+    const isWanted = wanted.has(ptr);
+
+    if (!interest.has(ptr)) {
+      skipValue();
+      if (isWanted) { ptrs.push(ptr); starts.push(start); lens.push(i - start); keyStarts.push(keyStart); keyLens.push(keyLen); remaining--; }
+      return;
+    }
+
+    const ch = text.charCodeAt(i);
+    if (ch === 0x7b) {
+      i++;
+      for (;;) {
+        skipWs();
+        if (i >= n) break;
+        if (text.charCodeAt(i) === 0x7d) { i++; break; }
+        if (text.charCodeAt(i) === 0x2c) { i++; continue; }
+        skipWs();
+        const memberKeyStart = i;
+        const key = readString(true);
+        const memberKeyLen = i - memberKeyStart;
+        skipWs();
+        if (text.charCodeAt(i) !== 0x3a) throw new Error('expected ":" at offset ' + i);
+        i++;
+        const seg = (key.indexOf('~') === -1 && key.indexOf('/') === -1)
+          ? key
+          : key.replace(/~/g, '~0').replace(/\//g, '~1');
+        walk(ptr + '/' + seg, memberKeyStart, memberKeyLen);
+        if (remaining === 0) return;
+      }
+    } else if (ch === 0x5b) {
+      i++;
+      let idx = 0;
+      for (;;) {
+        skipWs();
+        if (i >= n) break;
+        if (text.charCodeAt(i) === 0x5d) { i++; break; }
+        if (text.charCodeAt(i) === 0x2c) { i++; continue; }
+        const before = i;
+        walk(ptr + '/' + idx, -1, 0);
+        if (remaining === 0) return;
+        if (i === before) break;
+        idx++;
+      }
+    } else if (ch === 0x22) {
+      readString(false);
+    } else {
+      while (i < n) {
+        const c = text.charCodeAt(i);
+        if (c === 0x2c || c === 0x7d || c === 0x5d || c === 0x20 || c === 0x09 || c === 0x0a || c === 0x0d) break;
+        i++;
+      }
+    }
+
+    if (isWanted) { ptrs.push(ptr); starts.push(start); lens.push(i - start); keyStarts.push(keyStart); keyLens.push(keyLen); remaining--; }
+  }
+
+  if (text.charCodeAt(0) === 0xfeff) i = 1;
+  walk('', -1, 0);
+
+  if (ptrs.length === 0) return map;
+
+  const lines = text.split('\n');
+  const lineStart = new Array(lines.length + 1);
+  lineStart[0] = 0;
+  for (let k = 0; k < lines.length; k++) lineStart[k + 1] = lineStart[k] + lines[k].length + 1;
+
+  function lineOf (off) {
+    let lo = 0, hi = lineStart.length - 1;
+    while (lo < hi) {
+      const mid = (lo + hi + 1) >> 1;
+      if (lineStart[mid] <= off) lo = mid; else hi = mid - 1;
+    }
+    return lo;
+  }
+
+  for (let k = 0; k < ptrs.length; k++) {
+    const off = starts[k];
+    const line = lineOf(off);
+    const entry = {
+      byteOffset: off,
+      length: lens[k],
+      line: line + 1,
+      col: off - lineStart[line] + 1,
+      text: lines[line] || '',
+    };
+    if (keyStarts[k] >= 0) {
+      const keyLine = lineOf(keyStarts[k]);
+      entry.keyOffset = keyStarts[k];
+      entry.keyLength = keyLens[k];
+      entry.keyLine = keyLine + 1;
+      entry.keyCol = keyStarts[k] - lineStart[keyLine] + 1;
+    }
+    map[ptrs[k]] = entry;
+  }
+  return map;
+}
+
+module.exports = { buildDataPositionMap, buildTargetedPositionMap };

package/lib/formats.js

@@ -202,12 +202,16 @@ function ipv6 (s) {
 // Labels of letters, digits and hyphens, each 1 to 63 characters, none
 // starting or ending with a hyphen, joined by single dots, 253 characters at
 // most. Same answers as the expression it replaces, read once.
-function hostname (s) {
-  const n = s.length;
+// `from` and `to` let a caller check a hostname inside a larger string, which is
+// how the email check reads its domain half without slicing it out.
+function hostname (s, from, to) {
+  const start = from === undefined ? 0 : from;
+  const end = to === undefined ? s.length : to;
+  const n = end - start;
   if (n === 0 || n > 253) return false;
   let labelLength = 0;
   let previous = 46; // a dot, so a leading hyphen is refused like a leading dot
-  for (let i = 0; i < n; i++) {
+  for (let i = start; i < end; i++) {
     const c = s.charCodeAt(i);
     if (c === 46) {
       if (labelLength === 0 || previous === 45) return false;
@@ -686,15 +690,28 @@ function dateTimeSource (v, isStr) {
     `if(_dtu!==1439)return false}`);
 }
 
-function hostnameSource (v, isStr) {
-  return guard(v, isStr, `const _n=${v}.length;if(_n===0||_n>253)return false;let _ll=0,_pv=46;` +
-    `for(let _i=0;_i<_n;_i++){const _c=${v}.charCodeAt(_i);` +
+// The scan, over a range of the string given as source expressions. The email
+// check reads its domain half through this, without slicing it out, which was an
+// allocation on every call.
+//
+// A separate function rather than optional parameters on hostnameSource: the code
+// generator calls every entry of its format table as `fn(v, isStr, ctx)`, so a
+// third parameter here would silently receive a context object and emit
+// `_st=[object Object]`. That declines the whole compile, which is how it was
+// found.
+function hostnameRangeSource (v, st, en) {
+  return `const _st=${st},_en=${en},_n=_en-_st;if(_n===0||_n>253)return false;let _ll=0,_pv=46;` +
+    `for(let _i=_st;_i<_en;_i++){const _c=${v}.charCodeAt(_i);` +
     `if(_c===46){if(_ll===0||_pv===45)return false;_ll=0;_pv=_c;continue}` +
     `const _an=(_c>=48&&_c<=57)||(_c>=97&&_c<=122)||(_c>=65&&_c<=90);` +
     `if(!_an&&_c!==45)return false;` +
     `if(_c===45&&_pv===46)return false;` +
     `if(++_ll>63)return false;_pv=_c}` +
-    `if(_ll===0||_pv===45)return false`);
+    `if(_ll===0||_pv===45)return false`;
+}
+
+function hostnameSource (v, isStr) {
+  return guard(v, isStr, hostnameRangeSource(v, '0', `${v}.length`));
 }
 
 function uuidSource (v, isStr) {
@@ -856,12 +873,16 @@ function uriTemplateSource (v, isStr) {
       `if(_c===125)return false;` +
       `if(_c!==123&&(_c<=32||_c===127))return false;` +
       `if(_c!==123){_i++;continue}` +
-      `const _e=${v}.indexOf('}',_i+1);` +
-      `if(_e===-1)return false;` +
-      `const _x=${v}.slice(_i+1,_e);` +
+      // `_ute`, not `_e`: this source is spliced into a generated function whose
+      // error accumulator is `_e`, and a `const _e` here shadowed it, so
+      // `(_e||(_e=[])).push(...)` ran against a number and threw. The verdict was
+      // right, so the suite never saw it; only a caller reading `.errors` did.
+      `const _ute=${v}.indexOf('}',_i+1);` +
+      `if(_ute===-1)return false;` +
+      `const _x=${v}.slice(_i+1,_ute);` +
       `if(_x===''||_x.indexOf('{')!==-1)return false;` +
       `if(!${URI_TEMPLATE_EXPR.toString()}.test(_x))return false;` +
-      `_i=_e+1` +
+      `_i=_ute+1` +
     `}`;
   return isStr ? `{${inner}}` : `if(typeof ${v}==='string'){${inner}}`;
 }
@@ -874,35 +895,69 @@ function uriTemplateSource (v, isStr) {
 // the dot that separates atoms. Written as code ranges rather than a regular
 // expression because this lands inside every emitted module that validates an
 // email, and the expression cost more bytes there than the whole check.
-function isEmailLocalChar (c) {
-  return (c >= 48 && c <= 57) || (c >= 97 && c <= 122) || (c >= 65 && c <= 90) ||
-    c === 46 || c === 33 || (c >= 35 && c <= 39) || c === 42 || c === 43 ||
-    c === 45 || c === 47 || c === 61 || c === 63 || (c >= 94 && c <= 96) ||
-    (c >= 123 && c <= 126);
-}
-const EMAIL_LOCAL_SRC = (v) => `((${v}>=48&&${v}<=57)||(${v}>=97&&${v}<=122)||(${v}>=65&&${v}<=90)||${v}===46||${v}===33||(${v}>=35&&${v}<=39)||${v}===42||${v}===43||${v}===45||${v}===47||${v}===61||${v}===63||(${v}>=94&&${v}<=96)||(${v}>=123&&${v}<=126))`;
+// The emitted form keeps the comparison chain: a standalone module pays for the
+// bytes of a 128-entry table in every file that validates an email, and the
+// runtime pays for the chain on every call. Different budgets, same answers,
+// which `tests/test_format_engine_parity.js` holds.
+// Stated as the complement: of the printable range, only twelve characters are
+// not atext or the dot, so excluding them is 54 source bytes shorter than listing
+// what is allowed, and a standalone module carries this expression. Checked
+// against the allowed-list form over every code point from 0 to 65536 in
+// tests/test_formats_single_pass.js.
+const EMAIL_LOCAL_SRC = (v) => `(${v}>32&&${v}<127&&${v}!==34&&${v}!==40&&${v}!==41&&${v}!==44&&${v}!==58&&${v}!==59&&${v}!==60&&${v}!==62&&${v}!==64&&${v}!==91&&${v}!==92&&${v}!==93)`;
+// The same table treatment the rest of this file uses for character classes, and
+// no slicing: the two halves are read in place by offset. The version that split
+// the string at the '@' and tested each local character against a chain of ten
+// comparisons cost 3.2x the hostname check it contains, and that one function was
+// the only measured place ata validated slower than the default validator.
+const EMAIL_LOCAL = new Uint8Array(128);
+for (let i = 48; i <= 57; i++) EMAIL_LOCAL[i] = 1; // digits
+for (let i = 97; i <= 122; i++) EMAIL_LOCAL[i] = 1; // a-z
+for (let i = 65; i <= 90; i++) EMAIL_LOCAL[i] = 1; // A-Z
+for (let i = 35; i <= 39; i++) EMAIL_LOCAL[i] = 1; // # $ % & '
+for (let i = 94; i <= 96; i++) EMAIL_LOCAL[i] = 1; // ^ _ `
+for (let i = 123; i <= 126; i++) EMAIL_LOCAL[i] = 1; // { | } ~
+for (const c of [46, 33, 42, 43, 45, 47, 61, 63]) EMAIL_LOCAL[c] = 1; // . ! * + - / = ?
+
+// One forward pass over the string. '@' is not a local-part character, so in an
+// unquoted address the first one is the separator, and the local part can be
+// checked on the way to finding it. The version that called lastIndexOf first
+// read the string backwards before reading it forwards twice.
 function email(s) {
-  const at = s.lastIndexOf('@');
-  if (at <= 0 || at === s.length - 1) return false;
-  const local = s.slice(0, at);
-  const domain = s.slice(at + 1);
-  if (local.length > 64) return false;
-  if (local.charCodeAt(0) === 34) {
-    // quoted string: must close, and the quote may only end the local part
-    if (local.charCodeAt(local.length - 1) !== 34 || local.length < 2) return false;
+  const n = s.length;
+  if (n < 3) return false;
+  let at;
+  if (s.charCodeAt(0) === 34) {
+    // A quoted local part may contain '@', so it needs the last one. Rare enough
+    // to keep the extra scan rather than complicate the common path.
+    at = s.lastIndexOf('@');
+    if (at < 2 || at === n - 1 || at > 64) return false;
+    if (s.charCodeAt(at - 1) !== 34) return false;
   } else {
-    if (local.charCodeAt(0) === 46 || local.charCodeAt(local.length - 1) === 46) return false;
-    if (local.indexOf('..') !== -1) return false;
-    for (let i = 0; i < local.length; i++) if (!isEmailLocalChar(local.charCodeAt(i))) return false;
+    if (s.charCodeAt(0) === 46) return false; // a leading dot is not a mailbox
+    at = -1;
+    let afterDot = false;
+    for (let i = 0; i < n; i++) {
+      const c = s.charCodeAt(i);
+      if (c === 64) { at = i; break; }
+      if (c > 127 || EMAIL_LOCAL[c] === 0) return false;
+      if (c === 46) {
+        if (afterDot) return false; // a doubled dot is not one either
+        afterDot = true;
+      } else {
+        afterDot = false;
+      }
+    }
+    if (at <= 0 || at === n - 1 || at > 64) return false;
+    if (s.charCodeAt(at - 1) === 46) return false;
   }
-  if (domain.charCodeAt(0) === 91) { // '['
-    if (domain.charCodeAt(domain.length - 1) !== 93 || domain.length <= 2) return false;
-    const inner = domain.slice(1, -1);
+  if (s.charCodeAt(at + 1) === 91) { // '['
+    if (s.charCodeAt(n - 1) !== 93 || n - at - 1 <= 2) return false;
     // IPv6 literals are tagged; anything else in brackets is an IPv4 address.
-    if (inner.startsWith('IPv6:')) return ipv6(inner.slice(5));
-    return ipv4(inner);
+    if (s.startsWith('IPv6:', at + 2)) return ipv6(s.slice(at + 7, n - 1));
+    return ipv4(s.slice(at + 2, n - 1));
   }
-  return hostname(domain);
+  return hostname(s, at + 1, n);
 }
 // Emitted rather than bound as a closure: a standalone module embeds format
 // functions by their source text, so anything reaching a free variable would
@@ -910,23 +965,36 @@ function email(s) {
 // one hostname implementation for both halves of this file.
 function emailSource (v, isStr) {
   const inner =
-    `const _at=${v}.lastIndexOf('@');` +
-    `if(_at<=0||_at===${v}.length-1)return false;` +
-    `const _lp=${v}.slice(0,_at);const _dm=${v}.slice(_at+1);` +
-    `if(_lp.length>64)return false;` +
-    `if(_lp.charCodeAt(0)===34){if(_lp.length<2||_lp.charCodeAt(_lp.length-1)!==34)return false}` +
-    `else{` +
-      `if(_lp.charCodeAt(0)===46||_lp.charCodeAt(_lp.length-1)===46)return false;` +
-      `if(_lp.indexOf('..')!==-1)return false;` +
-      `for(let _i=0;_i<_lp.length;_i++){const _lc=_lp.charCodeAt(_i);if(!${EMAIL_LOCAL_SRC('_lc')})return false}` +
+    // One forward pass, and neither half sliced out. '@' is not a local-part
+    // character, so in an unquoted address the first one is the separator and the
+    // local part is checked on the way to it. A quoted local part may contain
+    // '@' and keeps the backward scan, which is the rare shape.
+    // The bounds tests are merged into one condition per branch, and there is no
+    // separate length check: an empty local part fails `_at<=0` and an empty
+    // domain fails `_at===_n0-1`, so a short string is already refused. This
+    // lands in every emitted module that validates an email, and 25 bytes of it
+    // put the CLI smoke build over its --max-size once.
+    `const _n0=${v}.length;let _at;` +
+    `if(${v}.charCodeAt(0)===34){` +
+      `_at=${v}.lastIndexOf('@');` +
+      `if(_at<2||_at===_n0-1||_at>64||${v}.charCodeAt(_at-1)!==34)return false` +
+    `}else{` +
+      `if(${v}.charCodeAt(0)===46)return false;` +
+      `_at=-1;let _pd=false;` +
+      `for(let _i=0;_i<_n0;_i++){const _lc=${v}.charCodeAt(_i);if(_lc===64){_at=_i;break}if(!${EMAIL_LOCAL_SRC('_lc')})return false;if(_lc===46){if(_pd)return false;_pd=true}else _pd=false}` +
+      `if(_at<=0||_at===_n0-1||_at>64||${v}.charCodeAt(_at-1)===46)return false` +
     `}` +
-    `if(_dm.charCodeAt(0)===91){` +
+    // An address literal is rare enough to pay for its own slice inside the
+    // branch that needs it; the hostname path, which is every real address,
+    // reads the domain in place.
+    `if(${v}.charCodeAt(_at+1)===91){` +
+      `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.startsWith('IPv6:')){const _i6=_in.slice(5);${ipv6Source('_i6', true)}}` +
       `else{${ipv4Source('_in', true)}}` +
     `}` +
-    `else{${hostnameSource('_dm', true)}}`;
+    `else{${hostnameRangeSource(v, '_at+1', `${v}.length`)}}`;
   return isStr ? `{${inner}}` : `if(typeof ${v}==='string'){${inner}}`;
 }
 

package/lib/js-compiler.js

@@ -1865,7 +1865,15 @@ function genCode(schema, v, lines, ctx, knownType) {
           fnName = '_def' + ctx.defFns.size + '_' + defName.replace(/[^A-Za-z0-9_]/g, '_')
           ctx.defFns.set(defName, fnName)
           const bodyLines = []
+          // The def is compiled as its own function over its own `d`, so the
+          // checks _deferOrInline holds back belong at the end of this body.
+          // The list hangs off ctx, so without the swap they are flushed into
+          // whatever function is compiling, carrying this def's key set.
+          const outerDeferred = ctx.deferredChecks
+          ctx.deferredChecks = null
           genCode(ctx.rootDefs[defName], 'd', bodyLines, ctx)
+          if (ctx.deferredChecks) for (const dc of ctx.deferredChecks) bodyLines.push(dc)
+          ctx.deferredChecks = outerDeferred
           // Entered through the cycle guard: see emitGuardState. In the fast
           // pass the wrapper only counts depth; the set is used by the second,
           // guarded pass that runs when data turns out to point back at
@@ -3889,7 +3897,14 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
       patChecks.push(`_re${ctx.regExpMap.get(pattern)}.test(_k${ci}[_i])`)
     }
     const isAdditional = patChecks.length ? `!_a${ci}.has(_k${ci}[_i])&&!(${patChecks.join('||')})` : `!_a${ci}.has(_k${ci}[_i])`
-    const inner = `const _k${ci}=Object.keys(${v});const _a${ci}=new Set([${allowed}]);for(let _i=0;_i<_k${ci}.length;_i++){if(${isAdditional}){_e.push({code:'${apLit.codeStr}',keyword:'additionalProperties',instancePath:${pathExpr||'""'},schemaPath:'${apSp}'${ordinalField(ctx, `${apSp}`)},params:{additionalProperty:_k${ci}[_i]},message:'must NOT have additional properties',docUrl:'${apLit.docUrl}'${apLit.frame}});if(!_all)return{valid:false,errors:_e}}}`
+    // Same shape as the combined generator: a for-in says whether anything is
+    // extra without allocating, and the keys are materialised only to name one.
+    // This function walks every node of a document that failed anywhere, so on a
+    // large array the clean items were each paying for a key array.
+    const gateChecks = patChecks.map((c) => c.split(`_k${ci}[_i]`).join(`_f${ci}`))
+    const gateTest = gateChecks.length ? `!_a${ci}.has(_f${ci})&&!(${gateChecks.join('||')})` : `!_a${ci}.has(_f${ci})`
+    const detail = `const _k${ci}=Object.keys(${v});for(let _i=0;_i<_k${ci}.length;_i++){if(${isAdditional}){_e.push({code:'${apLit.codeStr}',keyword:'additionalProperties',instancePath:${pathExpr||'""'},schemaPath:'${apSp}'${ordinalField(ctx, `${apSp}`)},params:{additionalProperty:_k${ci}[_i]},message:'must NOT have additional properties',docUrl:'${apLit.docUrl}'${apLit.frame}});if(!_all)return{valid:false,errors:_e}}}`
+    const inner = `const _a${ci}=new Set([${allowed}]);let _x${ci}=0;for(const _f${ci} in ${v}){if(${gateTest}){_x${ci}=1;break}}if(_x${ci}){${detail}}`
     lines.push(isObj ? `{${inner}}` : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}`)
   }
 
@@ -4554,18 +4569,28 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   if (schema.additionalProperties === false && schema.properties && !schema.patternProperties) {
     const propKeys = Object.keys(schema.properties)
     const ci = ctx.varCounter++
+    // The error has to name the offending property, so the keys have to be
+    // materialised to report one. They do not have to be materialised to find
+    // out whether there is one: a for-in answers that with no allocation, and
+    // an accepted document is the common case. The verdict generator pays a
+    // bare key count here, and this kept the combined function 2.8x that on a
+    // valid document, which is what stopped it from replacing the
+    // verdict-then-revalidate pair on the error path.
+    const detail = (test) =>
+      `const _k${ci}=Object.keys(${v});for(let _i=0;_i<_k${ci}.length;_i++)if(${test}){${fail('additionalProperties', 'additionalProperties', `{additionalProperty:_k${ci}[_i]}`, "'must NOT have additional properties'")}}`
+    let body
     if (propKeys.length <= 8) {
       // Direct chain: no Set allocation for small schemas
+      const gate = propKeys.map(k => `_f${ci}!==${JSON.stringify(k)}`).join('&&')
       const checks = propKeys.map(k => `_k${ci}[_i]!==${JSON.stringify(k)}`).join('&&')
-      lines.push(isObj
-        ? `{const _k${ci}=Object.keys(${v});for(let _i=0;_i<_k${ci}.length;_i++)if(${checks}){${fail('additionalProperties', 'additionalProperties', `{additionalProperty:_k${ci}[_i]}`, "'must NOT have additional properties'")}}}`
-        : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){const _k${ci}=Object.keys(${v});for(let _i=0;_i<_k${ci}.length;_i++)if(${checks}){${fail('additionalProperties', 'additionalProperties', `{additionalProperty:_k${ci}[_i]}`, "'must NOT have additional properties'")}}}`)
+      body = `let _x${ci}=0;for(const _f${ci} in ${v}){if(${gate}){_x${ci}=1;break}}if(_x${ci}){${detail(checks)}}`
     } else {
       const allowed = propKeys.map(k => JSON.stringify(k)).join(',')
-      lines.push(isObj
-        ? `{const _k${ci}=Object.keys(${v});const _a${ci}=new Set([${allowed}]);for(let _i=0;_i<_k${ci}.length;_i++)if(!_a${ci}.has(_k${ci}[_i])){${fail('additionalProperties', 'additionalProperties', `{additionalProperty:_k${ci}[_i]}`, "'must NOT have additional properties'")}}}`
-        : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){const _k${ci}=Object.keys(${v});const _a${ci}=new Set([${allowed}]);for(let _i=0;_i<_k${ci}.length;_i++)if(!_a${ci}.has(_k${ci}[_i])){${fail('additionalProperties', 'additionalProperties', `{additionalProperty:_k${ci}[_i]}`, "'must NOT have additional properties'")}}}`)
+      body = `const _a${ci}=new Set([${allowed}]);let _x${ci}=0;for(const _f${ci} in ${v}){if(!_a${ci}.has(_f${ci})){_x${ci}=1;break}}if(_x${ci}){${detail(`!_a${ci}.has(_k${ci}[_i])`)}}`
     }
+    lines.push(isObj
+      ? `{${body}}`
+      : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${body}}`)
   }
 
   // unevaluatedProperties: false where it is provably additionalProperties

package/lib/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "1.29.0",
+  "version": "1.30.1",
   "description": "JSON Schema validation that compiles for speed and still runs where code generation is blocked. Compiled and interpreted engines answer identically at 100% of the official suite. TypeScript inference, Standard Schema V1, and a build step that emits dependency-free modules.",
   "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_scanner_differential.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_retry_message.js && node tests/test_describe_schema.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_option.js && node tests/test_compile_cache_order.js && node tests/test_engine_diagnostic.js && node tests/test_format_engine_parity.js && node tests/test_uri_helper_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_strict_schema.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_unevaluated_error_shape.js && node tests/test_pattern_properties_errors.js && node tests/test_additional_properties_scaling.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_json_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_defaults_own_keys.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_malformed_json_termination.js && node tests/test_data_positions.js && node tests/test_position_map_cost.js && node tests/test_aot_staleness.js && node tests/test_file_positions.js && node tests/test_schema_hash.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_scanner_differential.js && node tests/test_validate_json_scanner_cost.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_retry_message.js && node tests/test_describe_schema.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_option.js && node tests/test_compile_cache_order.js && node tests/test_engine_diagnostic.js && node tests/test_format_engine_parity.js && node tests/test_error_accumulator_collision.js && node tests/test_uri_helper_parity.js && node tests/test_formats_single_pass.js && node tests/test_email_format_cost.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_deferred_def_scope.js && node tests/test_ajv_errors.js && node tests/test_custom_keywords.js && node tests/test_strict_schema.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_unevaluated_error_shape.js && node tests/test_pattern_properties_errors.js && node tests/test_additional_properties_scaling.js && node tests/test_additional_props_combined_cost.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_single_pass_errors.js && node tests/test_lazy_json_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_defaults_own_keys.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_malformed_json_termination.js && node tests/test_data_positions.js && node tests/test_targeted_positions.js && node tests/test_position_map_cost.js && node tests/test_targeted_positions_cost.js && node tests/test_aot_staleness.js && node tests/test_file_positions.js && node tests/test_aot_positions_cost.js && node tests/test_schema_hash.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",
@@ -121,13 +121,13 @@
     "LICENSE"
   ],
   "optionalDependencies": {
-    "@ata-validator/native-darwin-arm64": "1.29.0",
-    "@ata-validator/native-darwin-x64": "1.29.0",
-    "@ata-validator/native-linux-arm64-gnu": "1.29.0",
-    "@ata-validator/native-linux-arm64-musl": "1.29.0",
-    "@ata-validator/native-linux-x64-gnu": "1.29.0",
-    "@ata-validator/native-linux-x64-musl": "1.29.0",
-    "@ata-validator/native-win32-x64": "1.29.0"
+    "@ata-validator/native-darwin-arm64": "1.30.1",
+    "@ata-validator/native-darwin-x64": "1.30.1",
+    "@ata-validator/native-linux-arm64-gnu": "1.30.1",
+    "@ata-validator/native-linux-arm64-musl": "1.30.1",
+    "@ata-validator/native-linux-x64-gnu": "1.30.1",
+    "@ata-validator/native-linux-x64-musl": "1.30.1",
+    "@ata-validator/native-win32-x64": "1.30.1"
   },
   "peerDependencies": {
     "yaml": "^2.0.0"