ata-validator 1.58.1 → 1.60.0

package/README.md

@@ -661,9 +661,11 @@ through a `setFormats()` export the module carries. `docs/API.md` has the
 details.
 
 **Fastify startup, 10 route schemas, from a cold process to the first validated request:
-ajv 18.3 ms, ata 2.67 ms, no build step required.** ata registers in 0.22 ms of that and
-compiles on the first request, so counting only registration would overstate the gap.
-Reproduce with `node benchmark/bench_fastify_boot.mjs`.
+ajv 30.3 ms, ata 9.7 ms, no build step required** (Node 25, ajv 8.20.0, loading each
+library included). ata loads in 3.7 ms, registers the routes in 0.3 ms and compiles on the
+first request, so counting only registration would overstate the gap. The first request
+here comes in the same tick as setup; a server that listens first has the code generator
+loaded by then. Reproduce with `node benchmark/bench_fastify_boot.mjs`.
 
 ### Standard Schema V1
 

package/codegen.js

@@ -4,7 +4,8 @@
 // loads it on demand, once a validator gets hot; importing this once at
 // startup has every schema compiled to generated code from its first call,
 // and makes parse() and the ahead-of-time bundle methods available in the
-// browser. On Node, ata-validator already includes it and this does nothing.
+// browser. On Node, ata-validator loads it when a validator first compiles or
+// once the event loop is free; importing this loads it now.
 const core = require('./lib/validator-core.js');
 if (!core._codegenRegistered()) core._registerCodegen(require('./lib/codegen-engine.js'));
 module.exports = {};

package/index.js

@@ -6,7 +6,19 @@
 // lib/codegen-engine.js, so that the edge entry (index.edge.js) and
 // ata-validator/lite can load the core without it.
 const core = require('./lib/validator-core.js');
-core._registerCodegen(require('./lib/codegen-engine.js'));
+// The code generator loads on first need, or once the event loop is free,
+// not with the package: it is most of what requiring the package parsed. The
+// timer is unref'd, so a script that has finished does not stay to load it.
+// The loader lives here rather than in the core, which the browser build
+// shares and which has no use for it there.
+let engine = null;
+const loadCodegen = () => {
+  if (engine === null) core._registerCodegen(engine = require('./lib/codegen-engine.js'));
+  return engine;
+};
+core._setCodegenLoader(loadCodegen);
+const warm = setTimeout(loadCodegen, 0);
+if (typeof warm === 'object' && typeof warm.unref === 'function') warm.unref();
 
 // The public names. lib/public-api.js holds the same for index.edge.js; they
 // are written out here rather than required so that loading the package in

package/lib/aot-impl.js

@@ -371,6 +371,30 @@ function defaultsDecl(validator) {
     `let _ataFill;\nfunction applyDefaults(d) { (_ataFill || (_ataFill = _ataDefaults(JSON.parse(${text}))))(d); }\n`;
 }
 
+// What a bundled validator runs on the data before it checks it, for the
+// options the caller of bundleStandalone named: the runtime's pass for
+// `coerceTypes`, `removeAdditional` and `useDefaults: true`, as one generated
+// function (preprocessSource), in the runtime's order. A bundle used to leave
+// coerceTypes and removeAdditional out without a word, and then rejected what
+// the runtime accepts. Where the generated pass declines and the runtime
+// would change the data with its closure pass, there is nothing to carry it
+// in, and the bundle refuses. `useDefaults` alone runs applyDefaults.
+// Returns { decl, call }, the call naming the data parameter `arg`.
+function bundlePreprocess(validator, opts, fillDecl, label, arg = 'd') {
+  const coerceTypes = opts && opts.coerceTypes ? opts.coerceTypes : false;
+  const removeAdditional = opts && opts.removeAdditional ? opts.removeAdditional : false;
+  const useDefaults = !!(opts && opts.useDefaults === true);
+  if (!coerceTypes && !removeAdditional) return { decl: '', call: useDefaults && fillDecl ? `applyDefaults(${arg});` : '' };
+  const internals = require('./validator-core')._internals;
+  const schema = internals.resolveSchemaForPreprocess(validator._schemaObj, validator._schemaMap);
+  let src = null;
+  try { src = require('./codegen-engine').preprocessSource(schema, { coerceTypes, removeAdditional, useDefaults }); } catch { src = null; }
+  if (src !== null) return { decl: `function _ataPre(d) {\n${src}\n}\n`, call: `_ataPre(${arg});` };
+  const changes = (coerceTypes && internals.buildCoercer(schema) !== null) || (removeAdditional && internals.buildRemover(schema) !== null);
+  if (changes) throw new Error(`${label}: ${coerceTypes ? 'coerceTypes' : 'removeAdditional'} cannot be compiled into a standalone module for this schema; validate with the runtime Validator`);
+  return { decl: '', call: useDefaults && fillDecl ? `applyDefaults(${arg});` : '' };
+}
+
 function toStandaloneModule(validator, opts) {
   assertEmittable(validator, 'toStandaloneModule');
   validator._ensureCompiled();
@@ -384,6 +408,12 @@ function toStandaloneModule(validator, opts) {
   const source = !!(opts && opts.source);
   const sourceMap = opts && opts.sourceMap ? opts.sourceMap : null;
   const schemaFile = opts && opts.schemaFile ? opts.schemaFile : null;
+  // The validator's own coerceTypes and removeAdditional run before every
+  // check, as they do in the validator; a module used to leave them out and
+  // reject what the validator accepts. Defaults are not filled here: a module
+  // exports applyDefaults for that, and validate() leaves the data as it is.
+  const vopts = validator._options || {};
+  const pre = bundlePreprocess(validator, { coerceTypes: vopts.coerceTypes, removeAdditional: vopts.removeAdditional }, '', 'toStandaloneModule', 'data');
   const src = jsFn._source;
 
   let errCore = '';
@@ -612,7 +642,7 @@ function toStandaloneModule(validator, opts) {
   // reading patterns. A second declaration of that name shadowed it and the
   // prelude called this one instead, reaching _fn before its initialiser ran.
   const parseCore = cloneExpr
-    ? `function _ataParse(data) {\n  if (!_fn(data)) { const e = new Error('validation failed'); e.name = 'AtaValidationError'; throw e; }\n  return ${cloneExpr};\n}\n`
+    ? `function _ataParse(data) {\n  ${pre.call}if (!_fn(data)) { const e = new Error('validation failed'); e.name = 'AtaValidationError'; throw e; }\n  return ${cloneExpr};\n}\n`
     : '';
 
   // validateJSON(): parse the text, validate, and on failure attach a
@@ -701,8 +731,8 @@ const ABORT = Object.freeze({
 ${closureDecls}${sharedBlock}${preambleDecls}${formatDecls}const _fn = function(d) {
   ${src}
 };
-${errCore}${orderDecl}${compactCore}function isValid(data) { return _fn(data); }
-function validate(data) { ${validBody}; }
+${errCore}${orderDecl}${compactCore}${pre.decl}function isValid(data) { ${pre.call}return _fn(data); }
+function validate(data) { ${pre.call}${validBody}; }
 ${parseCore}${positionsCore}${fillDecl}${hashDecl}${exports}`;
 }
 
@@ -912,6 +942,12 @@ function bundle(Validator, schemas, opts) {
 // Zero-dependency self-contained bundle — no require('ata-validator') needed at runtime.
 // opts.format: 'cjs' (default) or 'esm'.
 // opts.formats: { name: fn } — embedded in the output via Function#toString.
+// opts.order: true hands each validator's errors out in the runtime's order,
+// as toStandaloneModule does (lib/aot-order.js).
+// Each validator of a schema with a default carries `applyDefaults(data)`, the
+// runtime's defaults pass, as a property; validate does not run it unless
+// `useDefaults: true` is passed. `coerceTypes` and `removeAdditional` run
+// before the check, as at runtime (bundlePreprocess).
 function bundleStandalone(Validator, schemas, opts) {
   // A custom keyword is a function, and a standalone module imports nothing,
   // so there is no way to carry it. Refuse rather than emit a module that
@@ -930,11 +966,14 @@ function bundleStandalone(Validator, schemas, opts) {
   // Pass one compiles; pass two emits. The helpers that several schemas hoist
   // are the same text declaring the same name, so the bundle keeps one copy at
   // module scope, and pass two needs to know the set before it writes anything.
+  const ordered = !!(opts && opts.order === true);
+  const validatorOpts = ordered ? Object.fromEntries(Object.entries(bundleOpts).filter(([k]) => k !== 'order')) : bundleOpts;
   const compiledEntries = schemas.map((schema) => {
-    const v = new Validator(schema, bundleOpts);
+    const v = new Validator(schema, validatorOpts);
     v._ensureCompiled();
     const jsFn = v._jsFn;
     if (!jsFn || !jsFn._hybridSource) return null;
+    const noOrdinal = !ordered || !require(AOT_ORDER_MODULE).wantsOrdinals(v._schemaObj);
     // The schema the validator compiled, not the one the caller passed. They
     // differ whenever anything prepared the schema: draft-07 normalization,
     // `format` removed under assertFormat: false, keywords outside the
@@ -944,7 +983,7 @@ function bundleStandalone(Validator, schemas, opts) {
       v._schemaObj,
       v._schemaMap,
       v._userFormats,
-      { noOrdinal: true },
+      { noOrdinal },
     );
     if (jsFn._usesSafeRe || (jsErrFn && jsErrFn._usesSafeRe)) bundleUsesSafeRe = true;
     return { v, jsFn, jsErrFn };
@@ -990,12 +1029,25 @@ function bundleStandalone(Validator, schemas, opts) {
     if (preambleSrc) preamble = preamble ? `${preamble}\n${preambleSrc}` : preambleSrc;
     const closureSrc = closureDeclLines(jsFn, 'var').join('\n');
     if (closureSrc) preamble = preamble ? `${preamble}\n${closureSrc}\n` : closureSrc + '\n';
+    // The runtime's passes over the data, for the options asked for, and its
+    // defaults pass as the validator's applyDefaults.
+    const fillDecl = defaultsDecl(v);
+    const pre = bundlePreprocess(v, opts, fillDecl, 'bundleStandalone');
+    preamble = preamble ? `${preamble}\n${fillDecl}${pre.decl}` : fillDecl + pre.decl;
+    const ret = (body) => fillDecl
+      ? `var _f=function(d){${pre.call}${body}};_f.applyDefaults=applyDefaults;return _f`
+      : `return function(d){${pre.call}${body}}`;
+    // In order: the collector's errors sorted as the runtime sorts them.
+    const hasErr = !!(jsErrFn && jsErrFn._errSource);
+    const errDecl = ordered && hasErr
+      ? `${require(AOT_ORDER_MODULE).orderDecl(v._schemaObj)}var E=function(d){var r=(function(d){var _all=true;${errBody}})(d);return r&&r.errors?{valid:false,errors:_ataOrder(r.errors)}:r};`
+      : `var E=function(d){var _all=true;${errBody}};`;
     if (opts && opts.verbose) {
       // Embed the schema and a small resolver so errors carry parentSchema.
       const schemaLit = JSON.stringify(v._schemaObj);
-      return `(function(R){${preamble}var _S=${schemaLit};function _PS(p){if(!p||p[0]!=='#')return undefined;var s=p.slice(1);if(!s)return _S;var ps=s.split('/').filter(Boolean).map(function(x){return x.replace(/~1/g,'/').replace(/~0/g,'~')});var t=_S;for(var i=0;i<ps.length-1;i++){if(t==null||typeof t!=='object')return undefined;t=t[ps[i]]}return t}var E=function(d){var _all=true;${errBody}};var _v=function(d){${jsFn._hybridSource}};return function(d){var r=_v(d);if(r&&r.valid===false&&r.errors){var es=[];for(var i=0;i<r.errors.length;i++){var e=r.errors[i];es.push(Object.assign({},e,{parentSchema:_PS(e.schemaPath)}))}return{valid:false,errors:es}}return r}})(R)`;
+      return `(function(R){${preamble}var _S=${schemaLit};function _PS(p){if(!p||p[0]!=='#')return undefined;var s=p.slice(1);if(!s)return _S;var ps=s.split('/').filter(Boolean).map(function(x){return x.replace(/~1/g,'/').replace(/~0/g,'~')});var t=_S;for(var i=0;i<ps.length-1;i++){if(t==null||typeof t!=='object')return undefined;t=t[ps[i]]}return t}${errDecl}var _v=function(d){${jsFn._hybridSource}};${ret('var r=_v(d);if(r&&r.valid===false&&r.errors){var es=[];for(var i=0;i<r.errors.length;i++){var e=r.errors[i];es.push(Object.assign({},e,{parentSchema:_PS(e.schemaPath)}))}return{valid:false,errors:es}}return r')}})(R)`;
     }
-    return `(function(R){${preamble}var E=function(d){var _all=true;${errBody}};return function(d){${jsFn._hybridSource}}})(R)`;
+    return `(function(R){${preamble}${errDecl}${ret(jsFn._hybridSource)}})(R)`;
   });
   const arr = `[${fns.join(',')}]`;
   // The code-point counter the length checks call. toStandaloneModule embeds

package/lib/compiled.js

@@ -17,6 +17,7 @@
 
 const { LazyRejection, RichRejection, LazyJsonRejection, _enrichLazy } = require('./rejections');
 const { COMPILED_OPTIONS, prepare, parse, installExtension, extendJSON, EXT_FALLBACK } = require('./compiled-common');
+const { installStandard } = require('./standard-schema');
 
 const VALID_RESULT = Object.freeze({ valid: true, errors: Object.freeze([]) });
 
@@ -99,6 +100,11 @@ function fromCompiled(mod, schema, options) {
       isValidJSON: json.isValidJSON,
     };
   });
+  // Standard Schema V1, as the runtime Validator hands it out, so a validator
+  // the build compiled away still works where the runtime one did (a form
+  // library, a router, an RPC layer). The schema it publishes is the one the
+  // module was built from, as the runtime reads it.
+  installStandard(api, () => schema, (self, value) => self.validate(value));
   return api;
 }
 

package/lib/standard-schema.js

@@ -0,0 +1,145 @@
+'use strict';
+
+// Standard Schema V1 for a validator: the `~standard` member a form library,
+// a router or an RPC layer reads instead of ata's own API. One module, so the
+// runtime Validator (lib/validator-core.js) and the wrapper around a module
+// written ahead of time (lib/compiled.js) hand out the same object built the
+// same way, and a validator the build compiled away still works where the
+// runtime one did.
+
+// Paths repeat across rejections of the same shape, so the parsed segment
+// list is cached per path string. Entries are frozen: the same array is
+// handed to every issue that names the path.
+//
+// The cache is bucketed by length and searched with ===, not keyed in a Map.
+// A path with an array index in it is concatenated afresh by every rejection,
+// and a Map has to hash each such string from scratch before it can look
+// anything up; that hashing was 30% of a Standard Schema rejection with
+// sixteen issues. Comparing against the few paths of the same length costs
+// less. Both levels are bounded so a stream of array indexes cannot grow it
+// without limit: a full bucket stops caching, too many lengths clear it.
+const _pathBuckets = new Map();
+const PATH_BUCKET_MAX = 32;
+const PATH_LENGTHS_MAX = 256;
+const EMPTY_PATH = Object.freeze([]);
+function parsePointerPath(path) {
+  if (!path) return EMPTY_PATH;
+  const n = path.length;
+  let bucket = _pathBuckets.get(n);
+  if (bucket !== undefined) {
+    for (let i = 0; i < bucket.length; i += 2) if (bucket[i] === path) return bucket[i + 1];
+  } else {
+    if (_pathBuckets.size >= PATH_LENGTHS_MAX) _pathBuckets.clear();
+    bucket = [];
+    _pathBuckets.set(n, bucket);
+  }
+  const segs = Object.freeze(parsePointerPathUncached(path));
+  if (bucket.length < PATH_BUCKET_MAX * 2) bucket.push(path, segs);
+  return segs;
+}
+
+function parsePointerPathUncached(path) {
+  // One pass, no intermediate arrays. Per Standard Schema V1 an array index
+  // is emitted as a number and an object key as a string; a segment is an
+  // index when it is all digits with no leading zero.
+  const out = [];
+  const n = path.length;
+  let start = 1;
+  for (let i = 1; i <= n; i++) {
+    if (i !== n && path.charCodeAt(i) !== 47) continue;
+    if (i > start) {
+      let seg = path.slice(start, i);
+      if (seg.indexOf('~') >= 0) seg = seg.replace(/~1/g, '/').replace(/~0/g, '~');
+      const c0 = seg.charCodeAt(0);
+      let numeric = c0 >= 48 && c0 <= 57 && (seg.length === 1 || c0 !== 48);
+      if (numeric) {
+        for (let k = 1; k < seg.length; k++) {
+          const c = seg.charCodeAt(k);
+          if (c < 48 || c > 57) { numeric = false; break; }
+        }
+      }
+      out.push({ key: numeric ? Number(seg) : seg });
+    }
+    start = i + 1;
+  }
+  return out;
+}
+
+// Standard JSON Schema, the `jsonSchema` member of `~standard`: what a consumer
+// such as the MCP SDK reads to publish a schema, from `input({ target })`.
+// ata validates the JSON Schema it was given and does not transform values, so
+// input and output are the same document, handed back as a copy when the
+// target is the schema's dialect: draft-07 when it declares draft-07, 2020-12
+// when it declares 2020-12 or nothing, as ata reads it. Any other target
+// throws, as the specification asks, rather than returning a document that
+// would mean something else there.
+function standardJsonSchema(getSchema) {
+  const convert = (options) => {
+    const target = options && options.target;
+    const schema = getSchema();
+    if (schema === true) return {};
+    if (schema === false) return { not: {} };
+    const declared = typeof schema.$schema === 'string' ? schema.$schema : '';
+    const dialect = declared === '' || declared.includes('draft/2020-12/schema') ? 'draft-2020-12'
+      : declared.includes('draft-07/schema') ? 'draft-07' : declared;
+    if (target !== dialect) {
+      throw new TypeError(`ata-validator cannot provide a ${dialect} schema as ${String(target)}; it does not convert between dialects`);
+    }
+    return JSON.parse(JSON.stringify(schema));
+  };
+  return Object.freeze({ input: convert, output: convert });
+}
+
+// The `~standard` object for `self`, a validator whose validate(value)
+// answers as ata's does: `getSchema(self)` returns the schema as the caller
+// wrote it, `validate(self, value)` is called each time, so an extension
+// installed later counts.
+function standardSchemaFor(self, getSchema, validate) {
+  return Object.freeze({
+    version: 1,
+    vendor: 'ata-validator',
+    jsonSchema: standardJsonSchema(() => getSchema(self)),
+    validate(value) {
+      const result = validate(self, value);
+      if (result.valid) {
+        return { value };
+      }
+      // An issue carries a message and a path and nothing else, so the
+      // suggestion and source-frame work the rich error path does would be
+      // thrown away here. Take the raw, schema-ordered list when the result
+      // offers one; fall back to the public list otherwise.
+      const raw = typeof result._ataRaw === 'function' ? result._ataRaw() : result.errors;
+      const issues = new Array(raw.length);
+      for (let i = 0; i < raw.length; i++) {
+        const err = raw[i];
+        const path = err.instancePath != null ? err.instancePath : (err.path || '');
+        let message = err.message;
+        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;
+        }
+        issues[i] = { message, path: parsePointerPath(path) };
+      }
+      return { issues };
+    },
+  });
+}
+
+// Installs `~standard` on `target` (an instance, or a prototype) as a lazy
+// accessor: built on first read for the object it is read from, then pinned
+// to that object as a plain, non-enumerable value, so a validator nobody asks
+// never builds it.
+function installStandard(target, getSchema, validate) {
+  Object.defineProperty(target, '~standard', {
+    configurable: true,
+    enumerable: false,
+    get() {
+      const std = standardSchemaFor(this, getSchema, validate);
+      Object.defineProperty(this, '~standard', { value: std, writable: false, enumerable: false, configurable: false });
+      return std;
+    },
+  });
+}
+
+module.exports = { parsePointerPath, standardJsonSchema, standardSchemaFor, installStandard };

package/lib/validator-core.js

@@ -25,6 +25,9 @@ function _registerCodegen(engine) {
   _codegen = engine;
   ({ compileToJS, compileToJSCodegen, compileToJSCodegenWithErrors, compileToJSCombined } = engine.jsCompiler);
 }
+// The code generator, loading it first where the entry loads it on need
+// (index.js); everywhere else, whatever is registered.
+let _loadCodegen = () => _codegen;
 // The ahead-of-time loaders without the code generator: the edge entry
 // (index.edge.js) registers lib/aot.browser.js here, so modules written by
 // `ata build` or Validator.bundle() load where generated code cannot run.
@@ -219,7 +222,7 @@ function collectRemovals(schema, actions, path) {
 // change within a realm and the probe itself is a code generation attempt.
 let _codegenAvailable = null;
 function codegenAvailable() {
-  if (_codegen === null) return false;
+  if (_loadCodegen() === null) return false;
   if (_codegenAvailable === null) {
     try {
       _codegenAvailable = compileFunction('return 1')() === 1;
@@ -355,64 +358,6 @@ function _jsonSyntaxRejection(e) {
 
 
 
-// Paths repeat across rejections of the same shape, so the parsed segment
-// list is cached per path string. Entries are frozen: the same array is
-// handed to every issue that names the path.
-//
-// The cache is bucketed by length and searched with ===, not keyed in a Map.
-// A path with an array index in it is concatenated afresh by every rejection,
-// and a Map has to hash each such string from scratch before it can look
-// anything up; that hashing was 30% of a Standard Schema rejection with
-// sixteen issues. Comparing against the few paths of the same length costs
-// less. Both levels are bounded so a stream of array indexes cannot grow it
-// without limit: a full bucket stops caching, too many lengths clear it.
-const _pathBuckets = new Map();
-const PATH_BUCKET_MAX = 32;
-const PATH_LENGTHS_MAX = 256;
-function parsePointerPath(path) {
-  if (!path) return EMPTY_PATH;
-  const n = path.length;
-  let bucket = _pathBuckets.get(n);
-  if (bucket !== undefined) {
-    for (let i = 0; i < bucket.length; i += 2) if (bucket[i] === path) return bucket[i + 1];
-  } else {
-    if (_pathBuckets.size >= PATH_LENGTHS_MAX) _pathBuckets.clear();
-    bucket = [];
-    _pathBuckets.set(n, bucket);
-  }
-  const segs = Object.freeze(parsePointerPathUncached(path));
-  if (bucket.length < PATH_BUCKET_MAX * 2) bucket.push(path, segs);
-  return segs;
-}
-const EMPTY_PATH = Object.freeze([]);
-
-function parsePointerPathUncached(path) {
-  // One pass, no intermediate arrays. Per Standard Schema V1 an array index
-  // is emitted as a number and an object key as a string; a segment is an
-  // index when it is all digits with no leading zero.
-  const out = [];
-  const n = path.length;
-  let start = 1;
-  for (let i = 1; i <= n; i++) {
-    if (i !== n && path.charCodeAt(i) !== 47) continue;
-    if (i > start) {
-      let seg = path.slice(start, i);
-      if (seg.indexOf('~') >= 0) seg = seg.replace(/~1/g, '/').replace(/~0/g, '~');
-      const c0 = seg.charCodeAt(0);
-      let numeric = c0 >= 48 && c0 <= 57 && (seg.length === 1 || c0 !== 48);
-      if (numeric) {
-        for (let k = 1; k < seg.length; k++) {
-          const c = seg.charCodeAt(k);
-          if (c < 48 || c > 57) { numeric = false; break; }
-        }
-      }
-      out.push({ key: numeric ? Number(seg) : seg });
-    }
-    start = i + 1;
-  }
-  return out;
-}
-
 function createPaddedBuffer(jsonStr) {
   if (typeof Buffer === 'undefined') throw new Error('createPaddedBuffer requires Node.js Buffer');
   const jsonBuf = Buffer.from(jsonStr);
@@ -951,7 +896,7 @@ class Validator {
   }
 
   _pos() {
-    return this._posCache || (this._posCache = require('./data-position-cache').createCache(_codegen !== null && _codegen.nativePositions ? _codegen.nativePositions() : null));
+    return this._posCache || (this._posCache = require('./data-position-cache').createCache(_loadCodegen() !== null && _codegen.nativePositions ? _codegen.nativePositions() : null));
   }
 
   _ensureVocabularies() {
@@ -1102,7 +1047,7 @@ class Validator {
     // pass looks for one. One reached through a reference into another
     // document is walked, since its defaults are not in this text.
     const mayHaveDefaults = preprocessSchema !== schemaObj || this._schemaStr.includes('"default"');
-    if (!this._interpretOnly && _codegen !== null) {
+    if (!this._interpretOnly && _loadCodegen() !== null) {
       const cacheable = !this._userFormats && !this._usesKeywords;
       const ppKey = cacheable ? mapKey + '\u0000' + String(options.coerceTypes) + '|' + (options.useDefaults !== false) + '|' + String(options.removeAdditional) : null;
       const hit = ppKey !== null ? _preprocessCache.get(ppKey) : undefined;
@@ -1726,7 +1671,7 @@ class Validator {
       return;
     }
     this._ensureVocabularies();
-    if (this._interpretOnly || _codegen === null || env('ATA_FORCE_NAPI')) return;
+    if (this._interpretOnly || env('ATA_FORCE_NAPI') || _loadCodegen() === null) return;
     _codegen.compileVerdict.call(this);
   }
 
@@ -1736,7 +1681,7 @@ class Validator {
   static fromStandalone(mod, schema, opts) {
     // It loads what Validator.bundleStandalone() writes, and compiles an error
     // function when the module carries none, so it goes with those methods.
-    if (_codegen === null && _aotLoader === null && _tiering === null) throw new TypeError('Validator.fromStandalone is not part of ata-validator/lite, like the bundle methods it loads for. Import it from ata-validator, or import a module from `ata build` directly.');
+    if (_loadCodegen() === null && _aotLoader === null && _tiering === null) throw new TypeError('Validator.fromStandalone is not part of ata-validator/lite, like the bundle methods it loads for. Import it from ata-validator, or import a module from `ata build` directly.');
     const options = opts || {};
     const schemaObj = typeof schema === "string" ? JSON.parse(schema) : schema;
 
@@ -1835,23 +1780,9 @@ class Validator {
       }
     };
 
-    // Standard Schema V1
+    // Standard Schema V1, the same object a Validator hands out.
     Object.defineProperty(v, "~standard", {
-      value: Object.freeze({
-        version: 1,
-        vendor: "ata-validator",
-        jsonSchema: standardJsonSchema(() => schemaObj),
-        validate(value) {
-          const result = v.validate(value);
-          if (result.valid) return { value };
-          return {
-            issues: result.errors.map((e) => ({
-              message: e.message,
-              path: parsePointerPath(e.instancePath),
-            })),
-          };
-        },
-      }),
+      value: require('./standard-schema').standardSchemaFor(v, () => schemaObj, (self, value) => self.validate(value)),
       writable: false,
       enumerable: false,
       configurable: false,
@@ -1922,7 +1853,7 @@ function version() {
 // generated module shapes; browser bundles get `lib/aot.browser.js` (a stub
 // that throws) via the package.json `browser` field.
 function _aot() {
-  if (_codegen !== null) return _codegen.aot();
+  if (_loadCodegen() !== null) return _codegen.aot();
   if (_aotLoader !== null) return _aotLoader();
   // The browser build: emitters stay out of the page, as they did when the
   // generator was in it (the package.json browser field maps lib/aot.js to
@@ -1991,74 +1922,19 @@ function defineSchema (schema) {
 // bound closure, stores it on the instance as an ordinary writable property
 // and returns it. The setter keeps the compile step's plain assignments
 // (`this.validate = fn`) working before the getter has ever run. Detached
-// Standard JSON Schema, the `jsonSchema` member of `~standard`: what a consumer
-// such as the MCP SDK reads to publish a schema, from `input({ target })`.
-// ata validates the JSON Schema it was given and does not transform values, so
-// input and output are the same document, handed back as a copy when the
-// target is the schema's dialect: draft-07 when it declares draft-07, 2020-12
-// when it declares 2020-12 or nothing, as ata reads it. Any other target
-// throws, as the specification asks, rather than returning a document that
-// would mean something else there.
-function standardJsonSchema(getSchema) {
-  const convert = (options) => {
-    const target = options && options.target;
-    const schema = getSchema();
-    if (schema === true) return {};
-    if (schema === false) return { not: {} };
-    const declared = typeof schema.$schema === 'string' ? schema.$schema : '';
-    const dialect = declared === '' || declared.includes('draft/2020-12/schema') ? 'draft-2020-12'
-      : declared.includes('draft-07/schema') ? 'draft-07' : declared;
-    if (target !== dialect) {
-      throw new TypeError(`ata-validator cannot provide a ${dialect} schema as ${String(target)}; it does not convert between dialects`);
-    }
-    return JSON.parse(JSON.stringify(schema));
-  };
-  return Object.freeze({ input: convert, output: convert });
-}
-
 // use (`const f = v.validate`) keeps working because the closure binds the
 // instance.
 // Standard Schema V1. Built on first read, then pinned to the instance with
 // the same descriptor the constructor used to install eagerly.
+// Lazy on the prototype, pinned to the instance on first read; the object
+// comes from lib/standard-schema.js, shared with the wrapper around a module
+// written ahead of time, and loaded only when something reads `~standard`.
 Object.defineProperty(Validator.prototype, "~standard", {
   configurable: true,
+  enumerable: false,
   get() {
-    const self = this;
-    const std = Object.freeze({
-      version: 1,
-      vendor: "ata-validator",
-      jsonSchema: standardJsonSchema(() => self._rawSchema),
-      validate(value) {
-        const result = self.validate(value);
-        if (result.valid) {
-          return { value };
-        }
-        // An issue carries a message and a path and nothing else, so the
-        // suggestion and source-frame work the rich error path does would be
-        // thrown away here. Take the raw, schema-ordered list when the result
-        // offers one; fall back to the public list otherwise.
-        const raw = typeof result._ataRaw === 'function' ? result._ataRaw() : result.errors;
-        const issues = new Array(raw.length);
-        for (let i = 0; i < raw.length; i++) {
-          const err = raw[i];
-          const path = err.instancePath != null ? err.instancePath : (err.path || '');
-          let message = err.message;
-          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;
-          }
-          issues[i] = { message, path: parsePointerPath(path) };
-        }
-        return { issues };
-      },
-    });
-    Object.defineProperty(this, "~standard", {
-      value: std,
-      writable: false,
-      enumerable: false,
-      configurable: false,
-    });
+    const std = require('./standard-schema').standardSchemaFor(this, (self) => self._rawSchema, (self, value) => self.validate(value));
+    Object.defineProperty(this, "~standard", { value: std, writable: false, enumerable: false, configurable: false });
     return std;
   },
 });
@@ -2346,7 +2222,7 @@ function _buildParse(self) {
     later._untilCodegen = true;
     return later;
   }
-  if (_codegen === null) return decline('this entry has no code generator to build the copy with', 'Use validate(); a valid result carries the input as it is.');
+  if (_loadCodegen() === null) return decline('this entry has no code generator to build the copy with', 'Use validate(); a valid result carries the input as it is.');
   return _codegen.buildParse(self, decline, extended);
 }
 
@@ -2417,7 +2293,8 @@ 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.
 Validator.prototype._coldTwin = function () {
-  return _codegen === null || _codegen.coldTwin === undefined ? null : _codegen.coldTwin(this, Validator);
+  const cg = _loadCodegen();
+  return cg === null || cg.coldTwin === undefined ? null : cg.coldTwin(this, Validator);
 };
 
 _defineLazyMethod('validate', (self) => (data) => {
@@ -2529,9 +2406,10 @@ module.exports = {
 // How an entry registers the code generator. Not enumerable, so the exported
 // surface of `require('ata-validator')` is what it was.
 Object.defineProperty(module.exports, '_registerCodegen', { value: _registerCodegen, enumerable: false });
+Object.defineProperty(module.exports, '_setCodegenLoader', { value: (load) => { _loadCodegen = load; }, enumerable: false });
 Object.defineProperty(module.exports, '_registerTiering', { value: _registerTiering, 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 });
 // What the compiled paths in index.js need from this module.
-Object.defineProperty(module.exports, '_internals', { value: { _interpArgs, _normalizeCallerSchemaUncached, resolveSchemaForPreprocess, _jsonSyntaxRejection, ABORT_EARLY_RESULT, HYBRID_TIER_CALLS, SIMDJSON_THRESHOLD, VALID_RESULT, _bindEntry, _bindVerdict, _compileCache, _compileCacheSet, _mustReject, _rememberInstance, _verboseWrap, compileCacheKey, getNative, isV1Dialect, resolveSchemaByPath }, enumerable: false });
+Object.defineProperty(module.exports, '_internals', { value: { _interpArgs, _normalizeCallerSchemaUncached, resolveSchemaForPreprocess, buildCoercer, buildRemover, _jsonSyntaxRejection, ABORT_EARLY_RESULT, HYBRID_TIER_CALLS, SIMDJSON_THRESHOLD, VALID_RESULT, _bindEntry, _bindVerdict, _compileCache, _compileCacheSet, _mustReject, _rememberInstance, _verboseWrap, compileCacheKey, getNative, isV1Dialect, resolveSchemaByPath }, 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.58.1';
+module.exports = '1.60.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "1.58.1",
+  "version": "1.60.0",
   "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",
@@ -186,13 +186,13 @@
     "codegen.d.ts"
   ],
   "optionalDependencies": {
-    "@ata-validator/native-darwin-arm64": "1.58.1",
-    "@ata-validator/native-darwin-x64": "1.58.1",
-    "@ata-validator/native-linux-arm64-gnu": "1.58.1",
-    "@ata-validator/native-linux-arm64-musl": "1.58.1",
-    "@ata-validator/native-linux-x64-gnu": "1.58.1",
-    "@ata-validator/native-linux-x64-musl": "1.58.1",
-    "@ata-validator/native-win32-x64": "1.58.1"
+    "@ata-validator/native-darwin-arm64": "1.60.0",
+    "@ata-validator/native-darwin-x64": "1.60.0",
+    "@ata-validator/native-linux-arm64-gnu": "1.60.0",
+    "@ata-validator/native-linux-arm64-musl": "1.60.0",
+    "@ata-validator/native-linux-x64-gnu": "1.60.0",
+    "@ata-validator/native-linux-x64-musl": "1.60.0",
+    "@ata-validator/native-win32-x64": "1.60.0"
   },
   "peerDependencies": {
     "yaml": "^2.0.0"