@likec4/language-server 1.41.0 → 1.42.1

package/dist/documentation/documentation-provider.mjs

@@ -25,7 +25,7 @@ export class LikeC4DocumentationProvider {
         const instance = this.parser.forDocument(doc).parseDeployedInstance(node);
         const [projectId, fqn] = FqnRef.isImportRef(instance.element) ? [instance.element.project, instance.element.model] : [doc.likec4ProjectId, instance.element.model];
         const el = projectId ? this.locator.getParsedElement(fqn, projectId) : this.locator.getParsedElement(fqn);
-        const lines = [instance.id, `_instance of_ ${instance.element}`];
+        const lines = [instance.id, `_instance of_ ${fqn}`];
         if (el) {
           lines.push(" ", `**${el.title}**`);
         }

package/dist/filesystem/FileSystemWatcher.d.ts

@@ -1,5 +1,5 @@
-import { type AsyncDisposable } from 'langium';
-import { type LikeC4SharedServices } from '../module';
+import type { AsyncDisposable } from 'langium';
+import type { LikeC4SharedServices } from '../module';
 export interface FileSystemWatcherModuleContext {
     fileSystemWatcher: (services: LikeC4SharedServices) => FileSystemWatcher;
 }

package/dist/filesystem/LikeC4FileSystem.mjs

@@ -4,9 +4,10 @@ import { URI } from "langium";
 import { NodeFileSystemProvider } from "langium/node";
 import { LikeC4LanguageMetaData } from "../generated/module.mjs";
 import { Content, isLikeC4Builtin } from "../likec4lib.mjs";
-import { logError } from "../logger.mjs";
+import { logger as rootLogger } from "../logger.mjs";
 import { chokidarFileSystemWatcher } from "./ChokidarWatcher.mjs";
 import { noopFileSystemWatcher } from "./FileSystemWatcher.mjs";
+const logger = rootLogger.getChild("filesystem");
 export const LikeC4FileSystem = (ehableWatcher = true) => ({
   fileSystemProvider: () => new SymLinkTraversingFileSystemProvider(),
   ...ehableWatcher ? chokidarFileSystemWatcher : noopFileSystemWatcher
@@ -18,7 +19,12 @@ class SymLinkTraversingFileSystemProvider extends NodeFileSystemProvider {
     if (isLikeC4Builtin(uri)) {
       return Promise.resolve(Content);
     }
-    return await super.readFile(uri);
+    try {
+      return await super.readFile(uri);
+    } catch (error) {
+      logger.error(`Failed to read file ${uri.fsPath}`, { error });
+      return "";
+    }
   }
   async readDirectory(folderPath) {
     const entries = [];
@@ -32,7 +38,7 @@ class SymLinkTraversingFileSystemProvider extends NodeFileSystemProvider {
         });
       }
     } catch (error) {
-      logError(error);
+      logger.error(`Failed to read directory ${folderPath.fsPath}`, { error });
     }
     return entries;
   }
@@ -48,7 +54,7 @@ class SymLinkTraversingFileSystemProvider extends NodeFileSystemProvider {
         });
       }
     } catch (error) {
-      logError(error);
+      logger.error(`Failed to scan project files ${folderUri.fsPath}`, { error });
     }
     return entries;
   }

package/dist/filesystem/index.d.ts

@@ -1,4 +1,4 @@
-import { type LikeC4ProjectConfig } from '@likec4/config';
+import type { LikeC4ProjectConfig } from '@likec4/config';
 import type { FileSystemNode, FileSystemProvider as LangiumFileSystemProvider, LangiumSharedCoreServices } from 'langium';
 import { URI } from 'vscode-uri';
 import { type FileSystemWatcherModuleContext } from './FileSystemWatcher';

package/dist/formatting/LikeC4Formatter.mjs

@@ -6,6 +6,7 @@ import { AbstractFormatter, Formatting } from "langium/lsp";
 import { filter, isTruthy } from "remeda";
 import * as ast from "../generated/ast.mjs";
 import * as utils from "./utils.mjs";
+import { isMultiline } from "./utils.mjs";
 const FormattingOptions = {
   newLine: Formatting.newLine({ allowMore: true }),
   oneSpace: Formatting.oneSpace(),
@@ -64,7 +65,7 @@ export class LikeC4Formatter extends AbstractFormatter {
   }
   formatTags(node) {
     this.on(node, ast.isTags, (n, f) => {
-      const tags = GrammarUtils.findNodesForProperty(n.$cstNode, "values").filter((x) => x).slice(1);
+      const tags = GrammarUtils.findNodesForProperty(n.$cstNode, "values").filter(isTruthy).slice(1);
       f.cst(tags).prepend(FormattingOptions.oneSpace);
       f.keywords(",").prepend(FormattingOptions.noSpace).append(FormattingOptions.oneSpace);
     });
@@ -109,6 +110,27 @@ export class LikeC4Formatter extends AbstractFormatter {
       f.keywords("]->").prepend(FormattingOptions.noSpace).append(FormattingOptions.oneSpace);
       f.keywords("-[").prepend(FormattingOptions.oneSpace).append(FormattingOptions.noSpace);
       f.properties("title").prepend(FormattingOptions.oneSpace);
+      const wrapToNextLine = (
+        // Dynamic step chain with multiline source
+        ast.isDynamicStepChain(n) && isMultiline(n.$cstNode) || ast.isDynamicStepSingle(n) && ast.isDynamicStepChain(n.$container) && isMultiline(n.$container.$cstNode)
+      );
+      if (!wrapToNextLine) {
+        return;
+      }
+      f.property("dotKind").prepend(Formatting.indent({ allowLess: false, allowMore: true, priority: 2 }));
+      f.keywords("->", "-[").prepend(Formatting.indent({ allowLess: false, allowMore: true, priority: 2 }));
+      if (n.custom?.$cstNode && isMultiline(n.custom.$cstNode)) {
+        f.property("custom").prepend({
+          options: {
+            allowLess: false,
+            allowMore: true,
+            priority: 2
+          },
+          moves: [{
+            tabs: 1
+          }]
+        });
+      }
     });
   }
   removeIndentFromTopLevelStatements(node) {
@@ -121,17 +143,26 @@ export class LikeC4Formatter extends AbstractFormatter {
     if (ast.isLikeC4Lib(node) || ast.isSpecificationRule(node) || ast.isSpecificationElementKind(node) || ast.isSpecificationRelationshipKind(node) || ast.isSpecificationDeploymentNodeKind(node) || ast.isGlobals(node) || ast.isGlobalStyle(node) || ast.isGlobalStyleGroup(node) || ast.isGlobalPredicateGroup(node) || ast.isGlobalDynamicPredicateGroup(node) || ast.isGlobalStyleGroup(node) || ast.isModel(node) || ast.isElementBody(node) || ast.isExtendElementBody(node) || ast.isRelationBody(node) || ast.isRelationStyleProperty(node) || ast.isMetadataBody(node) || ast.isModelViews(node) || ast.isElementViewBody(node) || ast.isDynamicViewBody(node) || ast.isDeploymentViewBody(node) || ast.isViewRuleStyle(node) || ast.isViewRuleGroup(node) || ast.isCustomElementProperties(node) || ast.isCustomRelationProperties(node) || ast.isElementStyleProperty(node) || ast.isDynamicViewParallelSteps(node) || ast.isModelDeployments(node) || ast.isDeploymentNodeBody(node) || ast.isDeploymentRelationBody(node) || ast.isDeployedInstanceBody(node) || ast.isExtendDeploymentBody(node)) {
       const formatter = this.getNodeFormatter(node);
       const openBrace = formatter.keywords("{");
+      openBrace.prepend(FormattingOptions.noIndent).prepend(FormattingOptions.oneSpace);
+      const multiline = isMultiline(node.$cstNode);
       const closeBrace = formatter.keywords("}");
       const interiorNodes = formatter.interior(openBrace, closeBrace);
-      let perviousNode = null;
+      let previousNode = null;
       for (const interiorNode of interiorNodes.nodes) {
-        if (!perviousNode || !utils.areOverlap(perviousNode, interiorNode)) {
-          formatter.cst([interiorNode]).prepend(FormattingOptions.indent);
+        if (!multiline) {
+          formatter.cst([interiorNode]).surround(FormattingOptions.oneSpace);
+          continue;
         }
-        perviousNode = interiorNode;
+        if (!previousNode || !utils.areOverlap(previousNode, interiorNode)) {
+          formatter.cst([interiorNode]).prepend(Formatting.newLine({ allowMore: true })).prepend(FormattingOptions.indent);
+        }
+        previousNode = interiorNode;
+      }
+      if (multiline) {
+        closeBrace.prepend(FormattingOptions.noIndent).prepend(Formatting.newLine({ allowMore: true }));
+      } else {
+        closeBrace.prepend(Formatting.oneSpace({ allowLess: true }));
       }
-      openBrace.prepend(FormattingOptions.noIndent).prepend(FormattingOptions.oneSpace);
-      closeBrace.prepend(FormattingOptions.noIndent).prepend(Formatting.newLine({ allowMore: true }));
     }
   }
   appendKeywordsWithSpace(node) {
@@ -354,11 +385,11 @@ export class LikeC4Formatter extends AbstractFormatter {
     if (ast.isExpressions(node)) {
       const formatter = this.getNodeFormatter(node);
       const parent = this.findPredicateExpressionRoot(node);
-      const isMultiline = parent?.$cstNode && utils.isMultiline(parent?.$cstNode);
-      if (isMultiline) {
+      const isMultiline2 = parent?.$cstNode && utils.isMultiline(parent?.$cstNode);
+      if (isMultiline2) {
         formatter.property("value").prepend(FormattingOptions.indent);
       }
-      formatter.keyword(",").prepend(FormattingOptions.noSpace).append(isMultiline ? FormattingOptions.newLine : FormattingOptions.oneSpace);
+      formatter.keyword(",").prepend(FormattingOptions.noSpace).append(isMultiline2 ? FormattingOptions.newLine : FormattingOptions.oneSpace);
     }
   }
   formatRelationExpression(node) {

package/dist/formatting/utils.d.ts

@@ -1,6 +1,6 @@
-import type { CstNode } from "langium";
-import type { Position, Range } from "vscode-languageserver-types";
+import type { CstNode } from 'langium';
+import type { Position, Range } from 'vscode-languageserver-types';
 export declare function areOverlap(a: CstNode, b: CstNode): boolean;
 export declare function compareRanges(a: CstNode, b: CstNode): number;
 export declare function isInRagne(range: Range, pos: Position): boolean;
-export declare function isMultiline(node: CstNode): boolean;
+export declare function isMultiline(node: CstNode | undefined): boolean;

package/dist/formatting/utils.mjs

@@ -11,5 +11,5 @@ export function isInRagne(range, pos) {
   return !(pos.line < range.start.line || pos.line > range.end.line || pos.line == range.start.line && pos.character < range.start.character || pos.line == range.end.line && pos.character > range.end.character);
 }
 export function isMultiline(node) {
-  return node.range.start.line != node.range.end.line;
+  return !!node && node.range.start.line != node.range.end.line;
 }

package/dist/generated/ast.d.ts

@@ -57,6 +57,9 @@ export declare function isDynamicViewProperty(item: unknown): item is DynamicVie
 export type DynamicViewRule = DynamicViewGlobalPredicateRef | DynamicViewIncludePredicate | ViewRuleAutoLayout | ViewRuleStyleOrGlobalRef;
 export declare const DynamicViewRule = "DynamicViewRule";
 export declare function isDynamicViewRule(item: unknown): item is DynamicViewRule;
+export type DynamicViewStep = DynamicStepChain | DynamicStepSingle;
+export declare const DynamicViewStep = "DynamicViewStep";
+export declare function isDynamicViewStep(item: unknown): item is DynamicViewStep;
 export type ElementProperty = ElementStringProperty | ElementStyleProperty | IconProperty | LinkProperty | MetadataProperty;
 export declare const ElementProperty = "ElementProperty";
 export declare function isElementProperty(item: unknown): item is ElementProperty;
@@ -162,6 +165,17 @@ export declare function isWhereRelationExpression(item: unknown): item is WhereR
 export type WhereTagEqual = WhereElementTag | WhereRelationParticipantTag | WhereRelationTag;
 export declare const WhereTagEqual = "WhereTagEqual";
 export declare function isWhereTagEqual(item: unknown): item is WhereTagEqual;
+export interface AbstractDynamicStep extends langium.AstNode {
+    readonly $container: DynamicStepChain | DynamicViewBody | DynamicViewParallelSteps;
+    readonly $type: 'AbstractDynamicStep' | 'DynamicStepChain' | 'DynamicStepSingle';
+    custom?: CustomRelationProperties;
+    dotKind?: RelationKindDotRef;
+    kind?: langium.Reference<RelationshipKind>;
+    target: ElementRef;
+    title?: string;
+}
+export declare const AbstractDynamicStep = "AbstractDynamicStep";
+export declare function isAbstractDynamicStep(item: unknown): item is AbstractDynamicStep;
 export interface ArrowProperty extends langium.AstNode {
     readonly $container: CustomRelationProperties | RelationStyleProperty | SpecificationRelationshipKind;
     readonly $type: 'ArrowProperty';
@@ -202,7 +216,7 @@ export interface CustomElementProperties extends langium.AstNode {
 export declare const CustomElementProperties = "CustomElementProperties";
 export declare function isCustomElementProperties(item: unknown): item is CustomElementProperties;
 export interface CustomRelationProperties extends langium.AstNode {
-    readonly $container: DynamicViewStep | RelationExprWith;
+    readonly $container: AbstractDynamicStep | RelationExprWith;
     readonly $type: 'CustomRelationProperties';
     props: Array<NotationProperty | NotesProperty | RelationNavigateToProperty | RelationStringProperty | RelationshipStyleProperty>;
 }
@@ -373,19 +387,6 @@ export interface DynamicViewRef extends langium.AstNode {
 }
 export declare const DynamicViewRef = "DynamicViewRef";
 export declare function isDynamicViewRef(item: unknown): item is DynamicViewRef;
-export interface DynamicViewStep extends langium.AstNode {
-    readonly $container: DynamicViewBody | DynamicViewParallelSteps;
-    readonly $type: 'DynamicViewStep';
-    custom?: CustomRelationProperties;
-    dotKind?: RelationKindDotRef;
-    isBackward: boolean;
-    kind?: langium.Reference<RelationshipKind>;
-    source: ElementRef;
-    target: ElementRef;
-    title?: string;
-}
-export declare const DynamicViewStep = "DynamicViewStep";
-export declare function isDynamicViewStep(item: unknown): item is DynamicViewStep;
 export interface Element extends langium.AstNode {
     readonly $container: ElementBody | ExtendElementBody | Model;
     readonly $type: 'Element';
@@ -421,7 +422,7 @@ export interface ElementKindExpression extends langium.AstNode {
 export declare const ElementKindExpression = "ElementKindExpression";
 export declare function isElementKindExpression(item: unknown): item is ElementKindExpression;
 export interface ElementRef extends langium.AstNode {
-    readonly $container: DeployedInstance | DynamicViewStep | ElementView;
+    readonly $container: AbstractDynamicStep | DeployedInstance | DynamicStepSingle | ElementView;
     readonly $type: 'ElementRef';
     modelElement: FqnRef;
 }
@@ -844,7 +845,7 @@ export interface RelationExprWith extends langium.AstNode {
 export declare const RelationExprWith = "RelationExprWith";
 export declare function isRelationExprWith(item: unknown): item is RelationExprWith;
 export interface RelationKindDotRef extends langium.AstNode {
-    readonly $container: DeploymentRelation | DynamicViewStep | OutgoingRelationExpr | Relation;
+    readonly $container: AbstractDynamicStep | DeploymentRelation | OutgoingRelationExpr | Relation;
     readonly $type: 'RelationKindDotRef';
     kind: langium.Reference<RelationshipKind>;
 }
@@ -1172,7 +1173,23 @@ export interface WildcardExpression extends langium.AstNode {
 }
 export declare const WildcardExpression = "WildcardExpression";
 export declare function isWildcardExpression(item: unknown): item is WildcardExpression;
+export interface DynamicStepChain extends AbstractDynamicStep {
+    readonly $container: DynamicStepChain | DynamicViewBody | DynamicViewParallelSteps;
+    readonly $type: 'DynamicStepChain';
+    source: DynamicStepChain | DynamicStepSingle;
+}
+export declare const DynamicStepChain = "DynamicStepChain";
+export declare function isDynamicStepChain(item: unknown): item is DynamicStepChain;
+export interface DynamicStepSingle extends AbstractDynamicStep {
+    readonly $container: DynamicStepChain | DynamicViewBody | DynamicViewParallelSteps;
+    readonly $type: 'DynamicStepSingle';
+    isBackward: boolean;
+    source: ElementRef;
+}
+export declare const DynamicStepSingle = "DynamicStepSingle";
+export declare function isDynamicStepSingle(item: unknown): item is DynamicStepSingle;
 export type LikeC4AstType = {
+    AbstractDynamicStep: AbstractDynamicStep;
     ArrowProperty: ArrowProperty;
     BorderProperty: BorderProperty;
     ColorLiteral: ColorLiteral;
@@ -1195,6 +1212,8 @@ export type LikeC4AstType = {
     DeploymentViewRulePredicate: DeploymentViewRulePredicate;
     DeploymentViewRuleStyle: DeploymentViewRuleStyle;
     DirectedRelationExpr: DirectedRelationExpr;
+    DynamicStepChain: DynamicStepChain;
+    DynamicStepSingle: DynamicStepSingle;
     DynamicView: DynamicView;
     DynamicViewBody: DynamicViewBody;
     DynamicViewDisplayVariantProperty: DynamicViewDisplayVariantProperty;

package/dist/generated/ast.mjs

@@ -60,6 +60,10 @@ export const DynamicViewRule = "DynamicViewRule";
 export function isDynamicViewRule(item) {
   return reflection.isInstance(item, DynamicViewRule);
 }
+export const DynamicViewStep = "DynamicViewStep";
+export function isDynamicViewStep(item) {
+  return reflection.isInstance(item, DynamicViewStep);
+}
 export const ElementProperty = "ElementProperty";
 export function isElementProperty(item) {
   return reflection.isInstance(item, ElementProperty);
@@ -203,6 +207,10 @@ export const WhereTagEqual = "WhereTagEqual";
 export function isWhereTagEqual(item) {
   return reflection.isInstance(item, WhereTagEqual);
 }
+export const AbstractDynamicStep = "AbstractDynamicStep";
+export function isAbstractDynamicStep(item) {
+  return reflection.isInstance(item, AbstractDynamicStep);
+}
 export const ArrowProperty = "ArrowProperty";
 export function isArrowProperty(item) {
   return reflection.isInstance(item, ArrowProperty);
@@ -303,10 +311,6 @@ export const DynamicViewRef = "DynamicViewRef";
 export function isDynamicViewRef(item) {
   return reflection.isInstance(item, DynamicViewRef);
 }
-export const DynamicViewStep = "DynamicViewStep";
-export function isDynamicViewStep(item) {
-  return reflection.isInstance(item, DynamicViewStep);
-}
 export const Element = "Element";
 export function isElement(item) {
   return reflection.isInstance(item, Element);
@@ -687,9 +691,17 @@ export const WildcardExpression = "WildcardExpression";
 export function isWildcardExpression(item) {
   return reflection.isInstance(item, WildcardExpression);
 }
+export const DynamicStepChain = "DynamicStepChain";
+export function isDynamicStepChain(item) {
+  return reflection.isInstance(item, DynamicStepChain);
+}
+export const DynamicStepSingle = "DynamicStepSingle";
+export function isDynamicStepSingle(item) {
+  return reflection.isInstance(item, DynamicStepSingle);
+}
 export class LikeC4AstReflection extends langium.AbstractAstReflection {
   getAllTypes() {
-    return [ArrowProperty, BorderProperty, ColorLiteral, ColorProperty, CustomColor, CustomElementProperties, CustomRelationProperties, DeployedInstance, DeployedInstanceBody, DeploymentElement, DeploymentNode, DeploymentNodeBody, DeploymentNodeKind, DeploymentNodeOrElementKind, DeploymentRelation, DeploymentRelationBody, DeploymentView, DeploymentViewBody, DeploymentViewRule, DeploymentViewRulePredicate, DeploymentViewRuleStyle, DirectedRelationExpr, DynamicView, DynamicViewBody, DynamicViewDisplayVariantProperty, DynamicViewGlobalPredicateRef, DynamicViewIncludePredicate, DynamicViewParallelSteps, DynamicViewProperty, DynamicViewRef, DynamicViewRule, DynamicViewStep, Element, ElementBody, ElementKind, ElementKindExpression, ElementProperty, ElementRef, ElementStringProperty, ElementStyleProperty, ElementTagExpression, ElementView, ElementViewBody, ElementViewRef, ExpressionV2, Expressions, ExtendDeployment, ExtendDeploymentBody, ExtendElement, ExtendElementBody, ExtendElementProperty, FqnExpr, FqnExprOrWhere, FqnExprOrWith, FqnExprWhere, FqnExprWith, FqnExpressions, FqnRef, FqnRefExpr, FqnReferenceable, GlobalDynamicPredicateGroup, GlobalPredicateGroup, GlobalStyle, GlobalStyleGroup, GlobalStyleId, Globals, HexColor, IconProperty, Imported, ImportsFromPoject, InOutRelationExpr, IncomingRelationExpr, LibIcon, LikeC4Grammar, LikeC4Lib, LikeC4View, LineProperty, LinkProperty, MarkdownOrString, MetadataAttribute, MetadataBody, MetadataProperty, Model, ModelDeployments, ModelReferenceable, ModelViews, MultipleProperty, NavigateToProperty, NotationProperty, NotesProperty, OpacityProperty, OutgoingRelationExpr, PaddingSizeProperty, RGBAColor, Referenceable, Relation, RelationBody, RelationExpr, RelationExprOrWhere, RelationExprOrWith, RelationExprWhere, RelationExprWith, RelationKindDotRef, RelationNavigateToProperty, RelationProperty, RelationStringProperty, RelationStyleProperty, RelationshipKind, RelationshipStyleProperty, ShapeProperty, ShapeSizeProperty, SizeProperty, SpecificationColor, SpecificationDeploymentNodeKind, SpecificationElementKind, SpecificationElementStringProperty, SpecificationRelationshipKind, SpecificationRelationshipStringProperty, SpecificationRule, SpecificationTag, StrictFqnElementRef, StrictFqnRef, StringProperty, StyleProperty, Tag, TagRef, Tags, TextSizeProperty, ViewProperty, ViewRef, ViewRule, ViewRuleAutoLayout, ViewRuleGlobalPredicateRef, ViewRuleGlobalStyle, ViewRuleGroup, ViewRulePredicate, ViewRuleStyle, ViewRuleStyleOrGlobalRef, ViewStringProperty, WhereBinaryExpression, WhereElement, WhereElementExpression, WhereElementKind, WhereElementNegation, WhereElementTag, WhereExpression, WhereKindEqual, WhereRelation, WhereRelationExpression, WhereRelationKind, WhereRelationNegation, WhereRelationParticipantKind, WhereRelationParticipantTag, WhereRelationTag, WhereTagEqual, WildcardExpression];
+    return [AbstractDynamicStep, ArrowProperty, BorderProperty, ColorLiteral, ColorProperty, CustomColor, CustomElementProperties, CustomRelationProperties, DeployedInstance, DeployedInstanceBody, DeploymentElement, DeploymentNode, DeploymentNodeBody, DeploymentNodeKind, DeploymentNodeOrElementKind, DeploymentRelation, DeploymentRelationBody, DeploymentView, DeploymentViewBody, DeploymentViewRule, DeploymentViewRulePredicate, DeploymentViewRuleStyle, DirectedRelationExpr, DynamicStepChain, DynamicStepSingle, DynamicView, DynamicViewBody, DynamicViewDisplayVariantProperty, DynamicViewGlobalPredicateRef, DynamicViewIncludePredicate, DynamicViewParallelSteps, DynamicViewProperty, DynamicViewRef, DynamicViewRule, DynamicViewStep, Element, ElementBody, ElementKind, ElementKindExpression, ElementProperty, ElementRef, ElementStringProperty, ElementStyleProperty, ElementTagExpression, ElementView, ElementViewBody, ElementViewRef, ExpressionV2, Expressions, ExtendDeployment, ExtendDeploymentBody, ExtendElement, ExtendElementBody, ExtendElementProperty, FqnExpr, FqnExprOrWhere, FqnExprOrWith, FqnExprWhere, FqnExprWith, FqnExpressions, FqnRef, FqnRefExpr, FqnReferenceable, GlobalDynamicPredicateGroup, GlobalPredicateGroup, GlobalStyle, GlobalStyleGroup, GlobalStyleId, Globals, HexColor, IconProperty, Imported, ImportsFromPoject, InOutRelationExpr, IncomingRelationExpr, LibIcon, LikeC4Grammar, LikeC4Lib, LikeC4View, LineProperty, LinkProperty, MarkdownOrString, MetadataAttribute, MetadataBody, MetadataProperty, Model, ModelDeployments, ModelReferenceable, ModelViews, MultipleProperty, NavigateToProperty, NotationProperty, NotesProperty, OpacityProperty, OutgoingRelationExpr, PaddingSizeProperty, RGBAColor, Referenceable, Relation, RelationBody, RelationExpr, RelationExprOrWhere, RelationExprOrWith, RelationExprWhere, RelationExprWith, RelationKindDotRef, RelationNavigateToProperty, RelationProperty, RelationStringProperty, RelationStyleProperty, RelationshipKind, RelationshipStyleProperty, ShapeProperty, ShapeSizeProperty, SizeProperty, SpecificationColor, SpecificationDeploymentNodeKind, SpecificationElementKind, SpecificationElementStringProperty, SpecificationRelationshipKind, SpecificationRelationshipStringProperty, SpecificationRule, SpecificationTag, StrictFqnElementRef, StrictFqnRef, StringProperty, StyleProperty, Tag, TagRef, Tags, TextSizeProperty, ViewProperty, ViewRef, ViewRule, ViewRuleAutoLayout, ViewRuleGlobalPredicateRef, ViewRuleGlobalStyle, ViewRuleGroup, ViewRulePredicate, ViewRuleStyle, ViewRuleStyleOrGlobalRef, ViewStringProperty, WhereBinaryExpression, WhereElement, WhereElementExpression, WhereElementKind, WhereElementNegation, WhereElementTag, WhereExpression, WhereKindEqual, WhereRelation, WhereRelationExpression, WhereRelationKind, WhereRelationNegation, WhereRelationParticipantKind, WhereRelationParticipantTag, WhereRelationTag, WhereTagEqual, WildcardExpression];
   }
   computeIsSubtype(subtype, supertype) {
     switch (subtype) {
@@ -729,6 +741,10 @@ export class LikeC4AstReflection extends langium.AbstractAstReflection {
       case OutgoingRelationExpr: {
         return this.isSubtype(RelationExpr, supertype);
       }
+      case DynamicStepChain:
+      case DynamicStepSingle: {
+        return this.isSubtype(AbstractDynamicStep, supertype) || this.isSubtype(DynamicViewStep, supertype);
+      }
       case DynamicViewDisplayVariantProperty:
       case ViewProperty: {
         return this.isSubtype(DynamicViewProperty, supertype);
@@ -870,20 +886,22 @@ export class LikeC4AstReflection extends langium.AbstractAstReflection {
   getReferenceType(refInfo) {
     const referenceId = `${refInfo.container.$type}:${refInfo.property}`;
     switch (referenceId) {
-      case "ColorProperty:customColor": {
-        return CustomColor;
-      }
-      case "DeploymentNode:kind": {
-        return DeploymentNodeKind;
-      }
+      case "AbstractDynamicStep:kind":
       case "DeploymentRelation:kind":
-      case "DynamicViewStep:kind":
+      case "DynamicStepChain:kind":
+      case "DynamicStepSingle:kind":
       case "OutgoingRelationExpr:kind":
       case "Relation:kind":
       case "RelationKindDotRef:kind":
       case "WhereRelationKind:value": {
         return RelationshipKind;
       }
+      case "ColorProperty:customColor": {
+        return CustomColor;
+      }
+      case "DeploymentNode:kind": {
+        return DeploymentNodeKind;
+      }
       case "DynamicViewGlobalPredicateRef:predicate": {
         return GlobalDynamicPredicateGroup;
       }
@@ -931,6 +949,18 @@ export class LikeC4AstReflection extends langium.AbstractAstReflection {
   }
   getTypeMetaData(type) {
     switch (type) {
+      case AbstractDynamicStep: {
+        return {
+          name: AbstractDynamicStep,
+          properties: [
+            { name: "custom" },
+            { name: "dotKind" },
+            { name: "kind" },
+            { name: "target" },
+            { name: "title" }
+          ]
+        };
+      }
       case ArrowProperty: {
         return {
           name: ArrowProperty,
@@ -1167,20 +1197,6 @@ export class LikeC4AstReflection extends langium.AbstractAstReflection {
           ]
         };
       }
-      case DynamicViewStep: {
-        return {
-          name: DynamicViewStep,
-          properties: [
-            { name: "custom" },
-            { name: "dotKind" },
-            { name: "isBackward", defaultValue: false },
-            { name: "kind" },
-            { name: "source" },
-            { name: "target" },
-            { name: "title" }
-          ]
-        };
-      }
       case Element: {
         return {
           name: Element,
@@ -2063,6 +2079,33 @@ export class LikeC4AstReflection extends langium.AbstractAstReflection {
           ]
         };
       }
+      case DynamicStepChain: {
+        return {
+          name: DynamicStepChain,
+          properties: [
+            { name: "custom" },
+            { name: "dotKind" },
+            { name: "kind" },
+            { name: "source" },
+            { name: "target" },
+            { name: "title" }
+          ]
+        };
+      }
+      case DynamicStepSingle: {
+        return {
+          name: DynamicStepSingle,
+          properties: [
+            { name: "custom" },
+            { name: "dotKind" },
+            { name: "isBackward", defaultValue: false },
+            { name: "kind" },
+            { name: "source" },
+            { name: "target" },
+            { name: "title" }
+          ]
+        };
+      }
       default: {
         return {
           name: type,