ata-validator 1.16.2 → 1.17.1

package/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 All notable changes to ata-validator are documented here. The format follows [Keep a Changelog](https://keepachangelog.com/), and this project adheres to semantic versioning.
 
+## 1.17.1 - 2026-09-13
+
+### Changed
+
+- The rejection object behind a failing `validate()` is an instance of a class with prototype accessors rather than an object literal that defined a getter and a closure on every rejection. Same shape, same laziness, same caching; `JSON.stringify` still sees the errors.
+- Declaration-order sorting of short error lists is a stable in-place insertion sort over the integer keys, with no comparator and no index array. Measured on the raw error list of the schema-benchmarks product schema, 15 errors: 1.49 to 1.10 µs; through the Standard Schema bridge 2.02 to 1.63 µs. Since 1.16.2 that row has gone from 3.30 to 1.63 µs on the same machine, and in the schema-benchmarks harness itself standard invalid went from 3.57 to 1.44 µs (60 percent less), every other row within noise.
+
+### Fixed
+
+- `validateJSON()` reports errors in schema declaration order, as `validate()` does. The text path enriched errors in emission order, so the first error could differ between the two entry points for the same document.
+- An instance built with options no longer answers a later `new Validator(sameSchema)` without options. The identity cache was seeded by every instance, so a validator created with `richErrors: false` or `coerceTypes` could be handed back to a caller that asked for the defaults.
+
+## 1.17.0 - 2026-09-13
+
+### Changed
+
+- Errors are put in schema declaration order by an integer computed when the schema is compiled, not by walking each error's schemaPath at read time. The rank of a path is its pre-order position in the schema tree, which is exactly the order the old array-of-indexes comparison produced; the code generator now writes that position into each error literal (`_o`, an internal field), the reader compares integers, and a list that already arrives in order is returned without sorting or allocating. Errors without a position (an appended custom-keyword error, a path into another document) keep their place next to the error before them. The ordinal logic lives in `lib/schema-order.js`; `tests/test_error_order_ordinal.js` holds the ordinal to the array rank on a set of paths and holds the public error order unchanged.
+- The Standard Schema bridge caches parsed issue paths per instancePath string (bounded, entries frozen), instead of splitting the string for every issue of every rejection.
+- Measured on the schema-benchmarks harness locally, before and after on the same machine: standard invalid 3.57 to 2.83 µs (21 percent less); every other row within noise. On the raw error list of that schema, 15 errors: 1.88 to 1.50 µs; through the Standard Schema bridge 3.30 to 1.99 µs. Verdict paths are untouched.
+- `richErrors: false` keeps the v0.14 key set: the ordering field is dropped from that shape.
+
 ## 1.16.2 - 2026-09-12
 
 ### Fixed

package/index.js

@@ -423,83 +423,127 @@ function resolveSchemaByPath(rootSchema, schemaPath) {
 // A failing route sees the same handful of schemaPaths over and over, which is
 // what makes the first one worth having.
 const _rankCache = new WeakMap();
-const _keyIndexCache = new WeakMap();
-
-function keyIndex(node, seg) {
-  let index = _keyIndexCache.get(node);
-  if (index === undefined) {
-    index = new Map();
-    const keys = Object.keys(node);
-    for (let i = 0; i < keys.length; i++) index.set(keys[i], i);
-    _keyIndexCache.set(node, index);
+const { rankFor: schemaOrderRank, ordinalFor: schemaOrdinal } = require('./lib/schema-order');
+
+// The rejection the rich-errors wrapper returns. `errors` is built on first
+// read and cached; `_ataRaw()` is the raw, schema-ordered list for consumers
+// that carry only message and path, such as the Standard Schema bridge.
+// Prototype accessors, not per-instance ones: see LazyRejection.
+class RichRejection {
+  constructor(result, data, positions, self, root, enrich) {
+    this.valid = false;
+    this._result = result;
+    this._data = data;
+    this._positions = positions;
+    this._self = self;
+    this._root = root;
+    this._enrich = enrich;
+    this._cached = null;
+  }
+  toJSON() {
+    return { valid: false, errors: this.errors };
+  }
+  _ataRaw() {
+    let raw = this._result.errors || [];
+    if (raw.length > 1) raw = sortErrorsBySchemaOrder(this._root, raw);
+    return raw;
   }
-  const at = index.get(seg);
-  return at === undefined ? -1 : at;
-}
-
-// `~1` and `~0` are the only escapes a JSON pointer has, and almost no schema
-// key contains a tilde. Looking for one is far cheaper than two regex passes
-// over every segment of every path.
-function unescapePointerSegment(seg) {
-  return seg.indexOf('~') < 0 ? seg : seg.replace(/~1/g, '/').replace(/~0/g, '~');
 }
+Object.defineProperty(RichRejection.prototype, 'errors', {
+  enumerable: true,
+  configurable: true,
+  get() {
+    if (this._cached === null) {
+      const self = this._self;
+      const enrich = this._enrich;
+      let raw = this._result.errors || [];
+      if (raw.length > 1) raw = sortErrorsBySchemaOrder(this._root, raw);
+      const cached = (enrich && raw.length)
+        ? raw.map((e) => enrich(e, {
+            data: this._data,
+            positions: this._positions,
+            schemaPositions: self._schemaPositions,
+            schemaFile: self._source ? self._source.path : undefined,
+          }))
+        // The v0.14 shape is a fixed key set; the ordering key the
+        // generated code carries is dropped from it here.
+        : raw.map(stripOrdinal);
+      // Correlation is published, never applied. Both halves of a typo pair
+      // stay in the array; `related` only says they are one mistake, so a
+      // wrong pairing costs a sentence rather than a hidden violation.
+      if (enrich && cached.length > 1) attachRelated(cached);
+      // No diagnostic payload here. validate(data) is the library hot path,
+      // and attaching one cost about 100 ns per rejection for a consumer
+      // that never renders. The text path attaches it, and a renderer given
+      // `{ data }` builds frames for object input on request.
+      this._cached = cached;
+    }
+    return this._cached;
+  },
+});
 
-function schemaOrderRank(rootSchema, schemaPath) {
-  if (!schemaPath || typeof schemaPath !== 'string' || !schemaPath.startsWith('#')) return null;
-  if (rootSchema === null || typeof rootSchema !== 'object') return null;
-
-  let byPath = _rankCache.get(rootSchema);
-  if (byPath === undefined) { byPath = new Map(); _rankCache.set(rootSchema, byPath); }
-  const hit = byPath.get(schemaPath);
-  if (hit !== undefined) return hit;
-
-  const rank = _computeRank(rootSchema, schemaPath);
-  byPath.set(schemaPath, rank);
-  return rank;
+// 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;
+  const out = {};
+  for (const k in e) if (k !== '_o') out[k] = e[k];
+  return out;
 }
 
-function _computeRank(rootSchema, schemaPath) {
-  const rank = [];
-  let node = rootSchema;
-  let start = 1;
-  while (start <= schemaPath.length) {
-    let end = schemaPath.indexOf('/', start);
-    if (end < 0) end = schemaPath.length;
-    if (end === start) { start = end + 1; continue; }   // what filter(Boolean) dropped
-    const seg = unescapePointerSegment(schemaPath.slice(start, end));
-    start = end + 1;
-
-    if (node == null || typeof node !== 'object') break;
-    if (Array.isArray(node)) {
-      const idx = Number(seg);
-      if (!Number.isInteger(idx) || idx < 0 || idx >= node.length) break;
-      rank.push(idx);
-      node = node[idx];
-    } else {
-      const idx = keyIndex(node, seg);
-      if (idx < 0) break;
-      rank.push(idx);
-      node = node[seg];
-    }
+// Errors in schema declaration order. Each error's key is its schemaPath's
+// pre-order ordinal in the root schema: written into the literal by the code
+// generator (`_o`), looked up once per path otherwise. Most rejections come
+// out already ordered, and those return without sorting or allocating.
+function sortErrorsBySchemaOrder(rootSchema, errors) {
+  const n = errors.length;
+  const keys = new Array(n);
+  let sorted = true;
+  let prev = -1;
+  for (let i = 0; i < n; i++) {
+    const e = errors[i];
+    let o = typeof e._o === 'number' ? e._o : schemaOrdinal(rootSchema, e.schemaPath);
+    // An error with no place in this document (an appended custom-keyword
+    // error, a path into another schema) stays next to the error before it,
+    // which is where the rank comparison left it too.
+    if (o === null) o = prev < 0 ? 0 : prev;
+    keys[i] = o;
+    if (o < prev) sorted = false;
+    prev = o;
   }
-  return rank;
+  if (sorted) return errors;
+  // Error lists are short. A stable insertion sort over the integer keys
+  // moves the errors in tandem with no comparator calls and no index array.
+  const out = errors.slice();
+  for (let i = 1; i < n; i++) {
+    const k = keys[i];
+    const e = out[i];
+    let j = i - 1;
+    while (j >= 0 && keys[j] > k) { keys[j + 1] = keys[j]; out[j + 1] = out[j]; j--; }
+    keys[j + 1] = k;
+    out[j + 1] = e;
+  }
+  return out;
 }
 
-function sortErrorsBySchemaOrder(rootSchema, errors) {
-  const ranked = errors.map((e, i) => ({ e, i, rank: schemaOrderRank(rootSchema, e.schemaPath) }));
-  ranked.sort((a, b) => {
-    if (!a.rank || !b.rank) return a.i - b.i;
-    const n = Math.min(a.rank.length, b.rank.length);
-    for (let k = 0; k < n; k++) {
-      if (a.rank[k] !== b.rank[k]) return a.rank[k] - b.rank[k];
-    }
-    return a.i - b.i;
-  });
-  return ranked.map((r) => r.e);
-}
 
+// Paths repeat across rejections of the same shape, so the parsed segment
+// list is cached per path string. Entries are frozen: the same array is
+// handed to every issue that names the path. The cache is bounded so a
+// stream of array indexes cannot grow it without limit.
+const _pathCache = new Map();
+const PATH_CACHE_MAX = 4096;
 function parsePointerPath(path) {
-  if (!path) return [];
+  if (!path) return EMPTY_PATH;
+  const hit = _pathCache.get(path);
+  if (hit !== undefined) return hit;
+  const segs = Object.freeze(parsePointerPathUncached(path));
+  if (_pathCache.size >= PATH_CACHE_MAX) _pathCache.clear();
+  _pathCache.set(path, segs);
+  return segs;
+}
+const EMPTY_PATH = Object.freeze([]);
+
+function parsePointerPathUncached(path) {
   // One pass, no intermediate arrays. Per Standard Schema V1 an array index
   // is emitted as a number and an object key as a string; a segment is an
   // index when it is all digits with no leading zero.
@@ -804,6 +848,7 @@ class Validator {
     this._schemaStr = null; // lazy: computed on first use
     this._schemaObj = schemaObj;
     this._options = options;
+    this._noOpts = !opts;
     this._initialized = false;
     this._nativeReady = false;
     this._compiled = null;
@@ -1441,43 +1486,11 @@ class Validator {
           // resolved eagerly since the cache is reset per call.
           const positions = (enrich && self._lastRawInput != null) ? self._pos().get(self._lastRawInput) : null;
           if (positions) self._posCache.reset();
-          let cached = null;
-          return {
-            valid: false,
-            // Raw shape for consumers that carry only message and path, such
-            // as the Standard Schema bridge: schema order, no enrichment.
-            // Reading `errors` afterwards still enriches from the same build.
-            _ataRaw() {
-              let raw = result.errors || [];
-              if (raw.length > 1) raw = sortErrorsBySchemaOrder(root, raw);
-              return raw;
-            },
-            get errors() {
-              if (cached === null) {
-                let raw = result.errors || [];
-                if (raw.length > 1) raw = sortErrorsBySchemaOrder(root, raw);
-                cached = (enrich && raw.length)
-                  ? raw.map((e) => enrich(e, {
-                      data,
-                      positions,
-                      schemaPositions: self._schemaPositions,
-                      schemaFile: self._source ? self._source.path : undefined,
-                    }))
-                  : raw;
-                // Correlation is published, never applied. Both halves of a
-                // typo pair stay in the array; `related` only says they are
-                // one mistake, so a wrong pairing costs a sentence rather
-                // than a hidden violation.
-                if (enrich && cached.length > 1) attachRelated(cached);
-                // No diagnostic payload here. validate(data) is the library
-                // hot path, and attaching one cost about 100 ns per rejection
-                // for a consumer that never renders. The text path attaches
-                // it below, and a renderer given `{ data }` builds frames for
-                // object input on request.
-              }
-              return cached;
-            },
-          };
+          // One instance of a class with prototype accessors. An object
+          // literal with a getter here cost a closure plus an accessor
+          // definition on every rejection, several hundred nanoseconds
+          // before any error was read.
+          return new RichRejection(result, data, positions, self, root, enrich);
         }
         return result;
       };
@@ -1513,7 +1526,10 @@ class Validator {
             try { parsedData = JSON.parse(jsonStr); } catch { parsedData = undefined; }
             if (!first || !first.docUrl) {
               const positions = (this._lastRawInput != null) ? this._pos().get(this._lastRawInput) : null;
-              const enriched = result.errors.map((e) => enrich(e, {
+              // Declaration order, as validate() applies it; the text path
+              // used to enrich in emission order.
+              const ordered = result.errors.length > 1 ? sortErrorsBySchemaOrder(this._schemaObj, result.errors) : result.errors;
+              const enriched = ordered.map((e) => enrich(e, {
                 data: parsedData,
                 positions,
                 schemaPositions: this._schemaPositions,
@@ -1652,8 +1668,12 @@ class Validator {
       if (bufferNeedsSlowPath(schemaObj, this._schemaMap, this._keywords)) installSlowBufferApis(this);
     }
 
-    // Save to identity cache for ultra-fast reuse with same schema object
-    if (this._schemaObj && typeof this._schemaObj === 'object') {
+    // Save to identity cache for ultra-fast reuse with same schema object.
+    // Only an instance built without options may answer a later
+    // `new Validator(schema)`: one built with options (richErrors: false,
+    // coerceTypes, formats, ...) would hand its options to a caller that
+    // asked for none.
+    if (this._noOpts && this._schemaObj && typeof this._schemaObj === 'object') {
       _identityCache.set(this._schemaObj, this);
     }
   }

package/lib/js-compiler.js

@@ -73,6 +73,7 @@ function enumCondition(ctx, vals, v) {
 
 
 const { codeFor } = require('./error-codes')
+const { ordinalFor } = require('./schema-order')
 const { compileSafe, patternIsSafe } = require('./safe-regex')
 
 // Closure value for a patternProperties/propertyNames regex: the linear-time
@@ -94,6 +95,14 @@ const DOC_BASE = 'https://ata-validator.com/e/'
 // like ",schemaSource:Object.freeze({...})" or "" if no source map hit.
 // The fragment always starts with a leading comma when non-empty so callers
 // can splice it inside an existing object literal.
+// The error's position in schema declaration order, as a literal field the
+// reader sorts by without deriving it from the path. Empty when the path is
+// not into the root document.
+function ordinalField (ctx, schemaPath) {
+  const o = ctx && ctx.rootSchema ? ordinalFor(ctx.rootSchema, schemaPath) : null
+  return o === null ? '' : `,_o:${o}`
+}
+
 function buildErrorLiteral (opts) {
   const { keyword, format, schemaPath, sourceMap } = opts
   let code = (keyword === 'format' && format) ? codeFor('format', format) : codeFor(keyword)
@@ -3213,7 +3222,7 @@ function compileToJSCodegenWithErrors(schema, schemaMap, userFormats, sourceOpts
   // AOT output small for schemas that don't compose. Standalone modules can't
   // require('./branch-collapse'), so the helper body is embedded verbatim.
   if (ctx.usesBranchCollapse) {
-    ctx.helperCode.push("const __ATA_SEVERITY={type:10,const:8,enum:8,required:5,format:3,minLength:3,maxLength:3,minimum:3,maximum:3,pattern:3,additionalProperties:2,unevaluatedProperties:2,unevaluatedItems:2};function __ataScore(errs){if(!errs||!errs.length)return 0;let s=0;for(const e of errs)s+=__ATA_SEVERITY[e.keyword]||4;return errs.length*100+s}function __ataCollapse(kw,br,pp,sp){const pass=br.filter(b=>b.valid);if(kw==='oneOf'){if(pass.length===1)return null;if(pass.length>1)return{code:'ATA4002',keyword:'oneOf',instancePath:pp||'',path:pp||'',schemaPath:sp,message:'value matched '+pass.length+' of '+br.length+' oneOf variants, expected exactly one',params:{matched:pass.length,total:br.length}}}else{if(pass.length>=1)return null}let bi=0,bs=Infinity;for(let i=0;i<br.length;i++){const s=__ataScore(br[i].errors);if(s<bs){bs=s;bi=i}}const code=kw==='oneOf'?'ATA4001':'ATA4003';const best=br[bi];return{code,keyword:kw,instancePath:pp||'',path:pp||'',schemaPath:sp,message:'value matched 0 of '+br.length+' '+kw+' variants',params:{variants:br.length,closest:bi,closestName:best.title||('variant '+(bi+1))},branchErrors:best.errors}}")
+    ctx.helperCode.push("const __ATA_SEVERITY={type:10,const:8,enum:8,required:5,format:3,minLength:3,maxLength:3,minimum:3,maximum:3,pattern:3,additionalProperties:2,unevaluatedProperties:2,unevaluatedItems:2};function __ataScore(errs){if(!errs||!errs.length)return 0;let s=0;for(const e of errs)s+=__ATA_SEVERITY[e.keyword]||4;return errs.length*100+s}function __ataCollapse(kw,br,pp,sp,o){const pass=br.filter(b=>b.valid);if(kw==='oneOf'){if(pass.length===1)return null;if(pass.length>1)return{code:'ATA4002',keyword:'oneOf',instancePath:pp||'',path:pp||'',schemaPath:sp,_o:o,message:'value matched '+pass.length+' of '+br.length+' oneOf variants, expected exactly one',params:{matched:pass.length,total:br.length}}}else{if(pass.length>=1)return null}let bi=0,bs=Infinity;for(let i=0;i<br.length;i++){const s=__ataScore(br[i].errors);if(s<bs){bs=s;bi=i}}const code=kw==='oneOf'?'ATA4001':'ATA4003';const best=br[bi];return{code,keyword:kw,instancePath:pp||'',path:pp||'',schemaPath:sp,_o:o,message:'value matched 0 of '+br.length+' '+kw+' variants',params:{variants:br.length,closest:bi,closestName:best.title||('variant '+(bi+1))},branchErrors:best.errors}}")
   }
   if (lines.length === 0) return (d) => ({ valid: true, errors: [] })
 
@@ -3299,7 +3308,7 @@ function emitBranchCollapse (branches, keyword, v, pathExpr, lines, ctx, schemaP
     } else if (sub === false) {
       // A false branch never matches; it reports the same error the
       // interpreter attaches to a false schema.
-      subLines.push(`_e.push({keyword:'not',instancePath:${pathExpr||'""'},schemaPath:'${subSp}',params:{},message:'boolean schema is false'})`)
+      subLines.push(`_e.push({keyword:'not',instancePath:${pathExpr||'""'},schemaPath:'${subSp}'${ordinalField(ctx, `${subSp}`)},params:{},message:'boolean schema is false'})`)
     }
     const title = (sub && typeof sub === 'object' && typeof sub.title === 'string') ? sub.title : ''
     titles.push(title)
@@ -3313,7 +3322,7 @@ function emitBranchCollapse (branches, keyword, v, pathExpr, lines, ctx, schemaP
   const titleArr = JSON.stringify(titles)
   const collapsed = `_brc${fi}`
   const pp = pathExpr || '""'
-  lines.push(`{const ${fnArr}=[${fns.join(',')}];const _bt${fi}=${titleArr};const ${resArr}=[];for(let _bi=0;_bi<${fnArr}.length;_bi++){const _br=${fnArr}[_bi](${v});${resArr}.push({valid:_br.valid,errors:_br.errors,title:_bt${fi}[_bi]})}const ${collapsed}=__ataCollapse('${branchKw}',${resArr},${pp},'${branchSp}');if(${collapsed}){_e.push(${collapsed});if(!_all)return{valid:false,errors:_e}}}`)
+  lines.push(`{const ${fnArr}=[${fns.join(',')}];const _bt${fi}=${titleArr};const ${resArr}=[];for(let _bi=0;_bi<${fnArr}.length;_bi++){const _br=${fnArr}[_bi](${v});${resArr}.push({valid:_br.valid,errors:_br.errors,title:_bt${fi}[_bi]})}const ${collapsed}=__ataCollapse('${branchKw}',${resArr},${pp},'${branchSp}',${(() => { const o = ordinalFor(ctx.rootSchema, branchSp); return o === null ? 'null' : o })()});if(${collapsed}){_e.push(${collapsed});if(!_all)return{valid:false,errors:_e}}}`)
 }
 
 // Error-collecting code generator.
@@ -3327,7 +3336,7 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   // name this keyword `false schema`; changing it here would change output
   // the interpreter path already produces, so both engines say `not`.
   if (schema === false) {
-    lines.push(`;_e.push({keyword:'not',instancePath:${pathExpr||'""'},schemaPath:'${schemaPrefix}',params:{},message:'boolean schema is false'});if(!_all)return{valid:false,errors:_e}`)
+    lines.push(`;_e.push({keyword:'not',instancePath:${pathExpr||'""'},schemaPath:'${schemaPrefix}'${ordinalField(ctx, `${schemaPrefix}`)},params:{},message:'boolean schema is false'});if(!_all)return{valid:false,errors:_e}`)
     return
   }
   if (schema === true) return
@@ -3442,7 +3451,7 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     {
       const typeSp = `${schemaPrefix}/type`
       const lit = buildErrorLiteral({ keyword: 'type', schemaPath: typeSp, sourceMap: ctx.sourceMap })
-      lines.push(`if(!(${conds.join('||')})){_e.push({code:'${lit.codeStr}',keyword:'type',instancePath:${pathExpr||'""'},schemaPath:'${typeSp}',params:{type:'${expected}'},message:'must be ${expected}',docUrl:'${lit.docUrl}'${lit.frame}});if(!_all)return{valid:false,errors:_e}}`)
+      lines.push(`if(!(${conds.join('||')})){_e.push({code:'${lit.codeStr}',keyword:'type',instancePath:${pathExpr||'""'},schemaPath:'${typeSp}'${ordinalField(ctx, `${typeSp}`)},params:{type:'${expected}'},message:'must be ${expected}',docUrl:'${lit.docUrl}'${lit.frame}});if(!_all)return{valid:false,errors:_e}}`)
     }
   }
 
@@ -3455,7 +3464,7 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   const fail = (keyword, schemaSuffix, paramsCode, msgCode, fmt) => {
     const sp = schemaPrefix + '/' + schemaSuffix
     const lit = buildErrorLiteral({ keyword, format: fmt, schemaPath: sp, sourceMap: ctx.sourceMap })
-    return `_e.push({code:'${lit.codeStr}',keyword:'${keyword}',instancePath:${pathExpr||'""'},schemaPath:'${sp}',params:${paramsCode},message:${msgCode},docUrl:'${lit.docUrl}'${lit.frame}});if(!_all)return{valid:false,errors:_e}`
+    return `_e.push({code:'${lit.codeStr}',keyword:'${keyword}',instancePath:${pathExpr||'""'},schemaPath:'${sp}',params:${paramsCode},message:${msgCode},docUrl:'${lit.docUrl}'${lit.frame}${ordinalField(ctx, sp)}});if(!_all)return{valid:false,errors:_e}`
   }
 
   // enum
@@ -3480,7 +3489,7 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     const reqSp = `${schemaPrefix}/required`
     const reqLit = buildErrorLiteral({ keyword: 'required', schemaPath: reqSp, sourceMap: ctx.sourceMap })
     for (const key of schema.required) {
-      lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&!(${JSON.stringify(key)} in ${v})){_e.push({code:'${reqLit.codeStr}',keyword:'required',instancePath:${pathExpr||'""'},schemaPath:'${reqSp}',params:{missingProperty:'${esc(key)}'},message:"must have required property '${esc(key)}'",docUrl:'${reqLit.docUrl}'${reqLit.frame}});if(!_all)return{valid:false,errors:_e}}`)
+      lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&!(${JSON.stringify(key)} in ${v})){_e.push({code:'${reqLit.codeStr}',keyword:'required',instancePath:${pathExpr||'""'},schemaPath:'${reqSp}'${ordinalField(ctx, `${reqSp}`)},params:{missingProperty:'${esc(key)}'},message:"must have required property '${esc(key)}'",docUrl:'${reqLit.docUrl}'${reqLit.frame}});if(!_all)return{valid:false,errors:_e}}`)
     }
   }
 
@@ -3550,7 +3559,7 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     const fc = FORMAT_CODEGEN[schema.format]
     const fmtSp = `${schemaPrefix}/format`
     const fmtLit = buildErrorLiteral({ keyword: 'format', format: schema.format, schemaPath: fmtSp, sourceMap: ctx.sourceMap })
-    const failPush = `_e.push({code:'${fmtLit.codeStr}',keyword:'format',instancePath:${pathExpr||'""'},schemaPath:'${fmtSp}',params:{format:'${esc(schema.format)}'},message:'must match format "${esc(schema.format)}"',docUrl:'${fmtLit.docUrl}'${fmtLit.frame}});if(!_all)return{valid:false,errors:_e}`
+    const failPush = `_e.push({code:'${fmtLit.codeStr}',keyword:'format',instancePath:${pathExpr||'""'},schemaPath:'${fmtSp}'${ordinalField(ctx, `${fmtSp}`)},params:{format:'${esc(schema.format)}'},message:'must match format "${esc(schema.format)}"',docUrl:'${fmtLit.docUrl}'${fmtLit.frame}});if(!_all)return{valid:false,errors:_e}`
     // Format errors use the boolean codegen, each `return false` becoming an
     // error push. One violation reports once: the first failing statement
     // pushes and leaves the labeled block, where it used to fall through and
@@ -3634,7 +3643,7 @@ 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}',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 _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}}}`
     lines.push(isObj ? `{${inner}}` : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}`)
   }
 
@@ -3644,7 +3653,7 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     const drLit = buildErrorLiteral({ keyword: 'dependentRequired', schemaPath: drSp, sourceMap: ctx.sourceMap })
     for (const [key, deps] of Object.entries(schema.dependentRequired)) {
       for (const dep of deps) {
-        lines.push(`if(typeof ${v}==='object'&&${v}!==null&&${JSON.stringify(key)} in ${v}&&!(${JSON.stringify(dep)} in ${v})){_e.push({code:'${drLit.codeStr}',keyword:'required',instancePath:${pathExpr||'""'},schemaPath:'${drSp}',params:{missingProperty:'${esc(dep)}'},message:"must have required property '${esc(dep)}'",docUrl:'${drLit.docUrl}'${drLit.frame}});if(!_all)return{valid:false,errors:_e}}`)
+        lines.push(`if(typeof ${v}==='object'&&${v}!==null&&${JSON.stringify(key)} in ${v}&&!(${JSON.stringify(dep)} in ${v})){_e.push({code:'${drLit.codeStr}',keyword:'required',instancePath:${pathExpr||'""'},schemaPath:'${drSp}'${ordinalField(ctx, `${drSp}`)},params:{missingProperty:'${esc(dep)}'},message:"must have required property '${esc(dep)}'",docUrl:'${drLit.docUrl}'${drLit.frame}});if(!_all)return{valid:false,errors:_e}}`)
       }
     }
   }
@@ -3731,7 +3740,7 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   if (schema.propertyNames === false) {
     const ki = ctx.varCounter++
     const p = pathExpr ? `${pathExpr}+'/'+_k${ki}` : `'/'+_k${ki}`
-    lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){for(const _k${ki} in ${v}){_e.push({keyword:'not',instancePath:${p},schemaPath:'${schemaPrefix}/propertyNames',params:{},message:'boolean schema is false'});if(!_all)return{valid:false,errors:_e}}}`)
+    lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){for(const _k${ki} in ${v}){_e.push({keyword:'not',instancePath:${p},schemaPath:'${schemaPrefix}/propertyNames'${ordinalField(ctx, `${schemaPrefix}/propertyNames`)},params:{},message:'boolean schema is false'});if(!_all)return{valid:false,errors:_e}}}`)
   }
 
   // propertyNames
@@ -3973,7 +3982,7 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   if (schema === false) {
     // Leading semicolon: the previous generated line may end in an
     // expression, and a line starting with `(` would be parsed as a call.
-    lines.push(`;(_e||(_e=[])).push({keyword:'not',instancePath:${pathExpr||'""'},schemaPath:'${schemaPrefix}',params:{},message:'boolean schema is false'})`)
+    lines.push(`;(_e||(_e=[])).push({keyword:'not',instancePath:${pathExpr||'""'},schemaPath:'${schemaPrefix}'${ordinalField(ctx, `${schemaPrefix}`)},params:{},message:'boolean schema is false'})`)
     return
   }
   if (schema === true) return
@@ -4061,12 +4070,15 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
         const pathVal = pathExpr ? pathExpr.slice(1, -1) : ''
         const msgVal = msgCode.slice(1, -1)
         ctx.closureVars.push(errVar)
-        ctx.closureVals.push(Object.freeze({keyword, instancePath: pathVal, schemaPath: sp, params: Object.freeze(paramsVal), message: msgVal}))
+        const o = ordinalFor(ctx.rootSchema, sp)
+        const lit = {keyword, instancePath: pathVal, schemaPath: sp, params: Object.freeze(paramsVal), message: msgVal}
+        if (o !== null) lit._o = o
+        ctx.closureVals.push(Object.freeze(lit))
         return `(_e||(_e=[])).push(${errVar})`
       }
     }
     // Dynamic path (e.g., array index): inline as before
-    return `(_e||(_e=[])).push({keyword:'${keyword}',instancePath:${pathExpr||'""'},schemaPath:'${sp}',params:${paramsCode},message:${msgCode}})`
+    return `(_e||(_e=[])).push({keyword:'${keyword}',instancePath:${pathExpr||'""'},schemaPath:'${sp}',params:${paramsCode},message:${msgCode}${ordinalField(ctx, sp)}})`
   }
 
   if (types) {
@@ -4135,7 +4147,7 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
         ctx.closureVals.push(Object.freeze({keyword: 'required', instancePath: pathVal, schemaPath: `${schemaPrefix}/required`, params: Object.freeze({missingProperty: key}), message: `must have required property '${key}'`}))
         lines.push(`if(${check}){(_e||(_e=[])).push(${errVar})}`)
       } else {
-        lines.push(`if(${check}){(_e||(_e=[])).push({keyword:'required',instancePath:${pathExpr||'""'},schemaPath:'${schemaPrefix}/required',params:{missingProperty:'${esc(key)}'},message:"must have required property '${esc(key)}'"})}`)
+        lines.push(`if(${check}){(_e||(_e=[])).push({keyword:'required',instancePath:${pathExpr||'""'},schemaPath:'${schemaPrefix}/required'${ordinalField(ctx, `${schemaPrefix}/required`)},params:{missingProperty:'${esc(key)}'},message:"must have required property '${esc(key)}'"})}`)
       }
     }
   } else if (schema.required) {
@@ -4149,7 +4161,7 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
         ctx.closureVals.push(Object.freeze({keyword: 'required', instancePath: pathVal, schemaPath: `${schemaPrefix}/required`, params: Object.freeze({missingProperty: key}), message: `must have required property '${key}'`}))
         lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&!(${JSON.stringify(key)} in ${v})){(_e||(_e=[])).push(${errVar})}`)
       } else {
-        lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&!(${JSON.stringify(key)} in ${v})){(_e||(_e=[])).push({keyword:'required',instancePath:${pathExpr||'""'},schemaPath:'${schemaPrefix}/required',params:{missingProperty:'${esc(key)}'},message:"must have required property '${esc(key)}'"})}`)
+        lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&!(${JSON.stringify(key)} in ${v})){(_e||(_e=[])).push({keyword:'required',instancePath:${pathExpr||'""'},schemaPath:'${schemaPrefix}/required'${ordinalField(ctx, `${schemaPrefix}/required`)},params:{missingProperty:'${esc(key)}'},message:"must have required property '${esc(key)}'"})}`)
       }
     }
   }
@@ -4271,7 +4283,7 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
           ctx.closureVals.push(Object.freeze({keyword: 'required', instancePath: pathVal, schemaPath: `${schemaPrefix}/dependentRequired`, params: Object.freeze({missingProperty: dep}), message: `must have required property '${dep}'`}))
           lines.push(`if(typeof ${v}==='object'&&${v}!==null&&${JSON.stringify(key)} in ${v}&&!(${JSON.stringify(dep)} in ${v})){(_e||(_e=[])).push(${errVar})}`)
         } else {
-          lines.push(`if(typeof ${v}==='object'&&${v}!==null&&${JSON.stringify(key)} in ${v}&&!(${JSON.stringify(dep)} in ${v})){(_e||(_e=[])).push({keyword:'required',instancePath:${pathExpr||'""'},schemaPath:'${schemaPrefix}/dependentRequired',params:{missingProperty:'${esc(dep)}'},message:"must have required property '${esc(dep)}'"})}`)
+          lines.push(`if(typeof ${v}==='object'&&${v}!==null&&${JSON.stringify(key)} in ${v}&&!(${JSON.stringify(dep)} in ${v})){(_e||(_e=[])).push({keyword:'required',instancePath:${pathExpr||'""'},schemaPath:'${schemaPrefix}/dependentRequired'${ordinalField(ctx, `${schemaPrefix}/dependentRequired`)},params:{missingProperty:'${esc(dep)}'},message:"must have required property '${esc(dep)}'"})}`)
         }
       }
     }
@@ -4417,7 +4429,7 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   if (schema.propertyNames === false) {
     const ki = ctx.varCounter++
     const p = pathExpr ? `${pathExpr}+'/'+_k${ki}` : `'/'+_k${ki}`
-    lines.push(`;if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){for(const _k${ki} in ${v}){(_e||(_e=[])).push({keyword:'not',instancePath:${p},schemaPath:'${schemaPrefix}/propertyNames',params:{},message:'boolean schema is false'})}}`)
+    lines.push(`;if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){for(const _k${ki} in ${v}){(_e||(_e=[])).push({keyword:'not',instancePath:${p},schemaPath:'${schemaPrefix}/propertyNames'${ordinalField(ctx, `${schemaPrefix}/propertyNames`)},params:{},message:'boolean schema is false'})}}`)
   }
 
   // propertyNames — skip if already merged into patternProperties loop

package/lib/schema-order.js

@@ -0,0 +1,128 @@
+'use strict';
+
+// Declaration order of a schemaPath within its root schema.
+//
+// `rankFor` is the path of child indexes from the root to the node the
+// schemaPath names (or to the deepest node it can reach), which sorts errors
+// in the order their keywords appear in the schema. `ordinalFor` is the same
+// order as one integer: the node's pre-order position in the schema tree.
+// Comparing two ranks segment by segment gives exactly the pre-order
+// relation, so the integer can stand in for the array, and the code
+// generator can compute it once per error site instead of the reader
+// deriving it from the path string on every rejection.
+//
+// Both are memoized per root schema; a validator's root never changes.
+
+const _keyIndexCache = new WeakMap();
+const _rankCache = new WeakMap();
+const _ordinalCache = new WeakMap();
+
+function keyIndex(node, seg) {
+  let index = _keyIndexCache.get(node);
+  if (index === undefined) {
+    index = new Map();
+    const keys = Object.keys(node);
+    for (let i = 0; i < keys.length; i++) index.set(keys[i], i);
+    _keyIndexCache.set(node, index);
+  }
+  const at = index.get(seg);
+  return at === undefined ? -1 : at;
+}
+
+// `~1` and `~0` are the only escapes a JSON pointer has, and almost no schema
+// key contains a tilde. Looking for one is far cheaper than two regex passes
+// over every segment of every path.
+function unescapePointerSegment(seg) {
+  return seg.indexOf('~') < 0 ? seg : seg.replace(/~1/g, '/').replace(/~0/g, '~');
+}
+
+function escapePointerSegment(seg) {
+  return seg.indexOf('~') < 0 && seg.indexOf('/') < 0 ? seg : seg.replace(/~/g, '~0').replace(/\//g, '~1');
+}
+
+function rankFor(rootSchema, schemaPath) {
+  if (!schemaPath || typeof schemaPath !== 'string' || !schemaPath.startsWith('#')) return null;
+  if (rootSchema === null || typeof rootSchema !== 'object') return null;
+  let byPath = _rankCache.get(rootSchema);
+  if (byPath === undefined) { byPath = new Map(); _rankCache.set(rootSchema, byPath); }
+  const hit = byPath.get(schemaPath);
+  if (hit !== undefined) return hit;
+  const rank = computeRank(rootSchema, schemaPath);
+  byPath.set(schemaPath, rank);
+  return rank;
+}
+
+function computeRank(rootSchema, schemaPath) {
+  const rank = [];
+  let node = rootSchema;
+  let start = 1;
+  while (start <= schemaPath.length) {
+    let end = schemaPath.indexOf('/', start);
+    if (end < 0) end = schemaPath.length;
+    if (end === start) { start = end + 1; continue; }
+    const seg = unescapePointerSegment(schemaPath.slice(start, end));
+    start = end + 1;
+    if (node == null || typeof node !== 'object') break;
+    if (Array.isArray(node)) {
+      const idx = Number(seg);
+      if (!Number.isInteger(idx) || idx < 0 || idx >= node.length) break;
+      rank.push(idx);
+      node = node[idx];
+    } else {
+      const idx = keyIndex(node, seg);
+      if (idx < 0) break;
+      rank.push(idx);
+      node = node[seg];
+    }
+  }
+  return rank;
+}
+
+// Pre-order numbering of every node in the schema, keyed by its pointer as
+// it appears in a schemaPath (segments escaped). Built once per root, on the
+// first ask. Cyclic structures are guarded; a schema object can contain
+// itself only through references, which are strings.
+function ordinals(rootSchema) {
+  let map = _ordinalCache.get(rootSchema);
+  if (map !== undefined) return map;
+  map = new Map();
+  const seen = new Set();
+  let next = 0;
+  const walk = (node, pointer) => {
+    map.set(pointer, next++);
+    if (node === null || typeof node !== 'object') return;
+    if (seen.has(node)) return;
+    seen.add(node);
+    if (Array.isArray(node)) {
+      for (let i = 0; i < node.length; i++) walk(node[i], pointer + '/' + i);
+    } else {
+      for (const key of Object.keys(node)) walk(node[key], pointer + '/' + escapePointerSegment(key));
+    }
+  };
+  walk(rootSchema, '#');
+  _ordinalCache.set(rootSchema, map);
+  return map;
+}
+
+// The ordinal of the deepest node the schemaPath reaches; null when the path
+// is not into this document.
+function ordinalFor(rootSchema, schemaPath) {
+  if (!schemaPath || typeof schemaPath !== 'string' || schemaPath.charCodeAt(0) !== 35) return null;
+  if (rootSchema === null || typeof rootSchema !== 'object') return null;
+  const map = ordinals(rootSchema);
+  const hit = map.get(schemaPath);
+  if (hit !== undefined) return hit;
+  // Walk back to the longest prefix that exists. Paths through a keyword's
+  // value that is a primitive, or through a key the schema does not have,
+  // land on the nearest enclosing node.
+  let p = schemaPath;
+  while (true) {
+    const cut = p.lastIndexOf('/');
+    if (cut < 0) return 0;
+    p = p.slice(0, cut);
+    const o = map.get(p);
+    if (o !== undefined) return o;
+  }
+}
+
+module.exports = { rankFor, ordinalFor, unescapePointerSegment };

package/lib/version.js

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

package/package.json

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