ata-validator 1.6.2 → 1.7.1

package/lib/interpreter.js

@@ -4,9 +4,10 @@
 // schemas the JS codegen cannot represent when the native engine is absent
 // (browser, edge workers, ATA_NO_NATIVE). It walks the schema directly with
 // full annotation tracking (unevaluatedProperties/Items), $id/$anchor
-// resolution, and $dynamicRef dynamic-scope semantics. It optimizes for
-// correctness and clarity, not speed: hot paths belong to codegen and the
-// native engine.
+// resolution, and $dynamicRef dynamic-scope semantics. Each schema node is
+// resolved once into a fixed-shape Plan (type bitmask, compiled pattern,
+// looked-up format, a flag per keyword group) so the walk itself reads no
+// schema properties; codegen and the native engine remain the fast paths.
 
 const { compileSafe } = require('./safe-regex');
 
@@ -135,6 +136,10 @@ function walkPointer(root, pointer) {
       node = node.$defs;
     } else if (part === '$defs' && node.definitions) {
       node = node.definitions;
+    } else if (part === 'items' && Array.isArray(node.prefixItems)) {
+      // draft-07 array-form items is normalized to prefixItems; pointers
+      // written against the original document still land.
+      node = node.prefixItems;
     } else {
       return undefined;
     }
@@ -200,13 +205,27 @@ function deepEqual(a, b) {
 function codePointLength(s) {
   let n = 0;
   for (let i = 0; i < s.length; i++) {
-    const c = s.charCodeAt(i);
-    if (c >= 0xd800 && c <= 0xdbff && i + 1 < s.length) i++;
+    // Wraparound test: one compare classifies a high surrogate.
+    if (((s.charCodeAt(i) - 0xd800) >>> 0) < 0x400 && i + 1 < s.length) i++;
     n++;
   }
   return n;
 }
 
+// The code point count of a UTF-16 string sits between ceil(length / 2) and
+// length, so most length bounds are decided without counting anything.
+function cpAtLeast(s, min) {
+  if (s.length >= 2 * min) return true;
+  if (s.length < min) return false;
+  return codePointLength(s) >= min;
+}
+
+function cpAtMost(s, max) {
+  if (s.length <= max) return true;
+  if (s.length > 2 * max + 1) return false;
+  return codePointLength(s) <= max;
+}
+
 function typeMatches(type, d) {
   switch (type) {
     case 'string': return typeof d === 'string';
@@ -246,7 +265,15 @@ const FORMAT_CHECKS = {
 
 // ---------- evaluation ----------
 
-const NO_ANNOTATIONS = { props: null, items: null };
+// Sink for subschema results whose annotations the caller never reads
+// (properties, items, propertyNames and friends). eval() skips the merge when
+// it sees this object, so it is never mutated.
+const DISCARD = { props: null, items: null };
+
+// Verdict-only error sink. When eval() sees this identity it neither builds
+// error objects nor formats messages; every push site is guarded on it. The
+// array is frozen so a missed guard throws in tests instead of hiding.
+const NOERRORS = Object.freeze([]);
 
 function mergeAnnotations(target, from) {
   if (from.props && from.props.size) {
@@ -259,6 +286,310 @@ function mergeAnnotations(target, from) {
   }
 }
 
+// ---------- plans ----------
+
+// Type bits, one per JSON Schema type. `integer` data also sets the `number`
+// bit so a `number` constraint accepts it.
+const T_STRING = 1;
+const T_NUMBER = 2;
+const T_INTEGER = 4;
+const T_BOOLEAN = 8;
+const T_NULL = 16;
+const T_OBJECT = 32;
+const T_ARRAY = 64;
+const T_ANY = 127;
+
+function typeBit(name) {
+  switch (name) {
+    case 'string': return T_STRING;
+    case 'number': return T_NUMBER;
+    case 'integer': return T_INTEGER;
+    case 'boolean': return T_BOOLEAN;
+    case 'null': return T_NULL;
+    case 'object': return T_OBJECT;
+    case 'array': return T_ARRAY;
+    default: return T_ANY; // unknown type names match everything
+  }
+}
+
+function dataBits(d) {
+  switch (typeof d) {
+    case 'string': return T_STRING;
+    case 'number':
+      if (!isFinite(d)) return 0;
+      return Number.isInteger(d) ? T_NUMBER | T_INTEGER : T_NUMBER;
+    case 'boolean': return T_BOOLEAN;
+    case 'object':
+      if (d === null) return T_NULL;
+      return Array.isArray(d) ? T_ARRAY : T_OBJECT;
+    default: return 0;
+  }
+}
+
+function isObjectMap(v) {
+  return v !== null && typeof v === 'object' && !Array.isArray(v);
+}
+
+// A plan is the schema node with every keyword resolved once: the type list
+// folded to a bitmask, the format looked up, patterns compiled, and a flag
+// per section so eval() can skip whole blocks without touching the schema
+// object. Plans have a fixed shape, which keeps eval() monomorphic where the
+// raw schema objects are not.
+class Plan {
+  // The plan is registered in the cache before `link` runs, so a schema
+  // object that contains itself structurally resolves to the same plan
+  // instead of recursing without end.
+  constructor(schema) {
+    this.schema = schema;
+  }
+
+  link(interp) {
+    const schema = this.schema;
+    // Children are linked as plans (or booleans) up front, so a visit never
+    // goes back through the plan cache. Reference targets are resolved at
+    // evaluation time and cached per base URI.
+    const child = (sub) => interp.node(sub);
+    this.refCache = null;
+    this.refBase0 = undefined;
+    this.refRes0 = null;
+    this.dynCache = null;
+    this.ref = typeof schema.$ref === 'string' ? schema.$ref : null;
+    this.dynamicRef = typeof schema.$dynamicRef === 'string' ? schema.$dynamicRef : null;
+    this.tracked = this.ref !== null || this.dynamicRef !== null;
+
+    this.typeMask = 0;
+    this.typeNames = null;
+    if (schema.type !== undefined) {
+      const types = Array.isArray(schema.type) ? schema.type : [schema.type];
+      let mask = 0;
+      for (const t of types) mask |= typeBit(t);
+      this.typeMask = mask;
+      this.typeNames = types;
+    }
+    this.hasType = schema.type !== undefined;
+    this.enum = schema.enum !== undefined ? schema.enum : null;
+    this.hasConst = schema.const !== undefined;
+    this.const = schema.const;
+
+    this.minimum = typeof schema.minimum === 'number' ? schema.minimum : undefined;
+    this.maximum = typeof schema.maximum === 'number' ? schema.maximum : undefined;
+    this.exclusiveMinimum = typeof schema.exclusiveMinimum === 'number' ? schema.exclusiveMinimum : undefined;
+    this.exclusiveMaximum = typeof schema.exclusiveMaximum === 'number' ? schema.exclusiveMaximum : undefined;
+    this.multipleOf = typeof schema.multipleOf === 'number' ? schema.multipleOf : undefined;
+    this.hasNumber = this.minimum !== undefined || this.maximum !== undefined || this.exclusiveMinimum !== undefined || this.exclusiveMaximum !== undefined || this.multipleOf !== undefined;
+
+    this.minLength = schema.minLength;
+    this.maxLength = schema.maxLength;
+    this.pattern = schema.pattern !== undefined ? interp.pattern(schema.pattern) : null;
+    this.patternSource = schema.pattern;
+    this.format = schema.format;
+    this.formatFn = null;
+    if (schema.format !== undefined) {
+      const uf = interp.userFormats;
+      const fc = (uf && typeof uf[schema.format] === 'function') ? uf[schema.format] : FORMAT_CHECKS[schema.format];
+      this.formatFn = fc || null;
+    }
+    this.hasString = this.minLength !== undefined || this.maxLength !== undefined || this.pattern !== null || this.formatFn !== null;
+
+    this.minItems = schema.minItems;
+    this.maxItems = schema.maxItems;
+    this.uniqueItems = schema.uniqueItems === true;
+    this.prefixItems = Array.isArray(schema.prefixItems) ? schema.prefixItems.map(child) : null;
+    this.items = schema.items !== undefined ? child(schema.items) : undefined;
+    this.contains = schema.contains !== undefined ? child(schema.contains) : undefined;
+    this.minContains = schema.minContains;
+    this.maxContains = schema.maxContains;
+    this.hasArray = this.minItems !== undefined || this.maxItems !== undefined || this.uniqueItems || this.prefixItems !== null || this.items !== undefined || this.contains !== undefined;
+
+    this.required = Array.isArray(schema.required) ? schema.required : null;
+    this.minProperties = schema.minProperties;
+    this.maxProperties = schema.maxProperties;
+    this.dependentRequired = isObjectMap(schema.dependentRequired) ? Object.entries(schema.dependentRequired) : null;
+    this.propertyNames = schema.propertyNames !== undefined ? child(schema.propertyNames) : undefined;
+    this.properties = null;
+    if (isObjectMap(schema.properties)) {
+      this.properties = new Map();
+      for (const key of Object.keys(schema.properties)) {
+        const ek = escapePointer(key);
+        // Escaped once here; the walk only concatenates.
+        this.properties.set(key, { node: child(schema.properties[key]), seg: '/' + ek, schemaSeg: '/properties/' + ek });
+      }
+    }
+    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]) }));
+    }
+    this.additionalProperties = schema.additionalProperties !== undefined ? child(schema.additionalProperties) : undefined;
+    this.dependentSchemas = isObjectMap(schema.dependentSchemas) ? Object.entries(schema.dependentSchemas).map(([k, v]) => [k, child(v)]) : null;
+    this.propertyDependencies = null;
+    if (isObjectMap(schema.propertyDependencies)) {
+      this.propertyDependencies = Object.entries(schema.propertyDependencies)
+        .filter(([, choices]) => isObjectMap(choices))
+        .map(([k, choices]) => [k, new Map(Object.keys(choices).map((v) => [v, child(choices[v])]))]);
+    }
+    this.hasObject = this.required !== null || this.minProperties !== undefined || this.maxProperties !== undefined || this.dependentRequired !== null || this.propertyNames !== undefined || this.properties !== null || this.patternProperties !== null || this.additionalProperties !== undefined || this.dependentSchemas !== null || this.propertyDependencies !== null;
+
+    this.allOf = Array.isArray(schema.allOf) ? schema.allOf.map(child) : null;
+    this.anyOf = Array.isArray(schema.anyOf) ? schema.anyOf.map(child) : null;
+    this.oneOf = Array.isArray(schema.oneOf) ? schema.oneOf.map(child) : null;
+    this.not = schema.not !== undefined ? child(schema.not) : undefined;
+    this.if = schema.if !== undefined ? child(schema.if) : undefined;
+    this.then = schema.then !== undefined ? child(schema.then) : undefined;
+    this.else = schema.else !== undefined ? child(schema.else) : undefined;
+    this.hasApplicators = this.allOf !== null || this.anyOf !== null || this.oneOf !== null || this.not !== undefined || this.if !== undefined;
+
+    this.unevaluatedProperties = schema.unevaluatedProperties !== undefined ? child(schema.unevaluatedProperties) : undefined;
+    this.unevaluatedItems = schema.unevaluatedItems !== undefined ? child(schema.unevaluatedItems) : undefined;
+    this.hasUnevaluated = this.unevaluatedProperties !== undefined || this.unevaluatedItems !== undefined;
+
+    // Resource bookkeeping, read once instead of two Map lookups per visit.
+    const nodeBase = interp.state.nodeBase.get(schema);
+    this.nodeBase = nodeBase !== undefined ? nodeBase : null;
+    this.isResourceRoot = nodeBase !== undefined && interp.state.resources.get(nodeBase) === schema;
+
+    // A leaf plan checks only value-level keywords: no references, no
+    // subschemas, no annotations, no resource boundary. Those skip the whole
+    // eval() prologue (cycle guard, scope, annotation sinks) and run through
+    // evalLeaf(). Most schemas are mostly leaves.
+    this.leaf = !this.tracked && !this.hasApplicators && !this.hasUnevaluated &&
+      this.properties === null && this.patternProperties === null &&
+      this.additionalProperties === undefined && this.propertyNames === undefined &&
+      this.dependentSchemas === null && this.propertyDependencies === null &&
+      this.prefixItems === null && this.items === undefined && this.contains === undefined &&
+      this.nodeBase === null;
+  }
+}
+
+
+// Verdict-only twin of evalLeaf: no error objects, no path strings, first
+// failure returns. Kept adjacent so the two cannot drift.
+function evalLeafV(P, data) {
+  const bits = dataBits(data);
+  if (P.hasType && (bits & P.typeMask) === 0) return false;
+  if (P.enum !== null) {
+    let found = false;
+    for (let i = 0; i < P.enum.length; i++) { if (deepEqual(P.enum[i], data)) { found = true; break; } }
+    if (!found) return false;
+  }
+  if (P.hasConst && !deepEqual(P.const, data)) return false;
+  if (P.hasNumber && typeof data === 'number') {
+    if (P.minimum !== undefined && !(data >= P.minimum)) return false;
+    if (P.maximum !== undefined && !(data <= P.maximum)) return false;
+    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.hasString && bits === T_STRING) {
+    if (P.minLength !== undefined && !cpAtLeast(data, P.minLength)) return false;
+    if (P.maxLength !== undefined && !cpAtMost(data, P.maxLength)) return false;
+    if (P.pattern !== null && !P.pattern.test(data)) return false;
+    if (P.formatFn !== null && !P.formatFn(data)) return false;
+  }
+  if (P.hasArray && bits === T_ARRAY) {
+    if (P.minItems !== undefined && data.length < P.minItems) return false;
+    if (P.maxItems !== undefined && data.length > P.maxItems) return false;
+    if (P.uniqueItems) {
+      for (let i = 0; i < data.length; i++) {
+        for (let j = i + 1; j < data.length; j++) {
+          if (deepEqual(data[i], data[j])) return false;
+        }
+      }
+    }
+  }
+  if (P.hasObject && bits === T_OBJECT) {
+    if (P.required !== null) {
+      const req = P.required;
+      for (let i = 0; i < req.length; i++) {
+        if (!Object.hasOwn(data, req[i])) return false;
+      }
+    }
+    if (P.minProperties !== undefined && Object.keys(data).length < P.minProperties) return false;
+    if (P.maxProperties !== undefined && Object.keys(data).length > P.maxProperties) return false;
+    if (P.dependentRequired !== null) {
+      for (const [key, deps] of P.dependentRequired) {
+        if (Object.hasOwn(data, key)) {
+          for (const dep of deps) if (!Object.hasOwn(data, dep)) return false;
+        }
+      }
+    }
+  }
+  return true;
+}
+
+// Value-level checks only; the caller guarantees P.leaf. The bodies mirror
+// the corresponding sections of eval() exactly, minus the prologue.
+function evalLeaf(P, data, errors, instancePath, schemaPath) {
+  let valid = true;
+  const schema = P.schema;
+  const bits = dataBits(data);
+  if (P.hasType && (bits & P.typeMask) === 0) {
+    if (errors !== NOERRORS) errors.push(err('type', 'type', instancePath, schemaPath + '/type', { type: schema.type }, `must be ${P.typeNames.join(' or ')}`));
+    valid = false;
+  }
+  if (P.enum !== null) {
+    let found = false;
+    for (let i = 0; i < P.enum.length; i++) { if (deepEqual(P.enum[i], data)) { found = true; break; } }
+    if (!found) {
+      if (errors !== NOERRORS) errors.push(err('enum', 'enum', instancePath, schemaPath + '/enum', { allowedValues: P.enum }, 'must be equal to one of the allowed values'));
+      valid = false;
+    }
+  }
+  if (P.hasConst && !deepEqual(P.const, data)) {
+    if (errors !== NOERRORS) errors.push(err('const', 'const', instancePath, schemaPath + '/const', { allowedValue: P.const }, 'must be equal to constant'));
+    valid = false;
+  }
+  if (P.hasNumber && typeof data === 'number') {
+    if (P.minimum !== undefined && !(data >= P.minimum)) { errors === NOERRORS || errors.push(err('minimum', 'minimum', instancePath, schemaPath + '/minimum', { comparison: '>=', limit: P.minimum }, `must be >= ${P.minimum}`)); valid = false; }
+    if (P.maximum !== undefined && !(data <= P.maximum)) { errors === NOERRORS || errors.push(err('maximum', 'maximum', instancePath, schemaPath + '/maximum', { comparison: '<=', limit: P.maximum }, `must be <= ${P.maximum}`)); valid = false; }
+    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.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; }
+    if (P.maxLength !== undefined && !cpAtMost(data, P.maxLength)) { errors === NOERRORS || errors.push(err('maxLength', 'maxLength', instancePath, schemaPath + '/maxLength', { limit: P.maxLength }, `must NOT have more than ${P.maxLength} characters`)); valid = false; }
+    if (P.pattern !== null && !P.pattern.test(data)) { errors === NOERRORS || errors.push(err('pattern', 'pattern', instancePath, schemaPath + '/pattern', { pattern: P.patternSource }, `must match pattern "${P.patternSource}"`)); valid = false; }
+    if (P.formatFn !== null && !P.formatFn(data)) { errors === NOERRORS || errors.push(err('format', 'format', instancePath, schemaPath + '/format', { format: P.format }, `must match format "${P.format}"`)); valid = false; }
+  }
+  if (P.hasArray && bits === T_ARRAY) {
+    if (P.minItems !== undefined && data.length < P.minItems) { errors === NOERRORS || errors.push(err('minItems', 'minItems', instancePath, schemaPath + '/minItems', { limit: P.minItems }, `must NOT have fewer than ${P.minItems} items`)); valid = false; }
+    if (P.maxItems !== undefined && data.length > P.maxItems) { errors === NOERRORS || errors.push(err('maxItems', 'maxItems', instancePath, schemaPath + '/maxItems', { limit: P.maxItems }, `must NOT have more than ${P.maxItems} items`)); valid = false; }
+    if (P.uniqueItems) {
+      outer: for (let i = 0; i < data.length; i++) {
+        for (let j = i + 1; j < data.length; j++) {
+          if (deepEqual(data[i], data[j])) {
+            if (errors !== NOERRORS) errors.push(err('uniqueItems', 'uniqueItems', instancePath, schemaPath + '/uniqueItems', { i, j }, 'must NOT have duplicate items'));
+            valid = false;
+            break outer;
+          }
+        }
+      }
+    }
+  }
+  if (P.hasObject && bits === T_OBJECT) {
+    const keys = Object.keys(data);
+    if (P.required !== null) {
+      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 (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; }
+    if (P.maxProperties !== undefined && keys.length > P.maxProperties) { errors === NOERRORS || errors.push(err('maxProperties', 'maxProperties', instancePath, schemaPath + '/maxProperties', { limit: P.maxProperties }, `must NOT have more than ${P.maxProperties} properties`)); valid = false; }
+    if (P.dependentRequired !== null) {
+      for (const [key, deps] of P.dependentRequired) {
+        if (Object.hasOwn(data, key)) {
+          for (const dep of deps) {
+            if (!Object.hasOwn(data, dep)) { errors === NOERRORS || errors.push(err('required', 'required', instancePath, schemaPath + '/dependentRequired', { missingProperty: dep }, `must have required property '${dep}'`)); valid = false; }
+          }
+        }
+      }
+    }
+  }
+  return valid;
+}
+
 class Interpreter {
   constructor(rootSchema, options) {
     const opts = options || {};
@@ -269,6 +600,21 @@ class Interpreter {
     // requirement. See the `$dynamicRef` branch in eval().
     this.bookending = !opts.v1;
     this.patternCache = new Map();
+    // Plans are built on first visit; a schema node is never re-read after.
+    this.plans = new Map();
+    this.rootNode = this.node(rootSchema);
+    // Compiled closure tree: undefined = not attempted, null = out of scope.
+    this._fast = undefined;
+  }
+
+  // The closure-tree compiler covers single-resource schemas without
+  // unevaluated keywords; everything else stays on eval(). Compiled lazily so
+  // construction stays cheap for schemas that never validate.
+  _fastRoot() {
+    if (this._fast === undefined) {
+      try { this._fast = compileInterpreter(this); } catch { this._fast = null; }
+    }
+    return this._fast;
   }
 
   pattern(src) {
@@ -290,57 +636,142 @@ class Interpreter {
     return re;
   }
 
+  plan(schema) {
+    let p = this.plans.get(schema);
+    if (p === undefined) {
+      p = new Plan(schema);
+      this.plans.set(schema, p);
+      p.link(this);
+    }
+    return p;
+  }
+
+  // $ref resolution depends on the base URI in effect, which can differ
+  // between visits of the same node; cache per (plan, base). Nearly every
+  // plan only ever sees one base, so the last resolution lives in two plain
+  // fields and the Map exists only for the rare second base. The cached
+  // entry carries the already-planned child, so a visit does no Map lookups.
+  resolveRefCached(P, base) {
+    if (P.refBase0 === base) return P.refRes0;
+    let cache = P.refCache;
+    let r = cache !== null ? cache.get(base) : undefined;
+    if (r === undefined) {
+      const raw = resolveRef(P.ref, base, this.state);
+      r = { child: raw.node === undefined ? undefined : this.node(raw.node), base: raw.base };
+      if (P.refBase0 === undefined) { P.refBase0 = base; P.refRes0 = r; }
+      else { if (cache === null) cache = P.refCache = new Map(); cache.set(base, r); }
+    }
+    return r;
+  }
+
+  // The static half of $dynamicRef (initial target and fragment) per base;
+  // the dynamic-scope search still runs on every visit.
+  resolveDynamicRefCached(P, base) {
+    let cache = P.dynCache;
+    if (cache === null) cache = P.dynCache = new Map();
+    let r = cache.get(base);
+    if (r === undefined) {
+      const { node, base: refBase } = resolveRef(P.dynamicRef, base, this.state);
+      const [, fragment] = splitFragment(resolveUri(base, P.dynamicRef));
+      r = { node, base: refBase, fragment, byAnchor: Boolean(fragment) && !fragment.startsWith('/') };
+      cache.set(base, r);
+    }
+    return r;
+  }
+
+  // Maps any schema value to what eval() accepts: a boolean or a Plan.
+  // Non-object, non-boolean values validate everything, as before.
+  node(schema) {
+    if (schema === true || schema === false) return schema;
+    if (typeof schema !== 'object' || schema === null) return true;
+    return this.plan(schema);
+  }
+
+  // Verdict only: same walk as validate(), no error construction at all.
+  isValid(data) {
+    const fast = this._fastRoot();
+    if (fast !== null) return fast.v(data, []);
+    const dynScope = [this.state.rootBase];
+    return this.eval(this.rootNode, data, this.state.rootBase, dynScope, NOERRORS, '', '#', [], DISCARD);
+  }
+
   validate(data) {
+    const fast = this._fastRoot();
+    if (fast !== null) {
+      const errors = [];
+      const valid = fast.c(data, errors, '', '#', []);
+      return valid ? { valid: true, data, errors: [] } : { valid: false, errors };
+    }
     const errors = [];
     const dynScope = [this.state.rootBase];
-    const valid = this.eval(this.root, data, this.state.rootBase, dynScope, errors, '', '#', [], NO_ANNOTATIONS_SINK());
+    // Nothing reads the root's annotations, so they are discarded from the start.
+    const valid = this.eval(this.rootNode, data, this.state.rootBase, dynScope, errors, '', '#', [], DISCARD);
     return valid ? { valid: true, data, errors: [] } : { valid: false, errors };
   }
 
   // Evaluates `schema` against `data`. Collected annotations for data are
   // written into `sink` ({props, items}); errors append to `errors`.
   // `stack` breaks infinite $ref recursion on identical (schema, data) pairs.
-  eval(schema, data, base, dynScope, errors, instancePath, schemaPath, stack, sink) {
-    if (schema === true) return true;
-    if (schema === false) {
-      errors.push(err('false schema', 'not', instancePath, schemaPath, {}, 'boolean schema is false'));
+  eval(P, data, base, dynScope, errors, instancePath, schemaPath, stack, sink) {
+    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 (typeof schema !== 'object' || schema === null) return true;
+    if (P.leaf) return evalLeaf(P, data, errors, instancePath, schemaPath);
+    const schema = P.schema;
 
-    for (const frame of stack) {
-      if (frame[0] === schema && frame[1] === data) return true; // fixed point
+    // Only a reference can lead evaluation back to a schema it is already
+    // inside of, so the cycle guard is maintained on reference nodes alone.
+    // The frame is pushed in place and popped on the way out; the array is
+    // created per validate() call, so a throw leaves nothing to clean up.
+    const tracked = P.tracked;
+    if (tracked) {
+      for (let i = stack.length - 2; i >= 0; i -= 2) {
+        if (stack[i] === schema && stack[i + 1] === data) return true; // fixed point
+      }
+      stack.push(schema, data);
     }
-    stack = stack.concat([[schema, data]]);
 
-    const nodeBase = this.state.nodeBase.get(schema);
-    if (nodeBase !== undefined && nodeBase !== base) base = nodeBase;
-    // Entering a schema resource extends the dynamic scope.
-    if (this.state.resources.get(base) === schema && dynScope[dynScope.length - 1] !== base) {
-      dynScope = dynScope.concat(base);
+    if (P.nodeBase !== null && P.nodeBase !== base) base = P.nodeBase;
+    // Entering a schema resource extends the dynamic scope, whether evaluation
+    // lands on the resource's root or on a subschema inside it: a reference
+    // to first#/$defs/stuff still passes through resource `first`. The scope
+    // is pushed in place and popped on the way out; evaluation is depth-first
+    // and nothing retains the array.
+    let scopePushed = false;
+    if (dynScope[dynScope.length - 1] !== base) {
+      dynScope.push(base);
+      scopePushed = true;
     }
 
     let valid = true;
-    const local = { props: null, items: null };
+    // Annotations only matter if this node or an ancestor reads them. When
+    // nobody does, in-place children get the discard sink too and `local`
+    // stays unallocated.
+    const collect = sink !== DISCARD || P.hasUnevaluated;
+    const local = collect ? { props: null, items: null } : DISCARD;
 
     // $ref / $dynamicRef: in-place applicators, annotations flow through
-    if (typeof schema.$ref === 'string') {
-      const { node, base: refBase } = resolveRef(schema.$ref, base, this.state);
-      if (node === undefined) {
-        errors.push(err('$ref', '$ref', instancePath, schemaPath + '/$ref', { ref: schema.$ref }, `cannot resolve $ref ${schema.$ref}`));
+    if (P.ref !== null) {
+      const { child, base: refBase } = this.resolveRefCached(P, base);
+      if (child === undefined) {
+        if (errors !== NOERRORS) errors.push(err('$ref', '$ref', instancePath, schemaPath + '/$ref', { ref: P.ref }, `cannot resolve $ref ${P.ref}`));
         valid = false;
       } else {
-        const sub = { props: null, items: null };
-        if (!this.eval(node, data, refBase, dynScope, errors, instancePath, schemaPath + '/$ref', stack, sub)) valid = false;
-        else mergeAnnotations(local, sub);
+        const sub = collect ? { props: null, items: null } : DISCARD;
+        if (!this.eval(child, data, refBase, dynScope, errors, instancePath, schemaPath + '/$ref', stack, sub)) valid = false;
+        else if (collect) mergeAnnotations(local, sub);
       }
     }
 
-    if (typeof schema.$dynamicRef === 'string') {
-      const ref = schema.$dynamicRef;
-      let { node, base: refBase } = resolveRef(ref, base, this.state);
-      const [, fragment] = splitFragment(resolveUri(base, ref));
-      if (fragment && !fragment.startsWith('/')) {
+    if (P.dynamicRef !== null) {
+      const ref = P.dynamicRef;
+      const initial = this.resolveDynamicRefCached(P, base);
+      let node = initial.node;
+      let refBase = initial.base;
+      const fragment = initial.fragment;
+      if (initial.byAnchor) {
         // Under 2020-12 the initial target must itself carry the matching
         // $dynamicAnchor before the dynamic scope is consulted (bookending);
         // otherwise the keyword behaves like $ref. v1 removes that
@@ -364,100 +795,92 @@ class Interpreter {
         }
       }
       if (node === undefined) {
-        errors.push(err('$dynamicRef', '$dynamicRef', instancePath, schemaPath + '/$dynamicRef', { ref }, `cannot resolve $dynamicRef ${ref}`));
+        if (errors !== NOERRORS) errors.push(err('$dynamicRef', '$dynamicRef', instancePath, schemaPath + '/$dynamicRef', { ref }, `cannot resolve $dynamicRef ${ref}`));
         valid = false;
       } else {
-        const sub = { props: null, items: null };
-        if (!this.eval(node, data, refBase, dynScope, errors, instancePath, schemaPath + '/$dynamicRef', stack, sub)) valid = false;
-        else mergeAnnotations(local, sub);
+        const sub = collect ? { props: null, items: null } : DISCARD;
+        if (!this.eval(this.node(node), data, refBase, dynScope, errors, instancePath, schemaPath + '/$dynamicRef', stack, sub)) valid = false;
+        else if (collect) mergeAnnotations(local, sub);
       }
     }
 
+    const bits = dataBits(data);
+
     // type / enum / const
-    if (schema.type !== undefined) {
-      const types = Array.isArray(schema.type) ? schema.type : [schema.type];
-      if (!types.some((t) => typeMatches(t, data))) {
-        errors.push(err('type', 'type', instancePath, schemaPath + '/type', { type: schema.type }, `must be ${types.join(' or ')}`));
-        valid = false;
-      }
+    if (P.hasType && (bits & P.typeMask) === 0) {
+      if (errors !== NOERRORS) errors.push(err('type', 'type', instancePath, schemaPath + '/type', { type: schema.type }, `must be ${P.typeNames.join(' or ')}`));
+      valid = false;
     }
-    if (schema.enum !== undefined) {
-      if (!schema.enum.some((v) => deepEqual(v, data))) {
-        errors.push(err('enum', 'enum', instancePath, schemaPath + '/enum', { allowedValues: schema.enum }, 'must be equal to one of the allowed values'));
+    if (P.enum !== null) {
+      let found = false;
+      for (let i = 0; i < P.enum.length; i++) { if (deepEqual(P.enum[i], data)) { found = true; break; } }
+      if (!found) {
+        if (errors !== NOERRORS) errors.push(err('enum', 'enum', instancePath, schemaPath + '/enum', { allowedValues: P.enum }, 'must be equal to one of the allowed values'));
         valid = false;
       }
     }
-    if (schema.const !== undefined) {
-      if (!deepEqual(schema.const, data)) {
-        errors.push(err('const', 'const', instancePath, schemaPath + '/const', { allowedValue: schema.const }, 'must be equal to constant'));
-        valid = false;
-      }
+    if (P.hasConst && !deepEqual(P.const, data)) {
+      if (errors !== NOERRORS) errors.push(err('const', 'const', instancePath, schemaPath + '/const', { allowedValue: P.const }, 'must be equal to constant'));
+      valid = false;
     }
 
     // numbers
-    if (typeof data === 'number') {
-      if (typeof schema.minimum === 'number' && !(data >= schema.minimum)) { errors.push(err('minimum', 'minimum', instancePath, schemaPath + '/minimum', { comparison: '>=', limit: schema.minimum }, `must be >= ${schema.minimum}`)); valid = false; }
-      if (typeof schema.maximum === 'number' && !(data <= schema.maximum)) { errors.push(err('maximum', 'maximum', instancePath, schemaPath + '/maximum', { comparison: '<=', limit: schema.maximum }, `must be <= ${schema.maximum}`)); valid = false; }
-      if (typeof schema.exclusiveMinimum === 'number' && !(data > schema.exclusiveMinimum)) { errors.push(err('exclusiveMinimum', 'exclusiveMinimum', instancePath, schemaPath + '/exclusiveMinimum', { comparison: '>', limit: schema.exclusiveMinimum }, `must be > ${schema.exclusiveMinimum}`)); valid = false; }
-      if (typeof schema.exclusiveMaximum === 'number' && !(data < schema.exclusiveMaximum)) { errors.push(err('exclusiveMaximum', 'exclusiveMaximum', instancePath, schemaPath + '/exclusiveMaximum', { comparison: '<', limit: schema.exclusiveMaximum }, `must be < ${schema.exclusiveMaximum}`)); valid = false; }
-      if (typeof schema.multipleOf === 'number' && !multipleOfOk(data, schema.multipleOf)) { errors.push(err('multipleOf', 'multipleOf', instancePath, schemaPath + '/multipleOf', { multipleOf: schema.multipleOf }, `must be multiple of ${schema.multipleOf}`)); valid = false; }
+    if (P.hasNumber && typeof data === 'number') {
+      if (P.minimum !== undefined && !(data >= P.minimum)) { errors === NOERRORS || errors.push(err('minimum', 'minimum', instancePath, schemaPath + '/minimum', { comparison: '>=', limit: P.minimum }, `must be >= ${P.minimum}`)); valid = false; }
+      if (P.maximum !== undefined && !(data <= P.maximum)) { errors === NOERRORS || errors.push(err('maximum', 'maximum', instancePath, schemaPath + '/maximum', { comparison: '<=', limit: P.maximum }, `must be <= ${P.maximum}`)); valid = false; }
+      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; }
     }
 
     // strings
-    if (typeof data === 'string') {
-      if (schema.minLength !== undefined && codePointLength(data) < schema.minLength) { errors.push(err('minLength', 'minLength', instancePath, schemaPath + '/minLength', { limit: schema.minLength }, `must NOT have fewer than ${schema.minLength} characters`)); valid = false; }
-      if (schema.maxLength !== undefined && codePointLength(data) > schema.maxLength) { errors.push(err('maxLength', 'maxLength', instancePath, schemaPath + '/maxLength', { limit: schema.maxLength }, `must NOT have more than ${schema.maxLength} characters`)); valid = false; }
-      if (schema.pattern !== undefined && !this.pattern(schema.pattern).test(data)) { errors.push(err('pattern', 'pattern', instancePath, schemaPath + '/pattern', { pattern: schema.pattern }, `must match pattern "${schema.pattern}"`)); valid = false; }
-      if (schema.format !== undefined) {
-        const fc = (this.userFormats && typeof this.userFormats[schema.format] === 'function') ? this.userFormats[schema.format] : FORMAT_CHECKS[schema.format];
-        if (fc && !fc(data)) { errors.push(err('format', 'format', instancePath, schemaPath + '/format', { format: schema.format }, `must match format "${schema.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; }
+      if (P.maxLength !== undefined && !cpAtMost(data, P.maxLength)) { errors === NOERRORS || errors.push(err('maxLength', 'maxLength', instancePath, schemaPath + '/maxLength', { limit: P.maxLength }, `must NOT have more than ${P.maxLength} characters`)); valid = false; }
+      if (P.pattern !== null && !P.pattern.test(data)) { errors === NOERRORS || errors.push(err('pattern', 'pattern', instancePath, schemaPath + '/pattern', { pattern: P.patternSource }, `must match pattern "${P.patternSource}"`)); valid = false; }
+      if (P.formatFn !== null && !P.formatFn(data)) { errors === NOERRORS || errors.push(err('format', 'format', instancePath, schemaPath + '/format', { format: P.format }, `must match format "${P.format}"`)); valid = false; }
     }
 
     // arrays
-    if (Array.isArray(data)) {
-      if (schema.minItems !== undefined && data.length < schema.minItems) { errors.push(err('minItems', 'minItems', instancePath, schemaPath + '/minItems', { limit: schema.minItems }, `must NOT have fewer than ${schema.minItems} items`)); valid = false; }
-      if (schema.maxItems !== undefined && data.length > schema.maxItems) { errors.push(err('maxItems', 'maxItems', instancePath, schemaPath + '/maxItems', { limit: schema.maxItems }, `must NOT have more than ${schema.maxItems} items`)); valid = false; }
-      if (schema.uniqueItems === true) {
+    if (P.hasArray && bits === T_ARRAY) {
+      if (P.minItems !== undefined && data.length < P.minItems) { errors === NOERRORS || errors.push(err('minItems', 'minItems', instancePath, schemaPath + '/minItems', { limit: P.minItems }, `must NOT have fewer than ${P.minItems} items`)); valid = false; }
+      if (P.maxItems !== undefined && data.length > P.maxItems) { errors === NOERRORS || errors.push(err('maxItems', 'maxItems', instancePath, schemaPath + '/maxItems', { limit: P.maxItems }, `must NOT have more than ${P.maxItems} items`)); valid = false; }
+      if (P.uniqueItems) {
         outer: for (let i = 0; i < data.length; i++) {
           for (let j = i + 1; j < data.length; j++) {
             if (deepEqual(data[i], data[j])) {
-              errors.push(err('uniqueItems', 'uniqueItems', instancePath, schemaPath + '/uniqueItems', { i, j }, 'must NOT have duplicate items'));
+              if (errors !== NOERRORS) errors.push(err('uniqueItems', 'uniqueItems', instancePath, schemaPath + '/uniqueItems', { i, j }, 'must NOT have duplicate items'));
               valid = false;
               break outer;
             }
           }
         }
       }
-      const prefix = Array.isArray(schema.prefixItems) ? schema.prefixItems : null;
-      if (prefix) {
-        for (let i = 0; i < Math.min(prefix.length, data.length); i++) {
-          const sub = { props: null, items: null };
-          if (!this.eval(prefix[i], data[i], base, dynScope, errors, instancePath + '/' + i, schemaPath + '/prefixItems/' + i, stack, sub)) valid = false;
-          if (!local.items) local.items = new Set();
-          local.items.add(i);
+      const prefix = P.prefixItems;
+      if (prefix !== null) {
+        const n = Math.min(prefix.length, data.length);
+        for (let i = 0; i < n; i++) {
+          if (!this.eval(prefix[i], data[i], base, dynScope, errors, instancePath + '/' + i, schemaPath + '/prefixItems/' + i, stack, DISCARD)) valid = false;
+          if (collect) { if (!local.items) local.items = new Set(); local.items.add(i); }
         }
       }
-      if (schema.items !== undefined) {
-        const start = prefix ? prefix.length : 0;
+      if (P.items !== undefined) {
+        const start = prefix !== null ? prefix.length : 0;
         for (let i = start; i < data.length; i++) {
-          const sub = { props: null, items: null };
-          if (!this.eval(schema.items, data[i], base, dynScope, errors, instancePath + '/' + i, schemaPath + '/items', stack, sub)) valid = false;
-          if (!local.items) local.items = new Set();
-          local.items.add(i);
+          if (!this.eval(P.items, data[i], base, dynScope, errors, instancePath + '/' + i, schemaPath + '/items', stack, DISCARD)) valid = false;
+          if (collect) { if (!local.items) local.items = new Set(); local.items.add(i); }
         }
       }
-      if (schema.contains !== undefined) {
+      if (P.contains !== undefined) {
         const matched = [];
         for (let i = 0; i < data.length; i++) {
-          const scratch = [];
-          const sub = { props: null, items: null };
-          if (this.eval(schema.contains, data[i], base, dynScope, scratch, instancePath + '/' + i, schemaPath + '/contains', stack, sub)) matched.push(i);
+          const scratch = errors === NOERRORS ? NOERRORS : [];
+          if (this.eval(P.contains, data[i], base, dynScope, scratch, instancePath + '/' + i, schemaPath + '/contains', stack, DISCARD)) matched.push(i);
         }
-        const minC = schema.minContains !== undefined ? schema.minContains : 1;
-        if (matched.length < minC) { errors.push(err('contains', 'contains', instancePath, schemaPath + '/contains', { minContains: minC }, `must contain at least ${minC} valid item(s)`)); valid = false; }
-        if (schema.maxContains !== undefined && matched.length > schema.maxContains) { errors.push(err('maxContains', 'maxContains', instancePath, schemaPath + '/maxContains', { limit: schema.maxContains }, `must NOT contain more than ${schema.maxContains} valid item(s)`)); valid = false; }
-        if (matched.length) {
+        const minC = P.minContains !== undefined ? P.minContains : 1;
+        if (matched.length < minC) { errors === NOERRORS || errors.push(err('contains', 'contains', instancePath, schemaPath + '/contains', { minContains: minC }, `must contain at least ${minC} valid item(s)`)); valid = false; }
+        if (P.maxContains !== undefined && matched.length > P.maxContains) { errors === NOERRORS || errors.push(err('maxContains', 'maxContains', instancePath, schemaPath + '/maxContains', { limit: P.maxContains }, `must NOT contain more than ${P.maxContains} valid item(s)`)); valid = false; }
+        if (collect && matched.length) {
           if (!local.items) local.items = new Set();
           for (const i of matched) local.items.add(i);
         }
@@ -465,63 +888,65 @@ class Interpreter {
     }
 
     // objects
-    if (typeof data === 'object' && data !== null && !Array.isArray(data)) {
+    if (P.hasObject && bits === T_OBJECT) {
       const keys = Object.keys(data);
-      if (Array.isArray(schema.required)) {
-        for (const key of schema.required) {
-          if (!Object.prototype.hasOwnProperty.call(data, key)) { errors.push(err('required', 'required', instancePath, schemaPath + '/required', { missingProperty: key }, `must have required property '${key}'`)); valid = false; }
+      if (P.required !== null) {
+        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 (schema.minProperties !== undefined && keys.length < schema.minProperties) { errors.push(err('minProperties', 'minProperties', instancePath, schemaPath + '/minProperties', { limit: schema.minProperties }, `must NOT have fewer than ${schema.minProperties} properties`)); valid = false; }
-      if (schema.maxProperties !== undefined && keys.length > schema.maxProperties) { errors.push(err('maxProperties', 'maxProperties', instancePath, schemaPath + '/maxProperties', { limit: schema.maxProperties }, `must NOT have more than ${schema.maxProperties} properties`)); valid = false; }
-      if (schema.dependentRequired && typeof schema.dependentRequired === 'object') {
-        for (const [key, deps] of Object.entries(schema.dependentRequired)) {
-          if (Object.prototype.hasOwnProperty.call(data, key)) {
+      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; }
+      if (P.maxProperties !== undefined && keys.length > P.maxProperties) { errors === NOERRORS || errors.push(err('maxProperties', 'maxProperties', instancePath, schemaPath + '/maxProperties', { limit: P.maxProperties }, `must NOT have more than ${P.maxProperties} properties`)); valid = false; }
+      if (P.dependentRequired !== null) {
+        for (const [key, deps] of P.dependentRequired) {
+          if (Object.hasOwn(data, key)) {
             for (const dep of deps) {
-              if (!Object.prototype.hasOwnProperty.call(data, dep)) { errors.push(err('required', 'required', instancePath, schemaPath + '/dependentRequired', { missingProperty: dep }, `must have required property '${dep}'`)); valid = false; }
+              if (!Object.hasOwn(data, dep)) { errors === NOERRORS || errors.push(err('required', 'required', instancePath, schemaPath + '/dependentRequired', { missingProperty: dep }, `must have required property '${dep}'`)); valid = false; }
             }
           }
         }
       }
-      if (schema.propertyNames !== undefined) {
+      if (P.propertyNames !== undefined) {
         for (const key of keys) {
-          if (!this.eval(schema.propertyNames, key, base, dynScope, errors, instancePath + '/' + escapePointer(key), schemaPath + '/propertyNames', stack, { props: null, items: null })) valid = false;
+          if (!this.eval(P.propertyNames, key, base, dynScope, errors, instancePath + '/' + escapePointer(key), schemaPath + '/propertyNames', stack, DISCARD)) valid = false;
         }
       }
-      const props = schema.properties && typeof schema.properties === 'object' ? schema.properties : null;
-      const patterns = schema.patternProperties && typeof schema.patternProperties === 'object' ? Object.keys(schema.patternProperties) : null;
-      for (const key of keys) {
+      const props = P.properties;
+      const patterns = P.patternProperties;
+      for (let k = 0; k < keys.length; k++) {
+        const key = keys[k];
         let evaluated = false;
-        if (props && Object.prototype.hasOwnProperty.call(props, key)) {
-          const sub = { props: null, items: null };
-          if (!this.eval(props[key], data[key], base, dynScope, errors, instancePath + '/' + escapePointer(key), schemaPath + '/properties/' + escapePointer(key), stack, sub)) valid = false;
+        const prop = props !== null ? props.get(key) : undefined;
+        if (prop !== undefined) {
+          if (!this.eval(prop.node, data[key], base, dynScope, errors, instancePath + prop.seg, schemaPath + prop.schemaSeg, stack, DISCARD)) valid = false;
           evaluated = true;
         }
-        if (patterns) {
-          for (const src of patterns) {
-            if (this.pattern(src).test(key)) {
-              const sub = { props: null, items: null };
-              if (!this.eval(schema.patternProperties[src], data[key], base, dynScope, errors, instancePath + '/' + escapePointer(key), schemaPath + '/patternProperties/' + escapePointer(src), stack, sub)) valid = false;
+        if (patterns !== null) {
+          for (let pi = 0; pi < patterns.length; pi++) {
+            const pp = patterns[pi];
+            if (pp.re.test(key)) {
+              if (!this.eval(pp.node, data[key], base, dynScope, errors, instancePath + '/' + escapePointer(key), schemaPath + '/patternProperties/' + escapePointer(pp.src), stack, DISCARD)) valid = false;
               evaluated = true;
             }
           }
         }
-        if (!evaluated && schema.additionalProperties !== undefined) {
-          const sub = { props: null, items: null };
-          if (!this.eval(schema.additionalProperties, data[key], base, dynScope, errors, instancePath + '/' + escapePointer(key), schemaPath + '/additionalProperties', stack, sub)) valid = false;
+        if (!evaluated && P.additionalProperties !== undefined) {
+          if (!this.eval(P.additionalProperties, data[key], base, dynScope, errors, instancePath + '/' + escapePointer(key), schemaPath + '/additionalProperties', stack, DISCARD)) valid = false;
           evaluated = true;
         }
-        if (evaluated) {
+        if (evaluated && collect) {
           if (!local.props) local.props = new Set();
           local.props.add(key);
         }
       }
-      if (schema.dependentSchemas && typeof schema.dependentSchemas === 'object') {
-        for (const [key, dep] of Object.entries(schema.dependentSchemas)) {
-          if (Object.prototype.hasOwnProperty.call(data, key)) {
-            const sub = { props: null, items: null };
+      if (P.dependentSchemas !== null) {
+        for (const [key, dep] of P.dependentSchemas) {
+          if (Object.hasOwn(data, key)) {
+            const sub = collect ? { props: null, items: null } : DISCARD;
             if (!this.eval(dep, data, base, dynScope, errors, instancePath, schemaPath + '/dependentSchemas/' + escapePointer(key), stack, sub)) valid = false;
-            else mergeAnnotations(local, sub);
+            else if (collect) mergeAnnotations(local, sub);
           }
         }
       }
@@ -529,125 +954,136 @@ class Interpreter {
       // value rather than its presence. Only string values can match, since the
       // inner keys are object keys. Equivalent to
       // `if: { properties: { p: { const: v } }, required: [p] }, then: <schema>`.
-      if (schema.propertyDependencies && typeof schema.propertyDependencies === 'object') {
-        for (const [key, choices] of Object.entries(schema.propertyDependencies)) {
-          if (!choices || typeof choices !== 'object' || Array.isArray(choices)) continue;
-          if (!Object.prototype.hasOwnProperty.call(data, key)) continue;
+      if (P.propertyDependencies !== null) {
+        for (const [key, choices] of P.propertyDependencies) {
+          if (!Object.hasOwn(data, key)) continue;
           const value = data[key];
           if (typeof value !== 'string') continue;
-          if (!Object.prototype.hasOwnProperty.call(choices, value)) continue;
-          const sub = { props: null, items: null };
+          const choice = choices.get(value);
+          if (choice === undefined) continue;
+          const sub = collect ? { props: null, items: null } : DISCARD;
           const branchPath = schemaPath + '/propertyDependencies/' + escapePointer(key) + '/' + escapePointer(value);
-          if (!this.eval(choices[value], data, base, dynScope, errors, instancePath, branchPath, stack, sub)) valid = false;
-          else mergeAnnotations(local, sub);
+          if (!this.eval(choice, data, base, dynScope, errors, instancePath, branchPath, stack, sub)) valid = false;
+          else if (collect) mergeAnnotations(local, sub);
         }
       }
     }
 
     // in-place applicators
-    if (Array.isArray(schema.allOf)) {
-      for (let i = 0; i < schema.allOf.length; i++) {
-        const sub = { props: null, items: null };
-        if (!this.eval(schema.allOf[i], data, base, dynScope, errors, instancePath, schemaPath + '/allOf/' + i, stack, sub)) valid = false;
-        else mergeAnnotations(local, sub);
-      }
-    }
-    if (Array.isArray(schema.anyOf)) {
-      let any = false;
-      const scratch = [];
-      for (let i = 0; i < schema.anyOf.length; i++) {
-        const sub = { props: null, items: null };
-        if (this.eval(schema.anyOf[i], data, base, dynScope, scratch, instancePath, schemaPath + '/anyOf/' + i, stack, sub)) {
-          any = true;
-          mergeAnnotations(local, sub);
+    if (P.hasApplicators) {
+      if (P.allOf !== null) {
+        for (let i = 0; i < P.allOf.length; i++) {
+          const sub = collect ? { props: null, items: null } : DISCARD;
+          if (!this.eval(P.allOf[i], data, base, dynScope, errors, instancePath, schemaPath + '/allOf/' + i, stack, sub)) valid = false;
+          else if (collect) mergeAnnotations(local, sub);
         }
       }
-      if (!any) {
-        for (const e of scratch) errors.push(e);
-        errors.push(err('anyOf', 'anyOf', instancePath, schemaPath + '/anyOf', {}, 'must match a schema in anyOf'));
-        valid = false;
-      }
-    }
-    if (Array.isArray(schema.oneOf)) {
-      let count = 0;
-      let winner = null;
-      const scratch = [];
-      for (let i = 0; i < schema.oneOf.length; i++) {
-        const sub = { props: null, items: null };
-        if (this.eval(schema.oneOf[i], data, base, dynScope, scratch, instancePath, schemaPath + '/oneOf/' + i, stack, sub)) {
-          count++;
-          winner = sub;
+      if (P.anyOf !== null) {
+        let any = false;
+        const scratch = errors === NOERRORS ? NOERRORS : [];
+        for (let i = 0; i < P.anyOf.length; i++) {
+          const sub = collect ? { props: null, items: null } : DISCARD;
+          if (this.eval(P.anyOf[i], data, base, dynScope, scratch, instancePath, schemaPath + '/anyOf/' + i, stack, sub)) {
+            any = true;
+            if (collect) mergeAnnotations(local, sub);
+          }
+        }
+        if (!any) {
+          if (errors !== NOERRORS) for (const e of scratch) errors.push(e);
+          if (errors !== NOERRORS) errors.push(err('anyOf', 'anyOf', instancePath, schemaPath + '/anyOf', {}, 'must match a schema in anyOf'));
+          valid = false;
         }
       }
-      if (count === 1) mergeAnnotations(local, winner);
-      else {
-        if (count === 0) for (const e of scratch) errors.push(e);
-        errors.push(err('oneOf', 'oneOf', instancePath, schemaPath + '/oneOf', { passingSchemas: count }, 'must match exactly one schema in oneOf'));
-        valid = false;
+      if (P.oneOf !== null) {
+        let count = 0;
+        let winner = null;
+        const scratch = errors === NOERRORS ? NOERRORS : [];
+        for (let i = 0; i < P.oneOf.length; i++) {
+          const sub = collect ? { props: null, items: null } : DISCARD;
+          if (this.eval(P.oneOf[i], data, base, dynScope, scratch, instancePath, schemaPath + '/oneOf/' + i, stack, sub)) {
+            count++;
+            winner = sub;
+          }
+        }
+        if (count === 1) { if (collect) mergeAnnotations(local, winner); }
+        else {
+          if (count === 0) for (const e of scratch) errors.push(e);
+          if (errors !== NOERRORS) errors.push(err('oneOf', 'oneOf', instancePath, schemaPath + '/oneOf', { passingSchemas: count }, 'must match exactly one schema in oneOf'));
+          valid = false;
+        }
       }
-    }
-    if (schema.not !== undefined) {
-      const scratch = [];
-      if (this.eval(schema.not, data, base, dynScope, scratch, instancePath, schemaPath + '/not', stack, { props: null, items: null })) {
-        errors.push(err('not', 'not', instancePath, schemaPath + '/not', {}, 'must NOT be valid'));
-        valid = false;
+      if (P.not !== undefined) {
+        const scratch = errors === NOERRORS ? NOERRORS : [];
+        if (this.eval(P.not, data, base, dynScope, scratch, instancePath, schemaPath + '/not', stack, DISCARD)) {
+          if (errors !== NOERRORS) errors.push(err('not', 'not', instancePath, schemaPath + '/not', {}, 'must NOT be valid'));
+          valid = false;
+        }
       }
-    }
-    if (schema.if !== undefined) {
-      const ifSub = { props: null, items: null };
-      const ifScratch = [];
-      const ifOk = this.eval(schema.if, data, base, dynScope, ifScratch, instancePath, schemaPath + '/if', stack, ifSub);
-      if (ifOk) {
-        mergeAnnotations(local, ifSub);
-        if (schema.then !== undefined) {
-          const sub = { props: null, items: null };
-          if (!this.eval(schema.then, data, base, dynScope, errors, instancePath, schemaPath + '/then', stack, sub)) valid = false;
-          else mergeAnnotations(local, sub);
+      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, schemaPath + '/if', stack, ifSub);
+        if (ifOk) {
+          if (collect) mergeAnnotations(local, ifSub);
+          if (P.then !== undefined) {
+            const sub = collect ? { props: null, items: null } : DISCARD;
+            if (!this.eval(P.then, data, base, dynScope, errors, instancePath, schemaPath + '/then', stack, sub)) valid = false;
+            else if (collect) mergeAnnotations(local, sub);
+          }
+        } else if (P.else !== undefined) {
+          const sub = collect ? { props: null, items: null } : DISCARD;
+          if (!this.eval(P.else, data, base, dynScope, errors, instancePath, schemaPath + '/else', stack, sub)) valid = false;
+          else if (collect) mergeAnnotations(local, sub);
         }
-      } else if (schema.else !== undefined) {
-        const sub = { props: null, items: null };
-        if (!this.eval(schema.else, data, base, dynScope, errors, instancePath, schemaPath + '/else', stack, sub)) valid = false;
-        else mergeAnnotations(local, sub);
       }
     }
 
     // unevaluated*: run last, against annotations from everything above
-    if (schema.unevaluatedProperties !== undefined && typeof data === 'object' && data !== null && !Array.isArray(data)) {
-      for (const key of Object.keys(data)) {
-        if (local.props && local.props.has(key)) continue;
-        const sub = { props: null, items: null };
-        if (!this.eval(schema.unevaluatedProperties, data[key], base, dynScope, errors, instancePath + '/' + escapePointer(key), schemaPath + '/unevaluatedProperties', stack, sub)) valid = false;
-        if (!local.props) local.props = new Set();
-        local.props.add(key);
+    if (P.hasUnevaluated) {
+      if (P.unevaluatedProperties !== undefined && bits === T_OBJECT) {
+        for (const key of Object.keys(data)) {
+          if (local.props && local.props.has(key)) continue;
+          if (!this.eval(P.unevaluatedProperties, data[key], base, dynScope, errors, instancePath + '/' + escapePointer(key), schemaPath + '/unevaluatedProperties', stack, DISCARD)) valid = false;
+          if (!local.props) local.props = new Set();
+          local.props.add(key);
+        }
       }
-    }
-    if (schema.unevaluatedItems !== undefined && Array.isArray(data)) {
-      for (let i = 0; i < data.length; i++) {
-        if (local.items && local.items.has(i)) continue;
-        const sub = { props: null, items: null };
-        if (!this.eval(schema.unevaluatedItems, data[i], base, dynScope, errors, instancePath + '/' + i, schemaPath + '/unevaluatedItems', stack, sub)) valid = false;
-        if (!local.items) local.items = new Set();
-        local.items.add(i);
+      if (P.unevaluatedItems !== undefined && bits === T_ARRAY) {
+        for (let i = 0; i < data.length; i++) {
+          if (local.items && local.items.has(i)) continue;
+          if (!this.eval(P.unevaluatedItems, data[i], base, dynScope, errors, instancePath + '/' + i, schemaPath + '/unevaluatedItems', stack, DISCARD)) valid = false;
+          if (!local.items) local.items = new Set();
+          local.items.add(i);
+        }
       }
     }
 
-    if (valid) mergeAnnotations(sink, local);
+    if (scopePushed) dynScope.pop();
+    if (tracked) stack.length -= 2;
+    if (valid && collect && sink !== DISCARD) mergeAnnotations(sink, local);
     return valid;
   }
 }
 
-function NO_ANNOTATIONS_SINK() {
-  return { props: null, items: null };
-}
-
 function escapePointer(s) {
-  return String(s).replace(/~/g, '~0').replace(/\//g, '~1');
+  if (typeof s !== 'string') s = String(s);
+  // Keys almost never contain `~` or `/`; skip the two regex passes when so.
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if (c === 0x7e || c === 0x2f) return s.replace(/~/g, '~0').replace(/\//g, '~1');
+  }
+  return s;
 }
 
 function err(code, keyword, instancePath, schemaPath, params, message) {
   return { keyword, instancePath, schemaPath, params, message };
 }
 
+const { compileInterpreter } = require('./plan-compiler').install({
+  Plan, NOERRORS, err, evalLeaf, evalLeafV, deepEqual, dataBits, escapePointer,
+  T_STRING, T_ARRAY, T_OBJECT, resolveRef, splitFragment, resolveUri,
+});
+
 function createInterpreter(schema, options) {
   return new Interpreter(schema, options);
 }