vscode-json-languageservice 5.6.3 → 5.7.0

package/CHANGELOG.md

@@ -1,3 +1,7 @@
+5.7.0 / 2026-01-12
+================
+* the error code for `SchemaResolveError` is now 0x10000 plus the error code returned by the request service.
+
 5.6.0 / 2025-05-28
 ================
  * added `Schema.enumSortTexts` and `Schema.enumDetails` to control the sort order and presentation of suggestions for enums

package/lib/esm/jsonLanguageTypes.d.ts

@@ -26,9 +26,10 @@ export declare enum ErrorCode {
     DuplicateKey = 520,
     CommentNotPermitted = 521,
     PropertyKeysMustBeDoublequoted = 528,
-    SchemaResolveError = 768,
-    SchemaUnsupportedFeature = 769
+    SchemaUnsupportedFeature = 769,
+    SchemaResolveError = 65536
 }
+export declare function isSchemaResolveError(code: number): boolean;
 export type ASTNode = ObjectASTNode | PropertyASTNode | ArrayASTNode | StringASTNode | NumberASTNode | BooleanASTNode | NullASTNode;
 export interface BaseASTNode {
     readonly type: 'object' | 'array' | 'property' | 'string' | 'number' | 'boolean' | 'null';
@@ -153,7 +154,8 @@ export interface WorkspaceContextService {
 }
 /**
  * The schema request service is used to fetch schemas. If successful, returns a resolved promise with the content of the schema.
- * In case of an error, returns a rejected promise with a displayable error string.
+ * In case of an error, returns a rejected promise with an Error object. If the type is of form { message: string, code: number }, the
+ * error code will be used for diagnostics.
  */
 export interface SchemaRequestService {
     (uri: string): PromiseLike<string>;

package/lib/esm/jsonLanguageTypes.js

@@ -29,9 +29,12 @@ export var ErrorCode;
     ErrorCode[ErrorCode["DuplicateKey"] = 520] = "DuplicateKey";
     ErrorCode[ErrorCode["CommentNotPermitted"] = 521] = "CommentNotPermitted";
     ErrorCode[ErrorCode["PropertyKeysMustBeDoublequoted"] = 528] = "PropertyKeysMustBeDoublequoted";
-    ErrorCode[ErrorCode["SchemaResolveError"] = 768] = "SchemaResolveError";
     ErrorCode[ErrorCode["SchemaUnsupportedFeature"] = 769] = "SchemaUnsupportedFeature";
+    ErrorCode[ErrorCode["SchemaResolveError"] = 65536] = "SchemaResolveError";
 })(ErrorCode || (ErrorCode = {}));
+export function isSchemaResolveError(code) {
+    return code >= ErrorCode.SchemaResolveError;
+}
 export var SchemaDraft;
 (function (SchemaDraft) {
     SchemaDraft[SchemaDraft["v3"] = 3] = "v3";

package/lib/esm/parser/jsonParser.js

@@ -364,9 +364,10 @@ function validate(n, schema, validationResult, matchingSchemas, context) {
         }
         const testAlternatives = (alternatives, maxOneMatch) => {
             const matches = [];
+            const alternativesToTest = _tryDiscriminatorOptimization(alternatives) ?? alternatives;
             // remember the best match that is used for error messages
             let bestMatch = undefined;
-            for (const subSchemaRef of alternatives) {
+            for (const subSchemaRef of alternativesToTest) {
                 const subSchema = asSchema(subSchemaRef);
                 const subValidationResult = new ValidationResult();
                 const subMatchingSchemas = matchingSchemas.newSub();
@@ -491,6 +492,70 @@ function validate(n, schema, validationResult, matchingSchemas, context) {
             });
         }
     }
+    function _tryDiscriminatorOptimization(alternatives) {
+        if (alternatives.length < 2) {
+            return undefined;
+        }
+        const buildConstMap = (getSchemas) => {
+            const constMap = new Map();
+            for (let i = 0; i < alternatives.length; i++) {
+                const schemas = getSchemas(asSchema(alternatives[i]), i);
+                if (!schemas) {
+                    return undefined; // Early exit if any alternative can't be processed
+                }
+                schemas.forEach(([key, schema]) => {
+                    if (schema.const !== undefined) {
+                        if (!constMap.has(key)) {
+                            constMap.set(key, new Map());
+                        }
+                        const valueMap = constMap.get(key);
+                        if (!valueMap.has(schema.const)) {
+                            valueMap.set(schema.const, []);
+                        }
+                        valueMap.get(schema.const).push(i);
+                    }
+                });
+            }
+            return constMap;
+        };
+        const findDiscriminator = (constMap, getValue) => {
+            for (const [key, valueMap] of constMap) {
+                const coveredAlts = new Set();
+                valueMap.forEach(indices => indices.forEach(idx => coveredAlts.add(idx)));
+                if (coveredAlts.size === alternatives.length) {
+                    const discriminatorValue = getValue(key);
+                    const matchingIndices = valueMap.get(discriminatorValue);
+                    if (matchingIndices?.length) {
+                        return matchingIndices.map(idx => alternatives[idx]);
+                    }
+                    break; // Found valid discriminator but no match
+                }
+            }
+            return undefined;
+        };
+        if (node.type === 'object' && node.properties?.length) {
+            const constMap = buildConstMap((schema) => schema.properties ? Object.entries(schema.properties).map(([k, v]) => [k, asSchema(v)]) : undefined);
+            if (constMap) {
+                return findDiscriminator(constMap, (propName) => {
+                    const prop = node.properties.find(p => p.keyNode.value === propName);
+                    return prop?.valueNode?.type === 'string' ? prop.valueNode.value : undefined;
+                });
+            }
+        }
+        else if (node.type === 'array' && node.items?.length) {
+            const constMap = buildConstMap((schema) => {
+                const itemSchemas = schema.prefixItems || (Array.isArray(schema.items) ? schema.items : undefined);
+                return itemSchemas ? itemSchemas.map((item, idx) => [idx, asSchema(item)]) : undefined;
+            });
+            if (constMap) {
+                return findDiscriminator(constMap, (itemIndex) => {
+                    const item = node.items[itemIndex];
+                    return item?.type === 'string' ? item.value : undefined;
+                });
+            }
+        }
+        return undefined;
+    }
     function _validateNumberNode(node) {
         const val = node.value;
         function normalizeFloats(float) {
@@ -952,7 +1017,7 @@ function validate(n, schema, validationResult, matchingSchemas, context) {
             for (const f of node.properties) {
                 const key = f.keyNode;
                 if (key) {
-                    validate(key, propertyNames, validationResult, NoOpSchemaCollector.instance, context);
+                    validate(key, propertyNames, validationResult, matchingSchemas, context);
                 }
             }
         }

package/lib/esm/services/jsonSchemaService.js

@@ -6,7 +6,7 @@ import * as Json from 'jsonc-parser';
 import { URI } from 'vscode-uri';
 import * as Strings from '../utils/strings';
 import { asSchema, getSchemaDraftFromId, normalizeId } from '../parser/jsonParser';
-import { SchemaDraft } from '../jsonLanguageTypes';
+import { SchemaDraft, ErrorCode } from '../jsonLanguageTypes';
 import * as l10n from '@vscode/l10n';
 import { createRegex } from '../utils/glob';
 import { isObject, isString } from '../utils/objects';
@@ -102,6 +102,9 @@ export class UnresolvedSchema {
         this.errors = errors;
     }
 }
+function toDiagnostic(message, code) {
+    return { message, code };
+}
 export class ResolvedSchema {
     constructor(schema, errors = [], warnings = [], schemaDraft) {
         this.schema = schema;
@@ -262,36 +265,45 @@ export class JSONSchemaService {
     loadSchema(url) {
         if (!this.requestService) {
             const errorMessage = l10n.t('Unable to load schema from \'{0}\'. No schema request service available', toDisplayString(url));
-            return this.promise.resolve(new UnresolvedSchema({}, [errorMessage]));
+            return this.promise.resolve(new UnresolvedSchema({}, [toDiagnostic(errorMessage, ErrorCode.SchemaResolveError)]));
         }
         return this.requestService(url).then(content => {
             if (!content) {
                 const errorMessage = l10n.t('Unable to load schema from \'{0}\': No content.', toDisplayString(url));
-                return new UnresolvedSchema({}, [errorMessage]);
+                return new UnresolvedSchema({}, [toDiagnostic(errorMessage, ErrorCode.SchemaResolveError)]);
             }
             const errors = [];
             if (content.charCodeAt(0) === 65279) {
-                errors.push(l10n.t('Problem reading content from \'{0}\': UTF-8 with BOM detected, only UTF 8 is allowed.', toDisplayString(url)));
+                errors.push(toDiagnostic(l10n.t('Problem reading content from \'{0}\': UTF-8 with BOM detected, only UTF 8 is allowed.', toDisplayString(url)), ErrorCode.SchemaResolveError));
                 content = content.trimStart();
             }
             let schemaContent = {};
             const jsonErrors = [];
             schemaContent = Json.parse(content, jsonErrors);
             if (jsonErrors.length) {
-                errors.push(l10n.t('Unable to parse content from \'{0}\': Parse error at offset {1}.', toDisplayString(url), jsonErrors[0].offset));
+                errors.push(toDiagnostic(l10n.t('Unable to parse content from \'{0}\': Parse error at offset {1}.', toDisplayString(url), jsonErrors[0].offset), ErrorCode.SchemaResolveError));
             }
             return new UnresolvedSchema(schemaContent, errors);
         }, (error) => {
-            let errorMessage = error.toString();
-            const errorSplit = error.toString().split('Error: ');
-            if (errorSplit.length > 1) {
-                // more concise error message, URL and context are attached by caller anyways
-                errorMessage = errorSplit[1];
+            let { message, code } = error;
+            if (typeof message !== 'string') {
+                let errorMessage = error.toString();
+                const errorSplit = error.toString().split('Error: ');
+                if (errorSplit.length > 1) {
+                    // more concise error message, URL and context are attached by caller anyways
+                    errorMessage = errorSplit[1];
+                }
+                if (Strings.endsWith(errorMessage, '.')) {
+                    errorMessage = errorMessage.substr(0, errorMessage.length - 1);
+                }
+                message = errorMessage;
             }
-            if (Strings.endsWith(errorMessage, '.')) {
-                errorMessage = errorMessage.substr(0, errorMessage.length - 1);
+            let errorCode = ErrorCode.SchemaResolveError;
+            if (typeof code === 'number' && code < 0x10000) {
+                errorCode += code;
             }
-            return new UnresolvedSchema({}, [l10n.t('Unable to load schema from \'{0}\': {1}.', toDisplayString(url), errorMessage)]);
+            const errorMessage = l10n.t('Unable to load schema from \'{0}\': {1}.', toDisplayString(url), message);
+            return new UnresolvedSchema({}, [toDiagnostic(errorMessage, errorCode)]);
         });
     }
     resolveSchemaContent(schemaToResolve, handle) {
@@ -299,7 +311,7 @@ export class JSONSchemaService {
         const schema = schemaToResolve.schema;
         const schemaDraft = schema.$schema ? getSchemaDraftFromId(schema.$schema) : undefined;
         if (schemaDraft === SchemaDraft.v3) {
-            return this.promise.resolve(new ResolvedSchema({}, [l10n.t("Draft-03 schemas are not supported.")], [], schemaDraft));
+            return this.promise.resolve(new ResolvedSchema({}, [toDiagnostic(l10n.t("Draft-03 schemas are not supported."), ErrorCode.SchemaUnsupportedFeature)], [], schemaDraft));
         }
         let usesUnsupportedFeatures = new Set();
         const contextService = this.contextService;
@@ -346,7 +358,8 @@ export class JSONSchemaService {
                 merge(target, section);
             }
             else {
-                resolveErrors.push(l10n.t('$ref \'{0}\' in \'{1}\' can not be resolved.', refSegment || '', sourceHandle.uri));
+                const message = l10n.t('$ref \'{0}\' in \'{1}\' can not be resolved.', refSegment || '', sourceHandle.uri);
+                resolveErrors.push(toDiagnostic(message, ErrorCode.SchemaResolveError));
             }
         };
         const resolveExternalLink = (node, uri, refSegment, parentHandle) => {
@@ -359,7 +372,8 @@ export class JSONSchemaService {
                 parentHandle.dependencies.add(uri);
                 if (unresolvedSchema.errors.length) {
                     const loc = refSegment ? uri + '#' + refSegment : uri;
-                    resolveErrors.push(l10n.t('Problems loading reference \'{0}\': {1}', loc, unresolvedSchema.errors[0]));
+                    const errorMessage = l10n.t('Problems loading reference \'{0}\': {1}', loc, unresolvedSchema.errors[0].message);
+                    resolveErrors.push(toDiagnostic(errorMessage, unresolvedSchema.errors[0].code));
                 }
                 mergeRef(node, unresolvedSchema.schema, referencedHandle, refSegment);
                 return resolveRefs(node, unresolvedSchema.schema, referencedHandle);
@@ -403,7 +417,7 @@ export class JSONSchemaService {
                 const anchor = isString(id) && id.charAt(0) === '#' ? id.substring(1) : next.$anchor;
                 if (anchor) {
                     if (result.has(anchor)) {
-                        resolveErrors.push(l10n.t('Duplicate anchor declaration: \'{0}\'', anchor));
+                        resolveErrors.push(toDiagnostic(l10n.t('Duplicate anchor declaration: \'{0}\'', anchor), ErrorCode.SchemaResolveError));
                     }
                     else {
                         result.set(anchor, next);
@@ -421,7 +435,7 @@ export class JSONSchemaService {
         return resolveRefs(schema, schema, handle).then(_ => {
             let resolveWarnings = [];
             if (usesUnsupportedFeatures.size) {
-                resolveWarnings.push(l10n.t('The schema uses meta-schema features ({0}) that are not yet supported by the validator.', Array.from(usesUnsupportedFeatures.keys()).join(', ')));
+                resolveWarnings.push(toDiagnostic(l10n.t('The schema uses meta-schema features ({0}) that are not yet supported by the validator.', Array.from(usesUnsupportedFeatures.keys()).join(', ')), ErrorCode.SchemaUnsupportedFeature));
             }
             return new ResolvedSchema(schema, resolveErrors, resolveWarnings, schemaDraft);
         });

package/lib/esm/services/jsonValidation.js

@@ -53,11 +53,11 @@ export class JSONValidation {
                     }
                 };
                 if (schema.errors.length) {
-                    addSchemaProblem(schema.errors[0], ErrorCode.SchemaResolveError);
+                    addSchemaProblem(schema.errors[0].message, schema.errors[0].code);
                 }
                 else if (schemaValidation) {
                     for (const warning of schema.warnings) {
-                        addSchemaProblem(warning, ErrorCode.SchemaUnsupportedFeature);
+                        addSchemaProblem(warning.message, warning.code);
                     }
                     const semanticErrors = jsonDocument.validate(textDocument, schema.schema, schemaValidation, documentSettings?.schemaDraft);
                     if (semanticErrors) {

package/lib/umd/jsonLanguageTypes.d.ts

@@ -26,9 +26,10 @@ export declare enum ErrorCode {
     DuplicateKey = 520,
     CommentNotPermitted = 521,
     PropertyKeysMustBeDoublequoted = 528,
-    SchemaResolveError = 768,
-    SchemaUnsupportedFeature = 769
+    SchemaUnsupportedFeature = 769,
+    SchemaResolveError = 65536
 }
+export declare function isSchemaResolveError(code: number): boolean;
 export type ASTNode = ObjectASTNode | PropertyASTNode | ArrayASTNode | StringASTNode | NumberASTNode | BooleanASTNode | NullASTNode;
 export interface BaseASTNode {
     readonly type: 'object' | 'array' | 'property' | 'string' | 'number' | 'boolean' | 'null';
@@ -153,7 +154,8 @@ export interface WorkspaceContextService {
 }
 /**
  * The schema request service is used to fetch schemas. If successful, returns a resolved promise with the content of the schema.
- * In case of an error, returns a rejected promise with a displayable error string.
+ * In case of an error, returns a rejected promise with an Error object. If the type is of form { message: string, code: number }, the
+ * error code will be used for diagnostics.
  */
 export interface SchemaRequestService {
     (uri: string): PromiseLike<string>;

package/lib/umd/jsonLanguageTypes.js

@@ -14,6 +14,7 @@
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.ClientCapabilities = exports.SchemaDraft = exports.ErrorCode = exports.DocumentHighlightKind = exports.VersionedTextDocumentIdentifier = exports.TextDocumentEdit = exports.CodeActionKind = exports.TextEdit = exports.WorkspaceEdit = exports.DocumentLink = exports.DocumentHighlight = exports.CodeAction = exports.Command = exports.CodeActionContext = exports.MarkedString = exports.Hover = exports.Location = exports.DocumentSymbol = exports.SymbolKind = exports.SymbolInformation = exports.InsertTextFormat = exports.CompletionItemTag = exports.CompletionList = exports.CompletionItemKind = exports.CompletionItem = exports.DiagnosticSeverity = exports.Diagnostic = exports.SelectionRange = exports.FoldingRangeKind = exports.FoldingRange = exports.ColorPresentation = exports.ColorInformation = exports.Color = exports.MarkupKind = exports.MarkupContent = exports.DocumentUri = exports.Position = exports.Range = exports.TextDocument = void 0;
+    exports.isSchemaResolveError = isSchemaResolveError;
     const vscode_languageserver_types_1 = require("vscode-languageserver-types");
     Object.defineProperty(exports, "Range", { enumerable: true, get: function () { return vscode_languageserver_types_1.Range; } });
     Object.defineProperty(exports, "Position", { enumerable: true, get: function () { return vscode_languageserver_types_1.Position; } });
@@ -76,9 +77,12 @@
         ErrorCode[ErrorCode["DuplicateKey"] = 520] = "DuplicateKey";
         ErrorCode[ErrorCode["CommentNotPermitted"] = 521] = "CommentNotPermitted";
         ErrorCode[ErrorCode["PropertyKeysMustBeDoublequoted"] = 528] = "PropertyKeysMustBeDoublequoted";
-        ErrorCode[ErrorCode["SchemaResolveError"] = 768] = "SchemaResolveError";
         ErrorCode[ErrorCode["SchemaUnsupportedFeature"] = 769] = "SchemaUnsupportedFeature";
+        ErrorCode[ErrorCode["SchemaResolveError"] = 65536] = "SchemaResolveError";
     })(ErrorCode || (exports.ErrorCode = ErrorCode = {}));
+    function isSchemaResolveError(code) {
+        return code >= ErrorCode.SchemaResolveError;
+    }
     var SchemaDraft;
     (function (SchemaDraft) {
         SchemaDraft[SchemaDraft["v3"] = 3] = "v3";

package/lib/umd/parser/jsonParser.js

@@ -394,9 +394,10 @@
             }
             const testAlternatives = (alternatives, maxOneMatch) => {
                 const matches = [];
+                const alternativesToTest = _tryDiscriminatorOptimization(alternatives) ?? alternatives;
                 // remember the best match that is used for error messages
                 let bestMatch = undefined;
-                for (const subSchemaRef of alternatives) {
+                for (const subSchemaRef of alternativesToTest) {
                     const subSchema = asSchema(subSchemaRef);
                     const subValidationResult = new ValidationResult();
                     const subMatchingSchemas = matchingSchemas.newSub();
@@ -521,6 +522,70 @@
                 });
             }
         }
+        function _tryDiscriminatorOptimization(alternatives) {
+            if (alternatives.length < 2) {
+                return undefined;
+            }
+            const buildConstMap = (getSchemas) => {
+                const constMap = new Map();
+                for (let i = 0; i < alternatives.length; i++) {
+                    const schemas = getSchemas(asSchema(alternatives[i]), i);
+                    if (!schemas) {
+                        return undefined; // Early exit if any alternative can't be processed
+                    }
+                    schemas.forEach(([key, schema]) => {
+                        if (schema.const !== undefined) {
+                            if (!constMap.has(key)) {
+                                constMap.set(key, new Map());
+                            }
+                            const valueMap = constMap.get(key);
+                            if (!valueMap.has(schema.const)) {
+                                valueMap.set(schema.const, []);
+                            }
+                            valueMap.get(schema.const).push(i);
+                        }
+                    });
+                }
+                return constMap;
+            };
+            const findDiscriminator = (constMap, getValue) => {
+                for (const [key, valueMap] of constMap) {
+                    const coveredAlts = new Set();
+                    valueMap.forEach(indices => indices.forEach(idx => coveredAlts.add(idx)));
+                    if (coveredAlts.size === alternatives.length) {
+                        const discriminatorValue = getValue(key);
+                        const matchingIndices = valueMap.get(discriminatorValue);
+                        if (matchingIndices?.length) {
+                            return matchingIndices.map(idx => alternatives[idx]);
+                        }
+                        break; // Found valid discriminator but no match
+                    }
+                }
+                return undefined;
+            };
+            if (node.type === 'object' && node.properties?.length) {
+                const constMap = buildConstMap((schema) => schema.properties ? Object.entries(schema.properties).map(([k, v]) => [k, asSchema(v)]) : undefined);
+                if (constMap) {
+                    return findDiscriminator(constMap, (propName) => {
+                        const prop = node.properties.find(p => p.keyNode.value === propName);
+                        return prop?.valueNode?.type === 'string' ? prop.valueNode.value : undefined;
+                    });
+                }
+            }
+            else if (node.type === 'array' && node.items?.length) {
+                const constMap = buildConstMap((schema) => {
+                    const itemSchemas = schema.prefixItems || (Array.isArray(schema.items) ? schema.items : undefined);
+                    return itemSchemas ? itemSchemas.map((item, idx) => [idx, asSchema(item)]) : undefined;
+                });
+                if (constMap) {
+                    return findDiscriminator(constMap, (itemIndex) => {
+                        const item = node.items[itemIndex];
+                        return item?.type === 'string' ? item.value : undefined;
+                    });
+                }
+            }
+            return undefined;
+        }
         function _validateNumberNode(node) {
             const val = node.value;
             function normalizeFloats(float) {
@@ -982,7 +1047,7 @@
                 for (const f of node.properties) {
                     const key = f.keyNode;
                     if (key) {
-                        validate(key, propertyNames, validationResult, NoOpSchemaCollector.instance, context);
+                        validate(key, propertyNames, validationResult, matchingSchemas, context);
                     }
                 }
             }

package/lib/umd/services/jsonSchemaService.js

@@ -115,6 +115,9 @@
         }
     }
     exports.UnresolvedSchema = UnresolvedSchema;
+    function toDiagnostic(message, code) {
+        return { message, code };
+    }
     class ResolvedSchema {
         constructor(schema, errors = [], warnings = [], schemaDraft) {
             this.schema = schema;
@@ -276,36 +279,45 @@
         loadSchema(url) {
             if (!this.requestService) {
                 const errorMessage = l10n.t('Unable to load schema from \'{0}\'. No schema request service available', toDisplayString(url));
-                return this.promise.resolve(new UnresolvedSchema({}, [errorMessage]));
+                return this.promise.resolve(new UnresolvedSchema({}, [toDiagnostic(errorMessage, jsonLanguageTypes_1.ErrorCode.SchemaResolveError)]));
             }
             return this.requestService(url).then(content => {
                 if (!content) {
                     const errorMessage = l10n.t('Unable to load schema from \'{0}\': No content.', toDisplayString(url));
-                    return new UnresolvedSchema({}, [errorMessage]);
+                    return new UnresolvedSchema({}, [toDiagnostic(errorMessage, jsonLanguageTypes_1.ErrorCode.SchemaResolveError)]);
                 }
                 const errors = [];
                 if (content.charCodeAt(0) === 65279) {
-                    errors.push(l10n.t('Problem reading content from \'{0}\': UTF-8 with BOM detected, only UTF 8 is allowed.', toDisplayString(url)));
+                    errors.push(toDiagnostic(l10n.t('Problem reading content from \'{0}\': UTF-8 with BOM detected, only UTF 8 is allowed.', toDisplayString(url)), jsonLanguageTypes_1.ErrorCode.SchemaResolveError));
                     content = content.trimStart();
                 }
                 let schemaContent = {};
                 const jsonErrors = [];
                 schemaContent = Json.parse(content, jsonErrors);
                 if (jsonErrors.length) {
-                    errors.push(l10n.t('Unable to parse content from \'{0}\': Parse error at offset {1}.', toDisplayString(url), jsonErrors[0].offset));
+                    errors.push(toDiagnostic(l10n.t('Unable to parse content from \'{0}\': Parse error at offset {1}.', toDisplayString(url), jsonErrors[0].offset), jsonLanguageTypes_1.ErrorCode.SchemaResolveError));
                 }
                 return new UnresolvedSchema(schemaContent, errors);
             }, (error) => {
-                let errorMessage = error.toString();
-                const errorSplit = error.toString().split('Error: ');
-                if (errorSplit.length > 1) {
-                    // more concise error message, URL and context are attached by caller anyways
-                    errorMessage = errorSplit[1];
+                let { message, code } = error;
+                if (typeof message !== 'string') {
+                    let errorMessage = error.toString();
+                    const errorSplit = error.toString().split('Error: ');
+                    if (errorSplit.length > 1) {
+                        // more concise error message, URL and context are attached by caller anyways
+                        errorMessage = errorSplit[1];
+                    }
+                    if (Strings.endsWith(errorMessage, '.')) {
+                        errorMessage = errorMessage.substr(0, errorMessage.length - 1);
+                    }
+                    message = errorMessage;
                 }
-                if (Strings.endsWith(errorMessage, '.')) {
-                    errorMessage = errorMessage.substr(0, errorMessage.length - 1);
+                let errorCode = jsonLanguageTypes_1.ErrorCode.SchemaResolveError;
+                if (typeof code === 'number' && code < 0x10000) {
+                    errorCode += code;
                 }
-                return new UnresolvedSchema({}, [l10n.t('Unable to load schema from \'{0}\': {1}.', toDisplayString(url), errorMessage)]);
+                const errorMessage = l10n.t('Unable to load schema from \'{0}\': {1}.', toDisplayString(url), message);
+                return new UnresolvedSchema({}, [toDiagnostic(errorMessage, errorCode)]);
             });
         }
         resolveSchemaContent(schemaToResolve, handle) {
@@ -313,7 +325,7 @@
             const schema = schemaToResolve.schema;
             const schemaDraft = schema.$schema ? (0, jsonParser_1.getSchemaDraftFromId)(schema.$schema) : undefined;
             if (schemaDraft === jsonLanguageTypes_1.SchemaDraft.v3) {
-                return this.promise.resolve(new ResolvedSchema({}, [l10n.t("Draft-03 schemas are not supported.")], [], schemaDraft));
+                return this.promise.resolve(new ResolvedSchema({}, [toDiagnostic(l10n.t("Draft-03 schemas are not supported."), jsonLanguageTypes_1.ErrorCode.SchemaUnsupportedFeature)], [], schemaDraft));
             }
             let usesUnsupportedFeatures = new Set();
             const contextService = this.contextService;
@@ -360,7 +372,8 @@
                     merge(target, section);
                 }
                 else {
-                    resolveErrors.push(l10n.t('$ref \'{0}\' in \'{1}\' can not be resolved.', refSegment || '', sourceHandle.uri));
+                    const message = l10n.t('$ref \'{0}\' in \'{1}\' can not be resolved.', refSegment || '', sourceHandle.uri);
+                    resolveErrors.push(toDiagnostic(message, jsonLanguageTypes_1.ErrorCode.SchemaResolveError));
                 }
             };
             const resolveExternalLink = (node, uri, refSegment, parentHandle) => {
@@ -373,7 +386,8 @@
                     parentHandle.dependencies.add(uri);
                     if (unresolvedSchema.errors.length) {
                         const loc = refSegment ? uri + '#' + refSegment : uri;
-                        resolveErrors.push(l10n.t('Problems loading reference \'{0}\': {1}', loc, unresolvedSchema.errors[0]));
+                        const errorMessage = l10n.t('Problems loading reference \'{0}\': {1}', loc, unresolvedSchema.errors[0].message);
+                        resolveErrors.push(toDiagnostic(errorMessage, unresolvedSchema.errors[0].code));
                     }
                     mergeRef(node, unresolvedSchema.schema, referencedHandle, refSegment);
                     return resolveRefs(node, unresolvedSchema.schema, referencedHandle);
@@ -417,7 +431,7 @@
                     const anchor = (0, objects_1.isString)(id) && id.charAt(0) === '#' ? id.substring(1) : next.$anchor;
                     if (anchor) {
                         if (result.has(anchor)) {
-                            resolveErrors.push(l10n.t('Duplicate anchor declaration: \'{0}\'', anchor));
+                            resolveErrors.push(toDiagnostic(l10n.t('Duplicate anchor declaration: \'{0}\'', anchor), jsonLanguageTypes_1.ErrorCode.SchemaResolveError));
                         }
                         else {
                             result.set(anchor, next);
@@ -435,7 +449,7 @@
             return resolveRefs(schema, schema, handle).then(_ => {
                 let resolveWarnings = [];
                 if (usesUnsupportedFeatures.size) {
-                    resolveWarnings.push(l10n.t('The schema uses meta-schema features ({0}) that are not yet supported by the validator.', Array.from(usesUnsupportedFeatures.keys()).join(', ')));
+                    resolveWarnings.push(toDiagnostic(l10n.t('The schema uses meta-schema features ({0}) that are not yet supported by the validator.', Array.from(usesUnsupportedFeatures.keys()).join(', ')), jsonLanguageTypes_1.ErrorCode.SchemaUnsupportedFeature));
                 }
                 return new ResolvedSchema(schema, resolveErrors, resolveWarnings, schemaDraft);
             });

package/lib/umd/services/jsonValidation.js

@@ -65,11 +65,11 @@
                         }
                     };
                     if (schema.errors.length) {
-                        addSchemaProblem(schema.errors[0], jsonLanguageTypes_1.ErrorCode.SchemaResolveError);
+                        addSchemaProblem(schema.errors[0].message, schema.errors[0].code);
                     }
                     else if (schemaValidation) {
                         for (const warning of schema.warnings) {
-                            addSchemaProblem(warning, jsonLanguageTypes_1.ErrorCode.SchemaUnsupportedFeature);
+                            addSchemaProblem(warning.message, warning.code);
                         }
                         const semanticErrors = jsonDocument.validate(textDocument, schema.schema, schemaValidation, documentSettings?.schemaDraft);
                         if (semanticErrors) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vscode-json-languageservice",
-  "version": "5.6.3",
+  "version": "5.7.0",
   "description": "Language service for JSON",
   "main": "./lib/umd/jsonLanguageService.js",
   "typings": "./lib/umd/jsonLanguageService",
@@ -17,12 +17,12 @@
   "devDependencies": {
     "@types/mocha": "^10.0.10",
     "@types/node": "22.x",
-    "@typescript-eslint/eslint-plugin": "^8.46.3",
-    "@typescript-eslint/parser": "^8.46.3",
-    "eslint": "^9.39.0",
+    "@typescript-eslint/eslint-plugin": "^8.53.0",
+    "@typescript-eslint/parser": "^8.53.0",
+    "eslint": "^9.39.2",
     "json-schema-test-suite": "https://github.com/json-schema-org/JSON-Schema-Test-Suite.git#69acf52990b004240839ae19b4bec8fb01d50876",
-    "mocha": "^11.7.4",
-    "rimraf": "^6.1.0",
+    "mocha": "^11.7.5",
+    "rimraf": "^6.1.2",
     "typescript": "^5.9.3"
   },
   "dependencies": {