@likec4/language-server 1.41.0 → 1.42.1

package/dist/model/parser/DeploymentModelParser.mjs

@@ -1,18 +1,18 @@
 import {
+  exact,
   FqnRef,
   invariant,
   isNonEmptyArray,
   LinkedList,
   nameFromFqn,
   nonexhaustive,
-  nonNullable,
-  omitUndefined
+  nonNullable
 } from "@likec4/core";
 import { loggable } from "@likec4/log";
 import { filter, first, isDefined, isEmpty, isTruthy, mapToObj, pipe } from "remeda";
 import {
   ast,
-  toRelationshipStyleExcludeDefaults
+  toRelationshipStyle
 } from "../../ast.mjs";
 import { serverLogger } from "../../logger.mjs";
 import { stringHash } from "../../utils/stringHash.mjs";
@@ -91,7 +91,7 @@ export function DeploymentModelParser(B) {
         summary: astNode.summary
       });
       const links = this.convertLinks(astNode.body);
-      return omitUndefined({
+      return exact({
         id,
         kind,
         title: title ?? nameFromFqn(id),
@@ -121,7 +121,7 @@ export function DeploymentModelParser(B) {
         summary: astNode.summary
       });
       const links = this.convertLinks(astNode.body);
-      return omitUndefined({
+      return exact({
         id,
         element: target,
         tags: tags ?? void 0,
@@ -194,7 +194,7 @@ export function DeploymentModelParser(B) {
         source.deployment,
         target.deployment
       );
-      return omitUndefined({
+      return exact({
         id,
         source,
         target,
@@ -203,7 +203,7 @@ export function DeploymentModelParser(B) {
         kind,
         tags: tags ?? void 0,
         ...isNonEmptyArray(links) && { links },
-        ...toRelationshipStyleExcludeDefaults(styleProp?.props, isValid),
+        ...toRelationshipStyle(styleProp?.props, isValid),
         navigateTo,
         astPath
       });

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

@@ -20,6 +20,7 @@ export declare function DeploymentViewParser<TBase extends WithExpressionV2 & Wi
         parseFqnExpressions(astNode: ast.FqnExpressions): c4.FqnExpr[];
         parseRelationExprOrWith(astNode: ast.RelationExprOrWith): c4.RelationExpr.Any;
         parseRelationExprWith(astNode: ast.RelationExprWith): c4.RelationExpr.Custom;
+        parseCustomRelationProperties(custom: ast.CustomRelationProperties | undefined): import("type-fest").Except<c4.RelationExpr.Custom["customRelation"], "expr">;
         parseRelationExprOrWhere(astNode: ast.RelationExprOrWhere): c4.RelationExpr.OrWhere;
         parseRelationExprWhere(astNode: ast.RelationExprWhere): c4.RelationExpr.Where;
         parseRelationExpr(astNode: ast.RelationExpr): c4.RelationExpr.OrWhere;

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

@@ -1,5 +1,6 @@
 import type * as c4 from '@likec4/core';
 import { type AstNode } from 'langium';
+import type { Except } from 'type-fest';
 import { ast } from '../../ast';
 import { type Base } from './Base';
 export type WithExpressionV2 = ReturnType<typeof ExpressionV2Parser>;
@@ -16,6 +17,7 @@ export declare function ExpressionV2Parser<TBase extends Base>(B: TBase): {
         parseFqnExpressions(astNode: ast.FqnExpressions): c4.FqnExpr[];
         parseRelationExprOrWith(astNode: ast.RelationExprOrWith): c4.RelationExpr.Any;
         parseRelationExprWith(astNode: ast.RelationExprWith): c4.RelationExpr.Custom;
+        parseCustomRelationProperties(custom: ast.CustomRelationProperties | undefined): Except<c4.RelationExpr.Custom["customRelation"], "expr">;
         parseRelationExprOrWhere(astNode: ast.RelationExprOrWhere): c4.RelationExpr.OrWhere;
         parseRelationExprWhere(astNode: ast.RelationExprWhere): c4.RelationExpr.Where;
         parseRelationExpr(astNode: ast.RelationExpr): c4.RelationExpr.OrWhere;

package/dist/model/parser/FqnRefParser.mjs

@@ -273,49 +273,54 @@ export function ExpressionV2Parser(B) {
     }
     parseRelationExprWith(astNode) {
       const expr = this.parseRelationExprOrWhere(astNode.subject);
-      const props = astNode.custom?.props ?? [];
+      const customProps = this.parseCustomRelationProperties(astNode.custom);
+      return {
+        customRelation: {
+          ...customProps,
+          expr
+        }
+      };
+    }
+    parseCustomRelationProperties(custom) {
+      const props = custom?.props ?? [];
       return props.reduce(
         (acc, prop) => {
           if (ast.isRelationStringProperty(prop) || ast.isNotationProperty(prop) || ast.isNotesProperty(prop)) {
             const value = isTruthy(prop.value) ? removeIndent(parseMarkdownAsString(prop.value)) : void 0;
             if (value) {
-              acc.customRelation[prop.key] = value;
+              acc[prop.key] = value;
             }
             return acc;
           }
           if (ast.isArrowProperty(prop)) {
             if (isTruthy(prop.value)) {
-              acc.customRelation[prop.key] = prop.value;
+              acc[prop.key] = prop.value;
             }
             return acc;
           }
           if (ast.isColorProperty(prop)) {
             const value = toColor(prop);
             if (isTruthy(value)) {
-              acc.customRelation[prop.key] = value;
+              acc[prop.key] = value;
             }
             return acc;
           }
           if (ast.isLineProperty(prop)) {
             if (isTruthy(prop.value)) {
-              acc.customRelation[prop.key] = prop.value;
+              acc[prop.key] = prop.value;
             }
             return acc;
           }
           if (ast.isRelationNavigateToProperty(prop)) {
             const viewId = prop.value.view.ref?.name;
             if (isTruthy(viewId)) {
-              acc.customRelation.navigateTo = viewId;
+              acc[prop.key] = viewId;
             }
             return acc;
           }
           nonexhaustive(prop);
         },
-        {
-          customRelation: {
-            expr
-          }
-        }
+        {}
       );
     }
     parseRelationExprOrWhere(astNode) {

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

@@ -20,8 +20,13 @@ export declare function GlobalsParser<TBase extends WithViewsParser>(B: TBase):
         parseDynamicElementView(astNode: ast.DynamicView, additionalStyles: any[]): import("../../ast").ParsedAstDynamicView;
         parseDynamicViewRule(astRule: ast.DynamicViewRule): c4.DynamicViewRule;
         parseDynamicViewIncludePredicate(astRule: ast.DynamicViewIncludePredicate): c4.DynamicViewIncludeRule;
-        parseDynamicParallelSteps(node: ast.DynamicViewParallelSteps): c4.DynamicViewParallelSteps;
-        parseDynamicStep(node: ast.DynamicViewStep): c4.DynamicViewStep;
+        parseDynamicParallelSteps(node: ast.DynamicViewParallelSteps): c4.DynamicStepsParallel;
+        parseDynamicStep(node: ast.DynamicViewStep): c4.DynamicStep | c4.DynamicStepsSeries;
+        recursiveParseDynamicStepChain(node: ast.DynamicStepChain, callstack?: Array<[source: c4.Fqn, target: c4.Fqn]>): c4.DynamicStep[];
+        parseDynamicStepSingle(node: ast.DynamicStepSingle): c4.DynamicStep;
+        parseAbstractDynamicStep(astnode: ast.AbstractDynamicStep): import("type-fest").Writable<import("type-fest").Except<c4.DynamicStep, "source", {
+            requireExactProps: true;
+        }>>;
         parsePredicate(astNode: ast.ExpressionV2): c4.ModelExpression;
         parseElementPredicate(astNode: ast.FqnExprOrWith): c4.ModelFqnExpr.Any;
         parseElementPredicateOrWhere(astNode: ast.FqnExprOrWhere): c4.ModelFqnExpr.OrWhere;
@@ -44,6 +49,7 @@ export declare function GlobalsParser<TBase extends WithViewsParser>(B: TBase):
         parseFqnExpressions(astNode: ast.FqnExpressions): c4.FqnExpr[];
         parseRelationExprOrWith(astNode: ast.RelationExprOrWith): c4.RelationExpr.Any;
         parseRelationExprWith(astNode: ast.RelationExprWith): c4.RelationExpr.Custom;
+        parseCustomRelationProperties(custom: ast.CustomRelationProperties | undefined): import("type-fest").Except<c4.RelationExpr.Custom["customRelation"], "expr">;
         parseRelationExprOrWhere(astNode: ast.RelationExprOrWhere): c4.RelationExpr.OrWhere;
         parseRelationExprWhere(astNode: ast.RelationExprWhere): c4.RelationExpr.Where;
         parseRelationExpr(astNode: ast.RelationExpr): c4.RelationExpr.OrWhere;

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

@@ -21,6 +21,7 @@ export declare function ModelParser<TBase extends WithExpressionV2>(B: TBase): {
         parseFqnExpressions(astNode: ast.FqnExpressions): c4.FqnExpr[];
         parseRelationExprOrWith(astNode: ast.RelationExprOrWith): c4.RelationExpr.Any;
         parseRelationExprWith(astNode: ast.RelationExprWith): c4.RelationExpr.Custom;
+        parseCustomRelationProperties(custom: ast.CustomRelationProperties | undefined): import("type-fest").Except<c4.RelationExpr.Custom["customRelation"], "expr">;
         parseRelationExprOrWhere(astNode: ast.RelationExprOrWhere): c4.RelationExpr.OrWhere;
         parseRelationExprWhere(astNode: ast.RelationExprWhere): c4.RelationExpr.Where;
         parseRelationExpr(astNode: ast.RelationExpr): c4.RelationExpr.OrWhere;

package/dist/model/parser/ModelParser.mjs

@@ -1,10 +1,10 @@
 import { invariant, isNonEmptyArray, LinkedList, nonexhaustive, nonNullable } from "@likec4/core";
-import { FqnRef, omitUndefined } from "@likec4/core/types";
+import { exact, FqnRef } from "@likec4/core/types";
 import { loggable } from "@likec4/log";
 import { filter, first, isDefined, isEmpty, isTruthy, map, mapToObj, pipe } from "remeda";
 import {
   ast,
-  toRelationshipStyleExcludeDefaults
+  toRelationshipStyle
 } from "../../ast.mjs";
 import { logger as mainLogger } from "../../logger.mjs";
 import { stringHash } from "../../utils/stringHash.mjs";
@@ -88,7 +88,7 @@ ${error}`, {
         technology: _technology
       });
       const links = this.parseLinks(astNode.body);
-      return omitUndefined({
+      return exact({
         id,
         kind,
         astPath,
@@ -109,7 +109,7 @@ ${error}`, {
       if (!tags && isEmpty(metadata ?? {}) && isEmpty(links)) {
         return null;
       }
-      return omitUndefined({
+      return exact({
         id,
         astPath,
         metadata,
@@ -123,12 +123,17 @@ ${error}`, {
         invariant(FqnRef.isModelRef(source) || FqnRef.isImportRef(source), "Relation source must be a model reference");
         return source;
       }
-      if (!ast.isElementBody(node.$container)) {
-        throw new Error("RelationRefError: Invalid container for sourceless relation");
+      if (ast.isElementBody(node.$container)) {
+        return {
+          model: this.resolveFqn(node.$container.$container)
+        };
       }
-      return {
-        model: this.resolveFqn(node.$container.$container)
-      };
+      if (ast.isExtendElementBody(node.$container)) {
+        return {
+          model: this.resolveFqn(node.$container.$container)
+        };
+      }
+      throw new Error("RelationRefError: Invalid container for sourceless relation");
     }
     parseRelation(astNode) {
       const isValid = this.isValid;
@@ -165,7 +170,7 @@ ${error}`, {
         source.model,
         target.model
       );
-      return omitUndefined({
+      return exact({
         id,
         astPath,
         source,
@@ -178,7 +183,7 @@ ${error}`, {
         navigateTo: navigateTo ? navigateTo : void 0,
         description,
         technology,
-        ...toRelationshipStyleExcludeDefaults(styleProp?.props, isValid)
+        ...toRelationshipStyle(styleProp?.props, isValid)
       });
     }
   };

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

@@ -26,6 +26,7 @@ export declare function PredicatesParser<TBase extends WithExpressionV2>(B: TBas
         parseFqnExpressions(astNode: ast.FqnExpressions): c4.FqnExpr[];
         parseRelationExprOrWith(astNode: ast.RelationExprOrWith): c4.RelationExpr.Any;
         parseRelationExprWith(astNode: ast.RelationExprWith): c4.RelationExpr.Custom;
+        parseCustomRelationProperties(custom: ast.CustomRelationProperties | undefined): import("type-fest").Except<c4.RelationExpr.Custom["customRelation"], "expr">;
         parseRelationExprOrWhere(astNode: ast.RelationExprOrWhere): c4.RelationExpr.OrWhere;
         parseRelationExprWhere(astNode: ast.RelationExprWhere): c4.RelationExpr.Where;
         parseRelationExpr(astNode: ast.RelationExpr): c4.RelationExpr.OrWhere;

package/dist/model/parser/SpecificationParser.mjs

@@ -1,9 +1,9 @@
 import * as c4 from "@likec4/core";
-import { omitUndefined } from "@likec4/core";
+import { exact } from "@likec4/core";
 import { nonNullable } from "@likec4/core/utils";
 import { loggable } from "@likec4/log";
 import { filter, isNonNullish, isNullish, isTruthy, mapToObj, omitBy, pipe } from "remeda";
-import { ast, parseMarkdownAsString, toRelationshipStyleExcludeDefaults } from "../../ast.mjs";
+import { ast, parseMarkdownAsString, toRelationshipStyle } from "../../ast.mjs";
 import { serverLogger } from "../../logger.mjs";
 import { removeIndent } from "./Base.mjs";
 const logger = serverLogger.getChild("SpecificationParser");
@@ -52,7 +52,7 @@ export function SpecificationParser(B) {
           );
           c4Specification.relationships[kindName] = {
             ...bodyProps,
-            ...toRelationshipStyleExcludeDefaults(props, this.isValid)
+            ...toRelationshipStyle(props.filter(ast.isRelationshipStyleProperty), this.isValid)
           };
         } catch (e) {
           logger.warn(loggable(e));
@@ -107,7 +107,7 @@ export function SpecificationParser(B) {
       const baseProps = this.parseBaseProps(bodyProps);
       const notation = removeIndent(parseMarkdownAsString(bodyProps.notation));
       return {
-        [kindName]: omitUndefined({
+        [kindName]: exact({
           ...baseProps,
           notation,
           tags: tags ?? void 0,

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

@@ -1,4 +1,5 @@
 import * as c4 from '@likec4/core';
+import type { Except, Writable } from 'type-fest';
 import { type ParsedAstDynamicView, type ParsedAstElementView, ast } from '../../ast';
 import type { WithDeploymentView } from './DeploymentViewParser';
 import type { WithPredicates } from './PredicatesParser';
@@ -18,8 +19,16 @@ export declare function ViewsParser<TBase extends WithPredicates & WithDeploymen
         parseDynamicElementView(astNode: ast.DynamicView, additionalStyles: ViewRuleStyleOrGlobalRef[]): ParsedAstDynamicView;
         parseDynamicViewRule(astRule: ast.DynamicViewRule): c4.DynamicViewRule;
         parseDynamicViewIncludePredicate(astRule: ast.DynamicViewIncludePredicate): c4.DynamicViewIncludeRule;
-        parseDynamicParallelSteps(node: ast.DynamicViewParallelSteps): c4.DynamicViewParallelSteps;
-        parseDynamicStep(node: ast.DynamicViewStep): c4.DynamicViewStep;
+        parseDynamicParallelSteps(node: ast.DynamicViewParallelSteps): c4.DynamicStepsParallel;
+        /**
+         * @returns non-empty array in case of step chain A -> B -> C
+         */
+        parseDynamicStep(node: ast.DynamicViewStep): c4.DynamicStep | c4.DynamicStepsSeries;
+        recursiveParseDynamicStepChain(node: ast.DynamicStepChain, callstack?: Array<[source: c4.Fqn, target: c4.Fqn]>): c4.DynamicStep[];
+        parseDynamicStepSingle(node: ast.DynamicStepSingle): c4.DynamicStep;
+        parseAbstractDynamicStep(astnode: ast.AbstractDynamicStep): Writable<Except<c4.DynamicStep, "source", {
+            requireExactProps: true;
+        }>>;
         parsePredicate(astNode: ast.ExpressionV2): c4.ModelExpression;
         parseElementPredicate(astNode: ast.FqnExprOrWith): c4.ModelFqnExpr.Any;
         parseElementPredicateOrWhere(astNode: ast.FqnExprOrWhere): c4.ModelFqnExpr.OrWhere;
@@ -42,6 +51,7 @@ export declare function ViewsParser<TBase extends WithPredicates & WithDeploymen
         parseFqnExpressions(astNode: ast.FqnExpressions): c4.FqnExpr[];
         parseRelationExprOrWith(astNode: ast.RelationExprOrWith): c4.RelationExpr.Any;
         parseRelationExprWith(astNode: ast.RelationExprWith): c4.RelationExpr.Custom;
+        parseCustomRelationProperties(custom: ast.CustomRelationProperties | undefined): Except<c4.RelationExpr.Custom["customRelation"], "expr">;
         parseRelationExprOrWhere(astNode: ast.RelationExprOrWhere): c4.RelationExpr.OrWhere;
         parseRelationExprWhere(astNode: ast.RelationExprWhere): c4.RelationExpr.Where;
         parseRelationExpr(astNode: ast.RelationExpr): c4.RelationExpr.OrWhere;

package/dist/model/parser/ViewsParser.mjs

@@ -1,6 +1,7 @@
 import * as c4 from "@likec4/core";
 import { invariant, isNonEmptyArray, nonexhaustive } from "@likec4/core";
-import { filter, find, isArray, isDefined, isEmpty, isNonNullish, isTruthy, mapToObj, pipe } from "remeda";
+import { loggable } from "@likec4/log";
+import { filter, find, isDefined, isEmpty, isNonNullish, isNumber, isTruthy, last, mapToObj, pipe } from "remeda";
 import {
   ast,
   parseMarkdownAsString,
@@ -8,11 +9,12 @@ import {
   toColor,
   ViewOps
 } from "../../ast.mjs";
-import { logger, logWarnError } from "../../logger.mjs";
+import { logger as mainLogger } from "../../logger.mjs";
 import { stringHash } from "../../utils/index.mjs";
 import { elementRef } from "../../utils/elementRef.mjs";
 import { parseViewManualLayout } from "../../view-utils/manual-layout.mjs";
 import { removeIndent, toSingleLine } from "./Base.mjs";
+const logger = mainLogger.getChild("ViewsParser");
 export function ViewsParser(B) {
   return class ViewsParser extends B {
     parseViews() {
@@ -22,7 +24,7 @@ export function ViewsParser(B) {
           try {
             return isValid(s) ? this.parseViewRuleStyleOrGlobalRef(s) : [];
           } catch (e) {
-            logWarnError(e);
+            logger.warn(loggable(e));
             return [];
           }
         });
@@ -50,7 +52,7 @@ export function ViewsParser(B) {
               view2.title = folder + " / " + (view2.title || view2.id);
             }
           } catch (e) {
-            logWarnError(e);
+            logger.warn(loggable(e));
           }
         }
       }
@@ -102,7 +104,7 @@ export function ViewsParser(B) {
             try {
               return this.isValid(n) ? this.parseElementViewRule(n) : [];
             } catch (e) {
-              logWarnError(e);
+              logger.warn(loggable(e));
               return [];
             }
           })
@@ -149,7 +151,7 @@ export function ViewsParser(B) {
             exprs.unshift(expr);
           }
         } catch (e) {
-          logWarnError(e);
+          logger.warn(loggable(e));
         }
         if (!prev) {
           break;
@@ -189,7 +191,7 @@ export function ViewsParser(B) {
           }
           nonexhaustive(rule);
         } catch (e) {
-          logWarnError(e);
+          logger.warn(loggable(e));
         }
       }
       return {
@@ -255,7 +257,7 @@ export function ViewsParser(B) {
             try {
               return isValid(n) ? this.parseDynamicViewRule(n) : [];
             } catch (e) {
-              logWarnError(e);
+              logger.warn(loggable(e));
               return [];
             }
           }, [])
@@ -270,7 +272,7 @@ export function ViewsParser(B) {
               }
             }
           } catch (e) {
-            logWarnError(e);
+            logger.warn(loggable(e));
           }
           return acc;
         }, []),
@@ -304,46 +306,113 @@ export function ViewsParser(B) {
             }
           }
         } catch (e) {
-          logWarnError(e);
+          logger.warn(loggable(e));
         }
         iter = iter.prev;
       }
       return { include };
     }
     parseDynamicParallelSteps(node) {
+      const parallelId = pathInsideDynamicView(node);
+      const __parallel = node.steps.map((step) => this.parseDynamicStep(step));
+      invariant(isNonEmptyArray(__parallel), "Dynamic parallel steps must have at least one step");
       return {
-        __parallel: node.steps.map((step) => this.parseDynamicStep(step))
+        parallelId,
+        __parallel
       };
     }
+    /**
+     * @returns non-empty array in case of step chain A -> B -> C
+     */
     parseDynamicStep(node) {
+      if (ast.isDynamicStepSingle(node)) {
+        invariant(this.isValid(node));
+        return this.parseDynamicStepSingle(node);
+      }
+      const __series = this.recursiveParseDynamicStepChain(node);
+      invariant(isNonEmptyArray(__series), "Dynamic step chain must have at least one step");
+      return {
+        seriesId: pathInsideDynamicView(node),
+        __series
+      };
+    }
+    recursiveParseDynamicStepChain(node, callstack) {
+      if (ast.isDynamicStepSingle(node.source)) {
+        if (!this.isValid(node.source)) {
+          return [];
+        }
+        const previous2 = this.parseDynamicStepSingle(node.source);
+        if (previous2.isBackward) {
+          return [];
+        }
+        const thisStep2 = {
+          ...this.parseAbstractDynamicStep(node),
+          source: previous2.target
+        };
+        if (thisStep2.target === previous2.source) {
+          thisStep2.isBackward = true;
+        } else if (callstack) {
+          callstack.push([previous2.source, previous2.target]);
+          callstack.push([thisStep2.source, thisStep2.target]);
+        }
+        return [previous2, thisStep2];
+      }
+      callstack ??= [];
+      const allprevious = this.recursiveParseDynamicStepChain(node.source, callstack);
+      if (!isNonEmptyArray(allprevious) || !this.isValid(node)) {
+        return [];
+      }
+      const previous = last(allprevious);
+      const thisStep = {
+        ...this.parseAbstractDynamicStep(node),
+        source: previous.target
+      };
+      const index = callstack.findIndex(([source, target]) => source === thisStep.target && target === thisStep.source);
+      if (index !== -1) {
+        thisStep.isBackward = true;
+        callstack.splice(index, callstack.length - index);
+      } else {
+        callstack.push([thisStep.source, thisStep.target]);
+      }
+      return [...allprevious, thisStep];
+    }
+    parseDynamicStepSingle(node) {
       const sourceEl = elementRef(node.source);
       if (!sourceEl) {
         throw new Error("Invalid reference to source");
       }
-      const targetEl = elementRef(node.target);
-      if (!targetEl) {
-        throw new Error("Invalid reference to target");
-      }
-      let source = this.resolveFqn(sourceEl);
-      let target = this.resolveFqn(targetEl);
-      const title = removeIndent(node.title) ?? null;
-      let step = {
-        source,
-        target,
-        title
+      let baseStep = {
+        ...this.parseAbstractDynamicStep(node),
+        source: this.resolveFqn(sourceEl)
       };
       if (node.isBackward) {
-        step = {
-          source: target,
-          target: source,
-          title,
+        baseStep = {
+          ...baseStep,
+          source: baseStep.target,
+          target: baseStep.source,
           isBackward: true
         };
       }
-      if (!isArray(node.custom?.props)) {
-        return step;
+      return baseStep;
+    }
+    parseAbstractDynamicStep(astnode) {
+      const targetEl = elementRef(astnode.target);
+      if (!targetEl) {
+        throw new Error("Invalid reference to target");
+      }
+      const step = {
+        target: this.resolveFqn(targetEl),
+        astPath: pathInsideDynamicView(astnode)
+      };
+      const title = removeIndent(astnode.title);
+      if (title) {
+        step.title = title;
+      }
+      const kind = astnode.kind?.ref?.name ?? astnode.dotKind?.kind.ref?.name;
+      if (kind) {
+        step.kind = kind;
       }
-      for (const prop of node.custom.props) {
+      for (const prop of astnode.custom?.props ?? []) {
         try {
           switch (true) {
             case ast.isRelationNavigateToProperty(prop): {
@@ -356,7 +425,14 @@ export function ViewsParser(B) {
             case ast.isRelationStringProperty(prop):
             case ast.isNotationProperty(prop): {
               if (isDefined(prop.value)) {
-                step[prop.key] = removeIndent(parseMarkdownAsString(prop.value)) ?? "";
+                if (prop.key === "description") {
+                  const value = removeIndent(prop.value);
+                  if (value) {
+                    step.description = value;
+                  }
+                } else {
+                  step[prop.key] = removeIndent(parseMarkdownAsString(prop.value)) ?? "";
+                }
               }
               break;
             }
@@ -389,10 +465,26 @@ export function ViewsParser(B) {
               nonexhaustive(prop);
           }
         } catch (e) {
-          logWarnError(e);
+          logger.warn(loggable(e));
         }
       }
       return step;
     }
   };
 }
+function pathInsideDynamicView(_node) {
+  let node = _node;
+  let path = [];
+  while (!ast.isDynamicViewBody(node)) {
+    if (isNumber(node.$containerIndex)) {
+      path.unshift(
+        `@${node.$containerIndex}`
+      );
+    }
+    path.unshift(
+      `/${node.$containerProperty ?? "__invalid__"}`
+    );
+    node = node.$container;
+  }
+  return path.join("");
+}

package/dist/model-change/ModelChanges.d.ts

@@ -1,5 +1,5 @@
 import { Location, Range, TextEdit } from 'vscode-languageserver-types';
-import { type ParsedLikeC4LangiumDocument } from '../ast';
+import type { ParsedLikeC4LangiumDocument } from '../ast';
 import type { LikeC4Services } from '../module';
 import type { ChangeView } from '../protocol';
 export declare class LikeC4ModelChanges {

package/dist/module.mjs

@@ -1,3 +1,4 @@
+import { onNextTick } from "@likec4/core/utils";
 import { GraphvizWasmAdapter, QueueGraphvizLayoter } from "@likec4/layouts";
 import {
   DocumentState,
@@ -144,9 +145,9 @@ export function createLanguageServices(context, module, module2, module3) {
   shared.ServiceRegistry.register(likec4);
   registerValidationChecks(likec4);
   if (!context.connection) {
-    shared.workspace.ConfigurationProvider.initialized({});
+    void shared.workspace.ConfigurationProvider.initialized({});
   } else {
-    likec4.Rpc.init();
+    onNextTick(() => likec4.Rpc.init());
   }
   return { shared, likec4 };
 }

package/dist/protocol.d.ts

@@ -176,18 +176,42 @@ export declare namespace BuildDocuments {
  * If LSP has multiple projects, the projectId is required.
  */
 export declare namespace Locate {
-    type Params = {
+    type Params = 
+    /**
+     * Locate an element by its fqn
+     */
+    {
         element: Fqn;
         projectId?: string | undefined;
         property?: string;
-    } | {
+    }
+    /**
+     * Locate a relation by its id
+     */
+     | {
         projectId?: string | undefined;
         relation: RelationId;
-    } | {
+    }
+    /**
+     * Locate a deployment by its fqn
+     */
+     | {
         deployment: DeploymentFqn;
         projectId?: string | undefined;
         property?: string;
-    } | {
+    }
+    /**
+     * Locate a step in a dynamic view by its astPath
+     */
+     | {
+        view: ViewId;
+        astPath: string;
+        projectId?: string | undefined;
+    }
+    /**
+     * Locate a view by its id
+     */
+     | {
         view: ViewId;
         projectId?: string | undefined;
     };