ata-validator 1.30.2 → 1.31.0

package/index.js

@@ -694,17 +694,31 @@ function sortErrorsBySchemaOrder(rootSchema, errors) {
 
 // Paths repeat across rejections of the same shape, so the parsed segment
 // list is cached per path string. Entries are frozen: the same array is
-// handed to every issue that names the path. The cache is bounded so a
-// stream of array indexes cannot grow it without limit.
-const _pathCache = new Map();
-const PATH_CACHE_MAX = 4096;
+// handed to every issue that names the path.
+//
+// The cache is bucketed by length and searched with ===, not keyed in a Map.
+// A path with an array index in it is concatenated afresh by every rejection,
+// and a Map has to hash each such string from scratch before it can look
+// anything up; that hashing was 30% of a Standard Schema rejection with
+// sixteen issues. Comparing against the few paths of the same length costs
+// less. Both levels are bounded so a stream of array indexes cannot grow it
+// without limit: a full bucket stops caching, too many lengths clear it.
+const _pathBuckets = new Map();
+const PATH_BUCKET_MAX = 32;
+const PATH_LENGTHS_MAX = 256;
 function parsePointerPath(path) {
   if (!path) return EMPTY_PATH;
-  const hit = _pathCache.get(path);
-  if (hit !== undefined) return hit;
+  const n = path.length;
+  let bucket = _pathBuckets.get(n);
+  if (bucket !== undefined) {
+    for (let i = 0; i < bucket.length; i += 2) if (bucket[i] === path) return bucket[i + 1];
+  } else {
+    if (_pathBuckets.size >= PATH_LENGTHS_MAX) _pathBuckets.clear();
+    bucket = [];
+    _pathBuckets.set(n, bucket);
+  }
   const segs = Object.freeze(parsePointerPathUncached(path));
-  if (_pathCache.size >= PATH_CACHE_MAX) _pathCache.clear();
-  _pathCache.set(path, segs);
+  if (bucket.length < PATH_BUCKET_MAX * 2) bucket.push(path, segs);
   return segs;
 }
 const EMPTY_PATH = Object.freeze([]);
@@ -1109,6 +1123,11 @@ class Validator {
     this._lastRawInput = null;
     // undefined: not built yet. null: this schema has no scanner.
     this._scanner = undefined;
+    // Checks a wrapper registered through _extendChecks. Declared here so
+    // registering one does not change the instance's shape.
+    this._verdictTail = null;
+    this._validateTail = null;
+    this._entryExt = null;
 
     // Public methods start as memoized accessors on the prototype; nothing is
     // allocated per instance until one is first read. See _defineLazyMethod
@@ -1117,10 +1136,12 @@ class Validator {
     // "~standard" (Standard Schema V1) is a lazy prototype accessor too;
     // see below the class. Consumers only pay for it if they read it.
 
-    // Populate identity cache so repeated `new Validator(sameSchema)` short-circuits.
-    if (!opts && typeof schema === "object" && schema !== null) {
-      _identityCache.set(schema, this);
-    }
+    // The identity cache, which lets a later `new Validator(sameSchema)` return
+    // this instance, is filled on the first compile rather than here. A WeakMap
+    // entry is an ephemeron the collector has to trace separately, and setting
+    // one cost about 780 ns against 150 for the rest of this constructor, five
+    // times over for an instance that may never validate anything. Once an
+    // instance has compiled, the shortcut behaves as before.
   }
 
   // `$vocabulary` says which keywords the dialect has, and answering needs the
@@ -1556,9 +1577,9 @@ class Validator {
       // The verdict methods answer validate()'s question without building the
       // error list, so they run the same preprocess pass. Skipping it made the
       // two disagree on input that coercion or a default would have fixed.
-      this.isValidObject = preprocess
+      _bindVerdict(this, preprocess
         ? (data) => { preprocess(data); return jsFn(data) }
-        : jsFn;
+        : jsFn);
       // Same preference as the object path: the combined function first, since
       // it validates and collects in one pass, and the error generator behind
       // it. `errPreferCombined` is that order, resolved on the first rejection
@@ -1672,37 +1693,59 @@ class Validator {
         this.isValid = (buf) => {
           self._ensureNative();
           const slot = self._fastSlot;
-          self.isValid = (b) => {
-            if (typeof b === 'string') b = Buffer.from(b);
-            else if (!(b instanceof Uint8Array)) throw new TypeError('isValid() requires a Buffer, Uint8Array, or string. For parsed objects, use isValidObject().');
-            return native.rawFastValidate(slot, b);
-          };
+          self.isValid = slot < 0
+            ? (b) => self._slowBufferValid(b, 'isValid')
+            : (b) => {
+              if (typeof b === 'string') b = Buffer.from(b);
+              else if (!(b instanceof Uint8Array)) throw new TypeError('isValid() requires a Buffer, Uint8Array, or string. For parsed objects, use isValidObject().');
+              return native.rawFastValidate(slot, b);
+            };
           return self.isValid(buf);
         };
         this.countValid = (ndjsonBuf) => {
           self._ensureNative();
           const slot = self._fastSlot;
-          self.countValid = (b) => {
-            if (typeof b === 'string') b = Buffer.from(b);
-            else if (!(b instanceof Uint8Array)) throw new TypeError('countValid() requires a Buffer, Uint8Array, or string');
-            const r = native.rawNDJSONValidate(slot, b);
-            let c = 0;
-            for (let i = 0; i < r.length; i++) if (r[i]) c++;
-            return c;
-          };
+          self.countValid = slot < 0
+            ? (b) => {
+              if (typeof b !== 'string' && !(b instanceof Uint8Array)) throw new TypeError('countValid() requires a Buffer, Uint8Array, or string');
+              const text = typeof b === 'string' ? b : Buffer.from(b.buffer, b.byteOffset, b.byteLength).toString('utf8');
+              let c = 0;
+              for (const line of text.split('\n')) {
+                if (line.trim() === '') continue;
+                if (self._slowBufferValid(line, 'countValid')) c++;
+              }
+              return c;
+            }
+            : (b) => {
+              if (typeof b === 'string') b = Buffer.from(b);
+              else if (!(b instanceof Uint8Array)) throw new TypeError('countValid() requires a Buffer, Uint8Array, or string');
+              const r = native.rawNDJSONValidate(slot, b);
+              let c = 0;
+              for (let i = 0; i < r.length; i++) if (r[i]) c++;
+              return c;
+            };
           return self.countValid(ndjsonBuf);
         };
         this.batchIsValid = (buffers) => {
           self._ensureNative();
           const slot = self._fastSlot;
-          self.batchIsValid = (bufs) => {
-            let v = 0;
-            for (const b of bufs) {
-              if (!(b instanceof Uint8Array)) throw new TypeError('batchIsValid() requires Buffer or Uint8Array elements');
-              if (native.rawFastValidate(slot, b)) v++;
+          self.batchIsValid = slot < 0
+            ? (bufs) => {
+              let v = 0;
+              for (const b of bufs) {
+                if (!(b instanceof Uint8Array)) throw new TypeError('batchIsValid() requires Buffer or Uint8Array elements');
+                if (self._slowBufferValid(b, 'batchIsValid')) v++;
+              }
+              return v;
             }
-            return v;
-          };
+            : (bufs) => {
+              let v = 0;
+              for (const b of bufs) {
+                if (!(b instanceof Uint8Array)) throw new TypeError('batchIsValid() requires Buffer or Uint8Array elements');
+                if (native.rawFastValidate(slot, b)) v++;
+              }
+              return v;
+            };
           return self.batchIsValid(buffers);
         };
       }
@@ -1749,9 +1792,9 @@ class Validator {
             return _validate(data);
           }
         : _validate;
-      this.isValidObject = this._fastVerdict
+      _bindVerdict(this, this._fastVerdict
         ? this._fastVerdict
-        : (data) => _validate(data).valid;
+        : (data) => _validate(data).valid);
       this.validateAndParse = (jsonStr) => this._compiled.validateAndParse(jsonStr);
       {
         const slot = this._fastSlot;
@@ -1809,9 +1852,9 @@ class Validator {
             ? (data) => { preprocess(data); return interp.validate(data); }
             : (data) => interp.validate(data));
       this.validate = run;
-      this.isValidObject = this._fastVerdict
+      _bindVerdict(this, this._fastVerdict
         ? this._fastVerdict
-        : (data) => run(data).valid;
+        : (data) => run(data).valid);
       this.validateJSON = (jsonStr) => {
         try {
           return run(JSON.parse(jsonStr));
@@ -1940,30 +1983,54 @@ class Validator {
     // schema coerces or defaults (preprocess mutates before the verdict),
     // under abortEarly (already a frozen stub), and for $dynamicRef (the
     // boolean engine is not the authority there).
+    // A check registered through _extendValidate joins here when it can: the
+    // verdict comes from the generated function with the check compiled in,
+    // and the check's own errors are appended when somebody reads them. A
+    // rejection then costs what it costs without the check. Where this layer
+    // is not installed, the end of this method wraps validate() instead.
+    const _vx = this._validateTail !== null ? this._validateTail() : null;
+    let _vxApplied = false;
     if (this._fastVerdict && !preprocess && !options.abortEarly && this.validate) {
       const _full = this.validate;
-      const _fast = this._fastVerdict;
+      const _fast = _vx ? _fuseTail(this._fastVerdict, _vx.check) : this._fastVerdict;
+      const _extra = _vx ? _vx.errors : null;
+      _vxApplied = true;
       const EMPTY_ERRORS = Object.freeze([]);
       const _verdictFallback = [{ keyword: 'validation', instancePath: '', schemaPath: '#', params: {}, message: 'schema validation failed' }];
+      const _withExtra = (own, data) => {
+        const more = _extra === null ? null : _extra(data);
+        if (more && more.length) return own ? own.concat(more) : more;
+        // The data changed between the verdict and this read; keep the
+        // verdict and say so rather than inventing a specific error.
+        return own || _verdictFallback;
+      };
       const _buildErrors = (data) => {
         const r = _full(data);
-        return (r && r.valid === false && r.errors && r.errors.length)
-          ? r.errors
-          // The data changed between the verdict and this read; keep the
-          // verdict and say so rather than inventing a specific error.
-          : _verdictFallback;
+        return _withExtra((r && r.valid === false && r.errors && r.errors.length) ? r.errors : null, data);
       };
       const _buildRawErrors = (data) => {
         const r = _full(data);
-        if (!r || r.valid !== false) return _verdictFallback;
-        const raw = typeof r._ataRaw === 'function' ? r._ataRaw() : r.errors;
-        return raw && raw.length ? raw : _verdictFallback;
+        let raw = null;
+        if (r && r.valid === false) {
+          raw = typeof r._ataRaw === 'function' ? r._ataRaw() : r.errors;
+          if (!raw || !raw.length) raw = null;
+        }
+        return _withExtra(raw, data);
       };
       this.validate = (data) => {
         if (_fast(data)) return { valid: true, data, errors: EMPTY_ERRORS };
         return new LazyRejection(_buildErrors, data, _buildRawErrors);
       };
     }
+    if (_vx && !_vxApplied && this.validate) {
+      const inner = this.validate;
+      const { check, errors } = _vx;
+      this.validate = (data) => {
+        const r = inner(data);
+        if (r.valid && check(data)) return r;
+        return new ExtendedRejection(r, data, errors);
+      };
+    }
 
     // The buffer APIs answer from the native walker, which disagrees with
     // validate() on shapes listed in lib/buffer-gate.js. For those schemas
@@ -2011,8 +2078,8 @@ class Validator {
         this.isValidJSON = (jsonStr) => {
           const scan = self._ensureScanner();
           if (scan === undefined) return byParsing(jsonStr);
-          if (scan === null) { self.isValidJSON = byParsing; return byParsing(jsonStr); }
-          self.isValidJSON = memoizable
+          if (scan === null) { _bindEntry(self, 'isValidJSON', byParsing); return byParsing(jsonStr); }
+          _bindEntry(self, 'isValidJSON', memoizable
             ? (text) => {
                 if (typeof text !== 'string') return byParsing(text);
                 if (text === _memoText) return _memoVerdict;
@@ -2027,7 +2094,7 @@ class Validator {
                 const r = scan(text);
                 if (r === -1) return byParsing(text);
                 return r === 1;
-              };
+              });
           return self.isValidJSON(jsonStr);
         };
         // validateJSON gets the same short-circuit isValidJSON has. The verdict is
@@ -2050,8 +2117,8 @@ class Validator {
           this.validateJSON = (jsonStr) => {
             const scan = self._ensureScanner();
             if (scan === undefined) return validateByParsing(jsonStr);
-            if (scan === null) { self.validateJSON = validateByParsing; return validateByParsing(jsonStr); }
-            self.validateJSON = (text) => {
+            if (scan === null) { _bindEntry(self, 'validateJSON', validateByParsing); return validateByParsing(jsonStr); }
+            _bindEntry(self, 'validateJSON', (text) => {
               if (typeof text === 'string') {
                 const r = scan(text);
                 if (r === 1) return VALID_RESULT;
@@ -2066,21 +2133,25 @@ class Validator {
                 }
               }
               return validateByParsing(text);
-            };
+            });
             return self.validateJSON(jsonStr);
           };
         }
       }
 
-
-    // Save to identity cache for ultra-fast reuse with same schema object.
-    // Only an instance built without options may answer a later
-    // `new Validator(schema)`: one built with options (richErrors: false,
-    // coerceTypes, formats, ...) would hand its options to a caller that
-    // asked for none.
-    if (this._noOpts && this._schemaObj && typeof this._schemaObj === 'object') {
-      _identityCache.set(this._schemaObj, this);
+    // An extension registered through _extendValidate covers the JSON entry
+    // points too. They are final here except for the scanner stubs above,
+    // which rebind themselves on first use through _bindEntry, so the
+    // extension is applied to whatever each one is now and again on rebind.
+    if (_vx) {
+      this._entryExt = _jsonEntryWrappers(_vx);
+      for (const name of ['validateJSON', 'isValidJSON', 'validateAndParse']) {
+        if (Object.prototype.hasOwnProperty.call(this, name) && typeof this[name] === 'function') _bindEntry(this, name, this[name]);
+      }
     }
+
+
+    _rememberInstance(this);
   }
 
   // Which engine answers validate() for this schema: 'codegen' (generated
@@ -2106,7 +2177,37 @@ class Validator {
       nativeSchemaStr = JSON.stringify(merged);
     }
     this._compiled = new native.CompiledSchema(nativeSchemaStr);
-    this._fastSlot = native.fastRegister(nativeSchemaStr);
+    // The fast registry is a fixed array of slots in the addon, and registering
+    // a distinct schema past the last one throws. It is an accelerator for the
+    // buffer path, not a requirement, so a full registry leaves the slot at -1
+    // and the buffer methods answer from the JS engine instead. Letting this
+    // throw made every validator built after the 4096th unusable on that path.
+    try {
+      this._fastSlot = native.fastRegister(nativeSchemaStr);
+    } catch {
+      this._fastSlot = -1;
+    }
+  }
+
+  // The buffer path without a fast slot: decode, parse, and hand the value to
+  // the engine that does not need one. Slower than the zero-copy walk, and the
+  // same answer. A negative slot must never reach rawFastValidate, whose bounds
+  // check would report a valid document as invalid.
+  _slowBufferValid(input, who) {
+    let text;
+    if (typeof input === 'string') text = input;
+    else if (input instanceof Uint8Array) {
+      text = Buffer.from(input.buffer, input.byteOffset, input.byteLength).toString('utf8');
+    } else {
+      throw new TypeError(who + '() requires a Buffer, Uint8Array, or string');
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(text);
+    } catch {
+      return false;
+    }
+    return this.isValidObject(parsed);
   }
 
   addSchema(schema) {
@@ -2153,7 +2254,8 @@ class Validator {
     const cached = (this._userFormats || this._usesKeywords) ? null : _compileCache.get(mapKey);
     if (cached && cached.jsFn) {
       this._jsFn = cached.jsFn;
-      this.isValidObject = cached.jsFn;
+      _bindVerdict(this, cached.jsFn);
+      _rememberInstance(this);
       return;
     }
     const uf = this._userFormats;
@@ -2161,7 +2263,8 @@ class Validator {
     const jsFn = _cg || compileToJS(this._schemaObj, null, sm);
     this._jsFn = jsFn;
     if (jsFn) {
-      this.isValidObject = jsFn;
+      _bindVerdict(this, jsFn);
+      _rememberInstance(this);
       // A partial entry: the verdict function is real, the other two are not
       // built yet rather than declined. `undefined` is the not-built marker
       // the full compile's _buildDeferred looks for; `null` would read as
@@ -2563,6 +2666,216 @@ Object.defineProperty(Validator.prototype, "~standard", {
   },
 });
 
+// Install the verdict method. Every place that binds isValidObject comes
+// through here, so a check registered with _extendVerdict survives the method
+// being replaced as the validator compiles further, which it does more than
+// once over its life.
+function _bindVerdict(self, fn) {
+  const resolve = self._verdictTail;
+  if (resolve !== null && typeof fn === 'function') {
+    const tail = resolve();
+    if (typeof tail === 'function') fn = _fuseTail(fn, tail);
+  }
+  self.isValidObject = fn;
+}
+
+// Bind one of the JSON entry points, through the extension wrapper when there is one.
+function _bindEntry(self, name, fn) {
+  const ext = self._entryExt;
+  self[name] = ext !== null && ext[name] ? ext[name](fn) : fn;
+}
+
+// The JSON entry points under an extension: the schema answers first, and only
+// text it accepts is parsed for the check, so a rejection costs nothing extra.
+function _jsonEntryWrappers({ check, errors }) {
+  const parse = (text) => JSON.parse(typeof text === 'string' ? text : new TextDecoder().decode(text));
+  return {
+    validateJSON: (inner) => (text) => {
+      const res = inner(text);
+      if (!res.valid) return res;
+      let data;
+      try { data = parse(text); } catch { return res; }
+      if (check(data)) return res;
+      const e = errors(data);
+      return e && e.length ? { valid: false, errors: e } : { valid: false, errors: [_EXT_FALLBACK] };
+    },
+    isValidJSON: (inner) => (text) => {
+      if (!inner(text)) return false;
+      let data;
+      try { data = parse(text); } catch { return true; }
+      return check(data);
+    },
+    validateAndParse: (inner) => (text) => {
+      const res = inner(text);
+      if (!res.valid) return res;
+      if (check(res.value)) return res;
+      const e = errors(res.value);
+      return { valid: false, value: res.value, errors: e && e.length ? e : [_EXT_FALLBACK] };
+    },
+  };
+}
+const _EXT_FALLBACK = Object.freeze({ keyword: 'validation', instancePath: '', schemaPath: '#', params: {}, message: 'schema validation failed' });
+
+// A verdict function that also runs `tail` on what it accepts. The generated
+// function can take the check in place of its final `return true`, one call
+// per document; anything else is composed.
+function _fuseTail(fn, tail) {
+  const fused = typeof fn._withTail === 'function' ? fn._withTail(tail) : null;
+  return fused || ((d) => fn(d) && tail(d));
+}
+
+// The rejection validate() returns on the paths where an extension check could
+// not join the lazy layer: the inner result, plus the check's errors appended
+// on first read. `inner` may itself be valid, when only the check failed.
+class ExtendedRejection {
+  constructor(inner, data, collect) {
+    this.valid = false;
+    this._inner = inner;
+    this._data = data;
+    this._collect = collect;
+    this._errors = null;
+  }
+  toJSON() {
+    return { valid: false, errors: this.errors };
+  }
+  _ataRaw() {
+    const inner = this._inner;
+    const more = this._collect(this._data) || [];
+    const raw = inner.valid ? more : (typeof inner._ataRaw === 'function' ? inner._ataRaw() : inner.errors).concat(more);
+    return raw.length ? raw : [_EXT_FALLBACK];
+  }
+}
+Object.defineProperty(ExtendedRejection.prototype, 'errors', {
+  enumerable: true,
+  configurable: true,
+  get() {
+    if (this._errors === null) {
+      const inner = this._inner;
+      const more = this._collect(this._data) || [];
+      const all = inner.valid ? more : inner.errors.concat(more);
+      this._errors = all.length ? all : [_EXT_FALLBACK];
+    }
+    return this._errors;
+  },
+});
+
+// For wrappers that enforce a check the schema does not carry, such as the
+// `instanceof` keyword of @ata-project/keywords. `resolve` is called whenever
+// the verdict method is bound, which is after the schema has been normalized,
+// and returns the check, a function of the document that answers true or
+// false, or null when there is nothing to add. Only isValidObject takes it;
+// the other entry points, which report errors, stay the wrapper's to handle.
+//
+// Before this, such a wrapper had to hold isValidObject behind an accessor so
+// that the validator's own rebinding could not drop its check, and every call
+// paid for the accessor and two more calls: 10.1 ns against 4.2 on a document
+// the schema rejects at its third property.
+Validator.prototype._verdictTail = null;
+Validator.prototype._validateTail = null;
+Validator.prototype._entryExt = null;
+
+// Let `new Validator(schema)` with the same schema object return this instance.
+// Only an instance built without options may answer that call: one built with
+// options (richErrors: false, coerceTypes, formats, ...) would hand its options
+// to a caller that asked for none, and an extended one would enforce checks the
+// caller never registered. Both the caller's object and the normalized one are
+// keys, since a later caller passes the former.
+function _rememberInstance(self) {
+  if (!self._noOpts || self._verdictTail !== null || self._validateTail !== null) return;
+  const raw = self._rawSchema;
+  if (raw && typeof raw === 'object' && !_identityCache.has(raw)) _identityCache.set(raw, self);
+  const obj = self._schemaObj;
+  if (obj !== raw && obj && typeof obj === 'object' && !_identityCache.has(obj)) _identityCache.set(obj, self);
+}
+
+// An extended validator answers differently from a plain one for the same
+// schema, so it must not be the instance `new Validator(sameSchema)` hands out.
+function _leaveIdentityCache(self) {
+  self._noOpts = false;
+  // Nothing is registered before the first compile, so there is nothing to
+  // take back.
+  if (!self._initialized && self._jsFn === null) return;
+  const raw = self._rawSchema;
+  if (raw && typeof raw === 'object' && _identityCache.get(raw) === self) _identityCache.delete(raw);
+  // The compiled form is cached too, at the end of the first compile. Read it
+  // only if it is already materialized: reading it otherwise builds it.
+  if (Object.prototype.hasOwnProperty.call(self, '_schemaObj')) {
+    const obj = self._schemaObj;
+    if (obj && typeof obj === 'object' && _identityCache.get(obj) === self) _identityCache.delete(obj);
+  }
+}
+
+// The same kind of extension for validate(): `resolve` returns { check, errors }
+// or null, where `errors(data)` lists the check's own errors, or returns null
+// when there are none. The check's errors come after the schema's, and a value
+// that fails only the check is rejected with the check's errors alone. Must be
+// called before validate() is first used, which is when it is compiled; later
+// calls throw rather than being silently ignored.
+Validator.prototype._extendValidate = function (resolve) {
+  if (typeof resolve !== 'function') throw new TypeError('_extendValidate expects a function');
+  if (this._initialized) throw new Error('_extendValidate must be called before the validator compiles');
+  _leaveIdentityCache(this);
+  const prev = this._validateTail;
+  this._validateTail = prev === null ? resolve : () => {
+    const a = prev(), b = resolve();
+    if (!a) return b;
+    if (!b) return a;
+    return {
+      check: (d) => a.check(d) && b.check(d),
+      errors: (d) => {
+        const x = a.errors(d), y = b.errors(d);
+        if (!x) return y;
+        if (!y) return x;
+        return x.concat(y);
+      },
+    };
+  };
+  return this;
+};
+
+// Both extensions in one call, from one resolver that returns { check, errors }
+// or null. This is the form @ata-project/keywords uses: registering costs one
+// closure, where wrapping the five entry points cost a closure per entry point,
+// the wrappers themselves and an accessor, most of what building a wrapped
+// validator took.
+Validator.prototype._extendChecks = function (resolve) {
+  if (typeof resolve !== 'function') throw new TypeError('_extendChecks expects a function');
+  this._extendValidate(resolve);
+  return this._extendVerdict(() => {
+    const x = resolve();
+    return x ? x.check : null;
+  });
+};
+
+// Whether this instance enforces a check its schema does not carry. The
+// ahead-of-time emitters build a module from the schema alone, so they refuse
+// an instance that says yes rather than emit one that accepts too much.
+// Reading it resolves the registered checks; only an emitter reads it.
+Object.defineProperty(Validator.prototype, '_externalChecks', {
+  configurable: true,
+  get() {
+    if (this._validateTail !== null && this._validateTail()) return true;
+    if (this._verdictTail !== null && typeof this._verdictTail() === 'function') return true;
+    return false;
+  },
+});
+
+Validator.prototype._extendVerdict = function (resolve) {
+  if (typeof resolve !== 'function') throw new TypeError('_extendVerdict expects a function');
+  _leaveIdentityCache(this);
+  const prev = this._verdictTail;
+  this._verdictTail = prev === null ? resolve : () => {
+    const a = prev(), b = resolve();
+    if (typeof a !== 'function') return b;
+    if (typeof b !== 'function') return a;
+    return (d) => a(d) && b(d);
+  };
+  // A method bound before this call was bound without the check. Rebind it.
+  // An unbound one binds through _bindVerdict on its first call.
+  if (Object.prototype.hasOwnProperty.call(this, 'isValidObject')) _bindVerdict(this, this.isValidObject);
+  return this;
+};
+
 function _defineLazyMethod(name, maker) {
   Object.defineProperty(Validator.prototype, name, {
     configurable: true,
@@ -2608,13 +2921,13 @@ _defineLazyMethod('isValidObject', (self) => (data) => {
   if (_tier.tier === 0) {
     const _plan = buildTier0Plan(self._schemaObj);
     let _n = 0;
-    self.isValidObject = (d) => {
+    _bindVerdict(self, (d) => {
       const r = tier0Validate(_plan, d);
       if (++_n === 2) {
         try { self._ensureCodegen(); } catch {}
       }
       return r;
-    };
+    });
   } else {
     // `new Function` is a property of the realm, not of the schema: under a
     // strict CSP or `--disallow-code-generation-from-strings` this throws

package/lib/formats.js

@@ -117,8 +117,16 @@ function dateTime (s) {
 // Also used for the dotted tail of an IPv4-mapped IPv6 address, which is why
 // the work is done over a range rather than a whole string: taking a slice for
 // it would allocate on a path that exists to avoid allocating.
+// Four dotted decimal octets, 0 to 255, no leading zeros: the same language
+// ipv4Range walks, as one regular expression. The engine answers a dotted quad
+// in about 12 ns where the walk takes 17, for the reason `uri` above found:
+// its character-class loop beats a charCodeAt loop. ipv4Range stays for the
+// embedded form inside an IPv6 address, where the octets are a slice.
+// tests/test_ipv4_regex.js holds the two to the same answers.
+const IPV4 = /^(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$/;
+
 function ipv4 (s) {
-  return ipv4Range(s, 0, s.length);
+  return IPV4.test(s);
 }
 
 function ipv4Range (s, from, to) {
@@ -147,8 +155,17 @@ function ipv4Range (s, from, to) {
 // allocated twice and accepted things like "12345::1"; they also disagreed
 // with each other about an IPv4 tail. Answers match Node's own `net.isIPv6`,
 // which the test uses as its oracle.
+// Eight groups of one to four hex digits and nothing else: the uncompressed
+// form, which is always a valid address. The walk below takes 64 ns on one;
+// this answers in about 30, and anything it does not match, compressed forms
+// and embedded IPv4 included, goes to the walk as before. It is only tried from
+// 15 characters, the shortest string it can match, so a short rejection does
+// not pay for it. tests/test_ipv6_fast_path.js holds the subset relation.
+const IPV6_FULL = /^(?:[0-9A-Fa-f]{1,4}:){7}[0-9A-Fa-f]{1,4}$/;
+
 function ipv6 (s) {
   const n = s.length;
+  if (n >= 15 && IPV6_FULL.test(s)) return true;
   if (n < 2 || n > 45) return false;
 
   let end = n;
@@ -256,7 +273,22 @@ SCHEME_CHAR[43] = 1; SCHEME_CHAR[45] = 1; SCHEME_CHAR[46] = 1;
 // string or scanned again. Reading it out with `slice` and asking the copy for
 // `lastIndexOf` and two regular expressions allocated a string per URI, and a
 // document carrying a handful of URLs paid that per field.
+// The shape almost every URI in a document has, as one regular expression: a
+// scheme, then either "//" and a host with no userinfo, port, brackets or
+// percent escapes, or no authority at all, then a tail of characters RFC 3986
+// allows, again without "%". Everything it accepts the walk below accepts too,
+// and it answers the common case in about 25 ns where the walk takes 43 on a
+// 34-character URL, because the engine scans a character class faster than a
+// charCodeAt loop does. Anything it declines, the walk decides as before.
+//
+// The two branches after the colon are exclusive on purpose. With the "//"
+// group merely optional, "http://[::1" could skip it and match "//[::1" as a
+// path, accepting a string the walk rejects for its unclosed bracket.
+// tests/test_uri_fast_path.js holds the subset relation.
+const URI_FAST = /^[A-Za-z][A-Za-z0-9+.\-]*:(?:\/\/[!$&-.0-9;=A-Z_a-z~]*(?:[\/?#][!#$&-;=?-\[\]_a-z~]*)?|(?!\/\/)[!#$&-;=?-\[\]_a-z~]*)$/;
+
 function uri (s) {
+  if (URI_FAST.test(s)) return true;
   const n = s.length;
   if (n === 0) return false;
   let c = s.charCodeAt(0);
@@ -762,8 +794,8 @@ const URI_HELPER_TABLES = 'const _uct=new Uint8Array(128);for(let _i=33;_i<127;_
   'for(let _i=97;_i<103;_i++)_uch[_i]=1;for(let _i=65;_i<71;_i++)_uch[_i]=1;' +
   'const _ucs=new Uint8Array(128);for(let _i=48;_i<58;_i++)_ucs[_i]=1;' +
   'for(let _i=97;_i<123;_i++)_ucs[_i]=1;for(let _i=65;_i<91;_i++)_ucs[_i]=1;' +
-  '_ucs[43]=1;_ucs[45]=1;_ucs[46]=1';
-const URI_HELPER_BODY = 'const _n=_s.length;if(_n===0)return false;let _c=_s.charCodeAt(0);if(_c>127||_ucs[_c]===0||(_c>=48&&_c<=57)||_c===43||_c===45||_c===46)return false;let _co=-1;for(let _i=1;_i<_n;_i++){_c=_s.charCodeAt(_i);if(_c===58){_co=_i;break}if(_c>127||_ucs[_c]===0)return false}if(_co===-1)return false;let _i=_co+1;let _ae=_n;if(_s.charCodeAt(_i)===47&&_s.charCodeAt(_i+1)===47){const _as=_i+2;let _at=-1,_fc=-1,_lc=-1,_br=0,_ba=0,_hs=_as;_ae=-1;for(_i=_as;_i<_n;_i++){_c=_s.charCodeAt(_i);if(_c>127||_uct[_c]===0)return false;if(_c===47||_c===63||_c===35){_ae=_i;break}if(_c===37){const _h1=_s.charCodeAt(_i+1),_h2=_s.charCodeAt(_i+2);if(!(_h1<=127)||!(_h2<=127)||_uch[_h1]===0||_uch[_h2]===0)return false;_i+=2;continue}if(_c===64){_ba=_br;_at=_i;_fc=-1;_lc=-1;_hs=_i+1}else if(_c===58){if(_fc===-1)_fc=_i;_lc=_i}else if(_c===91||_c===93){_br=1}}if(_ae===-1)_ae=_n;if(_at!==-1&&_ba)return false;if(_s.charCodeAt(_hs)===91){let _cl=-1;for(let _j=_hs+1;_j<_ae;_j++){if(_s.charCodeAt(_j)===93){_cl=_j;break}}if(_cl===-1)return false;if(_cl+1!==_ae){if(_s.charCodeAt(_cl+1)!==58)return false;for(let _j=_cl+2;_j<_ae;_j++){const _d=_s.charCodeAt(_j);if(_d<48||_d>57)return false}}}else if(_lc!==-1){if(_fc!==_lc)return false;for(let _j=_lc+1;_j<_ae;_j++){const _d=_s.charCodeAt(_j);if(_d<48||_d>57)return false}}_i=_ae}for(;_i<_n;_i++){_c=_s.charCodeAt(_i);if(_c>127||_uct[_c]===0)return false;if(_c===37){const _h1=_s.charCodeAt(_i+1),_h2=_s.charCodeAt(_i+2);if(!(_h1<=127)||!(_h2<=127)||_uch[_h1]===0||_uch[_h2]===0)return false;_i+=2}}return true;';
+  '_ucs[43]=1;_ucs[45]=1;_ucs[46]=1;const _ufa=/' + URI_FAST.source + '/';
+const URI_HELPER_BODY = 'if(_ufa.test(_s))return true;const _n=_s.length;if(_n===0)return false;let _c=_s.charCodeAt(0);if(_c>127||_ucs[_c]===0||(_c>=48&&_c<=57)||_c===43||_c===45||_c===46)return false;let _co=-1;for(let _i=1;_i<_n;_i++){_c=_s.charCodeAt(_i);if(_c===58){_co=_i;break}if(_c>127||_ucs[_c]===0)return false}if(_co===-1)return false;let _i=_co+1;let _ae=_n;if(_s.charCodeAt(_i)===47&&_s.charCodeAt(_i+1)===47){const _as=_i+2;let _at=-1,_fc=-1,_lc=-1,_br=0,_ba=0,_hs=_as;_ae=-1;for(_i=_as;_i<_n;_i++){_c=_s.charCodeAt(_i);if(_c>127||_uct[_c]===0)return false;if(_c===47||_c===63||_c===35){_ae=_i;break}if(_c===37){const _h1=_s.charCodeAt(_i+1),_h2=_s.charCodeAt(_i+2);if(!(_h1<=127)||!(_h2<=127)||_uch[_h1]===0||_uch[_h2]===0)return false;_i+=2;continue}if(_c===64){_ba=_br;_at=_i;_fc=-1;_lc=-1;_hs=_i+1}else if(_c===58){if(_fc===-1)_fc=_i;_lc=_i}else if(_c===91||_c===93){_br=1}}if(_ae===-1)_ae=_n;if(_at!==-1&&_ba)return false;if(_s.charCodeAt(_hs)===91){let _cl=-1;for(let _j=_hs+1;_j<_ae;_j++){if(_s.charCodeAt(_j)===93){_cl=_j;break}}if(_cl===-1)return false;if(_cl+1!==_ae){if(_s.charCodeAt(_cl+1)!==58)return false;for(let _j=_cl+2;_j<_ae;_j++){const _d=_s.charCodeAt(_j);if(_d<48||_d>57)return false}}}else if(_lc!==-1){if(_fc!==_lc)return false;for(let _j=_lc+1;_j<_ae;_j++){const _d=_s.charCodeAt(_j);if(_d<48||_d>57)return false}}_i=_ae}for(;_i<_n;_i++){_c=_s.charCodeAt(_i);if(_c>127||_uct[_c]===0)return false;if(_c===37){const _h1=_s.charCodeAt(_i+1),_h2=_s.charCodeAt(_i+2);if(!(_h1<=127)||!(_h2<=127)||_uch[_h1]===0||_uch[_h2]===0)return false;_i+=2}}return true;';
 const uriHelperSource = (name) =>
   URI_HELPER_TABLES + ';function ' + name + '(_s){' + URI_HELPER_BODY + '}';
 
@@ -1010,4 +1042,4 @@ function durationSource (v, isStr) {
   return isStr ? inner : `if(typeof ${v}==='string'&&${inner.slice(3)}`;
 }
 
-module.exports = { uriHelperSource, date, ipv4, dateTime, ipv6, hostname, uri, uriReference, uuid, time, noReserved, jsonPointer, relativeJsonPointer, uriTemplate, email, duration, uriChars, uriAuthority, uriCharsSource, uriAuthoritySource, iri, iriReference, idnEmail, iriSource, iriReferenceSource, idnEmailSource, dateSource, ipv4Source, dateTimeSource, ipv6Source, hostnameSource, uriSource, uuidSource, timeSource, noReservedSource, jsonPointerSource, relativeJsonPointerSource, uriTemplateSource, emailSource, durationSource };
+module.exports = { IPV4, IPV6_FULL, ipv4Range, URI_FAST, uriHelperSource, date, ipv4, dateTime, ipv6, hostname, uri, uriReference, uuid, time, noReserved, jsonPointer, relativeJsonPointer, uriTemplate, email, duration, uriChars, uriAuthority, uriCharsSource, uriAuthoritySource, iri, iriReference, idnEmail, iriSource, iriReferenceSource, idnEmailSource, dateSource, ipv4Source, dateTimeSource, ipv6Source, hostnameSource, uriSource, uuidSource, timeSource, noReservedSource, jsonPointerSource, relativeJsonPointerSource, uriTemplateSource, emailSource, durationSource };

package/lib/js-compiler.js

@@ -1567,7 +1567,7 @@ function compileToJSCodegen(schema, schemaMap, userFormats) {
   const defSets = ctx.defFns ? Array.from(ctx.defFns.values()) : []
   const needsGuard = ctx.usesRecursion || defSets.length > 0
 
-  let body, hybridBody
+  let body, hybridBody, tailBody
   if (ctx.usesRecursion) {
     // Self-recursive: a named body reached through the cycle guard, so data
     // that points back at itself settles instead of exhausting the stack.
@@ -1577,15 +1577,21 @@ function compileToJSCodegen(schema, schemaMap, userFormats) {
     body = `${decl}function _run(d){\n  ${run}\n  }\n  return _run(d)`
     // Hybrid: keep the boolean answer, wrap only the outer call
     hybridBody = `${decl}function _run(d){\n  ${run}\n  }\n  return _run(d)?R:E(d)`
+    tailBody = `${decl}function _run(d){\n  ${run}\n  }\n  return _run(d)&&__ataTail(d)`
   } else if (defSets.length > 0) {
     // No self-reference at the root, but a def on a cycle can still be
     // re-entered with the same value; the guarded functions need their state.
     const run = emitGuardedRun(`return _body(d)`, '', defSets)
     body = `function _body(d){\n  ${checkStr}\n  return true\n  }\n  function _run(d){\n  ${run}\n  }\n  return _run(d)`
     hybridBody = `function _body(d){\n  ${checkStr}\n  return true\n  }\n  function _run(d){\n  ${run}\n  }\n  return _run(d)?R:E(d)`
+    tailBody = `function _body(d){\n  ${checkStr}\n  return true\n  }\n  function _run(d){\n  ${run}\n  }\n  return _run(d)&&__ataTail(d)`
   } else {
     body = checkStr + '\n  return true'
     hybridBody = replaceTopLevel(checkStr + '\n  return R')
+    // An early accept inside the checks has to reach the tail too, so every
+    // top-level `return true` becomes the tail call, by the same rewrite the
+    // hybrid above relies on and test_hybrid_agreement holds to the suite.
+    tailBody = replaceTopLevel(checkStr + '\n  return true', 'return __ataTail(d)', 'return false')
   }
 
   const guardStr = needsGuard ? emitGuardState() : ''
@@ -1610,6 +1616,26 @@ function compileToJSCodegen(schema, schemaMap, userFormats) {
       boolFn._hybridFactory = (R, E) => hybridFactory(...closureValues, R, E)
     } catch {}
 
+    // The same function with one more check where it would return true, for a
+    // wrapper that enforces something the schema does not carry (see
+    // Validator#_extendVerdict). Calling the check from here rather than from a
+    // function around this one is the point: this function is too large for
+    // the engine to inline, so a wrapper is a second call on every document,
+    // and a rejection never reaches the check at all. Built on first request,
+    // since almost no validator is extended. Null when code generation is
+    // refused, and the caller composes instead.
+    let tailFactory
+    boolFn._withTail = (tail) => {
+      if (tailFactory === undefined) {
+        try {
+          tailFactory = new Function(...closureNames, '__ataTail', `${preambleStr}return function(d){${tailBody}}`)
+        } catch {
+          tailFactory = null
+        }
+      }
+      return tailFactory === null ? null : tailFactory(...closureValues, tail)
+    }
+
     // Store source for standalone compilation. Regex declarations are NOT
     // inlined into the body: they are carried by _closures and the emitters
     // declare them once at load scope. Inlining them here put a
@@ -1663,7 +1689,7 @@ function compileToJSCodegen(schema, schemaMap, userFormats) {
 
 // Replace top-level `return false` → `return E(d)` and `return true` → `return R`.
 // Tracks function nesting depth to preserve nested function internals.
-function replaceTopLevel(code) {
+function replaceTopLevel(code, onTrue = 'return R', onFalse = 'return E(d)') {
   let fnDepth = 0, result = '', i = 0
   while (i < code.length) {
     // A nested closure keeps its own returns. Both spellings count: a
@@ -1690,10 +1716,10 @@ function replaceTopLevel(code) {
         i++
       }
     } else if (code.startsWith('return false', i)) {
-      result += 'return E(d)'
+      result += onFalse
       i += 12
     } else if (code.startsWith('return true', i) && (i + 11 >= code.length || !/[a-zA-Z_$]/.test(code[i + 11]))) {
-      result += 'return R'
+      result += onTrue
       i += 11
     } else {
       result += code[i]
@@ -3147,8 +3173,20 @@ const FORMAT_CODEGEN = {
   'uri-reference': (v, isStr) => isStr
     ? `{${_formats.uriCharsSource(v, '0')}}`
     : `if(typeof ${v}==='string'){${_formats.uriCharsSource(v, '0')}}`,
-  ipv4: _formats.ipv4Source,
-  ipv6: _formats.ipv6Source,
+  ipv4: (v, isStr, ctx) => {
+    if (!ctx) return _formats.ipv4Source(v, isStr)
+    // Hoisted: a regex literal in the body would build a new RegExp per call.
+    hoistOnce(ctx, '_ip4Hoisted', 'const _ip4=/' + _formats.IPV4.source + '/')
+    return isStr ? `if(!_ip4.test(${v}))return false` : `if(typeof ${v}==='string'&&!_ip4.test(${v}))return false`
+  },
+  ipv6: (v, isStr, ctx) => {
+    if (!ctx) return _formats.ipv6Source(v, isStr)
+    hoistOnce(ctx, '_ip6Hoisted', 'const _ip6f=/' + _formats.IPV6_FULL.source + '/')
+    // The fast accept jumps past the walk; the walk's `return false`s are what
+    // the error generators rewrite, so they stay as they are.
+    const body = `_ip6:{if(${v}.length>=15&&_ip6f.test(${v}))break _ip6;${_formats.ipv6Source(v, true).replace(/^\{|\}$/g, '')}}`
+    return isStr ? body : `if(typeof ${v}==='string'){${body}}`
+  },
   hostname: _formats.hostnameSource,
 }
 
@@ -3512,7 +3550,23 @@ function compileToJSCodegenWithErrors(schema, schemaMap, userFormats, sourceOpts
     // first invalid document threw a ReferenceError instead of reporting.
     const cvars = ctx.closureVars
     const cvals = ctx.closureVals
-    if (ctx.usesSafeRe) {
+    // The helpers are constants: the uri tables, the compiled patterns, the
+    // branch-collapse functions, the name sets. In `body` they sit inside the
+    // function and were rebuilt on every call, which on a product schema with
+    // six URLs and one anyOf cost about 450 ns before a single check ran, more
+    // than every check and every error together. Here they run once, in a
+    // factory, as the verdict function's preamble does. Only for the plain
+    // shape: with $defs or recursion the helpers include functions that read
+    // the per-call guard state declared in the body, so those keep `body` as
+    // it is. `_errSource` below stays `body` either way, for the emitters.
+    const hoistable = !ctx.usesRecursion && defSetsE.length === 0 && helpersE !== ''
+    if (hoistable) {
+      const factoryBody = helpersE + 'return function(d,_all){const _e=[];\n  ' + checkStr +
+        '\n  return{valid:_e.length===0,errors:_e}}'
+      const params = ctx.usesSafeRe ? [...cvars, '__ataSafeRe'] : [...cvars]
+      const args = ctx.usesSafeRe ? [...cvals, compileSafe] : [...cvals]
+      fn = new Function(...params, factoryBody)(...args)
+    } else if (ctx.usesSafeRe) {
       // Inlined helperCode references __ataSafeRe; bind the safe-regex factory.
       // Standalone keeps the inline _errSource — the embed defines __ataSafeRe.
       const built = new Function(...cvars, '__ataSafeRe', 'd', '_all', body)

package/lib/t.js

@@ -15,15 +15,15 @@ const OPTIONAL = Symbol.for('ata.t.optional');
 const { attach: attachRefine } = require('./refine');
 
 function string(opts) {
-  return Object.assign({ type: 'string' }, opts);
+  return opts === undefined ? { type: 'string' } : { type: 'string', ...opts };
 }
 
 function number(opts) {
-  return Object.assign({ type: 'number' }, opts);
+  return opts === undefined ? { type: 'number' } : { type: 'number', ...opts };
 }
 
 function integer(opts) {
-  return Object.assign({ type: 'integer' }, opts);
+  return opts === undefined ? { type: 'integer' } : { type: 'integer', ...opts };
 }
 
 function boolean() {
@@ -47,7 +47,7 @@ function enumOf(values) {
 }
 
 function array(items, opts) {
-  return Object.assign({ type: 'array', items }, opts);
+  return opts === undefined ? { type: 'array', items } : { type: 'array', items, ...opts };
 }
 
 function tuple(items, opts) {
@@ -63,26 +63,46 @@ function tuple(items, opts) {
 }
 
 function record(values, opts) {
-  return Object.assign({ type: 'object', additionalProperties: values }, opts);
+  return opts === undefined ? { type: 'object', additionalProperties: values } : { type: 'object', additionalProperties: values, ...opts };
 }
 
 function object(properties, opts) {
-  const props = {};
-  const required = [];
+  // The common case has no optional member: then `properties` is copied as it
+  // is and the fresh key list is `required`. The values come from one
+  // Object.values call because reading them back key by key was the larger
+  // part of this function's cost. A member marked optional sends the whole
+  // object down the slower path that rewrites it.
   const keys = Object.keys(properties);
-  for (const key of keys) {
-    const schema = properties[key];
-    if (schema && schema[OPTIONAL] === true) {
-      const { [OPTIONAL]: _drop, ...rest } = schema;
-      props[key] = rest;
-    } else {
-      props[key] = schema;
-      required.push(key);
+  const values = Object.values(properties);
+  let anyOptional = false;
+  for (let i = 0; i < values.length; i++) {
+    const schema = values[i];
+    if (schema && schema[OPTIONAL] === true) { anyOptional = true; break; }
+  }
+  let out;
+  if (!anyOptional) {
+    out = keys.length
+      ? { type: 'object', properties: { ...properties }, required: keys }
+      : { type: 'object', properties: { ...properties } };
+  } else {
+    const props = {};
+    const required = [];
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      const schema = values[i];
+      if (schema && schema[OPTIONAL] === true) {
+        const { [OPTIONAL]: _drop, ...rest } = schema;
+        props[key] = rest;
+      } else {
+        props[key] = schema;
+        required.push(key);
+      }
     }
+    out = required.length
+      ? { type: 'object', properties: props, required }
+      : { type: 'object', properties: props };
   }
-  const out = { type: 'object', properties: props };
-  if (required.length) out.required = required;
-  return Object.assign(out, opts);
+  return opts === undefined ? out : Object.assign(out, opts);
 }
 
 function optional(schema) {

package/lib/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "1.30.2",
+  "version": "1.31.0",
   "description": "JSON Schema validation that compiles for speed and still runs where code generation is blocked. Compiled and interpreted engines answer identically at 100% of the official suite. TypeScript inference, Standard Schema V1, and a build step that emits dependency-free modules.",
   "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_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_output_format.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_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_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_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_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_deferred_def_scope.js && node tests/test_node_scoped_ctx_flags.js && node tests/test_ajv_errors.js && node tests/test_custom_keywords.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_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_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_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_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_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_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_output_format.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_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_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_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_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_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_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_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_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_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_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_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",
@@ -121,13 +121,13 @@
     "LICENSE"
   ],
   "optionalDependencies": {
-    "@ata-validator/native-darwin-arm64": "1.30.2",
-    "@ata-validator/native-darwin-x64": "1.30.2",
-    "@ata-validator/native-linux-arm64-gnu": "1.30.2",
-    "@ata-validator/native-linux-arm64-musl": "1.30.2",
-    "@ata-validator/native-linux-x64-gnu": "1.30.2",
-    "@ata-validator/native-linux-x64-musl": "1.30.2",
-    "@ata-validator/native-win32-x64": "1.30.2"
+    "@ata-validator/native-darwin-arm64": "1.31.0",
+    "@ata-validator/native-darwin-x64": "1.31.0",
+    "@ata-validator/native-linux-arm64-gnu": "1.31.0",
+    "@ata-validator/native-linux-arm64-musl": "1.31.0",
+    "@ata-validator/native-linux-x64-gnu": "1.31.0",
+    "@ata-validator/native-linux-x64-musl": "1.31.0",
+    "@ata-validator/native-win32-x64": "1.31.0"
   },
   "peerDependencies": {
     "yaml": "^2.0.0"