ata-validator 1.8.0 → 1.8.2

package/CHANGELOG.md

@@ -2,6 +2,32 @@
 
 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.8.2 - 2026-08-28
+
+### Fixed
+
+- A `pattern` of the form `^[class]+$`, `^[class]{m,n}$` or `^[class]{n}$` with n above 16 could be violated without `validate()` saying so. The boolean program compiles those patterns to an inline character loop wrapped in an arrow function, and the rewrite that turns the boolean program into the error-reporting one replaced the `return false` and `return true` inside that arrow with `return E(d)` and `return R`. Both are objects, so the arrow started returning a truthy value on mismatch, the enclosing `!(cond && obj)` went false, and the error program accepted what the boolean program had rejected.
+
+  What that looked like from outside depended on the path. Without preprocessing, `validate()` still rejected, because the boolean verdict runs first, but the error it produced was a generic `schema validation failed` with no keyword, no `params.pattern` and no path. With preprocessing, which means any schema carrying a `default` or a validator built with `coerceTypes` or `removeAdditional`, the error program is installed as `validate()` directly and the result was `valid: true`. `Validator.bundleStandalone` and `bundleCompact` embed the same program and had the same silent accept. `ata compile` output is built from the boolean program and was not affected. The rewrite has been wrong since 0.6.0; the official suite never exercised these pattern shapes, so nothing caught it.
+
+  The rewrite now leaves the body of an arrow function alone, the same way it already left `function` bodies alone. `tests/test_hybrid_agreement.js` compares the rewritten program with the boolean it came from on every affected shape, at the root, in a property, in array items, through `bundleStandalone` and through a compiled module, and checks the two preprocessing cases directly. `tests/test_codegen_entrypoint_agreement.js` now compares the rewritten program as a fifth participant across the whole official suite. `tests/test_ajv_errors.js`, which had been failing on exactly this for as long as the bug existed, is now part of `npm test`.
+
+### Changed
+
+- Ranking an error into schema declaration order no longer re-derives the rank on every error of every failing document. It was splitting the schema path with two regular expressions per segment and then scanning `Object.keys(node)` at each level, which was 8.5% of the error path in a profile, for an answer that depends only on the schema and the path. The rank is now cached per path under its root, each node's keys are indexed once, and escape handling is skipped for segments with no tilde. That function drops from 8.5% to 1.4% of the error path, and the error path as a whole gets 3.5% faster, median of eleven interleaved runs. `docs/performance-notes.md` records the larger gap this was measured against; it is not closed by this change.
+
+## 1.8.1 - 2026-08-27
+
+### Changed
+
+- Constructing a validator no longer clones and serializes every schema to find out whether it needed normalizing. It did that on the root and on each registered schema: serialize, deep clone, normalize the clone, serialize again, compare. For a schema with no `nullable` field and no draft-07 keyword the answer is always no, and the work was thrown away. Every question the normalizers ask is whether some key appears anywhere in the tree, so one walk answers all of them, and the clone now happens only for schemas that need it. No registry and ten fields goes from 18.5 to 4.6 µs; fifty registered schemas of fifty fields, which is a small server's worth, from 2570 to 260 µs.
+
+  The walk descends through every object-valued key rather than the subschema keywords the normalizers recurse through, so it is a superset of what they visit: it can report work where there is none, costing one clone, and cannot miss work there is. Across the 2344 schemas in the official suite it reports work on 335 where normalization changes 334. `tests/test_schema_scan.js` asserts that direction over the whole suite, and asserts the check is load-bearing by breaking the scan deliberately and confirming the broken one is caught.
+
+  The answer is remembered against the schema object, the way whole compiled validators already are, and so is the schema map built from a registry. Both were being redone once per validator, so a server building one validator per route over a shared registry paid for that registry once per route. Fifty routes over twenty shared schemas boots in 0.046 ms rather than 20.66 ms. Validators share the map, and anything that writes to one, which is `addSchema()` and the meta-schema registration during compilation, takes a private copy first.
+
+  Nothing about what any schema validates to changes. The comparison that decided the old answer is still there behind the walk, so a schema the walk sends down the slow path gets exactly the result it got before.
+
 ## 1.8.0 - 2026-08-27
 
 ### Added
@@ -24,7 +50,7 @@ All notable changes to ata-validator are documented here. The format follows [Ke
 
 ### Changed
 
-- Rejecting a document through the buffer APIs no longer costs more than accepting one. The On-Demand plan answers first, and a `false` from it used to be ambiguous: it could mean the document failed a constraint, or that the plan could not decide. The caller had to assume the second, so it re-created the padded view, parsed the whole document again into a DOM, tried the generated plan, and then walked the tree. A rejected document was therefore parsed twice and walked up to three times. The plan now reports whether it stopped because the document failed a constraint or because it could not be read, and only the second falls through. simdjson's `INCORRECT_TYPE` is a constraint failure rather than a read failure, which is the distinction that makes this work: a property holding a string where the schema wants an integer surfaces as a read error from `get<int64>`, not as a type mismatch. On a 62 KB array of a thousand objects with one bad element: 316 µs to 11 µs when the bad element is first, 315 µs to 40 µs when it is last, and rejecting is now never dearer than accepting. `tests/test_buffer_path_parity.js` holds the buffer path to the same answers as `validate()` across all 3359 suite cases, and still reports zero disagreements.
+- Rejecting a document through the buffer APIs no longer costs more than accepting one. The On-Demand plan answers first, and a `false` from it used to be ambiguous: it could mean the document failed a constraint, or that the plan could not decide. The caller had to assume the second, so it re-created the padded view, parsed the whole document again into a DOM, tried the generated plan, and then walked the tree. A rejected document was therefore parsed twice and walked up to three times. The plan now reports whether it stopped because the document failed a constraint or because it could not be read, and only the second falls through. simdjson's `INCORRECT_TYPE` is a constraint failure rather than a read failure, which is the distinction that makes this work: a property holding a string where the schema wants an integer surfaces as a read error from `get<int64>`, not as a type mismatch. On a 62 KB array of a thousand objects with one bad element: 316 µs to 11 µs when the bad element is first, 315 µs to 40 µs when it is last. On that shape rejecting is no longer dearer than accepting, and when the bad element is early it is several times cheaper. It is still dearer on a small document, where there is no bulk of parsing for an early exit to save: on a two-field object, 129 ns to accept and 278 ns to reject. `tests/test_buffer_path_parity.js` holds the buffer path to the same answers as `validate()` across all 3359 suite cases, and still reports zero disagreements.
 
 ## 1.7.3 - 2026-08-26
 

package/index.js

@@ -11,6 +11,7 @@ const {
 } = require("./lib/js-compiler");
 const { normalizeDraft7, normalizeNullable, stripFormatAssertions } = require("./lib/draft7");
 const { enabledKeywords, stripDisabledKeywords } = require("./lib/vocabularies");
+const { needsNormalization } = require("./lib/schema-scan");
 const { isV1Dialect } = require("./lib/dialect");
 const { classify } = require("./lib/shape-classifier");
 const { buildTier0Plan, tier0Validate } = require("./lib/tier0");
@@ -372,12 +373,64 @@ function resolveSchemaByPath(rootSchema, schemaPath) {
 // order AJV emits and what schema authors read top to bottom. Segments that
 // cannot be resolved (cross-schema refs, normalized keys) end the walk; the
 // stable sort then keeps such errors in engine emission order.
+// The rank of a `schemaPath` under a given root is fixed: the schema does not
+// change between validations, so neither does the answer. It was recomputed for
+// every error of every failing document, and computing it is not cheap. Two
+// caches, both keyed on things that do not change:
+//
+//   rootSchema -> schemaPath -> rank, so a path is walked once ever
+//   node       -> key -> its index, so the walk stops calling Object.keys and
+//                        scanning the result for a string
+//
+// 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;
-  const parts = schemaPath.slice(1).split('/').filter(Boolean).map((s) => s.replace(/~1/g, '/').replace(/~0/g, '~'));
+  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;
-  for (const seg of parts) {
+  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);
@@ -385,7 +438,7 @@ function schemaOrderRank(rootSchema, schemaPath) {
       rank.push(idx);
       node = node[idx];
     } else {
-      const idx = Object.keys(node).indexOf(seg);
+      const idx = keyIndex(node, seg);
       if (idx < 0) break;
       rank.push(idx);
       node = node[seg];
@@ -460,11 +513,20 @@ function _normalizeCallerSchema(s, inheritDraft7) {
   const needsDraft7 = declares
     ? (s.$schema === 'http://json-schema.org/draft-07/schema#' || s.$schema === 'http://json-schema.org/draft-07/schema')
     : !!inheritDraft7
+  // One walk answers whether there is anything to do. Almost always there is
+  // not, and then the serialize, clone, normalize, serialize, compare below is
+  // work spent to find that out. The walk over-reports rather than under, so a
+  // schema it clears is one no normalizer would have touched;
+  // `tests/test_schema_scan.js` holds that direction against the whole suite.
+  if (!needsNormalization(s, needsDraft7)) return s
+
   const str = JSON.stringify(s)
   const copy = _deepCloneWithSymbols(s)
   if (needsDraft7) normalizeDraft7(copy, true)
   normalizeNullable(copy)
   // Return original when normalization produced no change, copy otherwise.
+  // Kept even though the walk has already said there is work, so that a walk
+  // which over-reports still returns exactly what it returned before.
   // Change-detection uses JSON content only; symbols do not affect it.
   return JSON.stringify(copy) === str ? s : copy
 }
@@ -488,8 +550,33 @@ function declaredId(original, normalized) {
 
 // `inheritDraft7` is true when the root schema is draft-07: a retrieved
 // document that declares no dialect is read under the root's draft.
+// The map is derived entirely from what the caller passed, so the same
+// `schemas` gives the same map. A server building one validator per route over
+// a shared registry rebuilt it once per route, normalizing and re-reading the
+// `$id` of every registered schema each time. Keyed by the registry object,
+// and by the draft it is read under, since that changes what normalization
+// does to a document which declares no dialect of its own.
+//
+// Validators share the returned map, so anything that mutates one calls
+// `_ownSchemaMap()` first. There are two such places: registering the vendored
+// meta-schemas during compilation, and `addSchema()`.
+const _schemaMapCache = new WeakMap()
+
 function buildSchemaMap(schemas, inheritDraft7) {
   if (!schemas) return null
+  const byDraft = _schemaMapCache.get(schemas)
+  if (byDraft) {
+    const hit = byDraft[inheritDraft7 ? 1 : 0]
+    if (hit) return hit
+  }
+  const map = _buildSchemaMap(schemas, inheritDraft7)
+  const slot = byDraft || [null, null]
+  slot[inheritDraft7 ? 1 : 0] = map
+  if (!byDraft) _schemaMapCache.set(schemas, slot)
+  return map
+}
+
+function _buildSchemaMap(schemas, inheritDraft7) {
   const map = new Map()
   if (Array.isArray(schemas)) {
     for (const s of schemas) {
@@ -648,7 +735,9 @@ class Validator {
     // Built here rather than below because `$vocabulary` is resolved against
     // it, and that resolution waits until compilation so a meta-schema
     // registered by addSchema() still counts.
-    const schemaMap = buildSchemaMap(options.schemas, rootIsDraft7) || new Map();
+    const shared = buildSchemaMap(options.schemas, rootIsDraft7);
+    const schemaMap = shared || new Map();
+    this._schemaMapShared = shared !== null;
     this._schemaIsCallers = schemaObj === schema;
     this._vocabulariesApplied = false;
 
@@ -824,6 +913,7 @@ class Validator {
     // reference pay for the lookup.
     if (this._schemaStr.includes('json-schema.org/draft')) {
       const { METASCHEMAS } = require('./lib/metaschemas');
+      this._ownSchemaMap();
       for (const [id, meta] of METASCHEMAS) {
         const bare = id.replace(/#$/, '');
         for (const key of [id, bare, bare + '#', bare.replace(/^https:/, 'http:'), bare.replace(/^http:/, 'https:')]) {
@@ -1532,9 +1622,18 @@ class Validator {
     const rootIsDraft7 = !!(root && typeof root === 'object' && typeof root.$schema === 'string' &&
       (root.$schema === 'http://json-schema.org/draft-07/schema#' || root.$schema === 'http://json-schema.org/draft-07/schema'))
     const normalized = _normalizeCallerSchema(schema, rootIsDraft7)
+    this._ownSchemaMap()
     this._schemaMap.set(normalized.$id, normalized)
   }
 
+  // buildSchemaMap hands the same map to every validator built from the same
+  // registry. Take a private copy before writing to it.
+  _ownSchemaMap() {
+    if (!this._schemaMapShared) return
+    this._schemaMap = new Map(this._schemaMap)
+    this._schemaMapShared = false
+  }
+
   _ensureCodegen() {
     if (this._jsFn) return;
     this._ensureVocabularies();

package/lib/js-compiler.js

@@ -1492,9 +1492,17 @@ function compileToJSCodegen(schema, schemaMap, userFormats) {
 function replaceTopLevel(code) {
   let fnDepth = 0, result = '', i = 0
   while (i < code.length) {
-    if (code.startsWith('function', i) && (i === 0 || /[^a-zA-Z_$]/.test(code[i - 1]))) {
-      // Found a nested function — skip to opening brace, track all braces inside
-      let j = i + 8
+    // A nested closure keeps its own returns. Both spellings count: a
+    // `function` keyword and an arrow with a block body. The inline pattern
+    // compiler emits `(()=>{...return false...return true})()` and rewriting
+    // those returns turned the arrow's boolean into an object, which made
+    // `!(cond && obj)` false and let the hybrid accept what the boolean
+    // program rejected.
+    const isFunctionKw = code.startsWith('function', i) && (i === 0 || /[^a-zA-Z_$]/.test(code[i - 1]))
+    const isArrowBlock = code.startsWith('=>{', i)
+    if (isFunctionKw || isArrowBlock) {
+      // Skip to the opening brace, then track all braces inside the body.
+      let j = isArrowBlock ? i + 2 : i + 8
       while (j < code.length && code[j] !== '{') j++
       result += code.slice(i, j + 1)
       i = j + 1

package/lib/schema-scan.js

@@ -0,0 +1,115 @@
+'use strict';
+
+// One walk of a schema, answering in a single integer the questions that are
+// currently answered by doing work and looking at the result.
+//
+// `_normalizeCallerSchema` decides whether a schema needs normalizing by
+// serializing it, cloning it, normalizing the clone and serializing again to
+// compare. Two serializations and a deep copy, on every schema, to find out
+// that a modern schema needs nothing. The questions the normalizers actually
+// ask are all of the form "does this key appear anywhere in the tree", and one
+// traversal answers all of them at once. Daniel Lemire's rule from the C++
+// side, a layer up: do not do the work to find out whether the work is needed.
+//
+// The walk deliberately descends through **every** object-valued key, not the
+// list of subschema keywords the normalizers recurse through. That makes it a
+// superset of what they visit, so it can report work where there is none, but
+// never miss work there is. A false positive costs one clone. A false negative
+// would hand an un-normalized schema to the engines, which is the silent
+// acceptance this codebase treats as its worst failure. `tests/test_schema_scan.js`
+// pins the direction of that error against the whole suite.
+
+// One bit per question. Kept small and explicit; a schema which trips none of
+// them scans to 0 and can skip normalization entirely.
+const NULLABLE = 1 << 0;         // `nullable`, which normalizeNullable folds into `type`
+const REF_SIBLINGS = 1 << 1;     // a draft-07 `$ref` carrying keywords which are ignored
+const ANCHOR_ID = 1 << 2;        // a fragment-only `$id`, which is an anchor in draft-07
+const DEFINITIONS = 1 << 3;      // `definitions`, renamed to `$defs`
+const DEPENDENCIES = 1 << 4;     // `dependencies`, split into two keywords
+const TUPLE_ITEMS = 1 << 5;      // array-valued `items`, split into `prefixItems`
+
+// Everything only draft-07 normalization acts on. A schema of another dialect
+// can carry these without them meaning anything, so they are read together
+// with whether the document is draft-07 at all.
+const DRAFT7_WORK = REF_SIBLINGS | ANCHOR_ID | DEFINITIONS | DEPENDENCIES | TUPLE_ITEMS;
+
+// Copied from the normalizer rather than shared, so that a change there which
+// forgets this file shows up as a differential test failure rather than as a
+// silently wider scan. The test asserts the two agree.
+const REF_SIBLINGS_KEPT = new Set([
+  '$ref', '$defs', 'definitions', '$schema', '$comment',
+  'title', 'description', 'examples', 'default', 'readOnly', 'writeOnly',
+]);
+const ANCHOR_ID_RE = /^#[A-Za-z][A-Za-z0-9_.:-]*$/;
+
+// The answer depends only on the object, so it is remembered against it. A
+// server building one validator per route over a shared registry hands the
+// same registry objects to every one of them: fifty routes over twenty shared
+// schemas scanned those twenty a thousand times. Identity caching is what
+// `_identityCache` already does for whole compiled validators.
+//
+// This assumes a schema is not mutated after being handed to a Validator,
+// which is already true of everything else here: the compile cache, the
+// identity cache and the schema map would all be stale too.
+const CACHE = new WeakMap();
+
+function scan(schema) {
+  if (typeof schema !== 'object' || schema === null) return 0;
+  const hit = CACHE.get(schema);
+  if (hit !== undefined) return hit;
+
+  let bits = 0;
+  const seen = new Set();
+
+  const walk = (node) => {
+    if (typeof node !== 'object' || node === null) return;
+    if (Array.isArray(node)) {
+      for (let i = 0; i < node.length; i++) walk(node[i]);
+      return;
+    }
+    if (seen.has(node)) return;
+    seen.add(node);
+
+    if ('nullable' in node) bits |= NULLABLE;
+    if (node.definitions !== undefined && node.$defs === undefined) bits |= DEFINITIONS;
+    if (node.dependencies !== undefined) bits |= DEPENDENCIES;
+    if (Array.isArray(node.items)) bits |= TUPLE_ITEMS;
+    if (typeof node.$id === 'string' && ANCHOR_ID_RE.test(node.$id)) bits |= ANCHOR_ID;
+
+    // `Object.keys` rather than `for...in`: the prototype chain has nothing
+    // to contribute here, and walking it is the slower path in V8.
+    const keys = Object.keys(node);
+    if (typeof node.$ref === 'string') {
+      for (let i = 0; i < keys.length; i++) {
+        if (!REF_SIBLINGS_KEPT.has(keys[i])) { bits |= REF_SIBLINGS; break; }
+      }
+    }
+    // Every key, not just the subschema keywords, so this cannot miss a place
+    // the normalizers would reach.
+    for (let i = 0; i < keys.length; i++) walk(node[keys[i]]);
+  };
+
+  walk(schema);
+  CACHE.set(schema, bits);
+  return bits;
+}
+
+// Would normalization change this schema? `isDraft7` says whether the draft-07
+// rules apply at all, which the caller already knows.
+function needsNormalization(schema, isDraft7) {
+  const bits = scan(schema);
+  if (bits & NULLABLE) return true;
+  return isDraft7 ? (bits & DRAFT7_WORK) !== 0 : false;
+}
+
+module.exports = {
+  scan,
+  needsNormalization,
+  NULLABLE,
+  REF_SIBLINGS,
+  ANCHOR_ID,
+  DEFINITIONS,
+  DEPENDENCIES,
+  TUPLE_ITEMS,
+  DRAFT7_WORK,
+};

package/lib/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "1.8.0",
+  "version": "1.8.2",
   "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",
@@ -44,7 +44,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_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_defs_pointer_alias.js && node tests/test_cross_doc_root_ref.js && node tests/test_codegen_entrypoint_agreement.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_lazy_errors.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_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_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_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_ajv_errors.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_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_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",
@@ -112,13 +112,13 @@
     "LICENSE"
   ],
   "optionalDependencies": {
-    "@ata-validator/native-darwin-arm64": "1.8.0",
-    "@ata-validator/native-darwin-x64": "1.8.0",
-    "@ata-validator/native-linux-x64-gnu": "1.8.0",
-    "@ata-validator/native-linux-arm64-gnu": "1.8.0",
-    "@ata-validator/native-linux-x64-musl": "1.8.0",
-    "@ata-validator/native-linux-arm64-musl": "1.8.0",
-    "@ata-validator/native-win32-x64": "1.8.0"
+    "@ata-validator/native-darwin-arm64": "1.8.2",
+    "@ata-validator/native-darwin-x64": "1.8.2",
+    "@ata-validator/native-linux-x64-gnu": "1.8.2",
+    "@ata-validator/native-linux-arm64-gnu": "1.8.2",
+    "@ata-validator/native-linux-x64-musl": "1.8.2",
+    "@ata-validator/native-linux-arm64-musl": "1.8.2",
+    "@ata-validator/native-win32-x64": "1.8.2"
   },
   "peerDependencies": {
     "yaml": "^2.0.0"