ata-validator 1.30.3 → 1.31.1

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
@@ -1385,7 +1406,7 @@ class Validator {
                       return this._compiled.validate(x);
                     });
         }
-        return _errOnlyImpl(d);
+        return _mustReject(_errOnlyImpl(d));
       };
 
       // Best path: combined validator (single pass, validates + collects errors)
@@ -1429,7 +1450,7 @@ class Validator {
       let _errPreferredImpl = null;
       const errPreferCombined = (d) => {
         if (_errPreferredImpl === null) _errPreferredImpl = combinedIfSafe() || errOnly;
-        return _errPreferredImpl(d);
+        return _mustReject(_errPreferredImpl(d));
       };
 
       // The boolean engine is the verdict authority for these paths; the
@@ -1492,7 +1513,7 @@ class Validator {
         let impl = null;
         const onReject = (data) => {
           const combined = combinedIfSafe();
-          if (combined) { impl = combined; return combined(data); }
+          if (combined) { impl = combined; return _mustReject(combined(data)); }
           return errOnly(data);
         };
         const hybridFn = jsFn._hybridFactory(VALID_RESULT, onReject);
@@ -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
@@ -1771,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;
@@ -1831,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));
@@ -1962,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
@@ -2033,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;
@@ -2049,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
@@ -2072,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;
@@ -2088,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
@@ -2205,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;
@@ -2213,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
@@ -2615,6 +2666,229 @@ Object.defineProperty(Validator.prototype, "~standard", {
   },
 });
 
+// The error resolvers run only after a verdict function has said no. If one
+// answers valid anyway, two generators disagree, and the verdict is the one
+// to keep: returning the resolver's answer is how a vacuous combined function
+// turned a rejection into an acceptance in validateJSON. The disagreement is
+// reported as a generic failure rather than hidden.
+const _VERDICT_DISAGREES = Object.freeze({
+  valid: false,
+  errors: Object.freeze([Object.freeze({ keyword: 'validation', instancePath: '', schemaPath: '#', params: Object.freeze({}), message: 'schema validation failed' })]),
+});
+function _mustReject(r) {
+  return r && r.valid === false ? r : _VERDICT_DISAGREES;
+}
+
+// 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,
@@ -2660,13 +2934,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

@@ -968,6 +968,23 @@ function hasNestedIdScope(node, isRoot = true) {
 // only safe way out.
 const DECLINE = Symbol('ata.decline')
 
+// The error and combined generators compile the subschemas of not, if, contains
+// and their anyOf/oneOf closures with the boolean generator. That generator
+// follows a reference back to the root with `_validate` and a reference cycle
+// with a named function in its preamble, and neither exists inside the other
+// two generators' functions: the first threw a ReferenceError on the first
+// document that reached it, and the second cut the cycle, so the reference
+// checked nothing. While `nestedBoolean` is set, genCode declines at those
+// points instead, and the caller's generator declines the schema.
+function nestedGenCode(schema, v, lines, ctx) {
+  ctx.nestedBoolean = (ctx.nestedBoolean || 0) + 1
+  try {
+    genCode(schema, v, lines, ctx)
+  } finally {
+    ctx.nestedBoolean--
+  }
+}
+
 const CYCLE_DEPTH = 512
 
 // Declarations the guarded functions close over. Emitted once, ahead of them.
@@ -1567,7 +1584,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 +1594,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 +1633,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 +1706,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 +1733,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]
@@ -1852,6 +1895,7 @@ function genCode(schema, v, lines, ctx, knownType) {
   if (schema.$ref) {
     // Self-reference "#" — recursive call to root validator
     if (schema.$ref === '#') {
+      if (ctx.nestedBoolean) throw DECLINE
       ctx.usesRecursion = true
       lines.push(`if(!_validate(${v}))return false`)
       if (!hasSiblings) return
@@ -1894,7 +1938,7 @@ function genCode(schema, v, lines, ctx, knownType) {
         }
         lines.push(`if(!${fnName}(${v}))return false`)
         if (!hasSiblings) return
-      } else if (ctx.refStack.has(schema.$ref)) { if (!hasSiblings) return }
+      } else if (ctx.refStack.has(schema.$ref)) { if (ctx.nestedBoolean) throw DECLINE; if (!hasSiblings) return }
       else {
         ctx.refStack.add(schema.$ref)
         genCode(ctx.rootDefs[defName], v, lines, ctx, knownType)
@@ -1906,7 +1950,7 @@ function genCode(schema, v, lines, ctx, knownType) {
       const entry = ctx.rootDefs && ctx.rootDefs[schema.$ref]
       const anchorTarget = entry && entry.raw ? entry.raw : (ctx.anchors && ctx.anchors[schema.$ref])
       if (anchorTarget) {
-        if (ctx.refStack.has(schema.$ref)) { if (!hasSiblings) return }
+        if (ctx.refStack.has(schema.$ref)) { if (ctx.nestedBoolean) throw DECLINE; if (!hasSiblings) return }
         else {
           ctx.refStack.add(schema.$ref)
           genCode(anchorTarget, v, lines, ctx, knownType)
@@ -1949,11 +1993,13 @@ function genCode(schema, v, lines, ctx, knownType) {
       const target = ctx.anchors[anchorKey]
       if (target === ctx.rootSchema) {
         // Self-recursive: generate _validate(v) call
+        if (ctx.nestedBoolean) throw DECLINE
         ctx.usesRecursion = true
         lines.push(`if(!_validate(${v}))return false`)
       } else {
         // Different schema: inline the target validation
         const refKey = '$dynamicRef:' + anchorKey
+        if (ctx.refStack.has(refKey) && ctx.nestedBoolean) throw DECLINE
         if (!ctx.refStack.has(refKey)) {
           ctx.refStack.add(refKey)
           genCode(target, v, lines, ctx, knownType)
@@ -3147,8 +3193,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 +3570,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)
@@ -4124,7 +4198,7 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   if (schema.contains !== undefined) {
     const ci = ctx.varCounter++
     const subLines = []
-    genCode(schema.contains, `_cv`, subLines, ctx)
+    nestedGenCode(schema.contains, `_cv`, subLines, ctx)
     const fnBody = subLines.length === 0 ? `return true` : `${subLines.join(';')};return true`
     const minC = schema.minContains !== undefined ? schema.minContains : 1
     const maxC = schema.maxContains
@@ -4156,7 +4230,7 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   // not
   if (schema.not !== undefined) {
     const subLines = []
-    genCode(schema.not, '_nv', subLines, ctx)
+    nestedGenCode(schema.not, '_nv', subLines, ctx)
     const nfn = subLines.length === 0 ? `function(_nv){return true}` : `function(_nv){${subLines.join(';')};return true}`
     const fi = ctx.varCounter++
     lines.push(`{const _nf${fi}=${nfn};if(_nf${fi}(${v})){${fail('not', 'not', '{}', "'must NOT be valid'")}}}`)
@@ -4165,7 +4239,7 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   // if/then/else
   if (schema.if !== undefined) {
     const ifLines = []
-    genCode(schema.if, '_iv', ifLines, ctx)
+    nestedGenCode(schema.if, '_iv', ifLines, ctx)
     const fi = ctx.varCounter++
     const ifFn = ifLines.length === 0
       ? `function(_iv){return true}`
@@ -4270,22 +4344,34 @@ function compileToJSCombined(schema, VALID_RESULT, schemaMap, userFormats) {
   const ctx = { varCounter: 0, helperCode: [], shared: [], closureVars: ['_cpLen'], closureVals: [_cpLen],
                 rootDefs: cRootDefs, refStack: new Set(), schemaMap: schemaMap || null, anchors: cAnchors, rootSchema: schema, userFormats: userFormats || null }
   const lines = []
-  genCodeC(schema, 'd', '', lines, ctx, '#')
+  try {
+    genCodeC(schema, 'd', '', lines, ctx, '#')
+  } catch (e) {
+    if (e === DECLINE) return null
+    throw e
+  }
   if (lines.length === 0) return () => VALID_RESULT
 
-  // Use factory pattern: closure vars (regexes, etc.) created once, not per call
-  const closureParams = ctx.closureVars.join(',')
-  // Lazy error array — no allocation for valid data (the common case)
+  // Use factory pattern: closure vars (regexes, etc.) created once, not per call.
+  // The helpers are constants too and are declared in the factory: inside the
+  // function they were rebuilt on every call. `__ataSafeRe` is bound when a
+  // helper compiles a pattern through it, which the boolean generator does for
+  // subschemas under not/if/contains; without the binding those threw a
+  // ReferenceError on the first document that reached them.
+  const closureNames = ctx.usesSafeRe ? [...ctx.closureVars, '__ataSafeRe'] : ctx.closureVars
+  const closureArgs = ctx.usesSafeRe ? [...ctx.closureVals, compileSafe] : ctx.closureVals
+  const closureParams = closureNames.join(',')
+  const helpers = ctx.helperCode.length ? ctx.helperCode.join('\n  ') + '\n  ' : ''
+  // Lazy error array: no allocation for valid data (the common case)
   const inner = `let _e;\n  ` +
-    (ctx.helperCode.length ? ctx.helperCode.join('\n  ') + '\n  ' : '') +
     lines.join('\n  ') +
     `\n  return _e?{valid:false,errors:_e}:R`
 
   try {
-    if (typeof process !== 'undefined' && process.env && process.env.ATA_DUMP_CODEGEN) console.log('=== COMBINED CODEGEN ===\n' + inner + '\n=== CLOSURE VARS: ' + ctx.closureVars.length + ' ===')
+    if (typeof process !== 'undefined' && process.env && process.env.ATA_DUMP_CODEGEN) console.log('=== COMBINED CODEGEN ===\n' + helpers + inner + '\n=== CLOSURE VARS: ' + ctx.closureVars.length + ' ===')
     const factory = new Function('R' + (closureParams ? ',' + closureParams : ''),
-      `return function(d){${inner}}`)
-    return factory(VALID_RESULT, ...ctx.closureVals)
+      `${helpers}return function(d){${inner}}`)
+    return factory(VALID_RESULT, ...closureArgs)
   } catch (e) {
     if (typeof process !== 'undefined' && process.env && process.env.ATA_DEBUG) console.error('compileToJSCombined error:', e.message, '\n', inner.slice(0, 500))
     return null
@@ -4357,17 +4443,17 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     const anchorKey = schema.$dynamicRef.startsWith('#') ? schema.$dynamicRef : '#' + schema.$dynamicRef
     if (ctx.anchors && ctx.anchors[anchorKey]) {
       const target = ctx.anchors[anchorKey]
-      if (target === ctx.rootSchema) {
-        // Self-recursive: bail to non-combined path (combined doesn't support named recursion)
-        // Just skip — the hybrid path will handle this via jsFn + errFn
-      } else {
-        const refKey = '$dynamicRef:' + anchorKey
-        if (!ctx.refStack.has(refKey)) {
-          ctx.refStack.add(refKey)
-          genCodeC(target, v, pathExpr, lines, ctx, schemaPrefix)
-          ctx.refStack.delete(refKey)
-        }
-      }
+      // This generator has no named functions, so it cannot follow a reference
+      // back to the root or around a cycle. It used to emit nothing in both
+      // cases, which the function then answered as valid: a document the other
+      // generators reject passed through validateJSON. It declines instead,
+      // and the schema takes the error generator.
+      if (target === ctx.rootSchema) throw DECLINE
+      const refKey = '$dynamicRef:' + anchorKey
+      if (ctx.refStack.has(refKey)) throw DECLINE
+      ctx.refStack.add(refKey)
+      genCodeC(target, v, pathExpr, lines, ctx, schemaPrefix)
+      ctx.refStack.delete(refKey)
     }
   }
 
@@ -4850,7 +4936,7 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   if (schema.contains !== undefined) {
     const ci = ctx.varCounter++
     const subLines = []
-    genCode(schema.contains, `_cv`, subLines, ctx)
+    nestedGenCode(schema.contains, `_cv`, subLines, ctx)
     const fnBody = subLines.length === 0 ? `return true` : `${subLines.join(';')};return true`
     const minC = schema.minContains !== undefined ? schema.minContains : 1
     const maxC = schema.maxContains
@@ -4866,20 +4952,20 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   // anyOf
   if (schema.anyOf) {
     const fi = ctx.varCounter++
-    const fns = schema.anyOf.map(sub => { const sl = []; genCode(sub, '_av', sl, ctx); return sl.length === 0 ? `function(_av){return true}` : `function(_av){${sl.join(';')};return true}` })
+    const fns = schema.anyOf.map(sub => { const sl = []; nestedGenCode(sub, '_av', sl, ctx); return sl.length === 0 ? `function(_av){return true}` : `function(_av){${sl.join(';')};return true}` })
     lines.push(`{const _af${fi}=[${fns.join(',')}];let _am=false;for(let _ai=0;_ai<_af${fi}.length;_ai++){if(_af${fi}[_ai](${v})){_am=true;break}}if(!_am){${fail('anyOf', 'anyOf', '{}', "'must match a schema in anyOf'")}}}`)
   }
 
   // oneOf
   if (schema.oneOf) {
     const fi = ctx.varCounter++
-    const fns = schema.oneOf.map(sub => { const sl = []; genCode(sub, '_ov', sl, ctx); return sl.length === 0 ? `function(_ov){return true}` : `function(_ov){${sl.join(';')};return true}` })
+    const fns = schema.oneOf.map(sub => { const sl = []; nestedGenCode(sub, '_ov', sl, ctx); return sl.length === 0 ? `function(_ov){return true}` : `function(_ov){${sl.join(';')};return true}` })
     lines.push(`{const _of${fi}=[${fns.join(',')}];let _oc=0;for(let _oi=0;_oi<_of${fi}.length;_oi++){if(_of${fi}[_oi](${v}))_oc++;if(_oc>1)break}if(_oc!==1){${fail('oneOf', 'oneOf', '{}', "'must match exactly one schema in oneOf'")}}}`)
   }
 
   // not
   if (schema.not !== undefined) {
-    const sl = []; genCode(schema.not, '_nv', sl, ctx)
+    const sl = []; nestedGenCode(schema.not, '_nv', sl, ctx)
     const nfn = sl.length === 0 ? `function(_nv){return true}` : `function(_nv){${sl.join(';')};return true}`
     const fi = ctx.varCounter++
     lines.push(`{const _nf${fi}=${nfn};if(_nf${fi}(${v})){${fail('not', 'not', '{}', "'must NOT be valid'")}}}`)
@@ -4887,7 +4973,7 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
 
   // if/then/else
   if (schema.if !== undefined) {
-    const sl = []; genCode(schema.if, '_iv', sl, ctx)
+    const sl = []; nestedGenCode(schema.if, '_iv', sl, ctx)
     const fi = ctx.varCounter++
     const ifFn = sl.length === 0 ? `function(_iv){return true}` : `function(_iv){${sl.join(';')};return true}`
     lines.push(`{const _if${fi}=${ifFn}`)

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.3';
+module.exports = '1.31.1';

package/package.json

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