ata-validator 1.14.1 → 1.16.0

package/lib/interpreter.js

@@ -249,19 +249,24 @@ function multipleOfOk(d, m) {
 
 const _formats = require('./formats');
 const FORMAT_CHECKS = {
-  email: (s) => { const at = s.indexOf('@'); return at > 0 && at < s.length - 1 && s.indexOf('.', at) > at + 1; },
+  email: _formats.email,
   date: _formats.date,
   'date-time': _formats.dateTime,
   time: _formats.time,
-  duration: (s) => /^P(?:\d+Y)?(?:\d+M)?(?:\d+W)?(?:\d+D)?(?:T(?:\d+H)?(?:\d+M)?(?:\d+(?:\.\d+)?S)?)?$/.test(s) && s !== 'P' && !s.endsWith('T'),
+  duration: _formats.duration,
   uuid: _formats.uuid,
   uri: _formats.uri,
   'uri-reference': _formats.uriReference,
   ipv4: _formats.ipv4,
   ipv6: _formats.ipv6,
   hostname: _formats.hostname,
-  regex: (s) => { try { new RegExp(s, 'u'); return true; } catch { try { new RegExp(s); return true; } catch { return false; } } },
-  'json-pointer': (s) => s === '' || (/^\//.test(s) && !/~(?![01])/.test(s)),
+  regex: (s) => { try { new RegExp(s, 'u'); return true; } catch { return false; } },
+  'json-pointer': _formats.jsonPointer,
+  'relative-json-pointer': _formats.relativeJsonPointer,
+  'uri-template': _formats.uriTemplate,
+  iri: _formats.iri,
+  'iri-reference': _formats.iriReference,
+  'idn-email': _formats.idnEmail,
 };
 
 // ---------- evaluation ----------
@@ -437,12 +442,57 @@ class Plan {
     this.if = schema.if !== undefined ? child(schema.if) : undefined;
     this.then = schema.then !== undefined ? child(schema.then) : undefined;
     this.else = schema.else !== undefined ? child(schema.else) : undefined;
-    this.hasApplicators = this.allOf !== null || this.anyOf !== null || this.oneOf !== null || this.not !== undefined || this.if !== undefined;
+    // Macro keywords: the schema the macro returns is applied in place, the
+    // way the reference validator does it, so its errors carry the keyword's
+    // path and the keyword adds an error of its own when that schema fails.
+    this.macros = null;
+    if (interp.keywords !== null) {
+      for (const key of Object.keys(schema)) {
+        const def = interp.keywords[key];
+        if (def === undefined || def.macro === null) continue;
+        const expanded = def.macro(schema[key], schema);
+        if (expanded === undefined) continue;
+        if (this.macros === null) this.macros = [];
+        this.macros.push({ keyword: key, node: child(expanded) });
+      }
+    }
+    this.hasApplicators = this.allOf !== null || this.anyOf !== null || this.oneOf !== null || this.not !== undefined || this.if !== undefined || this.macros !== null;
 
     this.unevaluatedProperties = schema.unevaluatedProperties !== undefined ? child(schema.unevaluatedProperties) : undefined;
     this.unevaluatedItems = schema.unevaluatedItems !== undefined ? child(schema.unevaluatedItems) : undefined;
     this.hasUnevaluated = this.unevaluatedProperties !== undefined || this.unevaluatedItems !== undefined;
 
+    // Custom keywords present on this node, in schema order. Each op holds
+    // the per-value check, built once here for the compile form, and the
+    // type mask it applies to (T_ANY when the definition names no type).
+    this.custom = null;
+    if (interp.keywords !== null) {
+      for (const key of Object.keys(schema)) {
+        const def = interp.keywords[key];
+        if (def === undefined || def.macro !== null) continue;
+        const value = schema[key];
+        let mask = T_ANY;
+        if (def.types !== null) {
+          mask = 0;
+          for (const t of def.types) mask |= typeBit(t);
+        }
+        let fn;
+        if (def.compile !== null) {
+          fn = def.compile(value, schema);
+          if (typeof fn !== 'function') throw new Error(`keyword "${key}": compile must return a function`);
+        } else {
+          const validate = def.validate;
+          fn = (data) => validate(value, data, schema);
+          // Errors written by the validate function land on the function
+          // itself, which is where the check reads them from below.
+          fn.source = validate;
+        }
+        if (this.custom === null) this.custom = [];
+        this.custom.push({ keyword: key, fn, mask });
+      }
+    }
+    this.hasCustom = this.custom !== null;
+
     // Resource bookkeeping, read once instead of two Map lookups per visit.
     const nodeBase = interp.state.nodeBase.get(schema);
     this.nodeBase = nodeBase !== undefined ? nodeBase : null;
@@ -514,9 +564,60 @@ function evalLeafV(P, data) {
       }
     }
   }
+  if (P.hasCustom && !runCustomV(P, data, bits)) return false;
+  return true;
+}
+
+// Custom keyword checks for one node. The verdict variant stops at the first
+// failing keyword; the collecting variant runs them all and reports each,
+// taking the error objects the keyword's function left on itself when it
+// wrote any (`fn.errors`, the same convention as the default validator's
+// custom keywords) and a fixed message otherwise.
+function runCustomV(P, data, bits) {
+  const ops = P.custom;
+  for (let i = 0; i < ops.length; i++) {
+    const op = ops[i];
+    if ((bits & op.mask) === 0) continue;
+    const fn = op.fn;
+    const ok = fn(data);
+    const holder = fn.source || fn;
+    if (holder.errors) holder.errors = null;
+    if (!ok) return false;
+  }
   return true;
 }
 
+function runCustom(P, data, bits, errors, instancePath, schemaPath) {
+  const ops = P.custom;
+  let valid = true;
+  for (let i = 0; i < ops.length; i++) {
+    const op = ops[i];
+    if ((bits & op.mask) === 0) continue;
+    const fn = op.fn;
+    const ok = fn(data);
+    const holder = fn.source || fn;
+    const own = holder.errors;
+    if (own) holder.errors = null;
+    if (ok) continue;
+    valid = false;
+    if (errors === NOERRORS) return false;
+    const kwPath = schemaPath + '/' + op.keyword;
+    if (Array.isArray(own) && own.length > 0) {
+      for (let j = 0; j < own.length; j++) {
+        const e = own[j];
+        errors.push(err(op.keyword, e.keyword || op.keyword,
+          e.instancePath !== undefined ? instancePath + e.instancePath : instancePath,
+          e.schemaPath !== undefined ? e.schemaPath : kwPath,
+          e.params !== undefined ? e.params : {},
+          e.message !== undefined ? e.message : `must pass "${op.keyword}" keyword validation`));
+      }
+    } else {
+      errors.push(err(op.keyword, op.keyword, instancePath, kwPath, { keyword: op.keyword }, `must pass "${op.keyword}" keyword validation`));
+    }
+  }
+  return valid;
+}
+
 // Value-level checks only; the caller guarantees P.leaf. The bodies mirror
 // the corresponding sections of eval() exactly, minus the prologue.
 function evalLeaf(P, data, errors, instancePath, schemaPath) {
@@ -588,6 +689,7 @@ function evalLeaf(P, data, errors, instancePath, schemaPath) {
       }
     }
   }
+  if (P.hasCustom && !runCustom(P, data, bits, errors, instancePath, schemaPath)) valid = false;
   return valid;
 }
 
@@ -597,6 +699,8 @@ class Interpreter {
     this.root = rootSchema;
     this.state = indexSchemas(rootSchema, opts.schemaMap);
     this.userFormats = opts.formats || null;
+    // Custom keywords, already normalized by lib/keywords.js.
+    this.keywords = opts.keywords || null;
     // 2020-12 requires bookending for `$dynamicRef`; v1 removes the
     // requirement. See the `$dynamicRef` branch in eval().
     this.bookending = !opts.v1;
@@ -980,6 +1084,17 @@ class Interpreter {
           else if (collect) mergeAnnotations(local, sub);
         }
       }
+      if (P.macros !== null) {
+        for (let i = 0; i < P.macros.length; i++) {
+          const m = P.macros[i];
+          const sp = schemaPath + '/' + m.keyword;
+          const sub = collect ? { props: null, items: null } : DISCARD;
+          if (!this.eval(m.node, data, base, dynScope, errors, instancePath, sp, stack, sub)) {
+            valid = false;
+            if (errors !== NOERRORS) errors.push(err(m.keyword, m.keyword, instancePath, sp, { keyword: m.keyword }, `must pass "${m.keyword}" keyword validation`));
+          } else if (collect) mergeAnnotations(local, sub);
+        }
+      }
       if (P.anyOf !== null) {
         let any = false;
         const scratch = errors === NOERRORS ? NOERRORS : [];
@@ -1082,7 +1197,7 @@ function err(code, keyword, instancePath, schemaPath, params, message) {
 }
 
 const { compileInterpreter } = require('./plan-compiler').install({
-  Plan, NOERRORS, err, evalLeaf, evalLeafV, dataBits, escapePointer,
+  Plan, NOERRORS, err, evalLeaf, evalLeafV, runCustomV, dataBits, escapePointer,
   deepEqual, multipleOfOk, cpAtLeast, cpAtMost,
   T_STRING, T_ARRAY, T_OBJECT, resolveRef, splitFragment, resolveUri,
 });

package/lib/js-compiler.js

@@ -2024,7 +2024,7 @@ function genCode(schema, v, lines, ctx, knownType) {
   if (schema.format) {
     const fc = FORMAT_CODEGEN[schema.format]
     if (fc) {
-      lines.push(fc(v, isStr))
+      lines.push(fc(v, isStr, ctx))
     } else if (ctx.userFormats && typeof ctx.userFormats[schema.format] === 'function') {
       // User-supplied format checker: thread the function via closure and call at runtime.
       const safeName = schema.format.replace(/[^a-zA-Z0-9_]/g, '_')
@@ -2959,24 +2959,37 @@ function genCode(schema, v, lines, ctx, knownType) {
   }
 }
 
+// Formats whose check is large enough that repeating it at every call site
+// costs more than the call. They are hoisted once per compiled function and
+// invoked by name: one real schema with four email fields grew by 20 KB when
+// the check was inlined at each of them.
+const EMAIL_HELPER = `function _em(_s){${_formats.emailSource('_s', true)}return true}`
+
 const FORMAT_CODEGEN = {
-  email: (v, isStr) => {
-    const guard = isStr ? '' : `typeof ${v}==='string'&&`
-    return isStr
-      ? `{const _at=${v}.indexOf('@');if(_at<=0||_at>=${v}.length-1||${v}.indexOf('.',_at)<=_at+1)return false}`
-      : `if(typeof ${v}==='string'){const _at=${v}.indexOf('@');if(_at<=0||_at>=${v}.length-1||${v}.indexOf('.',_at)<=_at+1)return false}`
+  email: (v, isStr, ctx) => {
+    if (!ctx) return _formats.emailSource(v, isStr)
+    hoistOnce(ctx, '_emHoisted', EMAIL_HELPER)
+    return isStr ? `if(!_em(${v}))return false` : `if(typeof ${v}==='string'&&!_em(${v}))return false`
+  },
+  'json-pointer': _formats.jsonPointerSource,
+  'relative-json-pointer': _formats.relativeJsonPointerSource,
+  'uri-template': _formats.uriTemplateSource,
+  iri: _formats.iriSource,
+  'iri-reference': _formats.iriReferenceSource,
+  'idn-email': _formats.idnEmailSource,
+  regex: (v, isStr) => {
+    const inner = `try{new RegExp(${v},'u')}catch(_er){return false}`
+    return isStr ? `{${inner}}` : `if(typeof ${v}==='string'){${inner}}`
   },
   date: _formats.dateSource,
   uuid: _formats.uuidSource,
   'date-time': _formats.dateTimeSource,
   time: _formats.timeSource,
-  duration: (v, isStr) => isStr
-    ? `if(!/^P(?:\\d+Y)?(?:\\d+M)?(?:\\d+W)?(?:\\d+D)?(?:T(?:\\d+H)?(?:\\d+M)?(?:\\d+(?:\\.\\d+)?S)?)?$/.test(${v})||${v}==='P'||${v}.endsWith('T'))return false`
-    : `if(typeof ${v}==='string'&&(!/^P(?:\\d+Y)?(?:\\d+M)?(?:\\d+W)?(?:\\d+D)?(?:T(?:\\d+H)?(?:\\d+M)?(?:\\d+(?:\\.\\d+)?S)?)?$/.test(${v})||${v}==='P'||${v}.endsWith('T')))return false`,
+  duration: _formats.durationSource,
   uri: _formats.uriSource,
   'uri-reference': (v, isStr) => isStr
-    ? `{${_formats.noReservedSource(v, '0')}}`
-    : `if(typeof ${v}==='string'){${_formats.noReservedSource(v, '0')}}`,
+    ? `{${_formats.uriCharsSource(v, '0')}}`
+    : `if(typeof ${v}==='string'){${_formats.uriCharsSource(v, '0')}}`,
   ipv4: _formats.ipv4Source,
   ipv6: _formats.ipv6Source,
   hostname: _formats.hostnameSource,
@@ -3522,7 +3535,7 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     // let every later statement of the same check push the same error again.
     if (fc) {
       const ri = ctx.varCounter++
-      const fmtCode = fc(v, isStr).replace(/return false/g, `{${failPush};break _fmt${ri}}`)
+      const fmtCode = fc(v, isStr, ctx).replace(/return false/g, `{${failPush};break _fmt${ri}}`)
       lines.push(`_fmt${ri}:{${fmtCode}}`)
     } else if (ctx.userFormats && typeof ctx.userFormats[schema.format] === 'function') {
       // User-supplied format checker on the error path. Same closure plumbing
@@ -4158,7 +4171,7 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
       // Same rule as the error codegen: one violation, one error. The first
       // failing statement pushes and leaves the labeled block.
       const ri = ctx.varCounter++
-      const code = fc(v, isStr).replace(/return false/g, `{${fail('format', 'format', `{format:'${esc(schema.format)}'}`, `'must match format "${esc(schema.format)}"'`)};break _fmt${ri}}`)
+      const code = fc(v, isStr, ctx).replace(/return false/g, `{${fail('format', 'format', `{format:'${esc(schema.format)}'}`, `'must match format "${esc(schema.format)}"'`)};break _fmt${ri}}`)
       lines.push(`_fmt${ri}:{${code}}`)
     } else if (ctx.userFormats && typeof ctx.userFormats[schema.format] === 'function') {
       const safeName = schema.format.replace(/[^a-zA-Z0-9_]/g, '_')

package/lib/keywords.js

@@ -0,0 +1,113 @@
+'use strict';
+
+// Custom keywords for `new Validator(schema, { keywords })`.
+//
+// A definition is one of:
+//   fn                                    shorthand for { validate: fn }
+//   { validate(value, data, parent) }     called per value
+//   { compile(value, parent) -> fn }      called once per schema node, the
+//                                         returned function per value
+//   { macro(value, parent) -> schema }    the returned schema is applied in
+//                                         place, and the keyword reports an
+//                                         error of its own when it fails
+// with optional `type`: a JSON Schema type name or a list of them. A typed
+// keyword is skipped for data of any other type, which is what makes
+// `{ type: 'number', ... }` safe next to `type: ['number', 'string']`.
+//
+// Schemas that use a registered keyword run on the interpreted engine, so
+// every applicator around the custom check keeps its specification meaning.
+// A function cannot be carried into a standalone module, so the ahead-of-time
+// paths refuse these options instead of emitting a module that would ignore
+// the keyword.
+
+const RESERVED = new Set([
+  '$id', '$schema', '$ref', '$defs', '$anchor', '$dynamicRef', '$dynamicAnchor',
+  '$vocabulary', '$comment', 'definitions', 'type', 'enum', 'const',
+  'properties', 'patternProperties', 'additionalProperties', 'required',
+  'items', 'prefixItems', 'additionalItems', 'contains', 'allOf', 'anyOf',
+  'oneOf', 'not', 'if', 'then', 'else', 'format', 'pattern',
+  'unevaluatedProperties', 'unevaluatedItems', 'dependentSchemas',
+  'dependentRequired', 'dependencies', 'propertyNames', 'propertyDependencies',
+  'minimum', 'maximum', 'exclusiveMinimum', 'exclusiveMaximum', 'multipleOf',
+  'minLength', 'maxLength', 'minItems', 'maxItems', 'uniqueItems',
+  'minContains', 'maxContains', 'minProperties', 'maxProperties',
+]);
+
+// Normalize a caller's `{ name: def }` map into `{ name: { types, validate,
+// compile, macro } }`. Throws on a definition that has no way to run, so a
+// keyword that would otherwise be ignored is never accepted quietly.
+function normalizeKeywords(defs) {
+  if (!defs || typeof defs !== 'object') return null;
+  const names = Object.keys(defs);
+  if (names.length === 0) return null;
+  const out = Object.create(null);
+  for (const name of names) {
+    const raw = defs[name];
+    const def = typeof raw === 'function' ? { validate: raw } : raw;
+    if (!def || typeof def !== 'object') {
+      throw new Error(`keyword "${name}": definition must be a function or an object`);
+    }
+    if (RESERVED.has(name)) {
+      throw new Error(`keyword "${name}" is a JSON Schema keyword and cannot be redefined`);
+    }
+    const hasValidate = typeof def.validate === 'function';
+    const hasCompile = typeof def.compile === 'function';
+    const hasMacro = typeof def.macro === 'function';
+    if (!hasValidate && !hasCompile && !hasMacro) {
+      throw new Error(
+        `keyword "${name}": definition needs validate, compile or macro` +
+        (typeof def.code === 'function' ? ' (code-generating keywords are not supported)' : ''),
+      );
+    }
+    let types = null;
+    if (def.type !== undefined) {
+      types = Array.isArray(def.type) ? def.type.slice() : [def.type];
+      for (const t of types) {
+        if (typeof t !== 'string') throw new Error(`keyword "${name}": type must be a string or a list of strings`);
+      }
+    }
+    out[name] = {
+      name,
+      types,
+      validate: hasValidate ? def.validate : null,
+      compile: hasCompile ? def.compile : null,
+      macro: hasMacro ? def.macro : null,
+    };
+  }
+  return out;
+}
+
+// Does the schema, or any subschema of it, use a registered keyword? Walks
+// every object and array so keywords inside applicators and definitions are
+// found too. Property names under `properties` are not keywords, so that map
+// is descended into without reading its keys as keywords.
+function schemaUsesKeywords(schema, keywords) {
+  if (!keywords) return false;
+  const seen = new Set();
+  const walk = (node, keysAreNames) => {
+    if (node === null || typeof node !== 'object') return false;
+    if (seen.has(node)) return false;
+    seen.add(node);
+    if (Array.isArray(node)) {
+      for (const item of node) if (walk(item, false)) return true;
+      return false;
+    }
+    for (const key of Object.keys(node)) {
+      if (!keysAreNames && keywords[key] !== undefined) return true;
+      const v = node[key];
+      if (v !== null && typeof v === 'object') {
+        if (walk(v, !keysAreNames && NAME_MAPS.has(key))) return true;
+      }
+    }
+    return false;
+  };
+  return walk(schema, false);
+}
+
+// Maps whose keys are user-chosen names, not keywords.
+const NAME_MAPS = new Set([
+  'properties', 'patternProperties', '$defs', 'definitions',
+  'dependentSchemas', 'dependentRequired', 'dependencies', 'propertyDependencies',
+]);
+
+module.exports = { normalizeKeywords, schemaUsesKeywords };

package/lib/plan-compiler.js

@@ -46,7 +46,7 @@
 // allocation per child.
 
 function install(deps) {
-  const { Plan, NOERRORS, err, evalLeaf, evalLeafV, dataBits, escapePointer,
+  const { Plan, NOERRORS, err, evalLeaf, evalLeafV, runCustomV, dataBits, escapePointer,
           deepEqual, multipleOfOk, cpAtLeast, cpAtMost,
           T_STRING, T_ARRAY, T_OBJECT, resolveRef, splitFragment, resolveUri } = deps;
 
@@ -229,6 +229,10 @@ function install(deps) {
       if (run !== null) { needsBits = true; checks.push((data, bits) => bits !== T_OBJECT || run(data)); }
     }
 
+    if (P.hasCustom) {
+      needsBits = true;
+      checks.push((data, bits) => runCustomV(P, data, bits));
+    }
     if (checks.length === 0) return TRUE_FN;
     if (!needsBits) {
       if (checks.length === 1) { const a = checks[0]; return (data) => a(data, 0); }
@@ -368,7 +372,7 @@ function install(deps) {
     if (P.hasType || P.enum !== null || P.hasConst || P.hasNumber || P.hasString ||
         P.minItems !== undefined || P.maxItems !== undefined || P.uniqueItems ||
         P.required !== null || P.minProperties !== undefined || P.maxProperties !== undefined ||
-        P.dependentRequired !== null) {
+        P.dependentRequired !== null || P.hasCustom) {
       steps.push((data, errors, instancePath, schemaPath) => evalLeaf(P, data, errors, instancePath, schemaPath));
       vsteps.push(compileLeafV(P));
     }
@@ -679,6 +683,34 @@ function install(deps) {
         return true;
       });
     }
+    if (P.macros !== null) {
+      const ms = P.macros.map((m) => ({ keyword: m.keyword, fn: inPlace(m.node, base) }));
+      steps.push((data, errors, instancePath, schemaPath, stack, rec) => {
+        let ok = true;
+        for (let i = 0; i < ms.length; i++) {
+          const m = ms[i];
+          const sp = schemaPath + '/' + m.keyword;
+          let passed;
+          if (collect) {
+            const pl = pLen(rec), n0 = rec.n, xl = xLen(rec);
+            passed = m.fn.c(data, errors, instancePath, sp, stack, rec);
+            if (!passed) undo(rec, pl, n0, xl);
+          } else {
+            passed = m.fn.c(data, errors, instancePath, sp, stack);
+          }
+          if (!passed) {
+            ok = false;
+            if (errors === NOERRORS) return false;
+            errors.push(err(m.keyword, m.keyword, instancePath, sp, { keyword: m.keyword }, `must pass "${m.keyword}" keyword validation`));
+          }
+        }
+        return ok;
+      });
+      vsteps.push((data, stack, rec) => {
+        for (let i = 0; i < ms.length; i++) if (!ms[i].fn.v(data, stack, rec)) return false;
+        return true;
+      });
+    }
     if (P.anyOf !== null) {
       const fns = P.anyOf.map((v) => inPlace(v, base));
       steps.push((data, errors, instancePath, schemaPath, stack, rec) => {

package/lib/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "1.14.1",
+  "version": "1.16.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_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_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",
     "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.14.1",
-    "@ata-validator/native-darwin-x64": "1.14.1",
-    "@ata-validator/native-linux-x64-gnu": "1.14.1",
-    "@ata-validator/native-linux-arm64-gnu": "1.14.1",
-    "@ata-validator/native-linux-x64-musl": "1.14.1",
-    "@ata-validator/native-linux-arm64-musl": "1.14.1",
-    "@ata-validator/native-win32-x64": "1.14.1"
+    "@ata-validator/native-darwin-arm64": "1.16.0",
+    "@ata-validator/native-darwin-x64": "1.16.0",
+    "@ata-validator/native-linux-arm64-gnu": "1.16.0",
+    "@ata-validator/native-linux-arm64-musl": "1.16.0",
+    "@ata-validator/native-linux-x64-gnu": "1.16.0",
+    "@ata-validator/native-linux-x64-musl": "1.16.0",
+    "@ata-validator/native-win32-x64": "1.16.0"
   },
   "peerDependencies": {
     "yaml": "^2.0.0"
@@ -141,6 +141,8 @@
   "devDependencies": {
     "@sinclair/typebox": "^0.34.49",
     "@types/node": "^25.8.0",
+    "ajv": "^8.20.0",
+    "ajv-formats": "^3.0.1",
     "cmake-js": "^8.0.0",
     "esbuild": "^0.28.0",
     "jsonc-parser": "^3.3.1",