ata-validator 1.44.0 → 1.45.0

package/README.md

@@ -244,21 +244,21 @@ is the most common way to get a misleading number out of this library.
 
 | | compiled with `ata build` | runtime `new Validator(schema)` |
 |---|---|---|
-| In a bundle, gzipped | **2.1 KB** | 110.7 KB |
-| Time to a served request | **3.5 ms** | 8.2 ms |
+| In a bundle, gzipped | **2.1 KB** | 112.8 KB |
+| Time to a served request | **3.5 ms** | 8.6 ms |
 | Schema known when | build time | any time |
 
 The bundle row is the ten-field user schema in
 `tests/fixtures/error-dx/user.schema.json`, every export of the compiled module against
-`new Validator(schema)`, built with `bun build --minify --target=browser` on ata 1.43.0.
+`new Validator(schema)`, built with `bun build --minify --target=browser` on ata 1.44.0.
 The startup row is a Hono route on Bun 1.4, the median of three rounds of best-of-seven, from
-`benchmark/bundle`, against 3.4 ms for the same app doing no validation at all, so the
+`benchmark/bundle`, against 3.5 ms for the same app doing no validation at all, so the
 compiled path costs nothing measurable to start. The runtime figure is what it is because
 a schema that arrives at run time can use any keyword, so the whole engine has to be
 there. The compiled module imports nothing and contains only the checks your schema asks
 for.
 
-**On a server, use whichever fits your schemas.** 111 KB of JavaScript on a Node or Bun
+**On a server, use whichever fits your schemas.** 113 KB of JavaScript on a Node or Bun
 process is not a cost anyone notices, and the runtime API is the simpler thing to reach
 for. Speed is the same either way once warm.
 
@@ -491,7 +491,7 @@ const v = new Validator(schema, {
 
 ### Build-time compile (`ata compile`)
 
-The `ata` CLI turns a JSON Schema file into a self-contained JavaScript module. No runtime dependency on `ata-validator`, so only the generated validator ships to the browser. For the ten-field user schema in `tests/fixtures/error-dx/user.schema.json` the module is 2.1 KB gzipped, full error detail included, against 110.7 KB for the runtime bundled for the browser (ata 1.43.0).
+The `ata` CLI turns a JSON Schema file into a self-contained JavaScript module. No runtime dependency on `ata-validator`, so only the generated validator ships to the browser. For the ten-field user schema in `tests/fixtures/error-dx/user.schema.json` the module is 2.1 KB gzipped, full error detail included, against 112.8 KB for the runtime bundled for the browser (ata 1.44.0).
 
 ```bash
 npx ata compile schemas/user.json -o src/generated/user.validator.mjs
@@ -533,11 +533,11 @@ npx ata build 'schemas/*.json' --out-dir build/validators --check
 Run with `--watch` during development for incremental rebuilds.
 
 Bundle sizes for the 10-field user schema in `tests/fixtures/error-dx/user.schema.json`,
-minified and gzipped, measured with `bun build --minify --target=browser` on ata 1.43.0:
+minified and gzipped, measured with `bun build --minify --target=browser` on ata 1.44.0:
 
 | What the app imports | Size | Notes |
 |---|---|---|
-| `Validator` from `ata-validator` | 110.7 KB | The compiler ships with it, because a runtime schema can use any keyword |
+| `Validator` from `ata-validator` | 112.8 KB | The compiler ships with it, because a runtime schema can use any keyword |
 | `isValid` from the compiled module | **1.3 KB** | Nothing else is reachable, so the error collector is dropped |
 | `validate` from the compiled module | **1.9 KB** | Adds the detailed error collector |
 
@@ -575,7 +575,7 @@ through a `setFormats()` export the module carries. `docs/API.md` has the
 details.
 
 **Fastify startup, 10 route schemas, from a cold process to the first validated request:
-ajv 19.9 ms, ata 2.9 ms, no build step required.** ata registers in 0.5 ms of that and
+ajv 19.4 ms, ata 2.7 ms, no build step required.** ata registers in 0.2 ms of that and
 compiles on the first request, so counting only registration would overstate the gap.
 Reproduce with `node benchmark/bench_fastify_boot.mjs`.
 

package/lib/formats.js

@@ -382,12 +382,18 @@ function uriChar (c) {
 function isHex (c) {
   return (c >= 48 && c <= 57) || (c >= 97 && c <= 102) || (c >= 65 && c <= 70);
 }
+// The same set through the URI_CHAR and HEX_CHAR tables: one load per
+// character, where uriChar() was a call and up to eleven comparisons, and on
+// SchemaStore's SARIF samples, full of URIs, that loop was a sixth of what the
+// interpreted engine spent. A "%" at the end reads past the string, NaN,
+// which fails the bound as it failed isHex().
 function uriChars (s, from) {
   for (let i = from; i < s.length; i++) {
     const c = s.charCodeAt(i);
-    if (!uriChar(c)) return false;
+    if (c > 127 || URI_CHAR[c] === 0) return false;
     if (c === 37) { // '%'
-      if (!isHex(s.charCodeAt(i + 1)) || !isHex(s.charCodeAt(i + 2))) return false;
+      const h1 = s.charCodeAt(i + 1), h2 = s.charCodeAt(i + 2);
+      if (!(h1 <= 127) || !(h2 <= 127) || HEX_CHAR[h1] === 0 || HEX_CHAR[h2] === 0) return false;
       i += 2;
     }
   }

package/lib/interpreter.js

@@ -183,26 +183,22 @@ function resolveRef(ref, fromBase, state) {
 
 // ---------- value helpers ----------
 
-function deepEqual(a, b) {
-  if (a === b) return true;
-  if (typeof a === 'number' && typeof b === 'number') return a === b;
-  if (a === null || b === null || typeof a !== 'object' || typeof b !== 'object') return false;
-  const aArr = Array.isArray(a);
-  if (aArr !== Array.isArray(b)) return false;
-  if (aArr) {
-    if (a.length !== b.length) return false;
-    for (let i = 0; i < a.length; i++) if (!deepEqual(a[i], b[i])) return false;
-    return true;
-  }
-  const ak = Object.keys(a);
-  const bk = Object.keys(b);
-  if (ak.length !== bk.length) return false;
-  for (const k of ak) {
-    if (!(k in b) || !deepEqual(a[k], b[k])) return false;
-  }
-  return true;
+// uniqueItems: the functions the code generator emits as _uq and _uqp
+// (lib/unique-items.js), so both engines run the same code.
+const { allDistinct, duplicatePair, _deq } = require('./unique-items');
+
+// Whether `data` deep-equals one of the node's enum values (see enumPrims).
+function enumMember(P, data) {
+  if (data === null || typeof data !== 'object') return P.enumPrims.has(data);
+  const objs = P.enumObjs;
+  for (let i = 0; i < objs.length; i++) if (deepEqual(objs[i], data)) return true;
+  return false;
 }
 
+// JSON equality: the same function the code generator emits as `_deq`, so the
+// engines agree on what equal means (an object's own keys, in any order).
+const deepEqual = _deq;
+
 function codePointLength(s) {
   let n = 0;
   for (let i = 0; i < s.length; i++) {
@@ -375,6 +371,21 @@ class Plan {
     }
     this.hasType = schema.type !== undefined;
     this.enum = schema.enum !== undefined ? schema.enum : null;
+    // Membership for enumMember(): the primitive values in a Set, so a long
+    // enum answers in one lookup, and the object and array values, which only
+    // deepEqual can compare, in a list. Scanning every value with deepEqual
+    // was a fifth to a third of what validating SchemaStore's samples cost.
+    // NaN stays out of the Set: deepEqual never matches it, and a Set would.
+    this.enumPrims = null;
+    this.enumObjs = null;
+    if (Array.isArray(this.enum)) {
+      this.enumPrims = new Set();
+      this.enumObjs = [];
+      for (const v of this.enum) {
+        if (v !== null && typeof v === 'object') this.enumObjs.push(v);
+        else if (!(typeof v === 'number' && v !== v)) this.enumPrims.add(v);
+      }
+    }
     this.hasConst = schema.const !== undefined;
     this.const = schema.const;
 
@@ -524,9 +535,7 @@ function evalLeafV(P, data) {
   const bits = dataBits(data);
   if (P.hasType && (bits & P.typeMask) === 0) return false;
   if (P.enum !== null) {
-    let found = false;
-    for (let i = 0; i < P.enum.length; i++) { if (deepEqual(P.enum[i], data)) { found = true; break; } }
-    if (!found) return false;
+    if (!enumMember(P, data)) return false;
   }
   if (P.hasConst && !deepEqual(P.const, data)) return false;
   if (P.hasNumber && Number.isFinite(data)) {
@@ -545,13 +554,7 @@ function evalLeafV(P, data) {
   if (P.hasArray && bits === T_ARRAY) {
     if (P.minItems !== undefined && data.length < P.minItems) return false;
     if (P.maxItems !== undefined && data.length > P.maxItems) return false;
-    if (P.uniqueItems) {
-      for (let i = 0; i < data.length; i++) {
-        for (let j = i + 1; j < data.length; j++) {
-          if (deepEqual(data[i], data[j])) return false;
-        }
-      }
-    }
+    if (P.uniqueItems && !allDistinct(data)) return false;
   }
   if (P.hasObject && bits === T_OBJECT) {
     if (P.required !== null) {
@@ -635,9 +638,7 @@ function evalLeaf(P, data, errors, instancePath, schemaPath) {
     valid = false;
   }
   if (P.enum !== null) {
-    let found = false;
-    for (let i = 0; i < P.enum.length; i++) { if (deepEqual(P.enum[i], data)) { found = true; break; } }
-    if (!found) {
+    if (!enumMember(P, data)) {
       if (errors !== NOERRORS) errors.push(err('enum', 'enum', instancePath, schemaPath + '/enum', { allowedValues: P.enum }, 'must be equal to one of the allowed values'));
       valid = false;
     }
@@ -663,14 +664,11 @@ function evalLeaf(P, data, errors, instancePath, schemaPath) {
     if (P.minItems !== undefined && data.length < P.minItems) { errors === NOERRORS || errors.push(err('minItems', 'minItems', instancePath, schemaPath + '/minItems', { limit: P.minItems }, `must NOT have fewer than ${P.minItems} items`)); valid = false; }
     if (P.maxItems !== undefined && data.length > P.maxItems) { errors === NOERRORS || errors.push(err('maxItems', 'maxItems', instancePath, schemaPath + '/maxItems', { limit: P.maxItems }, `must NOT have more than ${P.maxItems} items`)); valid = false; }
     if (P.uniqueItems) {
-      outer: for (let i = 0; i < data.length; i++) {
-        for (let j = i + 1; j < data.length; j++) {
-          if (deepEqual(data[i], data[j])) {
-            if (errors !== NOERRORS) errors.push(err('uniqueItems', 'uniqueItems', instancePath, schemaPath + '/uniqueItems', { i, j }, `must NOT have duplicate items (items ## ${j} and ${i} are identical)`));
-            valid = false;
-            break outer;
-          }
-        }
+      const pair = duplicatePair(data);
+      if (pair !== null) {
+        const i = pair[0], j = pair[1];
+        if (errors !== NOERRORS) errors.push(err('uniqueItems', 'uniqueItems', instancePath, schemaPath + '/uniqueItems', { i, j }, `must NOT have duplicate items (items ## ${j} and ${i} are identical)`));
+        valid = false;
       }
     }
   }
@@ -924,9 +922,7 @@ class Interpreter {
       valid = false;
     }
     if (P.enum !== null) {
-      let found = false;
-      for (let i = 0; i < P.enum.length; i++) { if (deepEqual(P.enum[i], data)) { found = true; break; } }
-      if (!found) {
+      if (!enumMember(P, data)) {
         if (errors !== NOERRORS) errors.push(err('enum', 'enum', instancePath, schemaPath + '/enum', { allowedValues: P.enum }, 'must be equal to one of the allowed values'));
         valid = false;
       }
@@ -958,14 +954,11 @@ class Interpreter {
       if (P.minItems !== undefined && data.length < P.minItems) { errors === NOERRORS || errors.push(err('minItems', 'minItems', instancePath, schemaPath + '/minItems', { limit: P.minItems }, `must NOT have fewer than ${P.minItems} items`)); valid = false; }
       if (P.maxItems !== undefined && data.length > P.maxItems) { errors === NOERRORS || errors.push(err('maxItems', 'maxItems', instancePath, schemaPath + '/maxItems', { limit: P.maxItems }, `must NOT have more than ${P.maxItems} items`)); valid = false; }
       if (P.uniqueItems) {
-        outer: for (let i = 0; i < data.length; i++) {
-          for (let j = i + 1; j < data.length; j++) {
-            if (deepEqual(data[i], data[j])) {
-              if (errors !== NOERRORS) errors.push(err('uniqueItems', 'uniqueItems', instancePath, schemaPath + '/uniqueItems', { i, j }, `must NOT have duplicate items (items ## ${j} and ${i} are identical)`));
-              valid = false;
-              break outer;
-            }
-          }
+        const pair = duplicatePair(data);
+        if (pair !== null) {
+          const i = pair[0], j = pair[1];
+          if (errors !== NOERRORS) errors.push(err('uniqueItems', 'uniqueItems', instancePath, schemaPath + '/uniqueItems', { i, j }, `must NOT have duplicate items (items ## ${j} and ${i} are identical)`));
+          valid = false;
         }
       }
       const prefix = P.prefixItems;
@@ -1246,7 +1239,7 @@ function err(code, keyword, instancePath, schemaPath, params, message) {
 
 const { compileInterpreter } = require('./plan-compiler').install({
   Plan, NOERRORS, err, evalLeaf, evalLeafV, runCustomV, dataBits, escapePointer,
-  deepEqual, multipleOfOk, cpAtLeast, cpAtMost,
+  deepEqual, enumMember, allDistinct, multipleOfOk, cpAtLeast, cpAtMost,
   T_STRING, T_ARRAY, T_OBJECT, resolveRef, splitFragment, resolveUri,
 });
 

package/lib/js-compiler.js

@@ -10,12 +10,20 @@
 // forms answers a different question and costs a string per call.
 const DEQ_HELPER = "function _deq(a,b){if(a===b)return true;if(a===null||b===null||typeof a!=='object'||typeof b!=='object')return false;var aa=Array.isArray(a);if(aa!==Array.isArray(b))return false;var i;if(aa){if(a.length!==b.length)return false;for(i=0;i<a.length;i++)if(!_deq(a[i],b[i]))return false;return true}var ka=Object.keys(a);if(ka.length!==Object.keys(b).length)return false;for(i=0;i<ka.length;i++){var k=ka[i];if(!Object.prototype.hasOwnProperty.call(b,k)||!_deq(a[k],b[k]))return false}return true}"
 
-// uniqueItems helpers for the boolean generator. `_uq` answers whether every
-// item is distinct: short arrays compare pairwise and allocate nothing,
-// longer ones use a Set of primitives and fall back to sorted-key canonical
-// strings only once an object actually appears.
-const UQ_HELPERS = "function _cn(x){if(x===null||typeof x!=='object')return typeof x+':'+x;if(Array.isArray(x))return'['+x.map(_cn).join(',')+']';return'{'+Object.keys(x).sort().map(function(k){return JSON.stringify(k)+':'+_cn(x[k])}).join(',')+'}'}" +
-  "function _uq(a){var n=a.length,i,k;if(n<2)return true;if(n<=12){for(i=1;i<n;i++)for(k=0;k<i;k++)if(_deq(a[i],a[k]))return false;return true}var s=new Set();for(i=0;i<n;i++){var x=a[i];if(x!==null&&typeof x==='object')break;if(s.has(x))return false;s.add(x)}if(i===n)return true;s=new Set();for(i=0;i<n;i++){var c=_cn(a[i]);if(s.has(c))return false;s.add(c)}return true}"
+// uniqueItems helpers, emitted from the functions the interpreted engine
+// calls (lib/unique-items.js): `_uq` answers whether every item is distinct.
+// Loaded at the first schema with uniqueItems, not on every cold start.
+// Comment lines and indentation are dropped: the text lands in every
+// generated function and ahead-of-time module that checks uniqueItems.
+let _uqSources = null
+function uqSources () {
+  if (_uqSources === null) {
+    const u = require('./unique-items')
+    const compact = (fn) => String(fn).replace(/\n\s*\/\/[^\n]*/g, '').replace(/\n\s*/g, '\n')
+    _uqSources = { uq: compact(u._uqh) + compact(u._uq), uqp: 'var _uqpI=0;' + compact(u._uqp) }
+  }
+  return _uqSources
+}
 
 // Where a generator hoists a declaration so it runs once per compiled
 // function rather than once per call. The boolean generator has a preamble
@@ -97,7 +105,7 @@ function emitPtrEsc(ctx) {
 // `_uq` compares items with `_deq`, so it can never be hoisted alone.
 function emitUq(ctx) {
   emitDeq(ctx)
-  hoistOnce(ctx, '_uqHoisted', UQ_HELPERS)
+  hoistOnce(ctx, '_uqHoisted', uqSources().uq)
   return '_uq'
 }
 
@@ -107,15 +115,11 @@ function emitUq(ctx) {
 // a later equal, paired with its first later equal. That is the pair the
 // interpreted engine reports, and the generators used to report a different
 // one (the earliest repeat, paired with what it repeats), so the same document
-// named a different pair depending on the engine that answered. Short arrays
-// compare pairwise and allocate nothing; longer ones key a Map by value, or by
-// canonical string once an object appears. Building a canonical string for
-// every item on every call, as the generators did, made reading a uniqueItems
-// error up to ten times the cost of the verdict.
-const UQP_HELPER = "var _uqpI=0;function _uqp(a){var n=a.length,i,k;if(n<2)return -1;if(n<=12){for(i=0;i<n-1;i++)for(k=i+1;k<n;k++)if(_deq(a[i],a[k])){_uqpI=i;return k}return -1}var prim=true;for(i=0;i<n;i++){var x=a[i];if(x!==null&&typeof x==='object'){prim=false;break}}var m=new Map(),bi=-1,bj=-1;for(i=0;i<n;i++){var c=prim?a[i]:_cn(a[i]);var p=m.get(c);if(p===undefined)m.set(c,i);else if(p>=0){if(bi<0||p<bi){bi=p;bj=i}m.set(c,-1)}}if(bi<0)return -1;_uqpI=bi;return bj}"
+// named a different pair depending on the engine that answered. See
+// lib/unique-items.js for how it finds the pair.
 function emitUqp(ctx) {
   emitUq(ctx)
-  hoistOnce(ctx, '_uqpHoisted', UQP_HELPER)
+  hoistOnce(ctx, '_uqpHoisted', uqSources().uqp)
   return '_uqp'
 }
 
@@ -3481,6 +3485,10 @@ function genUniqueItemsNode(schema, v, lines, ctx, knownType, hoisted, isArr, ty
     // up. The previous form built the canonical closure and a Set on
     // every call, even for [1, 2, 3].
     inner = `if(!${emitUq(ctx)}(${v}))return false`
+  } else if (ctx.helperCode) {
+    // Inside the error or combined function, whose helper code is emitted
+    // into its source, the same hoisted helper.
+    inner = `if(!${emitUq(ctx)}(${v}))return false`
   } else {
     inner = `const _cn${si}=function(x){if(x===null||typeof x!=='object')return typeof x+':'+x;if(Array.isArray(x))return'['+x.map(_cn${si}).join(',')+']';return'{'+Object.keys(x).sort().map(function(k){return JSON.stringify(k)+':'+_cn${si}(x[k])}).join(',')+'}'};const _s${si}=new Set();for(let _i=0;_i<${v}.length;_i++){const _k=_cn${si}(${v}[_i]);if(_s${si}.has(_k))return false;_s${si}.add(_k)}`
   }
@@ -5203,7 +5211,7 @@ function emitBranchCollapse (branches, keyword, v, pathExpr, lines, ctx, schemaP
   // In the combined function `_e` is created on the first error and every
   // error is collected (`_all` is true there), so the report only pushes.
   const report = ctx.inCombined && !ctx.inBranchFn
-    ? `const ${collapsed}=__ataCollapse('${branchKw}',${resArr},_pp${fi},'${branchSp}',${ord},_bt${fi});if(${collapsed})(_e||(_e=[])).push(${collapsed})`
+    ? `const ${collapsed}=__ataCollapse('${branchKw}',${resArr},_pp${fi},'${branchSp}',${ord},_bt${fi});if(${collapsed})(_e=_ap(_e,${collapsed}))`
     : `const ${collapsed}=__ataCollapse('${branchKw}',${resArr},_pp${fi},'${branchSp}',${ord},_bt${fi});if(${collapsed}){_e.push(${collapsed});if(!_all)return{valid:false,errors:_e}}`
   // The node's runtime unevaluatedProperties already counted how many of
   // these branches pass, through the annotation functions, which answer the
@@ -5219,7 +5227,7 @@ function emitBranchCollapse (branches, keyword, v, pathExpr, lines, ctx, schemaP
   // branch errors, so it is built from the bits the count left.
   if (guard !== '' && keyword === 'oneOf' && counted.mask && ctx.inCombined && !ctx.inBranchFn) {
     const ord0 = ctx.noOrdinal ? 'null' : (() => { const o = ordinalFor(ctx.rootSchema, unescapeSp(branchSp)); return o === null ? 'null' : o })()
-    guard = `if(${same}&&${counted.count}>1){const _pi${fi}=[];for(let _k=0;_k<${branches.length};_k++)if((${counted.mask}>>_k)&1)_pi${fi}.push(_k);(_e||(_e=[])).push(__ataMulti(_pi${fi},${branches.length},${pp},'${branchSp}',${ord0}))}else if(!(${same}&&${counted.count}===1))`
+    guard = `if(${same}&&${counted.count}>1){const _pi${fi}=[];for(let _k=0;_k<${branches.length};_k++)if((${counted.mask}>>_k)&1)_pi${fi}.push(_k);(_e=_ap(_e,__ataMulti(_pi${fi},${branches.length},${pp},'${branchSp}',${ord0})))}else if(!(${same}&&${counted.count}===1))`
   }
   // Without such a count, each branch also gets a verdict function, and the
   // passing branches are counted with those: a oneOf with exactly one and an
@@ -5280,7 +5288,7 @@ function emitBranchCollapse (branches, keyword, v, pathExpr, lines, ctx, schemaP
         ? `const _pi${fi}=[];for(let _k=0;_k<${L};_k++)if((_m${fi}>>_k)&1)_pi${fi}.push(_k);`
         : ''
       const multi = `__ataMulti(_pi${fi},${L},_pp${fi},'${branchSp}',${ord})`
-      const pushMulti = top ? `(_e||(_e=[])).push(${multi})` : `_e.push(${multi});if(!_all)return{valid:false,errors:_e}`
+      const pushMulti = top ? `(_e=_ap(_e,${multi}))` : `_e.push(${multi});if(!_all)return{valid:false,errors:_e}`
       const count = tests.map((t, i) => `if(${t}){_n${fi}++;${mk ? `_m${fi}|=${1 << i}` : `_pi${fi}.push(${i})`}}`).join('')
       lines.push(`{const _pp${fi}=${pp};let _n${fi}=0${mk ? `,_m${fi}=0` : `,_pi${fi}=[]`};${count}if(_n${fi}!==1){if(_all===0){_e.push(null);return{valid:false,errors:_e}}if(_n${fi}>1){${collect}${pushMulti}}else{const ${resArr}=[];for(let _bi=0;_bi<${L};_bi++)${resArr}.push(${call});${report}}}}`)
     }
@@ -6012,7 +6020,7 @@ function sharedErr (lit, rootSchema) {
 // the document. `paramsShared` names a frozen params object hoisted for a
 // static site, so a static error's params stay one shared object as before.
 function errPushC(ctx, keyword, sp, pathExpr, paramsCode, msgCode, valueExpr, lean, paramsShared) {
-  if (!ctx.rich) return `(_e||(_e=[])).push(${lean})`
+  if (!ctx.rich) return `(_e=_ap(_e,${lean}))`
   if (!ctx.richMk) {
     ctx.richMk = true
     const { makeRich } = require('./enrich-site')
@@ -6028,7 +6036,7 @@ function errPushC(ctx, keyword, sp, pathExpr, paramsCode, msgCode, valueExpr, le
   // the definition and the reference's own comes in as `_sp`.
   const rel = sp.startsWith(SP_PLACEHOLDER)
   ctx.closureVals.push(errorSite(keyword, unescapeSp(rel ? sp.slice(SP_PLACEHOLDER.length) : sp), paramsVal, fmt))
-  return `(_e||(_e=[])).push(_mk(${siteVar},${pathExpr || '""'},${paramsShared || paramsCode},${msgCode},${valueExpr},d${rel ? ',_sp' : ''}))`
+  return `(_e=_ap(_e,_mk(${siteVar},${pathExpr || '""'},${paramsShared || paramsCode},${msgCode},${valueExpr},d${rel ? ',_sp' : ''})))`
 }
 
 function compileToJSCombined(schema, VALID_RESULT, schemaMap, userFormats, opts) {
@@ -6110,7 +6118,11 @@ function compileToJSCombined(schema, VALID_RESULT, schemaMap, userFormats, opts)
   if (needsBaseTracking(schema, schemaMap, new Set())) return null
 
   // runtimeShape: errors without the ordinal, see compileToJSCodegenWithErrors.
-  const ctx = { noOrdinal: !!(opts && opts.runtimeShape), rich: !!(opts && opts.rich), inCombined: true, hoisted: [], rootC: schema, varCounter: 0, helperCode: [], shared: [], closureVars: ['_cpLen'], closureVals: [_cpLen],
+  // `_ap` adds an error to a list that may not exist yet: the first one
+  // creates it as a one-element literal. Pushing onto an empty `[]` grew its
+  // backing store on every rejection, about 7% of reading errors across the
+  // official suite.
+  const ctx = { noOrdinal: !!(opts && opts.runtimeShape), rich: !!(opts && opts.rich), inCombined: true, hoisted: [], rootC: schema, varCounter: 0, helperCode: ['function _ap(e,x){if(e===undefined)return[x];e.push(x);return e}'], shared: [], closureVars: ['_cpLen'], closureVals: [_cpLen],
                 rootDefs: cRootDefs, refStack: new Set(), schemaMap: schemaMap || null, anchors: cAnchors, rootSchema: inputSchema, userFormats: userFormats || null }
   const lines = []
   try {
@@ -6273,6 +6285,14 @@ function emitDefFnC(key, target, cyclic, v, pathExpr, lines, ctx, schemaPrefix)
     ctx.defFnsC.set(key, fnName)
     const outerHoisted = ctx.hoisted
     ctx.hoisted = []
+    // The body is a function of its own: a reference the caller was in the
+    // middle of expanding is not on the stack inside it, where reaching it
+    // again is a call (this function, or another one) rather than a loop.
+    // With the caller's stack, a definition expanded once on the way into
+    // the root's function was taken for a cycle inside it, and the schema
+    // (a tree whose nodes hold trees) lost its one-pass function.
+    const outerRefs = ctx.refStack
+    ctx.refStack = new Set()
     const bodyLines = []
     let hoisted
     try {
@@ -6280,6 +6300,7 @@ function emitDefFnC(key, target, cyclic, v, pathExpr, lines, ctx, schemaPrefix)
     } finally {
       hoisted = ctx.hoisted
       ctx.hoisted = outerHoisted
+      ctx.refStack = outerRefs
     }
     let body = bodyLines.join('\n  ')
     body = body.split(`'${SP_PLACEHOLDER}`).join(`_sp+'`).split(`"${SP_PLACEHOLDER}`).join(`_sp+"`)
@@ -6438,12 +6459,12 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
         const lit = {keyword, instancePath: pathVal, schemaPath: spVal, params: Object.freeze(paramsVal), message: msgVal}
         if (o !== null) lit._o = o
         ctx.closureVals.push(sharedErr(lit, ctx.rootSchema))
-        return `(_e||(_e=[])).push(${errVar})`
+        return `(_e=_ap(_e,${errVar}))`
         }
       }
     }
     // Dynamic path (e.g., array index): inline as before
-    return `(_e||(_e=[])).push({keyword:'${keyword}',instancePath:${pathExpr||'""'},schemaPath:'${sp}',params:${paramsCode},message:${msgCode}${ordinalField(ctx, sp)}})`
+    return `(_e=_ap(_e,{keyword:'${keyword}',instancePath:${pathExpr||'""'},schemaPath:'${sp}',params:${paramsCode},message:${msgCode}${ordinalField(ctx, sp)}}))`
   }
 
   // enum and const apply to a value of any type, so a value that fails
@@ -6533,7 +6554,7 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
         const pathVal = pathExpr ? literalValue(pathExpr) : ''
         ctx.closureVars.push(errVar)
         ctx.closureVals.push(sharedErr({keyword: 'required', instancePath: pathVal, schemaPath: unescapeSp(`${schemaPrefix}/required`), params: Object.freeze({missingProperty: key}), message: `must have required property '${key}'`}, ctx.rootSchema))
-        lines.push(`if(${check}){(_e||(_e=[])).push(${errVar})}`)
+        lines.push(`if(${check}){(_e=_ap(_e,${errVar}))}`)
       } else {
         lines.push(`if(${check}){${errPushC(ctx, 'required', `${schemaPrefix}/required`, pathExpr, `{missingProperty:'${esc(key)}'}`, `"must have required property '${esc(key)}'"`, v, `{keyword:'required',instancePath:${pathExpr||'""'},schemaPath:'${schemaPrefix}/required'${ordinalField(ctx, `${schemaPrefix}/required`)},params:{missingProperty:'${esc(key)}'},message:"must have required property '${esc(key)}'"}`)}}`)
       }
@@ -6547,7 +6568,7 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
         const pathVal = pathExpr ? literalValue(pathExpr) : ''
         ctx.closureVars.push(errVar)
         ctx.closureVals.push(sharedErr({keyword: 'required', instancePath: pathVal, schemaPath: unescapeSp(`${schemaPrefix}/required`), params: Object.freeze({missingProperty: key}), message: `must have required property '${key}'`}, ctx.rootSchema))
-        lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&!${ownKeyExpr(ctx, v, key)}){(_e||(_e=[])).push(${errVar})}`)
+        lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&!${ownKeyExpr(ctx, v, key)}){(_e=_ap(_e,${errVar}))}`)
       } else {
         lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&!${ownKeyExpr(ctx, v, key)}){${errPushC(ctx, 'required', `${schemaPrefix}/required`, pathExpr, `{missingProperty:'${esc(key)}'}`, `"must have required property '${esc(key)}'"`, v, `{keyword:'required',instancePath:${pathExpr||'""'},schemaPath:'${schemaPrefix}/required'${ordinalField(ctx, `${schemaPrefix}/required`)},params:{missingProperty:'${esc(key)}'},message:"must have required property '${esc(key)}'"}`)}}`)
       }
@@ -6699,7 +6720,7 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
           const pathVal = pathExpr ? literalValue(pathExpr) : ''
           ctx.closureVars.push(errVar)
           ctx.closureVals.push(sharedErr({keyword: 'required', instancePath: pathVal, schemaPath: unescapeSp(`${schemaPrefix}/dependentRequired`), params: Object.freeze({missingProperty: dep}), message: `must have required property '${dep}'`}, ctx.rootSchema))
-          lines.push(`if(typeof ${v}==='object'&&${v}!==null&&${ownKeyExpr(ctx, v, key)}&&!${ownKeyExpr(ctx, v, dep)}){(_e||(_e=[])).push(${errVar})}`)
+          lines.push(`if(typeof ${v}==='object'&&${v}!==null&&${ownKeyExpr(ctx, v, key)}&&!${ownKeyExpr(ctx, v, dep)}){(_e=_ap(_e,${errVar}))}`)
         } else {
           lines.push(`if(typeof ${v}==='object'&&${v}!==null&&${ownKeyExpr(ctx, v, key)}&&!${ownKeyExpr(ctx, v, dep)}){${errPushC(ctx, 'required', `${schemaPrefix}/dependentRequired`, pathExpr, `{missingProperty:'${esc(dep)}'}`, `"must have required property '${esc(dep)}'"`, v, `{keyword:'required',instancePath:${pathExpr||'""'},schemaPath:'${schemaPrefix}/dependentRequired'${ordinalField(ctx, `${schemaPrefix}/dependentRequired`)},params:{missingProperty:'${esc(dep)}'},message:"must have required property '${esc(dep)}'"}`)}}`)
         }

package/lib/plan-compiler.js

@@ -52,12 +52,16 @@ const branchTitle = (n) => (n && n.schema && typeof n.schema.title === 'string'
 
 function install(deps) {
   const { Plan, NOERRORS, err, evalLeaf, evalLeafV, runCustomV, dataBits, escapePointer,
-          deepEqual, multipleOfOk, cpAtLeast, cpAtMost,
+          deepEqual, enumMember, allDistinct, multipleOfOk, cpAtLeast, cpAtMost,
           T_STRING, T_ARRAY, T_OBJECT, resolveRef, splitFragment, resolveUri } = deps;
 
   const TRUE_FN = () => true;
-  const TRUE_PAIR = { v: TRUE_FN, c: TRUE_FN };
+  // `leaf`: the node compiled no subschema of its own (see compileNode). A
+  // collecting caller asks a leaf for its verdict first and builds the paths
+  // for its errors only when it fails.
+  const TRUE_PAIR = { v: TRUE_FN, c: TRUE_FN, leaf: true };
   const FALSE_PAIR = {
+    leaf: true,
     v: () => false,
     c: (data, errors, instancePath, schemaPath) => {
       if (errors !== NOERRORS) errors.push(err('false schema', 'not', instancePath, schemaPath, {}, 'boolean schema is false'));
@@ -164,12 +168,8 @@ function install(deps) {
       checks.push((data, bits) => (bits & mask) !== 0);
     }
     if (P.enum !== null) {
-      const vals = P.enum;
-      if (vals.length === 0) checks.push(() => false);
-      else checks.push((data) => {
-        for (let i = 0; i < vals.length; i++) if (deepEqual(vals[i], data)) return true;
-        return false;
-      });
+      if (P.enum.length === 0) checks.push(() => false);
+      else checks.push((data) => enumMember(P, data));
     }
     if (P.hasConst) {
       const c = P.const;
@@ -205,14 +205,7 @@ function install(deps) {
       const arrs = [];
       if (P.minItems !== undefined) { const m = P.minItems; arrs.push((d) => d.length >= m); }
       if (P.maxItems !== undefined) { const m = P.maxItems; arrs.push((d) => d.length <= m); }
-      if (P.uniqueItems) {
-        arrs.push((d) => {
-          for (let i = 0; i < d.length; i++) {
-            for (let j = i + 1; j < d.length; j++) if (deepEqual(d[i], d[j])) return false;
-          }
-          return true;
-        });
-      }
+      if (P.uniqueItems) arrs.push(allDistinct);
       const run = combineValue(arrs);
       if (run !== null) { needsBits = true; checks.push((data, bits) => bits !== T_ARRAY || run(data)); }
     }
@@ -300,6 +293,7 @@ function install(deps) {
     const box = { v: null, c: null };
     const pair = {
       open: true,
+      leaf: false,
       v: (d, st, rec) => box.v(d, st, rec),
       c: (d, e, ip, sp, st, rec) => box.c(d, e, ip, sp, st, rec),
     };
@@ -308,8 +302,11 @@ function install(deps) {
     // In-place children collect when this node does; child applicators
     // never do. `rec` is threaded as the trailing argument of every step
     // and is undefined on non-collecting nodes, where nothing reads it.
-    const inPlace = (n, b) => compileNode(ctx, n, b, chain, collect);
-    const child = (n) => compileNode(ctx, n, base, chain, false);
+    // Whether this node compiles any subschema: a node that does not is a
+    // leaf, whose verdict is a few comparisons.
+    let nested = false;
+    const inPlace = (n, b) => { nested = true; return compileNode(ctx, n, b, chain, collect); };
+    const child = (n) => { nested = true; return compileNode(ctx, n, base, chain, false); };
 
     const steps = [];   // collect variant: (data, errors, ip, sp, stack, rec)
     const vsteps = [];  // verdict variant: (data, stack, rec)
@@ -399,7 +396,7 @@ function install(deps) {
         let ok = true;
         const n = Math.min(fns.length, data.length);
         for (let i = 0; i < n; i++) {
-          if (!fns[i].c(data[i], errors, instancePath + '/' + i, schemaPath + '/prefixItems/' + i, stack)) {
+          if (!((fns[i].leaf && fns[i].v(data[i], stack)) || fns[i].c(data[i], errors, instancePath + '/' + i, schemaPath + '/prefixItems/' + i, stack))) {
             ok = false;
             if (errors === NOERRORS) return false;
           }
@@ -422,7 +419,7 @@ function install(deps) {
         if (dataBits(data) !== T_ARRAY) return true;
         let ok = true;
         for (let i = start; i < data.length; i++) {
-          if (!fn.c(data[i], errors, instancePath + '/' + i, schemaPath + '/items', stack)) {
+          if (!((fn.leaf && fn.v(data[i], stack)) || fn.c(data[i], errors, instancePath + '/' + i, schemaPath + '/items', stack))) {
             ok = false;
             if (errors === NOERRORS) return false;
           }
@@ -536,7 +533,7 @@ function install(deps) {
           let evaluated = false;
           const prop = lookup !== null ? lookup(key) : undefined;
           if (prop !== undefined) {
-            if (!prop.fn.c(data[key], errors, instancePath + prop.seg, schemaPath + prop.schemaSeg, stack)) {
+            if (!((prop.fn.leaf && prop.fn.v(data[key], stack)) || prop.fn.c(data[key], errors, instancePath + prop.seg, schemaPath + prop.schemaSeg, stack))) {
               ok = false;
               if (errors === NOERRORS) return false;
             }
@@ -546,7 +543,7 @@ function install(deps) {
             for (let pi = 0; pi < patterns.length; pi++) {
               const pp = patterns[pi];
               if (pp.re.test(key)) {
-                if (!pp.fn.c(data[key], errors, instancePath + '/' + escapePointer(key), schemaPath + '/patternProperties/' + escapePointer(pp.src), stack)) {
+                if (!((pp.fn.leaf && pp.fn.v(data[key], stack)) || pp.fn.c(data[key], errors, instancePath + '/' + escapePointer(key), schemaPath + '/patternProperties/' + escapePointer(pp.src), stack))) {
                   ok = false;
                   if (errors === NOERRORS) return false;
                 }
@@ -559,7 +556,7 @@ function install(deps) {
               ok = false;
               if (errors === NOERRORS) return false;
               errors.push(err('additionalProperties', 'additionalProperties', instancePath, schemaPath + '/additionalProperties', { additionalProperty: key }, 'must NOT have additional properties'));
-            } else if (!apFn.c(data[key], errors, instancePath + '/' + escapePointer(key), schemaPath + '/additionalProperties', stack)) {
+            } else if (!((apFn.leaf && apFn.v(data[key], stack)) || apFn.c(data[key], errors, instancePath + '/' + escapePointer(key), schemaPath + '/additionalProperties', stack))) {
               ok = false;
               if (errors === NOERRORS) return false;
             }
@@ -927,7 +924,7 @@ function install(deps) {
         for (let k = 0; k < keys.length; k++) {
           const key = keys[k];
           if (hasProp(rec, key)) continue;
-          if (!fn.c(data[key], errors, instancePath + '/' + escapePointer(key), schemaPath + '/unevaluatedProperties', stack)) {
+          if (!((fn.leaf && fn.v(data[key], stack)) || fn.c(data[key], errors, instancePath + '/' + escapePointer(key), schemaPath + '/unevaluatedProperties', stack))) {
             ok = false;
             if (errors === NOERRORS) return false;
           }
@@ -983,7 +980,7 @@ function install(deps) {
         let ok = true;
         for (let i = 0; i < data.length; i++) {
           if (hasItem(rec, i)) continue;
-          if (!fn.c(data[i], errors, instancePath + '/' + i, schemaPath + '/unevaluatedItems', stack)) {
+          if (!((fn.leaf && fn.v(data[i], stack)) || fn.c(data[i], errors, instancePath + '/' + i, schemaPath + '/unevaluatedItems', stack))) {
             ok = false;
             if (errors === NOERRORS) return false;
           }
@@ -1068,6 +1065,7 @@ function install(deps) {
     box.v = vfn;
     pair.c = cfn;
     pair.v = vfn;
+    pair.leaf = !nested;
     pair.open = false;
     return pair;
   }

package/lib/unique-items.js

@@ -0,0 +1,139 @@
+'use strict';
+
+// uniqueItems for every engine. These are real functions: the interpreted
+// engine calls them, and the code generator emits their source text
+// (`String(fn)`) into the function it builds, so both run the same code.
+// They read only each other, `_deq` and `_uqpI`, which the generator emits
+// beside them.
+//
+// Short arrays compare pairwise and allocate nothing. Longer arrays of
+// primitives key a Set or Map by the value itself. Longer arrays that hold an
+// object key a Map by a numeric structural hash, and only items whose hashes
+// collide are compared with `_deq`. Equal values always hash alike: numbers
+// by value (so 1 and 1.0, 0 and -0 agree), strings by their characters,
+// arrays by position, and objects by the sum of their own key-value hashes,
+// whatever the key order. The hash replaced a sorted-key canonical string
+// built for every item on every call, which was over a quarter of the time a
+// generated verdict spent on SchemaStore's sample documents.
+
+// JSON equality, the same function the generator hoists as DEQ_HELPER.
+function _deq(a, b) {
+  if (a === b) return true;
+  if (a === null || b === null || typeof a !== 'object' || typeof b !== 'object') return false;
+  var aa = Array.isArray(a);
+  if (aa !== Array.isArray(b)) return false;
+  var i;
+  if (aa) {
+    if (a.length !== b.length) return false;
+    for (i = 0; i < a.length; i++) if (!_deq(a[i], b[i])) return false;
+    return true;
+  }
+  var ka = Object.keys(a);
+  if (ka.length !== Object.keys(b).length) return false;
+  for (i = 0; i < ka.length; i++) {
+    var k = ka[i];
+    if (!Object.prototype.hasOwnProperty.call(b, k) || !_deq(a[k], b[k])) return false;
+  }
+  return true;
+}
+
+function _uqh(x) {
+  if (x === null) return 1;
+  var t = typeof x, h, i;
+  if (t === 'boolean') return x ? 2 : 3;
+  if (t === 'number') {
+    if (x === 0) return 4;
+    h = x | 0;
+    return Math.imul(h ^ (((x - h) * 1e9) | 0), 0x9e3779b1) ^ 5;
+  }
+  if (t === 'string') {
+    h = 0x811c9dc5 ^ x.length;
+    for (i = 0; i < x.length; i++) h = Math.imul(h ^ x.charCodeAt(i), 16777619);
+    return h;
+  }
+  if (t !== 'object') return 6;
+  if (Array.isArray(x)) {
+    h = 0x2545f491 ^ x.length;
+    for (i = 0; i < x.length; i++) h = Math.imul(h ^ _uqh(x[i]), 16777619);
+    return h;
+  }
+  var ks = Object.keys(x);
+  h = 0x6c8e9cf5 ^ ks.length;
+  for (i = 0; i < ks.length; i++) h = (h + Math.imul(_uqh(ks[i]) ^ Math.imul(_uqh(x[ks[i]]), 0x5bd1e995), 0x27d4eb2d)) | 0;
+  return h;
+}
+
+// Whether every item is distinct.
+function _uq(a) {
+  var n = a.length, i, k;
+  if (n < 2) return true;
+  if (n <= 12) {
+    for (i = 1; i < n; i++) for (k = 0; k < i; k++) if (_deq(a[i], a[k])) return false;
+    return true;
+  }
+  var prim = true;
+  for (i = 0; i < n; i++) { var x = a[i]; if (x !== null && typeof x === 'object') { prim = false; break; } }
+  if (prim) {
+    var s = new Set();
+    for (i = 0; i < n; i++) { if (s.has(a[i])) return false; s.add(a[i]); }
+    return true;
+  }
+  var m = new Map();
+  for (i = 0; i < n; i++) {
+    var hh = _uqh(a[i]), b = m.get(hh);
+    if (b === undefined) m.set(hh, i);
+    else if (typeof b === 'number') { if (_deq(a[b], a[i])) return false; m.set(hh, [b, i]); }
+    else { for (k = 0; k < b.length; k++) if (_deq(a[b[k]], a[i])) return false; b.push(i); }
+  }
+  return true;
+}
+
+// The duplicate pair an error reports: the first item that has a later
+// equal, and its first later equal. Returns that later index and leaves the
+// first in _uqpI, or returns -1 when every item is distinct.
+var _uqpI = 0;
+function _uqp(a) {
+  var n = a.length, i, k;
+  if (n < 2) return -1;
+  if (n <= 12) {
+    for (i = 0; i < n - 1; i++) for (k = i + 1; k < n; k++) if (_deq(a[i], a[k])) { _uqpI = i; return k; }
+    return -1;
+  }
+  var prim = true;
+  for (i = 0; i < n; i++) { var x = a[i]; if (x !== null && typeof x === 'object') { prim = false; break; } }
+  var bi = -1, bj = -1, m = new Map();
+  if (prim) {
+    for (i = 0; i < n; i++) {
+      var p = m.get(a[i]);
+      if (p === undefined) m.set(a[i], i);
+      else if (p >= 0) { if (bi < 0 || p < bi) { bi = p; bj = i; } m.set(a[i], -1); }
+    }
+  } else {
+    // Each bucket holds the first occurrence of every distinct value that
+    // hashed there, in index order; a value is paired with its first later
+    // equal only once.
+    var paired = null;
+    for (i = 0; i < n; i++) {
+      var hh = _uqh(a[i]), b = m.get(hh), r = -1;
+      if (b === undefined) { m.set(hh, i); continue; }
+      if (typeof b === 'number') { if (_deq(a[b], a[i])) r = b; else m.set(hh, [b, i]); }
+      else { for (k = 0; k < b.length; k++) if (_deq(a[b[k]], a[i])) { r = b[k]; break; } if (r < 0) b.push(i); }
+      if (r >= 0) {
+        if (paired === null) paired = new Set();
+        if (!paired.has(r)) { paired.add(r); if (bi < 0 || r < bi) { bi = r; bj = i; } }
+      }
+    }
+  }
+  if (bi < 0) return -1;
+  _uqpI = bi;
+  return bj;
+}
+
+// For the interpreted engine.
+function allDistinct(a) { return _uq(a); }
+function duplicatePair(a) {
+  var j = _uqp(a);
+  return j < 0 ? null : [_uqpI, j];
+}
+
+module.exports = { allDistinct, duplicatePair, _deq, _uqh, _uq, _uqp };

package/lib/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "1.44.0",
+  "version": "1.45.0",
   "description": "JSON Schema validator that compiles to plain JavaScript, still runs where code generation is blocked, and can be compiled away at build time. Passes the full official test suite.",
   "main": "index.js",
   "module": "index.mjs",
@@ -64,7 +64,7 @@
     "release:check": "node tests/test_pack_purity.js && node scripts/check-doc-coverage.js && node tests/test_error_codes_lock.js && node tests/test_safe_regex_embed.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_number_text_parity.js && node tests/test_text_path_errors.js && node tests/test_compiled_parity.js && node tests/test_compiled_extension_parity.js && node tests/test_buffer_gate.js && node tests/test_scanner_differential.js && node tests/test_validate_json_scanner_cost.js && node tests/test_buffer_reject_cost.js && node tests/test_nan_verdict.js && node tests/test_remove_additional_nested.js && node tests/test_exclusive_bounds.js && node tests/test_engine_differential.js && node tests/test_error_shape_differential.js && node tests/test_error_list_differential.js && node tests/test_output_format.js && node tests/test_standard_json_schema.js && node tests/test_retry_message.js && node tests/test_describe_schema.js && node tests/test_aot_parse.js && node tests/test_draft7_semantics.js && node tests/test_metaschema_ref.js && node tests/test_pure_js_unsupported.js && node tests/test_native_load_order.js && node tests/test_pack_purity.js && node tests/test_make_native_package.js && node tests/test_browser.js && node tests/test_browser_nofs.js && node tests/test_browser_imports_guard.js && node tests/test_esm_exports.js && node tests/test_version_sync.js && node tests/test_native_loaded.js && node tests/test_native_lazy.js && node tests/test_buffer_apis_without_native.js && node tests/test_cold_start_modules.js && node tests/test_safe_regex_embed.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_regex_ecma_whitespace.js && node tests/test_regex_native_linear.js && node tests/test_aot_build.js && node tests/test_aot_differential.js && node tests/test_aot_cli_build.js && node tests/test_aot_cli_smoke.js && node tests/test_bundle_standalone.js && node tests/test_standalone_anyof.js && node tests/test_standalone_formats.js && node tests/test_aot_format_mode.js && node tests/test_aot_additional_props_errors.js && node tests/test_id_anchor_refs.js && node tests/test_engine_routing.js && node tests/test_engine_option.js && node tests/test_compile_cache_order.js && node tests/test_engine_diagnostic.js && node tests/test_format_engine_parity.js && node tests/test_error_accumulator_collision.js && node tests/test_uri_helper_parity.js && node tests/test_uri_fast_path.js && node tests/test_extend_verdict.js && node tests/test_ipv4_regex.js && node tests/test_ipv6_fast_path.js && node tests/test_nested_recursion_decline.js && node tests/test_generator_error_content.js && node tests/test_inherited_key_presence.js && node tests/test_proto_accessor.js && node tests/test_hybrid_tier.js && node tests/test_first_rejection_builds_one.js && node tests/test_container_local.js && node tests/test_one_shot_validate.js && node tests/test_fixed_pattern_inline.js && node tests/test_plan_source.js && node tests/test_fused_remove_additional.js && node tests/test_runtime_parse.js && node tests/test_formats_single_pass.js && node tests/test_email_format_cost.js && node tests/test_format_single_error.js && node tests/test_defs_pointer_alias.js && node tests/test_encoded_refs.js && node tests/test_cross_doc_root_ref.js && node tests/test_codegen_entrypoint_agreement.js && node tests/test_schema_code_injection.js && node tests/test_aot_html_safe.js && node tests/test_ref_annotation_siblings.js && node tests/test_gate_wrapped_schemas.js && node tests/test_pattern_message_escape.js && node tests/test_nested_defaults_engines.js && node tests/test_nested_coercion_parity.js && node tests/test_preprocess_cache.js && node tests/test_large_schema_codegen.js && node tests/test_base_uri.js && node tests/test_hoisted_def_recursion.js && node tests/test_alias_definitions.js && node tests/test_property_names_ref.js && node tests/test_hybrid_agreement.js && node tests/test_codegen_edge_shapes.js && node tests/test_deferred_def_scope.js && node tests/test_node_scoped_ctx_flags.js && node tests/test_fast_slot_exhaustion.js && node tests/test_ajv_errors.js && node tests/test_custom_keywords.js && node tests/test_custom_keyword_codegen.js && node tests/test_strict_schema.js && node tests/test_aot_external_checks.js && node tests/test_ajv_parity.js && node tests/test_user_format_error_path.js && node tests/test_unevaluated_error_path.js && node tests/test_unevaluated_error_shape.js && node tests/test_unevaluated_differential.js && node tests/fuzz_differential.js && node tests/test_pattern_properties_errors.js && node tests/test_additional_properties_scaling.js && node tests/test_additional_props_combined_cost.js && node tests/test_no_input_mutation.js && node tests/test_typed_validator_runner.js && node tests/test_define_schema.js && node tests/test_error_codes_lock.js && node tests/test_error_code_lookup.js && node tests/test_error_order.js && node tests/test_error_order_ordinal.js && node tests/test_ref_error_order.js && node tests/test_rejection_shape.js && node tests/test_lazy_normalization.js && node tests/test_value_equality.js && node tests/test_vocabulary.js && node tests/test_schema_scan.js && node tests/test_lazy_errors.js && node tests/test_error_read_paths.js && node tests/test_unique_items_error_pair.js && node tests/test_rich_errors_generated.js && node tests/test_captured_verdict_stub.js && node tests/test_generated_returns_rewrite.js && node tests/test_deep_pointer_refs.js && node tests/test_uneval_props_dynamic.js && node tests/test_one_pass_no_fallback.js && node tests/test_scanner_size_cap.js && node tests/test_scanner_index_keys.js && node tests/test_both_defs_containers.js && node tests/test_uneval_branch_counts.js && node tests/test_branch_verdicts.js && node tests/test_property_names_subschema.js && node tests/test_property_named_ref.js && node tests/test_validate_json_engines_same_errors.js && node tests/test_prototype_property_names.js && node tests/test_proto_name_rename_invariance.js && node tests/test_shared_definitions.js && node tests/test_compile_cache_bound.js && node tests/test_uneval_items_dynamic.js && node tests/test_escaped_property_names.js && node tests/test_ref_siblings_combined.js && node tests/test_unicode_property_patterns.js && node tests/test_cold_twin.js && node tests/test_native_positions.js && node tests/test_validate_json_single_parse.js && node tests/test_single_pass_errors.js && node tests/test_lazy_json_errors.js && node tests/test_lazy_instance.js && node tests/test_cyclic_input.js && node tests/test_native_error_codes.js && node tests/test_verdict_preprocess.js && node tests/test_lite_parity.js && node tests/test_lite_bundle_size.js && node tests/test_defaults_own_keys.js && node tests/test_plan_compiler.js && node tests/test_nullable.js && node tests/test_validate_and_parse.js && node tests/test_validate_data.js && node tests/test_enrich_error.js && node tests/test_enrich_received.js && node tests/test_rich_errors_optout.js && node tests/test_error_messages.js && node tests/test_source_positions.js && node tests/fuzz_positions.js && node tests/test_malformed_json_termination.js && node tests/test_data_positions.js && node tests/test_targeted_positions.js && node tests/test_position_map_cost.js && node tests/test_targeted_positions_cost.js && node tests/test_aot_staleness.js && node tests/test_file_positions.js && node tests/test_aot_positions_cost.js && node tests/test_schema_hash.js && node tests/test_render_shared.js && node tests/test_renderers.js && node tests/test_render_without_process.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_aot_source_frames.js && node tests/test_abort_early.js && node tests/test_branch_collapse.js && node tests/test_suggestions.js && node tests/test_levenshtein_banded.js && node tests/test_cli_validate.js && node tests/test_cli_version.js && node tests/test_collect_evaluated.js && node tests/test_differential_tiers.js && node tests/test_draft7.js && node tests/test_dual_path.js && node tests/test_keywords_codegen.js && node tests/test_ref_cross.js && node tests/test_shape_classifier.js && node tests/test_tier0.js && node benchmark/bench_aot_size.mjs",
+    "test": "node tests/run.js",
     "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",
@@ -143,13 +143,13 @@
     "LICENSE"
   ],
   "optionalDependencies": {
-    "@ata-validator/native-darwin-arm64": "1.44.0",
-    "@ata-validator/native-darwin-x64": "1.44.0",
-    "@ata-validator/native-linux-arm64-gnu": "1.44.0",
-    "@ata-validator/native-linux-arm64-musl": "1.44.0",
-    "@ata-validator/native-linux-x64-gnu": "1.44.0",
-    "@ata-validator/native-linux-x64-musl": "1.44.0",
-    "@ata-validator/native-win32-x64": "1.44.0"
+    "@ata-validator/native-darwin-arm64": "1.45.0",
+    "@ata-validator/native-darwin-x64": "1.45.0",
+    "@ata-validator/native-linux-arm64-gnu": "1.45.0",
+    "@ata-validator/native-linux-arm64-musl": "1.45.0",
+    "@ata-validator/native-linux-x64-gnu": "1.45.0",
+    "@ata-validator/native-linux-x64-musl": "1.45.0",
+    "@ata-validator/native-win32-x64": "1.45.0"
   },
   "peerDependencies": {
     "yaml": "^2.0.0"