ata-validator 1.7.0 → 1.7.2

package/lib/interpreter.js

@@ -205,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';
@@ -256,6 +270,11 @@ const FORMAT_CHECKS = {
 // 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();
@@ -331,6 +350,8 @@ class Plan {
     // 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;
@@ -425,7 +446,148 @@ class Plan {
     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 {
@@ -441,6 +603,19 @@ class Interpreter {
     // 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 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) {
+      try { this._fast = compileInterpreter(this); } catch { this._fast = null; }
+    }
+    return this._fast;
   }
 
   pattern(src) {
@@ -473,14 +648,19 @@ class Interpreter {
   }
 
   // $ref resolution depends on the base URI in effect, which can differ
-  // between visits of the same node; cache per (plan, base).
+  // 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;
-    if (cache === null) cache = P.refCache = new Map();
-    let r = cache.get(base);
+    let r = cache !== null ? cache.get(base) : undefined;
     if (r === undefined) {
-      r = resolveRef(P.ref, base, this.state);
-      cache.set(base, r);
+      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;
   }
@@ -508,7 +688,21 @@ class Interpreter {
     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, fast.cyclic ? [] : null);
+    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, '', '#', fast.cyclic ? [] : null);
+      return valid ? { valid: true, data, errors: [] } : { valid: false, errors };
+    }
     const errors = [];
     const dynScope = [this.state.rootBase];
     // Nothing reads the root's annotations, so they are discarded from the start.
@@ -522,9 +716,10 @@ class Interpreter {
   eval(P, data, base, dynScope, errors, instancePath, schemaPath, stack, sink) {
     if (P === true) return true;
     if (P === false) {
-      errors.push(err('false schema', 'not', instancePath, schemaPath, {}, 'boolean schema is 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
@@ -542,9 +737,13 @@ class Interpreter {
     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`.
+    // 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 = dynScope.concat(base);
+      dynScope.push(base);
+      scopePushed = true;
     }
 
     let valid = true;
@@ -556,13 +755,13 @@ class Interpreter {
 
     // $ref / $dynamicRef: in-place applicators, annotations flow through
     if (P.ref !== null) {
-      const { node, base: refBase } = this.resolveRefCached(P, base);
-      if (node === undefined) {
-        errors.push(err('$ref', '$ref', instancePath, schemaPath + '/$ref', { ref: P.ref }, `cannot resolve $ref ${P.ref}`));
+      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(this.node(node), data, refBase, dynScope, errors, instancePath, schemaPath + '/$ref', stack, sub)) valid = false;
+        if (!this.eval(child, data, refBase, dynScope, errors, instancePath, schemaPath + '/$ref', stack, sub)) valid = false;
         else if (collect) mergeAnnotations(local, sub);
       }
     }
@@ -597,7 +796,7 @@ 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 = collect ? { props: null, items: null } : DISCARD;
@@ -610,48 +809,48 @@ class Interpreter {
 
     // type / enum / const
     if (P.hasType && (bits & P.typeMask) === 0) {
-      errors.push(err('type', 'type', instancePath, schemaPath + '/type', { type: schema.type }, `must be ${P.typeNames.join(' or ')}`));
+      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) {
-        errors.push(err('enum', 'enum', instancePath, schemaPath + '/enum', { allowedValues: P.enum }, 'must be equal to one of the allowed values'));
+        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)) {
-      errors.push(err('const', 'const', instancePath, schemaPath + '/const', { allowedValue: P.const }, 'must be equal to constant'));
+      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 && typeof data === 'number') {
-      if (P.minimum !== undefined && !(data >= P.minimum)) { 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.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.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.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.push(err('multipleOf', 'multipleOf', instancePath, schemaPath + '/multipleOf', { multipleOf: P.multipleOf }, `must be multiple of ${P.multipleOf}`)); valid = false; }
+      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 && codePointLength(data) < P.minLength) { 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 && codePointLength(data) > P.maxLength) { 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.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.push(err('format', 'format', instancePath, schemaPath + '/format', { format: P.format }, `must match format "${P.format}"`)); valid = false; }
+      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 (P.hasArray && bits === T_ARRAY) {
-      if (P.minItems !== undefined && data.length < P.minItems) { 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.push(err('maxItems', 'maxItems', instancePath, schemaPath + '/maxItems', { limit: P.maxItems }, `must NOT have more than ${P.maxItems} items`)); valid = false; }
+      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;
             }
@@ -676,12 +875,12 @@ class Interpreter {
       if (P.contains !== undefined) {
         const matched = [];
         for (let i = 0; i < data.length; i++) {
-          const scratch = [];
+          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 = P.minContains !== undefined ? P.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 (P.maxContains !== undefined && matched.length > P.maxContains) { errors.push(err('maxContains', 'maxContains', instancePath, schemaPath + '/maxContains', { limit: P.maxContains }, `must NOT contain more than ${P.maxContains} valid item(s)`)); valid = false; }
+        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);
@@ -696,16 +895,16 @@ class Interpreter {
         const req = P.required;
         for (let i = 0; i < req.length; i++) {
           const key = req[i];
-          if (!Object.hasOwn(data, key)) { errors.push(err('required', 'required', instancePath, schemaPath + '/required', { missingProperty: key }, `must have required property '${key}'`)); valid = false; }
+          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.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.push(err('maxProperties', 'maxProperties', instancePath, schemaPath + '/maxProperties', { limit: P.maxProperties }, `must NOT have more than ${P.maxProperties} properties`)); 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.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; }
             }
           }
         }
@@ -782,7 +981,7 @@ class Interpreter {
       }
       if (P.anyOf !== null) {
         let any = false;
-        const scratch = [];
+        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)) {
@@ -791,15 +990,15 @@ class Interpreter {
           }
         }
         if (!any) {
-          for (const e of scratch) errors.push(e);
-          errors.push(err('anyOf', 'anyOf', instancePath, schemaPath + '/anyOf', {}, 'must match a schema in anyOf'));
+          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 (P.oneOf !== null) {
         let count = 0;
         let winner = null;
-        const scratch = [];
+        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)) {
@@ -810,20 +1009,20 @@ class Interpreter {
         if (count === 1) { if (collect) 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'));
+          if (errors !== NOERRORS) errors.push(err('oneOf', 'oneOf', instancePath, schemaPath + '/oneOf', { passingSchemas: count }, 'must match exactly one schema in oneOf'));
           valid = false;
         }
       }
       if (P.not !== undefined) {
-        const scratch = [];
+        const scratch = errors === NOERRORS ? NOERRORS : [];
         if (this.eval(P.not, data, base, dynScope, scratch, instancePath, schemaPath + '/not', stack, DISCARD)) {
-          errors.push(err('not', 'not', instancePath, schemaPath + '/not', {}, 'must NOT be valid'));
+          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 = [];
+        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);
@@ -860,6 +1059,7 @@ class Interpreter {
       }
     }
 
+    if (scopePushed) dynScope.pop();
     if (tracked) stack.length -= 2;
     if (valid && collect && sink !== DISCARD) mergeAnnotations(sink, local);
     return valid;
@@ -880,6 +1080,12 @@ 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, dataBits, escapePointer,
+  deepEqual, multipleOfOk, cpAtLeast, cpAtMost,
+  T_STRING, T_ARRAY, T_OBJECT, resolveRef, splitFragment, resolveUri,
+});
+
 function createInterpreter(schema, options) {
   return new Interpreter(schema, options);
 }