@likec4/language-server 1.23.1 → 1.24.0

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;
 }

package/dist/references/scope-provider.js

@@ -12,7 +12,7 @@ import {
 } from "langium";
 import { ast } from "../ast.js";
 import { logWarnError } from "../logger.js";
-import { elementRef, getFqnElementRef } from "../utils/elementRef.js";
+import { elementRef, readStrictFqn } from "../utils/elementRef.js";
 const { getDocument } = AstUtils;
 export class LikeC4ScopeProvider extends DefaultScopeProvider {
   deploymentsIndex;
@@ -22,18 +22,19 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
     this.fqnIndex = services.likec4.FqnIndex;
     this.deploymentsIndex = services.likec4.DeploymentsIndex;
   }
-  directChildrenOf(parent) {
-    return this.fqnIndex.directChildrenOf(parent);
-  }
   // we need lazy resolving here
   uniqueDescedants(of) {
     return new StreamImpl(
       () => {
         const element = of();
-        const fqn = element && this.fqnIndex.getFqn(element);
-        if (fqn) {
+        if (element && ast.isElement(element)) {
+          const fqn = this.fqnIndex.getFqn(element);
           return this.fqnIndex.uniqueDescedants(fqn).iterator();
         }
+        if (element && ast.isDeploymentNode(element)) {
+          const fqn = this.deploymentsIndex.getFqn(element);
+          return this.deploymentsIndex.uniqueDescedants(fqn).iterator();
+        }
         return null;
       },
       (iterator) => {
@@ -44,24 +45,6 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
       }
     );
   }
-  scopeElementRef(ref) {
-    return this.uniqueDescedants(() => ref.el.ref);
-  }
-  scopeExtendElement({ element }) {
-    return stream([element.el.$nodeDescription]).nonNullable().concat(this.uniqueDescedants(() => elementRef(element)));
-  }
-  scopeElementView({ viewOf, extends: ext }) {
-    if (viewOf) {
-      return stream([viewOf.el.$nodeDescription]).nonNullable().concat(this.uniqueDescedants(() => elementRef(viewOf)));
-    }
-    if (ext) {
-      return stream([ext]).flatMap((v) => {
-        const view = v.view.ref;
-        return view ? this.scopeElementView(view) : EMPTY_STREAM;
-      });
-    }
-    return EMPTY_STREAM;
-  }
   getScope(context) {
     try {
       const referenceType = this.reflection.getReferenceType(context);
@@ -70,6 +53,9 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
         if (ast.isFqnRef(container)) {
           return this.getScopeForFqnRef(container, context);
         }
+        if (ast.isStrictFqnRef(container)) {
+          return this.getScopeForStrictFqnRef(container, context);
+        }
         if (referenceType !== ast.Element) {
           return this.getGlobalScope(referenceType, context);
         }
@@ -78,12 +64,12 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
           if (!parent) {
             return this.getGlobalScope(referenceType, context);
           }
-          return new StreamScope(this.directChildrenOf(getFqnElementRef(parent)));
+          return new StreamScope(this.fqnIndex.directChildrenOf(readStrictFqn(parent)));
         }
         if (ast.isElementRef(container) && context.property === "el") {
           const parent = container.parent;
           if (parent) {
-            return new StreamScope(this.scopeElementRef(parent));
+            return new StreamScope(this.getScopeElementRef(parent));
           }
           if (context.reference.$refText === "this" || context.reference.$refText === "it") {
             const closestElement = AstUtils.getContainerOfType(container, ast.isElement);
@@ -106,6 +92,39 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
       return EMPTY_SCOPE;
     }
   }
+  getScopeElementRef(ref) {
+    return this.uniqueDescedants(() => ref.el.ref);
+  }
+  getScopeExtendElement({ element }) {
+    return stream([element.el.$nodeDescription]).nonNullable().concat(this.uniqueDescedants(() => elementRef(element)));
+  }
+  getScopeElementView({ viewOf, extends: ext }) {
+    if (viewOf) {
+      return stream([viewOf.el.$nodeDescription]).nonNullable().concat(this.uniqueDescedants(() => elementRef(viewOf)));
+    }
+    if (ext) {
+      return stream([ext]).flatMap((v) => {
+        const view = v.view.ref;
+        return view ? this.getScopeElementView(view) : EMPTY_STREAM;
+      });
+    }
+    return EMPTY_STREAM;
+  }
+  getScopeForStrictFqnRef(container, context) {
+    const parent = container.parent;
+    if (!parent) {
+      return this.getGlobalScope(ast.DeploymentNode, context);
+    }
+    return new StreamScope(
+      this.deploymentsIndex.directChildrenOf(readStrictFqn(parent)).filter((desc) => this.reflection.isSubtype(desc.type, ast.DeploymentNode))
+    );
+  }
+  getScopeExtendDeployment({ deploymentNode }) {
+    return stream([deploymentNode.value.$nodeDescription]).nonNullable().concat(this.uniqueDescedants(() => {
+      const target = deploymentNode.value.ref;
+      return target && ast.isDeploymentNode(target) ? target : void 0;
+    }));
+  }
   getScopeForFqnRef(container, context) {
     const parent = container.parent;
     if (!parent) {
@@ -125,18 +144,30 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
       return EMPTY_SCOPE;
     }
     if (ast.isDeploymentNode(parentRef)) {
-      return new StreamScope(this.deploymentsIndex.nested(parentRef));
+      return new StreamScope(this.uniqueDescedants(() => parentRef));
     }
     if (ast.isDeployedInstance(parentRef)) {
-      return new StreamScope(this.scopeElementRef(parentRef.element));
+      return new StreamScope(this.getScopeElementRef(parentRef.element));
     }
     if (ast.isElement(parentRef)) {
       return new StreamScope(this.uniqueDescedants(() => parentRef));
     }
     return nonexhaustive(parentRef);
   }
+  /**
+   * 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.
+   */
   computeScope(context, referenceType = this.reflection.getReferenceType(context)) {
     const isElementReference = this.reflection.isSubtype(referenceType, ast.Element);
+    const isDeploymentReference = this.reflection.isSubtype(referenceType, ast.DeploymentElement);
     const scopes = [];
     const doc = getDocument(context.container);
     const precomputed = doc.precomputedScopes;
@@ -150,11 +181,14 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
       if (elements.length > 0) {
         scopes.push(stream(elements));
       }
+      if (isDeploymentReference && ast.isExtendDeploymentBody(container)) {
+        scopes.push(this.getScopeExtendDeployment(container.$container));
+      }
       if (isElementReference && ast.isExtendElementBody(container)) {
-        scopes.push(this.scopeExtendElement(container.$container));
+        scopes.push(this.getScopeExtendElement(container.$container));
       }
       if (isElementReference && ast.isElementViewBody(container)) {
-        scopes.push(this.scopeElementView(container.$container));
+        scopes.push(this.getScopeElementView(container.$container));
       }
       container = container.$container;
     }

package/dist/test/testServices.d.ts

@@ -1,6 +1,7 @@
 import type { LikeC4LangiumDocument } from '../ast';
 export declare function createTestServices(workspace?: string): {
     services: any;
+    addDocument: (input: string, uri?: string) => Promise<LikeC4LangiumDocument>;
     parse: (input: string, uri?: string) => Promise<LikeC4LangiumDocument>;
     validate: (input: string | LikeC4LangiumDocument, uri?: string) => Promise<{
         document: LikeC4LangiumDocument;
@@ -13,7 +14,7 @@ export declare function createTestServices(workspace?: string): {
         errors: any;
         warnings: any;
     }>;
-    buildModel: () => Promise<any>;
+    buildModel: () => Promise<ComputedLikeC4Model>;
     buildLikeC4Model: () => Promise<any>;
     resetState: () => Promise<void>;
     format: (input: string | LikeC4LangiumDocument, uri?: string) => Promise<any>;

package/dist/test/testServices.js

@@ -1,4 +1,3 @@
-import { LikeC4Model } from "@likec4/core";
 import { DocumentState, EmptyFileSystem, TextDocument } from "langium";
 import * as assert from "node:assert";
 import stripIndent from "strip-indent";
@@ -19,7 +18,7 @@ export function createTestServices(workspace = "file:///test/workspace") {
   };
   let isInitialized = false;
   let documentIndex = 1;
-  const parse = async (input, uri) => {
+  const addDocument = async (input, uri) => {
     if (!isInitialized) {
       await services.shared.workspace.WorkspaceLock.write(async (_cancelToken) => {
         if (isInitialized) {
@@ -45,13 +44,17 @@ export function createTestServices(workspace = "file:///test/workspace") {
       docUri
     );
     langiumDocuments.addDocument(document);
+    return document;
+  };
+  const parse = async (input, uri) => {
+    const document = await addDocument(input, uri);
     await services.shared.workspace.WorkspaceLock.write(async (_cancelToken) => {
       await documentBuilder.build([document], { validation: false });
     });
     return document;
   };
   const validate = async (input, uri) => {
-    const document = typeof input === "string" ? await parse(input, uri) : input;
+    const document = typeof input === "string" ? await addDocument(input, uri) : input;
     await services.shared.workspace.WorkspaceLock.write(async (_cancelToken) => {
       await documentBuilder.build([document], { validation: true });
     });
@@ -80,13 +83,12 @@ export function createTestServices(workspace = "file:///test/workspace") {
     return TextDocument.applyEdits(document.textDocument, edits ?? []);
   };
   const validateAll = async () => {
-    await services.shared.workspace.WorkspaceLock.write(async (_cancelToken) => {
-      const docs2 = langiumDocuments.all.toArray();
-      await documentBuilder.build(docs2, { validation: true });
-    });
-    await documentBuilder.waitUntil(DocumentState.Validated);
     const docs = langiumDocuments.all.toArray();
     assert.ok(docs.length > 0, "no documents to validate");
+    await services.shared.workspace.WorkspaceLock.write(async (cancelToken) => {
+      await documentBuilder.build(docs, { validation: true }, cancelToken);
+    });
+    await documentBuilder.waitUntil(DocumentState.Validated);
     const diagnostics = docs.flatMap((doc) => doc.diagnostics ?? []);
     const warnings = diagnostics.flatMap((d) => d.severity === DiagnosticSeverity.Warning ? d.message : []);
     const errors = diagnostics.flatMap((d) => d.severity === DiagnosticSeverity.Error ? d.message : []);
@@ -98,15 +100,15 @@ export function createTestServices(workspace = "file:///test/workspace") {
   };
   const buildModel = async () => {
     await validateAll();
-    const model = await modelBuilder.buildComputedModel();
-    if (!model) throw new Error("No model found");
-    return model;
+    const likec4model = await modelBuilder.buildLikeC4Model();
+    if (!likec4model) throw new Error("No model found");
+    return likec4model.$model;
   };
   const buildLikeC4Model = async () => {
     await validateAll();
-    const model = await modelBuilder.buildComputedModel();
-    if (!model) throw new Error("No model found");
-    return LikeC4Model.create(model);
+    const likec4model = await modelBuilder.buildLikeC4Model();
+    if (!likec4model) throw new Error("No model found");
+    return likec4model;
   };
   const resetState = async () => {
     await services.shared.workspace.WorkspaceLock.write(async (cancelToken) => {
@@ -116,6 +118,7 @@ export function createTestServices(workspace = "file:///test/workspace") {
   };
   return {
     services,
+    addDocument,
     parse,
     validate,
     validateAll,

package/dist/utils/elementRef.d.ts

@@ -8,4 +8,4 @@ export declare function elementRef(node: ast.ElementRef | ast.StrictFqnElementRe
  * Returns FQN of StrictFqnElementRef
  * a.b.c.d - for c node returns a.b.c
  */
-export declare function getFqnElementRef(node: ast.StrictFqnElementRef): c4.Fqn;
+export declare function readStrictFqn(node: ast.StrictFqnElementRef | ast.StrictFqnRef): c4.Fqn;

package/dist/utils/elementRef.js

@@ -1,11 +1,11 @@
 export function elementRef(node) {
   return node.el.ref;
 }
-export function getFqnElementRef(node) {
-  const name = [node.el.$refText];
+export function readStrictFqn(node) {
+  const name = [node.$type === "StrictFqnRef" ? node.value.$refText : node.el.$refText];
   let parent = node.parent;
   while (parent) {
-    name.push(parent.el.$refText);
+    name.push(parent.$type === "StrictFqnRef" ? parent.value.$refText : parent.el.$refText);
     parent = parent.parent;
   }
   if (name.length === 1) {

package/dist/validation/deployment-checks.d.ts

@@ -4,3 +4,4 @@ import type { LikeC4Services } from '../module';
 export declare const deploymentNodeChecks: (services: LikeC4Services) => ValidationCheck<ast.DeploymentNode>;
 export declare const deployedInstanceChecks: (services: LikeC4Services) => ValidationCheck<ast.DeployedInstance>;
 export declare const deploymentRelationChecks: (services: LikeC4Services) => ValidationCheck<ast.DeploymentRelation>;
+export declare const extendDeploymentChecks: (services: LikeC4Services) => ValidationCheck<ast.ExtendDeployment>;

package/dist/validation/deployment-checks.js

@@ -1,5 +1,6 @@
 import { FqnRef, isSameHierarchy, nonNullable } from "@likec4/core";
 import { AstUtils } from "langium";
+import { ast } from "../ast.js";
 import { RESERVED_WORDS, tryOrLog } from "./_shared.js";
 const { getDocument } = AstUtils;
 export const deploymentNodeChecks = (services) => {
@@ -112,3 +113,14 @@ export const deploymentRelationChecks = (services) => {
     }
   });
 };
+export const extendDeploymentChecks = (services) => {
+  return tryOrLog((el, accept) => {
+    const target = el.deploymentNode.value.ref;
+    if (!target || !ast.isDeploymentNode(target)) {
+      accept("error", "ExtendDeployment allows only DeploymentNode", {
+        node: el,
+        property: "deploymentNode"
+      });
+    }
+  });
+};

package/dist/validation/index.d.ts

@@ -3,7 +3,7 @@ import { type LikeC4LangiumDocument, ast } from '../ast';
 import type { LikeC4Services } from '../module';
 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.DeployedInstance | ast.DeploymentNode | ast.DeploymentViewRulePredicate | ast.DeploymentViewRuleStyle | ast.ViewRuleAutoLayout | ast.DynamicViewGlobalPredicateRef | ast.DynamicViewIncludePredicate | ast.ViewRuleGlobalStyle | ast.ViewRuleStyle | ast.ElementDescedantsExpression | ast.ElementKindExpression | ast.ElementRef | ast.ElementTagExpression | ast.ExpandElementExpression | ast.WildcardExpression | ast.ElementPredicateWhere | ast.ElementPredicateWith | ast.ElementPredicateWhereV2 | ast.FqnRefExpr | ast.ElementStringProperty | ast.ElementStyleProperty | ast.IconProperty | ast.LinkProperty | ast.MetadataBody | ast.DirectedRelationExpr | ast.InOutRelationExpr | ast.IncomingRelationExpr | ast.OutgoingRelationExpr | ast.RelationPredicateWhereV2 | ast.Element | ast.ExtendElement | ast.DeploymentView | ast.DynamicView | ast.ElementView | ast.DirectedRelationExpression | ast.InOutRelationExpression | ast.IncomingRelationExpression | ast.OutgoingRelationExpression | ast.RelationPredicateWhere | ast.RelationPredicateWith | ast.RelationStringProperty | ast.ArrowProperty | ast.ColorProperty | ast.LineProperty | ast.PaddingSizeProperty | ast.ShapeSizeProperty | ast.TextSizeProperty | ast.MetadataAttribute | ast.NotationProperty | ast.NotesProperty | ast.SpecificationElementStringProperty | ast.SpecificationRelationshipStringProperty | ast.ViewStringProperty | ast.BorderProperty | ast.MultipleProperty | ast.OpacityProperty | ast.ShapeProperty | ast.ViewRuleGlobalPredicateRef | ast.ViewRuleGroup | ast.ExcludePredicate | ast.IncludePredicate | ast.SpecificationRelationshipKind | ast.GlobalStyle | ast.SpecificationColor | ast.NavigateToProperty | ast.DynamicViewStep | ast.Tags | ast.DeploymentRelation | ast.SpecificationDeploymentNodeKind | ast.DynamicViewParallelSteps | ast.GlobalDynamicPredicateGroup | ast.DynamicViewPredicateIterator | ast.Relation | ast.SpecificationElementKind | ast.GlobalPredicateGroup | ast.Globals | ast.GlobalStyleGroup | ast.SpecificationRule | ast.SpecificationTag;
+declare const isValidatableAstNode: (n: AstNode) => n is ast.DeployedInstance | ast.DeploymentNode | ast.DeploymentViewRulePredicate | ast.DeploymentViewRuleStyle | ast.ViewRuleAutoLayout | ast.DynamicViewGlobalPredicateRef | ast.DynamicViewIncludePredicate | ast.ViewRuleGlobalStyle | ast.ViewRuleStyle | ast.ElementDescedantsExpression | ast.ElementKindExpression | ast.ElementRef | ast.ElementTagExpression | ast.ExpandElementExpression | ast.WildcardExpression | ast.ElementPredicateWhere | ast.ElementPredicateWith | ast.ElementPredicateWhereV2 | ast.FqnRefExpr | ast.ElementStringProperty | ast.ElementStyleProperty | ast.IconProperty | ast.LinkProperty | ast.MetadataBody | ast.DirectedRelationExpr | ast.InOutRelationExpr | ast.IncomingRelationExpr | ast.OutgoingRelationExpr | ast.RelationPredicateWhereV2 | ast.Element | ast.ExtendDeployment | ast.ExtendElement | ast.DeploymentView | ast.DynamicView | ast.ElementView | ast.DirectedRelationExpression | ast.InOutRelationExpression | ast.IncomingRelationExpression | ast.OutgoingRelationExpression | ast.RelationPredicateWhere | ast.RelationPredicateWith | ast.RelationStringProperty | ast.ArrowProperty | ast.ColorProperty | ast.LineProperty | ast.PaddingSizeProperty | ast.ShapeSizeProperty | ast.TextSizeProperty | ast.MetadataAttribute | ast.NotationProperty | ast.NotesProperty | ast.SpecificationElementStringProperty | ast.SpecificationRelationshipStringProperty | ast.ViewStringProperty | ast.BorderProperty | ast.MultipleProperty | ast.OpacityProperty | ast.ShapeProperty | ast.ViewRuleGlobalPredicateRef | ast.ViewRuleGroup | ast.ExcludePredicate | ast.IncludePredicate | ast.SpecificationRelationshipKind | ast.GlobalStyle | ast.SpecificationColor | ast.NavigateToProperty | ast.DynamicViewStep | ast.Tags | ast.DeploymentRelation | ast.SpecificationDeploymentNodeKind | ast.DynamicViewParallelSteps | ast.GlobalDynamicPredicateGroup | ast.DynamicViewPredicateIterator | ast.Relation | ast.SpecificationElementKind | ast.GlobalPredicateGroup | ast.Globals | ast.GlobalStyleGroup | ast.SpecificationRule | ast.SpecificationTag;
 type ValidatableAstNode = Guarded<typeof isValidatableAstNode>;
 export declare function checksFromDiagnostics(doc: LikeC4LangiumDocument): {
     isValid: (n: ValidatableAstNode) => boolean;

package/dist/validation/index.js

@@ -3,7 +3,12 @@ import { isNullish } from "remeda";
 import { DiagnosticSeverity } from "vscode-languageserver-types";
 import { ast } from "../ast.js";
 import { logger } from "../logger.js";
-import { deployedInstanceChecks, deploymentNodeChecks, deploymentRelationChecks } from "./deployment-checks.js";
+import {
+  deployedInstanceChecks,
+  deploymentNodeChecks,
+  deploymentRelationChecks,
+  extendDeploymentChecks
+} from "./deployment-checks.js";
 import { dynamicViewRulePredicate } from "./dynamic-view-rule.js";
 import { dynamicViewStep } from "./dynamic-view-step.js";
 import { elementChecks } from "./element.js";
@@ -70,6 +75,7 @@ const isValidatableAstNode = validatableAstNodeGuards([
   ast.isNavigateToProperty,
   ast.isElement,
   ast.isExtendElement,
+  ast.isExtendDeployment,
   ast.isSpecificationElementKind,
   ast.isSpecificationRelationshipKind,
   ast.isSpecificationDeploymentNodeKind,
@@ -114,6 +120,7 @@ export function registerValidationChecks(services) {
     DeploymentNodeKind: deploymentNodeKindChecks(services),
     DeploymentNode: deploymentNodeChecks(services),
     DeploymentRelation: deploymentRelationChecks(services),
+    ExtendDeployment: extendDeploymentChecks(services),
     FqnRefExpr: fqnRefExprChecks(services),
     RelationExpr: relationExprChecks(services),
     NotesProperty: notesPropertyRuleChecks(services),

package/dist/views/configurable-layouter.js

@@ -19,7 +19,7 @@ export const ConfigurableLayouter = {
       const layouter = new GraphvizLayouter(wasmAdapter);
       const langId = services.LanguageMetaData.languageId;
       services.shared.workspace.ConfigurationProvider.onConfigurationSectionUpdate((update) => {
-        logger.debug("Configuration update", { update });
+        logger.debug("Configuration update: {update}", { update });
         if (update.section === langId) {
           try {
             const { mode, path } = update.configuration.graphviz ?? {
@@ -41,13 +41,13 @@ export const ConfigurableLayouter = {
               return;
             }
             layouter.changePort(new GraphvizBinaryAdapter(binaryPath));
-            logger.info(`use graphviz binary: ${binaryPath}`);
+            logger.info`use graphviz binary: ${binaryPath}`;
           } catch (error) {
             logger.error("Failed to update configuration", { error });
           }
           return;
         }
-        logger.warn("Unexpected configuration update", { update });
+        logger.warn("Unexpected configuration update: {update}", { update });
       });
       return layouter;
     }

package/dist/views/likec4-views.d.ts

@@ -15,6 +15,7 @@ export declare class LikeC4Views {
     private services;
     private cache;
     private viewsWithReportedErrors;
+    private ModelBuilder;
     constructor(services: LikeC4Services);
     get layouter(): GraphvizLayouter;
     computedViews(cancelToken?: Cancellation.CancellationToken): Promise<ComputedView[]>;

package/dist/views/likec4-views.js

@@ -3,15 +3,17 @@ import { logError, logWarnError } from "../logger.js";
 export class LikeC4Views {
   constructor(services) {
     this.services = services;
+    this.ModelBuilder = services.likec4.ModelBuilder;
   }
   cache = /* @__PURE__ */ new WeakMap();
   viewsWithReportedErrors = /* @__PURE__ */ new Set();
+  ModelBuilder;
   get layouter() {
     return this.services.likec4.Layouter;
   }
   async computedViews(cancelToken) {
-    const model = await this.services.likec4.ModelBuilder.buildComputedModel(cancelToken);
-    return model ? values(model.views) : [];
+    const likeC4Model = await this.ModelBuilder.buildLikeC4Model(cancelToken);
+    return values(likeC4Model.$model.views);
   }
   async layoutAllViews(cancelToken) {
     const views = await this.computedViews(cancelToken);
@@ -24,6 +26,7 @@ export class LikeC4Views {
       this.viewsWithReportedErrors.delete(view.id);
       tasks.push(
         this.layouter.layout(view).then((result) => {
+          this.viewsWithReportedErrors.delete(view.id);
           this.cache.set(view, result);
           return result;
         }).catch((e) => {
@@ -41,17 +44,14 @@ export class LikeC4Views {
     return results;
   }
   async layoutView(viewId, cancelToken) {
-    const model = await this.services.likec4.ModelBuilder.buildComputedModel(cancelToken);
-    if (!model) {
-      return null;
-    }
-    const view = model.views[viewId];
+    const model = await this.ModelBuilder.buildLikeC4Model(cancelToken);
+    const view = model.findView(viewId)?.$view;
     if (!view) {
       return null;
     }
     let cached = this.cache.get(view);
     if (cached) {
-      return cached;
+      return await Promise.resolve(cached);
     }
     try {
       const result = await this.layouter.layout(view);
@@ -63,8 +63,8 @@ export class LikeC4Views {
         const errMessage = e instanceof Error ? e.message : "" + e;
         this.services.shared.lsp.Connection?.window.showErrorMessage(`LikeC4: ${errMessage}`);
         this.viewsWithReportedErrors.add(viewId);
+        logError(e);
       }
-      logError(e);
       return Promise.reject(e);
     }
   }
@@ -74,7 +74,7 @@ export class LikeC4Views {
   }
   async viewsAsGraphvizOut() {
     const KEY = "All-LayoutedViews-DotWithSvg";
-    const cache = this.services.WorkspaceCache;
+    const cache = this.services.ValidatedWorkspaceCache;
     if (cache.has(KEY)) {
       return await Promise.resolve(cache.get(KEY));
     }
@@ -101,7 +101,7 @@ export class LikeC4Views {
   }
   async overviewGraph() {
     const KEY = "OverviewGraph";
-    const cache = this.services.WorkspaceCache;
+    const cache = this.services.ValidatedWorkspaceCache;
     if (cache.has(KEY)) {
       return await Promise.resolve(cache.get(KEY));
     }