@likec4/language-server 1.25.1 → 1.26.0

package/dist/config/index.d.ts

@@ -0,0 +1 @@
+export { parseConfigJson, ProjectConfig, validateConfig } from './schema';

package/dist/config/index.js

@@ -0,0 +1 @@
+export { parseConfigJson, ProjectConfig, validateConfig } from "./schema.js";

package/dist/config/schema.d.ts

@@ -0,0 +1,8 @@
+import * as v from 'valibot';
+export declare const ProjectConfig: v.ObjectSchema<{
+    readonly name: v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.DescriptionAction<string, "Project name, must be unique in the workspace">]>;
+    readonly exclude: v.SchemaWithPipe<[v.ExactOptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>, v.DescriptionAction<string[], "List of file patterns to exclude from the project, default is [\"node_modules\"]">]>;
+}, undefined>;
+export type ProjectConfig = v.InferOutput<typeof ProjectConfig>;
+export declare function parseConfigJson(config: string): ProjectConfig;
+export declare function validateConfig(config: unknown): ProjectConfig;

package/dist/config/schema.js

@@ -0,0 +1,19 @@
+import JSON5 from "json5";
+import * as v from "valibot";
+export const ProjectConfig = v.object({
+  name: v.pipe(
+    v.string(),
+    v.nonEmpty(),
+    v.description("Project name, must be unique in the workspace")
+  ),
+  exclude: v.pipe(
+    v.exactOptional(v.array(v.string())),
+    v.description('List of file patterns to exclude from the project, default is ["node_modules"]')
+  )
+});
+export function parseConfigJson(config) {
+  return validateConfig(JSON5.parse(config));
+}
+export function validateConfig(config) {
+  return v.parse(ProjectConfig, config);
+}

package/dist/index.d.ts

@@ -2,6 +2,7 @@ import { LikeC4FileSystem } from './LikeC4FileSystem';
 import { type LikeC4Services, type LikeC4SharedServices } from './module';
 export { getLspConnectionSink, logger as lspLogger } from './logger';
 export type { DocumentParser, LikeC4ModelBuilder, LikeC4ModelLocator, LikeC4ModelParser } from './model';
+export type { LikeC4LanguageServices } from './LikeC4LanguageServices';
 export { isLikeC4Builtin } from './likec4lib';
 export { createCustomLanguageServices, createLanguageServices, LikeC4Module } from './module';
 export type { LikeC4Services, LikeC4SharedServices } from './module';

package/dist/lsp/CodeLensProvider.js

@@ -1,6 +1,7 @@
 import { DocumentState } from "langium";
 import { isLikeC4LangiumDocument, ViewOps } from "../ast.js";
 import { logger } from "../logger.js";
+import { projectIdFrom } from "../utils/index.js";
 export class LikeC4CodeLensProvider {
   constructor(services) {
     this.services = services;
@@ -21,6 +22,7 @@ export class LikeC4CodeLensProvider {
       if (!range || !viewId) {
         return [];
       }
+      const projectId = projectIdFrom(ast);
       return {
         range: {
           start: range.start,
@@ -31,7 +33,7 @@ export class LikeC4CodeLensProvider {
         },
         command: {
           command: "likec4.open-preview",
-          arguments: [viewId],
+          arguments: [viewId, projectId],
           title: "open preview"
         }
       };

package/dist/model/builder/buildModel.d.ts

@@ -1,3 +1,10 @@
 import type * as c4 from '@likec4/core';
 import type { ParsedLikeC4LangiumDocument } from '../../ast';
-export declare function buildModel(docs: ParsedLikeC4LangiumDocument[]): c4.ParsedLikeC4Model;
+/**
+ * Each document was parsed into a ParsedLikeC4LangiumDocument, where elements
+ * do not inherit styles from specification.
+ *
+ * This function builds a model from all documents, merging the specifications
+ * and globals, and applying the extends to the elements.
+ */
+export declare function buildModel(docs: ParsedLikeC4LangiumDocument[]): c4.ParsedLikeC4ModelData;

package/dist/model/deployments-index.js

@@ -93,6 +93,6 @@ export class DeploymentsIndex extends FqnIndex {
         logWarnError(e);
       }
     }
-    return new DocumentFqnIndex(root, children, descendants, byfqn);
+    return new DocumentFqnIndex(root, children, descendants, byfqn, this.projects.belongsTo(document));
   }
 }

package/dist/model/fqn-index.d.ts

@@ -1,12 +1,14 @@
-import { type Fqn } from '@likec4/core/types';
+import { type Fqn, type ProjectId } from '@likec4/core/types';
 import { DefaultWeakMap, MultiMap } from '@likec4/core/utils';
-import { type AstNode, type LangiumDocuments, type Stream, WorkspaceCache } from 'langium';
+import { type AstNode, type Stream, WorkspaceCache } from 'langium';
 import { type AstNodeDescriptionWithFqn, type LikeC4LangiumDocument, ast } from '../ast';
 import type { LikeC4Services } from '../module';
 import { ADisposable } from '../utils';
+import { type LangiumDocuments, ProjectsManager } from '../workspace';
 export declare class FqnIndex<AstNd extends AstNode = ast.Element> extends ADisposable {
     protected services: LikeC4Services;
     private cachePrefix;
+    protected projects: ProjectsManager;
     protected langiumDocuments: LangiumDocuments;
     protected documentCache: DefaultWeakMap<LikeC4LangiumDocument, DocumentFqnIndex>;
     protected workspaceCache: WorkspaceCache<string, AstNodeDescriptionWithFqn[]>;
@@ -14,12 +16,12 @@ export declare class FqnIndex<AstNd extends AstNode = ast.Element> extends ADisp
     private documents;
     get(document: LikeC4LangiumDocument): DocumentFqnIndex;
     getFqn(el: AstNd): Fqn;
-    byFqn(fqn: Fqn): Stream<AstNodeDescriptionWithFqn>;
-    directChildrenOf(parent: Fqn): Stream<AstNodeDescriptionWithFqn>;
+    byFqn(projectId: ProjectId, fqn: Fqn): Stream<AstNodeDescriptionWithFqn>;
+    directChildrenOf(projectId: ProjectId, parent: Fqn): Stream<AstNodeDescriptionWithFqn>;
     /**
      * Returns descedant elements with unique names in the scope
      */
-    uniqueDescedants(parent: Fqn): Stream<AstNodeDescriptionWithFqn>;
+    uniqueDescedants(projectId: ProjectId, parent: Fqn): Stream<AstNodeDescriptionWithFqn>;
     protected createDocumentIndex(document: LikeC4LangiumDocument): DocumentFqnIndex;
 }
 export declare class DocumentFqnIndex {
@@ -36,6 +38,7 @@ export declare class DocumentFqnIndex {
      * All elements by FQN
      */
     private _byfqn;
+    readonly projectId: ProjectId;
     static readonly EMPTY: DocumentFqnIndex;
     constructor(_rootElements: Array<AstNodeDescriptionWithFqn>, 
     /**
@@ -49,7 +52,7 @@ export declare class DocumentFqnIndex {
     /**
      * All elements by FQN
      */
-    _byfqn: MultiMap<Fqn, AstNodeDescriptionWithFqn>);
+    _byfqn: MultiMap<Fqn, AstNodeDescriptionWithFqn>, projectId: ProjectId);
     rootElements(): readonly AstNodeDescriptionWithFqn[];
     byFqn(fqn: Fqn): readonly AstNodeDescriptionWithFqn[];
     children(parent: Fqn): readonly AstNodeDescriptionWithFqn[];

package/dist/model/fqn-index.js

@@ -16,12 +16,14 @@ import {
 import { logWarnError } from "../logger.js";
 import { ADisposable } from "../utils/index.js";
 import { readStrictFqn } from "../utils/elementRef.js";
+import { ProjectsManager } from "../workspace/index.js";
 export class FqnIndex extends ADisposable {
   constructor(services, cachePrefix = "fqn-index") {
     super();
     this.services = services;
     this.cachePrefix = cachePrefix;
     this.langiumDocuments = services.shared.workspace.LangiumDocuments;
+    this.projects = services.shared.workspace.ProjectsManager;
     this.documentCache = new DefaultWeakMap((doc) => this.createDocumentIndex(doc));
     this.workspaceCache = new WorkspaceCache(services.shared, DocumentState.IndexedContent);
     this.onDispose(
@@ -36,11 +38,12 @@ export class FqnIndex extends ADisposable {
       )
     );
   }
+  projects;
   langiumDocuments;
   documentCache;
   workspaceCache;
-  documents() {
-    return this.langiumDocuments.all.filter(
+  documents(projectId) {
+    return this.langiumDocuments.projectDocuments(projectId).filter(
       (d) => isLikeC4LangiumDocument(d) && d.state >= DocumentState.IndexedContent
     );
   }
@@ -62,17 +65,17 @@ export class FqnIndex extends ADisposable {
     this.get(doc);
     return nonNullable(ElementOps.readId(el), "Element fqn must be set, invalid state");
   }
-  byFqn(fqn) {
-    return stream(this.workspaceCache.get(`${this.cachePrefix}:${fqn}`, () => {
-      return this.documents().toArray().flatMap((doc) => {
+  byFqn(projectId, fqn) {
+    return stream(this.workspaceCache.get(`${this.cachePrefix}:${projectId}:${fqn}`, () => {
+      return this.documents(projectId).toArray().flatMap((doc) => {
         return this.get(doc).byFqn(fqn);
       });
     }));
   }
-  directChildrenOf(parent) {
+  directChildrenOf(projectId, parent) {
     return stream(
-      this.workspaceCache.get(`${this.cachePrefix}:directChildrenOf:${parent}`, () => {
-        const allchildren = this.documents().reduce((map, doc) => {
+      this.workspaceCache.get(`${this.cachePrefix}:${projectId}:directChildrenOf:${parent}`, () => {
+        const allchildren = this.documents(projectId).reduce((map, doc) => {
           this.get(doc).children(parent).forEach((desc) => {
             map.set(desc.name, desc);
           });
@@ -85,10 +88,10 @@ export class FqnIndex extends ADisposable {
   /**
    * Returns descedant elements with unique names in the scope
    */
-  uniqueDescedants(parent) {
+  uniqueDescedants(projectId, parent) {
     return stream(
-      this.workspaceCache.get(`${this.cachePrefix}:uniqueDescedants:${parent}`, () => {
-        const { children, descendants } = this.documents().reduce((map, doc) => {
+      this.workspaceCache.get(`${this.cachePrefix}:${projectId}:uniqueDescedants:${parent}`, () => {
+        const { children, descendants } = this.documents(projectId).reduce((map, doc) => {
           const docIndex = this.get(doc);
           docIndex.children(parent).forEach((desc) => {
             map.children.set(desc.name, desc);
@@ -181,20 +184,27 @@ export class FqnIndex extends ADisposable {
         logWarnError(e);
       }
     }
-    return new DocumentFqnIndex(root, children, descendants, byfqn);
+    return new DocumentFqnIndex(root, children, descendants, byfqn, this.projects.belongsTo(document));
   }
 }
 function uniqueByName(multimap) {
   return [...multimap.associations()].flatMap(([_name, descs]) => descs.length === 1 ? descs : []);
 }
 export class DocumentFqnIndex {
-  constructor(_rootElements, _children, _descendants, _byfqn) {
+  constructor(_rootElements, _children, _descendants, _byfqn, projectId) {
     this._rootElements = _rootElements;
     this._children = _children;
     this._descendants = _descendants;
     this._byfqn = _byfqn;
+    this.projectId = projectId;
   }
-  static EMPTY = new DocumentFqnIndex([], new MultiMap(), new MultiMap(), new MultiMap());
+  static EMPTY = new DocumentFqnIndex(
+    [],
+    new MultiMap(),
+    new MultiMap(),
+    new MultiMap(),
+    ProjectsManager.DefaultProjectId
+  );
   rootElements() {
     return this._rootElements;
   }

package/dist/model/model-builder.d.ts

@@ -1,15 +1,25 @@
 import type * as c4 from '@likec4/core';
 import { type ViewId, LikeC4Model } from '@likec4/core';
-import { type Cancellation, type URI, Disposable } from 'langium';
+import { type URI, Disposable } from 'langium';
+import { CancellationToken } from 'vscode-jsonrpc';
 import type { LikeC4Services } from '../module';
 import { ADisposable } from '../utils';
 type ModelParsedListener = (docs: URI[]) => void;
-export declare class LikeC4ModelBuilder extends ADisposable {
+export interface LikeC4ModelBuilder {
+    parseModel(projectId?: c4.ProjectId | undefined, cancelToken?: CancellationToken): Promise<c4.ParsedLikeC4ModelData | null>;
+    unsafeSyncBuildModel(projectId: c4.ProjectId): LikeC4Model.Computed;
+    buildLikeC4Model(projectId?: c4.ProjectId | undefined, cancelToken?: CancellationToken): Promise<LikeC4Model.Computed>;
+    computeView(viewId: ViewId, projectId?: c4.ProjectId | undefined, cancelToken?: CancellationToken): Promise<c4.ComputedView | null>;
+    onModelParsed(callback: ModelParsedListener): Disposable;
+}
+export declare class DefaultLikeC4ModelBuilder extends ADisposable implements LikeC4ModelBuilder {
+    private projects;
     private parser;
     private listeners;
     private cache;
     private DocumentBuilder;
     private LangiumDocuments;
+    private mutex;
     constructor(services: LikeC4Services);
     /**
      * WARNING:
@@ -17,16 +27,16 @@ export declare class LikeC4ModelBuilder extends ADisposable {
      * Otherwise, the model may be incomplete.
      */
     private unsafeSyncParseModel;
-    parseModel(cancelToken?: Cancellation.CancellationToken): Promise<c4.ParsedLikeC4Model | null>;
+    parseModel(projectId?: c4.ProjectId | undefined, cancelToken?: CancellationToken): Promise<c4.ParsedLikeC4ModelData | null>;
     private previousViews;
     /**
      * WARNING:
      * This method is internal and should to be called only when all documents are known to be parsed.
      * Otherwise, the model may be incomplete.
      */
-    unsafeSyncBuildModel(): LikeC4Model.Computed;
-    buildLikeC4Model(cancelToken?: Cancellation.CancellationToken): Promise<LikeC4Model.Computed>;
-    computeView(viewId: ViewId, cancelToken?: Cancellation.CancellationToken): Promise<c4.ComputedView | null>;
+    unsafeSyncBuildModel(projectId: c4.ProjectId): LikeC4Model.Computed;
+    buildLikeC4Model(projectId?: c4.ProjectId | undefined, cancelToken?: CancellationToken): Promise<LikeC4Model.Computed>;
+    computeView(viewId: ViewId, projectId?: c4.ProjectId | undefined, cancelToken?: CancellationToken): Promise<c4.ComputedView | null>;
     onModelParsed(callback: ModelParsedListener): Disposable;
     private documents;
     private notifyListeners;

package/dist/model/model-builder.js

@@ -6,7 +6,8 @@ import { loggable } from "@likec4/log";
 import { deepEqual as eq } from "fast-equals";
 import {
   Disposable,
-  DocumentState
+  DocumentState,
+  interruptAndCheck
 } from "langium";
 import prettyMs from "pretty-ms";
 import {
@@ -18,26 +19,31 @@ import {
   prop,
   values
 } from "remeda";
+import { CancellationToken } from "vscode-jsonrpc";
 import { isLikeC4Builtin } from "../likec4lib.js";
 import { logger as mainLogger, logWarnError } from "../logger.js";
 import { ADisposable } from "../utils/index.js";
 import { assignNavigateTo } from "../view-utils/index.js";
 import { buildModel } from "./builder/buildModel.js";
-const CACHE_KEY_PARSED_MODEL = "ParsedLikeC4Model";
-const CACHE_KEY_COMPUTED_MODEL = "ComputedLikeC4Model";
+const parsedModelCacheKey = (projectId) => `parsed-model-${projectId}`;
+const computedModelCacheKey = (projectId) => `computed-model-${projectId}`;
 const logger = mainLogger.getChild("ModelBuilder");
-export class LikeC4ModelBuilder extends ADisposable {
+export class DefaultLikeC4ModelBuilder extends ADisposable {
+  projects;
   parser;
   listeners = [];
   cache;
   DocumentBuilder;
   LangiumDocuments;
+  mutex;
   constructor(services) {
     super();
+    this.projects = services.shared.workspace.ProjectsManager;
     this.parser = services.likec4.ModelParser;
     this.cache = services.ValidatedWorkspaceCache;
     this.DocumentBuilder = services.shared.workspace.DocumentBuilder;
     this.LangiumDocuments = services.shared.workspace.LangiumDocuments;
+    this.mutex = services.shared.workspace.WorkspaceLock;
     this.onDispose(
       this.DocumentBuilder.onUpdate((_changed, deleted) => {
         if (deleted.length > 0) {
@@ -63,33 +69,38 @@ export class LikeC4ModelBuilder extends ADisposable {
    * This method is internal and should to be called only when all documents are known to be parsed.
    * Otherwise, the model may be incomplete.
    */
-  unsafeSyncParseModel() {
-    const docs = this.documents();
-    if (docs.length === 0) {
-      logger.debug("no documents to build model from");
-      return null;
-    }
+  unsafeSyncParseModel(projectId) {
     const cache = this.cache;
-    return cache.get(CACHE_KEY_PARSED_MODEL, () => {
+    const log = logger.getChild(["project", projectId]);
+    if (cache.has(parsedModelCacheKey(projectId))) {
+      log.debug("unsafeSyncParseModel from cache");
+    }
+    return cache.get(parsedModelCacheKey(projectId), () => {
+      const docs = this.documents(projectId);
+      if (docs.length === 0) {
+        logger.debug(`no documents to build model - project ${projectId}`);
+        return null;
+      }
+      log.debug("unsafeSyncParseModel from documents");
       return buildModel(docs);
     });
   }
-  async parseModel(cancelToken) {
+  async parseModel(projectId, cancelToken = CancellationToken.None) {
+    const project = this.projects.ensureProjectId(projectId);
+    const log = logger.getChild(["project", project]);
     const cache = this.cache;
-    const cached = cache.get(CACHE_KEY_PARSED_MODEL);
+    const cached = cache.get(parsedModelCacheKey(project));
     if (cached) {
-      logger.debug("parseModel from cache");
+      log.debug("parseModel from cache");
       return cached;
     }
-    if (this.LangiumDocuments.all.some((doc) => doc.state < DocumentState.Validated)) {
-      logger.debug("parseModel: waiting for documents to be validated");
-      await this.DocumentBuilder.waitUntil(DocumentState.Validated, cancelToken);
-      logger.debug("parseModel: documents are validated");
-    }
     const t0 = performance.now();
-    const result = this.unsafeSyncParseModel();
-    logger.debug(`parseModel in ${prettyMs(performance.now() - t0)}`);
-    return result;
+    return await this.mutex.read(async () => {
+      await interruptAndCheck(cancelToken);
+      const result = this.unsafeSyncParseModel(project);
+      log.debug(`parseModel in ${prettyMs(performance.now() - t0)}`);
+      return result;
+    });
   }
   previousViews = {};
   /**
@@ -97,11 +108,11 @@ export class LikeC4ModelBuilder extends ADisposable {
    * This method is internal and should to be called only when all documents are known to be parsed.
    * Otherwise, the model may be incomplete.
    */
-  unsafeSyncBuildModel() {
+  unsafeSyncBuildModel(projectId) {
     const cache = this.cache;
     const viewsCache = this.cache;
-    return cache.get(CACHE_KEY_COMPUTED_MODEL, () => {
-      const parsed = this.unsafeSyncParseModel();
+    return cache.get(computedModelCacheKey(projectId), () => {
+      const parsed = this.unsafeSyncParseModel(projectId);
       if (!parsed) {
         return LikeC4Model.EMPTY;
       }
@@ -121,52 +132,55 @@ export class LikeC4ModelBuilder extends ADisposable {
       }
       assignNavigateTo(allViews);
       const views = mapToObj(allViews, (v) => {
-        const previous = this.previousViews[v.id];
+        const key = computedViewKey(projectId, v.id);
+        const previous = this.previousViews[key];
         const view = previous && eq(v, previous) ? previous : v;
-        viewsCache.set(computedViewKey(v.id), view);
+        viewsCache.set(key, view);
         return [v.id, view];
       });
-      this.previousViews = { ...views };
+      this.previousViews = { ...this.previousViews, ...views };
       return LikeC4Model.create({
         ...model,
         views
       });
     });
   }
-  async buildLikeC4Model(cancelToken) {
+  async buildLikeC4Model(projectId, cancelToken = CancellationToken.None) {
+    const project = this.projects.ensureProjectId(projectId);
+    const log = logger.getChild(["project", project]);
     const cache = this.cache;
-    const cached = cache.get(CACHE_KEY_COMPUTED_MODEL);
+    const cached = cache.get(computedModelCacheKey(project));
     if (cached) {
-      logger.debug("buildLikeC4Model from cache");
+      log.debug("buildLikeC4Model from cache");
       return cached;
     }
     const t0 = performance.now();
-    const model = await this.parseModel(cancelToken);
-    if (!model) {
-      logger.debug("buildLikeC4Model: no model");
-      return LikeC4Model.EMPTY;
-    }
-    const result = this.unsafeSyncBuildModel();
-    logger.debug(`buildLikeC4Model in ${prettyMs(performance.now() - t0)}`);
-    return result;
+    return await this.mutex.read(async () => {
+      await interruptAndCheck(cancelToken);
+      const result = this.unsafeSyncBuildModel(project);
+      log.debug(`buildLikeC4Model in ${prettyMs(performance.now() - t0)}`);
+      return result;
+    });
   }
-  async computeView(viewId, cancelToken) {
+  async computeView(viewId, projectId, cancelToken = CancellationToken.None) {
+    const project = this.projects.ensureProjectId(projectId);
+    const log = logger.getChild(["project", project]);
     const cache = this.cache;
-    const cacheKey = computedViewKey(viewId);
+    const cacheKey = computedViewKey(project, viewId);
     if (cache.has(cacheKey)) {
       return cache.get(cacheKey);
     }
-    const parsed = await this.parseModel(cancelToken);
+    const parsed = await this.parseModel(project, cancelToken);
     if (!parsed) {
       return null;
     }
     return cache.get(cacheKey, () => {
       const view = parsed.views[viewId];
       if (!view) {
-        logger.warn`computeView: cant find view ${viewId}`;
+        log.warn`computeView: cant find view ${viewId}`;
         return null;
       }
-      logger.debug`computeView: ${viewId}`;
+      log.debug`computeView: ${viewId}`;
       const computeView = LikeC4Model.makeCompute(parsed);
       const result = computeView(view);
       if (!result.isSuccess) {
@@ -189,11 +203,11 @@ export class LikeC4ModelBuilder extends ADisposable {
           }
         }
       }
-      const previous = this.previousViews[viewId];
+      const previous = this.previousViews[cacheKey];
       if (previous && eq(computedView, previous)) {
         computedView = previous;
       } else {
-        this.previousViews[viewId] = computedView;
+        this.previousViews[cacheKey] = computedView;
       }
       return computedView;
     });
@@ -207,8 +221,8 @@ export class LikeC4ModelBuilder extends ADisposable {
       }
     });
   }
-  documents() {
-    return this.parser.documents().toArray();
+  documents(projectId) {
+    return this.parser.documents(projectId).toArray();
   }
   notifyListeners(docs) {
     for (const listener of this.listeners) {
@@ -220,6 +234,6 @@ export class LikeC4ModelBuilder extends ADisposable {
     }
   }
 }
-function computedViewKey(viewId) {
-  return `computed-view-${viewId}`;
+function computedViewKey(projectId, viewId) {
+  return `computed-view-${projectId}-${viewId}`;
 }

package/dist/model/model-locator.d.ts

@@ -1,6 +1,6 @@
 import type * as c4 from '@likec4/core';
 import type { Location } from 'vscode-languageserver-types';
-import type { ParsedAstElement } from '../ast';
+import type { ParsedAstElement, ParsedAstView, ParsedLikeC4LangiumDocument } from '../ast';
 import { ast } from '../ast';
 import type { LikeC4Services } from '../module';
 export declare class LikeC4ModelLocator {
@@ -9,16 +9,17 @@ export declare class LikeC4ModelLocator {
     private deploymentsIndex;
     private langiumDocuments;
     private parser;
+    private projects;
     constructor(services: LikeC4Services);
     private documents;
-    getParsedElement(astNodeOrFqn: ast.Element | c4.Fqn): ParsedAstElement | null;
-    locateElement(fqn: c4.Fqn, _prop?: string): Location | null;
-    locateDeploymentElement(fqn: c4.Fqn, _prop?: string): Location | null;
-    locateRelation(relationId: c4.RelationId): Location | null;
-    locateViewAst(viewId: c4.ViewId): {
-        doc: Stream<import("../ast").ParsedLikeC4LangiumDocument>;
-        view: any;
+    getParsedElement(...args: [ast.Element] | [c4.Fqn] | [c4.Fqn, c4.ProjectId]): ParsedAstElement | null;
+    locateElement(fqn: c4.Fqn, projectId?: c4.ProjectId | undefined): Location | null;
+    locateDeploymentElement(fqn: c4.Fqn, projectId?: c4.ProjectId | undefined): Location | null;
+    locateRelation(relationId: c4.RelationId, projectId?: c4.ProjectId): Location | null;
+    locateViewAst(viewId: c4.ViewId, projectId?: c4.ProjectId | undefined): null | {
+        doc: ParsedLikeC4LangiumDocument;
+        view: ParsedAstView;
         viewAst: ast.LikeC4View;
-    } | null;
-    locateView(viewId: c4.ViewId): Location | null;
+    };
+    locateView(viewId: c4.ViewId, projectId?: c4.ProjectId): Location | null;
 }

package/dist/model/model-locator.js

@@ -1,6 +1,7 @@
 import { AstUtils, GrammarUtils } from "langium";
 import { isString } from "remeda";
 import { ast } from "../ast.js";
+import { projectIdFrom } from "../utils/index.js";
 const { findNodeForKeyword, findNodeForProperty } = GrammarUtils;
 const { getDocument } = AstUtils;
 export class LikeC4ModelLocator {
@@ -10,18 +11,31 @@ export class LikeC4ModelLocator {
     this.deploymentsIndex = services.likec4.DeploymentsIndex;
     this.langiumDocuments = services.shared.workspace.LangiumDocuments;
     this.parser = services.likec4.ModelParser;
+    this.projects = services.shared.workspace.ProjectsManager;
   }
   fqnIndex;
   deploymentsIndex;
   langiumDocuments;
   parser;
-  documents() {
-    return this.parser.documents();
+  projects;
+  documents(projectId) {
+    return this.parser.documents(projectId);
   }
-  getParsedElement(astNodeOrFqn) {
+  // public getParsedElement(astNodeOrFqn: ast.Element): ParsedAstElement | null
+  // public getParsedElement(astNodeOrFqn: c4.Fqn, projectId?: c4.ProjectId): ParsedAstElement | null
+  getParsedElement(...args) {
+    let astNodeOrFqn;
+    let projectId;
+    if (args.length === 2) {
+      astNodeOrFqn = args[0];
+      projectId = args[1];
+    } else {
+      astNodeOrFqn = args[0];
+      projectId = isString(astNodeOrFqn) ? this.projects.ensureProjectId() : projectIdFrom(astNodeOrFqn);
+    }
     if (isString(astNodeOrFqn)) {
       const fqn2 = astNodeOrFqn;
-      const entry = this.fqnIndex.byFqn(astNodeOrFqn).head();
+      const entry = this.fqnIndex.byFqn(projectId, astNodeOrFqn).head();
       if (!entry) {
         return null;
       }
@@ -35,8 +49,9 @@ export class LikeC4ModelLocator {
     const doc = this.parser.parse(getDocument(astNodeOrFqn));
     return doc.c4Elements.find((e) => e.id === fqn) ?? null;
   }
-  locateElement(fqn, _prop) {
-    const entry = this.fqnIndex.byFqn(fqn).head();
+  locateElement(fqn, projectId) {
+    const _projectId = this.projects.ensureProjectId(projectId);
+    const entry = this.fqnIndex.byFqn(_projectId, fqn).head();
     const docsegment = entry?.nameSegment ?? entry?.selectionSegment;
     if (!entry || !docsegment) {
       return null;
@@ -46,8 +61,9 @@ export class LikeC4ModelLocator {
       range: docsegment.range
     };
   }
-  locateDeploymentElement(fqn, _prop) {
-    const entry = this.deploymentsIndex.byFqn(fqn).head();
+  locateDeploymentElement(fqn, projectId) {
+    const _projectId = this.projects.ensureProjectId(projectId);
+    const entry = this.deploymentsIndex.byFqn(_projectId, fqn).head();
     const docsegment = entry?.nameSegment ?? entry?.selectionSegment;
     if (!entry || !docsegment) {
       return null;
@@ -57,8 +73,9 @@ export class LikeC4ModelLocator {
       range: docsegment.range
     };
   }
-  locateRelation(relationId) {
-    for (const doc of this.documents()) {
+  locateRelation(relationId, projectId) {
+    const project = this.projects.ensureProjectId(projectId);
+    for (const doc of this.documents(project)) {
       const relation = doc.c4Relations.find((r) => r.id === relationId) ?? doc.c4DeploymentRelations.find((r) => r.id === relationId);
       if (!relation) {
         continue;
@@ -84,8 +101,9 @@ export class LikeC4ModelLocator {
     }
     return null;
   }
-  locateViewAst(viewId) {
-    for (const doc of this.documents()) {
+  locateViewAst(viewId, projectId) {
+    const project = this.projects.ensureProjectId(projectId);
+    for (const doc of this.documents(project)) {
       const view = doc.c4Views.find((r) => r.id === viewId);
       if (!view) {
         continue;
@@ -104,8 +122,8 @@ export class LikeC4ModelLocator {
     }
     return null;
   }
-  locateView(viewId) {
-    const res = this.locateViewAst(viewId);
+  locateView(viewId, projectId) {
+    const res = this.locateViewAst(viewId, projectId);
     if (!res) {
       return null;
     }