ata-validator 1.42.0 → 1.44.0

package/README.md

@@ -244,21 +244,21 @@ is the most common way to get a misleading number out of this library.
 
 | | compiled with `ata build` | runtime `new Validator(schema)` |
 |---|---|---|
-| In a bundle, gzipped | **2.2 KB** | 95.6 KB |
-| Time to a served request | **3.5 ms** | 7.8 ms |
+| In a bundle, gzipped | **2.1 KB** | 110.7 KB |
+| Time to a served request | **3.5 ms** | 8.2 ms |
 | Schema known when | build time | any time |
 
 The bundle row is the ten-field user schema in
 `tests/fixtures/error-dx/user.schema.json`, every export of the compiled module against
-`new Validator(schema)`, built with `bun build --minify --target=browser` on ata 1.36.0.
-The startup row is a Hono route on Bun 1.4, median of nine interleaved runs, from
-`benchmark/bundle`, against 3.5 ms for the same app doing no validation at all, so the
+`new Validator(schema)`, built with `bun build --minify --target=browser` on ata 1.43.0.
+The startup row is a Hono route on Bun 1.4, the median of three rounds of best-of-seven, from
+`benchmark/bundle`, against 3.4 ms for the same app doing no validation at all, so the
 compiled path costs nothing measurable to start. The runtime figure is what it is because
 a schema that arrives at run time can use any keyword, so the whole engine has to be
 there. The compiled module imports nothing and contains only the checks your schema asks
 for.
 
-**On a server, use whichever fits your schemas.** 96 KB of JavaScript on a Node or Bun
+**On a server, use whichever fits your schemas.** 111 KB of JavaScript on a Node or Bun
 process is not a cost anyone notices, and the runtime API is the simpler thing to reach
 for. Speed is the same either way once warm.
 
@@ -491,7 +491,7 @@ const v = new Validator(schema, {
 
 ### Build-time compile (`ata compile`)
 
-The `ata` CLI turns a JSON Schema file into a self-contained JavaScript module. No runtime dependency on `ata-validator`, so only the generated validator ships to the browser. For the ten-field user schema in `tests/fixtures/error-dx/user.schema.json` the module is 2.2 KB gzipped, full error detail included, against 95.6 KB for the runtime bundled for the browser.
+The `ata` CLI turns a JSON Schema file into a self-contained JavaScript module. No runtime dependency on `ata-validator`, so only the generated validator ships to the browser. For the ten-field user schema in `tests/fixtures/error-dx/user.schema.json` the module is 2.1 KB gzipped, full error detail included, against 110.7 KB for the runtime bundled for the browser (ata 1.43.0).
 
 ```bash
 npx ata compile schemas/user.json -o src/generated/user.validator.mjs
@@ -533,13 +533,13 @@ npx ata build 'schemas/*.json' --out-dir build/validators --check
 Run with `--watch` during development for incremental rebuilds.
 
 Bundle sizes for the 10-field user schema in `tests/fixtures/error-dx/user.schema.json`,
-minified and gzipped, measured with `bun build --minify --target=browser` on ata 1.36.0:
+minified and gzipped, measured with `bun build --minify --target=browser` on ata 1.43.0:
 
 | What the app imports | Size | Notes |
 |---|---|---|
-| `Validator` from `ata-validator` | 95.6 KB | The compiler ships with it, because a runtime schema can use any keyword |
+| `Validator` from `ata-validator` | 110.7 KB | The compiler ships with it, because a runtime schema can use any keyword |
 | `isValid` from the compiled module | **1.3 KB** | Nothing else is reachable, so the error collector is dropped |
-| `validate` from the compiled module | **2.0 KB** | Adds the detailed error collector |
+| `validate` from the compiled module | **1.9 KB** | Adds the detailed error collector |
 
 `--abort-early` makes the generated source about three times smaller, and after
 bundling it makes no difference: importing only `isValid` already leaves the error

package/index.js

@@ -434,6 +434,9 @@ function installCodegenPaths (ctx) {
     }
     return nativeText ? getNative().rawFastValidate(this._fastSlot, Buffer.from(jsonStr)) : undefined;
   };
+  // The parsed document is left on `_lastParsed` for the rich layer around
+  // validateJSON, which hands it to the rejection so reading the errors does
+  // not parse the text again (see LazyJsonRejection).
   const validateText = (jsonStr) => {
     let obj;
     try {
@@ -442,6 +445,7 @@ function installCodegenPaths (ctx) {
       if (!(e instanceof SyntaxError)) throw e;
       return _jsonSyntaxRejection(e);
     }
+    this._lastParsed = obj;
     return jsonValidateFn(obj);
   };
   this.validateJSON = useSimdjsonForLarge && !preprocess
@@ -503,7 +507,7 @@ function installCodegenPaths (ctx) {
 // The verdict function alone, for isValidObject() before a full compile: the
 // error and combined generators are left for the first rejection.
 installCodegenPaths.compileVerdict = function compileVerdict () {
-  const { compileCacheKey, _compileCache, _bindVerdict, _rememberInstance } = core._internals;
+  const { compileCacheKey, _compileCache, _compileCacheSet, _bindVerdict, _rememberInstance } = core._internals;
   if (!this._schemaStr) this._schemaStr = JSON.stringify(this._schemaObj);
   const sm = this._schemaMap.size > 0 ? this._schemaMap : null;
   const mapKey = compileCacheKey(this._schemaStr, this._schemaMap);
@@ -532,7 +536,7 @@ installCodegenPaths.compileVerdict = function compileVerdict () {
     // validator that later reuses this entry reports the same engine it
     // would have compiled to.
     if (!uf && !this._keywords) {
-      if (!cached) _compileCache.set(mapKey, { jsFn, combined: undefined, errFn: undefined, isCodegen: !!_cg, full: false });
+      if (!cached) _compileCacheSet(mapKey, { jsFn, combined: undefined, errFn: undefined, isCodegen: !!_cg, full: false });
       else cached.jsFn = jsFn;
     }
   }
@@ -878,8 +882,58 @@ function buildParse (self, decline, extended) {
 // preprocess pass, the JSON-text scanner, the parse() copy and the
 // ahead-of-time bundle methods. parse() and the bundle methods load on first
 // use.
+// Cold start. A validator's first COLD_CALLS calls are answered by an
+// interpreted twin, built from the same schema and options with
+// `engine: 'interpreter'`, which the test suite holds to the same answers and
+// errors as the generated code. Generating code and having V8 compile it is
+// the largest part of a first call on a large schema: from process start to
+// one rejection with its error read, SchemaStore's SARIF schema took 87 ms
+// with code generated at the first call and 31 ms with the twin answering.
+// A validator still in use after that compiles as before, so a server reaches
+// the generated code's speed within its first requests, and a command line
+// tool or a short-lived function never pays to compile. Only where compiling
+// costs enough to matter: a schema whose size with its references followed
+// passes COLD_MIN characters (expandedChars in lib/js-compiler.js). A small
+// schema compiles in about a millisecond and is generated at its first call
+// as before, which also keeps every test that compares the generated code
+// with the interpreter comparing the generated code. Not for a validator with
+// an extension (_extendValidate, _extendChecks), which the twin would not
+// carry. Returns the twin to answer this call, or null to compile.
+const COLD_CALLS = 64;
+const COLD_MIN = 16 * 1024;
+// Whether the schema may expand past `limit`, answered from its text where
+// that settles it. Without a `$ref` nothing expands, and expandedChars counts
+// at most 8 for each character of the text, so a short schema is decided
+// without walking it. The text is the one _ensureCompiled needs anyway. Walking
+// every small route schema here cost a Fastify boot of ten routes 0.15 ms.
+function mayExpandPast (self, limit) {
+  const str = self._schemaStr || (self._schemaStr = JSON.stringify(self._schemaObj));
+  if (str === undefined) return false;
+  if (str.length * 8 <= limit && !str.includes('"$ref"')) return false;
+  return jsCompiler.expandedChars(self._schemaObj, limit) > limit;
+}
+
+function coldTwin (self, Validator) {
+  const n = self._coldCalls === undefined ? 0 : self._coldCalls;
+  if (n >= COLD_CALLS || self._validateTail !== null || self._verdictTail !== null) return null;
+  let t = self._twin;
+  if (t === undefined) {
+    t = null;
+    if (!self._interpretOnly && !self._initialized && mayExpandPast(self, COLD_MIN)) {
+      try { t = new Validator(self._rawSchema, Object.assign({}, self._options, { engine: 'interpreter' })); } catch { t = null; }
+    }
+    self._twin = t;
+  }
+  if (t === null) return null;
+  self._coldCalls = n + 1;
+  return t;
+}
+
 core._registerCodegen({
   jsCompiler,
+  coldTwin,
+  // The native locator for error frames, loaded with the first frame.
+  nativePositions: () => require('./lib/native-positions').nativeTargeted,
   installPaths: installCodegenPaths,
   compileVerdict: installCodegenPaths.compileVerdict,
   installScanner: installCodegenPaths.installScanner,

package/lib/branch-collapse.js

@@ -44,6 +44,21 @@ function __ataScore (errs) {
 // `title`, or the titles in `titles` when given (the generated code passes
 // each branch's result as it is rather than copying it to add one).
 // Returns the single error to report, or null when the keyword is satisfied.
+// oneOf passed by more than one branch; generated code builds it from a count.
+function __ataMulti (passIdx, total, pp, sp, o) {
+  const multi = {
+    code: 'ATA4002',
+    keyword: 'oneOf',
+    instancePath: pp || '',
+    path: pp || '',
+    schemaPath: sp,
+    message: 'value matched ' + passIdx.length + ' of ' + total + ' oneOf variants, expected exactly one',
+    params: { passingSchemas: passIdx },
+  };
+  if (o !== null) Object.defineProperty(multi, '_o', { value: o });
+  return multi;
+}
+
 function __ataCollapse (kw, br, pp, sp, o, titles) {
   let passN = 0;
   for (let i = 0; i < br.length; i++) if (br[i].valid) passN++;
@@ -53,17 +68,7 @@ function __ataCollapse (kw, br, pp, sp, o, titles) {
     if (pass.length > 1) {
       const passIdx = [];
       for (let i = 0; i < br.length; i++) if (br[i].valid) passIdx.push(i);
-      const multi = {
-        code: 'ATA4002',
-        keyword: 'oneOf',
-        instancePath: pp || '',
-        path: pp || '',
-        schemaPath: sp,
-        message: 'value matched ' + pass.length + ' of ' + br.length + ' oneOf variants, expected exactly one',
-        params: { passingSchemas: passIdx },
-      };
-      if (o !== null) Object.defineProperty(multi, '_o', { value: o });
-      return multi;
+      return __ataMulti(passIdx, br.length, pp, sp, o);
     }
   } else if (pass.length >= 1) {
     return null;
@@ -97,12 +102,13 @@ function collapseBranches ({ keyword, branchResults, parentPath, parentSchemaPat
   return __ataCollapse(keyword, branchResults, parentPath, parentSchemaPath, ordinal === undefined ? null : ordinal);
 }
 
-// The three declarations as source, for the generated code to carry. Derived
+// The four declarations as source, for the generated code to carry. Derived
 // from the functions above rather than written out again, so a fix to one
 // cannot miss the other. `tests/test_branch_collapse.js` runs both.
 function embedSource () {
   return 'const __ATA_SEVERITY=' + JSON.stringify(__ATA_SEVERITY) + ';' +
     'const __ataScore=' + __ataScore.toString() + ';' +
+    'const __ataMulti=' + __ataMulti.toString() + ';' +
     'const __ataCollapse=' + __ataCollapse.toString() + ';';
 }
 

package/lib/clone-emit.js

@@ -78,8 +78,11 @@ function inlineRefsForClone(root) {
     for (const k of Object.keys(cur)) {
       if (strip && k === 'default') continue;
       const v = cur[k];
-      if (_INLINE_DATA_KEYS.has(k) || k === '$defs' || k === 'definitions') { out[k] = v; continue; }
-      out[k] = walk(v, active, strip);
+      // A property named "__proto__" is an own key of the copy: assigned, it
+      // set the copy's prototype and the property was gone from parse().
+      const w = (_INLINE_DATA_KEYS.has(k) || k === '$defs' || k === 'definitions') ? v : walk(v, active, strip);
+      if (k === '__proto__') Object.defineProperty(out, k, { value: w, writable: true, enumerable: true, configurable: true });
+      else out[k] = w;
     }
     if (siblingDefault !== undefined) out.default = siblingDefault;
     return out;

package/lib/data-position-cache.js

@@ -2,13 +2,17 @@
 
 const { buildDataPositionMap, buildTargetedPositionMap } = require('./data-positions');
 
+
 /**
  * Memoize the position map for the duration of a single validate() call.
  * Caller passes the original buffer/string. Identity-keyed: same reference
  * == same map. No global state, caller holds the cache instance.
  */
 
-function createCache () {
+// `nativeTargeted`, when given, is a faster source of the same entries: the
+// full entry point passes lib/native-positions.js, lite passes nothing.
+function createCache (nativeTargeted) {
+  const _nativeTargeted = typeof nativeTargeted === 'function' ? nativeTargeted : null;
   const wm = new WeakMap();
   const sm = new Map(); // strings can't go in WeakMap; clear after each validate
   let lastInput = null;
@@ -32,11 +36,13 @@ function createCache () {
         ? sm.get(input)
         : (Buffer.isBuffer(input) ? wm.get(input) : undefined);
       if (already) return already;
-      let filtered;
-      try {
-        filtered = buildTargetedPositionMap(input, wanted);
-      } catch {
-        return null;
+      let filtered = _nativeTargeted === null ? null : _nativeTargeted(input, wanted);
+      if (filtered === null) {
+        try {
+          filtered = buildTargetedPositionMap(input, wanted);
+        } catch {
+          return null;
+        }
       }
       let full;
       const fallback = (key) => {

package/lib/draft7.js

@@ -49,13 +49,11 @@ function _normalize(schema) {
   // dependencies → dependentSchemas + dependentRequired
   if (schema.dependencies) {
     for (const [key, value] of Object.entries(schema.dependencies)) {
-      if (Array.isArray(value)) {
-        if (!schema.dependentRequired) schema.dependentRequired = {}
-        schema.dependentRequired[key] = value
-      } else {
-        if (!schema.dependentSchemas) schema.dependentSchemas = {}
-        schema.dependentSchemas[key] = value
-      }
+      // defineProperty: a dependency on a property named "__proto__" is an
+      // own key here, where assignment would set the map's prototype.
+      const target = Array.isArray(value) ? 'dependentRequired' : 'dependentSchemas'
+      if (!schema[target]) schema[target] = {}
+      Object.defineProperty(schema[target], key, { value, writable: true, enumerable: true, configurable: true })
     }
     delete schema.dependencies
   }

package/lib/enrich-site.js

@@ -30,7 +30,7 @@ function errorSite (keyword, schemaPath, params, format) {
   };
 }
 
-function makeRich (site, path, params, message, value, root) {
+function makeRich (site, path, params, message, value, root, spPrefix) {
   // As resolveAt: a root that is null, undefined, '' or NaN resolves nothing.
   const at = (!root && root !== 0 && root !== false) ? MISSING : value;
   const out = {
@@ -40,7 +40,7 @@ function makeRich (site, path, params, message, value, root) {
     path,
     expected: site.expected === NO_EXPECTED ? expectedFor({ keyword: site.keyword, params }) : site.expected,
     received: at === MISSING ? undefined : reprValue(at),
-    schemaPath: site.schemaPath,
+    schemaPath: spPrefix === undefined ? site.schemaPath : spPrefix + site.schemaPath,
     docUrl: site.docUrl,
     instancePath: path,
     dataPath: path,