ata-validator 1.49.0 → 1.51.0

package/lib/interpreter-core.js

@@ -0,0 +1,1356 @@
+'use strict';
+
+// Interpreted draft 2020-12 engine. This is the correctness fallback for
+// 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. 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.
+
+// Read on the first pattern (see lib/js-compiler.js for why).
+let _safeRe = null;
+const compileSafe = (src) => (_safeRe || (_safeRe = require('./safe-regex'))).compileSafe(src);
+
+const SCHEMA_KEYWORDS = {
+  single: ['additionalProperties', 'contains', 'propertyNames', 'if', 'then', 'else', 'not', 'items', 'unevaluatedItems', 'unevaluatedProperties'],
+  maps: ['$defs', 'definitions', 'properties', 'patternProperties', 'dependentSchemas'],
+  lists: ['allOf', 'anyOf', 'oneOf', 'prefixItems'],
+};
+
+const FALLBACK_BASE = 'ata://root';
+
+function resolveUri(base, ref) {
+  try {
+    return new URL(ref, base || FALLBACK_BASE).href;
+  } catch {
+    return ref;
+  }
+}
+
+function splitFragment(uri) {
+  const hash = uri.indexOf('#');
+  if (hash < 0) return [uri, ''];
+  return [uri.slice(0, hash), decodeURIComponent(uri.slice(hash + 1))];
+}
+
+// Loaded on the first collapsed anyOf/oneOf error, not with the engine.
+let _collapse = null;
+const collapseBranches = (args) => (_collapse || (_collapse = require('./branch-collapse').collapseBranches))(args);
+
+// ---------- resource index ----------
+
+// `flat`: the caller knows the schema holds no embedded resource and no
+// anchor (the shared error runtime is told so by the build), so only the root
+// is registered and the walk over every node is skipped. Every node then
+// resolves against the root's base, which is what the walk would record.
+function indexSchemas(rootSchema, schemaMap, flat) {
+  const state = {
+    resources: new Map(), // baseUri -> schema node of the resource root
+    anchors: new Map(), // baseUri -> Map(anchorName -> node)
+    dynamicAnchors: new Map(), // baseUri -> Map(anchorName -> node)
+    nodeBase: new Map(), // schema node -> baseUri of its enclosing resource
+    rootBase: FALLBACK_BASE,
+  };
+
+  const rootBase =
+    typeof rootSchema === 'object' && rootSchema !== null && typeof rootSchema.$id === 'string'
+      ? resolveUri(FALLBACK_BASE, splitFragment(rootSchema.$id)[0])
+      : FALLBACK_BASE;
+  state.rootBase = rootBase;
+  if (flat === true && !schemaMap && typeof rootSchema === 'object' && rootSchema !== null) {
+    state.resources.set(rootBase, rootSchema);
+    state.anchors.set(rootBase, new Map());
+    state.dynamicAnchors.set(rootBase, new Map());
+    state.nodeBase.set(rootSchema, rootBase);
+    return state;
+  }
+  indexResource(rootSchema, rootBase, state);
+
+  if (schemaMap) {
+    for (const [id, schema] of schemaMap) {
+      const base = resolveUri(FALLBACK_BASE, splitFragment(id)[0]);
+      if (!state.resources.has(base)) indexResource(schema, base, state);
+      // Also register under the raw key so non-URI ids stay addressable.
+      if (!state.resources.has(id)) state.resources.set(id, schema);
+    }
+  }
+  return state;
+}
+
+function indexResource(node, baseUri, state) {
+  if (typeof node !== 'object' || node === null) return;
+  if (!state.resources.has(baseUri)) state.resources.set(baseUri, node);
+  if (!state.anchors.has(baseUri)) state.anchors.set(baseUri, new Map());
+  if (!state.dynamicAnchors.has(baseUri)) state.dynamicAnchors.set(baseUri, new Map());
+  walkSchema(node, baseUri, state, true);
+}
+
+function walkSchema(node, baseUri, state, isResourceRoot) {
+  if (typeof node !== 'object' || node === null) return;
+  if (state.nodeBase.has(node)) return; // cycle guard
+  state.nodeBase.set(node, baseUri);
+
+  if (!isResourceRoot && typeof node.$id === 'string') {
+    // Embedded resource: new base URI, indexed as its own resource.
+    const newBase = splitFragment(resolveUri(baseUri, node.$id))[0];
+    state.nodeBase.delete(node); // re-register under the new base
+    indexResource(node, newBase, state);
+    return;
+  }
+
+  if (typeof node.$anchor === 'string') state.anchors.get(baseUri).set(node.$anchor, node);
+  if (typeof node.$dynamicAnchor === 'string') {
+    state.dynamicAnchors.get(baseUri).set(node.$dynamicAnchor, node);
+    // A $dynamicAnchor is also addressable as a plain anchor.
+    state.anchors.get(baseUri).set(node.$dynamicAnchor, node);
+  }
+
+  for (const kw of SCHEMA_KEYWORDS.single) {
+    if (node[kw] !== undefined) walkSchema(node[kw], baseUri, state, false);
+  }
+  for (const kw of SCHEMA_KEYWORDS.maps) {
+    const map = node[kw];
+    if (map && typeof map === 'object' && !Array.isArray(map)) {
+      for (const key of Object.keys(map)) walkSchema(map[key], baseUri, state, false);
+    }
+  }
+  for (const kw of SCHEMA_KEYWORDS.lists) {
+    const list = node[kw];
+    if (Array.isArray(list)) for (const sub of list) walkSchema(sub, baseUri, state, false);
+  }
+  // propertyDependencies nests one level deeper than the other maps:
+  // property name -> property value -> schema.
+  const propDeps = node.propertyDependencies;
+  if (propDeps && typeof propDeps === 'object' && !Array.isArray(propDeps)) {
+    for (const choices of Object.values(propDeps)) {
+      if (choices && typeof choices === 'object' && !Array.isArray(choices)) {
+        for (const sub of Object.values(choices)) walkSchema(sub, baseUri, state, false);
+      }
+    }
+  }
+}
+
+// ---------- ref resolution ----------
+
+function walkPointer(root, pointer) {
+  if (pointer === '' || pointer === '/') return root;
+  const parts = pointer
+    .split('/')
+    .slice(1)
+    .map((s) => s.replace(/~1/g, '/').replace(/~0/g, '~'));
+  let node = root;
+  for (const part of parts) {
+    if (node === null || typeof node !== 'object') return undefined;
+    if (Array.isArray(node)) {
+      node = node[Number(part)];
+    } else if (part in node) {
+      node = node[part];
+    } else if (part === 'definitions' && node.$defs) {
+      // draft-07 normalization renames definitions to $defs; keep old
+      // pointers working (mirrors the 1.0.2 alias fix).
+      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;
+    }
+  }
+  return node;
+}
+
+function resolveRef(ref, fromBase, state) {
+  const abs = resolveUri(fromBase, ref);
+  const [uri, fragment] = splitFragment(abs);
+  let resource = state.resources.get(uri);
+  let resourceBase = uri;
+  if (resource === undefined && (uri === FALLBACK_BASE || uri === '')) {
+    resource = state.resources.get(state.rootBase);
+    resourceBase = state.rootBase;
+  }
+  if (resource === undefined) {
+    // Raw-id registration (schemaMap keys that are not URIs).
+    const [rawUri, rawFragment] = splitFragment(ref);
+    if (state.resources.has(rawUri)) {
+      resource = state.resources.get(rawUri);
+      resourceBase = rawUri;
+      if (rawFragment === '') return { node: resource, base: resourceBase };
+      if (rawFragment.startsWith('/')) return { node: walkPointer(resource, rawFragment), base: resourceBase };
+      const anchored = state.anchors.get(resourceBase);
+      return { node: anchored ? anchored.get(rawFragment) : undefined, base: resourceBase };
+    }
+    return { node: undefined, base: resourceBase };
+  }
+  if (fragment === '') return { node: resource, base: resourceBase };
+  if (fragment.startsWith('/')) {
+    const node = walkPointer(resource, fragment);
+    // A pointer can land inside an embedded resource; its recorded base wins.
+    const base = node !== null && typeof node === 'object' && state.nodeBase.has(node) ? state.nodeBase.get(node) : resourceBase;
+    return { node, base };
+  }
+  const anchored = state.anchors.get(resourceBase);
+  return { node: anchored ? anchored.get(fragment) : undefined, base: resourceBase };
+}
+
+// ---------- value helpers ----------
+
+// uniqueItems: the functions the code generator emits as _uq and _uqp
+// (lib/unique-items.js), so both engines run the same code.
+const { allDistinct, duplicatePair, _deq } = require('./unique-items');
+
+// Whether `data` deep-equals one of the node's enum values (see enumPrims).
+function enumMember(P, data) {
+  if (data === null || typeof data !== 'object') return P.enumPrims.has(data);
+  const objs = P.enumObjs;
+  for (let i = 0; i < objs.length; i++) if (deepEqual(objs[i], data)) return true;
+  return false;
+}
+
+// JSON equality: the same function the code generator emits as `_deq`, so the
+// engines agree on what equal means (an object's own keys, in any order).
+const deepEqual = _deq;
+
+function codePointLength(s) {
+  let n = 0;
+  for (let i = 0; i < 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';
+    case 'number': return 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 typeof d === 'object' && d !== null && !Array.isArray(d);
+    default: return true;
+  }
+}
+
+function multipleOfOk(d, m) {
+  if (m === 0) return false;
+  const q = d / m;
+  if (Number.isInteger(q)) return true;
+  // Float remainder tolerance (0.0075 % 0.0001 style cases)
+  return Math.abs(q - Math.round(q)) < 1e-9;
+}
+
+// The built-in format checks, built on the first schema that names a format:
+// the engine loads without lib/formats.js, which schemas without `format`
+// never need.
+let _formatChecks = null;
+function buildFormatChecks() {
+  const _formats = require('./formats');
+  return {
+  email: _formats.email,
+  date: _formats.date,
+  'date-time': _formats.dateTime,
+  time: _formats.time,
+  duration: _formats.duration,
+  uuid: _formats.uuid,
+  uri: _formats.uri,
+  'uri-reference': _formats.uriReference,
+  ipv4: _formats.ipv4,
+  ipv6: _formats.ipv6,
+  hostname: _formats.hostname,
+  regex: (s) => { try { new RegExp(s, 'u'); return true; } catch { return false; } },
+  'json-pointer': _formats.jsonPointer,
+  'relative-json-pointer': _formats.relativeJsonPointer,
+  'uri-template': _formats.uriTemplate,
+  iri: _formats.iri,
+  'iri-reference': _formats.iriReference,
+  'idn-email': _formats.idnEmail,
+  };
+}
+
+// ---------- evaluation ----------
+
+// 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) {
+    if (!target.props) target.props = new Set();
+    for (const p of from.props) target.props.add(p);
+  }
+  if (from.items && from.items.size) {
+    if (!target.items) target.items = new Set();
+    for (const i of from.items) target.items.add(i);
+  }
+}
+
+// ---------- 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;
+    // Membership for enumMember(): the primitive values in a Set, so a long
+    // enum answers in one lookup, and the object and array values, which only
+    // deepEqual can compare, in a list. Scanning every value with deepEqual
+    // was a fifth to a third of what validating SchemaStore's samples cost.
+    // NaN stays out of the Set: deepEqual never matches it, and a Set would.
+    this.enumPrims = null;
+    this.enumObjs = null;
+    if (Array.isArray(this.enum)) {
+      this.enumPrims = new Set();
+      this.enumObjs = [];
+      for (const v of this.enum) {
+        if (v !== null && typeof v === 'object') this.enumObjs.push(v);
+        else if (!(typeof v === 'number' && v !== v)) this.enumPrims.add(v);
+      }
+    }
+    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] : (_formatChecks || (_formatChecks = buildFormatChecks()))[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;
+    // Macro keywords: the schema the macro returns is applied in place, the
+    // way the reference validator does it, so its errors carry the keyword's
+    // path and the keyword adds an error of its own when that schema fails.
+    this.macros = null;
+    if (interp.keywords !== null) {
+      for (const key of Object.keys(schema)) {
+        const def = interp.keywords[key];
+        if (def === undefined || def.macro === null) continue;
+        const expanded = def.macro(schema[key], schema);
+        if (expanded === undefined) continue;
+        if (this.macros === null) this.macros = [];
+        this.macros.push({ keyword: key, node: child(expanded) });
+      }
+    }
+    this.hasApplicators = this.allOf !== null || this.anyOf !== null || this.oneOf !== null || this.not !== undefined || this.if !== undefined || this.macros !== null;
+
+    this.unevaluatedProperties = schema.unevaluatedProperties !== undefined ? child(schema.unevaluatedProperties) : undefined;
+    this.unevaluatedItems = schema.unevaluatedItems !== undefined ? child(schema.unevaluatedItems) : undefined;
+    // A `false` here rejects the member outright, and the error belongs to this
+    // keyword on this object, not to a boolean schema that happens to sit
+    // under it. Recorded at compile time so the check below is one test.
+    this.unevaluatedPropertiesFalse = schema.unevaluatedProperties === false;
+    this.unevaluatedItemsFalse = schema.unevaluatedItems === false;
+    this.hasUnevaluated = this.unevaluatedProperties !== undefined || this.unevaluatedItems !== undefined;
+
+    // Custom keywords present on this node, in schema order. Each op holds
+    // the per-value check, built once here for the compile form, and the
+    // type mask it applies to (T_ANY when the definition names no type).
+    this.custom = null;
+    if (interp.keywords !== null) {
+      for (const key of Object.keys(schema)) {
+        const def = interp.keywords[key];
+        if (def === undefined || def.macro !== null) continue;
+        const value = schema[key];
+        let mask = T_ANY;
+        if (def.types !== null) {
+          mask = 0;
+          for (const t of def.types) mask |= typeBit(t);
+        }
+        let fn;
+        if (def.compile !== null) {
+          fn = def.compile(value, schema);
+          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);
+          // 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.hasCustom = this.custom !== null;
+
+    // Resource bookkeeping, read once instead of two Map lookups per visit.
+    // Only a resource root changes the base: a node inside a resource is
+    // reached with its resource's base already, by descent from the root or
+    // through a reference, whose resolution hands over the target's base. The
+    // index records a base for every node, and carrying it here made every
+    // plan a resource boundary, so no plan was ever a leaf and every value
+    // check went through the whole eval() prologue.
+    const nodeBase = interp.state.nodeBase.get(schema);
+    this.isResourceRoot = nodeBase !== undefined && interp.state.resources.get(nodeBase) === schema;
+    this.nodeBase = this.isResourceRoot ? nodeBase : null;
+
+    // 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) {
+    if (!enumMember(P, data)) return false;
+  }
+  if (P.hasConst && !deepEqual(P.const, data)) return false;
+  if (P.hasNumber && Number.isFinite(data)) {
+    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 && !allDistinct(data)) 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;
+        }
+      }
+    }
+  }
+  if (P.hasCustom && !runCustomV(P, data, bits)) return false;
+  return true;
+}
+
+// Custom keyword checks for one node. The verdict variant stops at the first
+// failing keyword; the collecting variant runs them all and reports each,
+// 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) {
+  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);
+    const holder = fn.source || fn;
+    if (holder.errors) holder.errors = null;
+    if (!ok) return false;
+  }
+  return true;
+}
+
+function runCustom(P, data, bits, errors, instancePath, schemaPath) {
+  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;
+    const fn = op.fn;
+    const ok = fn(data);
+    const holder = fn.source || fn;
+    const own = holder.errors;
+    if (own) holder.errors = null;
+    if (ok) continue;
+    valid = false;
+    if (errors === NOERRORS) return false;
+    const kwPath = schemaPath + '/' + op.keyword;
+    if (Array.isArray(own) && own.length > 0) {
+      for (let j = 0; j < own.length; j++) {
+        const e = own[j];
+        errors.push(err(op.keyword, e.keyword || op.keyword,
+          e.instancePath !== undefined ? 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`));
+      }
+    } else {
+      errors.push(err(op.keyword, op.keyword, instancePath, kwPath, { keyword: op.keyword }, `must pass "${op.keyword}" keyword validation`));
+    }
+  }
+  return valid;
+}
+
+// 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(', ')}`));
+    valid = false;
+  }
+  if (P.enum !== null) {
+    if (!enumMember(P, data)) {
+      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 && Number.isFinite(data)) {
+    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) {
+      const pair = duplicatePair(data);
+      if (pair !== null) {
+        const i = pair[0], j = pair[1];
+        if (errors !== NOERRORS) errors.push(err('uniqueItems', 'uniqueItems', instancePath, schemaPath + '/uniqueItems', { i, j }, `must NOT have duplicate items (items ## ${j} and ${i} are identical)`));
+        valid = false;
+      }
+    }
+  }
+  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; }
+          }
+        }
+      }
+    }
+  }
+  if (P.hasCustom && !runCustom(P, data, bits, errors, instancePath, schemaPath)) valid = false;
+  return valid;
+}
+
+class Interpreter {
+  constructor(rootSchema, options) {
+    const opts = options || {};
+    this.root = rootSchema;
+    this.state = indexSchemas(rootSchema, opts.schemaMap, opts.flat === true);
+    this.userFormats = opts.formats || null;
+    // Custom keywords, already normalized by lib/keywords.js.
+    this.keywords = opts.keywords || null;
+    // 2020-12 requires bookending for `$dynamicRef`; v1 removes the
+    // 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;
+    this._calls = 0;
+    this._tier = typeof opts.tier === 'number' ? opts.tier : TIER;
+  }
+
+  // The closure-tree compiler covers every schema the interpreter accepts;
+  // eval() stays as the reference the compiled tree is diffed against.
+  // Compiled lazily so construction stays cheap for schemas that never
+  // validate.
+  _fastRoot() {
+    if (this._fast === undefined) {
+      const compile = planCompiler();
+      if (compile === null) this._fast = null;
+      else try { this._fast = compile(this); } catch { this._fast = null; }
+    }
+    return this._fast;
+  }
+  // The closure tree once the schema has been used TIER times, the plain walk
+  // before that (null).
+  _tiered() {
+    if (this._fast !== undefined) return this._fast;
+    return ++this._calls > this._tier ? this._fastRoot() : null;
+  }
+  // The plain walk takes more stack per level of data than the closure tree,
+  // which answered every call before calls were tiered: data deep enough to
+  // overflow it goes to the closure tree, compiled now, and answers as it did.
+  // Without a plan compiler (the shared error runtime) the overflow is
+  // rethrown for the caller to handle.
+  _deep(e) {
+    if (!(e instanceof RangeError) || this._fast !== undefined) throw e;
+    const fast = this._fastRoot();
+    if (fast === null) throw e;
+    return fast;
+  }
+
+  pattern(src) {
+    let re = this.patternCache.get(src);
+    if (!re) {
+      if (/\\[pP]\{/.test(src)) {
+        // Unicode property escapes need a real RegExp in unicode mode; the
+        // linear engine does not understand them.
+        try { re = new RegExp(src, 'u'); } catch { re = new RegExp(src); }
+      } else {
+        try {
+          re = compileSafe(src);
+        } catch {
+          try { re = new RegExp(src, 'u'); } catch { re = new RegExp(src); }
+        }
+      }
+      this.patternCache.set(src, re);
+    }
+    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._fast !== undefined ? this._fast : this._tiered();
+    if (fast !== null) return fast.v(data, fast.cyclic ? [] : null);
+    const dynScope = [this.state.rootBase];
+    try {
+      return this.eval(this.rootNode, data, this.state.rootBase, dynScope, NOERRORS, '', '#', [], DISCARD);
+    } catch (e) {
+      const deep = this._deep(e);
+      return deep.v(data, deep.cyclic ? [] : null);
+    }
+  }
+
+  validate(data) {
+    const fast = this._fast !== undefined ? this._fast : this._tiered();
+    if (fast !== null) {
+      const errors = [];
+      const valid = fast.c(data, errors, '', '#', fast.cyclic ? [] : null);
+      return valid ? { valid: true, data, errors: [] } : { valid: false, errors };
+    }
+    let errors = [];
+    const dynScope = [this.state.rootBase];
+    let valid;
+    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) {
+      const deep = this._deep(e);
+      errors = [];
+      valid = deep.c(data, errors, '', '#', deep.cyclic ? [] : null);
+    }
+    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(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;
+    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);
+    const schema = P.schema;
+
+    // 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);
+    }
+
+    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;
+    // 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 (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 = collect ? { props: null, items: null } : DISCARD;
+        if (!this.eval(child, data, refBase, dynScope, errors, instancePath, schemaPath, stack, sub)) valid = false;
+        else if (collect) mergeAnnotations(local, sub);
+      }
+    }
+
+    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
+        // requirement, so the scope is searched whether or not the initial
+        // target carries the anchor, and also when the reference does not
+        // resolve on its own, which is the shape the suite uses: a
+        // `$dynamicRef` in a resource that declares no anchor of that name.
+        const initialDyn = this.state.dynamicAnchors.get(refBase);
+        const bookended = node !== undefined && initialDyn && initialDyn.get(fragment) === node;
+        if (bookended || !this.bookending) {
+          // Outermost scope first: the first matching $dynamicAnchor
+          // encountered while evaluating wins.
+          for (const scopeBase of dynScope) {
+            const dyn = this.state.dynamicAnchors.get(scopeBase);
+            if (dyn && dyn.has(fragment)) {
+              node = dyn.get(fragment);
+              refBase = scopeBase;
+              break;
+            }
+          }
+        }
+      }
+      if (node === undefined) {
+        if (errors !== NOERRORS) errors.push(err('$dynamicRef', '$dynamicRef', instancePath, schemaPath + '/$dynamicRef', { ref }, `cannot resolve $dynamicRef ${ref}`));
+        valid = false;
+      } else {
+        const sub = collect ? { props: null, items: null } : DISCARD;
+        if (!this.eval(this.node(node), data, refBase, dynScope, errors, instancePath, schemaPath, stack, sub)) valid = false;
+        else if (collect) mergeAnnotations(local, sub);
+      }
+    }
+
+    const bits = dataBits(data);
+
+    // type / enum / const
+    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(', ')}`));
+      valid = false;
+    }
+    if (P.enum !== null) {
+      if (!enumMember(P, data)) {
+        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;
+    }
+
+    // numbers
+    if (P.hasNumber && Number.isFinite(data)) {
+      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 (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; }
+    }
+
+    // Custom keywords, where the plan compiler runs them: with the other
+    // value-level checks (evalLeaf), before any subschema. Only evalLeaf ran
+    // 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;
+
+    // arrays
+    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) {
+        const pair = duplicatePair(data);
+        if (pair !== null) {
+          const i = pair[0], j = pair[1];
+          if (errors !== NOERRORS) errors.push(err('uniqueItems', 'uniqueItems', instancePath, schemaPath + '/uniqueItems', { i, j }, `must NOT have duplicate items (items ## ${j} and ${i} are identical)`));
+          valid = false;
+        }
+      }
+      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, E ? instancePath + '/' + i : '', E ? schemaPath + '/prefixItems/' + i : '', stack, DISCARD)) valid = false;
+          if (collect) { if (!local.items) local.items = new Set(); local.items.add(i); }
+        }
+      }
+      if (P.items !== undefined) {
+        const start = prefix !== null ? prefix.length : 0;
+        for (let i = start; i < data.length; i++) {
+          if (!this.eval(P.items, data[i], base, dynScope, errors, E ? instancePath + '/' + i : '', E ? schemaPath + '/items' : '', stack, DISCARD)) valid = false;
+          if (collect) { if (!local.items) local.items = new Set(); local.items.add(i); }
+        }
+      }
+      if (P.contains !== undefined) {
+        const matched = [];
+        for (let i = 0; i < data.length; i++) {
+          const scratch = errors === NOERRORS ? NOERRORS : [];
+          if (this.eval(P.contains, data[i], base, dynScope, scratch, E ? instancePath + '/' + i : '', E ? schemaPath + '/contains' : '', stack, DISCARD)) matched.push(i);
+        }
+        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('contains', 'contains', instancePath, schemaPath + '/contains', { minContains: minC, maxContains: 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);
+        }
+      }
+    }
+
+    // objects
+    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; }
+            }
+          }
+        }
+      }
+      if (P.propertyNames !== undefined) {
+        for (const key of keys) {
+          if (!this.eval(P.propertyNames, key, base, dynScope, errors, instancePath, E ? schemaPath + '/propertyNames' : '', stack, DISCARD)) valid = false;
+        }
+      }
+      const props = P.properties;
+      const patterns = P.patternProperties;
+      for (let k = 0; k < keys.length; k++) {
+        const key = keys[k];
+        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;
+          evaluated = true;
+        }
+        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, E ? instancePath + '/' + escapePointer(key) : '', E ? schemaPath + '/patternProperties/' + escapePointer(pp.src) : '', stack, DISCARD)) valid = false;
+              evaluated = true;
+            }
+          }
+        }
+        if (!evaluated && P.additionalProperties !== undefined) {
+          // `additionalProperties: false` keeps its own keyword and names the
+          // property it turned away. Running it as a plain false subschema
+          // reported `not` at the key's path, which drops both.
+          if (P.additionalProperties === false) {
+            valid = false;
+            if (errors !== NOERRORS) errors.push(err('additionalProperties', 'additionalProperties', instancePath, schemaPath + '/additionalProperties', { additionalProperty: key }, 'must NOT have additional properties'));
+          } else if (!this.eval(P.additionalProperties, data[key], base, dynScope, errors, E ? instancePath + '/' + escapePointer(key) : '', E ? schemaPath + '/additionalProperties' : '', stack, DISCARD)) valid = false;
+          evaluated = true;
+        }
+        if (evaluated && collect) {
+          if (!local.props) local.props = new Set();
+          local.props.add(key);
+        }
+      }
+      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, E ? schemaPath + '/dependentSchemas/' + escapePointer(key) : '', stack, sub)) valid = false;
+            else if (collect) mergeAnnotations(local, sub);
+          }
+        }
+      }
+      // propertyDependencies: like dependentSchemas but keyed on the property's
+      // 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 (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;
+          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(choice, data, base, dynScope, errors, instancePath, branchPath, stack, sub)) valid = false;
+          else if (collect) mergeAnnotations(local, sub);
+        }
+      }
+    }
+
+    // in-place applicators
+    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, E ? schemaPath + '/allOf/' + i : '', stack, sub)) valid = false;
+          else if (collect) mergeAnnotations(local, sub);
+        }
+      }
+      if (P.macros !== null) {
+        for (let i = 0; i < P.macros.length; i++) {
+          const m = P.macros[i];
+          const sp = schemaPath + '/' + m.keyword;
+          const sub = collect ? { props: null, items: null } : DISCARD;
+          if (!this.eval(m.node, data, base, dynScope, errors, instancePath, sp, stack, sub)) {
+            valid = false;
+            if (errors !== NOERRORS) errors.push(err(m.keyword, m.keyword, instancePath, sp, { keyword: m.keyword }, `must pass "${m.keyword}" keyword validation`));
+          } else if (collect) mergeAnnotations(local, sub);
+        }
+      }
+      if (P.anyOf !== null) {
+        let any = false;
+        const scratch = errors === NOERRORS ? NOERRORS : [];
+        // Per-branch errors, taken as a slice of the shared scratch rather than
+        // an array each, so a branch that passes costs nothing extra.
+        const branches = errors === NOERRORS ? null : [];
+        for (let i = 0; i < P.anyOf.length; i++) {
+          const sub = collect ? { props: null, items: null } : DISCARD;
+          const mark = branches === null ? 0 : scratch.length;
+          const ok = this.eval(P.anyOf[i], data, base, dynScope, scratch, instancePath, E ? schemaPath + '/anyOf/' + i : '', stack, sub);
+          if (branches !== null) branches.push({ valid: ok, errors: scratch.slice(mark), title: branchTitle(P.anyOf[i]) });
+          if (ok) {
+            any = true;
+            if (collect) mergeAnnotations(local, sub);
+          }
+        }
+        if (!any) {
+          if (branches !== null) {
+            const collapsed = collapseBranches({ keyword: 'anyOf', branchResults: branches, parentPath: instancePath, parentSchemaPath: schemaPath + '/anyOf' });
+            if (collapsed !== null) errors.push(collapsed);
+          }
+          valid = false;
+        }
+      }
+      if (P.oneOf !== null) {
+        let count = 0;
+        let winner = null;
+        const scratch = errors === NOERRORS ? NOERRORS : [];
+        // Per-branch results, so a failing oneOf collapses to the branch that
+        // came closest instead of every branch's complaints at once.
+        const branches = errors === NOERRORS ? null : [];
+        for (let i = 0; i < P.oneOf.length; i++) {
+          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 (branches !== null) branches.push({ valid: ok, errors: scratch.slice(mark), title: branchTitle(P.oneOf[i]) });
+          if (ok) {
+            count++;
+            winner = sub;
+          }
+        }
+        if (count === 1) { if (collect) mergeAnnotations(local, winner); }
+        else {
+          if (branches !== null) {
+            const collapsed = collapseBranches({ keyword: 'oneOf', branchResults: branches, parentPath: instancePath, parentSchemaPath: schemaPath + '/oneOf' });
+            if (collapsed !== null) errors.push(collapsed);
+          }
+          valid = false;
+        }
+      }
+      if (P.not !== undefined) {
+        const scratch = errors === NOERRORS ? NOERRORS : [];
+        if (this.eval(P.not, data, base, dynScope, scratch, instancePath, E ? schemaPath + '/not' : '', stack, DISCARD)) {
+          if (errors !== NOERRORS) errors.push(err('not', 'not', instancePath, schemaPath + '/not', {}, 'must NOT be valid'));
+          valid = false;
+        }
+      }
+      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 (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, E ? 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, E ? schemaPath + '/else' : '', stack, sub)) valid = false;
+          else if (collect) mergeAnnotations(local, sub);
+        }
+      }
+    }
+
+    // unevaluated*: run last, against annotations from everything above
+    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 (P.unevaluatedPropertiesFalse) {
+            // The name is what is wrong, so the error names it and sits on the
+            // object holding it. Descending instead reported a false boolean
+            // schema at the member's own path, which says nothing about which
+            // key was unexpected and left `params` empty.
+            valid = false;
+            if (errors !== NOERRORS) errors.push(err('unevaluatedProperties', 'unevaluatedProperties', instancePath, schemaPath + '/unevaluatedProperties', { unevaluatedProperty: key }, 'must NOT have unevaluated properties'));
+          } else if (!this.eval(P.unevaluatedProperties, data[key], base, dynScope, errors, E ? instancePath + '/' + escapePointer(key) : '', E ? schemaPath + '/unevaluatedProperties' : '', stack, DISCARD)) valid = false;
+          if (!local.props) local.props = new Set();
+          local.props.add(key);
+        }
+      }
+      if (P.unevaluatedItems !== undefined && bits === T_ARRAY) {
+        for (let i = 0; i < data.length; i++) {
+          if (local.items && local.items.has(i)) continue;
+          if (P.unevaluatedItemsFalse) {
+            // One error for the array, not one per trailing element: what the
+            // array got wrong is its length past the last evaluated position.
+            valid = false;
+            if (errors !== NOERRORS) errors.push(err('unevaluatedItems', 'unevaluatedItems', instancePath, schemaPath + '/unevaluatedItems', { limit: i }, 'must NOT have more than ' + i + ' items'));
+            break;
+          }
+          if (!this.eval(P.unevaluatedItems, data[i], base, dynScope, errors, E ? instancePath + '/' + i : '', E ? schemaPath + '/unevaluatedItems' : '', stack, DISCARD)) valid = false;
+          if (!local.items) local.items = new Set();
+          local.items.add(i);
+        }
+      }
+    }
+
+    if (scopePushed) dynScope.pop();
+    if (tracked) stack.length -= 2;
+    if (valid && collect && sink !== DISCARD) mergeAnnotations(sink, local);
+    return valid;
+  }
+}
+
+// One branch title, for the collapsed anyOf/oneOf error. The compiled node
+// keeps the schema it came from, which is where a `title` lives.
+function branchTitle (node) {
+  return node && node.schema && typeof node.schema.title === 'string' ? node.schema.title : '';
+}
+
+function escapePointer(s) {
+  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 };
+}
+
+// The plan compiler (closure trees for the verdict and for errors) is wired in
+// by lib/interpreter.js. This file works without it, walking the plans
+// directly with the same answers, so the error runtime compiled modules share
+// (lib/error-runtime-entry.js) can carry the interpreter without it.
+//
+// It is loaded and run only for a schema that has been used often (TIER
+// calls): building the closure tree for a whole schema costs about as much as
+// a few thousand plain walks, measured on SchemaStore schemas, so a page or a
+// short-lived worker that checks a handful of documents never pays for it, or
+// for parsing its source.
+const TIER = 1000;
+let loadPlanCompiler = null;
+let compileInterpreter = null;
+function setPlanCompiler(load) {
+  loadPlanCompiler = load;
+  compileInterpreter = null;
+}
+function planCompiler() {
+  if (compileInterpreter === null && loadPlanCompiler !== null) {
+    compileInterpreter = loadPlanCompiler()({
+      Plan, NOERRORS, err, evalLeaf, evalLeafV, runCustomV, dataBits, escapePointer,
+      deepEqual, enumMember, allDistinct, multipleOfOk, cpAtLeast, cpAtMost,
+      T_STRING, T_ARRAY, T_OBJECT, resolveRef, splitFragment, resolveUri,
+    }).compileInterpreter;
+  }
+  return compileInterpreter;
+}
+
+function createInterpreter(schema, options) {
+  return new Interpreter(schema, options);
+}
+
+module.exports = { createInterpreter };
+Object.defineProperty(module.exports, '_setPlanCompiler', { value: setPlanCompiler, enumerable: false });
+// The resolver, for the code generator: it resolves references at compile
+// time the way this engine does at run time (normalizeRefs in js-compiler).
+Object.defineProperty(module.exports, '_refInternals', {
+  value: { indexSchemas, resolveRef, splitFragment, resolveUri, FALLBACK_BASE },
+  enumerable: false,
+});
+// For lib/plan-source.js, which emits source from the same plans and must call
+// the same helpers so the two cannot answer differently.
+Object.defineProperty(module.exports, '_planInternals', {
+  value: { Plan, deepEqual, cpAtLeast, cpAtMost, multipleOfOk, dataBits, typeBit, T_STRING, T_NUMBER, T_INTEGER, T_BOOLEAN, T_NULL, T_OBJECT, T_ARRAY, T_ANY },
+  enumerable: false,
+});