ata-validator 1.52.0 → 1.53.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;
@@ -521,16 +526,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 +561,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 +584,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;
@@ -610,13 +623,137 @@ 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 };
+}
+
+function isDiscriminated(schema) {
+  const d = schema.discriminator;
+  return d !== null && typeof d === 'object' && typeof d.propertyName === 'string';
+}
+
+// The reference's coercion: the first type in the list the value converts to,
+// after unwrapping a one-element array in 'array' mode, which then converts
+// the element.
+const NO_COERCION = Symbol('no coercion');
+function fitsType(d, t) {
+  switch (t) {
+    case 'string': return typeof d === 'string';
+    case 'number': return typeof d === 'number' && isFinite(d);
+    case 'integer': return typeof d === 'number' && Number.isInteger(d);
+    case 'boolean': return typeof d === 'boolean';
+    case 'null': return d === null;
+    case 'array': return Array.isArray(d);
+    case 'object': return d !== null && typeof d === 'object' && !Array.isArray(d);
+    default: return false;
+  }
+}
+// Whether an unwrapped element is kept as it is. The reference tests a list
+// of types here with every type at once, so a list of two or more keeps
+// nothing (`number` stands in for `integer` beside it), and the element goes
+// on to be converted, as one of a single type does when it does not fit.
+function unwrappedFits(d, types) {
+  let list = types;
+  if (list.length > 1 && list.includes('number')) list = list.filter((t) => t !== 'integer');
+  if (list.length > 1 && list.includes('array') && list.includes('object')) return false;
+  for (const t of list) if (!fitsType(d, t)) return false;
+  return true;
+}
+function coerceValue(data, types, arrayMode) {
+  if (arrayMode && Array.isArray(data) && data.length === 1) {
+    data = data[0];
+    if (unwrappedFits(data, types)) return data;
+  }
+  const kind = data === null ? 'null' : typeof data;
+  for (const t of types) {
+    switch (t) {
+      case 'number':
+      case 'integer':
+        if (kind === 'boolean' || kind === 'null') return +data;
+        // eslint-disable-next-line eqeqeq
+        if (kind === 'string' && data !== '' && data == +data && (t === 'number' || !(data % 1))) return +data;
+        break;
+      case 'string':
+        if (kind === 'number' || kind === 'boolean') return '' + data;
+        if (kind === 'null') return '';
+        break;
+      case 'boolean':
+        if (data === 'false' || data === 0 || data === null) return false;
+        if (data === 'true' || data === 1) return true;
+        break;
+      case 'null':
+        if (data === '' || data === 0 || data === false) return null;
+        break;
+      case 'array':
+        if (arrayMode && (kind === 'string' || kind === 'number' || kind === 'boolean' || kind === 'null')) return [data];
+        break;
+    }
+  }
+  return NO_COERCION;
+}
+
+// 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 +761,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 +788,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 +829,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; }
@@ -731,6 +880,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 +894,24 @@ 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;
+    // 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 +1016,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 +1028,83 @@ class Interpreter {
     }
   }
 
+  // The discriminator in place of oneOf: the branch the tag names is applied,
+  // and a tag that is not a string, or names no branch, is the error.
+  discriminate(P, data, base, dynScope, errors, instancePath, schemaPath, stack, local) {
+    const d = this.discrMap(P, base);
+    const tag = data[d.tagName];
+    if (typeof tag !== 'string') {
+      if (errors !== NOERRORS) errors.push(err('discriminator', 'discriminator', instancePath, schemaPath + '/discriminator', { error: 'tag', tag: d.tagName, tagValue: tag }, `tag "${d.tagName}" must be string`));
+      return false;
+    }
+    const i = d.map.get(tag);
+    if (i === undefined) {
+      if (errors !== NOERRORS) errors.push(err('discriminator', 'discriminator', instancePath, schemaPath + '/discriminator', { error: 'mapping', tag: d.tagName, tagValue: tag }, `value of tag "${d.tagName}" must be in oneOf`));
+      return false;
+    }
+    const sub = local !== DISCARD ? { props: null, items: null } : DISCARD;
+    const ok = this.eval(P.oneOf[i], data, base, dynScope, errors, instancePath, schemaPath + '/oneOf/' + i, stack, sub);
+    if (ok && local !== DISCARD) mergeAnnotations(local, sub);
+    return ok;
+  }
+
+  // Tag value to branch index, read from each branch's `properties`, through
+  // a `$ref`, with the reference's rules: a `const` or `enum` of unique
+  // strings, and the tag required by the node or by every branch.
+  discrMap(P, base) {
+    if (this._discr === null) this._discr = new Map();
+    let d = this._discr.get(P);
+    if (d !== undefined) return d;
+    const tagName = P.schema.discriminator.propertyName;
+    if (P.schema.discriminator.mapping !== undefined) throw new Error('discriminator: mapping is not supported');
+    const hasRequired = (s) => s !== null && typeof s === 'object' && Array.isArray(s.required) && s.required.includes(tagName);
+    let topRequired = hasRequired(P.schema);
+    const map = new Map();
+    for (let i = 0; i < P.oneOf.length; i++) {
+      let node = P.oneOf[i];
+      if (node !== null && typeof node === 'object' && node.ref !== null && node.ref !== undefined && (node.schema.properties === undefined)) {
+        const r = this.resolveRefCached(node, base);
+        if (r.child === undefined) throw new Error(`discriminator: cannot resolve $ref ${node.ref}`);
+        node = r.child;
+      }
+      const sch = node !== null && typeof node === 'object' ? node.schema : undefined;
+      const propSch = sch && sch.properties ? sch.properties[tagName] : undefined;
+      if (propSch === null || typeof propSch !== 'object') throw new Error(`discriminator: oneOf subschemas (or referenced schemas) must have "properties/${tagName}"`);
+      topRequired = topRequired || hasRequired(sch);
+      const values = propSch.const !== undefined ? [propSch.const] : Array.isArray(propSch.enum) ? propSch.enum : null;
+      if (values === null) throw new Error(`discriminator: "properties/${tagName}" must have "const" or "enum"`);
+      for (const v of values) {
+        if (typeof v !== 'string' || map.has(v)) throw new Error(`discriminator: "${tagName}" values must be unique strings`);
+        map.set(v, i);
+      }
+    }
+    if (!topRequired) throw new Error(`discriminator: "${tagName}" must be required`);
+    d = { tagName, map };
+    this._discr.set(P, d);
+    return d;
+  }
+
+  // Coerces the value at `instancePath` to the node's type and writes it where
+  // it sits; at the root, where it sits nowhere, the walk carries it on.
+  coerceAt(P, data, instancePath) {
+    const to = coerceValue(data, P.typeNames, this.coerce === 'array');
+    if (to === NO_COERCION) return data;
+    if (instancePath === '') this._ctxRoot = to;
+    else {
+      const ctx = dataCtx(instancePath, '', '');
+      if (ctx.parentData !== null && typeof ctx.parentData === 'object') ctx.parentData[ctx.parentDataProperty] = to;
+    }
+    return to;
+  }
+
+  // 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 +1115,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 +1138,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 +1182,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.coerceAt(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 +1236,7 @@ class Interpreter {
         else if (collect) mergeAnnotations(local, sub);
       }
     }
+    if (this.coerce !== false) data = this.here(instancePath, data);
 
     const bits = dataBits(data);
 
@@ -1003,6 +1263,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 +1279,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) {
@@ -1096,7 +1357,10 @@ 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.
+          if (data[key] !== undefined && !this.eval(prop.node, data[key], base, dynScope, errors, E ? instancePath + prop.seg : '', E ? schemaPath + prop.schemaSeg : '', stack, DISCARD)) valid = false;
           evaluated = true;
         }
         if (patterns !== null) {
@@ -1158,6 +1422,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 +1451,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 && isDiscriminated(schema)) {
+        if (bits === T_OBJECT && !this.discriminate(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 +1480,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 +1491,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 +1503,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 +1559,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);

package/lib/js-compiler.js

@@ -376,7 +376,9 @@ function compileToJS(schema, defs, schemaMap) {
       if (!propCheck) return null // bail if sub-schema too complex
       checks.push((d) => {
         if (typeof d !== 'object' || d === null || !hasOwnKey(d, key)) return true
-        return propCheck(d[key])
+        // An undefined value is not checked, as the generated code does not.
+        const v = d[key]
+        return v === undefined || propCheck(v)
       })
     }
   }

package/lib/keywords.js

@@ -10,6 +10,12 @@
 //   { macro(value, parent) -> schema }    the returned schema is applied in
 //                                         place, and the keyword reports an
 //                                         error of its own when it fails
+// with optional `dataContext: true`: the per-value function is also given
+// `{ instancePath, parentData, parentDataProperty, rootData }`, as the default
+// validator's keywords are, so it can read or change the value where it sits
+// (validate(value, data, parent, ctx), or the compiled fn(data, ctx)). Such a
+// schema runs on the interpreted engine's collecting walk, which knows where
+// every value is.
 // with optional `type`: a JSON Schema type name or a list of them. A typed
 // keyword is skipped for data of any other type, which is what makes
 // `{ type: 'number', ... }` safe next to `type: ['number', 'string']`.
@@ -72,6 +78,12 @@ function normalizeKeywords(defs) {
       validate: hasValidate ? def.validate : null,
       compile: hasCompile ? def.compile : null,
       macro: hasMacro ? def.macro : null,
+      dataContext: def.dataContext === true,
+      // Order among the custom keywords of one node, as the default
+      // validator's keywords declare it: `before` names a keyword this one
+      // runs ahead of, `post` runs it after the others.
+      before: typeof def.before === 'string' ? def.before : null,
+      post: def.post === true,
     };
   }
   return out;
@@ -110,4 +122,15 @@ const NAME_MAPS = new Set([
   'dependentSchemas', 'dependentRequired', 'dependencies', 'propertyDependencies',
 ]);
 
-module.exports = { normalizeKeywords, schemaUsesKeywords };
+// Does the schema use a registered keyword that asks for its data's context?
+function schemaUsesDataContext(schema, keywords) {
+  if (!keywords) return false;
+  let any = false;
+  for (const name of Object.keys(keywords)) if (keywords[name].dataContext) { any = true; break; }
+  if (!any) return false;
+  const only = Object.create(null);
+  for (const name of Object.keys(keywords)) if (keywords[name].dataContext) only[name] = keywords[name];
+  return schemaUsesKeywords(schema, only);
+}
+
+module.exports = { normalizeKeywords, schemaUsesKeywords, schemaUsesDataContext };

package/lib/levenshtein.js

@@ -1,20 +1,25 @@
 'use strict';
 
-// Bounded Levenshtein. Returns Infinity if distance > maxDistance (or, past
+// Bounded edit distance. Returns Infinity if distance > maxDistance (or, past
 // the bound, possibly some number greater than it; callers compare).
 //
+// Two adjacent characters swapped count as one edit, not two (the optimal
+// string alignment distance): `nmae` for `name` is the commonest typo there
+// is, and at two edits a four-letter name's budget of one turned it away.
+//
 // Only the cells within the bound of the diagonal are computed: a path
 // through any other cell already costs more than the bound. A typo hint asks
 // with a bound of one or two and compares the missing name with every key
 // present, so a row is five cells instead of the whole key. Without a bound
 // the band is the whole row.
 //
-// Two rows of scratch, reused across calls. The function is not recursive
+// Three rows of scratch, reused across calls. The function is not recursive
 // and the library is single-threaded, so nothing else is using them; growing
 // them once beats allocating two arrays on every comparison, which the
 // reject-path profile showed as most of this function's cost.
 let scratchA = new Int32Array(64);
 let scratchB = new Int32Array(64);
+let scratchC = new Int32Array(64);
 
 function levenshtein (a, b, maxDistance) {
   if (a === b) return 0;
@@ -28,7 +33,11 @@ function levenshtein (a, b, maxDistance) {
   if (scratchA.length < m + 2) {
     scratchA = new Int32Array(m + 2);
     scratchB = new Int32Array(m + 2);
+    scratchC = new Int32Array(m + 2);
   }
+  // The row before the previous one, read for a swap: within the band of
+  // row i the cell two back on the diagonal is inside the band of row i - 2.
+  let prev2 = scratchC;
   let prev = scratchA;
   let curr = scratchB;
   for (let j = 0; j <= m; j++) prev[j] = j <= max ? j : big;
@@ -40,20 +49,27 @@ function levenshtein (a, b, maxDistance) {
     // charCodeAt rather than indexing: reading a character by index allocates
     // a one-character string, and this is the innermost loop.
     const ca = a.charCodeAt(i - 1);
+    const pa = i > 1 ? a.charCodeAt(i - 2) : -1;
     for (let j = lo; j <= hi; j++) {
-      let v = prev[j - 1] + (ca === b.charCodeAt(j - 1) ? 0 : 1);
+      const cb = b.charCodeAt(j - 1);
+      let v = prev[j - 1] + (ca === cb ? 0 : 1);
       const del = curr[j - 1] + 1;
       if (del < v) v = del;
       const ins = prev[j] + 1;
       if (ins < v) v = ins;
+      if (j > 1 && ca !== cb && ca === b.charCodeAt(j - 2) && pa === cb) {
+        const swap = prev2[j - 2] + 1;
+        if (swap < v) v = swap;
+      }
       if (v > big) v = big;
       curr[j] = v;
       if (v < rowMin) rowMin = v;
     }
     if (hi < m) curr[hi + 1] = big;
     if (rowMin > max) return Infinity;
-    // A destructured swap builds an array per row; a temporary does not.
-    const t = prev;
+    // A destructured swap builds an array per row; temporaries do not.
+    const t = prev2;
+    prev2 = prev;
     prev = curr;
     curr = t;
   }