@likec4/language-server 1.32.2 → 1.34.0

package/dist/model/parser/DeploymentViewParser.js

@@ -1,11 +1,11 @@
 import * as c4 from "@likec4/core";
 import { invariant, isNonEmptyArray, nonexhaustive } from "@likec4/core";
-import { isNonNullish } from "remeda";
-import { ast, toAutoLayout, ViewOps } from "../../ast.js";
+import { filter, isNonNullish, mapToObj, pipe } from "remeda";
+import { ast, parseMarkdownAsString, toAutoLayout, ViewOps } from "../../ast.js";
 import { logWarnError } from "../../logger.js";
 import { stringHash } from "../../utils/index.js";
 import { parseViewManualLayout } from "../../view-utils/manual-layout.js";
-import { removeIndent, toSingleLine } from "./Base.js";
+import { removeIndent } from "./Base.js";
 export function DeploymentViewParser(B) {
   return class DeploymentViewParser extends B {
     parseDeploymentView(astNode) {
@@ -20,8 +20,17 @@ export function DeploymentViewParser(B) {
           astPath
         );
       }
-      const title = toSingleLine(props.find((p) => p.key === "title")?.value) ?? null;
-      const description = removeIndent(props.find((p) => p.key === "description")?.value) ?? null;
+      const {
+        title = null,
+        description = null
+      } = this.parseTitleDescriptionTechnology(
+        {},
+        pipe(
+          props,
+          filter(ast.isViewStringProperty),
+          mapToObj((p) => [p.key, p.value])
+        )
+      );
       const tags = this.convertTags(body);
       const links = this.convertLinks(body);
       ViewOps.writeId(astNode, id);
@@ -75,7 +84,7 @@ export function DeploymentViewParser(B) {
     }
     parseDeploymentViewRuleStyle(astRule) {
       const style = this.parseStyleProps(astRule.props.filter(ast.isStyleProperty));
-      const notation = removeIndent(astRule.props.find(ast.isNotationProperty)?.value);
+      const notation = removeIndent(parseMarkdownAsString(astRule.props.find(ast.isNotationProperty)?.value));
       const targets = this.parseFqnExpressions(astRule.targets);
       return {
         targets,

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

@@ -17,7 +17,9 @@ export declare function ExpressionV2Parser<TBase extends Base>(B: TBase): {
         parseRelationExprWith(astNode: ast.RelationExprWith): c4.RelationExpr.Custom;
         parseRelationExprOrWhere(astNode: ast.RelationExprOrWhere): c4.RelationExpr.OrWhere;
         parseRelationExprWhere(astNode: ast.RelationExprWhere): c4.RelationExpr.Where;
-        parseRelationExpr(astNode: ast.RelationExpr): c4.RelationExpr;
+        parseRelationExpr(astNode: ast.RelationExpr): c4.RelationExpr.OrWhere;
+        parseInlineKindCondition(astNode: ast.OutgoingRelationExpr): c4.WhereOperator | null;
+        wrapInWhere(expr: c4.RelationExpr, condition: c4.WhereOperator | null): c4.RelationExpr.OrWhere;
         isValid: import("../../validation").IsValidFn;
         readonly services: import("../..").LikeC4Services;
         readonly doc: import("../../ast").ParsedLikeC4LangiumDocument;
@@ -31,6 +33,7 @@ export declare function ExpressionV2Parser<TBase extends Base>(B: TBase): {
         getMetadata(metadataAstNode: ast.MetadataProperty | undefined): {
             [key: string]: string;
         } | undefined;
+        parseMarkdownOrString(markdownOrString: ast.MarkdownOrString | undefined): c4.MarkdownOrString | undefined;
         convertTags<E extends {
             tags?: ast.Tags;
         }>(withTags?: E | undefined): any;
@@ -43,5 +46,18 @@ export declare function ExpressionV2Parser<TBase extends Base>(B: TBase): {
         parseColorLiteral(astNode: ast.ColorLiteral): c4.ColorLiteral | undefined;
         parseElementStyle(elementProps: Array<ast.ElementProperty> | ast.ElementStyleProperty | undefined): import("../../ast").ParsedElementStyle;
         parseStyleProps(styleProps: Array<ast.StyleProperty> | undefined): import("../../ast").ParsedElementStyle;
+        parseTitleDescriptionTechnology(inlineProps: {
+            title?: string | undefined;
+            description?: string | undefined;
+            technology?: string | undefined;
+        }, bodyProps: {
+            title?: ast.MarkdownOrString | undefined;
+            description?: ast.MarkdownOrString | undefined;
+            technology?: ast.MarkdownOrString | undefined;
+        }): {
+            title?: string;
+            description?: c4.MarkdownOrString;
+            technology?: string;
+        };
     };
 } & TBase;

package/dist/model/parser/FqnRefParser.js

@@ -1,10 +1,10 @@
 import { invariant, nonexhaustive, nonNullable } from "@likec4/core";
 import { isBoolean, isDefined, isNonNullish, isTruthy } from "remeda";
-import { ast, parseAstOpacityProperty, parseAstSizeValue, toColor } from "../../ast.js";
+import { ast, parseAstOpacityProperty, parseAstSizeValue, parseMarkdownAsString, toColor } from "../../ast.js";
 import { logWarnError } from "../../logger.js";
 import { projectIdFrom } from "../../utils/index.js";
 import { importsRef, instanceRef } from "../../utils/fqnRef.js";
-import { parseWhereClause } from "../model-parser-where.js";
+import { createBinaryOperator, parseWhereClause } from "../model-parser-where.js";
 import { removeIndent } from "./Base.js";
 export function ExpressionV2Parser(B) {
   return class ExpressionV2Parser extends B {
@@ -88,7 +88,7 @@ export function ExpressionV2Parser(B) {
           }
           if (ast.isElementStringProperty(prop)) {
             if (isDefined(prop.value)) {
-              acc.custom[prop.key] = removeIndent(prop.value) || "";
+              acc.custom[prop.key] = removeIndent(parseMarkdownAsString(prop.value)) || "";
             }
             return acc;
           }
@@ -125,8 +125,9 @@ export function ExpressionV2Parser(B) {
             return acc;
           }
           if (ast.isNotationProperty(prop)) {
-            if (isTruthy(prop.value)) {
-              acc.custom[prop.key] = removeIndent(prop.value);
+            const value = isTruthy(prop.value) ? removeIndent(parseMarkdownAsString(prop.value)) : void 0;
+            if (value) {
+              acc.custom[prop.key] = value;
             }
             return acc;
           }
@@ -261,8 +262,9 @@ export function ExpressionV2Parser(B) {
       return props.reduce(
         (acc, prop) => {
           if (ast.isRelationStringProperty(prop) || ast.isNotationProperty(prop) || ast.isNotesProperty(prop)) {
-            if (isDefined(prop.value)) {
-              acc.customRelation[prop.key] = removeIndent(prop.value) ?? "";
+            const value = isTruthy(prop.value) ? removeIndent(parseMarkdownAsString(prop.value)) : void 0;
+            if (value) {
+              acc.customRelation[prop.key] = value;
             }
             return acc;
           }
@@ -315,31 +317,44 @@ export function ExpressionV2Parser(B) {
         !ast.isRelationExprWhere(astNode.subject),
         "RelationExprWhere is not allowed as subject of RelationExprWhere"
       );
+      const relationOrWhereExpr = this.parseRelationExpr(astNode.subject);
+      const expr = relationOrWhereExpr.where?.expr ?? relationOrWhereExpr;
+      const kindCondition = relationOrWhereExpr.where?.condition;
+      const whereCondition = astNode.where ? parseWhereClause(astNode.where) : null;
+      let condition;
+      if (whereCondition && kindCondition) {
+        condition = createBinaryOperator(
+          "and",
+          kindCondition,
+          whereCondition
+        );
+      } else {
+        condition = whereCondition ?? kindCondition ?? { kind: { neq: "--always-true--" } };
+      }
       return {
         where: {
-          expr: this.parseRelationExpr(astNode.subject),
-          condition: astNode.where ? parseWhereClause(astNode.where) : {
-            kind: { neq: "--always-true--" }
-          }
+          expr,
+          condition
         }
       };
     }
     parseRelationExpr(astNode) {
       switch (astNode.$type) {
         case "DirectedRelationExpr":
-          return {
+          return this.wrapInWhere({
             source: this.parseFqnExpr(astNode.source.from),
             target: this.parseFqnExpr(astNode.target),
             isBidirectional: astNode.source.isBidirectional
-          };
+          }, this.parseInlineKindCondition(astNode.source));
         case "InOutRelationExpr":
           return {
             inout: this.parseFqnExpr(astNode.inout.to)
           };
         case "OutgoingRelationExpr":
-          return {
-            outgoing: this.parseFqnExpr(astNode.from)
-          };
+          return this.wrapInWhere(
+            { outgoing: this.parseFqnExpr(astNode.from) },
+            this.parseInlineKindCondition(astNode)
+          );
         case "IncomingRelationExpr":
           return {
             incoming: this.parseFqnExpr(astNode.to)
@@ -348,5 +363,16 @@ export function ExpressionV2Parser(B) {
           nonexhaustive(astNode);
       }
     }
+    parseInlineKindCondition(astNode) {
+      const kind = astNode.kind ?? astNode.dotKind?.kind;
+      if (kind) {
+        invariant(kind.ref, "Kind is not resolved: " + astNode.$cstNode?.text);
+        return { kind: { eq: kind.ref?.name } };
+      }
+      return null;
+    }
+    wrapInWhere(expr, condition) {
+      return condition ? { where: { expr, condition } } : expr;
+    }
   };
 }

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

@@ -46,7 +46,9 @@ export declare function GlobalsParser<TBase extends WithViewsParser>(B: TBase):
         parseRelationExprWith(astNode: ast.RelationExprWith): c4.RelationExpr.Custom;
         parseRelationExprOrWhere(astNode: ast.RelationExprOrWhere): c4.RelationExpr.OrWhere;
         parseRelationExprWhere(astNode: ast.RelationExprWhere): c4.RelationExpr.Where;
-        parseRelationExpr(astNode: ast.RelationExpr): c4.RelationExpr;
+        parseRelationExpr(astNode: ast.RelationExpr): c4.RelationExpr.OrWhere;
+        parseInlineKindCondition(astNode: ast.OutgoingRelationExpr): c4.WhereOperator | null;
+        wrapInWhere(expr: c4.RelationExpr, condition: c4.WhereOperator | null): c4.RelationExpr.OrWhere;
         isValid: import("../../validation").IsValidFn;
         readonly services: import("../..").LikeC4Services;
         readonly doc: import("../../ast").ParsedLikeC4LangiumDocument;
@@ -60,6 +62,7 @@ export declare function GlobalsParser<TBase extends WithViewsParser>(B: TBase):
         getMetadata(metadataAstNode: ast.MetadataProperty | undefined): {
             [key: string]: string;
         } | undefined;
+        parseMarkdownOrString(markdownOrString: ast.MarkdownOrString | undefined): c4.MarkdownOrString | undefined;
         convertTags<E extends {
             tags?: ast.Tags;
         }>(withTags?: E | undefined): any;
@@ -72,6 +75,19 @@ export declare function GlobalsParser<TBase extends WithViewsParser>(B: TBase):
         parseColorLiteral(astNode: ast.ColorLiteral): c4.ColorLiteral | undefined;
         parseElementStyle(elementProps: Array<ast.ElementProperty> | ast.ElementStyleProperty | undefined): import("../../ast").ParsedElementStyle;
         parseStyleProps(styleProps: Array<ast.StyleProperty> | undefined): import("../../ast").ParsedElementStyle;
+        parseTitleDescriptionTechnology(inlineProps: {
+            title?: string | undefined;
+            description?: string | undefined;
+            technology?: string | undefined;
+        }, bodyProps: {
+            title?: ast.MarkdownOrString | undefined;
+            description?: ast.MarkdownOrString | undefined;
+            technology?: ast.MarkdownOrString | undefined;
+        }): {
+            title?: string;
+            description?: c4.MarkdownOrString;
+            technology?: string;
+        };
         parseDeploymentView(astNode: ast.DeploymentView): import("../../ast").ParsedAstDeploymentView;
         parseDeploymentViewRule(astRule: ast.DeploymentViewRule): c4.DeploymentViewRule;
         parseDeploymentViewRulePredicate(astRule: ast.DeploymentViewRulePredicate): c4.DeploymentViewPredicate;

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

@@ -17,6 +17,7 @@ export declare function ImportsParser<TBase extends Base>(B: TBase): {
         getMetadata(metadataAstNode: ast.MetadataProperty | undefined): {
             [key: string]: string;
         } | undefined;
+        parseMarkdownOrString(markdownOrString: ast.MarkdownOrString | undefined): ProjectId | undefined;
         convertTags<E extends {
             tags?: ast.Tags;
         }>(withTags?: E | undefined): any;
@@ -29,5 +30,18 @@ export declare function ImportsParser<TBase extends Base>(B: TBase): {
         parseColorLiteral(astNode: ast.ColorLiteral): ProjectId | undefined;
         parseElementStyle(elementProps: Array<ast.ElementProperty> | ast.ElementStyleProperty | undefined): import("../../ast").ParsedElementStyle;
         parseStyleProps(styleProps: Array<ast.StyleProperty> | undefined): import("../../ast").ParsedElementStyle;
+        parseTitleDescriptionTechnology(inlineProps: {
+            title?: string | undefined;
+            description?: string | undefined;
+            technology?: string | undefined;
+        }, bodyProps: {
+            title?: ast.MarkdownOrString | undefined;
+            description?: ast.MarkdownOrString | undefined;
+            technology?: ast.MarkdownOrString | undefined;
+        }): {
+            title?: string;
+            description?: ProjectId;
+            technology?: string;
+        };
     };
 } & TBase;

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

@@ -23,7 +23,9 @@ export declare function ModelParser<TBase extends WithExpressionV2>(B: TBase): {
         parseRelationExprWith(astNode: ast.RelationExprWith): c4.RelationExpr.Custom;
         parseRelationExprOrWhere(astNode: ast.RelationExprOrWhere): c4.RelationExpr.OrWhere;
         parseRelationExprWhere(astNode: ast.RelationExprWhere): c4.RelationExpr.Where;
-        parseRelationExpr(astNode: ast.RelationExpr): c4.RelationExpr;
+        parseRelationExpr(astNode: ast.RelationExpr): c4.RelationExpr.OrWhere;
+        parseInlineKindCondition(astNode: ast.OutgoingRelationExpr): c4.WhereOperator | null;
+        wrapInWhere(expr: c4.RelationExpr, condition: c4.WhereOperator | null): c4.RelationExpr.OrWhere;
         isValid: import("../../validation").IsValidFn;
         readonly services: import("../..").LikeC4Services;
         readonly doc: import("../../ast").ParsedLikeC4LangiumDocument;
@@ -37,6 +39,7 @@ export declare function ModelParser<TBase extends WithExpressionV2>(B: TBase): {
         getMetadata(metadataAstNode: ast.MetadataProperty | undefined): {
             [key: string]: string;
         } | undefined;
+        parseMarkdownOrString(markdownOrString: ast.MarkdownOrString | undefined): c4.MarkdownOrString | undefined;
         convertTags<E extends {
             tags?: ast.Tags;
         }>(withTags?: E | undefined): any;
@@ -49,5 +52,18 @@ export declare function ModelParser<TBase extends WithExpressionV2>(B: TBase): {
         parseColorLiteral(astNode: ast.ColorLiteral): c4.ColorLiteral | undefined;
         parseElementStyle(elementProps: Array<ast.ElementProperty> | ast.ElementStyleProperty | undefined): import("../../ast").ParsedElementStyle;
         parseStyleProps(styleProps: Array<ast.StyleProperty> | undefined): import("../../ast").ParsedElementStyle;
+        parseTitleDescriptionTechnology(inlineProps: {
+            title?: string | undefined;
+            description?: string | undefined;
+            technology?: string | undefined;
+        }, bodyProps: {
+            title?: ast.MarkdownOrString | undefined;
+            description?: ast.MarkdownOrString | undefined;
+            technology?: ast.MarkdownOrString | undefined;
+        }): {
+            title?: string;
+            description?: c4.MarkdownOrString;
+            technology?: string;
+        };
     };
 } & TBase;

package/dist/model/parser/ModelParser.js

@@ -8,7 +8,6 @@ import {
 } from "../../ast.js";
 import { logger as mainLogger } from "../../logger.js";
 import { stringHash } from "../../utils/stringHash.js";
-import { removeIndent, toSingleLine } from "./Base.js";
 const logger = mainLogger.getChild("ModelParser");
 function* streamModel(doc) {
   const traverseStack = LinkedList.from(doc.parseResult.value.models.flatMap((m) => m.elements));
@@ -76,16 +75,21 @@ ${error}`, {
       const style = this.parseElementStyle(astNode.body?.props);
       const metadata = this.getMetadata(astNode.body?.props.find(ast.isMetadataProperty));
       const astPath = this.getAstNodePath(astNode);
-      let [title, description, technology] = astNode.props ?? [];
+      let [_title, _description, _technology] = astNode.props ?? [];
       const bodyProps = pipe(
         astNode.body?.props ?? [],
         filter(isValid),
         filter(ast.isElementStringProperty),
-        mapToObj((p) => [p.key, p.value || void 0])
+        mapToObj((p) => [p.key, p.value])
+      );
+      const { title, ...descAndTech } = this.parseTitleDescriptionTechnology(
+        {
+          title: _title,
+          description: _description,
+          technology: _technology
+        },
+        bodyProps
       );
-      title = removeIndent(title ?? bodyProps.title);
-      description = removeIndent(bodyProps.description ?? description);
-      technology = toSingleLine(bodyProps.technology ?? technology);
       const links = this.parseLinks(astNode.body);
       return {
         id,
@@ -95,8 +99,7 @@ ${error}`, {
         ...metadata && { metadata },
         ...tags && { tags },
         ...links && isNonEmptyArray(links) && { links },
-        ...isTruthy(technology) && { technology },
-        ...isTruthy(description) && { description },
+        ...descAndTech,
         style
       };
     }
@@ -144,7 +147,7 @@ ${error}`, {
         astNode.body?.props ?? [],
         filter(ast.isRelationStringProperty),
         filter((p) => isTruthy(p.value)),
-        mapToObj((p) => [p.key, p.value || void 0])
+        mapToObj((p) => [p.key, p.value])
       );
       const navigateTo = pipe(
         astNode.body?.props ?? [],
@@ -153,9 +156,15 @@ ${error}`, {
         filter(isTruthy),
         first()
       );
-      const title = removeIndent(astNode.title ?? bodyProps.title) ?? "";
-      const description = removeIndent(astNode.description ?? bodyProps.description);
-      const technology = toSingleLine(astNode.technology) ?? removeIndent(bodyProps.technology);
+      const { title = "", ...descAndTech } = this.parseTitleDescriptionTechnology(
+        // inline props
+        {
+          title: astNode.title,
+          description: astNode.description,
+          technology: astNode.technology
+        },
+        bodyProps
+      );
       const styleProp = astNode.body?.props.find(ast.isRelationStyleProperty);
       const id = stringHash(
         astPath,
@@ -169,8 +178,7 @@ ${error}`, {
         target,
         title,
         ...metadata && { metadata },
-        ...isTruthy(technology) && { technology },
-        ...isTruthy(description) && { description },
+        ...descAndTech,
         ...kind && { kind },
         ...tags && { tags },
         ...isNonEmptyArray(links) && { links },

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

@@ -28,7 +28,9 @@ export declare function PredicatesParser<TBase extends WithExpressionV2>(B: TBas
         parseRelationExprWith(astNode: ast.RelationExprWith): c4.RelationExpr.Custom;
         parseRelationExprOrWhere(astNode: ast.RelationExprOrWhere): c4.RelationExpr.OrWhere;
         parseRelationExprWhere(astNode: ast.RelationExprWhere): c4.RelationExpr.Where;
-        parseRelationExpr(astNode: ast.RelationExpr): c4.RelationExpr;
+        parseRelationExpr(astNode: ast.RelationExpr): c4.RelationExpr.OrWhere;
+        parseInlineKindCondition(astNode: ast.OutgoingRelationExpr): c4.WhereOperator | null;
+        wrapInWhere(expr: c4.RelationExpr, condition: c4.WhereOperator | null): c4.RelationExpr.OrWhere;
         isValid: import("../../validation").IsValidFn;
         readonly services: import("../..").LikeC4Services;
         readonly doc: import("../../ast").ParsedLikeC4LangiumDocument;
@@ -42,6 +44,7 @@ export declare function PredicatesParser<TBase extends WithExpressionV2>(B: TBas
         getMetadata(metadataAstNode: ast.MetadataProperty | undefined): {
             [key: string]: string;
         } | undefined;
+        parseMarkdownOrString(markdownOrString: ast.MarkdownOrString | undefined): c4.MarkdownOrString | undefined;
         convertTags<E extends {
             tags?: ast.Tags;
         }>(withTags?: E | undefined): any;
@@ -54,5 +57,18 @@ export declare function PredicatesParser<TBase extends WithExpressionV2>(B: TBas
         parseColorLiteral(astNode: ast.ColorLiteral): c4.ColorLiteral | undefined;
         parseElementStyle(elementProps: Array<ast.ElementProperty> | ast.ElementStyleProperty | undefined): import("../../ast").ParsedElementStyle;
         parseStyleProps(styleProps: Array<ast.StyleProperty> | undefined): import("../../ast").ParsedElementStyle;
+        parseTitleDescriptionTechnology(inlineProps: {
+            title?: string | undefined;
+            description?: string | undefined;
+            technology?: string | undefined;
+        }, bodyProps: {
+            title?: ast.MarkdownOrString | undefined;
+            description?: ast.MarkdownOrString | undefined;
+            technology?: ast.MarkdownOrString | undefined;
+        }): {
+            title?: string;
+            description?: c4.MarkdownOrString;
+            technology?: string;
+        };
     };
 } & TBase;

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

@@ -23,6 +23,7 @@ export declare function SpecificationParser<TBase extends Base>(B: TBase): {
         getMetadata(metadataAstNode: ast.MetadataProperty | undefined): {
             [key: string]: string;
         } | undefined;
+        parseMarkdownOrString(markdownOrString: ast.MarkdownOrString | undefined): c4.MarkdownOrString | undefined;
         convertTags<E extends {
             tags?: ast.Tags;
         }>(withTags?: E | undefined): any;
@@ -35,5 +36,18 @@ export declare function SpecificationParser<TBase extends Base>(B: TBase): {
         parseColorLiteral(astNode: ast.ColorLiteral): c4.ColorLiteral | undefined;
         parseElementStyle(elementProps: Array<ast.ElementProperty> | ast.ElementStyleProperty | undefined): import("../../ast").ParsedElementStyle;
         parseStyleProps(styleProps: Array<ast.StyleProperty> | undefined): import("../../ast").ParsedElementStyle;
+        parseTitleDescriptionTechnology(inlineProps: {
+            title?: string | undefined;
+            description?: string | undefined;
+            technology?: string | undefined;
+        }, bodyProps: {
+            title?: ast.MarkdownOrString | undefined;
+            description?: ast.MarkdownOrString | undefined;
+            technology?: ast.MarkdownOrString | undefined;
+        }): {
+            title?: string;
+            description?: c4.MarkdownOrString;
+            technology?: string;
+        };
     };
 } & TBase;

package/dist/model/parser/SpecificationParser.js

@@ -1,6 +1,6 @@
 import { nonNullable } from "@likec4/core/utils";
-import { filter, isNonNullish, isTruthy, mapToObj, pipe } from "remeda";
-import { ast, toRelationshipStyleExcludeDefaults } from "../../ast.js";
+import { filter, isNonNullish, isNullish, isTruthy, mapToObj, omitBy, pipe } from "remeda";
+import { ast, parseMarkdownAsString, toRelationshipStyleExcludeDefaults } from "../../ast.js";
 import { logger, logWarnError } from "../../logger.js";
 import { removeIndent } from "./Base.js";
 export function SpecificationParser(B) {
@@ -43,7 +43,8 @@ export function SpecificationParser(B) {
           const bodyProps = pipe(
             props.filter(ast.isSpecificationRelationshipStringProperty) ?? [],
             filter((p) => this.isValid(p) && isNonNullish(p.value)),
-            mapToObj((p) => [p.key, removeIndent(p.value)])
+            mapToObj((p) => [p.key, removeIndent(parseMarkdownAsString(p.value))]),
+            omitBy(isNullish)
           );
           c4Specification.relationships[kindName] = {
             ...bodyProps,
@@ -55,14 +56,18 @@ export function SpecificationParser(B) {
       }
       const tags_specs = specifications.flatMap((s) => s.tags.filter(this.isValid));
       for (const tagSpec of tags_specs) {
-        const tag = tagSpec.tag.name;
-        const astPath = this.getAstNodePath(tagSpec.tag);
-        const color = tagSpec.color && this.parseColorLiteral(tagSpec.color);
-        if (isTruthy(tag)) {
-          c4Specification.tags[tag] = {
-            astPath,
-            ...color ? { color } : {}
-          };
+        try {
+          const tag = tagSpec.tag.name;
+          const astPath = this.getAstNodePath(tagSpec.tag);
+          const color = tagSpec.color && this.parseColorLiteral(tagSpec.color);
+          if (isTruthy(tag)) {
+            c4Specification.tags[tag] = {
+              astPath,
+              ...color ? { color } : {}
+            };
+          }
+        } catch (e) {
+          logWarnError(e);
         }
       }
       const colors_specs = specifications.flatMap((s) => s.colors.filter(isValid));

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

@@ -0,0 +1,4 @@
+import { type CstNode, type ValueType, DefaultValueConverter } from 'langium';
+export declare class LikeC4ValueConverter extends DefaultValueConverter {
+    protected runConverter(rule: any, input: string, cstNode: CstNode): ValueType;
+}

package/dist/model/parser/ValueConverter.js

@@ -0,0 +1,12 @@
+import { DefaultValueConverter, ValueConverter } from "langium";
+export class LikeC4ValueConverter extends DefaultValueConverter {
+  runConverter(rule, input, cstNode) {
+    if (rule.name === "MarkdownString") {
+      if (input.startsWith('"""') && input.endsWith('"""') || input.startsWith(`'''`) && input.endsWith(`'''`)) {
+        input = input.slice(3, -3);
+      }
+      return ValueConverter.convertString(input);
+    }
+    return super.runConverter(rule, input, cstNode);
+  }
+}

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

@@ -44,7 +44,9 @@ export declare function ViewsParser<TBase extends WithPredicates & WithDeploymen
         parseRelationExprWith(astNode: ast.RelationExprWith): c4.RelationExpr.Custom;
         parseRelationExprOrWhere(astNode: ast.RelationExprOrWhere): c4.RelationExpr.OrWhere;
         parseRelationExprWhere(astNode: ast.RelationExprWhere): c4.RelationExpr.Where;
-        parseRelationExpr(astNode: ast.RelationExpr): c4.RelationExpr;
+        parseRelationExpr(astNode: ast.RelationExpr): c4.RelationExpr.OrWhere;
+        parseInlineKindCondition(astNode: ast.OutgoingRelationExpr): c4.WhereOperator | null;
+        wrapInWhere(expr: c4.RelationExpr, condition: c4.WhereOperator | null): c4.RelationExpr.OrWhere;
         isValid: import("../../validation").IsValidFn;
         readonly services: import("../..").LikeC4Services;
         readonly doc: import("../../ast").ParsedLikeC4LangiumDocument;
@@ -58,6 +60,7 @@ export declare function ViewsParser<TBase extends WithPredicates & WithDeploymen
         getMetadata(metadataAstNode: ast.MetadataProperty | undefined): {
             [key: string]: string;
         } | undefined;
+        parseMarkdownOrString(markdownOrString: ast.MarkdownOrString | undefined): c4.MarkdownOrString | undefined;
         convertTags<E extends {
             tags?: ast.Tags;
         }>(withTags?: E | undefined): any;
@@ -70,6 +73,19 @@ export declare function ViewsParser<TBase extends WithPredicates & WithDeploymen
         parseColorLiteral(astNode: ast.ColorLiteral): c4.ColorLiteral | undefined;
         parseElementStyle(elementProps: Array<ast.ElementProperty> | ast.ElementStyleProperty | undefined): import("../../ast").ParsedElementStyle;
         parseStyleProps(styleProps: Array<ast.StyleProperty> | undefined): import("../../ast").ParsedElementStyle;
+        parseTitleDescriptionTechnology(inlineProps: {
+            title?: string | undefined;
+            description?: string | undefined;
+            technology?: string | undefined;
+        }, bodyProps: {
+            title?: ast.MarkdownOrString | undefined;
+            description?: ast.MarkdownOrString | undefined;
+            technology?: ast.MarkdownOrString | undefined;
+        }): {
+            title?: string;
+            description?: c4.MarkdownOrString;
+            technology?: string;
+        };
         parseDeploymentView(astNode: ast.DeploymentView): import("../../ast").ParsedAstDeploymentView;
         parseDeploymentViewRule(astRule: ast.DeploymentViewRule): c4.DeploymentViewRule;
         parseDeploymentViewRulePredicate(astRule: ast.DeploymentViewRulePredicate): c4.DeploymentViewPredicate;

package/dist/model/parser/ViewsParser.js

@@ -1,8 +1,9 @@
 import * as c4 from "@likec4/core";
 import { invariant, isNonEmptyArray, nonexhaustive } from "@likec4/core";
-import { isArray, isDefined, isNonNullish, isTruthy } from "remeda";
+import { filter, isArray, isDefined, isNonNullish, isTruthy, mapToObj, pipe } from "remeda";
 import {
   ast,
+  parseMarkdownAsString,
   toAutoLayout,
   toColor,
   ViewOps
@@ -71,8 +72,15 @@ export function ViewsParser(B) {
           viewOf ?? ""
         );
       }
-      const title = toSingleLine(body.props.find((p) => p.key === "title")?.value) ?? null;
-      const description = removeIndent(body.props.find((p) => p.key === "description")?.value) ?? null;
+      const { title = null, description = null } = this.parseTitleDescriptionTechnology(
+        {},
+        pipe(
+          body.props,
+          filter((p) => this.isValid(p)),
+          filter(ast.isViewStringProperty),
+          mapToObj((p) => [p.key, p.value])
+        )
+      );
       const tags = this.convertTags(body);
       const links = this.convertLinks(body);
       const manualLayout = parseViewManualLayout(astNode);
@@ -191,7 +199,7 @@ export function ViewsParser(B) {
         (e) => c4.ModelExpression.isFqnExpr(e)
       );
       const style = this.parseStyleProps(astRule.props.filter(ast.isStyleProperty));
-      const notation = removeIndent(astRule.props.find(ast.isNotationProperty)?.value);
+      const notation = removeIndent(parseMarkdownAsString(astRule.props.find(ast.isNotationProperty)?.value));
       return {
         targets,
         style,
@@ -216,8 +224,14 @@ export function ViewsParser(B) {
           astPath
         );
       }
-      const title = toSingleLine(props.find((p) => p.key === "title")?.value) ?? null;
-      const description = removeIndent(props.find((p) => p.key === "description")?.value) ?? null;
+      const { title = null, description = null } = this.parseTitleDescriptionTechnology(
+        {},
+        pipe(
+          props,
+          filter(ast.isViewStringProperty),
+          mapToObj((p) => [p.key, p.value])
+        )
+      );
       const tags = this.convertTags(body);
       const links = this.convertLinks(body);
       ViewOps.writeId(astNode, id);
@@ -338,7 +352,7 @@ export function ViewsParser(B) {
             case ast.isNotationProperty(prop):
             case ast.isNotesProperty(prop): {
               if (isDefined(prop.value)) {
-                step[prop.key] = removeIndent(prop.value) ?? "";
+                step[prop.key] = removeIndent(parseMarkdownAsString(prop.value)) ?? "";
               }
               break;
             }

package/dist/module.d.ts

@@ -4,9 +4,8 @@ import { type DefaultSharedModuleContext, type LangiumServices, type LangiumShar
 import { LikeC4DocumentationProvider } from './documentation';
 import { type LikeC4LanguageServices } from './LikeC4LanguageServices';
 import { LikeC4CodeLensProvider, LikeC4CompletionProvider, LikeC4DocumentHighlightProvider, LikeC4DocumentLinkProvider, LikeC4DocumentSymbolProvider, LikeC4HoverProvider, LikeC4SemanticTokenProvider } from './lsp';
-import { type LikeC4MCPServer, type LikeC4MCPServerFactory } from './mcp/LikeC4MCPServerFactory';
-import { type LikeC4MCPTools } from './mcp/LikeC4MCPTools';
-import { type LikeC4ModelBuilder, DeploymentsIndex, FqnIndex, LikeC4ModelLocator, LikeC4ModelParser } from './model';
+import { type LikeC4MCPServer, type LikeC4MCPServerFactory } from './mcp/interfaces';
+import { type LikeC4ModelBuilder, DeploymentsIndex, FqnIndex, LikeC4ModelLocator, LikeC4ModelParser, LikeC4ValueConverter } from './model';
 import { LikeC4ModelChanges } from './model-change/ModelChanges';
 import { LikeC4NameProvider, LikeC4ScopeComputation, LikeC4ScopeProvider } from './references';
 import { Rpc } from './Rpc';
@@ -36,7 +35,6 @@ export interface LikeC4AddedServices {
     ValidatedWorkspaceCache: WorkspaceCache<string, any>;
     Rpc: Rpc;
     mcp: {
-        Tools: LikeC4MCPTools;
         Server: LikeC4MCPServer;
         ServerFactory: LikeC4MCPServerFactory;
     };
@@ -66,6 +64,9 @@ export interface LikeC4AddedServices {
         ScopeProvider: LikeC4ScopeProvider;
     };
     shared?: LikeC4SharedServices;
+    parser: {
+        ValueConverter: LikeC4ValueConverter;
+    };
 }
 export type LikeC4Services = LangiumServices & LikeC4AddedServices;
 export declare const LikeC4Module: Module<LikeC4Services, PartialLangiumServices & LikeC4AddedServices>;