@likec4/language-server 1.23.1 → 1.24.0

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

@@ -8,6 +8,7 @@ export declare class LikeC4ModelLocator {
     private fqnIndex;
     private deploymentsIndex;
     private langiumDocuments;
+    private parser;
     constructor(services: LikeC4Services);
     private documents;
     getParsedElement(astNodeOrFqn: ast.Element | c4.Fqn): ParsedAstElement | null;

package/dist/model/model-locator.js

@@ -1,6 +1,6 @@
 import { AstUtils, GrammarUtils } from "langium";
 import { isString } from "remeda";
-import { ast, isParsedLikeC4LangiumDocument } from "../ast.js";
+import { ast } from "../ast.js";
 const { findNodeForKeyword, findNodeForProperty } = GrammarUtils;
 const { getDocument } = AstUtils;
 export class LikeC4ModelLocator {
@@ -9,12 +9,14 @@ export class LikeC4ModelLocator {
     this.fqnIndex = services.likec4.FqnIndex;
     this.deploymentsIndex = services.likec4.DeploymentsIndex;
     this.langiumDocuments = services.shared.workspace.LangiumDocuments;
+    this.parser = services.likec4.ModelParser;
   }
   fqnIndex;
   deploymentsIndex;
   langiumDocuments;
+  parser;
   documents() {
-    return this.langiumDocuments.all.filter(isParsedLikeC4LangiumDocument);
+    return this.parser.documents().toArray();
   }
   getParsedElement(astNodeOrFqn) {
     if (isString(astNodeOrFqn)) {
@@ -24,17 +26,13 @@ export class LikeC4ModelLocator {
         return null;
       }
       const doc2 = this.langiumDocuments.getDocument(entry.documentUri);
-      if (!doc2 || !isParsedLikeC4LangiumDocument(doc2)) {
+      if (!doc2) {
         return null;
       }
-      return doc2.c4Elements.find((e) => e.id === fqn2) ?? null;
+      return this.parser.parse(doc2).c4Elements.find((e) => e.id === fqn2) ?? null;
     }
     const fqn = this.fqnIndex.getFqn(astNodeOrFqn);
-    if (!fqn) return null;
-    const doc = getDocument(astNodeOrFqn);
-    if (!isParsedLikeC4LangiumDocument(doc)) {
-      return null;
-    }
+    const doc = this.parser.parse(getDocument(astNodeOrFqn));
     return doc.c4Elements.find((e) => e.id === fqn) ?? null;
   }
   locateElement(fqn, _prop) {

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

@@ -1,5 +1,5 @@
 import { invariant } from '@likec4/core';
-import { type LangiumDocument } from 'langium';
+import { type LangiumDocument, type Stream } from 'langium';
 import type { ParsedLikeC4LangiumDocument } from '../ast';
 import type { LikeC4Services } from '../module';
 import { BaseParser } from './parser/Base';
@@ -50,8 +50,8 @@ declare const DocumentParserFromMixins: {
         parseTags<E extends {
             tags?: import("../generated/ast").Tags;
         }>(withTags?: E): invariant<invariant> | null;
-        convertLinks(source?: import("../generated/ast").LinkProperty["$container"]): import("../ast").ParsedLink[] | undefined;
-        parseLinks(source?: import("../generated/ast").LinkProperty["$container"]): import("../ast").ParsedLink[] | undefined;
+        convertLinks(source?: import("../generated/ast").LinkProperty["$container"]): invariant[] | undefined;
+        parseLinks(source?: import("../generated/ast").LinkProperty["$container"]): invariant[] | undefined;
         parseDeploymentView(astNode: import("../generated/ast").DeploymentView): import("../ast").ParsedAstDeploymentView;
         parseDeploymentViewRule(astRule: import("../generated/ast").DeploymentViewRule): invariant;
         parseDeploymentViewRulePredicate(astRule: import("../generated/ast").DeploymentViewRulePredicate): invariant;
@@ -66,6 +66,7 @@ declare const DocumentParserFromMixins: {
         parseDeployment(): void;
         parseDeploymentNode(astNode: import("../generated/ast").DeploymentNode): import("../ast").ParsedAstDeployment.Node;
         parseDeployedInstance(astNode: import("../generated/ast").DeployedInstance): import("../ast").ParsedAstDeployment.Instance;
+        parseExtendDeployment(astNode: import("../generated/ast").ExtendDeployment): import("../ast").ParsedAstExtend | null;
         parseDeploymentRelation(astNode: import("../generated/ast").DeploymentRelation): import("../ast").ParsedAstDeploymentRelation;
     };
 } & {
@@ -109,8 +110,8 @@ declare const DocumentParserFromMixins: {
         parseTags<E extends {
             tags?: import("../generated/ast").Tags;
         }>(withTags?: E): invariant<invariant> | null;
-        convertLinks(source?: import("../generated/ast").LinkProperty["$container"]): import("../ast").ParsedLink[] | undefined;
-        parseLinks(source?: import("../generated/ast").LinkProperty["$container"]): import("../ast").ParsedLink[] | undefined;
+        convertLinks(source?: import("../generated/ast").LinkProperty["$container"]): invariant[] | undefined;
+        parseLinks(source?: import("../generated/ast").LinkProperty["$container"]): invariant[] | undefined;
         parseDeploymentView(astNode: import("../generated/ast").DeploymentView): import("../ast").ParsedAstDeploymentView;
         parseDeploymentViewRule(astRule: import("../generated/ast").DeploymentViewRule): invariant;
         parseDeploymentViewRulePredicate(astRule: import("../generated/ast").DeploymentViewRulePredicate): invariant;
@@ -125,6 +126,7 @@ declare const DocumentParserFromMixins: {
         parseDeployment(): void;
         parseDeploymentNode(astNode: import("../generated/ast").DeploymentNode): import("../ast").ParsedAstDeployment.Node;
         parseDeployedInstance(astNode: import("../generated/ast").DeployedInstance): import("../ast").ParsedAstDeployment.Instance;
+        parseExtendDeployment(astNode: import("../generated/ast").ExtendDeployment): import("../ast").ParsedAstExtend | null;
         parseDeploymentRelation(astNode: import("../generated/ast").DeploymentRelation): import("../ast").ParsedAstDeploymentRelation;
     };
 } & {
@@ -145,8 +147,8 @@ declare const DocumentParserFromMixins: {
         parseTags<E extends {
             tags?: import("../generated/ast").Tags;
         }>(withTags?: E): invariant<invariant> | null;
-        convertLinks(source?: import("../generated/ast").LinkProperty["$container"]): import("../ast").ParsedLink[] | undefined;
-        parseLinks(source?: import("../generated/ast").LinkProperty["$container"]): import("../ast").ParsedLink[] | undefined;
+        convertLinks(source?: import("../generated/ast").LinkProperty["$container"]): invariant[] | undefined;
+        parseLinks(source?: import("../generated/ast").LinkProperty["$container"]): invariant[] | undefined;
     };
 } & {
     new (...args: any[]): {
@@ -174,8 +176,8 @@ declare const DocumentParserFromMixins: {
         parseTags<E extends {
             tags?: import("../generated/ast").Tags;
         }>(withTags?: E): invariant<invariant> | null;
-        convertLinks(source?: import("../generated/ast").LinkProperty["$container"]): import("../ast").ParsedLink[] | undefined;
-        parseLinks(source?: import("../generated/ast").LinkProperty["$container"]): import("../ast").ParsedLink[] | undefined;
+        convertLinks(source?: import("../generated/ast").LinkProperty["$container"]): invariant[] | undefined;
+        parseLinks(source?: import("../generated/ast").LinkProperty["$container"]): invariant[] | undefined;
     };
 } & {
     new (...args: any[]): {
@@ -204,11 +206,12 @@ declare const DocumentParserFromMixins: {
         parseTags<E extends {
             tags?: import("../generated/ast").Tags;
         }>(withTags?: E): invariant<invariant> | null;
-        convertLinks(source?: import("../generated/ast").LinkProperty["$container"]): import("../ast").ParsedLink[] | undefined;
-        parseLinks(source?: import("../generated/ast").LinkProperty["$container"]): import("../ast").ParsedLink[] | undefined;
+        convertLinks(source?: import("../generated/ast").LinkProperty["$container"]): invariant[] | undefined;
+        parseLinks(source?: import("../generated/ast").LinkProperty["$container"]): invariant[] | undefined;
         parseDeployment(): void;
         parseDeploymentNode(astNode: import("../generated/ast").DeploymentNode): import("../ast").ParsedAstDeployment.Node;
         parseDeployedInstance(astNode: import("../generated/ast").DeployedInstance): import("../ast").ParsedAstDeployment.Instance;
+        parseExtendDeployment(astNode: import("../generated/ast").ExtendDeployment): import("../ast").ParsedAstExtend | null;
         parseDeploymentRelation(astNode: import("../generated/ast").DeploymentRelation): import("../ast").ParsedAstDeploymentRelation;
     };
 } & {
@@ -216,6 +219,7 @@ declare const DocumentParserFromMixins: {
         parseDeployment(): void;
         parseDeploymentNode(astNode: import("../generated/ast").DeploymentNode): import("../ast").ParsedAstDeployment.Node;
         parseDeployedInstance(astNode: import("../generated/ast").DeployedInstance): import("../ast").ParsedAstDeployment.Instance;
+        parseExtendDeployment(astNode: import("../generated/ast").ExtendDeployment): import("../ast").ParsedAstExtend | null;
         parseDeploymentRelation(astNode: import("../generated/ast").DeploymentRelation): import("../ast").ParsedAstDeploymentRelation;
         parseFqnRef(astNode: import("../generated/ast").FqnRef): invariant;
         parseFqnExpr(astNode: import("../generated/ast").FqnExpr): invariant;
@@ -238,14 +242,14 @@ declare const DocumentParserFromMixins: {
         parseTags<E extends {
             tags?: import("../generated/ast").Tags;
         }>(withTags?: E): invariant<invariant> | null;
-        convertLinks(source?: import("../generated/ast").LinkProperty["$container"]): import("../ast").ParsedLink[] | undefined;
-        parseLinks(source?: import("../generated/ast").LinkProperty["$container"]): import("../ast").ParsedLink[] | undefined;
+        convertLinks(source?: import("../generated/ast").LinkProperty["$container"]): invariant[] | undefined;
+        parseLinks(source?: import("../generated/ast").LinkProperty["$container"]): invariant[] | undefined;
     };
 } & {
     new (...args: any[]): {
         parseModel(): void;
         parseElement(astNode: import("../generated/ast").Element): import("../ast").ParsedAstElement;
-        parseExtendElement(astNode: import("../generated/ast").ExtendElement): import("../ast").ParsedAstExtendElement | null;
+        parseExtendElement(astNode: import("../generated/ast").ExtendElement): import("../ast").ParsedAstExtend | null;
         parseRelation(astNode: import("../generated/ast").Relation): import("../ast").ParsedAstRelation;
         isValid: import("../validation").IsValidFn;
         readonly services: LikeC4Services;
@@ -261,8 +265,8 @@ declare const DocumentParserFromMixins: {
         parseTags<E extends {
             tags?: import("../generated/ast").Tags;
         }>(withTags?: E): invariant<invariant> | null;
-        convertLinks(source?: import("../generated/ast").LinkProperty["$container"]): import("../ast").ParsedLink[] | undefined;
-        parseLinks(source?: import("../generated/ast").LinkProperty["$container"]): import("../ast").ParsedLink[] | undefined;
+        convertLinks(source?: import("../generated/ast").LinkProperty["$container"]): invariant[] | undefined;
+        parseLinks(source?: import("../generated/ast").LinkProperty["$container"]): invariant[] | undefined;
     };
 } & {
     new (...args: any[]): {
@@ -287,8 +291,8 @@ declare const DocumentParserFromMixins: {
         parseTags<E extends {
             tags?: import("../generated/ast").Tags;
         }>(withTags?: E): invariant<invariant> | null;
-        convertLinks(source?: import("../generated/ast").LinkProperty["$container"]): import("../ast").ParsedLink[] | undefined;
-        parseLinks(source?: import("../generated/ast").LinkProperty["$container"]): import("../ast").ParsedLink[] | undefined;
+        convertLinks(source?: import("../generated/ast").LinkProperty["$container"]): invariant[] | undefined;
+        parseLinks(source?: import("../generated/ast").LinkProperty["$container"]): invariant[] | undefined;
     };
 } & typeof BaseParser;
 export declare class DocumentParser extends DocumentParserFromMixins {
@@ -297,7 +301,9 @@ export declare class LikeC4ModelParser {
     private services;
     private cachedParsers;
     constructor(services: LikeC4Services);
+    documents(): Stream<ParsedLikeC4LangiumDocument>;
     parse(doc: LangiumDocument): ParsedLikeC4LangiumDocument;
     forDocument(doc: LangiumDocument): DocumentParser;
+    private createParser;
 }
 export {};

package/dist/model/model-parser.js

@@ -1,7 +1,7 @@
 import { invariant } from "@likec4/core";
 import { DocumentCache, DocumentState } from "langium";
 import { pipe } from "remeda";
-import { isFqnIndexedDocument } from "../ast.js";
+import { logger } from "../logger.js";
 import { BaseParser } from "./parser/Base.js";
 import { DeploymentModelParser } from "./parser/DeploymentModelParser.js";
 import { DeploymentViewParser } from "./parser/DeploymentViewParser.js";
@@ -27,50 +27,70 @@ export class DocumentParser extends DocumentParserFromMixins {
 export class LikeC4ModelParser {
   constructor(services) {
     this.services = services;
-    this.cachedParsers = new DocumentCache(services.shared, DocumentState.Validated);
+    this.cachedParsers = new DocumentCache(services.shared, DocumentState.IndexedReferences);
+    services.shared.workspace.DocumentBuilder.onDocumentPhase(
+      DocumentState.Validated,
+      (doc) => {
+        try {
+          this.cachedParsers.set(doc.uri, "DocumentParser", this.createParser(doc));
+        } catch (error) {
+          logger.error(`Error caching parser for document ${doc.uri.toString()}`, { error });
+        }
+        return Promise.resolve();
+      }
+    );
   }
   cachedParsers;
+  documents() {
+    return this.services.shared.workspace.LangiumDocuments.all.map(
+      (d) => this.parse(d)
+    );
+  }
   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)}`);
+    invariant(doc.state >= DocumentState.IndexedReferences, `Not a IndexedReferences: ${doc.uri.toString(true)}`);
     return this.cachedParsers.get(
       doc.uri,
       "DocumentParser",
-      () => new DocumentParser(this.services, doc)
+      () => this.createParser(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;