ata-validator 1.37.1 → 1.39.1

package/README.md

@@ -32,13 +32,13 @@ npm install --save-dev ata-validator
 npx ata build 'schemas/*.json' --out-dir src/generated
 ```
 
-The `ata-validator` package itself is pure JavaScript. The native accelerator (simdjson parsing, parallel NDJSON, buffer APIs) ships as per-platform optional packages that npm installs automatically where they fit, the same pattern Vite uses for esbuild. Seven targets are built: macOS on arm64 and x64, Linux on x64 and arm64 against both glibc and musl, and Windows on x64. A platform without a prebuild still installs and validates, on the pure-JS engine. For a guaranteed zero-binary install:
+The `ata-validator` package itself is pure JavaScript. The native accelerator (simdjson parsing, parallel NDJSON, buffer APIs) ships as per-platform optional packages that npm installs automatically where they fit, the same pattern Vite uses for esbuild. Seven targets are built: macOS on arm64 and x64, Linux on x64 and arm64 against both glibc (2.17 or later, below the 2.28 Node itself needs) and musl, and Windows on x64. A platform without a prebuild still installs and validates, on the pure-JS engine. For a guaranteed zero-binary install:
 
 ```bash
 npm install ata-validator --omit=optional
 ```
 
-or set `ATA_NO_NATIVE=1` at runtime. Typical schemas compile to specialized JS; shapes the compiler cannot represent (some `$dynamicRef`, cyclic `$ref`, unusual keyword interactions) fall back to an interpreted engine, so every schema validates in every environment. The pure-JS setup scores the same on the official suite as the native one, 1301 of 1301 Draft 2020-12 cases. Only the buffer and parallel APIs (`isValid` on raw buffers, `countValid`, `batchIsValid`, `validateAndParse`) need the native engine and say so with a clear error.
+or set `ATA_NO_NATIVE=1` at runtime. Typical schemas compile to specialized JS; shapes the compiler cannot represent (some `$dynamicRef`, cyclic `$ref`, unusual keyword interactions) fall back to an interpreted engine, so every schema validates in every environment. The pure-JS setup scores the same on the official suite as the native one, 1301 of 1301 Draft 2020-12 cases. The buffer and parallel APIs (`isValid` on raw buffers, `isValidPrepadded`, `isValidNDJSON`, `isValidParallel`, `countValid`, `batchIsValid`, `validateAndParse`) work without the addon too, answering through the same checks as `isValidJSON()`, slower than the addon: 177 ns against 92 for a small document on Node 25. In a browser, which has no `Buffer`, they throw and name the methods to use instead.
 
 Those four now agree with `validate()` on every case of the official suite, 3365 across three dialects. The native walker behind them does not handle every shape (`contains`, `unevaluatedProperties`, `patternProperties`, tuple `items`, cross-document `$ref`, a few formats), so for schemas using one of those the buffer APIs parse the bytes and answer through `validate()`; the list is in `lib/buffer-gate.js`. Typical request schemas stay on the zero-copy path. `npm test` holds the disagreement count at zero.
 

package/index.d.ts

@@ -439,7 +439,8 @@ export interface ValidatorOptions {
    * answers `validate()`, `isValidObject()` and `validateJSON()`. For a schema
    * that arrives from outside the trust boundary. The verdict is the same on
    * every engine; the cost is not. The buffer APIs (`isValid`, `countValid`,
-   * `batchIsValid`) are native-only and unaffected.
+   * `batchIsValid`) use the native addon where it loads, which this option
+   * does not affect; without it they answer through the engine it picks.
    */
   engine?: 'auto' | 'interpreter';
 }

package/lib/aot-impl.js

@@ -17,7 +17,7 @@ const { compileToJSCodegenWithErrors, compileToJSCodegen, unevalContributions }
 const { buildTargetedPositionMap } = require('./data-positions');
 const { schemaHash } = require('./schema-hash');
 const ATA_VERSION = require('./version');
-const SAFE_REGEX_SOURCE = require('./safe-regex-source');
+const { engineSource: safeRegexEngineSource } = require('./safe-regex');
 
 // Embedded verbatim in standalone modules so the output file has no runtime
 // dependency on ata-validator. ASCII fast-path plus surrogate-aware slow path.
@@ -31,21 +31,16 @@ const _CP_LEN_SOURCE = `function _cpLen(s) {
   return len;
 }`;
 
-// The linear-time regex engine, inlined verbatim into standalone output so a
-// compiled module that uses safe `pattern` matchers has no runtime dependency
-// on ata-validator. The engine source is baked into `lib/safe-regex-source.js`
-// at build time (see `scripts/regen-safe-regex-source.js`), so this path has
-// no `fs`/`path`/`__dirname` reads — safe in browser bundles too. The embed
-// strips the strict directive and CommonJS exports and adds the `__ataSafeRe`
-// alias the emitted code calls. The engine has no eval/new Function, so the
+// The linear-time regex engine, embedded in standalone modules whose patterns
+// need it so the output does not depend on ata-validator at run time. The text
+// is the engine's own function (lib/safe-regex.js), called once for the
+// `__ataSafeRe` the emitted code uses. No fs, path or __dirname, so this is
+// safe in browser bundles, and the engine has no eval or new Function, so the
 // embed is CSP-safe.
 let _safeRegexEmbed = null;
 function getSafeRegexEmbed() {
   if (_safeRegexEmbed === null) {
-    const body = SAFE_REGEX_SOURCE
-      .replace(/^'use strict'\s*\n/, '')
-      .replace(/\nmodule\.exports[^\n]*\n?/, '\n');
-    _safeRegexEmbed = body.trimEnd() + '\nconst __ataSafeRe = compileSafe;';
+    _safeRegexEmbed = 'const __ataSafeRe = (' + safeRegexEngineSource() + ')().compileSafe;';
   }
   return _safeRegexEmbed;
 }
@@ -213,7 +208,18 @@ function toStandaloneModule(validator, opts) {
       (source && sourceMap && schemaFile) ? { sourceMap, schemaFile } : null,
     );
     const errSrc = jsErrFn && jsErrFn._errSource ? jsErrFn._errSource : '';
-    if (errSrc) {
+    if (errSrc && jsErrFn._errFactory) {
+      // The helpers (patterns, name sets, definition and branch functions) are
+      // built once, not on every call. With $defs the
+      // cycle guard's state sits beside them, so a call made while one is
+      // running takes a function from a fresh factory call.
+      // Built on the first error read rather than at import, so a page that
+      // only ever accepts pays nothing for them at load.
+      const fac = jsErrFn._errFactory;
+      errCore = jsErrFn._errGuarded
+        ? `const _mkErr = function() {\n  ${fac}\n};\nlet _errMain = null;\nlet _errBusy = false;\nconst errFn = function(d, _all) { if (_errBusy) return _mkErr()(d, _all); if (_errMain === null) _errMain = _mkErr(); _errBusy = true; try { return _errMain(d, _all); } finally { _errBusy = false; } };\n`
+        : `const _mkErr = function() {\n  ${fac}\n};\nlet _errMain = null;\nconst errFn = function(d, _all) { return (_errMain || (_errMain = _mkErr()))(d, _all); };\n`;
+    } else if (errSrc) {
       errCore = `const errFn = function(d, _all) {\n  ${errSrc}\n};\n`;
     } else if (opts && typeof opts.onWarning === 'function') {
       // The caller asked for error detail and is not getting it: the error

package/lib/buffer-gate.browser.js

@@ -9,5 +9,10 @@
 
 module.exports = {
   bufferNeedsSlowPath: () => false,
-  installSlowBufferApis() {},
+  // A browser build has no addon and no Buffer, and the core throws before
+  // it gets here. A polyfilled Buffer would reach this: fail loudly rather
+  // than return with the methods still uninstalled.
+  installSlowBufferApis() {
+    throw new Error('The buffer APIs are not available in the browser build. Use validate(), isValidObject() or validateJSON().');
+  },
 };

package/lib/buffer-gate.js

@@ -122,14 +122,13 @@ function toText(input, name) {
   throw new TypeError(`${name}() requires a Buffer, Uint8Array, or string. For parsed objects, use isValidObject().`);
 }
 
-// Replaces the instance's buffer APIs with versions that parse and call
-// validate(). Installed after compilation, so `validator.validate` is final.
+// Replaces the instance's buffer APIs with versions that decode the bytes and
+// ask isValidJSON(), which answers as validate() does on the parsed value and
+// reads text the scanner covers without parsing it (a small document went from
+// 350 to 155 ns without the addon). Its own native route is behind this same
+// gate, so a schema routed here never reaches the walker through it.
 function installSlowBufferApis(validator) {
-  const isValidText = (text) => {
-    let value;
-    try { value = JSON.parse(text); } catch { return false; }
-    return validator.validate(value).valid;
-  };
+  const isValidText = (text) => validator.isValidJSON(text);
   validator.isValid = (input) => isValidText(toText(input, 'isValid'));
   validator.isValidPrepadded = (paddedBuffer, jsonLength) =>
     isValidText(Buffer.from(paddedBuffer.buffer, paddedBuffer.byteOffset, jsonLength).toString('utf8'));

package/lib/enrich-error.js

@@ -233,8 +233,10 @@ function enrich (rawErr, opts) {
   if ('schema' in rawErr) out.schema = rawErr.schema;
 
   // oneOf/anyOf collapse: preserve the nested branch errors so the pretty
-  // renderer can surface the closest variant's diagnostics.
-  if (rawErr.branchErrors) out.branchErrors = rawErr.branchErrors;
+  // renderer can surface the closest variant's diagnostics. They are enriched
+  // like any other error: passed through raw, they carried whatever the engine
+  // that answered wrote, the generator's internal ordering key included.
+  if (rawErr.branchErrors) out.branchErrors = rawErr.branchErrors.map((b) => enrich(b, data !== undefined ? { data } : null));
 
   if (positions && positions[path]) {
     const p = positions[path];