z-schema 10.0.0 → 12.0.0

package/dist/json-validation.js

@@ -1,698 +1,461 @@
-import { getFormatValidators } from './format-validators.js';
+import { getId } from './json-schema.js';
 import { Report } from './report.js';
-import { difference, isUniqueArray } from './utils/array.js';
-import { shallowClone } from './utils/clone.js';
-import { areEqual } from './utils/json.js';
-import { hasOwn } from './utils/properties.js';
 import { compileSchemaRegex } from './utils/schema-regex.js';
-import { ucs2decode } from './utils/unicode.js';
 import { isObject, whatIs } from './utils/what-is.js';
-const shouldSkipValidate = function (options, errors) {
-    return (options &&
-        Array.isArray(options.includeErrors) &&
-        options.includeErrors.length > 0 &&
-        !errors.some(function (err) {
-            return options.includeErrors.includes(err);
-        }));
-};
-export const JsonValidators = {
-    id: () => { },
-    $ref: () => { },
-    $schema: () => { },
-    title: () => { },
-    description: () => { },
-    default: () => { },
-    multipleOf: function (report, schema, json) {
-        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.1.1.2
-        if (shouldSkipValidate(this.validateOptions, ['MULTIPLE_OF'])) {
-            return;
-        }
-        if (typeof json !== 'number') {
-            return;
-        }
-        const result = json / schema.multipleOf;
-        if (!Number.isFinite(result) || Math.abs(result - Math.round(result)) >= 1e-10) {
-            report.addError('MULTIPLE_OF', [json, schema.multipleOf], undefined, schema, 'multipleOf');
-        }
-    },
-    maximum: function (report, schema, json) {
-        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.1.2.2
-        if (shouldSkipValidate(this.validateOptions, ['MAXIMUM', 'MAXIMUM_EXCLUSIVE'])) {
-            return;
-        }
-        if (typeof json !== 'number') {
-            return;
-        }
-        if (schema.exclusiveMaximum !== true) {
-            if (json > schema.maximum) {
-                report.addError('MAXIMUM', [json, schema.maximum], undefined, schema, 'maximum');
-            }
+import { additionalItemsValidator, containsValidator, itemsValidator, maxContainsValidator, maxItemsValidator, minContainsValidator, minItemsValidator, prefixItemsValidator, uniqueItemsValidator, } from './validation/array.js';
+import { allOfValidator, anyOfValidator, elseValidator, ifValidator, notValidator, oneOfValidator, thenValidator, } from './validation/combinators.js';
+import { exclusiveMaximumValidator, exclusiveMinimumValidator, maximumValidator, minimumValidator, multipleOfValidator, } from './validation/numeric.js';
+import { additionalPropertiesValidator, dependenciesValidator, dependentRequiredValidator, dependentSchemasValidator, maxPropertiesValidator, minPropertiesValidator, patternPropertiesValidator, propertiesValidator, propertyNamesValidator, requiredValidator, } from './validation/object.js';
+import { resolveDynamicRef, resolveRecursiveRef } from './validation/ref.js';
+import { getCachedValidationResult, isValidationVocabularyEnabled, VALIDATION_VOCAB_KEYWORDS, } from './validation/shared.js';
+import { contentEncodingValidator, contentMediaTypeValidator, formatValidator, maxLengthValidator, minLengthValidator, patternValidator, } from './validation/string.js';
+import { constValidator, enumValidator, typeValidator } from './validation/type.js';
+function collectEvaluated(args) {
+    const { report, currentSchema, json, mode, depth } = args;
+    if (!currentSchema || typeof currentSchema === 'boolean') {
+        return new Set();
+    }
+    if (depth > (this.options.maxRecursionDepth ?? 100)) {
+        report.addError('COLLECT_EVALUATED_DEPTH_EXCEEDED', [depth]);
+        return new Set();
+    }
+    const evaluated = new Set();
+    const merge = (other) => {
+        if (other === 'all')
+            return true;
+        for (const v of other) {
+            evaluated.add(v);
         }
-        else {
-            if (json >= schema.maximum) {
-                report.addError('MAXIMUM_EXCLUSIVE', [json, schema.maximum], undefined, schema, 'maximum');
-            }
+        return false;
+    };
+    const recurse = (subSchema) => {
+        if (mode === 'items') {
+            return collectEvaluated.call(this, {
+                report,
+                currentSchema: subSchema,
+                json,
+                mode: 'items',
+                jsonArr: args.jsonArr,
+                depth: depth + 1,
+            });
         }
-    },
-    exclusiveMaximum: function (report, schema, json) {
-        // In draft-06+, exclusiveMaximum is a standalone number
-        if (typeof schema.exclusiveMaximum === 'number') {
-            if (shouldSkipValidate(this.validateOptions, ['MAXIMUM_EXCLUSIVE'])) {
-                return;
-            }
-            if (typeof json !== 'number') {
-                return;
+        return collectEvaluated.call(this, {
+            report,
+            currentSchema: subSchema,
+            json,
+            mode: 'properties',
+            jsonData: args.jsonData,
+            depth: depth + 1,
+        });
+    };
+    // --- Mode-specific leaf collection ---
+    if (mode === 'items') {
+        const jsonArr = args.jsonArr;
+        // prefixItems (2020-12 tuple)
+        if (Array.isArray(currentSchema.prefixItems)) {
+            const len = Math.min(currentSchema.prefixItems.length, jsonArr.length);
+            for (let i = 0; i < len; i++) {
+                evaluated.add(i);
+            }
+        }
+        // items - can be array (2019-09 tuple) or schema (evaluates all)
+        if (currentSchema.items !== undefined) {
+            if (Array.isArray(currentSchema.items)) {
+                const len = Math.min(currentSchema.items.length, jsonArr.length);
+                for (let i = 0; i < len; i++) {
+                    evaluated.add(i);
+                }
             }
-            if (json >= schema.exclusiveMaximum) {
-                report.addError('MAXIMUM_EXCLUSIVE', [json, schema.exclusiveMaximum], undefined, schema, 'exclusiveMaximum');
+            else if (currentSchema.items !== false) {
+                return 'all';
             }
         }
-        // In draft-04, exclusiveMaximum is a boolean handled inside the `maximum` validator
-    },
-    minimum: function (report, schema, json) {
-        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.1.3.2
-        if (shouldSkipValidate(this.validateOptions, ['MINIMUM', 'MINIMUM_EXCLUSIVE'])) {
-            return;
-        }
-        if (typeof json !== 'number') {
-            return;
+        // additionalItems (2019-09) - when items is array form and additionalItems is present and not false
+        if (currentSchema.additionalItems !== undefined &&
+            currentSchema.additionalItems !== false &&
+            Array.isArray(currentSchema.items)) {
+            return 'all';
         }
-        if (schema.exclusiveMinimum !== true) {
-            if (json < schema.minimum) {
-                report.addError('MINIMUM', [json, schema.minimum], undefined, schema, 'minimum');
-            }
-        }
-        else {
-            if (json <= schema.minimum) {
-                report.addError('MINIMUM_EXCLUSIVE', [json, schema.minimum], undefined, schema, 'minimum');
-            }
-        }
-    },
-    exclusiveMinimum: function (report, schema, json) {
-        // In draft-06+, exclusiveMinimum is a standalone number
-        if (typeof schema.exclusiveMinimum === 'number') {
-            if (shouldSkipValidate(this.validateOptions, ['MINIMUM_EXCLUSIVE'])) {
-                return;
-            }
-            if (typeof json !== 'number') {
-                return;
+        // contains - evaluates specific indices that match the schema
+        if (currentSchema.contains !== undefined) {
+            for (let i = 0; i < jsonArr.length; i++) {
+                let passed = getCachedValidationResult(report, currentSchema.contains, jsonArr[i]);
+                if (passed === undefined) {
+                    const subReport = new Report(report);
+                    validate.call(this, subReport, currentSchema.contains, jsonArr[i]);
+                    passed = subReport.errors.length === 0;
+                }
+                if (passed) {
+                    evaluated.add(i);
+                }
             }
-            if (json <= schema.exclusiveMinimum) {
-                report.addError('MINIMUM_EXCLUSIVE', [json, schema.exclusiveMinimum], undefined, schema, 'exclusiveMinimum');
-            }
-        }
-        // In draft-04, exclusiveMinimum is a boolean handled inside the `minimum` validator
-    },
-    maxLength: function (report, schema, json) {
-        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.2.1.2
-        if (shouldSkipValidate(this.validateOptions, ['MAX_LENGTH'])) {
-            return;
-        }
-        if (typeof json !== 'string') {
-            return;
-        }
-        if (ucs2decode(json).length > schema.maxLength) {
-            report.addError('MAX_LENGTH', [json.length, schema.maxLength], undefined, schema, 'maxLength');
         }
-    },
-    minLength: function (report, schema, json) {
-        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.2.2.2
-        if (shouldSkipValidate(this.validateOptions, ['MIN_LENGTH'])) {
-            return;
-        }
-        if (typeof json !== 'string') {
-            return;
-        }
-        if (ucs2decode(json).length < schema.minLength) {
-            report.addError('MIN_LENGTH', [json.length, schema.minLength], undefined, schema, 'minLength');
+        // unevaluatedItems: true means all items evaluated
+        if (currentSchema.unevaluatedItems === true) {
+            return 'all';
         }
-    },
-    pattern: function (report, schema, json) {
-        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.2.3.2
-        if (shouldSkipValidate(this.validateOptions, ['PATTERN'])) {
-            return;
-        }
-        if (typeof json !== 'string') {
-            return;
-        }
-        const result = compileSchemaRegex(schema.pattern);
-        if (!result.ok) {
-            // Should not happen: schema should have been validated already
-            report.addError('PATTERN', [schema.pattern, json, result.error.message], undefined, schema, 'pattern');
-            return;
-        }
-        if (!result.value.test(json)) {
-            report.addError('PATTERN', [schema.pattern, json], undefined, schema, 'pattern');
-        }
-    },
-    additionalItems: function (report, schema, json) {
-        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.3.1.2
-        if (shouldSkipValidate(this.validateOptions, ['ARRAY_ADDITIONAL_ITEMS'])) {
-            return;
-        }
-        if (!Array.isArray(json)) {
-            return;
-        }
-        // if the value of "additionalItems" is boolean value false and the value of "items" is an array,
-        // the json is valid if its size is less than, or equal to, the size of "items".
-        if (schema.additionalItems === false && Array.isArray(schema.items)) {
-            if (json.length > schema.items.length) {
-                report.addError('ARRAY_ADDITIONAL_ITEMS', undefined, undefined, schema, 'additionalItems');
-            }
-        }
-    },
-    items: function () {
-        /*report: Report, schema: JsonSchemaInternal, json: unknown*/
-        // covered in additionalItems
-    },
-    maxItems: function (report, schema, json) {
-        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.3.2.2
-        if (shouldSkipValidate(this.validateOptions, ['ARRAY_LENGTH_LONG'])) {
-            return;
-        }
-        if (!Array.isArray(json)) {
-            return;
-        }
-        if (json.length > schema.maxItems) {
-            report.addError('ARRAY_LENGTH_LONG', [json.length, schema.maxItems], undefined, schema, 'maxItems');
-        }
-    },
-    minItems: function (report, schema, json) {
-        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.3.3.2
-        if (shouldSkipValidate(this.validateOptions, ['ARRAY_LENGTH_SHORT'])) {
-            return;
-        }
-        if (!Array.isArray(json)) {
-            return;
-        }
-        if (json.length < schema.minItems) {
-            report.addError('ARRAY_LENGTH_SHORT', [json.length, schema.minItems], undefined, schema, 'minItems');
-        }
-    },
-    uniqueItems: function (report, schema, json) {
-        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.3.4.2
-        if (shouldSkipValidate(this.validateOptions, ['ARRAY_UNIQUE'])) {
-            return;
-        }
-        if (!Array.isArray(json)) {
-            return;
-        }
-        if (schema.uniqueItems === true) {
-            const matches = [];
-            if (isUniqueArray(json, matches) === false) {
-                report.addError('ARRAY_UNIQUE', matches, undefined, schema, 'uniqueItems');
-            }
-        }
-    },
-    maxProperties: function (report, schema, json) {
-        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.1.2
-        if (shouldSkipValidate(this.validateOptions, ['OBJECT_PROPERTIES_MAXIMUM'])) {
-            return;
-        }
-        if (!isObject(json)) {
-            return;
-        }
-        const keysCount = Object.keys(json).length;
-        if (keysCount > schema.maxProperties) {
-            report.addError('OBJECT_PROPERTIES_MAXIMUM', [keysCount, schema.maxProperties], undefined, schema, 'maxProperties');
-        }
-    },
-    minProperties: function (report, schema, json) {
-        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.2.2
-        if (shouldSkipValidate(this.validateOptions, ['OBJECT_PROPERTIES_MINIMUM'])) {
-            return;
-        }
-        if (!isObject(json)) {
-            return;
-        }
-        const keysCount = Object.keys(json).length;
-        if (keysCount < schema.minProperties) {
-            report.addError('OBJECT_PROPERTIES_MINIMUM', [keysCount, schema.minProperties], undefined, schema, 'minProperties');
-        }
-    },
-    required: function (report, schema, json) {
-        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.3.2
-        if (shouldSkipValidate(this.validateOptions, ['OBJECT_MISSING_REQUIRED_PROPERTY'])) {
-            return;
-        }
-        if (!isObject(json)) {
-            return;
-        }
-        let idx = schema.required.length;
-        while (idx--) {
-            const requiredPropertyName = schema.required[idx];
-            if (!hasOwn(json, requiredPropertyName)) {
-                report.addError('OBJECT_MISSING_REQUIRED_PROPERTY', [requiredPropertyName], undefined, schema, 'required');
-            }
-        }
-    },
-    additionalProperties: function (report, schema, json) {
-        // covered in properties and patternProperties
-        if (schema.properties === undefined && schema.patternProperties === undefined) {
-            return JsonValidators.properties.call(this, report, schema, json);
-        }
-    },
-    patternProperties: function (report, schema, json) {
-        // covered in properties
-        if (schema.properties === undefined) {
-            return JsonValidators.properties.call(this, report, schema, json);
-        }
-    },
-    properties: function (report, schema, json) {
-        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.4.2
-        if (shouldSkipValidate(this.validateOptions, ['OBJECT_ADDITIONAL_PROPERTIES'])) {
-            return;
-        }
-        if (!isObject(json)) {
-            return;
-        }
-        const properties = schema.properties !== undefined ? schema.properties : {};
-        const patternProperties = schema.patternProperties !== undefined ? schema.patternProperties : {};
-        if (schema.additionalProperties === false) {
-            // The property set of the json to validate.
-            let s = Object.keys(json);
-            // The property set from "properties".
-            const p = Object.keys(properties);
-            // The property set from "patternProperties".
-            const pp = Object.keys(patternProperties);
-            // remove from "s" all elements of "p", if any;
-            s = difference(s, p);
-            // for each regex in "pp", remove all elements of "s" which this regex matches.
-            let idx = pp.length;
-            while (idx--) {
-                const result = compileSchemaRegex(pp[idx]);
-                if (!result.ok) {
-                    continue;
-                }
-                const regExp = result.value;
-                let idx2 = s.length;
-                while (idx2--) {
-                    if (regExp.test(s[idx2]) === true) {
-                        s.splice(idx2, 1);
-                    }
+    }
+    else {
+        // mode === 'properties'
+        const jsonData = args.jsonData;
+        // properties
+        if (isObject(currentSchema.properties)) {
+            for (const key of Object.keys(currentSchema.properties)) {
+                if (Object.hasOwn(jsonData, key)) {
+                    evaluated.add(key);
                 }
             }
-            // Validation of the json succeeds if, after these two steps, set "s" is empty.
-            if (s.length > 0) {
-                // assumeAdditional can be an array of allowed properties
-                if (Array.isArray(this.options.assumeAdditional)) {
-                    let idx3 = this.options.assumeAdditional.length;
-                    if (idx3) {
-                        while (idx3--) {
-                            const io = s.indexOf(this.options.assumeAdditional[idx3]);
-                            if (io !== -1) {
-                                s.splice(io, 1);
-                            }
+        }
+        // patternProperties
+        if (isObject(currentSchema.patternProperties)) {
+            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);
                         }
                     }
                 }
-                let idx4 = s.length;
-                if (idx4) {
-                    while (idx4--) {
-                        report.addError('OBJECT_ADDITIONAL_PROPERTIES', [s[idx4]], undefined, schema, 'properties');
-                    }
-                }
             }
         }
-    },
-    dependencies: function (report, schema, json) {
-        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.5.2
-        if (shouldSkipValidate(this.validateOptions, ['OBJECT_DEPENDENCY_KEY'])) {
-            return;
-        }
-        if (!isObject(json)) {
-            return;
-        }
-        const keys = Object.keys(schema.dependencies);
-        let idx = keys.length;
-        while (idx--) {
-            // iterate all dependencies
-            const dependencyName = keys[idx];
-            if (hasOwn(json, dependencyName)) {
-                const dependencyDefinition = schema.dependencies[dependencyName];
-                if (Array.isArray(dependencyDefinition)) {
-                    // Array
-                    // if dependency is an array, object needs to have all properties in this array
-                    let idx2 = dependencyDefinition.length;
-                    while (idx2--) {
-                        const requiredPropertyName = dependencyDefinition[idx2];
-                        if (!hasOwn(json, requiredPropertyName)) {
-                            report.addError('OBJECT_DEPENDENCY_KEY', [requiredPropertyName, dependencyName], undefined, schema, 'dependencies');
-                        }
+        // additionalProperties - evaluates all non-properties/non-patternProperties keys
+        if (currentSchema.additionalProperties !== undefined) {
+            const propKeys = isObject(currentSchema.properties) ? Object.keys(currentSchema.properties) : [];
+            const patternRegexes = [];
+            if (isObject(currentSchema.patternProperties)) {
+                for (const pattern of Object.keys(currentSchema.patternProperties)) {
+                    const result = compileSchemaRegex(pattern);
+                    if (result.ok) {
+                        patternRegexes.push(result.value);
                     }
                 }
-                else {
-                    // if dependency is a schema, validate against this schema
-                    validate.call(this, report, dependencyDefinition, json);
-                }
             }
-        }
-    },
-    enum: function (report, schema, json) {
-        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.1.2
-        if (shouldSkipValidate(this.validateOptions, ['ENUM_CASE_MISMATCH', 'ENUM_MISMATCH'])) {
-            return;
-        }
-        let match = false, caseInsensitiveMatch = false, idx = schema.enum.length;
-        while (idx--) {
-            if (areEqual(json, schema.enum[idx])) {
-                match = true;
-                break;
-            }
-            else if (areEqual(json, schema.enum[idx], { caseInsensitiveComparison: true })) {
-                caseInsensitiveMatch = true;
+            for (const key of Object.keys(jsonData)) {
+                if (propKeys.includes(key))
+                    continue;
+                if (patternRegexes.some((re) => re.test(key)))
+                    continue;
+                evaluated.add(key);
             }
         }
-        if (match === false) {
-            const error = caseInsensitiveMatch && this.options.enumCaseInsensitiveComparison ? 'ENUM_CASE_MISMATCH' : 'ENUM_MISMATCH';
-            report.addError(error, [JSON.stringify(json)], undefined, schema, 'enum');
-        }
-    },
-    type: function (report, schema, json) {
-        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.2.2
-        if (shouldSkipValidate(this.validateOptions, ['INVALID_TYPE'])) {
-            return;
-        }
-        const jsonType = whatIs(json);
-        if (typeof schema.type === 'string') {
-            if (jsonType !== schema.type && (jsonType !== 'integer' || schema.type !== 'number')) {
-                report.addError('INVALID_TYPE', [schema.type, jsonType], undefined, schema, 'type');
+        // 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)) {
+                if (Object.hasOwn(jsonData, depKey)) {
+                    if (merge(recurse(depSchema))) {
+                        return 'all';
+                    }
+                }
             }
         }
-        else {
-            if (schema.type.indexOf(jsonType) === -1 && (jsonType !== 'integer' || schema.type.indexOf('number') === -1)) {
-                report.addError('INVALID_TYPE', [JSON.stringify(schema.type), jsonType], undefined, schema, 'type');
-            }
+        // unevaluatedProperties: true in a sub-schema means all props are evaluated
+        if (currentSchema.unevaluatedProperties === true) {
+            return 'all';
         }
-    },
-    allOf: function (report, schema, json) {
-        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.3.2
-        let idx = schema.allOf.length;
-        while (idx--) {
-            const validateResult = validate.call(this, report, schema.allOf[idx], json);
-            if (this.options.breakOnFirstError && validateResult === false) {
-                break;
+    }
+    // --- Shared combinator traversal ---
+    // allOf
+    if (Array.isArray(currentSchema.allOf)) {
+        for (const subSchema of currentSchema.allOf) {
+            if (merge(recurse(subSchema))) {
+                return 'all';
             }
         }
-    },
-    anyOf: function (report, schema, json) {
-        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.4.2
-        const subReports = [];
-        let idx = schema.anyOf.length;
-        while (idx--) {
-            const subReport = new Report(report);
-            subReports.push(subReport);
-            validate.call(this, subReport, schema.anyOf[idx], json);
-        }
-        // Aggregate async tasks from sub-reports to the main report
-        const asyncTasksBefore = report.asyncTasks.length;
-        for (const subReport of subReports) {
-            report.asyncTasks.push(...subReport.asyncTasks);
-        }
-        const hasAsyncTasks = report.asyncTasks.length > asyncTasksBefore;
-        if (hasAsyncTasks) {
-            // Defer the decision until async tasks complete
-            const pathBeforeAsync = shallowClone(report.path);
-            report.addAsyncTask((callback) => {
-                setTimeout(() => callback(null), 0);
-            }, [], () => {
-                const backup = report.path;
-                report.path = pathBeforeAsync;
-                let passed = false;
-                for (const subReport of subReports) {
-                    if (subReport.errors.length === 0) {
-                        passed = true;
-                        break;
-                    }
-                }
-                if (passed === false) {
-                    report.addError('ANY_OF_MISSING', undefined, subReports, schema, 'anyOf');
+    }
+    // anyOf - only matching branches contribute
+    if (Array.isArray(currentSchema.anyOf)) {
+        for (const subSchema of currentSchema.anyOf) {
+            let passed = getCachedValidationResult(report, subSchema, json);
+            if (passed === undefined) {
+                const subReport = new Report(report);
+                validate.call(this, subReport, subSchema, json);
+                passed = subReport.errors.length === 0;
+            }
+            if (passed) {
+                if (merge(recurse(subSchema))) {
+                    return 'all';
                 }
-                report.path = backup;
-            });
+            }
         }
-        else {
-            // No async tasks, decide immediately
-            let passed = false;
-            for (const subReport of subReports) {
-                if (subReport.errors.length === 0) {
-                    passed = true;
-                    break;
+    }
+    // oneOf - only matching branches contribute
+    if (Array.isArray(currentSchema.oneOf)) {
+        for (const subSchema of currentSchema.oneOf) {
+            let passed = getCachedValidationResult(report, subSchema, json);
+            if (passed === undefined) {
+                const subReport = new Report(report);
+                validate.call(this, subReport, subSchema, json);
+                passed = subReport.errors.length === 0;
+            }
+            if (passed) {
+                if (merge(recurse(subSchema))) {
+                    return 'all';
                 }
             }
-            if (passed === false) {
-                report.addError('ANY_OF_MISSING', undefined, subReports, schema, 'anyOf');
-            }
         }
-    },
-    oneOf: function (report, schema, json) {
-        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.5.2
-        const subReports = [];
-        let idx = schema.oneOf.length;
-        while (idx--) {
-            const subReport = new Report(report);
-            subReports.push(subReport);
-            validate.call(this, subReport, schema.oneOf[idx], json);
-        }
-        // Aggregate async tasks from sub-reports to the main report
-        const asyncTasksBefore = report.asyncTasks.length;
-        for (const subReport of subReports) {
-            report.asyncTasks.push(...subReport.asyncTasks);
-        }
-        const hasAsyncTasks = report.asyncTasks.length > asyncTasksBefore;
-        if (hasAsyncTasks) {
-            // Defer the decision until async tasks complete
-            const pathBeforeAsync = shallowClone(report.path);
-            report.addAsyncTask((callback) => {
-                // This task runs after all async tasks, so we can check final state
-                setTimeout(() => callback(null), 0);
-            }, [], () => {
-                const backup = report.path;
-                report.path = pathBeforeAsync;
-                let passes = 0;
-                for (const subReport of subReports) {
-                    if (subReport.errors.length === 0) {
-                        passes++;
-                    }
-                }
-                if (passes === 0) {
-                    report.addError('ONE_OF_MISSING', undefined, subReports, schema, 'oneOf');
-                }
-                else if (passes > 1) {
-                    report.addError('ONE_OF_MULTIPLE', undefined, undefined, schema, 'oneOf');
+    }
+    // if/then/else
+    if (currentSchema.if !== undefined) {
+        let condPassed = getCachedValidationResult(report, currentSchema.if, json);
+        if (condPassed === undefined) {
+            const condReport = new Report(report);
+            validate.call(this, condReport, currentSchema.if, json);
+            condPassed = condReport.errors.length === 0;
+        }
+        if (condPassed) {
+            if (merge(recurse(currentSchema.if))) {
+                return 'all';
+            }
+            if (currentSchema.then !== undefined) {
+                if (merge(recurse(currentSchema.then))) {
+                    return 'all';
                 }
-                report.path = backup;
-            });
+            }
         }
         else {
-            // No async tasks, decide immediately
-            let passes = 0;
-            for (const subReport of subReports) {
-                if (subReport.errors.length === 0) {
-                    passes++;
-                }
-            }
-            if (passes === 0) {
-                report.addError('ONE_OF_MISSING', undefined, subReports, schema, 'oneOf');
-            }
-            else if (passes > 1) {
-                report.addError('ONE_OF_MULTIPLE', undefined, undefined, schema, 'oneOf');
-            }
-        }
-    },
-    not: function (report, schema, json) {
-        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.6.2
-        const subReport = new Report(report);
-        if (validate.call(this, subReport, schema.not, json) === true) {
-            report.addError('NOT_PASSED', undefined, undefined, schema, 'not');
-        }
-    },
-    definitions: function () {
-        /*report: Report, schema: JsonSchemaInternal, json: unknown*/
-        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.7.2
-        // nothing to do here
-    },
-    format: function (report, schema, json) {
-        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.7.2
-        const formatValidators = getFormatValidators(this.options);
-        const formatValidatorFn = formatValidators[schema.format];
-        if (typeof formatValidatorFn === 'function') {
-            if (shouldSkipValidate(this.validateOptions, ['INVALID_FORMAT'])) {
-                return;
-            }
-            if (report.hasError('INVALID_TYPE', [schema.type, whatIs(json)])) {
-                return;
-            }
-            if (formatValidatorFn.length === 2) {
-                // callback-based async - need to clone the path here, because it will change by the time async function reports back
-                const pathBeforeAsync = shallowClone(report.path);
-                report.addAsyncTask(formatValidatorFn, [json], function (result) {
-                    if (result !== true) {
-                        const backup = report.path;
-                        report.path = pathBeforeAsync;
-                        report.addError('INVALID_FORMAT', [schema.format, JSON.stringify(json)], undefined, schema, 'format');
-                        report.path = backup;
-                    }
-                });
-            }
-            else {
-                const result = formatValidatorFn.call(this, json);
-                if (result instanceof Promise) {
-                    // Promise-based async
-                    const pathBeforeAsync = shallowClone(report.path);
-                    const timeoutMs = this.options.asyncTimeout || 2000;
-                    report.addAsyncTask(async (callback) => {
-                        try {
-                            const timeoutPromise = new Promise((_, reject) => {
-                                setTimeout(() => reject(new Error('Async timeout')), timeoutMs);
-                            });
-                            const resolved = await Promise.race([result, timeoutPromise]);
-                            callback(resolved);
-                        }
-                        catch (error) {
-                            if (error.message === 'Async timeout') {
-                                // Don't call callback, let global timeout handle it
-                                return;
-                            }
-                            callback(false);
-                        }
-                    }, [], function (resolvedResult) {
-                        if (resolvedResult !== true) {
-                            const backup = report.path;
-                            report.path = pathBeforeAsync;
-                            report.addError('INVALID_FORMAT', [schema.format, JSON.stringify(json)], undefined, schema, 'format');
-                            report.path = backup;
-                        }
-                    });
-                }
-                else {
-                    // sync
-                    if (result !== true) {
-                        report.addError('INVALID_FORMAT', [schema.format, JSON.stringify(json)], undefined, schema, 'format');
-                    }
+            if (currentSchema.else !== undefined) {
+                if (merge(recurse(currentSchema.else))) {
+                    return 'all';
                 }
             }
         }
-        else if (this.options.ignoreUnknownFormats !== true) {
-            report.addError('UNKNOWN_FORMAT', [schema.format], undefined, schema, 'format');
-        }
-    },
-    // draft-06 additions
-    $id: () => {
-        // TODO: implement
-    },
-    const: function (report, schema, json) {
-        const constValue = schema.const;
-        if (areEqual(json, constValue) === false) {
-            report.addError('CONST', [JSON.stringify(constValue)], undefined, schema, undefined);
+    }
+    // $ref resolved
+    if (currentSchema.__$refResolved && currentSchema.__$refResolved !== currentSchema) {
+        if (merge(recurse(currentSchema.__$refResolved))) {
+            return 'all';
         }
-    },
-    contains: function (report, schema, json) {
-        if (shouldSkipValidate(this.validateOptions, ['CONTAINS'])) {
-            return;
+    }
+    // $recursiveRef
+    const recursiveTarget = resolveRecursiveRef(currentSchema, report.__$recursiveAnchorStack);
+    if (recursiveTarget && recursiveTarget !== currentSchema) {
+        if (merge(recurse(recursiveTarget))) {
+            return 'all';
         }
-        if (!Array.isArray(json)) {
-            return;
+    }
+    // $dynamicRef
+    const dynamicTarget = resolveDynamicRef(currentSchema, report.__$dynamicScopeStack);
+    if (dynamicTarget && dynamicTarget !== currentSchema) {
+        if (merge(recurse(dynamicTarget))) {
+            return 'all';
         }
-        const containsSchema = schema.contains;
-        if (containsSchema === undefined) {
-            return;
+    }
+    return evaluated;
+}
+// ---------------------------------------------------------------------------
+// unevaluatedItems
+// ---------------------------------------------------------------------------
+function unevaluatedItemsValidator(report, schema, json) {
+    if (!Array.isArray(json)) {
+        return;
+    }
+    // unevaluatedItems: true means all items are valid
+    if (schema.unevaluatedItems === true) {
+        return;
+    }
+    const unevalSchema = schema.unevaluatedItems;
+    if (unevalSchema === undefined) {
+        return;
+    }
+    if (json.length === 0) {
+        return;
+    }
+    const evaluatedItems = collectEvaluated.call(this, {
+        report,
+        currentSchema: schema,
+        json,
+        mode: 'items',
+        jsonArr: json,
+        depth: 0,
+    });
+    if (evaluatedItems === 'all') {
+        return;
+    }
+    const unevaluatedIndices = [];
+    for (let i = 0; i < json.length; i++) {
+        if (!evaluatedItems.has(i)) {
+            unevaluatedIndices.push(i);
         }
-        const subReports = [];
-        let idx = json.length;
-        while (idx--) {
+    }
+    if (unevaluatedIndices.length === 0) {
+        return;
+    }
+    if (unevalSchema === false) {
+        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) {
             const subReport = new Report(report);
-            subReports.push(subReport);
-            validate.call(this, subReport, containsSchema, json[idx]);
-        }
-        const asyncTasksBefore = report.asyncTasks.length;
-        for (const subReport of subReports) {
-            report.asyncTasks.push(...subReport.asyncTasks);
-        }
-        const hasAsyncTasks = report.asyncTasks.length > asyncTasksBefore;
-        const addContainsErrorIfNeeded = () => {
-            let hasValidItem = false;
-            for (const subReport of subReports) {
-                if (subReport.errors.length === 0) {
-                    hasValidItem = true;
-                    break;
-                }
+            validate.call(this, subReport, unevalSchema, json[idx]);
+            if (subReport.errors.length > 0) {
+                report.addError('ARRAY_UNEVALUATED_ITEMS', undefined, undefined, schema, 'unevaluatedItems');
+                break;
             }
-            if (!hasValidItem) {
-                report.addError('CONTAINS', undefined, subReports, schema, undefined);
-            }
-        };
-        if (hasAsyncTasks) {
-            const pathBeforeAsync = shallowClone(report.path);
-            report.addAsyncTask((callback) => {
-                setTimeout(() => callback(null), 0);
-            }, [], () => {
-                const backup = report.path;
-                report.path = pathBeforeAsync;
-                addContainsErrorIfNeeded();
-                report.path = backup;
-            });
-            return;
-        }
-        addContainsErrorIfNeeded();
-    },
-    examples: () => {
-        // TODO: implement
-    },
-    propertyNames: function (report, schema, json) {
-        if (shouldSkipValidate(this.validateOptions, ['PROPERTY_NAMES'])) {
-            return;
-        }
-        if (!isObject(json)) {
-            return;
-        }
-        const propertyNamesSchema = schema.propertyNames;
-        if (propertyNamesSchema === undefined) {
-            return;
-        }
-        const keys = Object.keys(json);
-        const subReports = [];
-        for (const key of keys) {
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// unevaluatedProperties
+// ---------------------------------------------------------------------------
+function unevaluatedPropertiesValidator(report, schema, json) {
+    if (!isObject(json)) {
+        return;
+    }
+    // unevaluatedProperties: true means all properties are valid
+    if (schema.unevaluatedProperties === true) {
+        return;
+    }
+    // unevaluatedProperties: false or unevaluatedProperties: {schema} both need evaluation
+    const unevalSchema = schema.unevaluatedProperties;
+    if (unevalSchema === undefined) {
+        return;
+    }
+    const allKeys = Object.keys(json);
+    if (allKeys.length === 0) {
+        return;
+    }
+    const evaluatedProperties = collectEvaluated.call(this, {
+        report,
+        currentSchema: schema,
+        json,
+        mode: 'properties',
+        jsonData: json,
+        depth: 0,
+    });
+    if (evaluatedProperties === 'all') {
+        return;
+    }
+    const unevaluatedKeys = allKeys.filter((key) => !evaluatedProperties.has(key));
+    if (unevaluatedKeys.length === 0) {
+        return;
+    }
+    if (unevalSchema === false) {
+        report.addError('OBJECT_UNEVALUATED_PROPERTIES', [unevaluatedKeys.join(', ')], undefined, schema, 'unevaluatedProperties');
+    }
+    else {
+        // unevaluatedProperties as a schema — validate each unevaluated key against it
+        for (const key of unevaluatedKeys) {
             const subReport = new Report(report);
-            subReports.push(subReport);
-            validate.call(this, subReport, propertyNamesSchema, key);
-        }
-        const asyncTasksBefore = report.asyncTasks.length;
-        for (const subReport of subReports) {
-            report.asyncTasks.push(...subReport.asyncTasks);
-        }
-        const hasAsyncTasks = report.asyncTasks.length > asyncTasksBefore;
-        const addPropertyNameErrors = () => {
-            for (let idx = 0; idx < keys.length; idx++) {
-                if (subReports[idx].errors.length > 0) {
-                    report.addError('PROPERTY_NAMES', [keys[idx]], subReports[idx], schema, undefined);
-                }
+            validate.call(this, subReport, unevalSchema, json[key]);
+            if (subReport.errors.length > 0) {
+                report.addError('OBJECT_UNEVALUATED_PROPERTIES', [key], undefined, schema, 'unevaluatedProperties');
             }
-        };
-        if (hasAsyncTasks) {
-            const pathBeforeAsync = shallowClone(report.path);
-            report.addAsyncTask((callback) => {
-                setTimeout(() => callback(null), 0);
-            }, [], () => {
-                const backup = report.path;
-                report.path = pathBeforeAsync;
-                addPropertyNameErrors();
-                report.path = backup;
-            });
-            return;
         }
-        addPropertyNameErrors();
-    },
+    }
+}
+// ---------------------------------------------------------------------------
+// definitions  (no-op)
+// ---------------------------------------------------------------------------
+function definitionsValidator() {
+    /*report: Report, schema: JsonSchemaInternal, json: unknown*/
+    // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.7.2
+    // nothing to do here
+}
+// ---------------------------------------------------------------------------
+// JsonValidators — keyword dispatch table
+// ---------------------------------------------------------------------------
+export const JsonValidators = {
+    // no-op validators (metadata / handled elsewhere)
+    id: () => { },
+    $id: () => { },
+    $ref: () => { },
+    $schema: () => { },
+    $dynamicAnchor: () => { },
+    $dynamicRef: () => { },
+    $anchor: () => { },
+    $defs: () => { },
+    $vocabulary: () => { },
+    $recursiveAnchor: () => { },
+    $recursiveRef: () => { },
+    examples: () => { },
+    title: () => { },
+    description: () => { },
+    default: () => { },
+    // type validators
+    type: typeValidator,
+    enum: enumValidator,
+    const: constValidator,
+    // numeric validators
+    multipleOf: multipleOfValidator,
+    maximum: maximumValidator,
+    exclusiveMaximum: exclusiveMaximumValidator,
+    minimum: minimumValidator,
+    exclusiveMinimum: exclusiveMinimumValidator,
+    // string validators
+    maxLength: maxLengthValidator,
+    minLength: minLengthValidator,
+    pattern: patternValidator,
+    format: formatValidator,
+    contentEncoding: contentEncodingValidator,
+    contentMediaType: contentMediaTypeValidator,
+    // array validators
+    additionalItems: additionalItemsValidator,
+    items: itemsValidator,
+    prefixItems: prefixItemsValidator,
+    maxItems: maxItemsValidator,
+    minItems: minItemsValidator,
+    uniqueItems: uniqueItemsValidator,
+    contains: containsValidator,
+    maxContains: maxContainsValidator,
+    minContains: minContainsValidator,
+    unevaluatedItems: unevaluatedItemsValidator,
+    // object validators
+    maxProperties: maxPropertiesValidator,
+    minProperties: minPropertiesValidator,
+    required: requiredValidator,
+    additionalProperties: additionalPropertiesValidator,
+    patternProperties: patternPropertiesValidator,
+    properties: propertiesValidator,
+    dependencies: dependenciesValidator,
+    dependentSchemas: dependentSchemasValidator,
+    dependentRequired: dependentRequiredValidator,
+    propertyNames: propertyNamesValidator,
+    unevaluatedProperties: unevaluatedPropertiesValidator,
+    // combinator validators
+    allOf: allOfValidator,
+    anyOf: anyOfValidator,
+    oneOf: oneOfValidator,
+    not: notValidator,
+    if: ifValidator,
+    then: thenValidator,
+    else: elseValidator,
+    // misc
+    definitions: definitionsValidator,
 };
+// ---------------------------------------------------------------------------
+// recurseArray
+// ---------------------------------------------------------------------------
 const recurseArray = function (report, schema, json) {
     // http://json-schema.org/latest/json-schema-validation.html#rfc.section.8.2
-    let idx = json.length;
+    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');
+    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]);
+                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]);
+                report.schemaPath.pop();
+                report.path.pop();
+            }
+        }
+        return;
+    }
     // If "items" is an array, this situation, the schema depends on the index:
     // if the index is less than, or equal to, the size of "items",
     // the child instance must be valid against the corresponding schema in the "items" array;
     // otherwise, it must be valid against the schema defined by "additionalItems".
     if (Array.isArray(schema.items)) {
-        while (idx--) {
+        for (let idx = 0; idx < json.length; idx++) {
             // equal to doesn't make sense here
             if (idx < schema.items.length) {
                 report.path.push(idx);
@@ -712,7 +475,7 @@ const recurseArray = function (report, schema, json) {
     else if (typeof schema.items === 'object' || typeof schema.items === 'boolean') {
         // If items is a schema, then the child instance must be valid against this schema,
         // regardless of its index, and regardless of the value of "additionalItems".
-        while (idx--) {
+        for (let idx = 0; idx < json.length; idx++) {
             report.path.push(idx);
             // Track schema path for array items validation
             report.schemaPath.push('items');
@@ -722,6 +485,9 @@ const recurseArray = function (report, schema, json) {
         }
     }
 };
+// ---------------------------------------------------------------------------
+// recurseObject
+// ---------------------------------------------------------------------------
 const recurseObject = function (report, schema, json) {
     // 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.
@@ -736,19 +502,16 @@ const recurseObject = function (report, schema, json) {
     const pp = schema.patternProperties ? Object.keys(schema.patternProperties) : [];
     // m - The property name of the child.
     const keys = Object.keys(json);
-    let idx = keys.length;
-    while (idx--) {
-        const m = keys[idx], propertyValue = json[m];
+    for (const m of keys) {
+        const propertyValue = json[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.indexOf(m) !== -1) {
+        if (p.includes(m)) {
             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".
-        let idx2 = pp.length;
-        while (idx2--) {
-            const regexString = pp[idx2];
+        for (const regexString of pp) {
             const result = compileSchemaRegex(regexString);
             if (result.ok && result.value.test(m) === true) {
                 s.push(schema.patternProperties[regexString]);
@@ -762,11 +525,10 @@ const recurseObject = function (report, schema, json) {
         // if s is empty in this stage, no additionalProperties are allowed
         // report.expect(s.length !== 0, 'E001', m);
         // Instance property value must pass all schemas from s
-        idx2 = s.length;
-        while (idx2--) {
+        for (const schema_s of s) {
             report.path.push(m);
             // Track schema path for properties validation
-            if (p.indexOf(m) !== -1) {
+            if (p.includes(m)) {
                 // This is a defined property
                 report.schemaPath.push('properties');
                 report.schemaPath.push(m);
@@ -775,15 +537,18 @@ const recurseObject = function (report, schema, json) {
                 // This is additionalProperties or patternProperties
                 report.schemaPath.push('additionalProperties');
             }
-            validate.call(this, report, s[idx2], propertyValue);
+            validate.call(this, report, schema_s, propertyValue);
             report.path.pop();
             report.schemaPath.pop();
-            if (p.indexOf(m) !== -1) {
+            if (p.includes(m)) {
                 report.schemaPath.pop(); // pop the property name for defined properties
             }
         }
     }
 };
+// ---------------------------------------------------------------------------
+// validate — main entry point
+// ---------------------------------------------------------------------------
 export function validate(report, schema, json) {
     report.commonErrorMessage = 'JSON_OBJECT_VALIDATION_FAILED';
     if (schema === true) {
@@ -809,50 +574,134 @@ export function validate(report, schema, json) {
         report.rootSchema = schema;
         isRoot = true;
     }
+    const recursiveAnchorStack = report.__$recursiveAnchorStack;
+    const dynamicScopeStack = report.__$dynamicScopeStack;
+    let pushedRecursiveAnchor = false;
+    let pushedDynamicScope = false;
+    const schemaId = getId(schema);
+    const schemaResourceRoot = schema.__$resourceRoot;
+    const dynamicScopeEntry = schemaResourceRoot || (isRoot || typeof schemaId === 'string' ? schema : undefined);
+    if (dynamicScopeEntry && dynamicScopeStack[dynamicScopeStack.length - 1] !== dynamicScopeEntry) {
+        dynamicScopeStack.push(dynamicScopeEntry);
+        pushedDynamicScope = true;
+    }
+    if (schema.$recursiveAnchor === true) {
+        recursiveAnchorStack.push(schema);
+        pushedRecursiveAnchor = true;
+    }
     // follow schema.$ref keys
     if (schema.$ref !== undefined) {
-        // avoid infinite loop with maxRefs
-        let maxRefs = 99;
-        while (schema.$ref && maxRefs > 0) {
+        const applySiblingKeywordsWithRef = this.options.version === 'draft2019-09' || this.options.version === 'draft2020-12';
+        if (applySiblingKeywordsWithRef) {
             if (!schema.__$refResolved) {
                 report.addError('REF_UNRESOLVED', [schema.$ref], undefined, schema);
-                break;
             }
-            else if (schema.__$refResolved === schema) {
-                break;
+            else {
+                validate.call(this, report, schema.__$refResolved, json);
+            }
+            keys = keys.filter((key) => key !== '$ref');
+        }
+        else {
+            // avoid infinite loop with maxRefs
+            let maxRefs = 99;
+            while (schema.$ref && maxRefs > 0) {
+                if (!schema.__$refResolved) {
+                    report.addError('REF_UNRESOLVED', [schema.$ref], undefined, schema);
+                    break;
+                }
+                else if (schema.__$refResolved === schema) {
+                    break;
+                }
+                else {
+                    schema = schema.__$refResolved;
+                    keys = Object.keys(schema);
+                }
+                maxRefs--;
+            }
+            if (maxRefs === 0) {
+                throw new Error('Circular dependency by $ref references!');
+            }
+            // Reset schema path for referenced schema - paths are relative to the referenced schema
+            report.schemaPath = [];
+        }
+    }
+    // follow schema.$recursiveRef keys
+    if (schema.$recursiveRef !== undefined) {
+        const applySiblingKeywordsWithRecursiveRef = this.options.version === 'draft2019-09' || this.options.version === 'draft2020-12';
+        if (applySiblingKeywordsWithRecursiveRef) {
+            const recursiveRefTarget = resolveRecursiveRef(schema, recursiveAnchorStack);
+            if (!recursiveRefTarget) {
+                report.addError('REF_UNRESOLVED', [schema.$recursiveRef], undefined, schema);
             }
             else {
-                schema = schema.__$refResolved;
-                keys = Object.keys(schema);
+                validate.call(this, report, recursiveRefTarget, json);
             }
-            maxRefs--;
+            keys = keys.filter((key) => key !== '$recursiveRef');
         }
-        if (maxRefs === 0) {
-            throw new Error('Circular dependency by $ref references!');
+    }
+    // follow schema.$dynamicRef keys
+    if (schema.$dynamicRef !== undefined) {
+        const applySiblingKeywordsWithDynamicRef = this.options.version === 'draft2020-12';
+        if (applySiblingKeywordsWithDynamicRef) {
+            const dynamicRefTarget = resolveDynamicRef(schema, dynamicScopeStack);
+            if (typeof dynamicRefTarget === 'undefined') {
+                report.addError('REF_UNRESOLVED', [schema.$dynamicRef], undefined, schema);
+            }
+            else {
+                validate.call(this, report, dynamicRefTarget, json);
+            }
+            keys = keys.filter((key) => key !== '$dynamicRef');
         }
-        // Reset schema path for referenced schema - paths are relative to the referenced schema
-        report.schemaPath = [];
+    }
+    const validationVocabularyEnabled = isValidationVocabularyEnabled(schema, report, this.options.version);
+    if (!validationVocabularyEnabled) {
+        keys = keys.filter((key) => !VALIDATION_VOCAB_KEYWORDS.has(key));
     }
     // type checking first
-    if (schema.type) {
+    if (validationVocabularyEnabled && schema.type) {
         keys.splice(keys.indexOf('type'), 1);
         report.schemaPath.push('type');
         JsonValidators.type.call(this, report, schema, json);
         report.schemaPath.pop();
         if (report.errors.length && this.options.breakOnFirstError) {
+            if (pushedRecursiveAnchor) {
+                recursiveAnchorStack.pop();
+            }
+            if (pushedDynamicScope) {
+                dynamicScopeStack.pop();
+            }
             return false;
         }
     }
     // now iterate all the keys in schema and execute validation methods
-    let idx = keys.length;
-    while (idx--) {
-        if (JsonValidators[keys[idx]]) {
-            JsonValidators[keys[idx]].call(this, report, schema, json);
+    // Defer unevaluatedItems/unevaluatedProperties to run after other validators,
+    // so combinator validation results are cached and available for annotation collection
+    const deferredUnevaluatedKeys = [];
+    for (const key of keys) {
+        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) {
                 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) {
+            const validator = JsonValidators[key];
+            if (validator) {
+                validator.call(this, report, schema, json);
+                if (report.errors.length && this.options.breakOnFirstError) {
+                    break;
+                }
+            }
+        }
+    }
     if (report.errors.length === 0 || this.options.breakOnFirstError === false) {
         if (Array.isArray(json)) {
             recurseArray.call(this, report, schema, json);
@@ -864,6 +713,12 @@ export function validate(report, schema, json) {
     if (typeof this.options.customValidator === 'function') {
         this.options.customValidator.call(this, report, schema, json);
     }
+    if (pushedRecursiveAnchor) {
+        recursiveAnchorStack.pop();
+    }
+    if (pushedDynamicScope) {
+        dynamicScopeStack.pop();
+    }
     // we don't need the root pointer anymore
     if (isRoot) {
         report.rootSchema = undefined;