ata-validator 1.61.1 → 1.61.2

package/README.md

@@ -748,10 +748,12 @@ So, in order of preference:
    module by hand. The module is plain JavaScript and compiles with the
    program: 24 ns, the same errors as the runtime.
 2. Where the runtime `Validator` stays, let it take the interpreted engine.
-   It does so by itself when Bun reports `Bun.isAOT`, when the executable is
-   built with `--disallow-code-generation-from-strings` (the program then
-   counts as closed for the compiler, too), or when `ATA_ENGINE=interpreter`
-   is set: 80 ns against 492 for the generated code there.
+   It does so by itself under `bun build --compile --aot` and `bun run --aot`,
+   where Bun resolves the package's `"aot"` export condition to an entry that
+   says so; also when the executable is built with
+   `--disallow-code-generation-from-strings` (the program then counts as
+   closed for the compiler, too), or when `ATA_ENGINE=interpreter` is set:
+   78 ns against 487 for the generated code there.
 3. Write the module for the compiler. `ata build schema.json --target bun`
    writes it with a closed object's keys read once and compared with the
    declared list in order (on a ten-item order with 1024 distinct documents,

package/index.aot.js

@@ -0,0 +1,8 @@
+'use strict';
+
+// ata-validator under Bun's ahead-of-time compiler, where Bun resolves the
+// `"aot"` export condition: the same package, with validators on the
+// interpreted engine by default, which is compiled with the program, rather
+// than on code made at run time, which is not (lib/aot-mark.js).
+require('./lib/aot-mark.js');
+module.exports = require('./index.js');

package/index.aot.mjs

@@ -0,0 +1,5 @@
+// ata-validator under Bun's ahead-of-time compiler; see index.aot.js. The mark
+// is imported first, so it runs before the package and before any caller.
+import './lib/aot-mark.js';
+export * from './index.mjs';
+export { default } from './index.mjs';

package/lib/aot-mark.js

@@ -0,0 +1,7 @@
+'use strict';
+
+// Loaded first by index.aot.js and index.aot.mjs, the entries Bun resolves
+// through the `"aot"` export condition when it compiles a program ahead of
+// time: every Validator made after this takes the interpreted engine by
+// default (see aotHost in lib/validator-core.js).
+require('./validator-core')._markAotHost();

package/lib/formats.js

@@ -538,4 +538,31 @@ function email(s) {
 const DURATION_RE = /^P(?:\d+W|(?:\d+Y(?:\d+M(?:\d+D)?)?|\d+M(?:\d+D)?|\d+D)(?:T(?:\d+H(?:\d+M(?:\d+S)?)?|\d+M(?:\d+S)?|\d+S))?|T(?:\d+H(?:\d+M(?:\d+S)?)?|\d+M(?:\d+S)?|\d+S))$/;
 function duration (s) { return DURATION_RE.test(s); }
 
-module.exports = { IPV4, DURATION_RE, IPV6_FULL, ipv4Range, URI_FAST, date, ipv4, dateTime, ipv6, hostname, uri, uriReference, uriWalk: _uriWalk, uuid, time, noReserved, jsonPointer, relativeJsonPointer, uriTemplate, email, duration, iri, iriReference, idnEmail, DURATION_RE, URI_TEMPLATE_EXPR };
+// The built-in format checks by name, built on first use. The interpreted
+// engine and the tier-0 verdict (lib/tier0.js) read the same table, so the two
+// cannot answer differently for a format.
+let _checks = null;
+function formatChecks () {
+  return _checks || (_checks = {
+    email,
+    date,
+    'date-time': dateTime,
+    time,
+    duration,
+    uuid,
+    uri,
+    'uri-reference': uriReference,
+    ipv4,
+    ipv6,
+    hostname,
+    regex: (s) => { try { new RegExp(s, 'u'); return true; } catch { return false; } },
+    'json-pointer': jsonPointer,
+    'relative-json-pointer': relativeJsonPointer,
+    'uri-template': uriTemplate,
+    iri,
+    'iri-reference': iriReference,
+    'idn-email': idnEmail,
+  });
+}
+
+module.exports = { formatChecks, IPV4, DURATION_RE, IPV6_FULL, ipv4Range, URI_FAST, date, ipv4, dateTime, ipv6, hostname, uri, uriReference, uriWalk: _uriWalk, uuid, time, noReserved, jsonPointer, relativeJsonPointer, uriTemplate, email, duration, iri, iriReference, idnEmail, DURATION_RE, URI_TEMPLATE_EXPR };

package/lib/interpreter-core.js

@@ -288,33 +288,9 @@ function multipleOfOk(d, m) {
   return Math.abs(q - Math.round(q)) < 1e-9;
 }
 
-// The built-in format checks, built on the first schema that names a format:
-// the engine loads without lib/formats.js, which schemas without `format`
-// never need.
-let _formatChecks = null;
-function buildFormatChecks() {
-  const _formats = require('./formats');
-  return {
-  email: _formats.email,
-  date: _formats.date,
-  'date-time': _formats.dateTime,
-  time: _formats.time,
-  duration: _formats.duration,
-  uuid: _formats.uuid,
-  uri: _formats.uri,
-  'uri-reference': _formats.uriReference,
-  ipv4: _formats.ipv4,
-  ipv6: _formats.ipv6,
-  hostname: _formats.hostname,
-  regex: (s) => { try { new RegExp(s, 'u'); return true; } catch { return false; } },
-  'json-pointer': _formats.jsonPointer,
-  'relative-json-pointer': _formats.relativeJsonPointer,
-  'uri-template': _formats.uriTemplate,
-  iri: _formats.iri,
-  'iri-reference': _formats.iriReference,
-  'idn-email': _formats.idnEmail,
-  };
-}
+// The built-in format checks come from lib/formats.js (formatChecks), loaded
+// on the first schema that names a format: the engine loads without it, which
+// schemas without `format` never need.
 
 // ---------- evaluation ----------
 
@@ -454,7 +430,7 @@ class Plan {
     this.formatFn = null;
     if (schema.format !== undefined) {
       const uf = interp.userFormats;
-      const fc = (uf && typeof uf[schema.format] === 'function') ? uf[schema.format] : (_formatChecks || (_formatChecks = buildFormatChecks()))[schema.format];
+      const fc = (uf && typeof uf[schema.format] === 'function') ? uf[schema.format] : require('./formats').formatChecks()[schema.format];
       this.formatFn = fc || null;
     }
     this.hasString = this.minLength !== undefined || this.maxLength !== undefined || this.pattern !== null || this.formatFn !== null;

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/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);
@@ -1213,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
@@ -2332,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);
@@ -2363,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 {}
       }
@@ -2450,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/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "1.61.1",
+  "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",
@@ -98,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"
@@ -170,6 +178,8 @@
   },
   "files": [
     "index.js",
+    "index.aot.js",
+    "index.aot.mjs",
     "index.mjs",
     "index.node.mjs",
     "index.bundle.mjs",
@@ -221,13 +231,13 @@
     "codegen.d.ts"
   ],
   "optionalDependencies": {
-    "@ata-validator/native-darwin-arm64": "1.61.1",
-    "@ata-validator/native-darwin-x64": "1.61.1",
-    "@ata-validator/native-linux-arm64-gnu": "1.61.1",
-    "@ata-validator/native-linux-arm64-musl": "1.61.1",
-    "@ata-validator/native-linux-x64-gnu": "1.61.1",
-    "@ata-validator/native-linux-x64-musl": "1.61.1",
-    "@ata-validator/native-win32-x64": "1.61.1"
+    "@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"