ata-validator 1.59.0 → 1.60.0

package/lib/aot-impl.js

@@ -379,20 +379,20 @@ function defaultsDecl(validator) {
 // 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 }.
-function bundlePreprocess(validator, opts, fillDecl, label) {
+// 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(d);' : '' };
+  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(d);' };
+  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(d);' : '' };
+  return { decl: '', call: useDefaults && fillDecl ? `applyDefaults(${arg});` : '' };
 }
 
 function toStandaloneModule(validator, opts) {
@@ -408,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 = '';
@@ -636,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
@@ -725,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}`;
 }
 

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

@@ -358,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);
@@ -1838,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,
@@ -1994,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;
   },
 });

package/lib/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "1.59.0",
+  "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.59.0",
-    "@ata-validator/native-darwin-x64": "1.59.0",
-    "@ata-validator/native-linux-arm64-gnu": "1.59.0",
-    "@ata-validator/native-linux-arm64-musl": "1.59.0",
-    "@ata-validator/native-linux-x64-gnu": "1.59.0",
-    "@ata-validator/native-linux-x64-musl": "1.59.0",
-    "@ata-validator/native-win32-x64": "1.59.0"
+    "@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"