ata-validator 1.52.0 → 1.54.0

package/lib/interpreter-core.js

@@ -430,6 +430,11 @@ class Plan {
       this.formatFn = fc || null;
     }
     this.hasString = this.minLength !== undefined || this.maxLength !== undefined || this.pattern !== null || this.formatFn !== null;
+    // A format compat registered for numbers (`type: 'number'`), checked on
+    // numbers as the reference checks it.
+    const nf = interp.numberFormats;
+    this.numFormatFn = schema.format !== undefined && nf !== null && typeof nf[schema.format] === 'function' ? nf[schema.format] : null;
+    if (this.numFormatFn !== null) this.hasNumber = true;
 
     this.minItems = schema.minItems;
     this.maxItems = schema.maxItems;
@@ -455,6 +460,21 @@ class Plan {
         this.properties.set(key, { node: child(schema.properties[key]), seg: '/' + ek, schemaSeg: '/properties/' + ek });
       }
     }
+    // A required key holding undefined is missing. Where the key is also a
+    // declared property, the property walk, which reads the value anyway,
+    // finds that (requiredInProps); the required check reads the value only
+    // for the other keys (requiredUndef), so a valid object pays no second
+    // read of each required value.
+    this.requiredInProps = null;
+    this.requiredUndef = null;
+    if (this.required !== null) {
+      const undef = this.required.map((k) => this.properties === null || !this.properties.has(k));
+      if (undef.includes(true)) this.requiredUndef = undef;
+      if (this.properties !== null) {
+        const inProps = this.required.filter((k) => this.properties.has(k));
+        if (inProps.length > 0) this.requiredInProps = new Set(inProps);
+      }
+    }
     this.patternProperties = null;
     if (isObjectMap(schema.patternProperties)) {
       this.patternProperties = Object.keys(schema.patternProperties).map((src) => ({ src, re: interp.pattern(src), node: child(schema.patternProperties[src]) }));
@@ -521,16 +541,20 @@ class Plan {
           if (typeof fn !== 'function') throw new Error(`keyword "${key}": compile must return a function`);
         } else {
           const validate = def.validate;
-          fn = (data) => validate(value, data, schema);
+          fn = def.dataContext ? (data, ctx) => validate(value, data, schema, ctx) : (data) => validate(value, data, schema);
           // Errors written by the validate function land on the function
           // itself, which is where the check reads them from below.
           fn.source = validate;
         }
         if (this.custom === null) this.custom = [];
-        this.custom.push({ keyword: key, fn, mask });
+        this.custom.push({ keyword: key, fn, mask, ctx: def.dataContext === true, before: def.before || null, post: def.post === true });
       }
+      if (this.custom !== null && this.custom.length > 1) this.custom = orderCustom(this.custom);
     }
     this.hasCustom = this.custom !== null;
+    // Keywords declared `post` run after everything else at the node, the
+    // subschemas included (see eval).
+    this.hasPost = this.custom !== null && this.custom.some((op) => op.post);
 
     // Resource bookkeeping, read once instead of two Map lookups per visit.
     // Only a resource root changes the base: a node inside a resource is
@@ -552,7 +576,10 @@ class Plan {
       this.additionalProperties === undefined && this.propertyNames === undefined &&
       this.dependentSchemas === null && this.propertyDependencies === null &&
       this.prefixItems === null && this.items === undefined && this.contains === undefined &&
-      this.nodeBase === null;
+      this.nodeBase === null &&
+      // The verdict-only leaf check carries no path, which a keyword reading
+      // its data's context needs.
+      !(this.custom !== null && this.custom.some((op) => op.ctx));
   }
 }
 
@@ -572,6 +599,7 @@ function evalLeafV(P, data) {
     if (P.exclusiveMinimum !== undefined && !(data > P.exclusiveMinimum)) return false;
     if (P.exclusiveMaximum !== undefined && !(data < P.exclusiveMaximum)) return false;
     if (P.multipleOf !== undefined && !multipleOfOk(data, P.multipleOf)) return false;
+    if (P.numFormatFn !== null && !P.numFormatFn(data)) return false;
   }
   if (P.hasString && bits === T_STRING) {
     if (P.minLength !== undefined && !cpAtLeast(data, P.minLength)) return false;
@@ -588,7 +616,8 @@ function evalLeafV(P, data) {
     if (P.required !== null) {
       const req = P.required;
       for (let i = 0; i < req.length; i++) {
-        if (!Object.hasOwn(data, req[i])) return false;
+        // A key holding undefined is missing, as in the default validator.
+        if (!Object.hasOwn(data, req[i]) || (P.requiredUndef !== null && P.requiredUndef[i] && data[req[i]] === undefined)) return false;
       }
     }
     if (P.minProperties !== undefined && Object.keys(data).length < P.minProperties) return false;
@@ -610,13 +639,72 @@ function evalLeafV(P, data) {
 // taking the error objects the keyword's function left on itself when it
 // wrote any (`fn.errors`, the same convention as the default validator's
 // custom keywords) and a fixed message otherwise.
-function runCustomV(P, data, bits) {
+// Custom keywords of one node in the order they declare: schema order, then
+// each one with `before` moved ahead of the keyword it names (when that is
+// one of them), then those marked `post` after the rest. A keyword that
+// rewrites its value (serializing a Date to a string, say) declares that it
+// runs before the one that checks the result.
+function orderCustom(ops) {
+  const out = ops.filter((op) => !op.post);
+  for (const op of ops.slice()) {
+    if (op.before === null) continue;
+    const at = out.indexOf(op);
+    const target = out.findIndex((o) => o.keyword === op.before);
+    if (at < 0 || target < 0 || at < target) continue;
+    out.splice(at, 1);
+    out.splice(target, 0, op);
+  }
+  for (const op of ops) if (op.post) out.push(op);
+  return out;
+}
+
+// The interpreter whose validate() is running a context-reading keyword, and
+// the context it is given: where the value sits, read from the root by path.
+let ctxInterp = null;
+function dataCtx(instancePath, schemaPath, keyword) {
+  const root = ctxInterp !== null ? ctxInterp._ctxRoot : undefined;
+  if (instancePath === '') return { instancePath, parentData: undefined, parentDataProperty: undefined, rootData: root, schemaPath: schemaPath + '/' + keyword };
+  const cut = instancePath.lastIndexOf('/');
+  let parent = root;
+  if (cut > 0) {
+    const segs = instancePath.slice(1, cut).split('/');
+    for (let i = 0; i < segs.length && parent !== null && typeof parent === 'object'; i++) parent = parent[segs[i].replace(/~1/g, '/').replace(/~0/g, '~')];
+  }
+  let key = instancePath.slice(cut + 1).replace(/~1/g, '/').replace(/~0/g, '~');
+  if (Array.isArray(parent) && /^(0|[1-9][0-9]*)$/.test(key)) key = +key;
+  return { instancePath, parentData: parent, parentDataProperty: key, rootData: root, schemaPath: schemaPath + '/' + keyword };
+}
+
+// After a context-reading keyword, the value is read again from where it sits:
+// the keyword may have replaced it (a date deserialized, a value serialized),
+// and the keywords after it check what it left, as the default validator's
+// do after a modifying keyword.
+function reread(ctx, data) {
+  const p = ctx.parentData;
+  return p !== null && typeof p === 'object' && ctx.parentDataProperty !== undefined ? p[ctx.parentDataProperty] : data;
+}
+
+// Every branch's result, kept on a collapsed anyOf or oneOf error when the
+// schema has keywords that read their data's context. Such a keyword may have
+// changed the data, so the errors of each branch cannot be had afterwards by
+// validating it again; compat reads them from here (see compat-errors.js).
+function keepBranches(error, branches) {
+  Object.defineProperty(error, '_branches', { value: branches });
+}
+
+function runCustomV(P, data, bits, instancePath, schemaPath) {
   const ops = P.custom;
   for (let i = 0; i < ops.length; i++) {
     const op = ops[i];
     if ((bits & op.mask) === 0) continue;
     const fn = op.fn;
-    const ok = fn(data);
+    let ok;
+    if (op.ctx) {
+      const ctx = dataCtx(instancePath || '', schemaPath || '#', op.keyword);
+      ok = fn(data, ctx);
+      const now = reread(ctx, data);
+      if (now !== data) { data = now; bits = dataBits(data); }
+    } else ok = fn(data);
     const holder = fn.source || fn;
     if (holder.errors) holder.errors = null;
     if (!ok) return false;
@@ -624,14 +712,23 @@ function runCustomV(P, data, bits) {
   return true;
 }
 
-function runCustom(P, data, bits, errors, instancePath, schemaPath) {
+// `post`: undefined runs every keyword, false those not declared post, true
+// only those.
+function runCustom(P, data, bits, errors, instancePath, schemaPath, post) {
   const ops = P.custom;
   let valid = true;
   for (let i = 0; i < ops.length; i++) {
     const op = ops[i];
     if ((bits & op.mask) === 0) continue;
+    if (post !== undefined && op.post !== post) continue;
     const fn = op.fn;
-    const ok = fn(data);
+    let ok;
+    if (op.ctx) {
+      const ctx = dataCtx(instancePath, schemaPath, op.keyword);
+      ok = fn(data, ctx);
+      const now = reread(ctx, data);
+      if (now !== data) { data = now; bits = dataBits(data); }
+    } else ok = fn(data);
     const holder = fn.source || fn;
     const own = holder.errors;
     if (own) holder.errors = null;
@@ -642,8 +739,10 @@ function runCustom(P, data, bits, errors, instancePath, schemaPath) {
     if (Array.isArray(own) && own.length > 0) {
       for (let j = 0; j < own.length; j++) {
         const e = own[j];
+        // A context-reading keyword writes the path it was given, as the
+        // default validator's keywords do; the others write one relative to it.
         errors.push(err(op.keyword, e.keyword || op.keyword,
-          e.instancePath !== undefined ? instancePath + e.instancePath : instancePath,
+          e.instancePath !== undefined ? (op.ctx ? e.instancePath : instancePath + e.instancePath) : instancePath,
           e.schemaPath !== undefined ? e.schemaPath : kwPath,
           e.params !== undefined ? e.params : {},
           e.message !== undefined ? e.message : `must pass "${op.keyword}" keyword validation`));
@@ -681,6 +780,7 @@ function evalLeaf(P, data, errors, instancePath, schemaPath) {
     if (P.exclusiveMinimum !== undefined && !(data > P.exclusiveMinimum)) { errors === NOERRORS || errors.push(err('exclusiveMinimum', 'exclusiveMinimum', instancePath, schemaPath + '/exclusiveMinimum', { comparison: '>', limit: P.exclusiveMinimum }, `must be > ${P.exclusiveMinimum}`)); valid = false; }
     if (P.exclusiveMaximum !== undefined && !(data < P.exclusiveMaximum)) { errors === NOERRORS || errors.push(err('exclusiveMaximum', 'exclusiveMaximum', instancePath, schemaPath + '/exclusiveMaximum', { comparison: '<', limit: P.exclusiveMaximum }, `must be < ${P.exclusiveMaximum}`)); valid = false; }
     if (P.multipleOf !== undefined && !multipleOfOk(data, P.multipleOf)) { errors === NOERRORS || errors.push(err('multipleOf', 'multipleOf', instancePath, schemaPath + '/multipleOf', { multipleOf: P.multipleOf }, `must be multiple of ${P.multipleOf}`)); valid = false; }
+    if (P.numFormatFn !== null && !P.numFormatFn(data)) { errors === NOERRORS || errors.push(err('format', 'format', instancePath, schemaPath + '/format', { format: P.format }, `must match format "${P.format}"`)); valid = false; }
   }
   if (P.hasString && bits === T_STRING) {
     if (P.minLength !== undefined && !cpAtLeast(data, P.minLength)) { errors === NOERRORS || errors.push(err('minLength', 'minLength', instancePath, schemaPath + '/minLength', { limit: P.minLength }, `must NOT have fewer than ${P.minLength} characters`)); valid = false; }
@@ -706,7 +806,7 @@ function evalLeaf(P, data, errors, instancePath, schemaPath) {
       const req = P.required;
       for (let i = 0; i < req.length; i++) {
         const key = req[i];
-        if (!Object.hasOwn(data, key)) { errors === NOERRORS || errors.push(err('required', 'required', instancePath, schemaPath + '/required', { missingProperty: key }, `must have required property '${key}'`)); valid = false; }
+        if (!Object.hasOwn(data, key) || (P.requiredUndef !== null && P.requiredUndef[i] && data[key] === undefined)) { errors === NOERRORS || errors.push(err('required', 'required', instancePath, schemaPath + '/required', { missingProperty: key }, `must have required property '${key}'`)); valid = false; }
       }
     }
     if (P.minProperties !== undefined && keys.length < P.minProperties) { errors === NOERRORS || errors.push(err('minProperties', 'minProperties', instancePath, schemaPath + '/minProperties', { limit: P.minProperties }, `must NOT have fewer than ${P.minProperties} properties`)); valid = false; }
@@ -731,6 +831,7 @@ class Interpreter {
     this.root = rootSchema;
     this.state = indexSchemas(rootSchema, opts.schemaMap, opts.flat === true);
     this.userFormats = opts.formats || null;
+    this.numberFormats = opts.numberFormats && Object.keys(opts.numberFormats).length > 0 ? opts.numberFormats : null;
     // Custom keywords, already normalized by lib/keywords.js.
     this.keywords = opts.keywords || null;
     // 2020-12 requires bookending for `$dynamicRef`; v1 removes the
@@ -744,6 +845,27 @@ class Interpreter {
     this._fast = undefined;
     this._calls = 0;
     this._tier = typeof opts.tier === 'number' ? opts.tier : TIER;
+    // A keyword that asks for its data's context (parentData and the rest)
+    // needs every value's path, which only the collecting walk builds: the
+    // verdict comes from that walk too, and the closure tree is not used.
+    this.dataContext = false;
+    if (this.keywords !== null) for (const k of Object.keys(this.keywords)) if (this.keywords[k].dataContext) { this.dataContext = true; break; }
+    // Type coercion where each `type` is checked, the reference's way, which
+    // reaches a value behind allOf, anyOf, oneOf and $ref (the pass that runs
+    // before validation reaches `properties` and `items` only). It writes the
+    // coerced value where the value sits, so it takes the same walk.
+    this.coerce = opts.coerce === 'array' ? 'array' : opts.coerce === true;
+    if (this.coerce !== false) this.dataContext = true;
+    // OpenAPI's discriminator, read the reference's way under its
+    // `discriminator` option: the tag picks the one oneOf branch to apply.
+    this.discriminator = opts.discriminator === true;
+    this._discr = null;
+    // Both come from compat, which installs the code for them (see
+    // lib/interpreter-compat.js), so a bundle without compat carries none of it.
+    this.ext = this.coerce !== false || this.discriminator ? compatExt() : null;
+    // The compiled closures know none of these.
+    if (this.dataContext || this.discriminator || this.numberFormats !== null) this._fast = null;
+    this._ctxRoot = undefined;
   }
 
   // The closure-tree compiler covers every schema the interpreter accepts;
@@ -848,6 +970,7 @@ class Interpreter {
 
   // Verdict only: same walk as validate(), no error construction at all.
   isValid(data) {
+    if (this.dataContext) return this.validate(data).valid;
     const fast = this._fast !== undefined ? this._fast : this._tiered();
     if (fast !== null) return fast.v(data, fast.cyclic ? [] : null);
     const dynScope = [this.state.rootBase];
@@ -859,6 +982,14 @@ class Interpreter {
     }
   }
 
+  // The value at `instancePath` as it is now, after a subschema may have
+  // coerced it.
+  here(instancePath, data) {
+    if (instancePath === '') return this._ctxRoot;
+    const ctx = dataCtx(instancePath, '', '');
+    return ctx.parentData !== null && typeof ctx.parentData === 'object' ? ctx.parentData[ctx.parentDataProperty] : data;
+  }
+
   validate(data) {
     const fast = this._fast !== undefined ? this._fast : this._tiered();
     if (fast !== null) {
@@ -869,13 +1000,20 @@ class Interpreter {
     let errors = [];
     const dynScope = [this.state.rootBase];
     let valid;
+    // The root a context-reading keyword resolves its parent from; kept
+    // across a nested validate() its own function might make.
+    const outerRoot = this._ctxRoot;
+    if (this.dataContext) { this._ctxRoot = data; ctxInterp = this; }
     try {
       // Nothing reads the root's annotations, so they are discarded from the start.
       valid = this.eval(this.rootNode, data, this.state.rootBase, dynScope, errors, '', '#', [], DISCARD);
     } catch (e) {
+      if (this.dataContext) throw e;
       const deep = this._deep(e);
       errors = [];
       valid = deep.c(data, errors, '', '#', deep.cyclic ? [] : null);
+    } finally {
+      if (this.dataContext) this._ctxRoot = outerRoot;
     }
     return valid ? { valid: true, data, errors: [] } : { valid: false, errors };
   }
@@ -885,14 +1023,17 @@ class Interpreter {
   // `stack` breaks infinite $ref recursion on identical (schema, data) pairs.
   eval(P, data, base, dynScope, errors, instancePath, schemaPath, stack, sink) {
     // Paths are built only while errors are collected; a verdict walk never
-    // reads them, and concatenating two per child was most of its cost.
-    const E = errors !== NOERRORS;
+    // reads them, and concatenating two per child was most of its cost. A
+    // keyword that reads its data's context needs them on every walk.
+    const E = errors !== NOERRORS || this.dataContext;
     if (P === true) return true;
     if (P === false) {
       if (errors !== NOERRORS) errors.push(err('false schema', 'not', instancePath, schemaPath, {}, 'boolean schema is false'));
       return false;
     }
-    if (P.leaf) return evalLeaf(P, data, errors, instancePath, schemaPath);
+    // The leaf check cannot coerce: it neither knows the value's place nor
+    // hands a coerced value on.
+    if (P.leaf && this.coerce === false) return evalLeaf(P, data, errors, instancePath, schemaPath);
     const schema = P.schema;
 
     // Only a reference can lead evaluation back to a schema it is already
@@ -926,6 +1067,9 @@ class Interpreter {
     const collect = sink !== DISCARD || P.hasUnevaluated;
     const local = collect ? { props: null, items: null } : DISCARD;
 
+    // Coercion first, before anything reads the value, as the reference does it.
+    if (this.coerce !== false && P.hasType && (dataBits(data) & P.typeMask) === 0) data = this.ext.coerceAt(this, P, data, instancePath);
+
     // $ref / $dynamicRef: in-place applicators, annotations flow through
     if (P.ref !== null) {
       const { child, base: refBase } = this.resolveRefCached(P, base);
@@ -977,6 +1121,7 @@ class Interpreter {
         else if (collect) mergeAnnotations(local, sub);
       }
     }
+    if (this.coerce !== false) data = this.here(instancePath, data);
 
     const bits = dataBits(data);
 
@@ -1003,6 +1148,7 @@ class Interpreter {
       if (P.exclusiveMinimum !== undefined && !(data > P.exclusiveMinimum)) { errors === NOERRORS || errors.push(err('exclusiveMinimum', 'exclusiveMinimum', instancePath, schemaPath + '/exclusiveMinimum', { comparison: '>', limit: P.exclusiveMinimum }, `must be > ${P.exclusiveMinimum}`)); valid = false; }
       if (P.exclusiveMaximum !== undefined && !(data < P.exclusiveMaximum)) { errors === NOERRORS || errors.push(err('exclusiveMaximum', 'exclusiveMaximum', instancePath, schemaPath + '/exclusiveMaximum', { comparison: '<', limit: P.exclusiveMaximum }, `must be < ${P.exclusiveMaximum}`)); valid = false; }
       if (P.multipleOf !== undefined && !multipleOfOk(data, P.multipleOf)) { errors === NOERRORS || errors.push(err('multipleOf', 'multipleOf', instancePath, schemaPath + '/multipleOf', { multipleOf: P.multipleOf }, `must be multiple of ${P.multipleOf}`)); valid = false; }
+      if (P.numFormatFn !== null && !P.numFormatFn(data)) { errors === NOERRORS || errors.push(err('format', 'format', instancePath, schemaPath + '/format', { format: P.format }, `must match format "${P.format}"`)); valid = false; }
     }
 
     // strings
@@ -1018,7 +1164,7 @@ class Interpreter {
     // them, so on a node that was not a leaf this walk skipped them and
     // accepted what they reject; the plan compiler, which answered every call
     // until calls were tiered, hid it.
-    if (P.hasCustom && !runCustom(P, data, bits, errors, instancePath, schemaPath)) valid = false;
+    if (P.hasCustom && !runCustom(P, data, bits, errors, instancePath, schemaPath, P.hasPost ? false : undefined)) valid = false;
 
     // arrays
     if (P.hasArray && bits === T_ARRAY) {
@@ -1070,7 +1216,7 @@ class Interpreter {
         const req = P.required;
         for (let i = 0; i < req.length; i++) {
           const key = req[i];
-          if (!Object.hasOwn(data, key)) { errors === NOERRORS || errors.push(err('required', 'required', instancePath, schemaPath + '/required', { missingProperty: key }, `must have required property '${key}'`)); valid = false; }
+          if (!Object.hasOwn(data, key) || (P.requiredUndef !== null && P.requiredUndef[i] && data[key] === undefined)) { errors === NOERRORS || errors.push(err('required', 'required', instancePath, schemaPath + '/required', { missingProperty: key }, `must have required property '${key}'`)); valid = false; }
         }
       }
       if (P.minProperties !== undefined && keys.length < P.minProperties) { errors === NOERRORS || errors.push(err('minProperties', 'minProperties', instancePath, schemaPath + '/minProperties', { limit: P.minProperties }, `must NOT have fewer than ${P.minProperties} properties`)); valid = false; }
@@ -1096,7 +1242,14 @@ class Interpreter {
         let evaluated = false;
         const prop = props !== null ? props.get(key) : undefined;
         if (prop !== undefined) {
-          if (!this.eval(prop.node, data[key], base, dynScope, errors, E ? instancePath + prop.seg : '', E ? schemaPath + prop.schemaSeg : '', stack, DISCARD)) valid = false;
+          // A declared property whose value is undefined is not checked, as the
+          // generated code does not check it: no JSON document carries one, and
+          // serialized the key is not there. Required, it is missing (see
+          // requiredInProps).
+          const value = data[key];
+          if (value !== undefined) {
+            if (!this.eval(prop.node, value, base, dynScope, errors, E ? instancePath + prop.seg : '', E ? schemaPath + prop.schemaSeg : '', stack, DISCARD)) valid = false;
+          } else if (P.requiredInProps !== null && P.requiredInProps.has(key)) { errors === NOERRORS || errors.push(err('required', 'required', instancePath, schemaPath + '/required', { missingProperty: key }, `must have required property '${key}'`)); valid = false; }
           evaluated = true;
         }
         if (patterns !== null) {
@@ -1158,6 +1311,7 @@ class Interpreter {
           const sub = collect ? { props: null, items: null } : DISCARD;
           if (!this.eval(P.allOf[i], data, base, dynScope, errors, instancePath, E ? schemaPath + '/allOf/' + i : '', stack, sub)) valid = false;
           else if (collect) mergeAnnotations(local, sub);
+          if (this.coerce !== false) data = this.here(instancePath, data);
         }
       }
       if (P.macros !== null) {
@@ -1186,16 +1340,25 @@ class Interpreter {
             any = true;
             if (collect) mergeAnnotations(local, sub);
           }
+          // Coercing, the branches after the first that passes are not tried,
+          // as the reference does not try them: each could coerce the value.
+          if (this.coerce !== false) {
+            data = this.here(instancePath, data);
+            if (ok && !collect) break;
+          }
         }
         if (!any) {
           if (branches !== null) {
             const collapsed = collapseBranches({ keyword: 'anyOf', branchResults: branches, parentPath: instancePath, parentSchemaPath: schemaPath + '/anyOf' });
+            if (collapsed !== null && this.dataContext) keepBranches(collapsed, branches);
             if (collapsed !== null) errors.push(collapsed);
           }
           valid = false;
         }
       }
-      if (P.oneOf !== null) {
+      if (P.oneOf !== null && this.discriminator && this.ext.isDiscriminated(schema)) {
+        if (bits === T_OBJECT && !this.ext.discriminate(this, P, data, base, dynScope, errors, instancePath, schemaPath, stack, collect ? local : DISCARD)) valid = false;
+      } else if (P.oneOf !== null) {
         let count = 0;
         let winner = null;
         const scratch = errors === NOERRORS ? NOERRORS : [];
@@ -1206,6 +1369,7 @@ class Interpreter {
           const sub = collect ? { props: null, items: null } : DISCARD;
           const mark = branches === null ? 0 : scratch.length;
           const ok = this.eval(P.oneOf[i], data, base, dynScope, scratch, instancePath, E ? schemaPath + '/oneOf/' + i : '', stack, sub);
+          if (this.coerce !== false) data = this.here(instancePath, data);
           if (branches !== null) branches.push({ valid: ok, errors: scratch.slice(mark), title: branchTitle(P.oneOf[i]) });
           if (ok) {
             count++;
@@ -1216,6 +1380,7 @@ class Interpreter {
         else {
           if (branches !== null) {
             const collapsed = collapseBranches({ keyword: 'oneOf', branchResults: branches, parentPath: instancePath, parentSchemaPath: schemaPath + '/oneOf' });
+            if (collapsed !== null && this.dataContext) keepBranches(collapsed, branches);
             if (collapsed !== null) errors.push(collapsed);
           }
           valid = false;
@@ -1227,11 +1392,13 @@ class Interpreter {
           if (errors !== NOERRORS) errors.push(err('not', 'not', instancePath, schemaPath + '/not', {}, 'must NOT be valid'));
           valid = false;
         }
+        if (this.coerce !== false) data = this.here(instancePath, data);
       }
       if (P.if !== undefined) {
         const ifSub = collect ? { props: null, items: null } : DISCARD;
         const ifScratch = errors === NOERRORS ? NOERRORS : [];
         const ifOk = this.eval(P.if, data, base, dynScope, ifScratch, instancePath, E ? schemaPath + '/if' : '', stack, ifSub);
+        if (this.coerce !== false) data = this.here(instancePath, data);
         if (ifOk) {
           if (collect) mergeAnnotations(local, ifSub);
           if (P.then !== undefined) {
@@ -1281,6 +1448,11 @@ class Interpreter {
       }
     }
 
+    if (P.hasPost) {
+      if (this.dataContext) data = this.here(instancePath, data);
+      if (!runCustom(P, data, dataBits(data), errors, instancePath, schemaPath, true)) valid = false;
+    }
+
     if (scopePushed) dynScope.pop();
     if (tracked) stack.length -= 2;
     if (valid && collect && sink !== DISCARD) mergeAnnotations(sink, local);
@@ -1336,12 +1508,27 @@ function planCompiler() {
   return compileInterpreter;
 }
 
+let installCompat = null;
+let compatInstalled = null;
+function setCompat(install) {
+  installCompat = install;
+  compatInstalled = null;
+}
+function compatExt() {
+  if (compatInstalled === null) {
+    if (installCompat === null) throw new Error('coercion where each type is checked and the discriminator are installed by ata-validator/compat');
+    compatInstalled = installCompat({ NOERRORS, DISCARD, err, mergeAnnotations, dataCtx });
+  }
+  return compatInstalled;
+}
+
 function createInterpreter(schema, options) {
   return new Interpreter(schema, options);
 }
 
 module.exports = { createInterpreter };
 Object.defineProperty(module.exports, '_setPlanCompiler', { value: setPlanCompiler, enumerable: false });
+Object.defineProperty(module.exports, '_setCompat', { value: setCompat, enumerable: false });
 // The resolver, for the code generator: it resolves references at compile
 // time the way this engine does at run time (normalizeRefs in js-compiler).
 Object.defineProperty(module.exports, '_refInternals', {

package/lib/js-compiler-errors.js

@@ -9,7 +9,7 @@ const { compileFunction } = require('./compile-fn')
 // the first call that compiles errors. Everything here was written as part
 // of js-compiler.js and reads its helpers from that module's _internal.
 const core = require('./js-compiler')
-const { ownHead, hasConstraints, assertEmitted, prepareForCodegen, sharedCodegenGate, codegenSafe, isSimplePN, hasUnresolvableRef, needsBaseTracking, _cpLen, sharedRt, DECLINE, bindRt, compileSafe, emitGuardState, withPlain, REF_NEUTRAL_SIBLINGS, resolveCrossSchemaRef, enumCondition, enumOperand, emitDeq, emitConstant, ownGuard, ownKeyExpr, multipleOfBad, compilePatternInline, useSafeEngine, reFlags, FORMAT_CODEGEN, PROTO_NAMES, setOwn, nestedGenCode, compileToJSCodegen, SKIP_VALUE_KEYS, skipString, CYCLE_DEPTH, cyclicDefNames, sharedDefNames, reFlagArg, hoistOnce, PTR_ESC_HELPER, unevalContributions, emitUq, uqSources, safeReClosure, fastPrefixCheck, replaceTopLevel, refTargetFor, genCode, addLocalAnnotations, addTopApplicatorAnnotations, protoIs, ANNOT_APPLICATORS, SIZE_SKIPS, emitRootGuard, emitGuardedRun } = core._internal
+const { ownHead, hasConstraints, assertEmitted, prepareForCodegen, sharedCodegenGate, codegenSafe, isSimplePN, hasUnresolvableRef, needsBaseTracking, _cpLen, sharedRt, DECLINE, bindRt, compileSafe, emitGuardState, withPlain, REF_NEUTRAL_SIBLINGS, resolveCrossSchemaRef, enumCondition, enumOperand, emitDeq, emitConstant, ownGuard, ownKeyExpr, multipleOfBad, compilePatternInline, useSafeEngine, reFlags, FORMAT_CODEGEN, PROTO_NAMES, setOwn, nestedGenCode, compileToJSCodegen, SKIP_VALUE_KEYS, skipString, CYCLE_DEPTH, cyclicDefNames, sharedDefNames, reFlagArg, hoistOnce, PTR_ESC_HELPER, unevalContributions, emitUq, uqSources, safeReClosure, fastPrefixCheck, replaceTopLevel, refTargetFor, genCode, addLocalAnnotations, addTopApplicatorAnnotations, protoIs, ANNOT_APPLICATORS, SIZE_SKIPS, emitRootGuard, emitGuardedRun, keyLoopEligible, SAME_KEYS_HELPER, seqTag } = core._internal
 
 
 function emitPtrEsc(ctx) {
@@ -590,9 +590,19 @@ function subtreeGuard (sub, ctx, gv) {
   // 25-definition API schema came to 55 KB of source in a 133 KB function,
   // and a function that size reaches the optimizing compiler late.
   ctx.shareDefs = true
+  // A record of many optional properties takes the verdict's key-loop form
+  // (keyLoopEligible): its optional properties are checked from the record's
+  // own keys. Written one read per property, the guard of a 150-property
+  // record was 16.9 KB, over GUARD_MAX, so there was no guard at all and
+  // every record of the list was collected in full; on records of mixed
+  // shapes those reads are megamorphic, and 2000 of them cost 18 ms where
+  // the verdict took 0.3. The key-loop form is 10 KB and reads only the keys
+  // the record has.
+  const outerKeyLoop = ctx.keyLoopNode
+  if (keyLoopEligible(sub)) ctx.keyLoopNode = sub
   try {
     const bl = []
-    try { nestedGenCode(sub, gv, bl, ctx) } finally { ctx.defFns = outerDefFns; ctx.shareDefs = outerShare }
+    try { nestedGenCode(sub, gv, bl, ctx) } finally { ctx.defFns = outerDefFns; ctx.shareDefs = outerShare; ctx.keyLoopNode = outerKeyLoop }
     if (bl.length === 0) { restoreCtx(ctx, saved); return null }
     const body = bl.join(';')
     // The verdict generator's recursion names (`_validate`, the cycle guard
@@ -612,17 +622,20 @@ function subtreeGuard (sub, ctx, gv) {
   }
 }
 // The collecting code for `sub` at `v`, behind its guard when there is one.
-function genGuardedC (sub, v, pathExpr, lines, ctx, schemaPrefix) {
+// `when`, a boolean variable, makes the guard conditional: when it is false
+// the value is collected without a verdict first (see the items case).
+function genGuardedC (sub, v, pathExpr, lines, ctx, schemaPrefix, when) {
   const gi = ctx.varCounter++
   const gv = `_gv${gi}`
   const g = subtreeGuard(sub, ctx, gv)
   if (g === null) { genCodeC(sub, v, pathExpr, lines, ctx, schemaPrefix); return }
-  if (g.name !== undefined) lines.push(`if(!${g.name}(${v})){`)
+  const cond = when ? `!${when}||` : ''
+  if (g.name !== undefined) lines.push(`if(${cond}!${g.name}(${v})){`)
   else {
     // The verdict's exits become jumps out of the block: a failure leaves
     // the flag set, success clears it. replaceTopLevel keeps nested
     // closures' returns as they are (see the hybrid rewrite).
-    lines.push(`{const ${gv}=${v};let _g${gi}=1;g${gi}:{${replaceTopLevel(g.body, `{_g${gi}=0;break g${gi}}`, `break g${gi}`)};_g${gi}=0}if(_g${gi}){`)
+    lines.push(`{const ${gv}=${v};let _g${gi}=1;${when ? `if(${when})` : ''}g${gi}:{${replaceTopLevel(g.body, `{_g${gi}=0;break g${gi}}`, `break g${gi}`)};_g${gi}=0}if(_g${gi}){`)
   }
   ctx.guardDepth = (ctx.guardDepth || 0) + 1
   try { genCodeC(sub, v, pathExpr, lines, ctx, schemaPrefix) } finally { ctx.guardDepth-- }
@@ -1164,7 +1177,7 @@ function genCodeENode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     const reqSp = `${schemaPrefix}/required`
     const reqLit = buildErrorLiteral({ keyword: 'required', schemaPath: reqSp, sourceMap: ctx.sourceMap })
     for (const key of schema.required) {
-      lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&!${ownKeyExpr(ctx, v, key)}){_e.push({code:'${reqLit.codeStr}',keyword:'required',instancePath:${pathExpr||'""'},schemaPath:'${reqSp}'${ordinalField(ctx, `${reqSp}`)},params:{missingProperty:'${esc(key)}'},message:"must have required property '${esc(key)}'",docUrl:'${reqLit.docUrl}'${reqLit.frame}});if(!_all)return{valid:false,errors:_e}}`)
+      lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&(${v}[${JSON.stringify(key)}]===undefined||!${ownGuard(ctx, v, key)})){_e.push({code:'${reqLit.codeStr}',keyword:'required',instancePath:${pathExpr||'""'},schemaPath:'${reqSp}'${ordinalField(ctx, `${reqSp}`)},params:{missingProperty:'${esc(key)}'},message:"must have required property '${esc(key)}'",docUrl:'${reqLit.docUrl}'${reqLit.frame}});if(!_all)return{valid:false,errors:_e}}`)
     }
   }
 
@@ -1354,7 +1367,8 @@ function genCodeENode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
       const childPath = childPathExpr(pathExpr, ptrSeg(key))
       const sp = schemaPrefix+'/properties/'+ptrSeg(key)
       const from = lines.length
-      lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&${ownKeyExpr(ctx, v, key)}){`)
+      // A value that is undefined is not checked (see the verdict generator).
+      lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&${v}[${JSON.stringify(key)}]!==undefined&&${ownKeyExpr(ctx, v, key)}){`)
       // A large subschema as a function of its own (emitPropFnE); false means inline.
       if (!propFnCandidateE(prop, ctx, sp) || !emitPropFnE(prop, `${v}[${JSON.stringify(key)}]`, childPath, lines, ctx, sp)) {
         genCodeE(prop, `${v}[${JSON.stringify(key)}]`, childPath, lines, ctx, sp)
@@ -1769,7 +1783,10 @@ function errPushC(ctx, keyword, sp, pathExpr, paramsCode, msgCode, valueExpr, le
   // the definition and the reference's own comes in as `_sp`.
   const rel = sp.startsWith(SP_PLACEHOLDER)
   ctx.closureVals.push(errorSite(keyword, unescapeSp(rel ? sp.slice(SP_PLACEHOLDER.length) : sp), paramsVal, fmt))
-  return `(_e=_ap(_A,_e,_mk(${siteVar},${pathExpr || '""'},${paramsShared || paramsCode},${msgCode},${valueExpr},d${rel ? ',_sp' : ''}),-1))`
+  // The site's ordinal key, as the plain form passes it: a list that comes out
+  // in order then needs no sorting, and one that does not is put in order from
+  // the keys collected beside it (sr) instead of looking up each error's path.
+  return `(_e=_ap(_A,_e,_mk(${siteVar},${pathExpr || '""'},${paramsShared || paramsCode},${msgCode},${valueExpr},d${rel ? ',_sp' : ''}),${apOrd(ctx, sp)}))`
 }
 
 function compileToJSCombined(schema, VALID_RESULT, schemaMap, userFormats, opts) {
@@ -1935,7 +1952,10 @@ function compileToJSCombined(schema, VALID_RESULT, schemaMap, userFormats, opts)
       // The checked sort (_srX) compares with the reader, which a module
       // does not carry: there `_SRT` keeps the list as it is.
       `\n  return _e?new _ER(_A.mo?_e:${env('ATA_CHECK_SORT') && !(opts && opts.emit) ? '_srX(_A,_e,_SRT)' : '_sr(_A,_e,_SRT)'}):${opts && opts.moduleShape ? 'R' : '{valid:true,data:d,errors:_EE}'}}catch(_x){return _FB(d)}`
-    : hoistDecl + allDecl + `let _e;${AP_RESET}\n  ` + checks + `\n  return _e?{valid:false,errors:_e}:R`
+    // The rich form also says whether its list came out in the reader's
+    // order (`mo`, kept by _ap from each site's ordinal key), so the reader
+    // (richBuilder) sorts only a list that did not.
+    : hoistDecl + allDecl + `let _e;${AP_RESET}\n  ` + checks + `\n  return _e?{valid:false,errors:_e${ctx.rich ? ',mo:_A.mo' : ''}}:R`
   // The verdict generator's hoisted functions (subtreeGuard writes guards
   // through it) come first: a oneOf branch it could not hoist was a closure
   // built at every call of the guard, six per element of a json-patch list.
@@ -1952,7 +1972,8 @@ function compileToJSCombined(schema, VALID_RESULT, schemaMap, userFormats, opts)
       console.log('=== COMBINED PARTS ===', JSON.stringify(Object.entries(acc).sort((a, b) => b[1] - a[1])))
     }
     const programSrc = assignOrdKeys(ctx, `${helpers}return function _vC(d){${inner}}`)
-    const factory = compileFunction('R' + (closureParams ? ',' + closureParams : ''), programSrc)
+    // The run-time program is tagged (seqTag); the emitted source is not.
+    const factory = compileFunction('R' + (closureParams ? ',' + closureParams : ''), (opts && opts.emit ? '' : seqTag()) + programSrc)
     const made = factory(VALID_RESULT, ...closureArgs)
     // For a standalone module (lib/aot-impl.js): the program's source and the
     // closure values it takes, after the function was built and tried on
@@ -2405,7 +2426,7 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
       }
     }
     for (const key of schema.required) {
-      const check = hoisted[key] ? `${hoisted[key]}===undefined` : `!${ownKeyExpr(ctx, v, key)}`
+      const check = hoisted[key] ? `${hoisted[key]}===undefined` : `(${v}[${JSON.stringify(key)}]===undefined||!${ownGuard(ctx, v, key)})`
       if (isStaticPath && !ctx.rich && !ctx.noOrdinal) {
         const ei = ctx.varCounter++
         const errVar = `_E${ei}`
@@ -2428,7 +2449,7 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
         ctx.closureVals.push(sharedErr({keyword: 'required', instancePath: pathVal, schemaPath: unescapeSp(`${schemaPrefix}/required`), params: Object.freeze({missingProperty: key}), message: `must have required property '${key}'`}, ctx.rootSchema))
         lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&!${ownKeyExpr(ctx, v, key)}){(_e=_ap(_A,_e,${errVar},${apOrd(ctx, `${schemaPrefix}/required`)}))}`)
       } else {
-        lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&!${ownKeyExpr(ctx, v, key)}){${errPushC(ctx, 'required', `${schemaPrefix}/required`, pathExpr, `{missingProperty:'${esc(key)}'}`, `"must have required property '${esc(key)}'"`, v, `{keyword:'required',instancePath:${pathExpr||'""'},schemaPath:'${schemaPrefix}/required'${ordinalField(ctx, `${schemaPrefix}/required`)},params:{missingProperty:'${esc(key)}'},message:"must have required property '${esc(key)}'"}`)}}`)
+        lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&(${v}[${JSON.stringify(key)}]===undefined||!${ownGuard(ctx, v, key)})){${errPushC(ctx, 'required', `${schemaPrefix}/required`, pathExpr, `{missingProperty:'${esc(key)}'}`, `"must have required property '${esc(key)}'"`, v, `{keyword:'required',instancePath:${pathExpr||'""'},schemaPath:'${schemaPrefix}/required'${ordinalField(ctx, `${schemaPrefix}/required`)},params:{missingProperty:'${esc(key)}'},message:"must have required property '${esc(key)}'"}`)}}`)
       }
     }
   }
@@ -2612,7 +2633,7 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
         sub(`_o${oi}`)
         lines.push(`}}`)
       } else {
-        lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&${ownKeyExpr(ctx, v, key)}){`)
+        lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&${v}[${JSON.stringify(key)}]!==undefined&&${ownKeyExpr(ctx, v, key)}){`)
         sub(`${v}[${JSON.stringify(key)}]`)
         lines.push(`}`)
       }
@@ -2643,9 +2664,24 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     const idx = `_j${ctx.varCounter}`, elem = `_ei${ctx.varCounter}`
     ctx.varCounter++
     const childPath = childPathDynExpr(pathExpr, idx)
-    lines.push(`if(Array.isArray(${v})){for(let ${idx}=${startIdx};${idx}<${v}.length;${idx}++){const ${elem}=${v}[${idx}]`)
-    genGuardedC(schema.items, elem, childPath, lines, ctx, schemaPrefix+'/items')
-    lines.push(`}}`)
+    if (ctx.inCombined && keyLoopEligible(schema.items)) {
+      // Records of many optional properties (see subtreeGuard): the guard,
+      // a key loop per record, is run only for a list of mixed shapes,
+      // decided as the verdict decides (the first, middle and last record's
+      // keys). On records of one shape the collecting code's reads are
+      // monomorphic and cheaper than any guard: 2000 uniform records read
+      // for errors in 16 us, with a guard on each 69.
+      hoistOnce(ctx, 'sameKeysHelper', SAME_KEYS_HELPER)
+      const n = `_n${ctx.varCounter++}`
+      const mx = `_mx${ctx.varCounter++}`
+      lines.push(`if(Array.isArray(${v})){const ${n}=${v}.length;const ${mx}=${n}-${startIdx}>2&&(!_sameKeys(${v}[${startIdx}],${v}[(${n}+${startIdx})>>1])||!_sameKeys(${v}[${startIdx}],${v}[${n}-1]));for(let ${idx}=${startIdx};${idx}<${n};${idx}++){const ${elem}=${v}[${idx}]`)
+      genGuardedC(schema.items, elem, childPath, lines, ctx, schemaPrefix+'/items', mx)
+      lines.push(`}}`)
+    } else {
+      lines.push(`if(Array.isArray(${v})){for(let ${idx}=${startIdx};${idx}<${v}.length;${idx}++){const ${elem}=${v}[${idx}]`)
+      genGuardedC(schema.items, elem, childPath, lines, ctx, schemaPrefix+'/items')
+      lines.push(`}}`)
+    }
   }
 
   // prefixItems