@likec4/language-server 1.40.0 → 1.42.0

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/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) {
@@ -155,6 +186,7 @@ export class LikeC4Formatter extends AbstractFormatter {
         "title",
         "description",
         "technology",
+        "summary",
         "notation",
         "notes",
         "color",
@@ -353,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

@@ -29,7 +29,7 @@ export declare const LikeC4Terminals: {
     Hex: RegExp;
 };
 export type LikeC4TerminalNames = keyof typeof LikeC4Terminals;
-export type LikeC4KeywordNames = "(" | ")" | "*" | "," | "->" | "-[" | ":" | ";" | "<-" | "<->" | "BottomTop" | "LeftRight" | "RightLeft" | "TopBottom" | "]->" | "amber" | "and" | "autoLayout" | "blue" | "border" | "browser" | "color" | "crow" | "cylinder" | "dashed" | "deployment" | "deploymentNode" | "description" | "diagram" | "diamond" | "dot" | "dotted" | "dynamic" | "dynamicPredicateGroup" | "element" | "element.kind" | "element.tag" | "exclude" | "extend" | "extends" | "from" | "global" | "gray" | "green" | "group" | "head" | "icon" | "icons" | "import" | "include" | "indigo" | "instance" | "instanceOf" | "is" | "kind" | "large" | "lg" | "likec4lib" | "line" | "link" | "md" | "medium" | "metadata" | "mobile" | "model" | "multiple" | "muted" | "navigateTo" | "node" | "none" | "normal" | "not" | "notation" | "notes" | "odiamond" | "odot" | "of" | "onormal" | "opacity" | "open" | "or" | "padding" | "par" | "parallel" | "person" | "predicate" | "predicateGroup" | "primary" | "queue" | "rectangle" | "red" | "relationship" | "rgb" | "rgba" | "secondary" | "sequence" | "shape" | "size" | "sky" | "slate" | "sm" | "small" | "solid" | "source" | "specification" | "storage" | "style" | "styleGroup" | "tag" | "tail" | "target" | "technology" | "textSize" | "title" | "variant" | "vee" | "view" | "views" | "where" | "with" | "xl" | "xlarge" | "xs" | "xsmall" | "{" | "}";
+export type LikeC4KeywordNames = "(" | ")" | "*" | "," | "->" | "-[" | ":" | ";" | "<-" | "<->" | "BottomTop" | "LeftRight" | "RightLeft" | "TopBottom" | "]->" | "amber" | "and" | "autoLayout" | "blue" | "border" | "browser" | "color" | "crow" | "cylinder" | "dashed" | "deployment" | "deploymentNode" | "description" | "diagram" | "diamond" | "dot" | "dotted" | "dynamic" | "dynamicPredicateGroup" | "element" | "element.kind" | "element.tag" | "exclude" | "extend" | "extends" | "from" | "global" | "gray" | "green" | "group" | "head" | "icon" | "icons" | "import" | "include" | "indigo" | "instance" | "instanceOf" | "is" | "kind" | "large" | "lg" | "likec4lib" | "line" | "link" | "md" | "medium" | "metadata" | "mobile" | "model" | "multiple" | "muted" | "navigateTo" | "node" | "none" | "normal" | "not" | "notation" | "notes" | "odiamond" | "odot" | "of" | "onormal" | "opacity" | "open" | "or" | "padding" | "par" | "parallel" | "person" | "predicate" | "predicateGroup" | "primary" | "queue" | "rectangle" | "red" | "relationship" | "rgb" | "rgba" | "secondary" | "sequence" | "shape" | "size" | "sky" | "slate" | "sm" | "small" | "solid" | "source" | "specification" | "storage" | "style" | "styleGroup" | "summary" | "tag" | "tail" | "target" | "technology" | "textSize" | "title" | "variant" | "vee" | "view" | "views" | "where" | "with" | "xl" | "xlarge" | "xs" | "xsmall" | "{" | "}";
 export type LikeC4TokenNames = LikeC4TerminalNames | LikeC4KeywordNames;
 export type ArrowType = 'crow' | 'diamond' | 'dot' | 'none' | 'normal' | 'odiamond' | 'odot' | 'onormal' | 'open' | 'vee';
 export declare function isArrowType(item: unknown): item is ArrowType;
@@ -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>;
 }
@@ -213,6 +227,7 @@ export interface DeployedInstance extends langium.AstNode {
     readonly $type: 'DeployedInstance';
     body?: DeployedInstanceBody;
     name?: Id;
+    summary?: string;
     target: ElementRef;
     title?: string;
 }
@@ -233,6 +248,7 @@ export interface DeploymentNode extends langium.AstNode {
     body?: DeploymentNodeBody;
     kind: langium.Reference<DeploymentNodeKind>;
     name: Id;
+    summary?: string;
     title?: string;
 }
 export declare const DeploymentNode = "DeploymentNode";
@@ -371,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';
@@ -419,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;
 }
@@ -428,7 +431,7 @@ export declare function isElementRef(item: unknown): item is ElementRef;
 export interface ElementStringProperty extends langium.AstNode {
     readonly $container: CustomElementProperties | DeployedInstanceBody | DeploymentNodeBody | ElementBody;
     readonly $type: 'ElementStringProperty';
-    key: 'description' | 'technology' | 'title';
+    key: 'description' | 'summary' | 'technology' | 'title';
     value: MarkdownOrString;
 }
 export declare const ElementStringProperty = "ElementStringProperty";
@@ -842,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>;
 }
@@ -934,7 +937,7 @@ export declare function isSpecificationElementKind(item: unknown): item is Speci
 export interface SpecificationElementStringProperty extends langium.AstNode {
     readonly $container: SpecificationDeploymentNodeKind | SpecificationElementKind;
     readonly $type: 'SpecificationElementStringProperty';
-    key: 'description' | 'notation' | 'technology' | 'title';
+    key: 'description' | 'notation' | 'summary' | 'technology' | 'title';
     value: MarkdownOrString;
 }
 export declare const SpecificationElementStringProperty = "SpecificationElementStringProperty";
@@ -1170,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;
@@ -1193,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,
@@ -989,6 +1019,7 @@ export class LikeC4AstReflection extends langium.AbstractAstReflection {
           properties: [
             { name: "body" },
             { name: "name" },
+            { name: "summary" },
             { name: "target" },
             { name: "title" }
           ]
@@ -1011,6 +1042,7 @@ export class LikeC4AstReflection extends langium.AbstractAstReflection {
             { name: "body" },
             { name: "kind" },
             { name: "name" },
+            { name: "summary" },
             { name: "title" }
           ]
         };
@@ -1165,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,
@@ -2061,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,