ata-validator 1.61.0 → 1.61.2

package/lib/rejections.js

@@ -1,13 +1,12 @@
 'use strict';
 
-// The rejection objects validate() and validateJSON() return, and the helpers
+// The rejection objects validate() returns, and the helpers
 // that build their errors on first read: declaration-order sorting,
 // enrichment, typo correlation and source frames. Shared by the validator core
 // and by the wrapper around a compiled module, so both report errors through
-// the same code.
+// the same code. The one validateJSON() returns is in lib/json-rejections.js.
 
 const { ordinalFor: schemaOrdinal, rankFor: schemaRank } = require('./schema-order');
-const { setDiagnosticSource: attachDiagnosticSource } = require('./diagnostic-source');
 
 // Rejection result with errors materialized on first read. The accessor
 // lives on the prototype so constructing one is a plain allocation; an
@@ -80,6 +79,15 @@ class RichRejection {
     return raw;
   }
 }
+// The position map builder of lib/json-rejections.js, which sets it when it
+// loads. Only validateJSON passes JSON text here, and the code that calls it
+// loads that module first (were it not, the call below throws, it does not
+// skip the frames); validate() and a compiled wrapper without the JSON
+// entry points never load it, so their bundles carry neither it nor the
+// rejection validateJSON returns (532 bytes gzipped of the wrapper).
+let _positionsFor = null;
+function _setPositionsFor (fn) { _positionsFor = fn; }
+
 // Orders a raw error list and gives it the shape the caller asked for: the
 // legacy key set, or enriched. Shared by both rejection classes below.
 function presentErrors(raw, data, rawInput, self, root, enrich) {
@@ -87,7 +95,7 @@ function presentErrors(raw, data, rawInput, self, root, enrich) {
   // The position map, resolved on the first read of an error's frame (see
   // defineLazyFrames in lib/enrich-error.js): a walk of the document that a
   // caller reading messages and paths never needs.
-  const lazyPositions = enrich && raw.length && rawInput != null ? lazyPositionsFor(self, rawInput, raw) : null;
+  const lazyPositions = enrich && raw.length && rawInput != null ? _positionsFor(self, rawInput, raw) : null;
   // One options object for the whole list, not one per error.
   const opts = enrich && raw.length
     ? {
@@ -126,153 +134,6 @@ Object.defineProperty(RichRejection.prototype, 'errors', {
 });
 
 
-// The rejection validateJSON returns. Everything the text path adds over
-// validate(data), the value tree enrichment needs, the position map, the
-// diagnostic payload, happens on first access to `.errors`. Reading `.valid`
-// touches none of it. The JSON text is held here rather than read back off the
-// validator, so the result does not depend on what the instance does next.
-class LazyJsonRejection {
-  // `parsed`, when given, is the document the inner path parsed from
-  // `jsonStr` and validated, after defaults, coercion and removal: reading the
-  // errors uses it instead of parsing the text again, which on a 5 MB
-  // document was a third of what reading them cost.
-  constructor(result, jsonStr, self, enrich, parsed) {
-    this.valid = false;
-    this._result = result;
-    this._jsonStr = jsonStr;
-    this._self = self;
-    this._enrich = enrich;
-    this._cached = null;
-    this._parsed = parsed;
-  }
-  toJSON() {
-    return { valid: false, errors: this.errors };
-  }
-}
-Object.defineProperty(LazyJsonRejection.prototype, 'errors', {
-  enumerable: true,
-  configurable: true,
-  get() {
-    if (this._cached !== null) return this._cached;
-    const self = this._self;
-    const enrich = this._enrich;
-    const jsonStr = this._jsonStr;
-    // Reading the inner errors realizes the inner lazy layer, if there was one.
-    const raw = this._result.errors || [];
-    if (!raw.length) { this._cached = raw; return raw; }
-
-    // The enrich pass plucks `received` from the value tree and the suggestion
-    // engine (required-typo, format hints, coercion nudges) walks it too.
-    let parsedData = this._parsed;
-    if (parsedData === undefined) {
-      try { parsedData = JSON.parse(jsonStr); } catch { parsedData = undefined; }
-      // What was checked is the document after defaults, coercion and removal,
-      // so `received` has to come from that, as it does for validate(). A
-      // default that failed its own schema has no value in the text at all.
-      if (parsedData !== undefined && self._preprocess) self._preprocess(parsedData);
-    }
-
-    // Errors the inner path already enriched carry a `received` key: enrich()
-    // always sets one, even when there is no value to show. `code` is not a
-    // safe signal, because branch-collapse attaches codes to raw errors, and
-    // `docUrl` is not either, because the generated error functions stamp it
-    // on raw errors; taking it as the signal left those errors without
-    // `received` or a suggestion on the text path while validate() had both.
-    if (!raw[0] || !('received' in raw[0])) {
-      // Declaration order, as validate() applies it; the text path used to
-      // enrich in emission order.
-      const ordered = needsOrdering(raw) ? sortErrorsBySchemaOrder(self._schemaObj, raw) : raw;
-      // The position map waits for the first read of a frame (lib/enrich-error
-      // defineLazyFrames); until then reading the list costs the enrichment alone.
-      const lazyPositions = lazyPositionsFor(self, jsonStr, ordered);
-      const enrichOpts = {
-        data: parsedData,
-        positions: null,
-        lazyPositions,
-        schemaPositions: self._schemaPositions,
-        schemaFile: self._source ? self._source.path : undefined,
-      };
-      const enriched = ordered.map((e) => enrich(e, enrichOpts));
-      if (enriched.length > 1) attachRelated(enriched);
-      attachDiagnosticSource(enriched, {
-        data: parsedData,
-        text: jsonStr,
-        // Read by the diagnostic renderer only, which resolves the same map.
-        get positions () { return lazyPositions(); },
-        schema: self._schemaObj,
-        mutatesInput: self._mutatesInput === true,
-      });
-      this._cached = enriched;
-      return enriched;
-    }
-
-    // Already enriched, so the frames are usually attached too. Only a gap in
-    // them is worth another walk of the document: resolving the map to discover
-    // there was nothing to fill cost a second full walk on every rejection.
-    if (raw.some((e) => e && !e.dataFrame)) {
-      const positions = self._pos().targeted(jsonStr, wantedPointersFor(raw.filter((e) => e && !e.dataFrame)));
-      if (positions) {
-        for (const e of raw) {
-          if (e && !e.dataFrame) {
-            const path = e.path != null ? e.path : (e.instancePath || '');
-            const p = positions[path];
-            if (p) e.dataFrame = { byteOffset: p.byteOffset, length: p.length, line: p.line, col: p.col, text: p.text };
-          }
-        }
-        self._posCache.reset();
-      }
-    }
-    if (raw.length > 1) attachRelated(raw);
-    attachDiagnosticSource(raw, {
-      data: parsedData,
-      text: jsonStr,
-      schema: self._schemaObj,
-      mutatesInput: self._mutatesInput === true,
-    });
-    this._cached = raw;
-    return raw;
-  },
-});
-
-// The targeted position map for a list, built on the first call and shared
-// by every error's frame accessor (lib/enrich-error defineLazyFrames).
-function lazyPositionsFor (self, text, errors) {
-  let done = false;
-  let positions = null;
-  return () => {
-    if (done) return positions;
-    done = true;
-    positions = self._pos().targeted(text, wantedPointersFor(errors));
-    if (positions) self._posCache.reset();
-    return positions;
-  };
-}
-
-// The pointers a set of errors will ask the position map about. lib/enrich-error
-// looks up the error's own path, and for an additional or unevaluated property
-// the child pointer named in `params`, unescaped, which is the form it asks for.
-// The escaped form goes in too: including a pointer that is never read costs
-// nothing, and the cache answers anything outside this set from the full map
-// rather than reporting no position.
-function wantedPointersFor (errors) {
-  const wanted = new Set();
-  for (const e of errors) {
-    if (!e) continue;
-    const path = e.path != null ? e.path : (e.instancePath || '');
-    wanted.add(path);
-    if (e.instancePath != null && e.instancePath !== path) wanted.add(e.instancePath);
-    const params = e.params;
-    const named = params && (params.additionalProperty || params.unevaluatedProperty);
-    if (typeof named === 'string') {
-      wanted.add(path + '/' + named);
-      if (named.indexOf('~') !== -1 || named.indexOf('/') !== -1) {
-        wanted.add(path + '/' + named.replace(/~/g, '~0').replace(/\//g, '~1'));
-      }
-    }
-  }
-  return wanted;
-}
-
 // A raw error in the legacy shape. The error generator writes `code` and
 // `docUrl` into its literals because a standalone module returns them as they
 // are; the runtime's legacy shape never had them, and the interpreter leaves
@@ -411,4 +272,4 @@ function attachRelated (errors) {
   return errors;
 }
 
-module.exports = { LazyRejection, RichRejection, presentErrors, needsOrdering, LazyJsonRejection, _enrichLazy, attachRelated, sortErrorsBySchemaOrder, stripOrdinal, wantedPointersFor };
+module.exports = { LazyRejection, RichRejection, presentErrors, needsOrdering, _enrichLazy, attachRelated, sortErrorsBySchemaOrder, stripOrdinal, _setPositionsFor };

package/lib/shape-classifier.js

@@ -24,7 +24,7 @@ const TIER0_PRIMITIVE_ALLOWED = new Set([
   'type', 'enum', 'const',
   'minLength', 'maxLength',
   'minimum', 'maximum', 'exclusiveMinimum', 'exclusiveMaximum',
-  'multipleOf',
+  'multipleOf', 'format',
   ...META_KEYS,
 ]);
 
@@ -54,6 +54,11 @@ function isTier0Primitive(schema) {
     }
   }
   if (schema.const !== undefined && !isPrimitiveEnumValue(schema.const)) return false;
+  // `format` on a string, by name: tier 0 checks it with the table the
+  // interpreted engine reads (formats.formatChecks) or the caller's own
+  // function. A format on another type is a compat check for numbers, which
+  // the full engines handle.
+  if (schema.format !== undefined && (schema.type !== 'string' || typeof schema.format !== 'string')) return false;
   return true;
 }
 

package/lib/standard-schema.js

@@ -117,7 +117,7 @@ function standardSchemaFor(self, getSchema, validate) {
         if (!message) {
           // The native engine reports numeric codes without a message; the
           // enrich pass knows how to word those. Rare, so required lazily.
-          message = require('./enrich-error').enrich(err, {}).message;
+          message = require('./native-message')(err);
         }
         issues[i] = { message, path: parsePointerPath(path) };
       }

package/lib/tier0.js

@@ -49,7 +49,17 @@ const _hop = Object.prototype.hasOwnProperty;
 // Deno removes the __proto__ accessor; read the prototype another way there.
 const _PN = typeof Bun === 'undefined' && ({}).__proto__ === Object.prototype; // JavaScriptCore goes through Object.getPrototypeOf, see js-compiler's _PN
 
-function primConstraint(key, propSchema) {
+// The check for a string's `format`: the caller's own function by that name,
+// else the built-in one, else none (an unknown format is an annotation), as
+// the interpreted engine picks it.
+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;
+}
+
+function primConstraint(key, propSchema, userFormats) {
   const t = propSchema.type;
   const hasEnum = Array.isArray(propSchema.enum);
   const hasConst = propSchema.const !== undefined;
@@ -75,14 +85,15 @@ function primConstraint(key, propSchema) {
     exclMin: typeof propSchema.exclusiveMinimum === 'number' ? propSchema.exclusiveMinimum : 0,
     exclMax: typeof propSchema.exclusiveMaximum === 'number' ? propSchema.exclusiveMaximum : 0,
     multipleOf: typeof propSchema.multipleOf === 'number' ? propSchema.multipleOf : 0,
+    formatFn: propSchema.type === 'string' ? formatFnOf(propSchema, userFormats) : null,
   };
 }
 
-function buildTier0Plan(schema) {
+function buildTier0Plan(schema, userFormats) {
   if (schema.type !== 'object') {
     return {
       isPrimitive: true,
-      constraints: [primConstraint('__root__', schema)],
+      constraints: [primConstraint('__root__', schema, userFormats)],
       requiredMask: 0,
       additionalAllowed: true,
       knownKeys: null,
@@ -96,7 +107,7 @@ function buildTier0Plan(schema) {
   let requiredMask = 0;
   for (let i = 0; i < keys.length; i++) {
     const k = keys[i];
-    constraints[i] = primConstraint(k, props[k]);
+    constraints[i] = primConstraint(k, props[k], userFormats);
     knownKeys.add(k);
     if (required && required.has(k)) requiredMask |= (1 << i);
   }
@@ -128,6 +139,7 @@ function checkPrimitive(c, v) {
     const maxLen = c.maxLen;
     if (minLen >= 0) { const l = v.length; if (l < minLen) return false; if (l < minLen * 2 && codePointLength(v) < minLen) return false; }
     if (maxLen >= 0) { const l = v.length; if (l > maxLen && codePointLength(v) > maxLen) return false; }
+    if (c.formatFn !== null && !c.formatFn(v)) return false;
   } else if (m === T_INTEGER) {
     if (typeof v !== 'number' || !Number.isInteger(v)) return false;
     const f = c.numFlags;
@@ -186,6 +198,7 @@ function tier0ValidateObject(plan, data) {
       const maxLen = c.maxLen;
       if (minLen >= 0) { const l = v.length; if (l < minLen) return false; if (l < minLen * 2 && codePointLength(v) < minLen) return false; }
       if (maxLen >= 0) { const l = v.length; if (l > maxLen && codePointLength(v) > maxLen) return false; }
+      if (c.formatFn !== null && !c.formatFn(v)) return false;
     } else if (m === T_INTEGER) {
       if (typeof v !== 'number' || !Number.isInteger(v)) return false;
       const f = c.numFlags;

package/lib/validator-core.js

@@ -19,10 +19,17 @@ const { normalizeKeywords, schemaUsesKeywords } = require('./keywords');
 // bundle built from lite.js never contains it. Until something registers, the
 // core behaves exactly as it does where `new Function` is blocked: every
 // schema runs on the interpreted engine, which passes the same test suite.
-// Whether this process runs code compiled ahead of time, where generated
-// code falls to an interpreter: Bun's flag for its compiler, or the
-// environment saying so (an executable built before the flag existed).
+// Whether this process runs code compiled ahead of time, where code made at
+// run time with `new Function` falls to an interpreter and ata's interpreted
+// engine, compiled with the program, is six times faster (481 against 78 ns
+// a document under bun build --compile --aot). Bun resolves the package's
+// `"aot"` export condition there, which loads index.aot.js and marks the
+// process (_markAotHost); `Bun.isAOT` was the earlier signal, and
+// ATA_ENGINE=interpreter says so from outside.
+let _aotEntry = false;
+function _markAotHost() { _aotEntry = true; }
 function aotHost() {
+  if (_aotEntry) return true;
   if (env('ATA_ENGINE') === 'interpreter') return true;
   const b = typeof Bun !== 'undefined' ? Bun : undefined;
   return !!(b && b.isAOT === true);
@@ -353,7 +360,14 @@ function resolveSchemaByPath(rootSchema, schemaPath) {
 // by every page that loads the package, validating or not.
 let LazyRejection, RichRejection, LazyJsonRejection, _enrichLazy, presentErrors, needsOrdering, sortErrorsBySchemaOrder, stripOrdinal;
 function _loadRejections() {
-  ({ LazyRejection, RichRejection, LazyJsonRejection, _enrichLazy, presentErrors, needsOrdering, sortErrorsBySchemaOrder, stripOrdinal } = require('./rejections'));
+  ({ LazyRejection, RichRejection, _enrichLazy, presentErrors, needsOrdering, sortErrorsBySchemaOrder, stripOrdinal } = require('./rejections'));
+}
+// The rejection validateJSON returns, and the position map an error's frame
+// reads, loaded with the first rejection that carries JSON text: a process
+// that only ever calls validate() never parses them (lib/json-rejections.js,
+// lib/diagnostic-source.js).
+function _loadJsonRejections() {
+  if (LazyJsonRejection === undefined) ({ LazyJsonRejection } = require('./json-rejections'));
 }
 
 // Text that does not parse, reported the same way on every path and platform:
@@ -1206,7 +1220,13 @@ class Validator {
       // once per call: deciding first and walking again for the errors would
       // run the keyword twice, the second time on what the first left.
       const once = interp.dataContext === true;
-      if (!preprocess && !once) this._fastVerdict = (d) => interp.isValid(d);
+      // A schema tier 0 takes answers its verdict there, with or without a
+      // call to validate() first: the shared walk over a flat plan beats the
+      // closure tree, 76 to 60 ns on Node and 85 to 49 under Bun's compiler,
+      // where the closures are not typed. Not for custom keywords, which
+      // tier 0 does not know.
+      const t0 = !preprocess && !once && !this._usesKeywords ? _tier0Verdict(this) : null;
+      if (!preprocess && !once) this._fastVerdict = t0 !== null ? t0 : (d) => interp.isValid(d);
       if (preprocess && !once) _preVerdict = (d) => { preprocess(d); return interp.isValid(d); };
       // abortEarly is a documented contract, not a property of whichever engine
       // answered: it promises the frozen ATA9000 stub instead of a detailed
@@ -1284,6 +1304,7 @@ class Validator {
           // literal with a getter here cost a closure plus an accessor
           // definition on every rejection, several hundred nanoseconds
           // before any error was read.
+          if (rawInput != null) _loadJsonRejections();
           return new RichRejection(result, data, rawInput, self, root, enrich);
         }
         return result;
@@ -1320,6 +1341,7 @@ class Validator {
           // and on the codegen path that realizes the inner lazy layer, which is
           // the document walk this exists to avoid.
           if (result && result.valid === false) {
+            _loadJsonRejections();
             return new LazyJsonRejection(result, jsonStr, this, enrich, parsed);
           }
           return result;
@@ -2323,6 +2345,22 @@ for (const [name, pick] of [
 
 // Cold start: an interpreted twin answers a large schema's first calls where
 // the code generator is registered (see coldTwin in index.js). Lite has none.
+// Whether this validator, in the browser build before the generator has
+// come, counts its calls so a busy one moves to generated code (lib/tiering.js).
+function _ticks(self) {
+  return _codegen === null && _tiering !== null && !self._interpretOnly && !env('ATA_FORCE_NAPI');
+}
+// The tier-0 verdict for a schema it takes, or null: counting calls where
+// _ticks says so.
+function _tier0Verdict(self) {
+  if (require('./shape-classifier').classify(self._schemaObj).tier !== 0) return null;
+  const { buildTier0Plan, tier0Validate } = require('./tier0');
+  const plan = buildTier0Plan(self._schemaObj, self._userFormats);
+  if (!_ticks(self)) return (d) => tier0Validate(plan, d);
+  const tick = _tiering.counter(self);
+  return (d) => { tick(); return tier0Validate(plan, d); };
+}
+
 Validator.prototype._coldTwin = function () {
   const cg = _loadCodegen();
   return cg === null || cg.coldTwin === undefined ? null : cg.coldTwin(this, Validator);
@@ -2354,21 +2392,13 @@ _defineLazyMethod('isValidObject', (self) => {
     return self.isValidObject(data);
   }
   // Lazy: classify + build tier 0 plan on first call, not in constructor.
-  const _tier = require("./shape-classifier").classify(self._schemaObj);
-  if (_tier.tier === 0) {
-    // Bound once here, so the verdict below reads a local, not the module.
-    const { buildTier0Plan, tier0Validate } = require("./tier0");
-    const _plan = buildTier0Plan(self._schemaObj);
+  const _t0 = _tier0Verdict(self);
+  if (_t0 !== null) {
+    // In the browser build the verdict counts its calls (see _tier0Verdict);
+    // elsewhere the second call builds the generated code behind it.
     let _n = 0;
-    // In the browser build the generator is not there yet: count the calls
-    // like the interpreted engine does, or a schema checked only through
-    // this method stays on the plan walk, four times slower, for good.
-    const _tick = _codegen === null && _tiering !== null && !self._interpretOnly && !env('ATA_FORCE_NAPI') ? _tiering.counter(self) : null;
-    _bindVerdict(self, _tick !== null ? (d) => {
-      _tick();
-      return tier0Validate(_plan, d);
-    } : (d) => {
-      const r = tier0Validate(_plan, d);
+    _bindVerdict(self, _ticks(self) ? _t0 : (d) => {
+      const r = _t0(d);
       if (++_n === 2) {
         try { self._ensureCodegen(); } catch {}
       }
@@ -2441,6 +2471,7 @@ Object.defineProperty(module.exports, '_registerCodegen', { value: _registerCode
 Object.defineProperty(module.exports, '_setCodegenLoader', { value: (load) => { _loadCodegen = load; }, enumerable: false });
 Object.defineProperty(module.exports, '_registerTiering', { value: _registerTiering, enumerable: false });
 Object.defineProperty(module.exports, '_registerBuiltHook', { value: _registerBuiltHook, enumerable: false });
+Object.defineProperty(module.exports, '_markAotHost', { value: _markAotHost, enumerable: false });
 Object.defineProperty(module.exports, '_codegenRegistered', { value: () => _codegen !== null, enumerable: false });
 Object.defineProperty(module.exports, '_tiering', { get: () => _tiering, enumerable: false });
 Object.defineProperty(module.exports, '_registerAot', { value: _registerAot, enumerable: false });

package/lib/verify.js

@@ -195,8 +195,72 @@ function mutate (doc, r) {
   }
 }
 
-// Documents for `schema`: `count` made, half of them with one rule broken.
-function generate (schema, count, seed) {
+// The values on either side of each bound the schema states, for the value
+// at one place: a module that wrote a bound off by one (`< 12` for a minimum
+// of 13) answers every random document as the runtime does, and differs only
+// here. A bound is where a hand edit, a stale module or a generator bug shows.
+function boundaryValues (schema, type) {
+  const out = []
+  const int = type === 'integer'
+  const step = int ? 1 : 0.5
+  const num = (b) => typeof b === 'number' && Number.isFinite(b)
+  if (type === 'integer' || type === 'number') {
+    if (num(schema.minimum)) out.push(schema.minimum, schema.minimum - step)
+    if (num(schema.maximum)) out.push(schema.maximum, schema.maximum + step)
+    if (num(schema.exclusiveMinimum)) out.push(schema.exclusiveMinimum, schema.exclusiveMinimum + step)
+    if (num(schema.exclusiveMaximum)) out.push(schema.exclusiveMaximum, schema.exclusiveMaximum - step)
+    if (num(schema.multipleOf) && schema.multipleOf > 0) out.push(schema.multipleOf, schema.multipleOf * 1.5)
+  }
+  if (type === 'string') {
+    const str = (n) => 'abcdefghij'.repeat(Math.ceil(n / 10) + 1).slice(0, n)
+    if (num(schema.minLength)) { out.push(str(schema.minLength)); if (schema.minLength > 0) out.push(str(schema.minLength - 1)) }
+    if (num(schema.maxLength) && schema.maxLength < 4096) out.push(str(schema.maxLength), str(schema.maxLength + 1))
+  }
+  return out
+}
+
+// Documents that differ from a valid one at a single place, by a value on
+// either side of a bound stated there: properties, nested objects, the first
+// element of an array, through local references. At most `limit` of them.
+function boundaryDocs (schema, r, defs, limit, accepts) {
+  // A base the runtime accepts, where the caller can say, so that a bound
+  // read wrong changes the verdict and not only the error list.
+  let base = makeValid(schema, r, defs, 0)
+  if (accepts) for (let i = 0; i < 50 && base !== undefined && !accepts(base); i++) base = makeValid(schema, r, defs, 0)
+  if (base === undefined) return []
+  const out = []
+  const visit = (sub, path, depth) => {
+    if (out.length >= limit || depth > 8 || !sub || typeof sub !== 'object') return
+    if (typeof sub.$ref === 'string') { const t = resolveLocal(sub.$ref, defs); if (t !== undefined) visit(t, path, depth + 1); return }
+    if (Array.isArray(sub.allOf)) { visit(mergeAllOf(sub), path, depth + 1); return }
+    const types = Array.isArray(sub.type) ? sub.type : sub.type !== undefined ? [sub.type] : []
+    for (const t of types.length ? types : ['integer', 'number', 'string']) {
+      for (const val of boundaryValues(sub, t)) {
+        if (out.length >= limit) return
+        const d = clone(base)
+        if (path.length === 0) { out.push(val); continue }
+        let o = d
+        for (let i = 0; i < path.length - 1; i++) {
+          if (o[path[i]] === undefined || o[path[i]] === null || typeof o[path[i]] !== 'object') o[path[i]] = typeof path[i + 1] === 'number' ? [] : {}
+          o = o[path[i]]
+        }
+        o[path[path.length - 1]] = val
+        out.push(d)
+      }
+    }
+    if (sub.properties && typeof sub.properties === 'object') {
+      for (const k of Object.keys(sub.properties)) if (k !== '__proto__') visit(sub.properties[k], [...path, k], depth + 1)
+    }
+    const item = Array.isArray(sub.prefixItems) ? sub.prefixItems[0] : sub.items && typeof sub.items === 'object' && !Array.isArray(sub.items) ? sub.items : null
+    if (item) visit(item, [...path, 0], depth + 1)
+  }
+  visit(schema, [], 0)
+  return out
+}
+
+// Documents for `schema`: `count` made, half of them with one rule broken,
+// then the documents on either side of each bound (up to `count` more).
+function generate (schema, count, seed, accepts) {
   const r = rng(seed)
   const defs = { $defs: schema && schema.$defs, definitions: schema && schema.definitions }
   const docs = []
@@ -205,6 +269,7 @@ function generate (schema, count, seed) {
     if (i % 2 === 1 && d !== undefined) d = mutate(clone(d), r)
     docs.push(d)
   }
+  for (const d of boundaryDocs(schema, r, defs, count, accepts)) docs.push(d)
   return docs
 }
 
@@ -256,7 +321,7 @@ async function verifyOne ({ schemaFile, moduleFile, schema, generate: count = 20
   if (mod.schemaHash !== undefined && mod.schemaHash !== hash) report.stale = true
   let runtime
   try { runtime = new Validator(schema, {}) } catch (e) { report.error = `schema does not compile: ${e.message}`; return report }
-  const docs = generate(schema, count, seed).map((d, i) => ({ source: `generated #${i + 1}`, doc: d }))
+  const docs = generate(schema, count, seed, (d) => { try { return runtime.isValidObject(clone(d)) } catch { return false } }).map((d, i) => ({ source: `generated #${i + 1}`, doc: d }))
   report.generated = docs.length
   const sampleDocs = readSamples(samples)
   report.samples = sampleDocs.length

package/lib/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "1.61.0",
+  "version": "1.61.2",
   "description": "JSON Schema validator that compiles to plain JavaScript, still runs where code generation is blocked, and can be compiled away at build time. Passes the full official test suite.",
   "type": "commonjs",
   "main": "index.js",
@@ -8,6 +8,11 @@
   "types": "index.d.ts",
   "exports": {
     ".": {
+      "aot": {
+        "types": "./index.d.ts",
+        "import": "./index.aot.mjs",
+        "require": "./index.aot.js"
+      },
       "workerd": {
         "types": "./index.d.ts",
         "import": "./index.edge.mjs",
@@ -60,6 +65,25 @@
       "import": "./compiled-verdict.mjs",
       "require": "./compiled-verdict.js"
     },
+    "./compiled-object": {
+      "types": "./compiled-object.d.ts",
+      "import": "./compiled-object.mjs",
+      "require": "./compiled-object.js"
+    },
+    "./compiled-plain": {
+      "types": "./compiled-plain.d.ts",
+      "import": "./compiled-plain.mjs",
+      "require": "./compiled-plain.js"
+    },
+    "./compiled-bare": {
+      "types": "./compiled-bare.d.ts",
+      "import": "./compiled-bare.mjs",
+      "require": "./compiled-bare.js"
+    },
+    "./compiled-bare-rich": {
+      "types": "./compiled-bare-rich.d.ts",
+      "default": "./lib/compiled-bare-rich.js"
+    },
     "./lite": {
       "types": "./lite.d.ts",
       "import": "./lite.mjs",
@@ -79,7 +103,10 @@
   },
   "sideEffects": [
     "./codegen.js",
-    "./codegen.mjs"
+    "./codegen.mjs",
+    "./lib/aot-mark.js",
+    "./index.aot.js",
+    "./index.aot.mjs"
   ],
   "bin": {
     "ata": "bin/ata.js"
@@ -89,7 +116,12 @@
     "./lib/aot.js": "./lib/aot.browser.js",
     "./lib/buffer-gate.js": "./lib/buffer-gate.browser.js",
     "./lib/interpreter.js": "./lib/interpreter.browser.js",
-    "./lib/aot-order.js": false
+    "./lib/aot-order.js": false,
+    "./lib/compiled-defaults.js": "./lib/compiled-defaults.browser.js",
+    "./lib/native-message.js": "./lib/native.browser.js",
+    "./lib/native-codes.js": "./lib/native.browser.js",
+    "./lib/email-literal.js": false,
+    "./lib/native-positions.js": "./lib/native.browser.js"
   },
   "scripts": {
     "prepublishOnly": "node tests/test_pack_purity.js && ATA_ALLOW_DOC_PLACEHOLDERS=1 node scripts/check-doc-coverage.js && node tests/test_error_codes_lock.js && node tests/test_safe_regex_embed.js && node tests/test_version_sync.js",
@@ -146,6 +178,8 @@
   },
   "files": [
     "index.js",
+    "index.aot.js",
+    "index.aot.mjs",
     "index.mjs",
     "index.node.mjs",
     "index.bundle.mjs",
@@ -173,6 +207,16 @@
     "compiled-verdict.js",
     "compiled-verdict.mjs",
     "compiled-verdict.d.ts",
+    "compiled-object.js",
+    "compiled-object.mjs",
+    "compiled-object.d.ts",
+    "compiled-plain.js",
+    "compiled-plain.mjs",
+    "compiled-plain.d.ts",
+    "compiled-bare.js",
+    "compiled-bare.mjs",
+    "compiled-bare.d.ts",
+    "compiled-bare-rich.d.ts",
     "lite.js",
     "lite.mjs",
     "lite.d.ts",
@@ -187,13 +231,13 @@
     "codegen.d.ts"
   ],
   "optionalDependencies": {
-    "@ata-validator/native-darwin-arm64": "1.61.0",
-    "@ata-validator/native-darwin-x64": "1.61.0",
-    "@ata-validator/native-linux-arm64-gnu": "1.61.0",
-    "@ata-validator/native-linux-arm64-musl": "1.61.0",
-    "@ata-validator/native-linux-x64-gnu": "1.61.0",
-    "@ata-validator/native-linux-x64-musl": "1.61.0",
-    "@ata-validator/native-win32-x64": "1.61.0"
+    "@ata-validator/native-darwin-arm64": "1.61.2",
+    "@ata-validator/native-darwin-x64": "1.61.2",
+    "@ata-validator/native-linux-arm64-gnu": "1.61.2",
+    "@ata-validator/native-linux-arm64-musl": "1.61.2",
+    "@ata-validator/native-linux-x64-gnu": "1.61.2",
+    "@ata-validator/native-linux-x64-musl": "1.61.2",
+    "@ata-validator/native-win32-x64": "1.61.2"
   },
   "peerDependencies": {
     "yaml": "^2.0.0"