ata-validator 1.62.1 → 1.63.1

package/lib/plan-compiler.js

@@ -56,6 +56,21 @@ function install(deps) {
           T_STRING, T_NUMBER, T_INTEGER, T_BOOLEAN, T_NULL, T_ARRAY, T_OBJECT, resolveRef, splitFragment, resolveUri } = deps;
 
   const TRUE_FN = () => true;
+  // Leaf codes (leafCode in compileLeafV): a string with lengths and a
+  // pattern, an integer or a number with minimum and maximum, a boolean, an
+  // enum of primitives, a primitive const. Each answers as the closure it
+  // stands for.
+  const LC_STR = 1, LC_INT = 2, LC_NUM = 3, LC_BOOL = 4, LC_ENUM = 5, LC_CONST = 6;
+  function leafOk(c, d) {
+    switch (c[0]) {
+      case LC_STR: return typeof d === 'string' && (c[1] === -1 || cpAtLeast(d, c[1])) && (c[2] === -1 || cpAtMost(d, c[2])) && (c[3] === null || c[3].test(d));
+      case LC_INT: case LC_NUM: return (c[0] === LC_INT ? Number.isInteger(d) : typeof d === 'number' && isFinite(d)) && d >= c[1] && d <= c[2];
+      case LC_BOOL: return typeof d === 'boolean';
+      case LC_ENUM: return c[1].has(d);
+      default: return d === c[1];
+    }
+  }
+
   // `leaf`: the node compiled no subschema of its own (see compileNode). A
   // collecting caller asks a leaf for its verdict first and builds the paths
   // for its errors only when it fails.
@@ -92,6 +107,7 @@ function install(deps) {
   function fresh() { return { props: null, n: 0, x: null, keys: null }; }
   // Object.keys once per record: every node that shares a record sees the
   // same data object.
+  const propEnum = Object.prototype.propertyIsEnumerable;
   function keysOf(rec, data) {
     if (rec.keys === null) rec.keys = Object.keys(data);
     return rec.keys;
@@ -183,11 +199,17 @@ function install(deps) {
     // chain of guarded checks: the interpreted engine spent a fifth of a
     // document in those calls.
     const reqFolded = P.required !== null && P.requiredUndef === null && P.properties !== null;
+    // The operands of the commonest leaves, for an object walk that checks
+    // them in place (leafCode below): bounds that are only minimum and
+    // maximum, and string checks that are only lengths and a pattern.
+    let nLo = -Infinity, nHi = Infinity, nPlain = true;
+    let sLo = -1, sHi = -1, sRe = null, sPlain = true;
     let numsRun = null;
     if (P.hasNumber) {
       const nums = [];
-      if (P.minimum !== undefined) { const m = P.minimum; nums.push((d) => d >= m); }
-      if (P.maximum !== undefined) { const m = P.maximum; nums.push((d) => d <= m); }
+      if (P.minimum !== undefined) { const m = P.minimum; nLo = m; nums.push((d) => d >= m); }
+      if (P.maximum !== undefined) { const m = P.maximum; nHi = m; nums.push((d) => d <= m); }
+      if (P.exclusiveMinimum !== undefined || P.exclusiveMaximum !== undefined || P.multipleOf !== undefined) nPlain = false;
       if (P.exclusiveMinimum !== undefined) { const m = P.exclusiveMinimum; nums.push((d) => d > m); }
       if (P.exclusiveMaximum !== undefined) { const m = P.exclusiveMaximum; nums.push((d) => d < m); }
       if (P.multipleOf !== undefined) { const m = P.multipleOf; nums.push((d) => multipleOfOk(d, m)); }
@@ -196,6 +218,10 @@ function install(deps) {
     let strsRun = null;
     if (P.hasString) {
       const strs = [];
+      if (P.minLength !== undefined) sLo = P.minLength;
+      if (P.maxLength !== undefined) sHi = P.maxLength;
+      if (P.pattern !== null) sRe = P.pattern;
+      if (P.formatFn !== null) sPlain = false;
       if (P.minLength !== undefined && P.maxLength !== undefined) {
         const lo = P.minLength, hi = P.maxLength;
         strs.push((d) => { const n = d.length; return (n >= 2 * lo && n <= hi) || (cpAtLeast(d, lo) && cpAtMost(d, hi)); });
@@ -254,10 +280,10 @@ function install(deps) {
       if (!foreign) {
         const r = own;
         switch (m) {
-          case T_STRING: return r === null ? (d) => typeof d === 'string' : (d) => typeof d === 'string' && r(d);
-          case T_INTEGER: return r === null ? (d) => Number.isInteger(d) : (d) => Number.isInteger(d) && r(d);
-          case T_NUMBER: return r === null ? (d) => typeof d === 'number' && isFinite(d) : (d) => typeof d === 'number' && isFinite(d) && r(d);
-          case T_BOOLEAN: return (d) => typeof d === 'boolean';
+          case T_STRING: return leafCode(r === null ? (d) => typeof d === 'string' : (d) => typeof d === 'string' && r(d), sPlain ? [LC_STR, sLo, sHi, sRe] : null);
+          case T_INTEGER: return leafCode(r === null ? (d) => Number.isInteger(d) : (d) => Number.isInteger(d) && r(d), nPlain ? [LC_INT, nLo, nHi] : null);
+          case T_NUMBER: return leafCode(r === null ? (d) => typeof d === 'number' && isFinite(d) : (d) => typeof d === 'number' && isFinite(d) && r(d), nPlain ? [LC_NUM, nLo, nHi] : null);
+          case T_BOOLEAN: return leafCode((d) => typeof d === 'boolean', [LC_BOOL]);
           case T_NULL: return (d) => d === null;
           case T_OBJECT: return r === null ? (d) => typeof d === 'object' && d !== null && !Array.isArray(d) : (d) => typeof d === 'object' && d !== null && !Array.isArray(d) && r(d);
           case T_ARRAY: return r === null ? (d) => Array.isArray(d) : (d) => Array.isArray(d) && r(d);
@@ -279,7 +305,16 @@ function install(deps) {
     }
     if (checks.length === 0) return TRUE_FN;
     if (!needsBits) {
-      if (checks.length === 1) { const a = checks[0]; return (data) => a(data, 0); }
+      if (checks.length === 1) {
+        const a = checks[0];
+        const fn = (data) => a(data, 0);
+        // An enum of primitives alone, or a primitive const alone.
+        if (!P.hasType && !P.hasCustom && numsRun === null && strsRun === null && arrsRun === null && objsRun === null) {
+          if (P.enum !== null && P.enum.length > 0 && P.enumObjs.length === 0) return leafCode(fn, [LC_ENUM, P.enumPrims]);
+          if (P.hasConst && P.enum === null && (P.const === null || typeof P.const !== 'object')) return leafCode(fn, [LC_CONST, P.const]);
+        }
+        return fn;
+      }
       return (data) => {
         for (let i = 0; i < checks.length; i++) if (!checks[i](data, 0)) return false;
         return true;
@@ -297,6 +332,16 @@ function install(deps) {
     };
   }
 
+  // A leaf check that an object walk may run in place, by its code and
+  // operands, instead of calling it: one call site calling every property's
+  // check cannot be inlined, and on a form the calls were most of the
+  // verdict. leafOk must answer as the function does; tests/test_plan_leaf_codes.js
+  // holds the two to each other.
+  function leafCode(fn, code) {
+    if (code !== null) fn.lc = code;
+    return fn;
+  }
+
   // Folds a group's checks into one call, or null when the group is empty.
   function combineValue(fns) {
     if (fns.length === 0) return null;
@@ -565,9 +610,10 @@ function install(deps) {
       steps.push((data, errors, instancePath, schemaPath, stack, rec) => {
         if (dataBits(data) !== T_OBJECT) return true;
         let ok = true;
-        const keys = collect ? keysOf(rec, data) : Object.keys(data);
+        const keys = collect ? keysOf(rec, data) : Object.getOwnPropertyNames(data);
         if (pnFn !== null) {
           for (const k of keys) {
+            if (!collect && !propEnum.call(data, k)) continue;
             // propertyNames applies its subschema to the property NAME, not to
             // the value sitting at that key, so the failure is reported against
             // the object that carries the name rather than against `/<key>`.
@@ -599,7 +645,11 @@ function install(deps) {
             }
             evaluated = true;
           }
-          if (patterns !== null) {
+          // A name only properties lists is read whether enumerable or not,
+          // as the short walk above and the generated code read it by name;
+          // patterns and additionalProperties see the names for-in sees.
+          const seen = collect || prop !== undefined && patterns === null && apFn === null || propEnum.call(data, key);
+          if (patterns !== null && seen) {
             for (let pi = 0; pi < patterns.length; pi++) {
               const pp = patterns[pi];
               if (pp.re.test(key)) {
@@ -611,7 +661,7 @@ function install(deps) {
               }
             }
           }
-          if (!evaluated && apFn !== null) {
+          if (!evaluated && apFn !== null && seen) {
             if (apFalse) {
               ok = false;
               if (errors === NOERRORS) return false;
@@ -671,9 +721,9 @@ function install(deps) {
         vsteps.push((data, stack, rec) => {
         if (fusedLeaf !== null && !fusedLeaf(data)) return false;
         if (dataBits(data) !== T_OBJECT) return true;
-        const keys = collect ? keysOf(rec, data) : Object.keys(data);
+        const keys = collect ? keysOf(rec, data) : Object.getOwnPropertyNames(data);
         if (pnFn !== null) {
-          for (const k of keys) if (!pnFn.v(k, stack)) return false;
+          for (const k of keys) if ((collect || propEnum.call(data, k)) && !pnFn.v(k, stack)) return false;
         }
         let seenReq = 0;
         for (let k = 0; k < keys.length; k++) {
@@ -687,7 +737,8 @@ function install(deps) {
             if (prop.req) seenReq++;
             evaluated = true;
           }
-          if (patterns !== null) {
+          const seen = collect || prop !== undefined && patterns === null && apFn === null || propEnum.call(data, key);
+          if (patterns !== null && seen) {
             for (let pi = 0; pi < patterns.length; pi++) {
               const pp = patterns[pi];
               if (pp.re.test(key)) {
@@ -696,7 +747,7 @@ function install(deps) {
               }
             }
           }
-          if (!evaluated && apFn !== null) {
+          if (!evaluated && apFn !== null && seen) {
             if (!apFn.v(data[key], stack)) return false;
             evaluated = true;
           }
@@ -704,6 +755,54 @@ function install(deps) {
         }
         return seenReq === reqN;
       });
+        // From three names to 32: below three the key array costs less than
+        // the for-in (1.7 ns on one name), past 32 the scan costs more.
+        if (apFalse && patterns === null && pnFn === null && !collect && propKeys !== null && propKeys.length >= 3 && propKeys.length <= 32) {
+          // A closed object with a short list of names, on an ordinary
+          // object: walk its keys with for-in and find each in the list, no
+          // key array and no Map. A key the list lacks is extra when it is
+          // the object's own (an enumerable name on Object.prototype is not).
+          // A listed key is read directly: for-in meets Object.prototype's
+          // own names (`constructor`) only on the object itself, so this is
+          // the short walk's rule. Other objects take the walk above.
+          const keyed = vsteps.pop();
+          const n = propKeys.length;
+          const fns = propList.map((e) => e.fn);
+          const reqs = propList.map((e) => e.req);
+          // Names met, as bits: the required ones must all be set, and a
+          // listed name not met may still be the object's own, hidden from
+          // for-in (defineProperty, enumerable: false), which the generated
+          // code and this engine's error path read by name: those are read
+          // after the walk, which on an ordinary document is the absent ones.
+          const reqMask = reqs.reduce((m, r, i) => r ? m | (1 << i) : m, 0);
+          const allMask = n === 32 ? -1 : (1 << n) - 1;
+          // A property whose check is a coded leaf is checked in place.
+          const codes = propList.map((e) => (e.fn.leaf && e.fn.v.lc !== undefined ? e.fn.v.lc : null));
+          vsteps.push((data, stack, rec) => {
+            if (dataBits(data) !== T_OBJECT || Object.getPrototypeOf(data) !== Object.prototype) return keyed(data, stack, rec);
+            if (fusedLeaf !== null && !fusedLeaf(data)) return false;
+            let seen = 0;
+            for (const key in data) {
+              let i = 0;
+              while (i < n && propKeys[i] !== key) i++;
+              if (i === n) { if (Object.hasOwn(data, key)) return false; continue; }
+              seen |= 1 << i;
+              const value = data[key];
+              if (value === undefined) { if (reqs[i]) return false; continue; }
+              const lc = codes[i];
+              if (lc !== null ? !leafOk(lc, value) : !fns[i].v(value, stack)) return false;
+            }
+            if ((seen & reqMask) !== reqMask) return false;
+            for (let miss = seen ^ allMask; miss !== 0; miss &= miss - 1) {
+              const i = 31 - Math.clz32(miss & -miss);
+              const value = data[propKeys[i]];
+              if (value === undefined || !Object.hasOwn(data, propKeys[i])) continue;
+              const lc = codes[i];
+              if (lc !== null ? !leafOk(lc, value) : !fns[i].v(value, stack)) return false;
+            }
+            return true;
+          });
+        }
       }
     }
     if (P.dependentSchemas !== null) {

package/lib/public-api.js

@@ -58,6 +58,11 @@ function attachSuggestions (errors, data) {
   return errors;
 }
 
+// Loaded on first call, like the tools: a process that never calls them does
+// not read the file.
+function defineSchema (schema) { return require('./schema-helpers.js').defineSchema(schema); }
+function schemaOf (...a) { return require('./schema-helpers.js').schemaOf(...a); }
+
 module.exports = {
   Validator: core.Validator,
   compile: core.compile,
@@ -69,8 +74,8 @@ module.exports = {
   SIMDJSON_PADDING: core.SIMDJSON_PADDING,
   parseJSON: core.parseJSON,
   toTypeScript,
-  defineSchema: core.defineSchema,
-  schemaOf: core.schemaOf,
+  defineSchema,
+  schemaOf,
   renderPretty,
   renderCompact,
   toOutput,

package/lib/rejections.js

@@ -159,7 +159,9 @@ function stripOrdinal(e) {
   // lib/branch-collapse.js builds, the only place these codes come from. Its
   // fields are copied by name, in that order, without the ordinal: walking
   // its keys with for-in was most of the cost of reading such an error.
-  if (e.path !== undefined && e.docUrl === undefined && COLLAPSE_CODES.has(e.code)) {
+  // One that carries verbose's fields takes the copy of every key below,
+  // which keeps them; this one dropped them.
+  if (e.path !== undefined && e.docUrl === undefined && COLLAPSE_CODES.has(e.code) && !('parentSchema' in e)) {
     const out = { code: e.code, keyword: e.keyword, instancePath: e.instancePath, path: e.path, schemaPath: e.schemaPath, message: e.message, params: e.params };
     if ('branchErrors' in e) out.branchErrors = Array.isArray(e.branchErrors) ? e.branchErrors.map(stripOrdinal) : e.branchErrors;
     return out;

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/shape-classifier.js

@@ -40,9 +40,21 @@ function isPrimitiveEnumValue(v) {
   return v === null || t === 'string' || t === 'number' || t === 'boolean';
 }
 
+// A node of `enum` or `const` alone, no type: the values decide, as the full
+// engines decide it (enumMember, deepEqual), and every value is a primitive,
+// so a Set lookup or a === is the whole check. Form fields are written this
+// way often (`{ enum: ['TR', 'DE'] }`, `{ const: true }`), and one of them
+// sent the whole object to the slower engines.
+const TIER0_UNTYPED_ALLOWED = new Set(['enum', 'const', ...META_KEYS]);
+
 function isTier0Primitive(schema) {
   if (typeof schema !== 'object' || schema === null || Array.isArray(schema)) return false;
-  if (!isPrimitiveType(schema.type)) return false;
+  if (!isPrimitiveType(schema.type)) {
+    if (schema.type !== undefined || (schema.enum === undefined && schema.const === undefined)) return false;
+    for (const k of Object.keys(schema)) {
+      if (!TIER0_UNTYPED_ALLOWED.has(k)) return false;
+    }
+  }
   for (const k of Object.keys(schema)) {
     if (!TIER0_PRIMITIVE_ALLOWED.has(k)) return false;
   }

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/tier0.js

@@ -166,9 +166,10 @@ function checkPrimitive(c, v) {
     }
   } else if (m === T_BOOLEAN) {
     if (typeof v !== 'boolean') return false;
-  } else {
+  } else if (m !== 0) {
     return false;
   }
+  // m === 0: a node of enum or const alone; the checks below decide.
   if (c.hasEnum && !c.enumSet.has(v)) return false;
   if (c.hasConst && v !== c.constVal) return false;
   return true;
@@ -176,18 +177,32 @@ function checkPrimitive(c, v) {
 
 // Inlined object validator. Separating the primitive path removes a dead
 // branch from the hot object path.
-function tier0ValidateObject(plan, data) {
+// The object verdict as one closure over the plan's fields, read once: the
+// bound isValidObject() is then one call into a function whose loop reads
+// captured constants, where a plan passed each call cost two calls and a
+// field load per use (an empty object 17 ns against 7 for a validator built
+// the same way by hand; a number 9 against 4).
+function makeObjectVerdict(plan) {
+  const P_additionalAllowed = plan.additionalAllowed;
+  const P_constraints = plan.constraints;
+  const P_knownKeys = plan.knownKeys;
+  const P_requiredMask = plan.requiredMask;
+  return function tier0ObjectVerdict(data) {
   if (typeof data !== 'object' || data === null || Array.isArray(data)) return false;
-  const cs = plan.constraints;
+  const cs = P_constraints;
   const n = cs.length;
-  const reqMask = plan.requiredMask;
+  const reqMask = P_requiredMask;
+  // Whether the object is an ordinary one, read once: then a defined value
+  // under a name Object.prototype lacks is the object's own. Read for each
+  // present field, it was one test per field on a valid document.
+  const plain = (_PN ? data.__proto__ : Object.getPrototypeOf(data)) === Object.prototype;
   let seenMask = 0;
   for (let i = 0; i < n; i++) {
     const c = cs[i];
     let v = data[c.key];
     // Presence is an own-property question: a value the object inherits is
     // treated as absent, as the interpreted engine treats it.
-    if (v !== undefined && (c.protoName || (_PN ? data.__proto__ : Object.getPrototypeOf(data)) !== Object.prototype) && !_hop.call(data, c.key)) v = undefined;
+    if (v !== undefined && (c.protoName || !plain) && !_hop.call(data, c.key)) v = undefined;
     if (v === undefined) {
       // A required key holding undefined is missing, as in every engine.
       if (reqMask & (1 << i)) return false;
@@ -225,21 +240,35 @@ function tier0ValidateObject(plan, data) {
       }
     } else if (m === T_BOOLEAN) {
       if (typeof v !== 'boolean') return false;
-    } else {
+    } else if (m !== 0) {
       return false;
     }
+    // m === 0: a node of enum or const alone; the checks below decide.
     if (c.hasEnum && !c.enumSet.has(v)) return false;
     if (c.hasConst && v !== c.constVal) return false;
   }
   if ((seenMask & reqMask) !== reqMask) return false;
-  if (!plan.additionalAllowed) {
-    const known = plan.knownKeys;
+  if (!P_additionalAllowed) {
+    const known = P_knownKeys;
     for (const k in data) {
       if (!Object.prototype.hasOwnProperty.call(data, k)) continue;
       if (!known.has(k)) return false;
     }
   }
   return true;
+  };
+}
+function tier0ValidateObject(plan, data) {
+  let f = plan._objectVerdict;
+  if (f === undefined) f = plan._objectVerdict = makeObjectVerdict(plan);
+  return f(data);
+}
+// The verdict for a plan as one closure, for a validator to bind directly.
+function tier0Verdict(plan) {
+  if (plan.isPrimitive) { const c = plan.constraints[0]; return (data) => checkPrimitive(c, data); }
+  let f = plan._objectVerdict;
+  if (f === undefined) f = plan._objectVerdict = makeObjectVerdict(plan);
+  return f;
 }
 
 function tier0Validate(plan, data) {
@@ -250,6 +279,7 @@ function tier0Validate(plan, data) {
 module.exports = {
   buildTier0Plan,
   tier0Validate,
+  tier0Verdict,
   tier0ValidateObject,
   checkPrimitive,
   TYPE_MASK,

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,12 +1665,17 @@ 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) {
-    if (this._initialized) {
-      throw new Error('Cannot add schema after compilation — call addSchema() before validate()')
+    // After a compile of either kind: the verdict-only one isValidObject()
+    // makes (_jsFn) binds a function over the registry as it was, and a
+    // schema added after it reached validate() but not isValidObject(),
+    // which kept answering against the old definition. A call the
+    // interpreted twin answered compiled nothing, and the twin is rebuilt.
+    if (this._initialized || this._jsFn) {
+      throw new Error('Cannot add schema after compilation: call addSchema() before validate(), isValidObject(), validateJSON() or isValidJSON()')
     }
     if (!schema || !schema.$id) {
       throw new Error('Schema must have $id')
@@ -1688,7 +1711,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 +1738,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 +1969,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
@@ -2349,16 +2361,22 @@ function _ticks(self) {
 // _ticks says so.
 function _tier0Verdict(self) {
   if (require('./shape-classifier').classify(self._schemaObj).tier !== 0) return null;
-  const { buildTier0Plan, tier0Validate } = require('./tier0');
+  const { buildTier0Plan, tier0Verdict } = require('./tier0');
   const plan = buildTier0Plan(self._schemaObj, self._userFormats);
-  if (!_ticks(self)) return (d) => tier0Validate(plan, d);
+  const verdict = tier0Verdict(plan);
+  if (!_ticks(self)) return verdict;
   const tick = _tiering.counter(self);
-  return (d) => { tick(); return tier0Validate(plan, d); };
+  return (d) => { tick(); return verdict(d); };
 }
 
 Validator.prototype._coldTwin = function () {
   const cg = _loadCodegen();
-  return cg === null || cg.coldTwin === undefined ? null : cg.coldTwin(this, Validator);
+  // Where no code can be generated (a strict CSP), the interpreted engine is
+  // the compile itself: a twin would only delay it, and its size test read
+  // the schema's text for nothing (6.5% of a schema's first check there).
+  // The probe of the realm (codegenAvailable) is not run for a validator
+  // asked for the interpreted engine, which never generates code.
+  return cg === null || cg.coldTwin === undefined || this._interpretOnly || !codegenAvailable() ? null : cg.coldTwin(this, Validator);
 };
 
 _defineLazyMethod('validate', (self) => (data) => {
@@ -2395,7 +2413,14 @@ _defineLazyMethod('isValidObject', (self) => {
     _bindVerdict(self, _ticks(self) ? _t0 : (d) => {
       const r = _t0(d);
       if (++_n === 2) {
+        const before = self.isValidObject;
         try { self._ensureCodegen(); } catch {}
+        // Where the generated code did not take the method over (no code
+        // generation in this realm, or the generator declined), the plan's
+        // closure answers directly from now on: this wrapper cost every
+        // later call a count and a call, 13.5 against 4.7 ns on an empty
+        // object, on exactly the pages and workers that have no generator.
+        if (self.isValidObject === before) _bindVerdict(self, _t0);
       }
       return r;
     });
@@ -2457,8 +2482,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.