ata-validator 1.62.1 → 1.63.0

package/lib/schema-helpers.js

@@ -0,0 +1,12 @@
+'use strict';
+
+// defineSchema and schemaOf outside the core; lib/schema-helpers.mjs says why.
+function defineSchema (schema) {
+  return schema;
+}
+
+function schemaOf () {
+  throw new Error('schemaOf<T>() is replaced at build time by @ata-project/unplugin (with ts-json-schema-generator installed); it has no run-time form. Write the JSON Schema, or build with the plugin.');
+}
+
+module.exports = { defineSchema, schemaOf };

package/lib/schema-helpers.mjs

@@ -0,0 +1,20 @@
+// The ES form of lib/schema-helpers.js, for the ES entries. Those entries read
+// each core name through a call marked pure, so a module that imports only
+// `defineSchema` leaves the validator core out of its bundle; a destructuring
+// `export const { ... } = core` was kept whole, and a form whose validator the
+// build plugin had compiled away still shipped the runtime through it. The core
+// holds no copy, so a bundle carries the helpers once.
+// tests/test_define_schema_bundle.js covers both forms.
+
+// Identity at run time: it gives an inline schema its JSONSchema type
+// (index.d.ts) for autocomplete and value checks while authoring.
+export function defineSchema (schema) {
+  return schema;
+}
+
+// Written in by @ata-project/unplugin from a TypeScript type at build time. A
+// call that reaches run time was not replaced, and a loud error beats an
+// empty schema that accepts everything.
+export function schemaOf () {
+  throw new Error('schemaOf<T>() is replaced at build time by @ata-project/unplugin (with ts-json-schema-generator installed); it has no run-time form. Write the JSON Schema, or build with the plugin.');
+}

package/lib/schema-order.js

@@ -140,8 +140,10 @@ function computeRank(rootSchema, schemaPath) {
 function remoteTarget(docs, base, node) {
   const ref = node.$ref;
   if (typeof ref !== 'string' || ref.charCodeAt(0) === 35) return null;
-  const abs = resolveUri(ref, base);
-  if (abs === null) return null;
+  // A name with no base to resolve against (a root without $id referencing
+  // `shared#`) is looked up as written, the way such documents are registered
+  // (schemas: [{ $id: 'shared' }]); it used to stop the rank there.
+  const abs = resolveUri(ref, base) || ref;
   const hash = abs.indexOf('#');
   const uri = hash < 0 ? abs : abs.slice(0, hash);
   let target = docs.get(uri);

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('./native-message')(err);
+          { const m = require('./native-message'); message = (typeof m === 'function' ? m : m.default)(err); }
         }
         issues[i] = { message, path: parsePointerPath(path) };
       }

package/lib/validator-core.js

@@ -6,8 +6,14 @@
 // threshold, version(). Loading it at require cost about 1.9 ms of a 9.7 ms
 // serverless start, for every process that never calls any of those.
 let _nativeMod;
+// A module whose exports are one function, as a function. A CDN that turns
+// each CommonJS file into an ES module (esm.sh) hands require() an object
+// with the function on `default`, and calling it threw on the first
+// validator. Node and bundlers hand over the function itself.
+function callable(m) { return typeof m === 'function' ? m : m.default; }
+
 function getNative() {
-  if (_nativeMod === undefined) _nativeMod = require("./native-load")();
+  if (_nativeMod === undefined) _nativeMod = callable(require("./native-load"))();
   return _nativeMod;
 }
 const { env } = require('./env');
@@ -83,9 +89,9 @@ const _hasOwn = Object.prototype.hasOwnProperty;
 
 // Build a function that coerces property values to match schema types in-place.
 // Handles string→number, string→integer, string→boolean, number→string, boolean→string.
-function buildCoercer(schema) {
+function buildCoercer(schema, arrayMode) {
   if (typeof schema !== "object" || schema === null) return null;
-  const node = buildNodeCoercer(schema, new Set());
+  const node = buildNodeCoercer(schema, new Set(), arrayMode === true);
   if (node === null) return null;
   return (data) => { if (typeof data === "object" && data !== null) node(data); };
 }
@@ -101,7 +107,7 @@ function coercionFor(schema, seen) {
 
 // The steps for the object or array at `schema`. `seen` stops a schema that
 // contains itself through an inline cycle.
-function buildNodeCoercer(schema, seen) {
+function buildNodeCoercer(schema, seen, arrayMode) {
   if (seen.has(schema)) return null;
   seen.add(schema);
   const steps = [];
@@ -110,13 +116,17 @@ function buildNodeCoercer(schema, seen) {
       // Assignment to `__proto__` would replace the prototype; the generated
       // pass skips it for the same reason.
       if (key === "__proto__") continue;
+      // coerceTypes: 'array' wraps a lone value of a top-level property typed
+      // array, as the generated pass does; this pass used to leave it.
+      const wrap = arrayMode === true && prop && prop.type === "array";
       const c = coercionFor(prop, seen);
-      if (!c) continue;
-      const { scalar, inner } = c;
+      if (!c && !wrap) continue;
+      const { scalar, inner } = c || {};
       steps.push((o) => {
         // Own properties only: `key in o` found values the object inherits,
         // and the pass then rewrote the shared object behind them.
         if (!_hasOwn.call(o, key)) return;
+        if (wrap && o[key] !== undefined && !Array.isArray(o[key])) o[key] = [o[key]];
         if (scalar) {
           const v = scalar(o[key]);
           if (v !== undefined) o[key] = v;
@@ -964,6 +974,14 @@ class Validator {
 
   _ensureCompiled() {
     if (this._initialized) return;
+    // A compile that throws (a custom keyword's compile returning no
+    // function, say) leaves the validator uncompiled, so the next call throws
+    // the same error. The flag stayed set, and the next call's lazy method
+    // called itself until the stack ran out.
+    try { this._compile(); } catch (e) { this._initialized = false; throw e; }
+  }
+
+  _compile() {
     if (LazyRejection === undefined) _loadRejections();
     this._ensureVocabularies();
     this._initialized = true;
@@ -1002,7 +1020,7 @@ class Validator {
     // The generated code takes the form of the target engine (js-compiler's
     // setTargetEngine), so a function written for one engine is never handed
     // to a compile asked for the other in the same process.
-    const mapKey = compileCacheKey(this._schemaStr, this._schemaMap) + '\u0000' + (_codegen && _codegen.jsCompiler && typeof _codegen.jsCompiler.targetEngine === 'function' ? _codegen.jsCompiler.targetEngine() : 'v8');
+    const mapKey = (_codegen !== null && _codegen.keyFor !== undefined && _codegen.keyFor(this)) || compileCacheKey(this._schemaStr, this._schemaMap) + '\u0000' + (_codegen && _codegen.jsCompiler && typeof _codegen.jsCompiler.targetEngine === 'function' ? _codegen.jsCompiler.targetEngine() : 'v8');
     var _forceNapi = this._interpretOnly || env('ATA_FORCE_NAPI');
     // Custom formats are JS functions: bypass the compile cache since they can
     // differ between validators that share the same schema string. An
@@ -1112,7 +1130,7 @@ class Validator {
     if (!preprocess) {
       // Without a `default` in the text the defaults module stays unloaded.
       const applyDefaults = options.useDefaults === false || !mayHaveDefaults ? null : buildDefaultsApplier(preprocessSchema);
-      const applyCoerce = options.coerceTypes ? buildCoercer(preprocessSchema) : null;
+      const applyCoerce = options.coerceTypes ? buildCoercer(preprocessSchema, options.coerceTypes === 'array') : null;
       const applyRemove = options.removeAdditional
         ? buildRemover(preprocessSchema)
         : null;
@@ -1626,7 +1644,7 @@ class Validator {
   _ensureNative() {
     if (this._nativeReady) return;
     this._nativeReady = true;
-    require('./native-attach.js')(this, getNative());
+    callable(require('./native-attach.js'))(this, getNative());
   }
 
   // The buffer APIs, installed on the first call to any of them. The schema
@@ -1647,7 +1665,7 @@ class Validator {
     if (!native && typeof Buffer === 'undefined') throw new Error(`Native addon required for ${name}(). Use validate(), isValidObject() or validateJSON(), which do not need it.`);
     const { bufferNeedsSlowPath, installSlowBufferApis } = require('./buffer-gate.js');
     if (!native) return installSlowBufferApis(this);
-    require('./native-attach.js').installFast(this, native, bufferNeedsSlowPath, installSlowBufferApis);
+    callable(require('./native-attach.js')).installFast(this, native, bufferNeedsSlowPath, installSlowBufferApis);
   }
 
   addSchema(schema) {
@@ -1688,7 +1706,12 @@ class Validator {
       return;
     }
     this._ensureVocabularies();
-    if (this._interpretOnly || env('ATA_FORCE_NAPI') || _loadCodegen() === null) return;
+    // Where the realm refuses generated code (a strict CSP,
+    // --disallow-code-generation-from-strings) the verdict-only compile could
+    // only reach the closure compiler, which answers in about twice the time
+    // of the interpreted engine the full compile binds there; the callers
+    // fall through to that compile when this leaves no function.
+    if (this._interpretOnly || env('ATA_FORCE_NAPI') || _loadCodegen() === null || !codegenAvailable()) return;
     _codegen.compileVerdict.call(this);
   }
 
@@ -1710,7 +1733,7 @@ class Validator {
 
     // Mutators
     const applyDefaults = buildDefaultsApplier(schemaObj);
-    const applyCoerce = options.coerceTypes ? buildCoercer(schemaObj) : null;
+    const applyCoerce = options.coerceTypes ? buildCoercer(schemaObj, options.coerceTypes === 'array') : null;
     const applyRemove = options.removeAdditional
       ? buildRemover(schemaObj)
       : null;
@@ -1941,22 +1964,6 @@ function compile(schema, opts) {
 // and the suggestion helper are exported by index.js. None of them is called
 // by a Validator, so ata-validator/lite leaves them out.
 
-// Authoring helper: identity at runtime. Its only job is to attach the
-// JSONSchema type (see index.d.ts) to an inline schema object so TypeScript
-// gives autocomplete and value checking while authoring. Returns the schema
-// untouched so it can be passed straight to Validator, toStandaloneModule, etc.
-// `schemaOf<T>()`: the JSON Schema of a TypeScript type, written in by
-// @ata-project/unplugin at build time from the type and its JSDoc tags. It
-// has no run-time form: a call that reaches here was not replaced, and the
-// loud error is better than an empty schema that accepts everything.
-function schemaOf () {
-  throw new Error('schemaOf<T>() is replaced at build time by @ata-project/unplugin (with ts-json-schema-generator installed); it has no run-time form. Write the JSON Schema, or build with the plugin.');
-}
-
-function defineSchema (schema) {
-  return schema;
-}
-
 // Public methods start as memoized accessors on the prototype. A fresh
 // Validator allocates none of them; the first read of a method builds the
 // bound closure, stores it on the instance as an ordinary writable property
@@ -2457,8 +2464,6 @@ module.exports = {
   createPaddedBuffer,
   SIMDJSON_PADDING,
   parseJSON,
-  defineSchema,
-  schemaOf,
 };
 // How an entry registers the code generator. Not enumerable, so the exported
 // surface of `require('ata-validator')` is what it was.

package/lib/version.js

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

package/lite.js

@@ -15,12 +15,17 @@
 // where the size of what ships matters more than nanoseconds per call.
 const core = require('./lib/validator-core.js');
 
+// Loaded on first call, like the tools: a process that never calls them does
+// not read the file.
+function defineSchema (schema) { return require('./lib/schema-helpers.js').defineSchema(schema); }
+function schemaOf (...a) { return require('./lib/schema-helpers.js').schemaOf(...a); }
+
 module.exports = {
   Validator: core.Validator,
   validate: core.validate,
   validateAsync: core.validateAsync,
   parseAsync: core.parseAsync,
-  defineSchema: core.defineSchema,
-  schemaOf: core.schemaOf,
+  defineSchema,
+  schemaOf,
   version: core.version,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "1.62.1",
+  "version": "1.63.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",
@@ -109,6 +109,24 @@
       "types": "./codegen.d.ts",
       "import": "./codegen.mjs",
       "require": "./codegen.js"
+    },
+    "./kernels": {
+      "import": "./lib/kernels/index.mjs"
+    },
+    "./plan": {
+      "types": "./lib/kernels/plan.d.ts",
+      "import": "./lib/kernels/plan.mjs"
+    },
+    "./plan-rich": {
+      "types": "./lib/kernels/plan.d.ts",
+      "import": "./lib/kernels/plan-rich.mjs"
+    },
+    "./openapi": {
+      "types": "./lib/openapi.d.ts",
+      "default": "./lib/openapi.js"
+    },
+    "./ir": {
+      "import": "./lib/ir/index.mjs"
     }
   },
   "sideEffects": [
@@ -248,13 +266,13 @@
     "codegen.d.ts"
   ],
   "optionalDependencies": {
-    "@ata-validator/native-darwin-arm64": "1.62.1",
-    "@ata-validator/native-darwin-x64": "1.62.1",
-    "@ata-validator/native-linux-arm64-gnu": "1.62.1",
-    "@ata-validator/native-linux-arm64-musl": "1.62.1",
-    "@ata-validator/native-linux-x64-gnu": "1.62.1",
-    "@ata-validator/native-linux-x64-musl": "1.62.1",
-    "@ata-validator/native-win32-x64": "1.62.1"
+    "@ata-validator/native-darwin-arm64": "1.63.0",
+    "@ata-validator/native-darwin-x64": "1.63.0",
+    "@ata-validator/native-linux-arm64-gnu": "1.63.0",
+    "@ata-validator/native-linux-arm64-musl": "1.63.0",
+    "@ata-validator/native-linux-x64-gnu": "1.63.0",
+    "@ata-validator/native-linux-x64-musl": "1.63.0",
+    "@ata-validator/native-win32-x64": "1.63.0"
   },
   "peerDependencies": {
     "yaml": "^2.0.0"