ata-validator 1.61.3 → 1.62.0

package/lib/stream.js

@@ -0,0 +1,293 @@
+'use strict';
+
+// Validation as the body arrives. A request that carries many documents, a
+// JSON array or NDJSON, is today read to the end, parsed as a whole and then
+// validated, so a bad third record is reported after the last byte: on a
+// 100 MB upload that is half a second and 500 to 800 MB of memory before the
+// caller hears "record 2, email". Here each record is validated the moment
+// its last byte lands, so the same upload is refused after 100 KB, in
+// milliseconds, with memory that does not grow with the body. Measured in
+// the commit that added this: 517 ms and 783 MB to 6 ms and 114 MB for an
+// early failure; the late failure costs the same time with a third of the
+// memory.
+//
+// The splitting reads the text once and parses nothing it does not have to.
+// NDJSON is split at newlines. A JSON array is split by a scan that tracks
+// strings and nesting depth and hands out each top-level element; inside a
+// string it jumps to the next quote with indexOf and counts the backslashes
+// before it, so string bodies, most of a document's bytes, cost no branch
+// per character. Each element is then parsed and validated on its own, by
+// the validator's own verdict and, when it fails, its own error list.
+
+const PARSE_KEYWORD = '__parse__';
+
+// A record's failure as the stream reports it: the record's index from zero
+// and the errors validate() would give for that document, or the parse
+// error in the shape validateJSON() uses for a document that is not JSON.
+function failure (record, errors) {
+  return { valid: false, record, errors };
+}
+function parseFailure (record, message) {
+  return failure(record, [{ keyword: PARSE_KEYWORD, instancePath: '', schemaPath: '', params: {}, message: 'invalid JSON: ' + message }]);
+}
+
+// The decoder for byte chunks: a multi-byte character split across two
+// chunks is completed by the next one. Strings pass through untouched.
+function decoderFor () {
+  const d = typeof TextDecoder === 'function' ? new TextDecoder('utf-8') : null;
+  return (chunk, last) => {
+    if (typeof chunk === 'string') return chunk;
+    if (d === null) return Buffer.from(chunk).toString('utf8');
+    return d.decode(chunk, { stream: !last });
+  };
+}
+
+// The end of the string that opens at `from` (the index after the quote), or
+// -1 when the chunk ends first. A quote preceded by an odd number of
+// backslashes is escaped.
+function stringEnd (s, from) {
+  let i = from;
+  for (;;) {
+    const q = s.indexOf('"', i);
+    if (q < 0) return -1;
+    let bs = 0;
+    for (let k = q - 1; k >= from && s.charCodeAt(k) === 92; k--) bs++;
+    if ((bs & 1) === 0) return q;
+    i = q + 1;
+  }
+}
+
+function isSpace (c) { return c === 32 || c === 10 || c === 13 || c === 9; }
+
+/**
+ * A record stream over one validator. `push(chunk)` takes a string, Buffer or
+ * Uint8Array and returns null while every record so far is valid, or the
+ * first failure as soon as a record fails (and the stream is then done).
+ * `end()` closes the input and returns `{ valid, records, errors }`, where
+ * `errors` lists every failure seen (one, unless `stopOnFirst` is false).
+ */
+class RecordStream {
+  constructor (validator, opts) {
+    this._v = validator;
+    this._format = (opts && opts.format) || 'auto';
+    this._stop = !(opts && opts.stopOnFirst === false);
+    this._onRecord = (opts && typeof opts.onRecord === 'function') ? opts.onRecord : null;
+    this._decode = decoderFor();
+    this._buf = '';
+    this._pos = 0;        // scan position in _buf
+    this._start = -1;     // where the element in progress begins, array form
+    this._depth = 0;      // nesting inside the current element, array form
+    this._opened = false; // the outer '[' has been read
+    this._closed = false; // the outer ']' has been read
+    this._expectValue = true; // array form: a value may start here (after '[' or ',')
+    this.records = 0;
+    this.failures = [];
+    this.done = false;
+    this.result = null;
+  }
+
+  // One record's text: parse, validate, report. Returns the failure or null.
+  _record (text) {
+    const index = this.records++;
+    let doc;
+    try { doc = JSON.parse(text); } catch (e) { return this._fail(parseFailure(index, e.message)); }
+    if (this._v.isValidObject(doc)) {
+      if (this._onRecord !== null) this._onRecord(doc, index);
+      return null;
+    }
+    const r = this._v.validate(doc);
+    return this._fail(failure(index, r.valid ? [] : r.errors));
+  }
+
+  _fail (f) {
+    this.failures.push(f);
+    if (this._stop) { this.done = true; this.result = { valid: false, records: this.records, errors: this.failures }; }
+    return f;
+  }
+
+  push (chunk) {
+    if (this.done) return this.failures.length ? this.failures[0] : null;
+    const text = this._decode(chunk, false);
+    if (text.length === 0) return null;
+    this._buf += text;
+    if (this._format === 'auto') {
+      let i = 0;
+      while (i < this._buf.length && isSpace(this._buf.charCodeAt(i))) i++;
+      if (i === this._buf.length) return null;
+      this._format = this._buf.charCodeAt(i) === 91 ? 'array' : 'ndjson';
+    }
+    return this._format === 'array' ? this._scanArray() : this._scanLines();
+  }
+
+  _scanLines () {
+    const s = this._buf;
+    let from = 0;
+    for (;;) {
+      const nl = s.indexOf('\n', from);
+      if (nl < 0) break;
+      let end = nl;
+      if (end > from && s.charCodeAt(end - 1) === 13) end--;
+      const line = s.slice(from, end);
+      from = nl + 1;
+      if (line.trim().length === 0) continue;
+      const f = this._record(line);
+      if (f !== null && this.done) { this._buf = ''; return f; }
+    }
+    this._buf = from === 0 ? s : s.slice(from);
+    return null;
+  }
+
+  _scanArray () {
+    const s = this._buf;
+    const n = s.length;
+    let pos = this._pos;
+    while (pos < n) {
+      const c = s.charCodeAt(pos);
+      if (!this._opened) {
+        if (isSpace(c)) { pos++; continue; }
+        if (c !== 91) return this._syntax('a JSON array must start with "["');
+        this._opened = true; pos++; continue;
+      }
+      if (this._closed) {
+        if (isSpace(c)) { pos++; continue; }
+        return this._syntax('unexpected text after the closing "]"');
+      }
+      if (this._start < 0) {
+        // Between elements: whitespace, a comma, the closing bracket, or the
+        // first character of a value.
+        if (isSpace(c)) { pos++; continue; }
+        if (c === 93) {
+          if (this._expectValue && this.records > 0) return this._syntax('a trailing comma before "]"');
+          this._closed = true; pos++; continue;
+        }
+        if (c === 44) {
+          if (this._expectValue) return this._syntax('two commas with no value between');
+          this._expectValue = true; pos++; continue;
+        }
+        if (!this._expectValue) return this._syntax('a value with no comma before it');
+        this._start = pos;
+        if (c === 34) {
+          const q = stringEnd(s, pos + 1);
+          if (q < 0) break; // the string continues in the next chunk
+          pos = q + 1;
+          const f = this._emit(s.slice(this._start, pos));
+          if (f !== null) return f;
+          continue;
+        }
+        if (c === 123 || c === 91) { this._depth = 1; pos++; continue; }
+        pos++; continue; // a scalar: it runs to a delimiter
+      }
+      if (this._depth === 0) {
+        // A scalar in progress ends at whitespace, a comma or the bracket,
+        // which the next round reads.
+        if (isSpace(c) || c === 44 || c === 93) {
+          const f = this._emit(s.slice(this._start, pos));
+          if (f !== null) return f;
+          continue;
+        }
+        pos++; continue;
+      }
+      // Inside an object or array element.
+      if (c === 34) {
+        const q = stringEnd(s, pos + 1);
+        if (q < 0) break;
+        pos = q + 1; continue;
+      }
+      if (c === 123 || c === 91) { this._depth++; pos++; continue; }
+      if (c === 125 || c === 93) {
+        this._depth--; pos++;
+        if (this._depth === 0) {
+          const f = this._emit(s.slice(this._start, pos));
+          if (f !== null) return f;
+        }
+        continue;
+      }
+      pos++;
+    }
+    // Keep only the element in progress, or nothing.
+    if (this._start >= 0) { this._buf = s.slice(this._start); this._pos = pos - this._start; this._start = 0; }
+    else { this._buf = ''; this._pos = 0; }
+    return null;
+  }
+
+  _syntax (message) {
+    this._buf = ''; this._pos = 0; this.done = true;
+    return this._fail(parseFailure(this.records, message));
+  }
+
+  _emit (text) {
+    this._start = -1; this._depth = 0; this._expectValue = false;
+    const f = this._record(text);
+    if (f !== null && this.done) { this._buf = ''; this._pos = 0; return f; }
+    return null;
+  }
+
+  end () {
+    if (!this.done) {
+      const tail = this._decode(new Uint8Array(0), true);
+      if (tail) this.push(tail);
+      if (!this.done) {
+        if (this._format === 'ndjson') { if (this._buf.trim().length > 0) this._record(this._buf); }
+        else if (this._format === 'array') {
+          if (!this._opened) this._fail(parseFailure(this.records, 'no JSON array in the input'));
+          else if (this._start >= 0 || !this._closed) this._fail(parseFailure(this.records, 'the array is not closed'));
+        }
+      }
+      this.done = true;
+    }
+    this._buf = '';
+    this.result = { valid: this.failures.length === 0, records: this.records, errors: this.failures };
+    return this.result;
+  }
+}
+
+function streamValidator (validator, opts) { return new RecordStream(validator, opts); }
+
+// A Node http request (http.IncomingMessage) rather than any other Readable.
+// Destroying one at the first failure closes the socket under the response
+// the caller writes next: Node's fetch then gets `write EPIPE` and Chrome
+// "Failed to fetch", never the 400. So reading stops and the rest of the
+// body is drained and dropped; memory stays flat and the answer goes out
+// (Node's fetch read it after 24 ms and 1 MB of a 100 MB upload).
+function isHttpRequest (source) {
+  return typeof source.httpVersion === 'string' && typeof source.resume === 'function';
+}
+
+// The whole of an async source (a Node Readable, a Web ReadableStream, any
+// async iterable of chunks) through a record stream. On the first failure
+// the source is stopped: a Node stream is destroyed (a Node http request is
+// drained instead, see isHttpRequest), a Web stream's reader cancelled, an
+// iterator returned, so a failing upload is not validated to its end.
+async function validateStream (validator, source, opts) {
+  const rs = new RecordStream(validator, opts);
+  if (source && typeof source.getReader === 'function') {
+    const reader = source.getReader();
+    try {
+      for (;;) {
+        const { value, done } = await reader.read();
+        if (done) break;
+        const f = rs.push(value);
+        if (f !== null && rs.done) { await reader.cancel('ata: record ' + f.record + ' is invalid'); return rs.end(); }
+      }
+    } finally { reader.releaseLock(); }
+    return rs.end();
+  }
+  const request = isHttpRequest(source);
+  // A request's iterator must leave the stream alive when returned.
+  const it = request && typeof source.iterator === 'function' ? source.iterator({ destroyOnReturn: false })
+    : source[Symbol.asyncIterator] ? source[Symbol.asyncIterator]() : source[Symbol.iterator]();
+  for (;;) {
+    const { value, done } = await it.next();
+    if (done) break;
+    const f = rs.push(value);
+    if (f !== null && rs.done) {
+      if (request) { if (typeof it.return === 'function') await it.return(); source.resume(); }
+      else if (typeof source.destroy === 'function') source.destroy();
+      else if (typeof it.return === 'function') await it.return();
+      return rs.end();
+    }
+  }
+  return rs.end();
+}
+
+module.exports = { RecordStream, streamValidator, validateStream, PARSE_KEYWORD };

package/lib/tier0.js

@@ -55,8 +55,12 @@ const _PN = typeof Bun === 'undefined' && ({}).__proto__ === Object.prototype; /
 function formatFnOf(propSchema, userFormats) {
   const f = propSchema.format;
   if (typeof f !== 'string') return null;
-  if (userFormats && typeof userFormats[f] === 'function') return userFormats[f];
-  return require('./formats').formatChecks()[f] || null;
+  // Own properties only: `format: 'constructor'` or '__proto__' read an
+  // inherited Object member and called it as a check, or threw.
+  const own = Object.prototype.hasOwnProperty;
+  if (userFormats && own.call(userFormats, f) && typeof userFormats[f] === 'function') return userFormats[f];
+  const fc = require('./formats').formatChecks();
+  return own.call(fc, f) && typeof fc[f] === 'function' ? fc[f] : null;
 }
 
 function primConstraint(key, propSchema, userFormats) {

package/lib/ts-gen.js

@@ -104,25 +104,30 @@ function renderObject(schema, defs, depth) {
     }
     return 'Record<string, unknown>';
   }
-  const lines = keys.map((k) => {
-    const t = renderValueType(props[k], defs, depth + 1);
+  // Each property's type is rendered once and the index signature below
+  // reuses the text; rendering it again there doubled the work per level.
+  const types = keys.map((k) => renderValueType(props[k], defs, depth + 1));
+  const lines = keys.map((k, i) => {
     const opt = required.has(k) ? '' : '?';
     const safeKey = /^[A-Za-z_$][\w$]*$/.test(k) ? k : JSON.stringify(k);
     const doc = renderJsDoc(props[k], '  ');
-    return `${doc}  ${safeKey}${opt}: ${t};`;
+    return `${doc}  ${safeKey}${opt}: ${types[i]};`;
   });
   // extra keys when additionalProperties is present as a schema or true
   const extra = schema.additionalProperties;
   if (extra && typeof extra === 'object') {
     // TypeScript requires the index signature to be a supertype of every
     // named property's emitted type. Widen to a union covering each property
-    // type, plus undefined when any property is optional.
+    // type, plus undefined when any property is optional. A property whose
+    // type is an object literal is not repeated in the union: with one at
+    // every level the output doubled per level (2^levels characters) and a
+    // 22-level chain did not finish. `unknown` covers it.
     const widen = new Set();
     widen.add(renderValueType(extra, defs, depth + 1));
     let hasOptional = false;
-    for (const k of keys) {
-      widen.add(renderValueType(props[k], defs, depth + 1));
-      if (!required.has(k)) hasOptional = true;
+    for (let i = 0; i < keys.length; i++) {
+      widen.add(types[i].includes('{') ? 'unknown' : types[i]);
+      if (!required.has(keys[i])) hasOptional = true;
     }
     if (hasOptional) widen.add('undefined');
     const indexType = widen.has('unknown') ? 'unknown' : Array.from(widen).join(' | ');
@@ -154,12 +159,20 @@ function toTypeName(name) {
 // constraints the TypeScript type cannot express (minLength, format, range,
 // etc.). Editors and TypeDoc surface these on hover, so authors can see what
 // the schema requires even though tsc does not enforce it.
+// Text from the schema inside a block comment: a `*/` in a pattern, a format,
+// a default or an example closed the comment and the rest of the value was
+// read as a declaration. The slash is escaped, which a comment reader shows
+// as written.
+function commentSafe(s) {
+  return String(s).replace(/\*\//g, '*\\/');
+}
+
 function renderJsDoc(schema, indent) {
   if (!schema || typeof schema !== 'object') return '';
 
   let description = '';
   if (typeof schema.description === 'string' && schema.description.length > 0) {
-    description = schema.description.replace(/\*\//g, '* /');
+    description = commentSafe(schema.description);
   }
 
   const tags = [];
@@ -168,15 +181,15 @@ function renderJsDoc(schema, indent) {
   for (const k of numKeys) {
     if (typeof schema[k] === 'number') tags.push(`@${k} ${schema[k]}`);
   }
-  if (typeof schema.pattern === 'string') tags.push(`@pattern ${schema.pattern}`);
-  if (typeof schema.format === 'string') tags.push(`@format ${schema.format}`);
+  if (typeof schema.pattern === 'string') tags.push(`@pattern ${commentSafe(schema.pattern)}`);
+  if (typeof schema.format === 'string') tags.push(`@format ${commentSafe(schema.format)}`);
   if (schema.uniqueItems === true) tags.push('@uniqueItems');
   if (schema.deprecated === true) tags.push('@deprecated');
   if (schema.default !== undefined) {
-    try { tags.push(`@default ${JSON.stringify(schema.default)}`); } catch (_) {}
+    try { tags.push(`@default ${commentSafe(JSON.stringify(schema.default))}`); } catch (_) {}
   }
   if (Array.isArray(schema.examples) && schema.examples.length > 0) {
-    try { tags.push(`@example ${JSON.stringify(schema.examples[0])}`); } catch (_) {}
+    try { tags.push(`@example ${commentSafe(JSON.stringify(schema.examples[0]))}`); } catch (_) {}
   }
 
   if (description === '' && tags.length === 0) return '';

package/lib/unique-items.js

@@ -10,8 +10,8 @@
 // primitives key a Set or Map by the value itself. Longer arrays that hold an
 // object key a Map by a numeric structural hash, and only items whose hashes
 // collide are compared with `_deq`. Equal values always hash alike: numbers
-// by value (so 1 and 1.0, 0 and -0 agree), strings by their characters,
-// arrays by position, and objects by the sum of their own key-value hashes,
+// by their bits, with 0 and -0 as one (1 and 1.0 are one double already),
+// strings by their characters, arrays by position, and objects by the sum of their own key-value hashes,
 // whatever the key order. The hash replaced a sorted-key canonical string
 // built for every item on every call, which was over a quarter of the time a
 // generated verdict spent on SchemaStore's sample documents.
@@ -55,7 +55,15 @@ function _uqh(x) {
   if (t === 'number') {
     if (x === 0) return 4;
     h = x | 0;
-    return Math.imul(h ^ (((x - h) * 1e9) | 0), 0x9e3779b1) ^ 5;
+    if (h === x) return Math.imul(h, 0x9e3779b1) ^ 5;
+    // Every bit of the number goes into the hash, read through a typed
+    // array kept on the function (its source is emitted into modules, so
+    // nothing outside it is read). Nine decimal places, which this used to
+    // keep, hashed every number below 1e-9 alike, and an array of them was
+    // compared item against item.
+    var f = _uqh.f || (_uqh.f = new Float64Array(1)), w = _uqh.w || (_uqh.w = new Uint32Array(f.buffer));
+    f[0] = x;
+    return Math.imul(w[0] ^ Math.imul(w[1], 0x9e3779b1), 0x85ebca6b) ^ 5;
   }
   if (t === 'string') {
     h = 0x811c9dc5 ^ x.length;

package/lib/validator-core.js

@@ -76,6 +76,11 @@ function buildDefaultsApplier(schema) {
   return _defaults.buildDefaultsApplier(schema);
 }
 
+// The preprocess passes act on own properties only; what the document
+// inherits is not part of it, and a value found through the prototype belongs
+// to some other object.
+const _hasOwn = Object.prototype.hasOwnProperty;
+
 // Build a function that coerces property values to match schema types in-place.
 // Handles string→number, string→integer, string→boolean, number→string, boolean→string.
 function buildCoercer(schema) {
@@ -109,7 +114,9 @@ function buildNodeCoercer(schema, seen) {
       if (!c) continue;
       const { scalar, inner } = c;
       steps.push((o) => {
-        if (!(key in o)) return;
+        // Own properties only: `key in o` found values the object inherits,
+        // and the pass then rewrote the shared object behind them.
+        if (!_hasOwn.call(o, key)) return;
         if (scalar) {
           const v = scalar(o[key]);
           if (v !== undefined) o[key] = v;
@@ -211,7 +218,9 @@ function collectRemovals(schema, actions, path) {
       actions.push((data) => {
         let target = data;
         for (let j = 0; j < parentPath.length; j++) {
-          if (typeof target !== "object" || target === null) return;
+          // Own keys only: a nested object the document inherits is not part
+          // of it, and deleting from it would strip a shared object.
+          if (typeof target !== "object" || target === null || !_hasOwn.call(target, parentPath[j])) return;
           target = target[parentPath[j]];
         }
         if (
@@ -386,6 +395,11 @@ function _jsonSyntaxRejection(e) {
 
 function createPaddedBuffer(jsonStr) {
   if (typeof Buffer === 'undefined') throw new Error('createPaddedBuffer requires Node.js Buffer');
+  // JSON text only. Buffer.from takes an array-like too, so { length: 1e8 }
+  // allocated a hundred million zero bytes and called that the document.
+  if (typeof jsonStr !== 'string' && !(jsonStr instanceof Uint8Array)) {
+    throw new TypeError('createPaddedBuffer expects a string or a Uint8Array (Buffer) of JSON text');
+  }
   const jsonBuf = Buffer.from(jsonStr);
   const padded = Buffer.allocUnsafe(jsonBuf.length + SIMDJSON_PADDING);
   jsonBuf.copy(padded);
@@ -832,10 +846,11 @@ class Validator {
     // and previously invalid data validates. `true` throws here, at
     // construction, with every finding; `'log'` reports through
     // `options.logger` or the console and continues. The check runs on the
-    // schema as written, before any normalization touches it.
+    // schema as written, before any normalization touches it. A schema given
+    // as JSON text is parsed first: the string itself has no keywords.
     if (options.strictSchema === true || options.strictSchema === 'log') {
       const { checkSchemaStrict } = require('./strict-check');
-      const problems = checkSchemaStrict(schema, { userKeywords: options.keywords || null });
+      const problems = checkSchemaStrict(typeof schema === 'string' ? JSON.parse(schema) : schema, { userKeywords: options.keywords || null });
       if (problems.length > 0) {
         const text = problems.map((x) => `strict mode: ${x.message} at ${x.path}`).join('\n');
         if (options.strictSchema === true) {
@@ -1586,7 +1601,7 @@ class Validator {
     // 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);
+      this._entryExt = _jsonEntryWrappers(this, _vx);
       for (const name of ['validateJSON', 'isValidJSON', 'validateAndParse']) {
         if (Object.prototype.hasOwnProperty.call(this, name) && typeof this[name] === 'function') _bindEntry(this, name, this[name]);
       }
@@ -1605,34 +1620,13 @@ class Validator {
     return this._engine || 'interpreter';
   }
 
+  // The native engine's compiled schema and fast slot, set up on the first
+  // buffer call. lib/native-attach.js; the browser build maps it to a stub,
+  // since there is no addon there.
   _ensureNative() {
     if (this._nativeReady) return;
     this._nativeReady = true;
-    const native = getNative();
-    if (!native) return;
-    if (!this._schemaStr) this._schemaStr = JSON.stringify(this._schemaObj);
-    let nativeSchemaStr = this._schemaStr;
-    // A boolean root references nothing, so the registry has nowhere to go and
-    // is left out; merging it used to throw on `true` and `false`.
-    if (this._schemaMap.size > 0 && typeof this._schemaObj === 'object' && this._schemaObj !== null) {
-      const merged = JSON.parse(this._schemaStr);
-      if (!merged.$defs) merged.$defs = {};
-      for (const [id, s] of this._schemaMap) {
-        merged.$defs['__ext_' + id.replace(/[^a-zA-Z0-9]/g, '_')] = s;
-      }
-      nativeSchemaStr = JSON.stringify(merged);
-    }
-    this._compiled = new native.CompiledSchema(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;
-    }
+    require('./native-attach.js')(this, getNative());
   }
 
   // The buffer APIs, installed on the first call to any of them. The schema
@@ -1653,33 +1647,7 @@ class Validator {
     if (!native && typeof Buffer === 'undefined') throw new Error(`Native addon required for ${name}(). Use validate(), isValidObject() or validateJSON(), which do not need it.`);
     const { bufferNeedsSlowPath, installSlowBufferApis } = require('./buffer-gate.js');
     if (!native) return installSlowBufferApis(this);
-    if (bufferNeedsSlowPath(this._schemaObj, this._schemaMap, this._keywords)) return installSlowBufferApis(this);
-    this._ensureNative();
-    const slot = this._fastSlot;
-    if (!(slot >= 0)) return installSlowBufferApis(this);
-    const bytes = (b, who) => {
-      if (typeof b === 'string') return Buffer.from(b);
-      if (b instanceof Uint8Array) return b;
-      throw new TypeError(`${who}() requires a Buffer, Uint8Array, or string. For parsed objects, use isValidObject().`);
-    };
-    this.isValid = (b) => native.rawFastValidate(slot, bytes(b, 'isValid'));
-    this.isValidPrepadded = (paddedBuffer, jsonLength) => native.rawFastValidate(slot, paddedBuffer, jsonLength);
-    this.isValidParallel = (b) => native.rawParallelValidate(slot, bytes(b, 'isValidParallel'));
-    this.isValidNDJSON = (b) => native.rawNDJSONValidate(slot, bytes(b, 'isValidNDJSON'));
-    this.countValid = (b) => {
-      const r = native.rawNDJSONValidate(slot, bytes(b, 'countValid'));
-      let n = 0;
-      for (let i = 0; i < r.length; i++) if (r[i]) n++;
-      return n;
-    };
-    this.batchIsValid = (buffers) => {
-      let n = 0;
-      for (const b of buffers) {
-        if (!(b instanceof Uint8Array)) throw new TypeError('batchIsValid() requires Buffer or Uint8Array elements');
-        if (native.rawFastValidate(slot, b)) n++;
-      }
-      return n;
-    };
+    require('./native-attach.js').installFast(this, native, bufferNeedsSlowPath, installSlowBufferApis);
   }
 
   addSchema(schema) {
@@ -1696,6 +1664,10 @@ class Validator {
     const normalized = _normalizeCallerSchema(schema, rootIsDraft7)
     this._ownSchemaMap()
     this._schemaMap.set(normalized.$id, normalized)
+    // An interpreted twin built for the first calls (lib/codegen-engine.js
+    // coldTwin) carries the registry as it was; the next call builds one
+    // from the registry as it is now.
+    if (this._twin !== undefined) this._twin = undefined
   }
 
   // buildSchemaMap hands the same map to every validator built from the same
@@ -1754,23 +1726,38 @@ class Validator {
     v._preprocess = preprocess;
 
     // Error function — use pre-compiled from standalone if available, else compile
-    let errFn = (d) => ({
+    const stub = (d) => ({
       valid: false,
       errors: [
         { code: "validation_failed", path: "", message: "validation failed" },
       ],
     });
+    let errFn = stub;
     if (mod.errFn) {
       errFn = (d) => mod.errFn(d, true);
     } else if (compileToJSCodegenWithErrors !== undefined) {
       // Without the code generator (the edge entry) a module that carries no
-      // error function reports the stub above.
-      const jsErrFn = compileToJSCodegenWithErrors(schemaObj);
+      // error function reports the stub above. The function is compiled from
+      // the schema as the runtime reads it, normalized, with the registry and
+      // the caller's formats: compiled from the schema as written, a draft-04
+      // boolean exclusiveMinimum was an annotation and the function said
+      // valid. It only explains a rejection: the module's verdict stands, so
+      // a valid: true from here is reported as the stub, never as acceptance.
+      let jsErrFn = null;
+      try {
+        const draft = schemaObj && typeof schemaObj === 'object' ? draftCode(schemaObj.$schema) : 0;
+        const normalized = _normalizeCallerSchema(schemaObj, 0);
+        const map = buildSchemaMap(options.schemas, draft);
+        jsErrFn = compileToJSCodegenWithErrors(normalized, map && map.size > 0 ? map : null, options.formats || null);
+        if (jsErrFn) jsErrFn({}, true);
+      } catch {
+        jsErrFn = null;
+      }
       if (jsErrFn) {
-        try {
-          jsErrFn({}, true);
-          errFn = (d) => jsErrFn(d, true);
-        } catch {}
+        errFn = (d) => {
+          const r = jsErrFn(d, true);
+          return r && r.valid === false ? r : stub(d);
+        };
       }
     }
 
@@ -2083,8 +2070,16 @@ function _bindEntry(self, name, 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));
+// The check sees the document the schema checked: the parsed text after the
+// preprocess pass (defaults, coercion, removal). Checking the raw text let a
+// default the check rejects through.
+function _jsonEntryWrappers(self, { check, errors }) {
+  const parse = (text) => {
+    const data = JSON.parse(typeof text === 'string' ? text : new TextDecoder().decode(text));
+    const pre = self._preprocess;
+    if (pre !== null && pre !== undefined) pre(data);
+    return data;
+  };
   return {
     validateJSON: (inner) => (text) => {
       const res = inner(text);