ata-validator 1.16.1 → 1.17.0

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 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.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
+
+- A schema with `unevaluatedProperties` or `unevaluatedItems` reported every failure as one placeholder error, `{ code: 'unevaluated', message: 'unevaluated property or item' }`, with no `keyword` and no `instancePath`. The generated code answers the verdict for these schemas but the error generator declines them, and the error path then fell into a stub instead of the interpreted engine, which reports them correctly. A wrong type, a missing required property, a bad format or an enum miss under a root `unevaluatedProperties: false` all came back as that one line, so anything mapping errors by keyword and path saw nothing useful. Failing data is now re-validated by the interpreted engine on that path, as it already was without the native addon for other declined shapes. Verdicts were never affected. Found by a user comparing error output on a generated config schema. `tests/test_unevaluated_error_path.js` holds the generated-code path to the interpreter's errors on five shapes, in all three engine modes.
+
 ## 1.16.1 - 2026-09-12
 
 ### Fixed

package/index.js

@@ -423,83 +423,64 @@ 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 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 schemaOrderRank(rootSchema, schemaPath) {
-  if (!schemaPath || typeof schemaPath !== 'string' || !schemaPath.startsWith('#')) return null;
-  if (rootSchema === null || typeof rootSchema !== 'object') return null;
+const { rankFor: schemaOrderRank, ordinalFor: schemaOrdinal } = require('./lib/schema-order');
 
-  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;
+  const idx = new Array(n);
+  for (let i = 0; i < n; i++) idx[i] = i;
+  idx.sort((a, b) => keys[a] - keys[b] || a - b);
+  const out = new Array(n);
+  for (let i = 0; i < n; i++) out[i] = errors[idx[i]];
+  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.
@@ -1057,12 +1038,14 @@ class Validator {
           }]
         };
       };
+      // The error generator declines unevaluated*; the interpreted engine
+      // reports those schemas correctly, so failing data is re-validated
+      // there. This used to be a placeholder error with no keyword and no
+      // path, which hid whatever had actually failed.
       const errFn =
         safeErrFn ||
-        (hasUnevaluated
-          ? (d) => ({ valid: jsFn(d), errors: jsFn(d) ? [] : [{ code: 'unevaluated', path: '', message: 'unevaluated property or item' }] })
-          : !native
-            ? jsOnlyFallback
+        (hasUnevaluated || !native
+          ? jsOnlyFallback
             : hasDynRef
               ? (d) => {
                   this._ensureNative();
@@ -1461,7 +1444,9 @@ class Validator {
                       schemaPositions: self._schemaPositions,
                       schemaFile: self._source ? self._source.path : undefined,
                     }))
-                  : raw;
+                  // 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

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.1';
+module.exports = '1.17.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "1.16.1",
+  "version": "1.17.0",
   "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_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_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.1",
-    "@ata-validator/native-darwin-x64": "1.16.1",
-    "@ata-validator/native-linux-arm64-gnu": "1.16.1",
-    "@ata-validator/native-linux-arm64-musl": "1.16.1",
-    "@ata-validator/native-linux-x64-gnu": "1.16.1",
-    "@ata-validator/native-linux-x64-musl": "1.16.1",
-    "@ata-validator/native-win32-x64": "1.16.1"
+    "@ata-validator/native-darwin-arm64": "1.17.0",
+    "@ata-validator/native-darwin-x64": "1.17.0",
+    "@ata-validator/native-linux-arm64-gnu": "1.17.0",
+    "@ata-validator/native-linux-arm64-musl": "1.17.0",
+    "@ata-validator/native-linux-x64-gnu": "1.17.0",
+    "@ata-validator/native-linux-x64-musl": "1.17.0",
+    "@ata-validator/native-win32-x64": "1.17.0"
   },
   "peerDependencies": {
     "yaml": "^2.0.0"