@likec4/language-server 1.20.3 → 1.21.1

package/dist/generated-lib/icons.js

@@ -342,6 +342,7 @@ export const LibIcons = `likec4lib { icons {
   azure:arc-data-services
   azure:arc-kubernetes
   azure:arc-machines
+  azure:arc-postgre-sql
   azure:arc-sql-managed-instance
   azure:arc-sql-server
   azure:atm-multistack

package/dist/lsp/CompletionProvider.js

@@ -11,7 +11,8 @@ const STYLE_FIELDS = [
   "icon",
   "border",
   "opacity",
-  "multiple"
+  "multiple",
+  "size"
 ].join(",");
 export class LikeC4CompletionProvider extends DefaultCompletionProvider {
   completionOptions = {

package/dist/lsp/SemanticTokenProvider.js

@@ -134,6 +134,54 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
       });
       return "prune";
     }
+    if (ast.isGlobalStyleGroup(node) || ast.isGlobalStyle(node)) {
+      acceptor({
+        node,
+        property: "id",
+        type: SemanticTokenTypes.variable,
+        modifier: [
+          SemanticTokenModifiers.definition,
+          SemanticTokenModifiers.readonly
+        ]
+      });
+      return;
+    }
+    if (ast.isViewRuleGlobalStyle(node)) {
+      acceptor({
+        node,
+        property: "style",
+        type: SemanticTokenTypes.variable,
+        modifier: [
+          SemanticTokenModifiers.definition,
+          SemanticTokenModifiers.readonly
+        ]
+      });
+      return;
+    }
+    if (ast.isGlobalPredicateGroup(node) || ast.isGlobalDynamicPredicateGroup(node)) {
+      acceptor({
+        node,
+        property: "name",
+        type: SemanticTokenTypes.variable,
+        modifier: [
+          SemanticTokenModifiers.definition,
+          SemanticTokenModifiers.readonly
+        ]
+      });
+      return;
+    }
+    if (ast.isViewRuleGlobalPredicateRef(node)) {
+      acceptor({
+        node,
+        property: "predicate",
+        type: SemanticTokenTypes.variable,
+        modifier: [
+          SemanticTokenModifiers.definition,
+          SemanticTokenModifiers.readonly
+        ]
+      });
+      return;
+    }
     if (ast.isElementTagExpression(node) && isTruthy(node.tag)) {
       acceptor({
         node,
@@ -155,7 +203,7 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
       });
       return !node.parent ? "prune" : void 0;
     }
-    if (ast.isElementRef(node) || ast.isFqnElementRef(node)) {
+    if (ast.isElementRef(node) || ast.isStrictFqnElementRef(node)) {
       acceptor({
         node,
         property: "el",
@@ -254,7 +302,7 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
       }
       return "prune";
     }
-    if (ast.isColorProperty(node) || ast.isShapeProperty(node) || ast.isArrowProperty(node) || ast.isLineProperty(node) || ast.isBorderProperty(node)) {
+    if (ast.isColorProperty(node) || ast.isShapeProperty(node) || ast.isArrowProperty(node) || ast.isLineProperty(node) || ast.isBorderProperty(node) || ast.isSizeProperty(node)) {
       acceptor({
         node,
         property: "key",

package/dist/model/model-builder.js

@@ -14,6 +14,7 @@ import {
   filter,
   flatMap,
   groupBy,
+  hasAtLeast,
   indexBy,
   isBoolean,
   isDefined,
@@ -31,6 +32,7 @@ import {
   reduce,
   reverse,
   sort,
+  unique,
   values
 } from "remeda";
 import { isParsedLikeC4LangiumDocument } from "../ast.js";
@@ -97,7 +99,10 @@ function buildModel(services, docs) {
         icon,
         opacity,
         border,
-        multiple
+        size,
+        multiple,
+        padding,
+        textSize
       },
       id,
       kind,
@@ -120,6 +125,9 @@ function buildModel(services, docs) {
         border ??= __kind.style.border;
         technology ??= __kind.technology;
         multiple ??= __kind.style.multiple;
+        size ??= __kind.style.size;
+        padding ??= __kind.style.padding;
+        textSize ??= __kind.style.textSize;
         return {
           ...color && { color },
           ...shape && { shape },
@@ -128,6 +136,9 @@ function buildModel(services, docs) {
           ...__kind.notation && { notation: __kind.notation },
           style: {
             ...border && { border },
+            ...size && { size },
+            ...padding && { padding },
+            ...textSize && { textSize },
             ...isBoolean(multiple) && { multiple },
             ...isNumber(opacity) && { opacity }
           },
@@ -145,9 +156,52 @@ function buildModel(services, docs) {
       return null;
     };
   }
+  const elementsExtendData = /* @__PURE__ */ new Map();
+  function mergeAllC4ExtendElements(doc) {
+    for (const el of doc.c4ExtendElements) {
+      let links = el.links ? resolveLinks(doc, el.links) : null;
+      const existing = elementsExtendData.get(el.id);
+      if (existing) {
+        links = existing.links ? [...existing.links, ...links ?? []] : links;
+        let tags = [...existing.tags ?? [], ...el.tags ?? []];
+        if (!hasAtLeast(tags, 1)) {
+          tags = null;
+        }
+        elementsExtendData.set(el.id, {
+          tags,
+          links,
+          metadata: { ...existing.metadata, ...el.metadata }
+        });
+      } else {
+        elementsExtendData.set(el.id, {
+          tags: el.tags ?? null,
+          links,
+          metadata: { ...el.metadata }
+        });
+      }
+    }
+  }
+  function withExtendElementData(el) {
+    const extendData = elementsExtendData.get(el.id);
+    if (extendData) {
+      const links = [...el.links ?? [], ...extendData.links ?? []];
+      const tags = unique([...el.tags ?? [], ...extendData.tags ?? []]);
+      const metadata = { ...el.metadata, ...extendData.metadata };
+      return {
+        ...el,
+        tags: hasAtLeast(tags, 1) ? tags : null,
+        links: hasAtLeast(links, 1) ? links : null,
+        ...!isEmpty(metadata) && { metadata }
+      };
+    }
+    return el;
+  }
   const elements = pipe(
     docs,
-    flatMap((d) => map(d.c4Elements, toModelElement(d))),
+    flatMap((d) => {
+      mergeAllC4ExtendElements(d);
+      return map(d.c4Elements, toModelElement(d));
+    }),
     filter(isTruthy),
     // sort from root elements to nested, so that parent is always present
     // Import to preserve the order from the source
@@ -159,7 +213,7 @@ function buildModel(services, docs) {
           logWarnError(`No parent found for ${el.id}`);
           return acc;
         }
-        acc[el.id] = el;
+        acc[el.id] = withExtendElementData(el);
         return acc;
       },
       {}

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

@@ -59,6 +59,7 @@ declare const DocumentParserFromMixins: {
         parseFqnRef(astNode: import("../generated/ast").FqnRef): invariant;
         parseFqnExpr(astNode: import("../generated/ast").FqnExpr): invariant;
         parseFqnRefExpr(astNode: import("../generated/ast").FqnRefExpr): invariant;
+        parseElementWhereExpr(astNode: import("../generated/ast").ElementPredicateWhereV2): invariant;
         parseFqnExpressions(astNode: import("../generated/ast").FqnExpressions): invariant[];
         parseRelationWhereExpr(astNode: import("../generated/ast").RelationPredicateWhereV2): invariant;
         parseRelationExpr(astNode: import("../generated/ast").RelationExpr): invariant;
@@ -117,6 +118,7 @@ declare const DocumentParserFromMixins: {
         parseFqnRef(astNode: import("../generated/ast").FqnRef): invariant;
         parseFqnExpr(astNode: import("../generated/ast").FqnExpr): invariant;
         parseFqnRefExpr(astNode: import("../generated/ast").FqnRefExpr): invariant;
+        parseElementWhereExpr(astNode: import("../generated/ast").ElementPredicateWhereV2): invariant;
         parseFqnExpressions(astNode: import("../generated/ast").FqnExpressions): invariant[];
         parseRelationWhereExpr(astNode: import("../generated/ast").RelationPredicateWhereV2): invariant;
         parseRelationExpr(astNode: import("../generated/ast").RelationExpr): invariant;
@@ -184,6 +186,7 @@ declare const DocumentParserFromMixins: {
         parseFqnRef(astNode: import("../generated/ast").FqnRef): invariant;
         parseFqnExpr(astNode: import("../generated/ast").FqnExpr): invariant;
         parseFqnRefExpr(astNode: import("../generated/ast").FqnRefExpr): invariant;
+        parseElementWhereExpr(astNode: import("../generated/ast").ElementPredicateWhereV2): invariant;
         parseFqnExpressions(astNode: import("../generated/ast").FqnExpressions): invariant[];
         parseRelationWhereExpr(astNode: import("../generated/ast").RelationPredicateWhereV2): invariant;
         parseRelationExpr(astNode: import("../generated/ast").RelationExpr): invariant;
@@ -217,6 +220,7 @@ declare const DocumentParserFromMixins: {
         parseFqnRef(astNode: import("../generated/ast").FqnRef): invariant;
         parseFqnExpr(astNode: import("../generated/ast").FqnExpr): invariant;
         parseFqnRefExpr(astNode: import("../generated/ast").FqnRefExpr): invariant;
+        parseElementWhereExpr(astNode: import("../generated/ast").ElementPredicateWhereV2): invariant;
         parseFqnExpressions(astNode: import("../generated/ast").FqnExpressions): invariant[];
         parseRelationWhereExpr(astNode: import("../generated/ast").RelationPredicateWhereV2): invariant;
         parseRelationExpr(astNode: import("../generated/ast").RelationExpr): invariant;
@@ -241,6 +245,7 @@ declare const DocumentParserFromMixins: {
     new (...args: any[]): {
         parseModel(): void;
         parseElement(astNode: import("../generated/ast").Element): import("../ast").ParsedAstElement;
+        parseExtendElement(astNode: import("../generated/ast").ExtendElement): import("../ast").ParsedAstExtendElement | null;
         parseRelation(astNode: import("../generated/ast").Relation): import("../ast").ParsedAstRelation;
         isValid: import("../validation").IsValidFn;
         readonly services: LikeC4Services;
@@ -264,6 +269,7 @@ declare const DocumentParserFromMixins: {
         parseFqnRef(astNode: import("../generated/ast").FqnRef): invariant;
         parseFqnExpr(astNode: import("../generated/ast").FqnExpr): invariant;
         parseFqnRefExpr(astNode: import("../generated/ast").FqnRefExpr): invariant;
+        parseElementWhereExpr(astNode: import("../generated/ast").ElementPredicateWhereV2): invariant;
         parseFqnExpressions(astNode: import("../generated/ast").FqnExpressions): invariant[];
         parseRelationWhereExpr(astNode: import("../generated/ast").RelationPredicateWhereV2): invariant;
         parseRelationExpr(astNode: import("../generated/ast").RelationExpr): invariant;

package/dist/model/model-parser.js

@@ -42,6 +42,7 @@ export class LikeC4ModelParser {
           deployments: {}
         },
         c4Elements: [],
+        c4ExtendElements: [],
         c4Relations: [],
         c4Deployments: [],
         c4DeploymentRelations: [],

package/dist/model/parser/Base.js

@@ -1,5 +1,5 @@
 import { invariant, isNonEmptyArray } from "@likec4/core";
-import { filter, flatMap, isNonNullish, isTruthy, mapToObj, pipe } from "remeda";
+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";
@@ -32,10 +32,16 @@ export class BaseParser {
     return this.services.workspace.AstNodeLocator.getAstNodePath(node);
   }
   getMetadata(metadataAstNode) {
-    if (!metadataAstNode || !this.isValid(metadataAstNode)) {
+    if (!metadataAstNode || !this.isValid(metadataAstNode) || isEmpty(metadataAstNode.props)) {
       return void 0;
     }
-    return mapToObj(metadataAstNode.props, (p) => [p.key, removeIndent(p.value)]);
+    const data = pipe(
+      metadataAstNode.props,
+      map((p) => [p.key, removeIndent(p.value)]),
+      filter(([_, value]) => isTruthy(value)),
+      fromEntries()
+    );
+    return isEmpty(data) ? void 0 : data;
   }
   convertTags(withTags) {
     return this.parseTags(withTags);
@@ -45,7 +51,7 @@ export class BaseParser {
     if (!iter) {
       return null;
     }
-    const tags = [];
+    let tags = [];
     while (iter) {
       try {
         if (this.isValid(iter)) {
@@ -58,7 +64,7 @@ export class BaseParser {
       }
       iter = iter.prev;
     }
-    tags.reverse();
+    tags = unique(tags.reverse());
     return isNonEmptyArray(tags) ? tags : null;
   }
   convertLinks(source) {

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

@@ -11,6 +11,7 @@ export declare function DeploymentModelParser<TBase extends WithExpressionV2>(B:
         parseFqnRef(astNode: ast.FqnRef): c4.FqnRef;
         parseFqnExpr(astNode: ast.FqnExpr): c4.FqnExpr;
         parseFqnRefExpr(astNode: ast.FqnRefExpr): c4.FqnExpr.NonWildcard;
+        parseElementWhereExpr(astNode: ast.ElementPredicateWhereV2): c4.RelationExpr;
         parseFqnExpressions(astNode: ast.FqnExpressions): c4.FqnExpr[];
         parseRelationWhereExpr(astNode: ast.RelationPredicateWhereV2): c4.RelationExpr;
         parseRelationExpr(astNode: ast.RelationExpr): c4.RelationExpr;

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

@@ -12,6 +12,7 @@ export declare function DeploymentViewParser<TBase extends WithExpressionV2 & Wi
         parseFqnRef(astNode: ast.FqnRef): c4.FqnRef;
         parseFqnExpr(astNode: ast.FqnExpr): c4.FqnExpr;
         parseFqnRefExpr(astNode: ast.FqnRefExpr): c4.FqnExpr.NonWildcard;
+        parseElementWhereExpr(astNode: ast.ElementPredicateWhereV2): c4.RelationExpr;
         parseFqnExpressions(astNode: ast.FqnExpressions): c4.FqnExpr[];
         parseRelationWhereExpr(astNode: ast.RelationPredicateWhereV2): c4.RelationExpr;
         parseRelationExpr(astNode: ast.RelationExpr): c4.RelationExpr;

package/dist/model/parser/DeploymentViewParser.js

@@ -67,6 +67,9 @@ export function DeploymentViewParser(B) {
               case ast.isFqnExpr(expr):
                 exprs.unshift(this.parseFqnExpr(expr));
                 break;
+              case ast.isElementPredicateWhereV2(expr):
+                exprs.unshift(this.parseElementWhereExpr(expr));
+                break;
               case ast.isRelationExpr(expr):
                 exprs.unshift(this.parseRelationExpr(expr));
                 break;

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

@@ -7,6 +7,7 @@ export declare function ExpressionV2Parser<TBase extends Base>(B: TBase): {
         parseFqnRef(astNode: ast.FqnRef): c4.FqnRef;
         parseFqnExpr(astNode: ast.FqnExpr): c4.FqnExpr;
         parseFqnRefExpr(astNode: ast.FqnRefExpr): c4.FqnExpr.NonWildcard;
+        parseElementWhereExpr(astNode: ast.ElementPredicateWhereV2): c4.RelationExpr;
         parseFqnExpressions(astNode: ast.FqnExpressions): c4.FqnExpr[];
         parseRelationWhereExpr(astNode: ast.RelationPredicateWhereV2): c4.RelationExpr;
         parseRelationExpr(astNode: ast.RelationExpr): c4.RelationExpr;

package/dist/model/parser/FqnRefParser.js

@@ -65,6 +65,16 @@ export function ExpressionV2Parser(B) {
           return { ref };
       }
     }
+    parseElementWhereExpr(astNode) {
+      return {
+        where: {
+          expr: this.parseFqnExpr(astNode.subject),
+          condition: astNode.where ? parseWhereClause(astNode.where) : {
+            kind: { neq: "--always-true--" }
+          }
+        }
+      };
+    }
     parseFqnExpressions(astNode) {
       const exprs = [];
       let iter = astNode;

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

@@ -56,6 +56,7 @@ export declare function GlobalsParser<TBase extends WithViewsParser>(B: TBase):
         parseFqnRef(astNode: ast.FqnRef): c4.FqnRef;
         parseFqnExpr(astNode: ast.FqnExpr): c4.FqnExpr;
         parseFqnRefExpr(astNode: ast.FqnRefExpr): c4.FqnExpr.NonWildcard;
+        parseElementWhereExpr(astNode: ast.ElementPredicateWhereV2): c4.RelationExpr;
         parseFqnExpressions(astNode: ast.FqnExpressions): c4.FqnExpr[];
         parseRelationWhereExpr(astNode: ast.RelationPredicateWhereV2): c4.RelationExpr;
         parseRelationExpr(astNode: ast.RelationExpr): c4.RelationExpr;

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

@@ -1,11 +1,12 @@
 import type * as c4 from '@likec4/core';
-import { type ParsedAstElement, type ParsedAstRelation, ast } from '../../ast';
+import { type ParsedAstElement, type ParsedAstExtendElement, 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;
         parseRelation(astNode: ast.Relation): ParsedAstRelation;
         isValid: import("../../validation").IsValidFn;
         readonly services: import("../..").LikeC4Services;

package/dist/model/parser/ModelParser.js

@@ -1,5 +1,5 @@
 import { isNonEmptyArray, nonexhaustive, nonNullable } from "@likec4/core";
-import { filter, first, isNonNullish, isTruthy, map, mapToObj, pipe } from "remeda";
+import { filter, first, isEmpty, isNonNullish, isTruthy, map, mapToObj, pipe } from "remeda";
 import {
   ast,
   resolveRelationPoints,
@@ -26,6 +26,13 @@ export function ModelParser(B) {
             }
             continue;
           }
+          if (ast.isExtendElement(el)) {
+            const parsed = this.parseExtendElement(el);
+            if (parsed) {
+              doc.c4ExtendElements.push(parsed);
+            }
+            continue;
+          }
           nonexhaustive(el);
         } catch (e) {
           logWarnError(e);
@@ -72,6 +79,24 @@ export function ModelParser(B) {
         style
       };
     }
+    parseExtendElement(astNode) {
+      const isValid = this.isValid;
+      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 }
+      };
+    }
     parseRelation(astNode) {
       const isValid = this.isValid;
       const coupling = resolveRelationPoints(astNode);

package/dist/model/parser/PredicatesParser.js

@@ -1,6 +1,6 @@
 import { invariant, nonexhaustive } from "@likec4/core";
 import { isBoolean, isDefined, isTruthy } from "remeda";
-import { ast, parseAstOpacityProperty, toColor } from "../../ast.js";
+import { ast, parseAstOpacityProperty, parseAstSizeValue, toColor } from "../../ast.js";
 import { logWarnError } from "../../logger.js";
 import { elementRef } from "../../utils/elementRef.js";
 import { parseWhereClause } from "../model-parser-where.js";
@@ -171,6 +171,24 @@ export function PredicatesParser(B) {
             }
             return acc;
           }
+          if (ast.isShapeSizeProperty(prop)) {
+            if (isTruthy(prop.value)) {
+              acc.custom[prop.key] = parseAstSizeValue(prop);
+            }
+            return acc;
+          }
+          if (ast.isTextSizeProperty(prop)) {
+            if (isTruthy(prop.value)) {
+              acc.custom[prop.key] = parseAstSizeValue(prop);
+            }
+            return acc;
+          }
+          if (ast.isPaddingSizeProperty(prop)) {
+            if (isTruthy(prop.value)) {
+              acc.custom[prop.key] = parseAstSizeValue(prop);
+            }
+            return acc;
+          }
           nonexhaustive(prop);
         },
         {

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

@@ -54,6 +54,7 @@ export declare function ViewsParser<TBase extends WithPredicates & WithDeploymen
         parseFqnRef(astNode: ast.FqnRef): c4.FqnRef;
         parseFqnExpr(astNode: ast.FqnExpr): c4.FqnExpr;
         parseFqnRefExpr(astNode: ast.FqnRefExpr): c4.FqnExpr.NonWildcard;
+        parseElementWhereExpr(astNode: ast.ElementPredicateWhereV2): c4.RelationExpr;
         parseFqnExpressions(astNode: ast.FqnExpressions): c4.FqnExpr[];
         parseRelationWhereExpr(astNode: ast.RelationPredicateWhereV2): c4.RelationExpr;
         parseRelationExpr(astNode: ast.RelationExpr): c4.RelationExpr;

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

@@ -1,4 +1,4 @@
-import { DefaultScopeProvider, type ReferenceInfo, type Scope } from 'langium';
+import { type ReferenceInfo, type Scope, DefaultScopeProvider } from 'langium';
 import { ast } from '../ast';
 import type { LikeC4Services } from '../module';
 export declare class LikeC4ScopeProvider extends DefaultScopeProvider {

package/dist/references/scope-provider.js

@@ -73,7 +73,7 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
         if (referenceType !== ast.Element) {
           return this.getGlobalScope(referenceType, context);
         }
-        if (ast.isFqnElementRef(container) && context.property === "el") {
+        if (ast.isStrictFqnElementRef(container) && context.property === "el") {
           const parent = container.parent;
           if (!parent) {
             return this.getGlobalScope(referenceType, context);

package/dist/test/testServices.d.ts

@@ -14,6 +14,7 @@ export declare function createTestServices(workspace?: string): {
         warnings: any;
     }>;
     buildModel: () => Promise<any>;
+    buildLikeC4Model: () => Promise<any>;
     resetState: () => Promise<void>;
     format: (input: string | LikeC4LangiumDocument, uri?: string) => Promise<any>;
 };

package/dist/test/testServices.js

@@ -1,3 +1,4 @@
+import { LikeC4Model } from "@likec4/core";
 import { DocumentState, EmptyFileSystem, TextDocument } from "langium";
 import * as assert from "node:assert";
 import stripIndent from "strip-indent";
@@ -101,6 +102,12 @@ export function createTestServices(workspace = "file:///test/workspace") {
     if (!model) throw new Error("No model found");
     return model;
   };
+  const buildLikeC4Model = async () => {
+    await validateAll();
+    const model = await modelBuilder.buildComputedModel();
+    if (!model) throw new Error("No model found");
+    return LikeC4Model.create(model);
+  };
   const resetState = async () => {
     await services.shared.workspace.WorkspaceLock.write(async (cancelToken) => {
       const docs = langiumDocuments.all.toArray().map((doc) => doc.uri);
@@ -113,6 +120,7 @@ export function createTestServices(workspace = "file:///test/workspace") {
     validate,
     validateAll,
     buildModel,
+    buildLikeC4Model,
     resetState,
     format
   };

package/dist/utils/elementRef.d.ts

@@ -3,9 +3,9 @@ import type { ast } from '../ast';
 /**
  * Returns referenced AST Element
  */
-export declare function elementRef(node: ast.ElementRef | ast.FqnElementRef): any;
+export declare function elementRef(node: ast.ElementRef | ast.StrictFqnElementRef): any;
 /**
- * Returns FQN of FqnElementRef
+ * Returns FQN of StrictFqnElementRef
  * a.b.c.d - for c node returns a.b.c
  */
-export declare function getFqnElementRef(node: ast.FqnElementRef): c4.Fqn;
+export declare function getFqnElementRef(node: ast.StrictFqnElementRef): c4.Fqn;

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.ElementStringProperty | ast.ElementStyleProperty | ast.IconProperty | ast.LinkProperty | ast.MetadataBody | ast.FqnRefExpr | 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.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.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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@likec4/language-server",
   "description": "LikeC4 Language Server",
-  "version": "1.20.3",
+  "version": "1.21.1",
   "license": "MIT",
   "bugs": "https://github.com/likec4/likec4/issues",
   "homepage": "https://likec4.dev",
@@ -90,36 +90,34 @@
     "test:watch": "vitest"
   },
   "devDependencies": {
-    "@likec4/core": "1.20.3",
-    "@likec4/icons": "1.20.3",
-    "@likec4/layouts": "1.20.3",
-    "@likec4/log": "1.20.3",
-    "@likec4/tsconfig": "1.20.3",
-    "@msgpack/msgpack": "^3.0.0-beta3",
-    "@smithy/util-base64": "^3.0.0",
+    "@likec4/core": "1.21.1",
+    "@likec4/icons": "1.21.1",
+    "@likec4/layouts": "1.21.1",
+    "@likec4/log": "1.21.1",
+    "@likec4/tsconfig": "1.21.1",
+    "@msgpack/msgpack": "^3.0.0-beta4",
+    "@smithy/util-base64": "^4.0.0",
     "@types/node": "^20.17.7",
     "@types/which": "^3.0.4",
-    "@vitest/coverage-v8": "^2.1.8",
+    "@vitest/coverage-v8": "^3.0.4",
     "esm-env": "^1.2.2",
-    "execa": "^9.3.1",
     "fast-equals": "^5.2.2",
-    "fdir": "^6.4.2",
+    "fdir": "^6.4.3",
     "indent-string": "^5.0.0",
     "json5": "^2.2.3",
     "langium": "3.3.1",
     "langium-cli": "3.3.0",
     "natural-compare-lite": "^1.4.0",
-    "npm-run-all2": "^7.0.1",
     "p-debounce": "^4.0.0",
-    "remeda": "^2.19.0",
+    "remeda": "^2.20.1",
     "strip-indent": "^4.0.0",
     "tsx": "~4.19.2",
-    "turbo": "^2.3.4",
+    "turbo": "^2.4.0",
     "type-fest": "4.28.1",
     "typescript": "^5.7.3",
     "ufo": "^1.5.4",
     "unbuild": "^3.3.1",
-    "vitest": "^2.1.8",
+    "vitest": "^3.0.4",
     "vscode-jsonrpc": "8.2.0",
     "vscode-languageserver": "9.0.1",
     "vscode-languageserver-types": "3.17.5",