@likec4/language-server 1.46.3 → 1.47.0

package/dist/references/scope-provider.js

@@ -54,8 +54,7 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
         }
     }
     // we need lazy resolving here
-    *genUniqueDescedants(of) {
-        const element = of();
+    *genUniqueDescedants(element) {
         if (!element) {
             return;
         }
@@ -83,7 +82,7 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
             };
         }
         // we make extended element resolvable inside ExtendElementBody
-        yield* this.genUniqueDescedants(() => elementRef(element));
+        yield* this.genUniqueDescedants(elementRef(element));
     }
     *genScopeElementView({ viewOf, extends: ext }) {
         if (viewOf) {
@@ -92,7 +91,7 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
             if (viewOf.modelElement.value.$nodeDescription) {
                 yield viewOf.modelElement.value.$nodeDescription;
             }
-            yield* this.genUniqueDescedants(() => elementRef(viewOf));
+            yield* this.genUniqueDescedants(elementRef(viewOf));
             return;
         }
         if (ext) {
@@ -115,10 +114,10 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
         if (deploymentNode.value.$nodeDescription) {
             yield deploymentNode.value.$nodeDescription;
         }
-        yield* this.genUniqueDescedants(() => {
-            const target = deploymentNode.value.ref;
-            return target && ast.isDeploymentNode(target) ? target : undefined;
-        });
+        const target = deploymentNode.value.ref;
+        if (target && ast.isDeploymentNode(target)) {
+            yield* this.genUniqueDescedants(target);
+        }
     }
     streamForFqnRef(projectId, container, context) {
         const parent = container.parent;
@@ -130,25 +129,23 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
             return EMPTY_STREAM;
         }
         if (ast.isImported(parentRef)) {
-            return stream(this.genUniqueDescedants(() => {
-                return parentRef.imported.ref;
-            }));
+            return stream(this.genUniqueDescedants(parentRef.imported.ref));
         }
         if (ast.isDeploymentNode(parentRef)) {
-            return stream(this.genUniqueDescedants(() => parentRef));
+            return stream(this.genUniqueDescedants(parentRef));
         }
         if (ast.isDeployedInstance(parentRef)) {
-            // if (ast.isElement(target)) {
-            return stream(this.genUniqueDescedants(() => {
-                const target = parentRef.target.modelElement.value.ref;
-                if (ast.isImported(target)) {
-                    return target.imported.ref;
-                }
-                return ast.isElement(target) ? target : undefined;
-            }));
+            const target = parentRef.target.modelElement.value.ref;
+            // dprint-ignore
+            const resolvedTarget = ast.isImported(target)
+                ? target.imported.ref
+                : ast.isElement(target)
+                    ? target
+                    : undefined;
+            return stream(this.genUniqueDescedants(resolvedTarget));
         }
         if (ast.isElement(parentRef)) {
-            return stream(this.genUniqueDescedants(() => parentRef));
+            return stream(this.genUniqueDescedants(parentRef));
         }
         return nonexhaustive(parentRef);
     }

package/dist/utils/elementRef.js

@@ -3,11 +3,17 @@ import { ast } from '../ast';
  * Returns referenced AST Element
  */
 export function elementRef(node) {
-    let el = ast.isStrictFqnElementRef(node) ? node.el.ref : node.modelElement.value.ref;
-    if (el?.$type === 'Imported') {
-        el = el.imported.ref;
+    try {
+        let el = ast.isStrictFqnElementRef(node) ? node.el.ref : node.modelElement.value.ref;
+        if (el?.$type === 'Imported') {
+            el = el.imported.ref;
+        }
+        return el?.$type === 'Element' ? el : undefined;
+    }
+    catch {
+        // ignore reference errors
+        return undefined;
     }
-    return el?.$type === 'Element' ? el : undefined;
 }
 /**
  * Returns FQN of StrictFqnElementRef

package/dist/validation/index.d.ts

@@ -4,7 +4,7 @@ import type { LikeC4Services } from '../module';
 export { LikeC4DocumentValidator } from './DocumentValidator';
 type Guard<N extends AstNode> = (n: AstNode) => n is N;
 type Guarded<G> = G extends Guard<infer N> ? N : never;
-declare const isValidatableAstNode: (n: AstNode) => n is ast.DynamicViewDisplayVariantProperty | ast.LinkProperty | ast.ViewStringProperty | ast.ElementStringProperty | ast.ElementStyleProperty | ast.IconProperty | ast.MetadataBody | ast.RelationStringProperty | ast.MetadataAttribute | ast.NotationProperty | ast.NotesProperty | ast.SpecificationElementStringProperty | ast.SpecificationRelationshipStringProperty | ast.HexColor | ast.RGBAColor | ast.DeployedInstance | ast.DeploymentNode | ast.DeploymentViewRulePredicate | ast.DeploymentViewRuleStyle | ast.ViewRuleAutoLayout | ast.DynamicViewGlobalPredicateRef | ast.DynamicViewIncludePredicate | ast.ViewRuleGlobalStyle | ast.ViewRuleStyle | ast.DynamicStepChain | ast.DynamicStepSingle | ast.ElementKindExpression | ast.ElementTagExpression | ast.FqnRefExpr | ast.WildcardExpression | ast.FqnExprWhere | ast.FqnExprWith | ast.DirectedRelationExpr | ast.InOutRelationExpr | ast.IncomingRelationExpr | ast.OutgoingRelationExpr | ast.RelationExprWhere | ast.RelationExprWith | ast.Element | ast.ExtendDeployment | ast.ExtendElement | ast.Imported | ast.DeploymentView | ast.DynamicView | ast.ElementView | ast.ArrowProperty | ast.ColorProperty | ast.LineProperty | ast.PaddingSizeProperty | ast.ShapeSizeProperty | ast.TextSizeProperty | ast.BorderProperty | ast.MultipleProperty | ast.OpacityProperty | ast.ShapeProperty | ast.ViewRuleGlobalPredicateRef | ast.ViewRuleGroup | ast.ViewRulePredicate | ast.ViewRuleRank | ast.DynamicViewParallelSteps | ast.SpecificationRelationshipKind | ast.SpecificationRule | ast.ElementRef | ast.DeploymentRelation | ast.Relation | ast.GlobalDynamicPredicateGroup | ast.Globals | ast.GlobalPredicateGroup | ast.GlobalStyle | ast.SpecificationDeploymentNodeKind | ast.SpecificationElementKind | ast.GlobalStyleGroup | ast.SpecificationColor | ast.NavigateToProperty | ast.Tags | ast.ExtendRelation | ast.ImportsFromPoject | ast.SpecificationTag;
+declare const isValidatableAstNode: (n: AstNode) => n is ast.Element | ast.DeployedInstance | ast.DeploymentNode | ast.Tags | ast.ElementKindExpression | ast.ElementTagExpression | ast.FqnRefExpr | ast.WildcardExpression | ast.FqnExprWhere | ast.FqnExprWith | ast.DirectedRelationExpr | ast.InOutRelationExpr | ast.IncomingRelationExpr | ast.OutgoingRelationExpr | ast.RelationExprWhere | ast.RelationExprWith | ast.ImportsFromPoject | ast.Imported | ast.Globals | ast.GlobalPredicateGroup | ast.GlobalDynamicPredicateGroup | ast.GlobalStyle | ast.GlobalStyleGroup | ast.DeploymentViewRulePredicate | ast.DynamicViewIncludePredicate | ast.ViewRulePredicate | ast.DeploymentView | ast.DynamicView | ast.ViewRuleGroup | ast.ElementView | ast.DeploymentViewRuleStyle | ast.ViewRuleRank | ast.ViewRuleStyle | ast.DynamicViewParallelSteps | ast.DynamicStepChain | ast.DynamicStepSingle | ast.ViewRuleAutoLayout | ast.LinkProperty | ast.ViewStringProperty | ast.SpecificationDeploymentNodeKind | ast.SpecificationElementKind | ast.ExtendDeployment | ast.DeploymentRelation | ast.ExtendElement | ast.ExtendRelation | ast.Relation | ast.SpecificationRule | ast.BorderProperty | ast.ColorProperty | ast.IconProperty | ast.MultipleProperty | ast.OpacityProperty | ast.PaddingSizeProperty | ast.ShapeProperty | ast.ShapeSizeProperty | ast.TextSizeProperty | ast.ElementStyleProperty | ast.SpecificationRelationshipKind | ast.ViewRuleGlobalPredicateRef | ast.ViewRuleGlobalStyle | ast.DynamicViewGlobalPredicateRef | ast.ArrowProperty | ast.LineProperty | ast.DynamicViewDisplayVariantProperty | ast.MetadataBody | ast.ElementStringProperty | ast.MetadataAttribute | ast.NotationProperty | ast.NotesProperty | ast.RelationStringProperty | ast.SpecificationElementStringProperty | ast.SpecificationRelationshipStringProperty | ast.NavigateToProperty | ast.ElementRef | ast.SpecificationTag | ast.SpecificationColor | ast.HexColor | ast.RGBAColor;
 type ValidatableAstNode = Guarded<typeof isValidatableAstNode>;
 export declare function checksFromDiagnostics(doc: LikeC4LangiumDocument): {
     isValid: (n: ValidatableAstNode) => boolean;

package/dist/workspace/IndexManager.js

@@ -16,8 +16,10 @@ export class IndexManager extends DefaultIndexManager {
         let documentUris = stream(this.symbolIndex.keys());
         return documentUris
             .filter(uri => {
-            return (!uris || uris.has(uri)) && (projects.belongsTo(uri) === projectId ||
-                projects.isIncluded(projectId, uri));
+            if (uris && !uris.has(uri)) {
+                return false;
+            }
+            return projects.isIncluded(projectId, uri);
         })
             .flatMap(uri => this.getFileDescriptions(uri, nodeType));
     }

package/dist/workspace/LangiumDocuments.d.ts

@@ -8,6 +8,10 @@ export declare class LangiumDocuments extends DefaultLangiumDocuments {
     constructor(services: LikeC4SharedServices);
     addDocument(document: LangiumDocument): void;
     getDocument(uri: URI): LikeC4LangiumDocument | undefined;
+    /**
+     * Returns all known documents, without any filtering.
+     */
+    get allKnownDocuments(): Stream<LangiumDocument>;
     get all(): Stream<LikeC4LangiumDocument>;
     /**
      * Returns all documents, excluding built-in documents and documents excluded by ProjectsManager.

package/dist/workspace/LangiumDocuments.js

@@ -1,6 +1,6 @@
 import { compareNaturalHierarchically } from '@likec4/core/utils';
 import { DefaultLangiumDocuments, stream } from 'langium';
-import { groupBy, prop } from 'remeda';
+import { hasAtLeast } from 'remeda';
 import { isLikeC4LangiumDocument } from '../ast';
 import { LikeC4LanguageMetaData } from '../generated/module';
 import { isLikeC4Builtin } from '../likec4lib';
@@ -32,16 +32,22 @@ export class LangiumDocuments extends DefaultLangiumDocuments {
     }
     getDocument(uri) {
         const doc = super.getDocument(uri);
-        if (doc && !exclude(doc)) {
-            doc.likec4ProjectId = this.services.workspace.ProjectsManager.belongsTo(doc);
-        }
         if (doc && !isLikeC4LangiumDocument(doc)) {
             throw new Error(`Document ${doc.uri.path} is not a LikeC4 document`);
         }
+        if (doc && !exclude(doc)) {
+            doc.likec4ProjectId = this.services.workspace.ProjectsManager.belongsTo(doc);
+        }
         return doc;
     }
+    /**
+     * Returns all known documents, without any filtering.
+     */
+    get allKnownDocuments() {
+        return stream(this.documentMap.values());
+    }
     get all() {
-        return stream(this.documentMap.values())
+        return this.allKnownDocuments
             .filter((doc) => {
             if (doc.textDocument.languageId === LikeC4LanguageMetaData.languageId) {
                 if (!isLikeC4Builtin(doc.uri)) {
@@ -66,18 +72,29 @@ export class LangiumDocuments extends DefaultLangiumDocuments {
      */
     projectDocuments(projectId) {
         const projects = this.services.workspace.ProjectsManager;
-        return this.allExcludingBuiltin.filter(doc => {
-            return doc.likec4ProjectId === projectId || projects.isIncluded(projectId, doc.uri);
+        return this.all.filter(doc => {
+            if (isLikeC4Builtin(doc.uri)) {
+                return false;
+            }
+            return projects.isIncluded(projectId, doc.uri);
         });
     }
     groupedByProject() {
-        return groupBy(this.allExcludingBuiltin.toArray(), prop('likec4ProjectId'));
+        return this.services.workspace.ProjectsManager
+            .all
+            .reduce((acc, projectId) => {
+            const docs = this.projectDocuments(projectId).toArray();
+            if (hasAtLeast(docs, 1)) {
+                acc[projectId] = docs;
+            }
+            return acc;
+        }, {});
     }
     /**
      * Reset the project IDs of all documents.
      */
     resetProjectIds() {
-        super.all.forEach(doc => {
+        this.allKnownDocuments.forEach(doc => {
             if (exclude(doc)) {
                 return;
             }

package/dist/workspace/ProjectsManager.d.ts

@@ -2,6 +2,7 @@ import { type IncludeConfig, type LikeC4ProjectConfig, type LikeC4ProjectConfigI
 import type { NonEmptyArray, NonEmptyReadonlyArray } from '@likec4/core';
 import type { ProjectId, scalar } from '@likec4/core/types';
 import { type Cancellation, type LangiumDocument, URI, WorkspaceCache } from 'langium';
+import picomatch from 'picomatch';
 import type { Tagged } from 'type-fest';
 import type { LikeC4SharedServices } from '../module';
 /**
@@ -15,7 +16,7 @@ interface ProjectData {
     config: LikeC4ProjectConfig;
     folder: ProjectFolder;
     folderUri: URI;
-    exclude?: (path: string) => boolean;
+    exclude?: picomatch.Matcher;
     /**
      * Resolved include paths with both URI and folder string representations.
      * These are additional directories that are part of this project.
@@ -59,6 +60,10 @@ export declare class ProjectsManager {
     get default(): ProjectData;
     get all(): NonEmptyReadonlyArray<scalar.ProjectId>;
     getProject(arg: scalar.ProjectId | LangiumDocument): Project;
+    /**
+     * Returns all projects that include the specified folder, or inside the folder.
+     */
+    findAllProjectsByFolder(folder: URI | string): ProjectData[];
     /**
      * Validates and ensures the project ID.
      * If no project ID is specified, returns default project ID
@@ -75,10 +80,11 @@ export declare class ProjectsManager {
      */
     isExcluded(document: LangiumDocument | URI | string): boolean;
     /**
-     * Checks if the specified document is included by the project.
+     * Checks if the specified document is included by the project:
+     * - if the document belongs to the project and is not excluded
+     * - if the document is included by the project
      */
     isIncluded(projectId: ProjectId, document: LangiumDocument | URI | string): boolean;
-    includedInProjects(document: LangiumDocument | URI | string): ProjectId[];
     /**
      * Checks if it is a config file and it is not excluded by default exclude pattern
      *

package/dist/workspace/ProjectsManager.js

@@ -1,11 +1,13 @@
+var _a;
 import { isLikeC4Config, normalizeIncludeConfig, validateProjectConfig, } from '@likec4/config';
-import { BiMap, invariant, memoizeProp, nonNullable } from '@likec4/core/utils';
-import { wrapError } from '@likec4/log';
+import { BiMap, compareNaturalHierarchically, DefaultMap, invariant, memoizeProp, nonNullable, } from '@likec4/core/utils';
+import { loggable, wrapError } from '@likec4/log';
 import { deepEqual } from 'fast-equals';
-import { interruptAndCheck, URI, WorkspaceCache, } from 'langium';
+import { isOperationCancelled, OperationCancelled, URI, WorkspaceCache, } from 'langium';
 import picomatch from 'picomatch';
-import { filter, hasAtLeast, isNullish, map, pipe, prop, sortBy } from 'remeda';
-import { joinRelativeURL, parseFilename, withoutProtocol, withTrailingSlash, } from 'ufo';
+import { filter, hasAtLeast, isNullish, map, pipe, prop, sort } from 'remeda';
+import { cleanDoubleSlashes, isRelative, joinRelativeURL, joinURL, parseFilename, withoutProtocol, withoutTrailingSlash, withTrailingSlash, } from 'ufo';
+import { isLikeC4Builtin } from '../likec4lib';
 import { logger as mainLogger } from '../logger';
 const logger = mainLogger.getChild('ProjectsManager');
 function normalizeUri(uri) {
@@ -20,6 +22,11 @@ function normalizeUri(uri) {
         return uri.uri.toString();
     }
 }
+/**
+ * Compare function to ensure consistent order
+ */
+const compare = compareNaturalHierarchically('/', true);
+const compareUri = (a, b) => compare(withoutTrailingSlash(a.path), withoutTrailingSlash(b.path));
 /**
  * Returns a predicate that checks if the given path is included in the project folder.
  */
@@ -66,6 +73,23 @@ export class ProjectsManager {
      * This ensures that the most specific project is used for a document.
      */
     #projects = [];
+    /**
+     * This is a cached lookup for performance.
+     */
+    #lookupById = new DefaultMap((id) => {
+        if (id === _a.DefaultProjectId) {
+            const folder = ProjectFolder(this.getWorkspaceFolder());
+            return {
+                id,
+                config: DefaultProject.config,
+                folder,
+                folderUri: URI.parse(folder),
+                exclude: DefaultProject.exclude,
+                includeConfig: DefaultProject.includeConfig,
+            };
+        }
+        return nonNullable(this.#projects.find(p => p.id === id), `Project ${id} not found`);
+    });
     #excludedDocuments = new WeakMap();
     constructor(services) {
         this.services = services;
@@ -85,14 +109,14 @@ export class ProjectsManager {
         if (this.#projects.length > 1) {
             return undefined;
         }
-        return this.#projects[0]?.id ?? ProjectsManager.DefaultProjectId;
+        return this.#projects[0]?.id ?? _a.DefaultProjectId;
     }
     set defaultProjectId(id) {
         if (id === this.#defaultProjectId) {
             return;
         }
         this.#defaultProject = undefined;
-        if (!id || id === ProjectsManager.DefaultProjectId) {
+        if (!id || id === _a.DefaultProjectId) {
             logger.debug `reset default project ID`;
             this.#defaultProjectId = undefined;
             return;
@@ -103,20 +127,8 @@ export class ProjectsManager {
     }
     get default() {
         if (!this.#defaultProject) {
-            const id = this.defaultProjectId ?? ProjectsManager.DefaultProjectId;
-            let project = this.#projects.find(p => p.id === id);
-            if (!project) {
-                const folderUri = this.getWorkspaceFolder();
-                project = {
-                    id,
-                    config: DefaultProject.config,
-                    folder: ProjectFolder(folderUri),
-                    folderUri,
-                    exclude: DefaultProject.exclude,
-                    includeConfig: DefaultProject.includeConfig,
-                };
-            }
-            this.#defaultProject = project;
+            const id = this.defaultProjectId ?? _a.DefaultProjectId;
+            this.#defaultProject = this.#lookupById.get(id);
         }
         return this.#defaultProject;
     }
@@ -140,23 +152,7 @@ export class ProjectsManager {
     }
     getProject(arg) {
         const id = typeof arg === 'string' ? arg : (arg.likec4ProjectId || this.belongsTo(arg));
-        if (id === DefaultProject.id) {
-            let folderUri;
-            try {
-                folderUri = this.services.workspace.WorkspaceManager.workspaceUri;
-            }
-            catch (error) {
-                logger.warn('Failed to get workspace URI, using default folder', { error });
-                folderUri = URI.file('/');
-                // ignore - workspace not initialized
-            }
-            return {
-                id: ProjectsManager.DefaultProjectId,
-                config: DefaultProject.config,
-                folderUri,
-            };
-        }
-        const project = nonNullable(this.#projects.find(p => p.id === id), `Project "${id}" not found`);
+        const project = this.#lookupById.get(id);
         return {
             id,
             folderUri: project.folderUri,
@@ -164,14 +160,22 @@ export class ProjectsManager {
             ...(project.includePaths && { includePaths: map(project.includePaths, prop('uri')) }),
         };
     }
+    /**
+     * Returns all projects that include the specified folder, or inside the folder.
+     */
+    findAllProjectsByFolder(folder) {
+        const projectFolder = ProjectFolder(folder);
+        const isInsideOrIncludes = (p) => p.folder.startsWith(projectFolder) || projectFolder.startsWith(p.folder);
+        return this.#projects.filter(isInsideOrIncludes);
+    }
     /**
      * Validates and ensures the project ID.
      * If no project ID is specified, returns default project ID
      * If there are multiple projects and default project is not set, throws an error
      */
     ensureProjectId(projectId) {
-        if (projectId === ProjectsManager.DefaultProjectId) {
-            return this.defaultProjectId ?? ProjectsManager.DefaultProjectId;
+        if (projectId === _a.DefaultProjectId) {
+            return this.defaultProjectId ?? _a.DefaultProjectId;
         }
         if (projectId) {
             invariant(this.#projectIdToFolder.has(projectId), `Project ID ${projectId} is not registered`);
@@ -196,7 +200,11 @@ export class ProjectsManager {
         if (typeof document === 'string' || URI.isUri(document)) {
             let docUriAsString = normalizeUri(document);
             const project = this.findProjectForDocument(docUriAsString);
-            return !!project.exclude && project.exclude(withoutProtocol(docUriAsString));
+            if (!project.exclude) {
+                return false;
+            }
+            const input = withoutProtocol(docUriAsString);
+            return project.exclude(input);
         }
         let isExcluded = this.#excludedDocuments.get(document);
         if (isExcluded === undefined) {
@@ -206,24 +214,23 @@ export class ProjectsManager {
         return isExcluded;
     }
     /**
-     * Checks if the specified document is included by the project.
+     * Checks if the specified document is included by the project:
+     * - if the document belongs to the project and is not excluded
+     * - if the document is included by the project
      */
     isIncluded(projectId, document) {
-        if (typeof document === 'string' || URI.isUri(document)) {
-            let project = this.#projects.find(p => p.id === projectId);
-            if (!project || !project.includePaths) {
-                return false;
-            }
-            return project.includePaths.some(isParentFolderFor(document));
+        if (typeof document !== 'string' && !URI.isUri(document)) {
+            return this.isIncluded(projectId, document.uri);
         }
-        return this.isIncluded(projectId, document.uri);
-    }
-    includedInProjects(document) {
-        if (typeof document === 'string' || URI.isUri(document)) {
-            let docUriAsString = normalizeUri(document);
-            return pipe(this.#projects, filter(p => !!p.includePaths && p.includePaths.some(isParentFolderFor(docUriAsString))), map(p => p.id));
+        const belongsTo = this.belongsTo(document);
+        if (belongsTo === projectId) {
+            return !this.isExcluded(document);
+        }
+        let includePaths = this.#lookupById.get(projectId)?.includePaths;
+        if (!includePaths) {
+            return false;
         }
-        return this.includedInProjects(document.uri);
+        return includePaths.some(isParentFolderFor(document));
     }
     /**
      * Checks if it is a config file and it is not excluded by default exclude pattern
@@ -258,8 +265,11 @@ export class ProjectsManager {
             return await this.registerProject({ config, folderUri }, cancelToken);
         }
         catch (error) {
-            this.services.lsp.Connection?.window.showErrorMessage(`LikeC4: Failed to register project at ${configFile.fsPath}`);
-            throw wrapError(error, `Failed to register project config ${configFile.fsPath}:\n`);
+            if (!isOperationCancelled(error)) {
+                this.services.lsp.Connection?.window.showErrorMessage(`LikeC4: Failed to register project at ${configFile.fsPath}`);
+                throw wrapError(error, `Failed to register project config ${configFile.fsPath}:\n`);
+            }
+            return Promise.reject(error);
         }
     }
     /**
@@ -291,9 +301,7 @@ export class ProjectsManager {
             // if there is any project within subfolder or parent folder
             // we need to reset assigned to documents project IDs
             mustReset = this.#projects.some(p => p.folder.startsWith(folder) || folder.startsWith(p.folder));
-            this.#projects = pipe([...this.#projects, project], sortBy(
-            // sort by folder depth (longest first)
-            [({ folder }) => withoutProtocol(folder).split('/').length, 'desc']));
+            this.#projects = pipe([...this.#projects, project], sort((a, b) => compareUri(a.folderUri, b.folderUri)));
             logger.info `register project ${project.id} folder: ${folder}`;
         }
         else {
@@ -314,13 +322,20 @@ export class ProjectsManager {
             const includeConfig = normalizeIncludeConfig(config.include);
             project.includeConfig = includeConfig;
         }
-        // Reset cached default project
-        this.#defaultProject = undefined;
         if (isNullish(config.exclude)) {
             project.exclude = DefaultProject.exclude;
         }
         else if (hasAtLeast(config.exclude, 1)) {
-            project.exclude = picomatch(config.exclude, { dot: true });
+            const patterns = map(config.exclude, p => {
+                if (!isRelative(p) && !p.startsWith('**')) {
+                    p = joinURL('**', p);
+                }
+                return cleanDoubleSlashes(joinRelativeURL(project.folderUri.path, p));
+            });
+            project.exclude = picomatch(patterns, {
+                contains: true,
+                dot: true,
+            });
         }
         // Resolve include paths relative to project folder
         if (project.includeConfig.paths && hasAtLeast(project.includeConfig.paths, 1)) {
@@ -366,14 +381,22 @@ export class ProjectsManager {
         else {
             delete project.includePaths;
         }
+        // Reset cached default project
+        this.#defaultProject = undefined;
         this.#projectIdToFolder.set(project.id, folder);
+        this.#lookupById.clear();
         // Reset assigned project IDs if no projects reload is active
         if (mustReset && !this.#activeReload) {
             await this.rebuidProject(project.id, cancelToken).catch(error => {
+                if (isOperationCancelled(error)) {
+                    return Promise.reject(error);
+                }
                 logger.warn('Failed to rebuild project {projectId} after config change', {
                     projectId: project.id,
                     error,
                 });
+                // ignore error, we logged it
+                return Promise.resolve();
             });
         }
         return project;
@@ -393,19 +416,25 @@ export class ProjectsManager {
     }
     #activeReload = null;
     async reloadProjects(cancelToken) {
-        try {
-            if (!this.#activeReload) {
-                logger.debug `schedule reload projects`;
-                this.#activeReload = this._reloadProjects(cancelToken);
-            }
-            else {
-                logger.debug `reload projects is already in progress, waiting`;
-            }
-            await this.#activeReload;
+        if (this.#activeReload) {
+            logger.debug `reload projects is already in progress, waiting`;
+            return await this.#activeReload.catch(() => {
+                // ignore errors
+            });
         }
-        finally {
+        logger.debug `schedule reload projects`;
+        this.#activeReload = Promise.resolve()
+            .then(() => this._reloadProjects(cancelToken))
+            .catch(error => {
+            if (!isOperationCancelled(error)) {
+                logger.warn('Failed to reload projects', { error });
+            }
+            return Promise.reject(error);
+        })
+            .finally(() => {
             this.#activeReload = null;
-        }
+        });
+        return await this.#activeReload;
     }
     async _reloadProjects(cancelToken) {
         const folders = this.services.workspace.WorkspaceManager.workspaceFolders;
@@ -433,20 +462,25 @@ export class ProjectsManager {
         if (configFiles.length === 0 && this.#projects.length !== 0) {
             logger.warning('No config files found, but some projects were registered before');
         }
+        // Sort config files hierarchically, ensuring consistent order
+        configFiles.sort(compareUri);
         this.#projects = [];
         this.#projectIdToFolder.clear();
+        this.#lookupById.clear();
         for (const uri of configFiles) {
-            if (cancelToken) {
-                await interruptAndCheck(cancelToken);
-            }
-            try {
-                await this.registerConfigFile(uri, cancelToken);
-            }
-            catch (error) {
-                logger.error('Failed to load config file {uri}', { uri: uri.fsPath, error });
+            if (cancelToken?.isCancellationRequested) {
+                break;
             }
+            await this.registerConfigFile(uri, cancelToken).catch(error => {
+                if (!isOperationCancelled(error)) {
+                    logger.warn(loggable(error));
+                }
+            });
         }
         this.reset();
+        if (cancelToken?.isCancellationRequested) {
+            throw OperationCancelled;
+        }
         await this.services.workspace.WorkspaceManager.rebuildAll(cancelToken);
     }
     uniqueProjectId(name) {
@@ -466,6 +500,7 @@ export class ProjectsManager {
         this.services.workspace.LangiumDocuments.resetProjectIds();
         this.documentBelongsTo.clear();
         this.mappingsToProject.clear();
+        this.#lookupById.clear();
         this.#excludedDocuments = new WeakMap();
     }
     async rebuidProject(projectId, cancelToken) {
@@ -478,9 +513,15 @@ export class ProjectsManager {
         const log = logger.getChild(project.id);
         const folder = project.folder;
         const includePaths = project.includePaths;
-        const docs = this.services.workspace.LangiumDocuments
-            .all
-            .filter(doc => {
+        const allDocs = this.services.workspace.LangiumDocuments
+            .allKnownDocuments
+            .filter(doc => !isLikeC4Builtin(doc.uri))
+            .toArray();
+        // If no documents are found, return early
+        if (allDocs.length === 0) {
+            return;
+        }
+        const docs = pipe(allDocs, filter(doc => {
             if (project.exclude?.(doc.uri.path)) {
                 return false;
             }
@@ -493,25 +534,22 @@ export class ProjectsManager {
             }
             const docdir = withTrailingSlash(joinRelativeURL(docUriStr, '..'));
             return docdir.startsWith(folder) || folder.startsWith(docdir);
-        })
-            .map(d => d.uri)
-            .toArray();
-        if (docs.length > 0) {
-            log.info('rebuild project documents: {docs}', {
-                docs: docs.length,
-            });
-            this.reset();
-            await this.services.workspace.DocumentBuilder
-                .update(docs, [], cancelToken)
-                .catch(error => {
-                log.warn('Failed to rebuild project', {
-                    error,
-                });
-            });
-        }
-        else {
+        }), map(d => d.uri));
+        if (docs.length === 0) {
             log.debug('no documents in project, skipping rebuild');
+            return;
         }
+        log.info('rebuild project documents: {docs}', {
+            docs: docs.length,
+        });
+        this.reset();
+        await this.services.workspace.DocumentBuilder
+            .update(docs, [], cancelToken)
+            .catch(error => {
+            log.warn('Failed to rebuild project', {
+                error,
+            });
+        });
     }
     findProjectForDocument(documentUri) {
         return this.mappingsToProject.get(documentUri, () => {
@@ -569,3 +607,4 @@ export class ProjectsManager {
         }
     }
 }
+_a = ProjectsManager;