vscode-json-languageservice 5.7.2 → 6.0.0-next.2

package/lib/esm/parser/jsonParser.js

@@ -3,16 +3,19 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 import * as Json from 'jsonc-parser';
-import { isNumber, equals, isBoolean, isString, isDefined, isObject } from '../utils/objects';
-import { extendedRegExp, stringLength } from '../utils/strings';
-import { ErrorCode, Diagnostic, DiagnosticSeverity, Range, SchemaDraft } from '../jsonLanguageTypes';
+import { isNumber, equals, isBoolean, isString, isDefined, isObject } from '../utils/objects.js';
+import { extendedRegExp, stringLength } from '../utils/strings.js';
+import { ErrorCode, Diagnostic, DiagnosticSeverity, Range, SchemaDraft } from '../jsonLanguageTypes.js';
 import { URI } from 'vscode-uri';
+import { isKeywordEnabled, isFormatAssertionEnabled } from '../services/vocabularies.js';
 import * as l10n from '@vscode/l10n';
 const formats = {
     'color-hex': { errorMessage: l10n.t('Invalid color format. Use #RGB, #RGBA, #RRGGBB or #RRGGBBAA.'), pattern: /^#([0-9A-Fa-f]{3,4}|([0-9A-Fa-f]{2}){3,4})$/ },
     'date-time': { errorMessage: l10n.t('String is not a RFC3339 date-time.'), pattern: /^(\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])T([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9]|60)(\.[0-9]+)?(Z|(\+|-)([01][0-9]|2[0-3]):([0-5][0-9]))$/i },
     'date': { errorMessage: l10n.t('String is not a RFC3339 date.'), pattern: /^(\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])$/i },
     'time': { errorMessage: l10n.t('String is not a RFC3339 time.'), pattern: /^([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9]|60)(\.[0-9]+)?(Z|(\+|-)([01][0-9]|2[0-3]):([0-5][0-9]))$/i },
+    'duration': { errorMessage: l10n.t('String is not an ISO 8601 duration.'), pattern: /^P(?!$)(\d+Y)?(\d+M)?(\d+W)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+(\.\d+)?S)?)?$/ },
+    'uuid': { errorMessage: l10n.t('String is not a valid UUID.'), pattern: /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i },
     'email': { errorMessage: l10n.t('String is not an e-mail address.'), pattern: /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z0-9-]+\.)+[a-zA-Z]{2,}))$/ },
     'hostname': { errorMessage: l10n.t('String is not a hostname.'), pattern: /^(?=.{1,253}\.?$)[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[-0-9a-z]{0,61}[0-9a-z])?)*\.?$/i },
     'ipv4': { errorMessage: l10n.t('String is not an IPv4 address.'), pattern: /^(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$/ },
@@ -130,8 +133,10 @@ const schemaDraftFromId = {
     'https://json-schema.org/draft/2020-12/schema': SchemaDraft.v2020_12
 };
 class EvaluationContext {
-    constructor(schemaDraft) {
+    constructor(schemaDraft, activeVocabularies, explicitSchemaDraft) {
         this.schemaDraft = schemaDraft;
+        this.activeVocabularies = activeVocabularies;
+        this.explicitSchemaDraft = explicitSchemaDraft;
     }
 }
 class SchemaCollector {
@@ -264,10 +269,14 @@ export class JSONDocument {
             doVisit(this.root);
         }
     }
-    validate(textDocument, schema, severity = DiagnosticSeverity.Warning, schemaDraft) {
+    validate(textDocument, schema, severity = DiagnosticSeverity.Warning, schemaDraft, activeVocabularies) {
         if (this.root && schema) {
             const validationResult = new ValidationResult();
-            validate(this.root, schema, validationResult, NoOpSchemaCollector.instance, new EvaluationContext(schemaDraft ?? getSchemaDraft(schema)));
+            const { explicitDraft, effectiveDraft } = resolveDrafts(schema, schemaDraft);
+            const context = new EvaluationContext(effectiveDraft, activeVocabularies, explicitDraft);
+            const schemaStack = [];
+            const schemaRoots = [schema];
+            validate(this.root, schema, validationResult, NoOpSchemaCollector.instance, context, schemaStack, schemaRoots);
             return validationResult.problems.map(p => {
                 const range = Range.create(textDocument.positionAt(p.location.offset), textDocument.positionAt(p.location.offset + p.location.length));
                 return Diagnostic.create(range, p.message, p.severity ?? severity, p.code);
@@ -275,32 +284,123 @@ export class JSONDocument {
         }
         return undefined;
     }
-    getMatchingSchemas(schema, focusOffset = -1, exclude) {
+    getMatchingSchemas(schema, focusOffset = -1, exclude, activeVocabularies) {
         if (this.root && schema) {
             const matchingSchemas = new SchemaCollector(focusOffset, exclude);
-            const schemaDraft = getSchemaDraft(schema);
-            const context = new EvaluationContext(schemaDraft);
-            validate(this.root, schema, new ValidationResult(), matchingSchemas, context);
+            const { explicitDraft, effectiveDraft } = resolveDrafts(schema);
+            const context = new EvaluationContext(effectiveDraft, activeVocabularies, explicitDraft);
+            const schemaStack = [];
+            const schemaRoots = [schema];
+            validate(this.root, schema, new ValidationResult(), matchingSchemas, context, schemaStack, schemaRoots);
             return matchingSchemas.schemas;
         }
         return [];
     }
 }
-function getSchemaDraft(schema, fallBack = SchemaDraft.v2020_12) {
-    let schemaId = schema.$schema;
-    if (schemaId) {
-        return getSchemaDraftFromId(schemaId) ?? fallBack;
-    }
-    return fallBack;
+/*
+ * Resolves the schema draft versions for validation.
+ * - explicitDraft: the draft explicitly declared via $schema or passed as an override.
+ *   Undefined when no $schema is present and no override is provided.
+ * - effectiveDraft: the draft used for keyword gating, defaulting to 2020-12.
+ * These are tracked separately so that behaviors like format assertion can
+ * distinguish "explicitly 2020-12" (annotation-only per spec) from
+ * "no $schema, defaulting to 2020-12" (asserts for backward compatibility).
+ */
+function resolveDrafts(schema, schemaDraftOverride) {
+    const explicitDraft = schemaDraftOverride ?? (schema.$schema ? getSchemaDraftFromId(schema.$schema) : undefined);
+    const effectiveDraft = explicitDraft ?? SchemaDraft.v2020_12;
+    return { explicitDraft, effectiveDraft };
 }
-function validate(n, schema, validationResult, matchingSchemas, context) {
+// Keywords introduced in 2019-09 (not available in draft-07 and earlier)
+const keywords201909 = new Set([
+    'dependentRequired', 'dependentSchemas',
+    'unevaluatedProperties', 'unevaluatedItems',
+    'minContains', 'maxContains'
+]);
+function validate(n, schema, validationResult, matchingSchemas, context, schemaStack, schemaRoots) {
     if (!n || !matchingSchemas.include(n)) {
         return;
     }
     if (n.type === 'property') {
-        return validate(n.valueNode, schema, validationResult, matchingSchemas, context);
+        return validate(n.valueNode, schema, validationResult, matchingSchemas, context, schemaStack, schemaRoots);
     }
     const node = n;
+    if (schema.$recursiveRef) {
+        const hasRecursiveAnchor = (s) => s.$recursiveAnchor === true;
+        const isSchemaRoot = (s) => s.$id || s.id || s.$originalId;
+        // Find nearest schema resource root
+        const currentResourceRoot = schemaStack.slice().reverse().find(isSchemaRoot);
+        // If current resource has $recursiveAnchor, find first $recursiveAnchor in stack
+        // Otherwise use current resource root or fall back to document root
+        const targetSchema = (currentResourceRoot && hasRecursiveAnchor(currentResourceRoot))
+            ? schemaStack.find(hasRecursiveAnchor)
+            : currentResourceRoot ?? schemaRoots[0];
+        // Validate against the target schema (avoiding infinite loop).
+        // Fall through afterwards so sibling keywords (e.g. unevaluatedProperties)
+        // are still evaluated against this node, accumulating processedProperties.
+        if (targetSchema && targetSchema !== schema) {
+            validate(node, targetSchema, validationResult, matchingSchemas, context, schemaStack, schemaRoots);
+        }
+    }
+    // Track schema document roots (schemas with $id or $originalId) if not already the root
+    const isNewRoot = (schema.$id || schema.id || schema.$originalId) && !schemaRoots.includes(schema);
+    if (isNewRoot) {
+        schemaRoots.push(schema);
+    }
+    // Push current schema to stack for $recursiveRef resolution
+    schemaStack.push(schema);
+    // 2020-12 $dynamicRef. The initial (static) target and the referenced plain-name
+    // fragment were recorded during schema resolution in $dynamicRefInfo (target and
+    // name). "Bookending": dynamic resolution applies only when that
+    // initial target is itself a $dynamicAnchor of the referenced name; then the
+    // reference resolves to the outermost matching $dynamicAnchor currently in the
+    // dynamic scope (schemaRoots, ordered outermost-first). Otherwise it behaves
+    // like a plain $ref to the initial target. This runs after the schemaRoots push
+    // so the resource that contains the $dynamicRef participates in its own
+    // dynamic-scope resolution.
+    const dynamicRefInfo = schema.$dynamicRefInfo;
+    const dynamicRefTarget = dynamicRefInfo?.target;
+    if (dynamicRefTarget !== undefined) {
+        let targetSchema = dynamicRefTarget;
+        const dynamicName = dynamicRefInfo?.name;
+        if (dynamicName !== undefined && dynamicRefTarget.$dynamicAnchor === dynamicName) {
+            for (const root of schemaRoots) {
+                const candidate = root.$anchorMaps?.dynamic.get(dynamicName);
+                if (candidate) {
+                    targetSchema = candidate;
+                    break;
+                }
+            }
+        }
+        // Validate the instance against the referenced schema, then fall through so
+        // that any sibling keywords on this same node are validated too: per 2020-12
+        // $dynamicRef is an applicator that applies alongside its siblings (like $ref),
+        // not a redirect that replaces them. The shared cleanup below pops the stack.
+        if (targetSchema && targetSchema !== schema) {
+            validate(node, targetSchema, validationResult, matchingSchemas, context, schemaStack, schemaRoots);
+        }
+    }
+    const enabled = (keyword) => {
+        // Draft-based keyword gating: keywords only exist in certain drafts.
+        // 'dependencies' was replaced by dependentRequired/dependentSchemas in 2019-09
+        if (keyword === 'dependencies') {
+            return context.schemaDraft <= SchemaDraft.v7;
+        }
+        // Keywords introduced in 2019-09 (not available in draft-07 and earlier)
+        if (keywords201909.has(keyword)) {
+            return context.schemaDraft >= SchemaDraft.v2019_09;
+        }
+        // 'prefixItems' was introduced in 2020-12
+        if (keyword === 'prefixItems') {
+            return context.schemaDraft >= SchemaDraft.v2020_12;
+        }
+        // Vocabulary-based filtering only applies for 2019-09+ (vocabulary is not a concept in older drafts)
+        if (context.schemaDraft >= SchemaDraft.v2019_09 && context.activeVocabularies) {
+            return isKeywordEnabled(keyword, context.activeVocabularies);
+        }
+        // No vocabulary info or pre-2019-09: enable all draft-appropriate keywords
+        return true;
+    };
     _validateNode();
     switch (node.type) {
         case 'object':
@@ -317,11 +417,17 @@ function validate(n, schema, validationResult, matchingSchemas, context) {
             break;
     }
     matchingSchemas.add({ node: node, schema: schema });
+    // Pop schema from stack when done
+    schemaStack.pop();
+    // Pop schema root if we pushed one
+    if (isNewRoot) {
+        schemaRoots.pop();
+    }
     function _validateNode() {
         function matchesType(type) {
             return node.type === type || (type === 'integer' && node.type === 'number' && node.isInteger);
         }
-        if (Array.isArray(schema.type)) {
+        if (Array.isArray(schema.type) && enabled('type')) {
             if (!schema.type.some(matchesType)) {
                 validationResult.problems.push({
                     location: { offset: node.offset, length: node.length },
@@ -329,7 +435,7 @@ function validate(n, schema, validationResult, matchingSchemas, context) {
                 });
             }
         }
-        else if (schema.type) {
+        else if (schema.type && !Array.isArray(schema.type) && enabled('type')) {
             if (!matchesType(schema.type)) {
                 validationResult.problems.push({
                     location: { offset: node.offset, length: node.length },
@@ -337,20 +443,20 @@ function validate(n, schema, validationResult, matchingSchemas, context) {
                 });
             }
         }
-        if (Array.isArray(schema.allOf)) {
+        if (Array.isArray(schema.allOf) && enabled('allOf')) {
             for (const subSchemaRef of schema.allOf) {
                 const subValidationResult = new ValidationResult();
                 const subMatchingSchemas = matchingSchemas.newSub();
-                validate(node, asSchema(subSchemaRef), subValidationResult, subMatchingSchemas, context);
+                validate(node, asSchema(subSchemaRef), subValidationResult, subMatchingSchemas, context, schemaStack, schemaRoots);
                 validationResult.merge(subValidationResult);
                 matchingSchemas.merge(subMatchingSchemas);
             }
         }
         const notSchema = asSchema(schema.not);
-        if (notSchema) {
+        if (notSchema && enabled('not')) {
             const subValidationResult = new ValidationResult();
             const subMatchingSchemas = matchingSchemas.newSub();
-            validate(node, notSchema, subValidationResult, subMatchingSchemas, context);
+            validate(node, notSchema, subValidationResult, subMatchingSchemas, context, schemaStack, schemaRoots);
             if (!subValidationResult.hasProblems()) {
                 validationResult.problems.push({
                     location: { offset: node.offset, length: node.length },
@@ -371,7 +477,7 @@ function validate(n, schema, validationResult, matchingSchemas, context) {
                 const subSchema = asSchema(subSchemaRef);
                 const subValidationResult = new ValidationResult();
                 const subMatchingSchemas = matchingSchemas.newSub();
-                validate(node, subSchema, subValidationResult, subMatchingSchemas, context);
+                validate(node, subSchema, subValidationResult, subMatchingSchemas, context, schemaStack, schemaRoots);
                 if (!subValidationResult.hasProblems()) {
                     matches.push(subSchema);
                 }
@@ -413,16 +519,16 @@ function validate(n, schema, validationResult, matchingSchemas, context) {
             }
             return matches.length;
         };
-        if (Array.isArray(schema.anyOf)) {
+        if (Array.isArray(schema.anyOf) && enabled('anyOf')) {
             testAlternatives(schema.anyOf, false);
         }
-        if (Array.isArray(schema.oneOf)) {
+        if (Array.isArray(schema.oneOf) && enabled('oneOf')) {
             testAlternatives(schema.oneOf, true);
         }
         const testBranch = (schema) => {
             const subValidationResult = new ValidationResult();
             const subMatchingSchemas = matchingSchemas.newSub();
-            validate(node, asSchema(schema), subValidationResult, subMatchingSchemas, context);
+            validate(node, asSchema(schema), subValidationResult, subMatchingSchemas, context, schemaStack, schemaRoots);
             validationResult.merge(subValidationResult);
             matchingSchemas.merge(subMatchingSchemas);
         };
@@ -430,10 +536,12 @@ function validate(n, schema, validationResult, matchingSchemas, context) {
             const subSchema = asSchema(ifSchema);
             const subValidationResult = new ValidationResult();
             const subMatchingSchemas = matchingSchemas.newSub();
-            validate(node, subSchema, subValidationResult, subMatchingSchemas, context);
+            validate(node, subSchema, subValidationResult, subMatchingSchemas, context, schemaStack, schemaRoots);
             matchingSchemas.merge(subMatchingSchemas);
-            validationResult.mergeProcessedProperties(subValidationResult);
+            // if passed: merge properties from if;
+            // otherwise don't merge properties from if, only from else
             if (!subValidationResult.hasProblems()) {
+                validationResult.mergeProcessedProperties(subValidationResult);
                 if (thenSchema) {
                     testBranch(thenSchema);
                 }
@@ -443,10 +551,10 @@ function validate(n, schema, validationResult, matchingSchemas, context) {
             }
         };
         const ifSchema = asSchema(schema.if);
-        if (ifSchema) {
+        if (ifSchema && enabled('if')) {
             testCondition(ifSchema, asSchema(schema.then), asSchema(schema.else));
         }
-        if (Array.isArray(schema.enum)) {
+        if (Array.isArray(schema.enum) && enabled('enum')) {
             const val = getNodeValue(node);
             let enumValueMatch = false;
             for (const e of schema.enum) {
@@ -465,7 +573,7 @@ function validate(n, schema, validationResult, matchingSchemas, context) {
                 });
             }
         }
-        if (isDefined(schema.const)) {
+        if (isDefined(schema.const) && enabled('const')) {
             const val = getNodeValue(node);
             if (!equals(val, schema.const)) {
                 validationResult.problems.push({
@@ -514,6 +622,18 @@ function validate(n, schema, validationResult, matchingSchemas, context) {
                         }
                         valueMap.get(schema.const).push(i);
                     }
+                    else if (schema.enum && Array.isArray(schema.enum)) {
+                        for (const enumValue of schema.enum) {
+                            if (!constMap.has(key)) {
+                                constMap.set(key, new Map());
+                            }
+                            const valueMap = constMap.get(key);
+                            if (!valueMap.has(enumValue)) {
+                                valueMap.set(enumValue, []);
+                            }
+                            valueMap.get(enumValue).push(i);
+                        }
+                    }
                 });
             }
             return constMap;
@@ -566,7 +686,7 @@ function validate(n, schema, validationResult, matchingSchemas, context) {
             };
         }
         ;
-        if (isNumber(schema.multipleOf)) {
+        if (isNumber(schema.multipleOf) && enabled('multipleOf')) {
             let remainder = -1;
             if (Number.isInteger(schema.multipleOf)) {
                 remainder = val % schema.multipleOf;
@@ -608,28 +728,28 @@ function validate(n, schema, validationResult, matchingSchemas, context) {
             return undefined;
         }
         const exclusiveMinimum = getExclusiveLimit(schema.minimum, schema.exclusiveMinimum);
-        if (isNumber(exclusiveMinimum) && val <= exclusiveMinimum) {
+        if (isNumber(exclusiveMinimum) && val <= exclusiveMinimum && enabled('exclusiveMinimum')) {
             validationResult.problems.push({
                 location: { offset: node.offset, length: node.length },
                 message: l10n.t('Value is below the exclusive minimum of {0}.', exclusiveMinimum)
             });
         }
         const exclusiveMaximum = getExclusiveLimit(schema.maximum, schema.exclusiveMaximum);
-        if (isNumber(exclusiveMaximum) && val >= exclusiveMaximum) {
+        if (isNumber(exclusiveMaximum) && val >= exclusiveMaximum && enabled('exclusiveMaximum')) {
             validationResult.problems.push({
                 location: { offset: node.offset, length: node.length },
                 message: l10n.t('Value is above the exclusive maximum of {0}.', exclusiveMaximum)
             });
         }
         const minimum = getLimit(schema.minimum, schema.exclusiveMinimum);
-        if (isNumber(minimum) && val < minimum) {
+        if (isNumber(minimum) && val < minimum && enabled('minimum')) {
             validationResult.problems.push({
                 location: { offset: node.offset, length: node.length },
                 message: l10n.t('Value is below the minimum of {0}.', minimum)
             });
         }
         const maximum = getLimit(schema.maximum, schema.exclusiveMaximum);
-        if (isNumber(maximum) && val > maximum) {
+        if (isNumber(maximum) && val > maximum && enabled('maximum')) {
             validationResult.problems.push({
                 location: { offset: node.offset, length: node.length },
                 message: l10n.t('Value is above the maximum of {0}.', maximum)
@@ -637,19 +757,19 @@ function validate(n, schema, validationResult, matchingSchemas, context) {
         }
     }
     function _validateStringNode(node) {
-        if (isNumber(schema.minLength) && stringLength(node.value) < schema.minLength) {
+        if (isNumber(schema.minLength) && stringLength(node.value) < schema.minLength && enabled('minLength')) {
             validationResult.problems.push({
                 location: { offset: node.offset, length: node.length },
                 message: l10n.t('String is shorter than the minimum length of {0}.', schema.minLength)
             });
         }
-        if (isNumber(schema.maxLength) && stringLength(node.value) > schema.maxLength) {
+        if (isNumber(schema.maxLength) && stringLength(node.value) > schema.maxLength && enabled('maxLength')) {
             validationResult.problems.push({
                 location: { offset: node.offset, length: node.length },
                 message: l10n.t('String is longer than the maximum length of {0}.', schema.maxLength)
             });
         }
-        if (isString(schema.pattern)) {
+        if (isString(schema.pattern) && enabled('pattern')) {
             const regex = extendedRegExp(schema.pattern);
             if (regex && !(regex.test(node.value))) {
                 validationResult.problems.push({
@@ -658,7 +778,8 @@ function validate(n, schema, validationResult, matchingSchemas, context) {
                 });
             }
         }
-        if (schema.format) {
+        // Only validate format if format-assertion vocabulary is active (not annotation-only)
+        if (schema.format && enabled('format') && isFormatAssertionEnabled(context.activeVocabularies, context.explicitSchemaDraft)) {
             switch (schema.format) {
                 case 'uri':
                 case 'uri-reference':
@@ -688,6 +809,8 @@ function validate(n, schema, validationResult, matchingSchemas, context) {
                 case 'date-time':
                 case 'date':
                 case 'time':
+                case 'duration':
+                case 'uuid':
                 case 'email':
                 case 'hostname':
                 case 'ipv4':
@@ -723,7 +846,7 @@ function validate(n, schema, validationResult, matchingSchemas, context) {
                 const itemValidationResult = new ValidationResult();
                 const item = node.items[index];
                 if (item) {
-                    validate(item, subSchema, itemValidationResult, matchingSchemas, context);
+                    validate(item, subSchema, itemValidationResult, matchingSchemas, context, schemaStack, schemaRoots);
                     validationResult.mergePropertyMatch(itemValidationResult);
                 }
                 validationResult.processedProperties.add(String(index));
@@ -745,19 +868,19 @@ function validate(n, schema, validationResult, matchingSchemas, context) {
             else {
                 for (; index < node.items.length; index++) {
                     const itemValidationResult = new ValidationResult();
-                    validate(node.items[index], additionalItemSchema, itemValidationResult, matchingSchemas, context);
+                    validate(node.items[index], additionalItemSchema, itemValidationResult, matchingSchemas, context, schemaStack, schemaRoots);
                     validationResult.mergePropertyMatch(itemValidationResult);
                     validationResult.processedProperties.add(String(index));
                 }
             }
         }
         const containsSchema = asSchema(schema.contains);
-        if (containsSchema) {
+        if (containsSchema && enabled('contains')) {
             let containsCount = 0;
             for (let index = 0; index < node.items.length; index++) {
                 const item = node.items[index];
                 const itemValidationResult = new ValidationResult();
-                validate(item, containsSchema, itemValidationResult, NoOpSchemaCollector.instance, context);
+                validate(item, containsSchema, itemValidationResult, NoOpSchemaCollector.instance, context, schemaStack, schemaRoots);
                 if (!itemValidationResult.hasProblems()) {
                     containsCount++;
                     if (context.schemaDraft >= SchemaDraft.v2020_12) {
@@ -771,13 +894,13 @@ function validate(n, schema, validationResult, matchingSchemas, context) {
                     message: schema.errorMessage || l10n.t('Array does not contain required item.')
                 });
             }
-            if (isNumber(schema.minContains) && containsCount < schema.minContains) {
+            if (isNumber(schema.minContains) && containsCount < schema.minContains && enabled('minContains')) {
                 validationResult.problems.push({
                     location: { offset: node.offset, length: node.length },
                     message: schema.errorMessage || l10n.t('Array has too few items that match the contains contraint. Expected {0} or more.', schema.minContains)
                 });
             }
-            if (isNumber(schema.maxContains) && containsCount > schema.maxContains) {
+            if (isNumber(schema.maxContains) && containsCount > schema.maxContains && enabled('maxContains')) {
                 validationResult.problems.push({
                     location: { offset: node.offset, length: node.length },
                     message: schema.errorMessage || l10n.t('Array has too many items that match the contains contraint. Expected {0} or less.', schema.maxContains)
@@ -785,7 +908,7 @@ function validate(n, schema, validationResult, matchingSchemas, context) {
             }
         }
         const unevaluatedItems = schema.unevaluatedItems;
-        if (unevaluatedItems !== undefined) {
+        if (unevaluatedItems !== undefined && enabled('unevaluatedItems')) {
             for (let i = 0; i < node.items.length; i++) {
                 if (!validationResult.processedProperties.has(String(i))) {
                     if (unevaluatedItems === false) {
@@ -796,7 +919,7 @@ function validate(n, schema, validationResult, matchingSchemas, context) {
                     }
                     else {
                         const itemValidationResult = new ValidationResult();
-                        validate(node.items[i], schema.unevaluatedItems, itemValidationResult, matchingSchemas, context);
+                        validate(node.items[i], schema.unevaluatedItems, itemValidationResult, matchingSchemas, context, schemaStack, schemaRoots);
                         validationResult.mergePropertyMatch(itemValidationResult);
                     }
                 }
@@ -804,19 +927,19 @@ function validate(n, schema, validationResult, matchingSchemas, context) {
                 validationResult.propertiesValueMatches++;
             }
         }
-        if (isNumber(schema.minItems) && node.items.length < schema.minItems) {
+        if (isNumber(schema.minItems) && node.items.length < schema.minItems && enabled('minItems')) {
             validationResult.problems.push({
                 location: { offset: node.offset, length: node.length },
                 message: l10n.t('Array has too few items. Expected {0} or more.', schema.minItems)
             });
         }
-        if (isNumber(schema.maxItems) && node.items.length > schema.maxItems) {
+        if (isNumber(schema.maxItems) && node.items.length > schema.maxItems && enabled('maxItems')) {
             validationResult.problems.push({
                 location: { offset: node.offset, length: node.length },
                 message: l10n.t('Array has too many items. Expected {0} or fewer.', schema.maxItems)
             });
         }
-        if (schema.uniqueItems === true) {
+        if (schema.uniqueItems === true && enabled('uniqueItems')) {
             const values = getNodeValue(node);
             function hasDuplicates() {
                 for (let i = 0; i < values.length - 1; i++) {
@@ -845,13 +968,11 @@ function validate(n, schema, validationResult, matchingSchemas, context) {
             seenKeys[key] = propertyNode.valueNode;
             unprocessedProperties.add(key);
         }
-        if (Array.isArray(schema.required)) {
+        if (Array.isArray(schema.required) && enabled('required')) {
             for (const propertyName of schema.required) {
                 if (!seenKeys[propertyName]) {
-                    const keyNode = node.parent && node.parent.type === 'property' && node.parent.keyNode;
-                    const location = keyNode ? { offset: keyNode.offset, length: keyNode.length } : { offset: node.offset, length: 1 };
                     validationResult.problems.push({
-                        location: location,
+                        location: { offset: node.offset, length: node.length },
                         message: l10n.t('Missing property "{0}".', propertyName)
                     });
                 }
@@ -861,7 +982,7 @@ function validate(n, schema, validationResult, matchingSchemas, context) {
             unprocessedProperties.delete(prop);
             validationResult.processedProperties.add(prop);
         };
-        if (schema.properties) {
+        if (schema.properties && enabled('properties')) {
             for (const propertyName of Object.keys(schema.properties)) {
                 propertyProcessed(propertyName);
                 const propertySchema = schema.properties[propertyName];
@@ -882,20 +1003,28 @@ function validate(n, schema, validationResult, matchingSchemas, context) {
                     }
                     else {
                         const propertyValidationResult = new ValidationResult();
-                        validate(child, propertySchema, propertyValidationResult, matchingSchemas, context);
+                        validate(child, propertySchema, propertyValidationResult, matchingSchemas, context, schemaStack, schemaRoots);
                         validationResult.mergePropertyMatch(propertyValidationResult);
                     }
                 }
             }
         }
-        if (schema.patternProperties) {
+        if (schema.patternProperties && enabled('patternProperties')) {
+            // Collect all properties matched by any pattern first
+            // A property must be validated against all patterns it matches
+            // Properties in `properties` can also match `patternProperties`, check all keys
+            const allPropertyNames = Object.keys(seenKeys);
+            const patternPropertyMatches = new Set();
             for (const propertyPattern of Object.keys(schema.patternProperties)) {
                 const regex = extendedRegExp(propertyPattern);
                 if (regex) {
-                    const processed = [];
-                    for (const propertyName of unprocessedProperties) {
+                    for (const propertyName of allPropertyNames) {
                         if (regex.test(propertyName)) {
-                            processed.push(propertyName);
+                            // Only mark as pattern match if not already in `properties`
+                            // for additionalProperties tracking
+                            if (unprocessedProperties.has(propertyName)) {
+                                patternPropertyMatches.add(propertyName);
+                            }
                             const child = seenKeys[propertyName];
                             if (child) {
                                 const propertySchema = schema.patternProperties[propertyPattern];
@@ -914,18 +1043,19 @@ function validate(n, schema, validationResult, matchingSchemas, context) {
                                 }
                                 else {
                                     const propertyValidationResult = new ValidationResult();
-                                    validate(child, propertySchema, propertyValidationResult, matchingSchemas, context);
+                                    validate(child, propertySchema, propertyValidationResult, matchingSchemas, context, schemaStack, schemaRoots);
                                     validationResult.mergePropertyMatch(propertyValidationResult);
                                 }
                             }
                         }
                     }
-                    processed.forEach(propertyProcessed);
                 }
             }
+            // Mark all matched properties as processed after all patterns have been checked
+            patternPropertyMatches.forEach(propertyProcessed);
         }
         const additionalProperties = schema.additionalProperties;
-        if (additionalProperties !== undefined) {
+        if (additionalProperties !== undefined && enabled('additionalProperties')) {
             for (const propertyName of unprocessedProperties) {
                 propertyProcessed(propertyName);
                 const child = seenKeys[propertyName];
@@ -939,14 +1069,32 @@ function validate(n, schema, validationResult, matchingSchemas, context) {
                     }
                     else if (additionalProperties !== true) {
                         const propertyValidationResult = new ValidationResult();
-                        validate(child, additionalProperties, propertyValidationResult, matchingSchemas, context);
+                        validate(child, additionalProperties, propertyValidationResult, matchingSchemas, context, schemaStack, schemaRoots);
                         validationResult.mergePropertyMatch(propertyValidationResult);
                     }
                 }
             }
         }
+        if (schema.dependentRequired && enabled('dependentRequired')) {
+            for (const key in schema.dependentRequired) {
+                const prop = seenKeys[key];
+                const propertyDeps = schema.dependentRequired[key];
+                if (prop && Array.isArray(propertyDeps)) {
+                    _validatePropertyDependencies(key, propertyDeps);
+                }
+            }
+        }
+        if (schema.dependentSchemas && enabled('dependentSchemas')) {
+            for (const key in schema.dependentSchemas) {
+                const prop = seenKeys[key];
+                const propertyDeps = schema.dependentSchemas[key];
+                if (prop) {
+                    _validatePropertyDependencies(key, propertyDeps);
+                }
+            }
+        }
         const unevaluatedProperties = schema.unevaluatedProperties;
-        if (unevaluatedProperties !== undefined) {
+        if (unevaluatedProperties !== undefined && enabled('unevaluatedProperties')) {
             const processed = [];
             for (const propertyName of unprocessedProperties) {
                 if (!validationResult.processedProperties.has(propertyName)) {
@@ -962,7 +1110,7 @@ function validate(n, schema, validationResult, matchingSchemas, context) {
                         }
                         else if (unevaluatedProperties !== true) {
                             const propertyValidationResult = new ValidationResult();
-                            validate(child, unevaluatedProperties, propertyValidationResult, matchingSchemas, context);
+                            validate(child, unevaluatedProperties, propertyValidationResult, matchingSchemas, context, schemaStack, schemaRoots);
                             validationResult.mergePropertyMatch(propertyValidationResult);
                         }
                     }
@@ -970,7 +1118,7 @@ function validate(n, schema, validationResult, matchingSchemas, context) {
             }
             processed.forEach(propertyProcessed);
         }
-        if (isNumber(schema.maxProperties)) {
+        if (isNumber(schema.maxProperties) && enabled('maxProperties')) {
             if (node.properties.length > schema.maxProperties) {
                 validationResult.problems.push({
                     location: { offset: node.offset, length: node.length },
@@ -978,7 +1126,7 @@ function validate(n, schema, validationResult, matchingSchemas, context) {
                 });
             }
         }
-        if (isNumber(schema.minProperties)) {
+        if (isNumber(schema.minProperties) && enabled('minProperties')) {
             if (node.properties.length < schema.minProperties) {
                 validationResult.problems.push({
                     location: { offset: node.offset, length: node.length },
@@ -986,25 +1134,7 @@ function validate(n, schema, validationResult, matchingSchemas, context) {
                 });
             }
         }
-        if (schema.dependentRequired) {
-            for (const key in schema.dependentRequired) {
-                const prop = seenKeys[key];
-                const propertyDeps = schema.dependentRequired[key];
-                if (prop && Array.isArray(propertyDeps)) {
-                    _validatePropertyDependencies(key, propertyDeps);
-                }
-            }
-        }
-        if (schema.dependentSchemas) {
-            for (const key in schema.dependentSchemas) {
-                const prop = seenKeys[key];
-                const propertyDeps = schema.dependentSchemas[key];
-                if (prop && isObject(propertyDeps)) {
-                    _validatePropertyDependencies(key, propertyDeps);
-                }
-            }
-        }
-        if (schema.dependencies) {
+        if (schema.dependencies && enabled('dependencies')) {
             for (const key in schema.dependencies) {
                 const prop = seenKeys[key];
                 if (prop) {
@@ -1013,11 +1143,11 @@ function validate(n, schema, validationResult, matchingSchemas, context) {
             }
         }
         const propertyNames = asSchema(schema.propertyNames);
-        if (propertyNames) {
+        if (propertyNames && enabled('propertyNames')) {
             for (const f of node.properties) {
                 const key = f.keyNode;
                 if (key) {
-                    validate(key, propertyNames, validationResult, matchingSchemas, context);
+                    validate(key, propertyNames, validationResult, matchingSchemas, context, schemaStack, schemaRoots);
                 }
             }
         }
@@ -1039,8 +1169,9 @@ function validate(n, schema, validationResult, matchingSchemas, context) {
                 const propertySchema = asSchema(propertyDep);
                 if (propertySchema) {
                     const propertyValidationResult = new ValidationResult();
-                    validate(node, propertySchema, propertyValidationResult, matchingSchemas, context);
+                    validate(node, propertySchema, propertyValidationResult, matchingSchemas, context, schemaStack, schemaRoots);
                     validationResult.mergePropertyMatch(propertyValidationResult);
+                    validationResult.mergeProcessedProperties(propertyValidationResult);
                 }
             }
         }