@likec4/language-server 1.23.1 → 1.24.1

package/dist/model/model-parser.js

@@ -1,7 +1,10 @@
-import { invariant } from "@likec4/core";
-import { DocumentCache, DocumentState } from "langium";
+import { DefaultWeakMap } from "@likec4/core/utils";
+import { loggable } from "@likec4/log";
+import { DocumentState } from "langium";
 import { pipe } from "remeda";
-import { isFqnIndexedDocument } from "../ast.js";
+import { DiagnosticSeverity } from "vscode-languageserver-types";
+import { isLikeC4Builtin } from "../likec4lib.js";
+import { logger as rootLogger } from "../logger.js";
 import { BaseParser } from "./parser/Base.js";
 import { DeploymentModelParser } from "./parser/DeploymentModelParser.js";
 import { DeploymentViewParser } from "./parser/DeploymentViewParser.js";
@@ -24,53 +27,80 @@ const DocumentParserFromMixins = pipe(
 );
 export class DocumentParser extends DocumentParserFromMixins {
 }
+const logger = rootLogger.getChild("ModelParser");
 export class LikeC4ModelParser {
   constructor(services) {
     this.services = services;
-    this.cachedParsers = new DocumentCache(services.shared, DocumentState.Validated);
+    services.shared.workspace.DocumentBuilder.onDocumentPhase(
+      DocumentState.Linked,
+      (doc) => {
+        try {
+          if (!isLikeC4Builtin(doc.uri)) {
+            this.cachedParsers.set(doc, this.createParser(doc));
+          }
+        } catch (e) {
+          logger.warn(loggable(e));
+        }
+      }
+    );
+    services.shared.workspace.DocumentBuilder.onDocumentPhase(
+      DocumentState.Validated,
+      (doc) => {
+        if (doc.diagnostics?.some((d) => d.severity === DiagnosticSeverity.Error)) {
+          this.cachedParsers.delete(doc);
+        }
+      }
+    );
+  }
+  cachedParsers = new DefaultWeakMap((doc) => this.createParser(doc));
+  documents() {
+    return this.services.shared.workspace.LangiumDocuments.all.map(
+      (d) => this.parse(d)
+    );
   }
-  cachedParsers;
   parse(doc) {
-    invariant(isFqnIndexedDocument(doc), `Not a FqnIndexedDocument: ${doc.uri.toString(true)}`);
     try {
-      const props = {
-        c4Specification: {
-          tags: /* @__PURE__ */ new Set(),
-          elements: {},
-          relationships: {},
-          colors: {},
-          deployments: {}
-        },
-        c4Elements: [],
-        c4ExtendElements: [],
-        c4Relations: [],
-        c4Deployments: [],
-        c4DeploymentRelations: [],
-        c4Globals: {
-          predicates: {},
-          dynamicPredicates: {},
-          styles: {}
-        },
-        c4Views: []
-      };
-      doc = Object.assign(doc, props);
       const parser = this.forDocument(doc);
-      parser.parseSpecification();
-      parser.parseModel();
-      parser.parseGlobals();
-      parser.parseDeployment();
-      parser.parseViews();
       return parser.doc;
     } catch (cause) {
       throw new Error(`Error parsing document ${doc.uri.toString()}`, { cause });
     }
   }
   forDocument(doc) {
-    invariant(isFqnIndexedDocument(doc), `Not a FqnIndexedDocument: ${doc.uri.toString(true)}`);
-    return this.cachedParsers.get(
-      doc.uri,
-      "DocumentParser",
-      () => new DocumentParser(this.services, doc)
-    );
+    if (doc.state < DocumentState.Linked) {
+      logger.warn(`Document ${doc.uri.toString()} is not linked`);
+    }
+    return this.cachedParsers.get(doc);
+  }
+  createParser(doc) {
+    const props = {
+      c4Specification: {
+        tags: /* @__PURE__ */ new Set(),
+        elements: {},
+        relationships: {},
+        colors: {},
+        deployments: {}
+      },
+      c4Elements: [],
+      c4ExtendElements: [],
+      c4ExtendDeployments: [],
+      c4Relations: [],
+      c4Deployments: [],
+      c4DeploymentRelations: [],
+      c4Globals: {
+        predicates: {},
+        dynamicPredicates: {},
+        styles: {}
+      },
+      c4Views: []
+    };
+    doc = Object.assign(doc, props);
+    const parser = new DocumentParser(this.services, doc);
+    parser.parseSpecification();
+    parser.parseModel();
+    parser.parseGlobals();
+    parser.parseDeployment();
+    parser.parseViews();
+    return parser;
   }
 }

package/dist/model/parser/Base.d.ts

@@ -1,6 +1,6 @@
 import type * as c4 from '@likec4/core';
 import type { AstNode } from 'langium';
-import { type ParsedLikeC4LangiumDocument, type ParsedLink, ast } from '../../ast';
+import { type ParsedLikeC4LangiumDocument, ast } from '../../ast';
 import type { LikeC4Services } from '../../module';
 import { type IsValidFn } from '../../validation';
 export type GConstructor<T = {}> = new (...args: any[]) => T;
@@ -23,6 +23,6 @@ export declare class BaseParser {
     parseTags<E extends {
         tags?: ast.Tags;
     }>(withTags?: E): c4.NonEmptyArray<c4.Tag> | null;
-    convertLinks(source?: ast.LinkProperty['$container']): ParsedLink[] | undefined;
-    parseLinks(source?: ast.LinkProperty['$container']): ParsedLink[] | undefined;
+    convertLinks(source?: ast.LinkProperty['$container']): c4.Link[] | undefined;
+    parseLinks(source?: ast.LinkProperty['$container']): c4.Link[] | undefined;
 }

package/dist/model/parser/Base.js

@@ -1,8 +1,8 @@
-import { invariant, isNonEmptyArray } from "@likec4/core";
+import { isNonEmptyArray } from "@likec4/core";
 import { filter, flatMap, fromEntries, isEmpty, isNonNullish, isTruthy, map, pipe, unique } from "remeda";
 import stripIndent from "strip-indent";
 import { ast } from "../../ast.js";
-import { getFqnElementRef } from "../../utils/elementRef.js";
+import { readStrictFqn } from "../../utils/elementRef.js";
 import { checksFromDiagnostics } from "../../validation/index.js";
 export function toSingleLine(str) {
   return isNonNullish(str) ? removeIndent(str).split("\n").join(" ") : void 0;
@@ -18,15 +18,16 @@ export class BaseParser {
   }
   isValid;
   resolveFqn(node) {
+    if (ast.isExtendElement(node)) {
+      return readStrictFqn(node.element);
+    }
+    if (ast.isExtendDeployment(node)) {
+      return readStrictFqn(node.deploymentNode);
+    }
     if (ast.isDeploymentElement(node)) {
       return this.services.likec4.DeploymentsIndex.getFqn(node);
     }
-    if (ast.isExtendElement(node)) {
-      return getFqnElementRef(node.element);
-    }
-    const fqn = this.services.likec4.FqnIndex.getFqn(node);
-    invariant(fqn, `Not indexed element: ${this.getAstNodePath(node)}`);
-    return fqn;
+    return this.services.likec4.FqnIndex.getFqn(node);
   }
   getAstNodePath(node) {
     return this.services.workspace.AstNodeLocator.getAstNodePath(node);
@@ -84,7 +85,12 @@ export class BaseParser {
         const url = p.value;
         if (isTruthy(url)) {
           const title = isTruthy(p.title) ? toSingleLine(p.title) : void 0;
-          return title ? { url, title } : { url };
+          const relative = this.services.lsp.DocumentLinkProvider.relativeLink(this.doc, url);
+          return {
+            url,
+            ...title && { title },
+            ...relative && relative !== url && { relative }
+          };
         }
         return [];
       })

package/dist/model/parser/DeploymentModelParser.d.ts

@@ -1,5 +1,5 @@
 import type * as c4 from '@likec4/core';
-import { type ParsedAstDeployment, type ParsedAstDeploymentRelation, ast } from '../../ast';
+import { type ParsedAstDeployment, type ParsedAstDeploymentRelation, type ParsedAstExtend, ast } from '../../ast';
 import type { WithExpressionV2 } from './FqnRefParser';
 export type WithDeploymentModel = ReturnType<typeof DeploymentModelParser>;
 export declare function DeploymentModelParser<TBase extends WithExpressionV2>(B: TBase): {
@@ -7,6 +7,7 @@ export declare function DeploymentModelParser<TBase extends WithExpressionV2>(B:
         parseDeployment(): void;
         parseDeploymentNode(astNode: ast.DeploymentNode): ParsedAstDeployment.Node;
         parseDeployedInstance(astNode: ast.DeployedInstance): ParsedAstDeployment.Instance;
+        parseExtendDeployment(astNode: ast.ExtendDeployment): ParsedAstExtend | null;
         parseDeploymentRelation(astNode: ast.DeploymentRelation): ParsedAstDeploymentRelation;
         parseFqnRef(astNode: ast.FqnRef): c4.FqnRef;
         parseFqnExpr(astNode: ast.FqnExpr): c4.FqnExpr;
@@ -29,7 +30,7 @@ export declare function DeploymentModelParser<TBase extends WithExpressionV2>(B:
         parseTags<E extends {
             tags?: ast.Tags;
         }>(withTags?: E): c4.NonEmptyArray<c4.Tag> | null;
-        convertLinks(source?: ast.LinkProperty["$container"]): import("../../ast").ParsedLink[] | undefined;
-        parseLinks(source?: ast.LinkProperty["$container"]): import("../../ast").ParsedLink[] | undefined;
+        convertLinks(source?: ast.LinkProperty["$container"]): c4.Link[] | undefined;
+        parseLinks(source?: ast.LinkProperty["$container"]): c4.Link[] | undefined;
     };
 } & TBase;

package/dist/model/parser/DeploymentModelParser.js

@@ -1,8 +1,7 @@
-import { FqnRef, isNonEmptyArray, nameFromFqn, nonexhaustive, nonNullable } from "@likec4/core";
-import { filter, first, isTruthy, map, mapToObj, pipe } from "remeda";
+import { FqnRef, isNonEmptyArray, LinkedList, nameFromFqn, nonexhaustive, nonNullable } from "@likec4/core";
+import { filter, first, isEmpty, isTruthy, map, mapToObj, pipe } from "remeda";
 import {
   ast,
-  streamDeploymentModel,
   toElementStyle,
   toRelationshipStyleExcludeDefaults
 } from "../../ast.js";
@@ -10,6 +9,31 @@ import { logWarnError } from "../../logger.js";
 import { elementRef } from "../../utils/elementRef.js";
 import { stringHash } from "../../utils/stringHash.js";
 import { removeIndent, toSingleLine } from "./Base.js";
+function* streamDeploymentModel(doc) {
+  const traverseStack = LinkedList.from(
+    doc.parseResult.value.deployments.flatMap((m) => m.elements)
+  );
+  const relations = [];
+  let el;
+  while (el = traverseStack.shift()) {
+    if (ast.isDeploymentRelation(el)) {
+      relations.push(el);
+      continue;
+    }
+    if (ast.isDeployedInstance(el)) {
+      yield el;
+      continue;
+    }
+    if (el.body && el.body.elements.length > 0) {
+      for (const child of el.body.elements) {
+        traverseStack.push(child);
+      }
+    }
+    yield el;
+  }
+  yield* relations;
+  return;
+}
 export function DeploymentModelParser(B) {
   return class DeploymentModelParser extends B {
     parseDeployment() {
@@ -30,6 +54,13 @@ export function DeploymentModelParser(B) {
               doc.c4Deployments.push(this.parseDeploymentNode(el));
               break;
             }
+            case ast.isExtendDeployment(el): {
+              const parsed = this.parseExtendDeployment(el);
+              if (parsed) {
+                doc.c4ExtendDeployments.push(parsed);
+              }
+              break;
+            }
             default:
               nonexhaustive(el);
           }
@@ -112,6 +143,26 @@ export function DeploymentModelParser(B) {
         style
       };
     }
+    parseExtendDeployment(astNode) {
+      if (!this.isValid(astNode)) {
+        return null;
+      }
+      const id = this.resolveFqn(astNode);
+      const tags = this.parseTags(astNode.body);
+      const metadata = this.getMetadata(astNode.body?.props.find(ast.isMetadataProperty));
+      const astPath = this.getAstNodePath(astNode);
+      const links = this.parseLinks(astNode.body) ?? [];
+      if (!tags && isEmpty(metadata ?? {}) && isEmpty(links)) {
+        return null;
+      }
+      return {
+        id,
+        astPath,
+        ...metadata && { metadata },
+        ...tags && { tags },
+        ...links && isNonEmptyArray(links) && { links }
+      };
+    }
     parseDeploymentRelation(astNode) {
       const isValid = this.isValid;
       const astPath = this.getAstNodePath(astNode);

package/dist/model/parser/DeploymentViewParser.d.ts

@@ -30,11 +30,12 @@ export declare function DeploymentViewParser<TBase extends WithExpressionV2 & Wi
         parseTags<E extends {
             tags?: ast.Tags;
         }>(withTags?: E): c4.NonEmptyArray<c4.Tag> | null;
-        convertLinks(source?: ast.LinkProperty["$container"]): import("../../ast").ParsedLink[] | undefined;
-        parseLinks(source?: ast.LinkProperty["$container"]): import("../../ast").ParsedLink[] | undefined;
+        convertLinks(source?: ast.LinkProperty["$container"]): c4.Link[] | undefined;
+        parseLinks(source?: ast.LinkProperty["$container"]): c4.Link[] | undefined;
         parseDeployment(): void;
         parseDeploymentNode(astNode: ast.DeploymentNode): import("../../ast").ParsedAstDeployment.Node;
         parseDeployedInstance(astNode: ast.DeployedInstance): import("../../ast").ParsedAstDeployment.Instance;
+        parseExtendDeployment(astNode: ast.ExtendDeployment): import("../../ast").ParsedAstExtend | null;
         parseDeploymentRelation(astNode: ast.DeploymentRelation): import("../../ast").ParsedAstDeploymentRelation;
     };
 } & TBase;

package/dist/model/parser/FqnRefParser.d.ts

@@ -25,7 +25,7 @@ export declare function ExpressionV2Parser<TBase extends Base>(B: TBase): {
         parseTags<E extends {
             tags?: ast.Tags;
         }>(withTags?: E): c4.NonEmptyArray<c4.Tag> | null;
-        convertLinks(source?: ast.LinkProperty["$container"]): import("../../ast").ParsedLink[] | undefined;
-        parseLinks(source?: ast.LinkProperty["$container"]): import("../../ast").ParsedLink[] | undefined;
+        convertLinks(source?: ast.LinkProperty["$container"]): c4.Link[] | undefined;
+        parseLinks(source?: ast.LinkProperty["$container"]): c4.Link[] | undefined;
     };
 } & TBase;

package/dist/model/parser/GlobalsParser.d.ts

@@ -47,8 +47,8 @@ export declare function GlobalsParser<TBase extends WithViewsParser>(B: TBase):
         parseTags<E extends {
             tags?: ast.Tags;
         }>(withTags?: E): c4.NonEmptyArray<c4.Tag> | null;
-        convertLinks(source?: ast.LinkProperty["$container"]): import("../../ast").ParsedLink[] | undefined;
-        parseLinks(source?: ast.LinkProperty["$container"]): import("../../ast").ParsedLink[] | undefined;
+        convertLinks(source?: ast.LinkProperty["$container"]): c4.Link[] | undefined;
+        parseLinks(source?: ast.LinkProperty["$container"]): c4.Link[] | undefined;
         parseDeploymentView(astNode: ast.DeploymentView): import("../../ast").ParsedAstDeploymentView;
         parseDeploymentViewRule(astRule: ast.DeploymentViewRule): c4.DeploymentViewRule;
         parseDeploymentViewRulePredicate(astRule: ast.DeploymentViewRulePredicate): c4.DeploymentViewRulePredicate;
@@ -63,6 +63,7 @@ export declare function GlobalsParser<TBase extends WithViewsParser>(B: TBase):
         parseDeployment(): void;
         parseDeploymentNode(astNode: ast.DeploymentNode): import("../../ast").ParsedAstDeployment.Node;
         parseDeployedInstance(astNode: ast.DeployedInstance): import("../../ast").ParsedAstDeployment.Instance;
+        parseExtendDeployment(astNode: ast.ExtendDeployment): import("../../ast").ParsedAstExtend | null;
         parseDeploymentRelation(astNode: ast.DeploymentRelation): import("../../ast").ParsedAstDeploymentRelation;
     };
 } & TBase;

package/dist/model/parser/ModelParser.d.ts

@@ -1,12 +1,12 @@
 import type * as c4 from '@likec4/core';
-import { type ParsedAstElement, type ParsedAstExtendElement, type ParsedAstRelation, ast } from '../../ast';
+import { type ParsedAstElement, type ParsedAstExtend, type ParsedAstRelation, ast } from '../../ast';
 import { type Base } from './Base';
 export type WithModel = ReturnType<typeof ModelParser>;
 export declare function ModelParser<TBase extends Base>(B: TBase): {
     new (...args: any[]): {
         parseModel(): void;
         parseElement(astNode: ast.Element): ParsedAstElement;
-        parseExtendElement(astNode: ast.ExtendElement): ParsedAstExtendElement | null;
+        parseExtendElement(astNode: ast.ExtendElement): ParsedAstExtend | null;
         parseRelation(astNode: ast.Relation): ParsedAstRelation;
         isValid: import("../../validation").IsValidFn;
         readonly services: import("../..").LikeC4Services;
@@ -22,7 +22,7 @@ export declare function ModelParser<TBase extends Base>(B: TBase): {
         parseTags<E extends {
             tags?: ast.Tags;
         }>(withTags?: E): c4.NonEmptyArray<c4.Tag> | null;
-        convertLinks(source?: ast.LinkProperty["$container"]): import("../../ast").ParsedLink[] | undefined;
-        parseLinks(source?: ast.LinkProperty["$container"]): import("../../ast").ParsedLink[] | undefined;
+        convertLinks(source?: ast.LinkProperty["$container"]): c4.Link[] | undefined;
+        parseLinks(source?: ast.LinkProperty["$container"]): c4.Link[] | undefined;
     };
 } & TBase;

package/dist/model/parser/ModelParser.js

@@ -1,15 +1,56 @@
-import { isNonEmptyArray, nonexhaustive, nonNullable } from "@likec4/core";
-import { filter, first, isEmpty, isNonNullish, isTruthy, map, mapToObj, pipe } from "remeda";
+import { isNonEmptyArray, LinkedList, nonexhaustive, nonNullable } from "@likec4/core";
+import { filter, first, isDefined, isEmpty, isNonNullish, isTruthy, map, mapToObj, pipe } from "remeda";
 import {
   ast,
-  resolveRelationPoints,
-  streamModel,
   toElementStyle,
   toRelationshipStyleExcludeDefaults
 } from "../../ast.js";
 import { logWarnError } from "../../logger.js";
+import { elementRef } from "../../utils/elementRef.js";
 import { stringHash } from "../../utils/stringHash.js";
 import { removeIndent, toSingleLine } from "./Base.js";
+function resolveRelationPoints(node) {
+  const target = elementRef(node.target);
+  if (!target) {
+    throw new Error("RelationRefError: Invalid reference to target");
+  }
+  if (isDefined(node.source)) {
+    const source = elementRef(node.source);
+    if (!source) {
+      throw new Error("RelationRefError: Invalid reference to source");
+    }
+    return {
+      source,
+      target
+    };
+  }
+  if (!ast.isElementBody(node.$container)) {
+    throw new Error("RelationRefError: Invalid container for sourceless relation");
+  }
+  return {
+    source: node.$container.$container,
+    target
+  };
+}
+function* streamModel(doc) {
+  const traverseStack = LinkedList.from(doc.parseResult.value.models.flatMap((m) => m.elements));
+  const relations = [];
+  let el;
+  while (el = traverseStack.shift()) {
+    if (ast.isRelation(el)) {
+      relations.push(el);
+      continue;
+    }
+    if (el.body && el.body.elements && el.body.elements.length > 0) {
+      for (const child of el.body.elements) {
+        traverseStack.push(child);
+      }
+    }
+    yield el;
+  }
+  yield* relations;
+  return;
+}
 export function ModelParser(B) {
   return class ModelParser extends B {
     parseModel() {

package/dist/model/parser/PredicatesParser.d.ts

@@ -28,7 +28,7 @@ export declare function PredicatesParser<TBase extends Base>(B: TBase): {
         parseTags<E extends {
             tags?: ast.Tags;
         }>(withTags?: E): c4.NonEmptyArray<c4.Tag> | null;
-        convertLinks(source?: ast.LinkProperty["$container"]): import("../../ast").ParsedLink[] | undefined;
-        parseLinks(source?: ast.LinkProperty["$container"]): import("../../ast").ParsedLink[] | undefined;
+        convertLinks(source?: ast.LinkProperty["$container"]): c4.Link[] | undefined;
+        parseLinks(source?: ast.LinkProperty["$container"]): c4.Link[] | undefined;
     };
 } & TBase;

package/dist/model/parser/SpecificationParser.d.ts

@@ -21,7 +21,7 @@ export declare function SpecificationParser<TBase extends Base>(B: TBase): {
         parseTags<E extends {
             tags?: ast.Tags;
         }>(withTags?: E): c4.NonEmptyArray<c4.Tag> | null;
-        convertLinks(source?: ast.LinkProperty["$container"]): import("../../ast").ParsedLink[] | undefined;
-        parseLinks(source?: ast.LinkProperty["$container"]): import("../../ast").ParsedLink[] | undefined;
+        convertLinks(source?: ast.LinkProperty["$container"]): c4.Link[] | undefined;
+        parseLinks(source?: ast.LinkProperty["$container"]): c4.Link[] | undefined;
     };
 } & TBase;

package/dist/model/parser/ViewsParser.d.ts

@@ -45,8 +45,8 @@ export declare function ViewsParser<TBase extends WithPredicates & WithDeploymen
         parseTags<E extends {
             tags?: ast.Tags;
         }>(withTags?: E): c4.NonEmptyArray<c4.Tag> | null;
-        convertLinks(source?: ast.LinkProperty["$container"]): import("../../ast").ParsedLink[] | undefined;
-        parseLinks(source?: ast.LinkProperty["$container"]): import("../../ast").ParsedLink[] | undefined;
+        convertLinks(source?: ast.LinkProperty["$container"]): c4.Link[] | undefined;
+        parseLinks(source?: ast.LinkProperty["$container"]): c4.Link[] | undefined;
         parseDeploymentView(astNode: ast.DeploymentView): import("../../ast").ParsedAstDeploymentView;
         parseDeploymentViewRule(astRule: ast.DeploymentViewRule): c4.DeploymentViewRule;
         parseDeploymentViewRulePredicate(astRule: ast.DeploymentViewRulePredicate): c4.DeploymentViewRulePredicate;
@@ -61,6 +61,7 @@ export declare function ViewsParser<TBase extends WithPredicates & WithDeploymen
         parseDeployment(): void;
         parseDeploymentNode(astNode: ast.DeploymentNode): import("../../ast").ParsedAstDeployment.Node;
         parseDeployedInstance(astNode: ast.DeployedInstance): import("../../ast").ParsedAstDeployment.Instance;
+        parseExtendDeployment(astNode: ast.ExtendDeployment): import("../../ast").ParsedAstExtend | null;
         parseDeploymentRelation(astNode: ast.DeploymentRelation): import("../../ast").ParsedAstDeploymentRelation;
     };
 } & TBase;

package/dist/module.d.ts

@@ -1,5 +1,5 @@
 import { GraphvizLayouter } from '@likec4/layouts';
-import { type Module, DocumentCache, WorkspaceCache } from 'langium';
+import { type Module, WorkspaceCache } from 'langium';
 import { type DefaultSharedModuleContext, type LangiumServices, type LangiumSharedServices, type PartialLangiumServices } from 'langium/lsp';
 import { LikeC4DocumentationProvider } from './documentation';
 import { LikeC4CodeLensProvider, LikeC4CompletionProvider, LikeC4DocumentHighlightProvider, LikeC4DocumentLinkProvider, LikeC4DocumentSymbolProvider, LikeC4HoverProvider, LikeC4SemanticTokenProvider } from './lsp';
@@ -26,8 +26,7 @@ export interface LikeC4AddedServices {
     documentation: {
         DocumentationProvider: LikeC4DocumentationProvider;
     };
-    WorkspaceCache: WorkspaceCache<string, any>;
-    DocumentCache: DocumentCache<string, any>;
+    ValidatedWorkspaceCache: WorkspaceCache<string, any>;
     Rpc: Rpc;
     likec4: {
         Views: LikeC4Views;

package/dist/module.js

@@ -1,6 +1,6 @@
 import { GraphvizLayouter, GraphvizWasmAdapter } from "@likec4/layouts";
 import {
-  DocumentCache,
+  DocumentState,
   EmptyFileSystem,
   inject,
   WorkspaceCache
@@ -62,8 +62,7 @@ export const LikeC4Module = {
   documentation: {
     DocumentationProvider: bind(LikeC4DocumentationProvider)
   },
-  WorkspaceCache: (services) => new WorkspaceCache(services.shared),
-  DocumentCache: (services) => new DocumentCache(services.shared),
+  ValidatedWorkspaceCache: (services) => new WorkspaceCache(services.shared, DocumentState.Validated),
   Rpc: bind(Rpc),
   likec4: {
     Layouter: (_services) => {

package/dist/references/scope-computation.d.ts

@@ -3,7 +3,7 @@ import type { CancellationToken } from 'vscode-languageserver';
 import { type LikeC4LangiumDocument, ast } from '../ast';
 import type { LikeC4Services } from '../module';
 type ElementsContainer = ast.Model | ast.ElementBody | ast.ExtendElementBody;
-type DeploymentsContainer = ast.ModelDeployments | ast.DeploymentNodeBody;
+type DeploymentsContainer = ast.ModelDeployments | ast.DeploymentNodeBody | ast.ExtendDeploymentBody;
 export declare class LikeC4ScopeComputation extends DefaultScopeComputation {
     constructor(services: LikeC4Services);
     computeExports(document: LikeC4LangiumDocument, _cancelToken?: CancellationToken): Promise<AstNodeDescription[]>;

package/dist/references/scope-computation.js

@@ -242,19 +242,20 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
     return local;
   }
   processDeployments(container, scopes, document) {
-    const localnames = /* @__PURE__ */ new Set();
+    const localScope = new MultiMap();
     const descedants = [];
     for (const el of container.elements) {
       if (ast.isDeploymentRelation(el)) {
         continue;
       }
-      let name = this.nameProvider.getName(el);
-      if (isTruthy(name)) {
-        const desc = this.descriptions.createDescription(el, name, document);
-        scopes.add(container, desc);
-        localnames.add(desc.name);
+      if (!ast.isExtendDeployment(el)) {
+        let name = this.nameProvider.getName(el);
+        if (isTruthy(name)) {
+          const desc = this.descriptions.createDescription(el, name, document);
+          localScope.add(name, desc);
+        }
       }
-      if (ast.isDeploymentNode(el) && el.body) {
+      if (!ast.isDeployedInstance(el) && el.body) {
         try {
           descedants.push(
             ...this.processDeployments(el.body, scopes, document)
@@ -264,18 +265,20 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
         }
       }
     }
-    if (descedants.length > 0) {
+    if (descedants.length) {
       pipe(
         descedants,
-        filter((desc) => !localnames.has(desc.name)),
+        filter((desc) => !localScope.has(desc.name)),
         groupBy((desc) => desc.name),
         forEachObj((descs, name) => {
           if (descs.length === 1) {
-            scopes.add(container, descs[0]);
+            localScope.add(name, descs[0]);
           }
         })
       );
     }
-    return [...scopes.get(container).values()];
+    const local = [...localScope.values()];
+    scopes.addAll(container, local);
+    return local;
   }
 }

package/dist/references/scope-provider.d.ts

@@ -5,12 +5,24 @@ export declare class LikeC4ScopeProvider extends DefaultScopeProvider {
     private deploymentsIndex;
     private fqnIndex;
     constructor(services: LikeC4Services);
-    private directChildrenOf;
     private uniqueDescedants;
-    private scopeElementRef;
-    private scopeExtendElement;
-    private scopeElementView;
     getScope(context: ReferenceInfo): Scope;
+    private getScopeElementRef;
+    private getScopeExtendElement;
+    private getScopeElementView;
+    private getScopeForStrictFqnRef;
+    private getScopeExtendDeployment;
     protected getScopeForFqnRef(container: ast.FqnRef, context: ReferenceInfo): any;
+    /**
+     * Computes the scope for a given reference context.
+     *
+     * @param context - The reference information containing the context for which the scope is being computed.
+     * @param referenceType - The type of reference being resolved. Defaults to the reference type derived from the context.
+     * @returns A scope containing the relevant AST node descriptions for the given reference context.
+     *
+     * This method first checks if there are precomputed scopes available in the document. If not, it falls back to the global scope.
+     * It then iterates through the container hierarchy, collecting relevant scopes based on the reference type and container type.
+     * Finally, it combines the collected scopes with the global scope to produce the final scope.
+     */
     protected computeScope(context: ReferenceInfo, referenceType?: any): any;
 }