z-schema 12.1.1 → 12.3.1

package/src/json-validation.ts

@@ -1,4 +1,5 @@
 import type { JsonSchemaAll, JsonSchemaInternal } from './json-schema-versions.js';
+import type { JsonValidatorFn } from './validation/shared.js';
 import type { ZSchemaBase } from './z-schema-base.js';
 
 import { getId } from './json-schema.js';
@@ -48,7 +49,6 @@ import { resolveDynamicRef, resolveRecursiveRef } from './validation/ref.js';
 import {
   getCachedValidationResult,
   isValidationVocabularyEnabled,
-  type JsonValidatorFn,
   VALIDATION_VOCAB_KEYWORDS,
 } from './validation/shared.js';
 import {
@@ -65,34 +65,34 @@ import { constValidator, enumValidator, typeValidator } from './validation/type.
 // collectEvaluated — unified traversal for unevaluatedItems / unevaluatedProperties
 // ---------------------------------------------------------------------------
 
-type CollectEvaluatedItemsArgs = {
+interface CollectEvaluatedItemsArgs {
   report: Report;
   currentSchema: JsonSchemaInternal | boolean | undefined;
   json: unknown;
   mode: 'items';
   jsonArr: unknown[];
   depth: number;
-};
+}
 
-type CollectEvaluatedPropertiesArgs = {
+interface CollectEvaluatedPropertiesArgs {
   report: Report;
   currentSchema: JsonSchemaInternal | boolean | undefined;
   json: unknown;
   mode: 'properties';
   jsonData: Record<string, unknown>;
   depth: number;
-};
+}
 
 type CollectEvaluatedArgs = CollectEvaluatedItemsArgs | CollectEvaluatedPropertiesArgs;
 
-function collectEvaluated(this: ZSchemaBase, args: CollectEvaluatedArgs): Set<number | string> | 'all' {
+function collectEvaluated(ctx: ZSchemaBase, args: CollectEvaluatedArgs): Set<number | string> | 'all' {
   const { report, currentSchema, json, mode, depth } = args;
 
   if (!currentSchema || typeof currentSchema === 'boolean') {
     return new Set();
   }
 
-  if (depth > (this.options.maxRecursionDepth ?? 100)) {
+  if (depth > (ctx.options.maxRecursionDepth ?? 100)) {
     report.addError('COLLECT_EVALUATED_DEPTH_EXCEEDED', [depth]);
     return new Set();
   }
@@ -100,7 +100,9 @@ function collectEvaluated(this: ZSchemaBase, args: CollectEvaluatedArgs): Set<nu
   const evaluated = new Set<number | string>();
 
   const merge = (other: Set<number | string> | 'all') => {
-    if (other === 'all') return true;
+    if (other === 'all') {
+      return true;
+    }
     for (const v of other) {
       evaluated.add(v);
     }
@@ -109,28 +111,28 @@ function collectEvaluated(this: ZSchemaBase, args: CollectEvaluatedArgs): Set<nu
 
   const recurse = (subSchema: JsonSchemaInternal | boolean | undefined): Set<number | string> | 'all' => {
     if (mode === 'items') {
-      return collectEvaluated.call(this, {
+      return collectEvaluated(ctx, {
         report,
         currentSchema: subSchema,
         json,
         mode: 'items',
-        jsonArr: (args as CollectEvaluatedItemsArgs).jsonArr,
+        jsonArr: args.jsonArr,
         depth: depth + 1,
       });
     }
-    return collectEvaluated.call(this, {
+    return collectEvaluated(ctx, {
       report,
       currentSchema: subSchema,
       json,
       mode: 'properties',
-      jsonData: (args as CollectEvaluatedPropertiesArgs).jsonData,
+      jsonData: args.jsonData,
       depth: depth + 1,
     });
   };
 
   // --- Mode-specific leaf collection ---
   if (mode === 'items') {
-    const jsonArr = (args as CollectEvaluatedItemsArgs).jsonArr;
+    const { jsonArr } = args;
 
     // prefixItems (2020-12 tuple)
     if (Array.isArray(currentSchema.prefixItems)) {
@@ -167,7 +169,7 @@ function collectEvaluated(this: ZSchemaBase, args: CollectEvaluatedArgs): Set<nu
         let passed = getCachedValidationResult(report, currentSchema.contains, jsonArr[i]);
         if (passed === undefined) {
           const subReport = new Report(report);
-          validate.call(this, subReport, currentSchema.contains as JsonSchemaInternal | boolean, jsonArr[i]);
+          validate(ctx, subReport, currentSchema.contains as JsonSchemaInternal | boolean, jsonArr[i]);
           passed = subReport.errors.length === 0;
         }
         if (passed) {
@@ -182,11 +184,13 @@ function collectEvaluated(this: ZSchemaBase, args: CollectEvaluatedArgs): Set<nu
     }
   } else {
     // mode === 'properties'
-    const jsonData = (args as CollectEvaluatedPropertiesArgs).jsonData;
+    const { jsonData } = args;
 
     // properties
     if (isObject(currentSchema.properties)) {
-      for (const key of Object.keys(currentSchema.properties)) {
+      const propKeysCE = Object.keys(currentSchema.properties);
+      for (let i = 0; i < propKeysCE.length; i++) {
+        const key = propKeysCE[i];
         if (Object.hasOwn(jsonData, key)) {
           evaluated.add(key);
         }
@@ -198,9 +202,10 @@ function collectEvaluated(this: ZSchemaBase, args: CollectEvaluatedArgs): Set<nu
       for (const pattern of Object.keys(currentSchema.patternProperties)) {
         const result = compileSchemaRegex(pattern);
         if (result.ok) {
-          for (const key of Object.keys(jsonData)) {
-            if (result.value.test(key)) {
-              evaluated.add(key);
+          const jdKeys = Object.keys(jsonData);
+          for (let i = 0; i < jdKeys.length; i++) {
+            if (result.value.test(jdKeys[i])) {
+              evaluated.add(jdKeys[i]);
             }
           }
         }
@@ -209,7 +214,7 @@ function collectEvaluated(this: ZSchemaBase, args: CollectEvaluatedArgs): Set<nu
 
     // additionalProperties - evaluates all non-properties/non-patternProperties keys
     if (currentSchema.additionalProperties !== undefined) {
-      const propKeys = isObject(currentSchema.properties) ? Object.keys(currentSchema.properties) : [];
+      const propKeySet = new Set(isObject(currentSchema.properties) ? Object.keys(currentSchema.properties) : []);
       const patternRegexes: RegExp[] = [];
       if (isObject(currentSchema.patternProperties)) {
         for (const pattern of Object.keys(currentSchema.patternProperties)) {
@@ -219,9 +224,22 @@ function collectEvaluated(this: ZSchemaBase, args: CollectEvaluatedArgs): Set<nu
           }
         }
       }
-      for (const key of Object.keys(jsonData)) {
-        if (propKeys.includes(key)) continue;
-        if (patternRegexes.some((re) => re.test(key))) continue;
+      const apKeys = Object.keys(jsonData);
+      for (let i = 0; i < apKeys.length; i++) {
+        const key = apKeys[i];
+        if (propKeySet.has(key)) {
+          continue;
+        }
+        let matchedPattern = false;
+        for (let pi = 0; pi < patternRegexes.length; pi++) {
+          if (patternRegexes[pi].test(key)) {
+            matchedPattern = true;
+            break;
+          }
+        }
+        if (matchedPattern) {
+          continue;
+        }
         evaluated.add(key);
       }
     }
@@ -229,10 +247,8 @@ function collectEvaluated(this: ZSchemaBase, args: CollectEvaluatedArgs): Set<nu
     // dependentSchemas - only applies when the dependency key is present in the data
     if (isObject(currentSchema.dependentSchemas)) {
       for (const [depKey, depSchema] of Object.entries(currentSchema.dependentSchemas as Record<string, unknown>)) {
-        if (Object.hasOwn(jsonData, depKey)) {
-          if (merge(recurse(depSchema as JsonSchemaInternal | boolean))) {
-            return 'all';
-          }
+        if (Object.hasOwn(jsonData, depKey) && merge(recurse(depSchema as JsonSchemaInternal | boolean))) {
+          return 'all';
         }
       }
     }
@@ -247,8 +263,8 @@ function collectEvaluated(this: ZSchemaBase, args: CollectEvaluatedArgs): Set<nu
 
   // allOf
   if (Array.isArray(currentSchema.allOf)) {
-    for (const subSchema of currentSchema.allOf) {
-      if (merge(recurse(subSchema as JsonSchemaInternal | boolean))) {
+    for (let i = 0; i < currentSchema.allOf.length; i++) {
+      if (merge(recurse(currentSchema.allOf[i] as JsonSchemaInternal | boolean))) {
         return 'all';
       }
     }
@@ -256,34 +272,32 @@ function collectEvaluated(this: ZSchemaBase, args: CollectEvaluatedArgs): Set<nu
 
   // anyOf - only matching branches contribute
   if (Array.isArray(currentSchema.anyOf)) {
-    for (const subSchema of currentSchema.anyOf) {
+    for (let i = 0; i < currentSchema.anyOf.length; i++) {
+      const subSchema = currentSchema.anyOf[i];
       let passed = getCachedValidationResult(report, subSchema, json);
       if (passed === undefined) {
         const subReport = new Report(report);
-        validate.call(this, subReport, subSchema as JsonSchemaInternal | boolean, json);
+        validate(ctx, subReport, subSchema as JsonSchemaInternal | boolean, json);
         passed = subReport.errors.length === 0;
       }
-      if (passed) {
-        if (merge(recurse(subSchema as JsonSchemaInternal | boolean))) {
-          return 'all';
-        }
+      if (passed && merge(recurse(subSchema as JsonSchemaInternal | boolean))) {
+        return 'all';
       }
     }
   }
 
   // oneOf - only matching branches contribute
   if (Array.isArray(currentSchema.oneOf)) {
-    for (const subSchema of currentSchema.oneOf) {
+    for (let i = 0; i < currentSchema.oneOf.length; i++) {
+      const subSchema = currentSchema.oneOf[i];
       let passed = getCachedValidationResult(report, subSchema, json);
       if (passed === undefined) {
         const subReport = new Report(report);
-        validate.call(this, subReport, subSchema as JsonSchemaInternal | boolean, json);
+        validate(ctx, subReport, subSchema as JsonSchemaInternal | boolean, json);
         passed = subReport.errors.length === 0;
       }
-      if (passed) {
-        if (merge(recurse(subSchema as JsonSchemaInternal | boolean))) {
-          return 'all';
-        }
+      if (passed && merge(recurse(subSchema as JsonSchemaInternal | boolean))) {
+        return 'all';
       }
     }
   }
@@ -293,48 +307,40 @@ function collectEvaluated(this: ZSchemaBase, args: CollectEvaluatedArgs): Set<nu
     let condPassed = getCachedValidationResult(report, currentSchema.if, json);
     if (condPassed === undefined) {
       const condReport = new Report(report);
-      validate.call(this, condReport, currentSchema.if as JsonSchemaInternal | boolean, json);
+      validate(ctx, condReport, currentSchema.if, json);
       condPassed = condReport.errors.length === 0;
     }
     if (condPassed) {
-      if (merge(recurse(currentSchema.if as JsonSchemaInternal | boolean))) {
+      if (merge(recurse(currentSchema.if))) {
         return 'all';
       }
-      if (currentSchema.then !== undefined) {
-        if (merge(recurse(currentSchema.then as JsonSchemaInternal | boolean))) {
-          return 'all';
-        }
-      }
-    } else {
-      if (currentSchema.else !== undefined) {
-        if (merge(recurse(currentSchema.else as JsonSchemaInternal | boolean))) {
-          return 'all';
-        }
+      if (currentSchema.then !== undefined && merge(recurse(currentSchema.then))) {
+        return 'all';
       }
+    } else if (currentSchema.else !== undefined && merge(recurse(currentSchema.else))) {
+      return 'all';
     }
   }
 
   // $ref resolved
-  if (currentSchema.__$refResolved && currentSchema.__$refResolved !== currentSchema) {
-    if (merge(recurse(currentSchema.__$refResolved as JsonSchemaInternal))) {
-      return 'all';
-    }
+  if (
+    currentSchema.__$refResolved &&
+    currentSchema.__$refResolved !== currentSchema &&
+    merge(recurse(currentSchema.__$refResolved))
+  ) {
+    return 'all';
   }
 
   // $recursiveRef
   const recursiveTarget = resolveRecursiveRef(currentSchema, report.__$recursiveAnchorStack);
-  if (recursiveTarget && recursiveTarget !== currentSchema) {
-    if (merge(recurse(recursiveTarget))) {
-      return 'all';
-    }
+  if (recursiveTarget && recursiveTarget !== currentSchema && merge(recurse(recursiveTarget))) {
+    return 'all';
   }
 
   // $dynamicRef
   const dynamicTarget = resolveDynamicRef(currentSchema, report.__$dynamicScopeStack);
-  if (dynamicTarget && dynamicTarget !== currentSchema) {
-    if (merge(recurse(dynamicTarget as JsonSchemaInternal))) {
-      return 'all';
-    }
+  if (dynamicTarget && dynamicTarget !== currentSchema && merge(recurse(dynamicTarget as JsonSchemaInternal))) {
+    return 'all';
   }
 
   return evaluated;
@@ -344,7 +350,7 @@ function collectEvaluated(this: ZSchemaBase, args: CollectEvaluatedArgs): Set<nu
 // unevaluatedItems
 // ---------------------------------------------------------------------------
 
-function unevaluatedItemsValidator(this: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
+function unevaluatedItemsValidator(ctx: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
   if (!Array.isArray(json)) {
     return;
   }
@@ -363,7 +369,7 @@ function unevaluatedItemsValidator(this: ZSchemaBase, report: Report, schema: Js
     return;
   }
 
-  const evaluatedItems = collectEvaluated.call(this, {
+  const evaluatedItems = collectEvaluated(ctx, {
     report,
     currentSchema: schema,
     json,
@@ -391,9 +397,10 @@ function unevaluatedItemsValidator(this: ZSchemaBase, report: Report, schema: Js
     report.addError('ARRAY_UNEVALUATED_ITEMS', undefined, undefined, schema, 'unevaluatedItems');
   } else {
     // unevaluatedItems as a schema — validate each unevaluated item against it
-    for (const idx of unevaluatedIndices) {
+    for (let i = 0; i < unevaluatedIndices.length; i++) {
+      const idx = unevaluatedIndices[i];
       const subReport = new Report(report);
-      validate.call(this, subReport, unevalSchema as JsonSchemaInternal, json[idx]);
+      validate(ctx, subReport, unevalSchema, json[idx]);
       if (subReport.errors.length > 0) {
         report.addError('ARRAY_UNEVALUATED_ITEMS', undefined, undefined, schema, 'unevaluatedItems');
         break;
@@ -406,7 +413,7 @@ function unevaluatedItemsValidator(this: ZSchemaBase, report: Report, schema: Js
 // unevaluatedProperties
 // ---------------------------------------------------------------------------
 
-function unevaluatedPropertiesValidator(this: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
+function unevaluatedPropertiesValidator(ctx: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
   if (!isObject(json)) {
     return;
   }
@@ -427,7 +434,7 @@ function unevaluatedPropertiesValidator(this: ZSchemaBase, report: Report, schem
     return;
   }
 
-  const evaluatedProperties = collectEvaluated.call(this, {
+  const evaluatedProperties = collectEvaluated(ctx, {
     report,
     currentSchema: schema,
     json,
@@ -440,7 +447,12 @@ function unevaluatedPropertiesValidator(this: ZSchemaBase, report: Report, schem
     return;
   }
 
-  const unevaluatedKeys = allKeys.filter((key) => !evaluatedProperties.has(key));
+  const unevaluatedKeys: string[] = [];
+  for (let i = 0; i < allKeys.length; i++) {
+    if (!evaluatedProperties.has(allKeys[i])) {
+      unevaluatedKeys.push(allKeys[i]);
+    }
+  }
 
   if (unevaluatedKeys.length === 0) {
     return;
@@ -456,9 +468,10 @@ function unevaluatedPropertiesValidator(this: ZSchemaBase, report: Report, schem
     );
   } else {
     // unevaluatedProperties as a schema — validate each unevaluated key against it
-    for (const key of unevaluatedKeys) {
+    for (let i = 0; i < unevaluatedKeys.length; i++) {
+      const key = unevaluatedKeys[i];
       const subReport = new Report(report);
-      validate.call(this, subReport, unevalSchema as JsonSchemaInternal, (json as Record<string, unknown>)[key]);
+      validate(ctx, subReport, unevalSchema, (json as Record<string, unknown>)[key]);
       if (subReport.errors.length > 0) {
         report.addError('OBJECT_UNEVALUATED_PROPERTIES', [key], undefined, schema, 'unevaluatedProperties');
       }
@@ -480,23 +493,27 @@ function definitionsValidator() {
 // JsonValidators — keyword dispatch table
 // ---------------------------------------------------------------------------
 
+const noopValidator: JsonValidatorFn = () => {
+  // intentional no-op: metadata keyword or handled elsewhere in the pipeline
+};
+
 export const JsonValidators: Record<keyof JsonSchemaAll, JsonValidatorFn> = {
   // no-op validators (metadata / handled elsewhere)
-  id: () => {},
-  $id: () => {},
-  $ref: () => {},
-  $schema: () => {},
-  $dynamicAnchor: () => {},
-  $dynamicRef: () => {},
-  $anchor: () => {},
-  $defs: () => {},
-  $vocabulary: () => {},
-  $recursiveAnchor: () => {},
-  $recursiveRef: () => {},
-  examples: () => {},
-  title: () => {},
-  description: () => {},
-  default: () => {},
+  id: noopValidator,
+  $id: noopValidator,
+  $ref: noopValidator,
+  $schema: noopValidator,
+  $dynamicAnchor: noopValidator,
+  $dynamicRef: noopValidator,
+  $anchor: noopValidator,
+  $defs: noopValidator,
+  $vocabulary: noopValidator,
+  $recursiveAnchor: noopValidator,
+  $recursiveRef: noopValidator,
+  examples: noopValidator,
+  title: noopValidator,
+  description: noopValidator,
+  default: noopValidator,
 
   // type validators
   type: typeValidator,
@@ -560,25 +577,25 @@ export const JsonValidators: Record<keyof JsonSchemaAll, JsonValidatorFn> = {
 // recurseArray
 // ---------------------------------------------------------------------------
 
-const recurseArray = function (this: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: Array<unknown>) {
+function recurseArray(ctx: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown[]) {
   // http://json-schema.org/latest/json-schema-validation.html#rfc.section.8.2
 
   const schemaUri = typeof schema.$schema === 'string' ? schema.$schema : undefined;
   const isDraft202012Schema =
     schemaUri === 'https://json-schema.org/draft/2020-12/schema' ||
-    (!schemaUri && this.options.version === 'draft2020-12');
+    (!schemaUri && ctx.options.version === 'draft2020-12');
   const prefixItems = isDraft202012Schema && Array.isArray(schema.prefixItems) ? schema.prefixItems : undefined;
 
   if (prefixItems) {
     for (let idx = 0; idx < json.length; idx++) {
       if (idx < prefixItems.length) {
         report.path.push(idx);
-        validate.call(this, report, prefixItems[idx], json[idx]);
+        validate(ctx, report, prefixItems[idx], json[idx]);
         report.path.pop();
       } else if (schema.items !== undefined && !Array.isArray(schema.items)) {
         report.path.push(idx);
         report.schemaPath.push('items');
-        validate.call(this, report, schema.items, json[idx]);
+        validate(ctx, report, schema.items, json[idx]);
         report.schemaPath.pop();
         report.path.pop();
       }
@@ -595,15 +612,13 @@ const recurseArray = function (this: ZSchemaBase, report: Report, schema: JsonSc
       // equal to doesn't make sense here
       if (idx < schema.items.length) {
         report.path.push(idx);
-        validate.call(this, report, schema.items[idx], json[idx]);
+        validate(ctx, report, schema.items[idx], json[idx]);
         report.path.pop();
-      } else {
+      } else if (typeof schema.additionalItems === 'object') {
         // might be boolean, so check that it's an object
-        if (typeof schema.additionalItems === 'object') {
-          report.path.push(idx);
-          validate.call(this, report, schema.additionalItems, json[idx]);
-          report.path.pop();
-        }
+        report.path.push(idx);
+        validate(ctx, report, schema.additionalItems, json[idx]);
+        report.path.pop();
       }
     }
   } else if (typeof schema.items === 'object' || typeof schema.items === 'boolean') {
@@ -613,23 +628,23 @@ const recurseArray = function (this: ZSchemaBase, report: Report, schema: JsonSc
       report.path.push(idx);
       // Track schema path for array items validation
       report.schemaPath.push('items');
-      validate.call(this, report, schema.items, json[idx]);
+      validate(ctx, report, schema.items, json[idx]);
       report.schemaPath.pop();
       report.path.pop();
     }
   }
-};
+}
 
 // ---------------------------------------------------------------------------
 // recurseObject
 // ---------------------------------------------------------------------------
 
-const recurseObject = function (this: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: Record<any, any>) {
+function recurseObject(ctx: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: Record<string, unknown>) {
   // http://json-schema.org/latest/json-schema-validation.html#rfc.section.8.3
 
   // If "additionalProperties" is absent, it is considered present with an empty schema as a value.
   // In addition, boolean value true is considered equivalent to an empty schema.
-  let additionalProperties = schema.additionalProperties;
+  let { additionalProperties } = schema;
   if (additionalProperties === true || additionalProperties === undefined) {
     additionalProperties = {};
   }
@@ -643,22 +658,33 @@ const recurseObject = function (this: ZSchemaBase, report: Report, schema: JsonS
   // m - The property name of the child.
   const keys = Object.keys(json);
 
+  // Precompile patternProperties regexes once before the per-key loop
+  const ppCompiled: Array<{ key: string; re: RegExp }> = [];
+  for (let i = 0; i < pp.length; i++) {
+    const r = compileSchemaRegex(pp[i]);
+    if (r.ok) {
+      ppCompiled.push({ key: pp[i], re: r.value });
+    }
+  }
+
   for (const m of keys) {
     const propertyValue = json[m];
 
+    // Hoist membership check: compute once per key
+    const isProp = p.includes(m);
+
     // s - The set of schemas for the child instance.
     const s = [];
 
     // 1. If set "p" contains value "m", then the corresponding schema in "properties" is added to "s".
-    if (p.includes(m)) {
+    if (isProp) {
       s.push(schema.properties![m]);
     }
 
     // 2. For each regex in "pp", if it matches "m" successfully, the corresponding schema in "patternProperties" is added to "s".
-    for (const regexString of pp) {
-      const result = compileSchemaRegex(regexString);
-      if (result.ok && result.value.test(m) === true) {
-        s.push(schema.patternProperties![regexString]);
+    for (let i = 0; i < ppCompiled.length; i++) {
+      if (ppCompiled[i].re.test(m)) {
+        s.push(schema.patternProperties![ppCompiled[i].key]);
       }
     }
 
@@ -675,7 +701,7 @@ const recurseObject = function (this: ZSchemaBase, report: Report, schema: JsonS
     for (const schema_s of s) {
       report.path.push(m);
       // Track schema path for properties validation
-      if (p.includes(m)) {
+      if (isProp) {
         // This is a defined property
         report.schemaPath.push('properties');
         report.schemaPath.push(m);
@@ -683,22 +709,22 @@ const recurseObject = function (this: ZSchemaBase, report: Report, schema: JsonS
         // This is additionalProperties or patternProperties
         report.schemaPath.push('additionalProperties');
       }
-      validate.call(this, report, schema_s, propertyValue);
+      validate(ctx, report, schema_s, propertyValue);
       report.path.pop();
       report.schemaPath.pop();
-      if (p.includes(m)) {
+      if (isProp) {
         report.schemaPath.pop(); // pop the property name for defined properties
       }
     }
   }
-};
+}
 
 // ---------------------------------------------------------------------------
 // validate — main entry point
 // ---------------------------------------------------------------------------
 
 export function validate(
-  this: ZSchemaBase,
+  ctx: ZSchemaBase,
   report: Report,
   schema: boolean | JsonSchemaInternal,
   json: unknown
@@ -738,9 +764,9 @@ export function validate(
   let pushedRecursiveAnchor = false;
   let pushedDynamicScope = false;
   const schemaId = getId(schema);
-  const schemaResourceRoot = (schema as JsonSchemaInternal).__$resourceRoot;
+  const schemaResourceRoot = schema.__$resourceRoot;
   const dynamicScopeEntry = schemaResourceRoot || (isRoot || typeof schemaId === 'string' ? schema : undefined);
-  if (dynamicScopeEntry && dynamicScopeStack[dynamicScopeStack.length - 1] !== dynamicScopeEntry) {
+  if (dynamicScopeEntry && dynamicScopeStack.at(-1) !== dynamicScopeEntry) {
     dynamicScopeStack.push(dynamicScopeEntry);
     pushedDynamicScope = true;
   }
@@ -752,15 +778,18 @@ export function validate(
   // follow schema.$ref keys
   if (schema.$ref !== undefined) {
     const applySiblingKeywordsWithRef =
-      this.options.version === 'draft2019-09' || this.options.version === 'draft2020-12';
+      ctx.options.version === 'draft2019-09' || ctx.options.version === 'draft2020-12';
 
     if (applySiblingKeywordsWithRef) {
-      if (!schema.__$refResolved) {
-        report.addError('REF_UNRESOLVED', [schema.$ref], undefined, schema);
+      if (schema.__$refResolved) {
+        validate(ctx, report, schema.__$refResolved, json);
       } else {
-        validate.call(this, report, schema.__$refResolved as JsonSchemaInternal, json);
+        report.addError('REF_UNRESOLVED', [schema.$ref], undefined, schema);
+      }
+      const refIdx = keys.indexOf('$ref');
+      if (refIdx !== -1) {
+        keys.splice(refIdx, 1);
       }
-      keys = keys.filter((key) => key !== '$ref');
     } else {
       // avoid infinite loop with maxRefs
       let maxRefs = 99;
@@ -787,48 +816,60 @@ export function validate(
   // follow schema.$recursiveRef keys
   if (schema.$recursiveRef !== undefined) {
     const applySiblingKeywordsWithRecursiveRef =
-      this.options.version === 'draft2019-09' || this.options.version === 'draft2020-12';
+      ctx.options.version === 'draft2019-09' || ctx.options.version === 'draft2020-12';
 
     if (applySiblingKeywordsWithRecursiveRef) {
       const recursiveRefTarget = resolveRecursiveRef(schema, recursiveAnchorStack);
 
-      if (!recursiveRefTarget) {
-        report.addError('REF_UNRESOLVED', [schema.$recursiveRef], undefined, schema);
+      if (recursiveRefTarget) {
+        validate(ctx, report, recursiveRefTarget, json);
       } else {
-        validate.call(this, report, recursiveRefTarget, json);
+        report.addError('REF_UNRESOLVED', [schema.$recursiveRef], undefined, schema);
+      }
+      const recursiveRefIdx = keys.indexOf('$recursiveRef');
+      if (recursiveRefIdx !== -1) {
+        keys.splice(recursiveRefIdx, 1);
       }
-      keys = keys.filter((key) => key !== '$recursiveRef');
     }
   }
 
   // follow schema.$dynamicRef keys
   if (schema.$dynamicRef !== undefined) {
-    const applySiblingKeywordsWithDynamicRef = this.options.version === 'draft2020-12';
+    const applySiblingKeywordsWithDynamicRef = ctx.options.version === 'draft2020-12';
 
     if (applySiblingKeywordsWithDynamicRef) {
       const dynamicRefTarget = resolveDynamicRef(schema, dynamicScopeStack);
 
-      if (typeof dynamicRefTarget === 'undefined') {
+      if (dynamicRefTarget === undefined) {
         report.addError('REF_UNRESOLVED', [schema.$dynamicRef], undefined, schema);
       } else {
-        validate.call(this, report, dynamicRefTarget, json);
+        validate(ctx, report, dynamicRefTarget, json);
+      }
+      const dynamicRefIdx = keys.indexOf('$dynamicRef');
+      if (dynamicRefIdx !== -1) {
+        keys.splice(dynamicRefIdx, 1);
       }
-      keys = keys.filter((key) => key !== '$dynamicRef');
     }
   }
 
-  const validationVocabularyEnabled = isValidationVocabularyEnabled(schema, report, this.options.version);
+  const validationVocabularyEnabled = isValidationVocabularyEnabled(schema, report, ctx.options.version);
   if (!validationVocabularyEnabled) {
-    keys = keys.filter((key) => !VALIDATION_VOCAB_KEYWORDS.has(key));
+    let wi = 0;
+    for (let ri = 0; ri < keys.length; ri++) {
+      if (!VALIDATION_VOCAB_KEYWORDS.has(keys[ri])) {
+        keys[wi++] = keys[ri];
+      }
+    }
+    keys.length = wi;
   }
 
   // type checking first
   if (validationVocabularyEnabled && schema.type) {
     keys.splice(keys.indexOf('type'), 1);
     report.schemaPath.push('type');
-    JsonValidators.type.call(this, report, schema, json);
+    JsonValidators.type(ctx, report, schema, json);
     report.schemaPath.pop();
-    if (report.errors.length && this.options.breakOnFirstError) {
+    if (report.errors.length && ctx.options.breakOnFirstError) {
       if (pushedRecursiveAnchor) {
         recursiveAnchorStack.pop();
       }
@@ -843,43 +884,45 @@ export function validate(
   // Defer unevaluatedItems/unevaluatedProperties to run after other validators,
   // so combinator validation results are cached and available for annotation collection
   const deferredUnevaluatedKeys: Array<keyof JsonSchemaAll> = [];
-  for (const key of keys) {
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
     if (key === 'unevaluatedItems' || key === 'unevaluatedProperties') {
       deferredUnevaluatedKeys.push(key);
       continue;
     }
     const validator = JsonValidators[key];
     if (validator) {
-      validator.call(this, report, schema, json);
-      if (report.errors.length && this.options.breakOnFirstError) {
+      validator(ctx, report, schema, json);
+      if (report.errors.length && ctx.options.breakOnFirstError) {
         break;
       }
     }
   }
 
   // Run unevaluated* validators after all others have cached their combinator results
-  if (deferredUnevaluatedKeys.length > 0 && !(report.errors.length > 0 && this.options.breakOnFirstError)) {
-    for (const key of deferredUnevaluatedKeys) {
+  if (deferredUnevaluatedKeys.length > 0 && !(report.errors.length > 0 && ctx.options.breakOnFirstError)) {
+    for (let i = 0; i < deferredUnevaluatedKeys.length; i++) {
+      const key = deferredUnevaluatedKeys[i];
       const validator = JsonValidators[key];
       if (validator) {
-        validator.call(this, report, schema, json);
-        if (report.errors.length && this.options.breakOnFirstError) {
+        validator(ctx, report, schema, json);
+        if (report.errors.length && ctx.options.breakOnFirstError) {
           break;
         }
       }
     }
   }
 
-  if (report.errors.length === 0 || this.options.breakOnFirstError === false) {
+  if (report.errors.length === 0 || ctx.options.breakOnFirstError === false) {
     if (Array.isArray(json)) {
-      recurseArray.call(this, report, schema, json);
+      recurseArray(ctx, report, schema, json);
     } else if (isObject(json)) {
-      recurseObject.call(this, report, schema, json);
+      recurseObject(ctx, report, schema, json);
     }
   }
 
-  if (typeof this.options.customValidator === 'function') {
-    this.options.customValidator.call(this, report, schema, json);
+  if (typeof ctx.options.customValidator === 'function') {
+    ctx.options.customValidator.call(ctx, report, schema, json);
   }
 
   if (pushedRecursiveAnchor) {