@likec4/core 1.26.1 → 1.26.2

package/dist/builder/index.mjs

@@ -1,5 +1,5 @@
-import { i, l, d, L as LikeC4Model } from '../shared/core.CcjDE4j7.mjs';
-import { b as t, m, n as nameFromFqn, l as l$1, c as isSameHierarchy, p as parentFqn, a as i$1, d as t$1 } from '../shared/core.BqezHsjR.mjs';
+import { a as i, l, d, L as LikeC4Model } from '../shared/core.NNojPYtn.mjs';
+import { c as t, m, n as nameFromFqn, l as l$1, d as isSameHierarchy, p as parentFqn, a as i$1, e as t$1 } from '../shared/core.DvRnF4Sc.mjs';
 import { o, b as isElementPredicateExpr, D as DefaultElementShape, c as DefaultThemeColor, n as n$1, d as DeploymentElement, e as isScopedElementView } from '../shared/core.yND74qFI.mjs';
 import { u, i as invariant } from '../shared/core.DRxv3HIl.mjs';
 

package/dist/compute-view/index.mjs

@@ -1,8 +1,8 @@
-import { G as Graph, r, w as willCreateCycle, t as topologicalSortExports, i as i$1, l } from '../shared/core.CcjDE4j7.mjs';
-export { c as computeView, a as computeViews, u as unsafeComputeView } from '../shared/core.CcjDE4j7.mjs';
-export { c as computeRelationshipsView } from '../shared/core.BBJd-FqJ.mjs';
+import { G as Graph, r, w as willCreateCycle, t as topologicalSortExports, i as i$1, a as i$2, l } from '../shared/core.NNojPYtn.mjs';
+export { c as computeView, b as computeViews, u as unsafeComputeView } from '../shared/core.NNojPYtn.mjs';
+export { c as computeRelationshipsView } from '../shared/core.C8xqv5sq.mjs';
 import { i as isExtendsElementView, a as isElementView } from '../shared/core.yND74qFI.mjs';
-import { a as i, m } from '../shared/core.BqezHsjR.mjs';
+import { a as i, b as isNonEmptyArray, m } from '../shared/core.DvRnF4Sc.mjs';
 import { u } from '../shared/core.DRxv3HIl.mjs';
 
 function y(...t){return u(f,t)}function f(t,e){if(!i(e,1))return {...t};if(!i(e,2)){let{[e[0]]:r,...m}=t;return m}let o={...t};for(let r of e)delete o[r];return o}
@@ -43,9 +43,21 @@ function resolveRulesExtendedViews(unresolvedViews) {
     if (!extendsFrom || !isElementView(extendsFrom)) {
       return acc;
     }
+    const tags = i$1([
+      ...extendsFrom.tags ?? [],
+      ...view.tags ?? []
+    ]);
+    const links = [
+      ...extendsFrom.links ?? [],
+      ...view.links ?? []
+    ];
     acc[view.id] = {
       ...extendsFrom,
       ...view,
+      title: view.title ?? extendsFrom.title ?? null,
+      description: view.description ?? extendsFrom.description ?? null,
+      tags: isNonEmptyArray(tags) ? tags : null,
+      links: isNonEmptyArray(links) ? links : null,
       rules: [...extendsFrom.rules, ...view.rules]
     };
     return acc;
@@ -72,7 +84,7 @@ function withReadableEdges({ edges, nodes, ...view }, separator = ":") {
 function viewsWithReadableEdges({ views, ...model }) {
   return {
     ...model,
-    views: i$1(views, (v) => y(withReadableEdges(v), ["nodeIds", "edgeIds"]))
+    views: i$2(views, (v) => y(withReadableEdges(v), ["nodeIds", "edgeIds"]))
   };
 }
 

package/dist/index.mjs

@@ -1,10 +1,10 @@
 export { i as invariant, a as nonNullable, n as nonexhaustive } from './shared/core.DRxv3HIl.mjs';
 export { A as AsFqn, B as BorderStyles, V as ComputedNode, W as ComputedView, S as DefaultArrowType, D as DefaultElementShape, T as DefaultLineStyle, g as DefaultPaddingSize, U as DefaultRelationshipColor, h as DefaultShapeSize, j as DefaultTextSize, c as DefaultThemeColor, d as DeploymentElement, X as DiagramNode, E as ElementKind, k as ElementShapes, f as Expr, H as ExpressionV2, I as FqnExpr, J as FqnRef, R as RelationExpr, Y as extractStep, Z as getBBoxCenter, _ as getParallelStepsPrefix, K as isAndOperator, $ as isAutoLayoutDirection, l as isCustomElement, m as isCustomRelationExpr, a0 as isDeploymentView, a1 as isDynamicView, a2 as isDynamicViewParallelSteps, p as isElement, q as isElementKindExpr, b as isElementPredicateExpr, r as isElementRef, s as isElementTagExpr, a as isElementView, t as isElementWhere, u as isExpandedElementExpr, i as isExtendsElementView, w as isInOut, v as isIncoming, L as isKindEqual, M as isNotOperator, N as isOrOperator, x as isOutgoing, O as isParticipantOperator, y as isRelation, z as isRelationExpression, C as isRelationPredicateExpr, F as isRelationWhere, e as isScopedElementView, a3 as isStepEdgeId, P as isTagEqual, a4 as isViewRuleAutoLayout, a5 as isViewRuleGlobalPredicateRef, a6 as isViewRuleGlobalStyle, a7 as isViewRuleGroup, a8 as isViewRulePredicate, a9 as isViewRuleStyle, G as isWildcard, aa as stepEdgeId, Q as whereOperatorAsPredicate } from './shared/core.yND74qFI.mjs';
-export { C as Connection, b as ConnectionModel, D as DeployedInstanceModel, e as DeploymentConnectionModel, f as DeploymentNodeModel, g as DeploymentRelationModel, E as EdgeModel, h as ElementModel, j as LikeC4DeploymentModel, L as LikeC4Model, k as LikeC4ViewModel, N as NodeModel, R as RelationshipModel, c as computeView, a as computeViews, u as unsafeComputeView } from './shared/core.CcjDE4j7.mjs';
-export { c as computeRelationshipsView } from './shared/core.BBJd-FqJ.mjs';
+export { C as Connection, e as ConnectionModel, D as DeployedInstanceModel, f as DeploymentConnectionModel, g as DeploymentNodeModel, h as DeploymentRelationModel, E as EdgeModel, j as ElementModel, k as LikeC4DeploymentModel, L as LikeC4Model, m as LikeC4ViewModel, N as NodeModel, R as RelationshipModel, c as computeView, b as computeViews, u as unsafeComputeView } from './shared/core.NNojPYtn.mjs';
+export { c as computeRelationshipsView } from './shared/core.C8xqv5sq.mjs';
 export { ThemeColors, isThemeColor } from './types/index.mjs';
 export { BiMap, DefaultWeakMap, LinkedList, MultiMap, Queue, compareRelations, delay, ireduce } from './utils/index.mjs';
-export { D as DefaultMap, S as Stack, g as ancestorsFqn, h as commonAncestor, e as commonHead, j as compareByFqnHierarchically, k as compareFqnHierarchically, f as compareNatural, I as difference, J as equalsSet, x as getOrCreate, a as hasAtLeast, o as hierarchyDistance, q as hierarchyLevel, A as ifilter, i as ifind, B as iflat, C as imap, K as intersection, r as isAncestor, s as isDescendantOf, E as isIterable, y as isNonEmptyArray, c as isSameHierarchy, z as isString, F as isome, G as iunique, n as nameFromFqn, O as objectHash, p as parentFqn, u as sortByFqnHierarchically, v as sortNaturalByFqn, w as sortParentsFirst, N as stringHash, L as symmetricDifference, H as toArray, t as toSet, M as union } from './shared/core.BqezHsjR.mjs';
+export { D as DefaultMap, S as Stack, h as ancestorsFqn, j as commonAncestor, f as commonHead, k as compareByFqnHierarchically, o as compareFqnHierarchically, g as compareNatural, I as difference, J as equalsSet, y as getOrCreate, a as hasAtLeast, q as hierarchyDistance, r as hierarchyLevel, A as ifilter, i as ifind, B as iflat, C as imap, K as intersection, s as isAncestor, u as isDescendantOf, E as isIterable, b as isNonEmptyArray, d as isSameHierarchy, z as isString, F as isome, G as iunique, n as nameFromFqn, O as objectHash, p as parentFqn, v as sortByFqnHierarchically, w as sortNaturalByFqn, x as sortParentsFirst, N as stringHash, L as symmetricDifference, H as toArray, t as toSet, M as union } from './shared/core.DvRnF4Sc.mjs';
 
 const { min: min$4, max: max$4 } = Math;
 

package/dist/model/index.mjs

@@ -1 +1 @@
-export { C as Connection, b as ConnectionModel, D as DeployedInstanceModel, e as DeploymentConnectionModel, f as DeploymentNodeModel, g as DeploymentRelationModel, E as EdgeModel, h as ElementModel, j as LikeC4DeploymentModel, L as LikeC4Model, k as LikeC4ViewModel, N as NodeModel, R as RelationshipModel, m as deploymentConnection, n as differenceConnections, o as findAscendingConnections, p as findDeepestNestedConnection, q as findDescendantConnections, s as hasSameSource, v as hasSameSourceTarget, x as hasSameTarget, y as isAnyInOut, K as isDeployedInstance, M as isDeploymentNode, z as isIncoming, A as isNestedConnection, B as isOutgoing, F as mergeConnections, H as modelConnection, I as sortConnectionsByBoundaryHierarchy, J as sortDeepestFirst } from '../shared/core.CcjDE4j7.mjs';
+export { C as Connection, e as ConnectionModel, D as DeployedInstanceModel, f as DeploymentConnectionModel, g as DeploymentNodeModel, h as DeploymentRelationModel, E as EdgeModel, j as ElementModel, k as LikeC4DeploymentModel, L as LikeC4Model, m as LikeC4ViewModel, N as NodeModel, R as RelationshipModel, n as deploymentConnection, o as differenceConnections, p as findAscendingConnections, q as findDeepestNestedConnection, s as findDescendantConnections, v as hasSameSource, x as hasSameSourceTarget, y as hasSameTarget, z as isAnyInOut, M as isDeployedInstance, O as isDeploymentNode, A as isIncoming, B as isNestedConnection, F as isOutgoing, H as mergeConnections, I as modelConnection, J as sortConnectionsByBoundaryHierarchy, K as sortDeepestFirst } from '../shared/core.NNojPYtn.mjs';

package/dist/shared/{core.BBJd-FqJ.mjs → core.C8xqv5sq.mjs}

@@ -1,4 +1,4 @@
-import { t as toSet, i as ifind } from './core.BqezHsjR.mjs';
+import { t as toSet, i as ifind } from './core.DvRnF4Sc.mjs';
 
 function computeRelationshipsView(subjectId, likec4model) {
   const subject = likec4model.element(subjectId);

package/dist/shared/{core.BqezHsjR.mjs → core.DvRnF4Sc.mjs}

@@ -1453,4 +1453,4 @@ function requireObject_hash () {
 var object_hashExports = requireObject_hash();
 const objectHash = /*@__PURE__*/getDefaultExportFromCjs(object_hashExports);
 
-export { ifilter as A, iflat as B, imap as C, DefaultMap as D, isIterable as E, isome as F, iunique as G, toArray as H, difference as I, equals as J, intersection as K, symmetricDifference as L, union as M, stringHash as N, objectHash as O, C as P, s as Q, a as R, Stack as S, getDefaultExportFromCjs as T, requireForeach as U, requireIterator as V, u as W, d as X, n as Y, hasIntersection as Z, i$1 as a, t$1 as b, isSameHierarchy as c, t as d, commonHead as e, compareNatural as f, ancestorsFqn as g, commonAncestor as h, ifind as i, compareByFqnHierarchically as j, compareFqnHierarchically as k, l, m, nameFromFqn as n, hierarchyDistance as o, parentFqn as p, hierarchyLevel as q, isAncestor as r, isDescendantOf as s, toSet as t, sortByFqnHierarchically as u, sortNaturalByFqn as v, sortParentsFirst as w, getOrCreate as x, isNonEmptyArray as y, isString as z };
+export { ifilter as A, iflat as B, imap as C, DefaultMap as D, isIterable as E, isome as F, iunique as G, toArray as H, difference as I, equals as J, intersection as K, symmetricDifference as L, union as M, stringHash as N, objectHash as O, C as P, s as Q, a as R, Stack as S, getDefaultExportFromCjs as T, requireForeach as U, requireIterator as V, u as W, d as X, n as Y, hasIntersection as Z, i$1 as a, isNonEmptyArray as b, t$1 as c, isSameHierarchy as d, t as e, commonHead as f, compareNatural as g, ancestorsFqn as h, ifind as i, commonAncestor as j, compareByFqnHierarchically as k, l, m, nameFromFqn as n, compareFqnHierarchically as o, parentFqn as p, hierarchyDistance as q, hierarchyLevel as r, isAncestor as s, toSet as t, isDescendantOf as u, sortByFqnHierarchically as v, sortNaturalByFqn as w, sortParentsFirst as x, getOrCreate as y, isString as z };

package/dist/shared/{core.CcjDE4j7.mjs → core.NNojPYtn.mjs}

@@ -1,5 +1,5 @@
 import { D as DefaultElementShape, c as DefaultThemeColor, h as DefaultShapeSize, ab as o$8, t as isElementWhere, Q as whereOperatorAsPredicate, G as isWildcard, q as isElementKindExpr, s as isElementTagExpr, n as n$4, u as isExpandedElementExpr, r as isElementRef, l as isCustomElement, a9 as isViewRuleStyle, ac as y$2, V as ComputedNode, E as ElementKind, S as DefaultArrowType, I as FqnExpr, R as RelationExpr, o as o$9, a8 as isViewRulePredicate, a4 as isViewRuleAutoLayout, a7 as isViewRuleGroup, a5 as isViewRuleGlobalPredicateRef, a6 as isViewRuleGlobalStyle, aa as stepEdgeId, a2 as isDynamicViewParallelSteps, T as DefaultLineStyle, U as DefaultRelationshipColor, x as isOutgoing$1, v as isIncoming$1, w as isInOut, y as isRelation, F as isRelationWhere, m as isCustomRelationExpr, C as isRelationPredicateExpr, b as isElementPredicateExpr, a as isElementView, a1 as isDynamicView, a0 as isDeploymentView, d as DeploymentElement, Y as extractStep, a3 as isStepEdgeId, e as isScopedElementView } from './core.yND74qFI.mjs';
-import { P as C, Q as s$1, R as a$5, q as hierarchyLevel, r as isAncestor, h as commonAncestor, v as sortNaturalByFqn, m as m$3, e as commonHead, T as getDefaultExportFromCjs, U as requireForeach, V as requireIterator, W as u$7, O as objectHash, K as intersection, I as difference, M as union, N as stringHash, J as equals, s as isDescendantOf, z as isString, c as isSameHierarchy, F as isome, A as ifilter, E as isIterable, t as toSet, w as sortParentsFirst, H as toArray, D as DefaultMap, C as imap, a as i$9, X as d$6, p as parentFqn, Y as n$5, j as compareByFqnHierarchically, y as isNonEmptyArray, f as compareNatural, n as nameFromFqn, b as t$6, l as l$7, Z as hasIntersection, u as sortByFqnHierarchically, g as ancestorsFqn, S as Stack, G as iunique, B as iflat, x as getOrCreate, i as ifind } from './core.BqezHsjR.mjs';
+import { P as C, Q as s$1, R as a$5, r as hierarchyLevel, s as isAncestor, j as commonAncestor, w as sortNaturalByFqn, m as m$3, f as commonHead, T as getDefaultExportFromCjs, U as requireForeach, V as requireIterator, W as u$7, O as objectHash, K as intersection, I as difference, M as union, N as stringHash, J as equals, u as isDescendantOf, z as isString, d as isSameHierarchy, F as isome, A as ifilter, E as isIterable, t as toSet, x as sortParentsFirst, H as toArray, D as DefaultMap, C as imap, a as i$9, X as d$6, p as parentFqn, Y as n$5, k as compareByFqnHierarchically, b as isNonEmptyArray, g as compareNatural, n as nameFromFqn, c as t$6, l as l$7, Z as hasIntersection, v as sortByFqnHierarchically, h as ancestorsFqn, S as Stack, G as iunique, B as iflat, y as getOrCreate, i as ifind } from './core.DvRnF4Sc.mjs';
 import { u as u$6, a as nonNullable, i as invariant, n as nonexhaustive } from './core.DRxv3HIl.mjs';
 
 function y$1(t,i){let a=i.length-t.length;if(a===1){let[n,...r]=i;return C(n,{lazy:t,lazyArgs:r})}if(a===0){let n={lazy:t,lazyArgs:i};return Object.assign(e=>C(e,n),n)}throw new Error("Wrong number of arguments")}
@@ -4653,11 +4653,8 @@ class DynamicViewCompute {
       relations,
       tags,
       navigateTo: derivedNavigateTo,
-      head,
-      tail,
       color,
-      line,
-      notation
+      line
     } = this.findRelations(source, target);
     const navigateTo = n$2(stepNavigateTo) && stepNavigateTo !== this.view.id ? stepNavigateTo : derivedNavigateTo;
     this.steps.push({
@@ -4670,11 +4667,8 @@ class DynamicViewCompute {
       isBackward: isBackward ?? false,
       ...navigateTo ? { navigateTo } : {},
       ...tags ? { tags } : {},
-      ...head ? { head } : {},
-      ...tail ? { tail } : {},
       ...color ? { color } : {},
-      ...line ? { line } : {},
-      ...notation ? { notation } : {}
+      ...line ? { line } : {}
     });
   }
   compute() {
@@ -4793,11 +4787,8 @@ class DynamicViewCompute {
         tags: null,
         relations: null,
         navigateTo: null,
-        tail: null,
-        head: null,
         color: null,
-        line: null,
-        notation: null
+        line: null
       };
     }
     const alltags = C(
@@ -4822,17 +4813,12 @@ class DynamicViewCompute {
       relationships,
       l$5((acc, { title, $relationship: r }) => {
         n$2(title) && acc.title.add(title);
-        n$2(r.tail) && acc.tail.add(r.tail);
-        n$2(r.head) && acc.head.add(r.head);
         n$2(r.color) && acc.color.add(r.color);
         n$2(r.line) && acc.line.add(r.line);
         return acc;
       }, {
-        tail: /* @__PURE__ */ new Set(),
-        head: /* @__PURE__ */ new Set(),
         color: /* @__PURE__ */ new Set(),
         line: /* @__PURE__ */ new Set(),
-        notation: /* @__PURE__ */ new Set(),
         title: /* @__PURE__ */ new Set()
       })
     );
@@ -4841,11 +4827,8 @@ class DynamicViewCompute {
       relations,
       navigateTo: navigateTo ?? null,
       title: t$2([...commonProperties.title]) ?? null,
-      tail: t$2([...commonProperties.tail]) ?? null,
-      head: t$2([...commonProperties.head]) ?? null,
       color: t$2([...commonProperties.color]) ?? null,
-      line: t$2([...commonProperties.line]) ?? null,
-      notation: t$2([...commonProperties.notation]) ?? null
+      line: t$2([...commonProperties.line]) ?? null
     };
   }
 }
@@ -7476,4 +7459,4 @@ class LikeC4Model {
   });
 })(LikeC4Model || (LikeC4Model = {}));
 
-export { isNestedConnection as A, isOutgoing as B, Connection as C, DeployedInstanceModel as D, EdgeModel as E, mergeConnections as F, Graph as G, find$1 as H, sortConnectionsByBoundaryHierarchy as I, sortDeepestFirst as J, isDeployedInstance as K, LikeC4Model as L, isDeploymentNode as M, NodeModel as N, RelationshipModel as R, computeViews as a, ConnectionModel as b, computeView as c, d$2 as d, DeploymentConnectionModel as e, DeploymentNodeModel as f, DeploymentRelationModel as g, ElementModel as h, i$3 as i, LikeC4DeploymentModel as j, LikeC4ViewModel as k, l$3 as l, find as m, differenceConnections as n, findAscendingConnections as o, findDeepestNestedConnection as p, findDescendantConnections as q, r$3 as r, hasSameSource as s, topologicalSortExports as t, unsafeComputeView as u, hasSameSourceTarget as v, willCreateCycle as w, hasSameTarget as x, isAnyInOut as y, isIncoming as z };
+export { isIncoming as A, isNestedConnection as B, Connection as C, DeployedInstanceModel as D, EdgeModel as E, isOutgoing as F, Graph as G, mergeConnections as H, find$1 as I, sortConnectionsByBoundaryHierarchy as J, sortDeepestFirst as K, LikeC4Model as L, isDeployedInstance as M, NodeModel as N, isDeploymentNode as O, RelationshipModel as R, i$3 as a, computeViews as b, computeView as c, d$2 as d, ConnectionModel as e, DeploymentConnectionModel as f, DeploymentNodeModel as g, DeploymentRelationModel as h, i$8 as i, ElementModel as j, LikeC4DeploymentModel as k, l$3 as l, LikeC4ViewModel as m, find as n, differenceConnections as o, findAscendingConnections as p, findDeepestNestedConnection as q, r$3 as r, findDescendantConnections as s, topologicalSortExports as t, unsafeComputeView as u, hasSameSource as v, willCreateCycle as w, hasSameSourceTarget as x, hasSameTarget as y, isAnyInOut as z };

package/dist/utils/index.mjs

@@ -1,5 +1,5 @@
-import { U as requireForeach, T as getDefaultExportFromCjs, V as requireIterator, d as t, Y as n, h as commonAncestor, k as compareFqnHierarchically } from '../shared/core.BqezHsjR.mjs';
-export { D as DefaultMap, S as Stack, g as ancestorsFqn, e as commonHead, j as compareByFqnHierarchically, f as compareNatural, I as difference, J as equalsSet, x as getOrCreate, a as hasAtLeast, o as hierarchyDistance, q as hierarchyLevel, A as ifilter, i as ifind, B as iflat, C as imap, K as intersection, r as isAncestor, s as isDescendantOf, E as isIterable, y as isNonEmptyArray, c as isSameHierarchy, z as isString, F as isome, G as iunique, n as nameFromFqn, O as objectHash, p as parentFqn, u as sortByFqnHierarchically, v as sortNaturalByFqn, w as sortParentsFirst, N as stringHash, L as symmetricDifference, H as toArray, t as toSet, M as union } from '../shared/core.BqezHsjR.mjs';
+import { U as requireForeach, T as getDefaultExportFromCjs, V as requireIterator, e as t, Y as n, j as commonAncestor, o as compareFqnHierarchically } from '../shared/core.DvRnF4Sc.mjs';
+export { D as DefaultMap, S as Stack, h as ancestorsFqn, f as commonHead, k as compareByFqnHierarchically, g as compareNatural, I as difference, J as equalsSet, y as getOrCreate, a as hasAtLeast, q as hierarchyDistance, r as hierarchyLevel, A as ifilter, i as ifind, B as iflat, C as imap, K as intersection, s as isAncestor, u as isDescendantOf, E as isIterable, b as isNonEmptyArray, d as isSameHierarchy, z as isString, F as isome, G as iunique, n as nameFromFqn, O as objectHash, p as parentFqn, v as sortByFqnHierarchically, w as sortNaturalByFqn, x as sortParentsFirst, N as stringHash, L as symmetricDifference, H as toArray, t as toSet, M as union } from '../shared/core.DvRnF4Sc.mjs';
 import { i as invariant } from '../shared/core.DRxv3HIl.mjs';
 
 function o(r,n){let e=Math.ceil(r),t=Math.floor(n);if(t<e)throw new RangeError(`randomInteger: The range [${r.toString()},${n.toString()}] contains no integer`);return Math.floor(Math.random()*(t-e+1)+e)}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@likec4/core",
-  "version": "1.26.1",
+  "version": "1.26.2",
   "license": "MIT",
   "homepage": "https://likec4.dev",
   "author": "Denis Davydkov <denis@davydkov.com>",
@@ -96,7 +96,7 @@
     "typescript": "5.8.2",
     "unbuild": "^3.3.1",
     "vitest": "^3.0.8",
-    "@likec4/tsconfig": "1.26.1"
+    "@likec4/tsconfig": "1.26.2"
   },
   "scripts": {
     "typecheck": "tsc --noEmit",

package/src/builder/Builder.with.ts

@@ -5,39 +5,39 @@ export interface BuilderMethods<T extends AnyTypes> {
   with<A extends AnyTypes>(): Builder<A>
 
   with<
-    A extends AnyTypes
+    A extends AnyTypes,
   >(
-    op1: (input: Builder<T>) => Builder<A>
+    op1: (input: Builder<T>) => Builder<A>,
   ): Builder<A>
 
   with<
     A extends AnyTypes,
-    B extends AnyTypes
+    B extends AnyTypes,
   >(
     op1: (input: Builder<T>) => Builder<A>,
-    op2: (input: Builder<A>) => Builder<B>
+    op2: (input: Builder<A>) => Builder<B>,
   ): Builder<B>
 
   with<
     A extends AnyTypes,
     B extends AnyTypes,
-    C extends AnyTypes
+    C extends AnyTypes,
   >(
     op1: (input: Builder<T>) => Builder<A>,
     op2: (input: Builder<A>) => Builder<B>,
-    op3: (input: Builder<B>) => Builder<C>
+    op3: (input: Builder<B>) => Builder<C>,
   ): Builder<C>
 
   with<
     A extends AnyTypes,
     B extends AnyTypes,
     C extends AnyTypes,
-    D extends AnyTypes
+    D extends AnyTypes,
   >(
     op1: (input: Builder<T>) => Builder<A>,
     op2: (input: Builder<A>) => Builder<B>,
     op3: (input: Builder<B>) => Builder<C>,
-    op4: (input: Builder<C>) => Builder<D>
+    op4: (input: Builder<C>) => Builder<D>,
   ): Builder<D>
 
   with<
@@ -45,13 +45,13 @@ export interface BuilderMethods<T extends AnyTypes> {
     B extends AnyTypes,
     C extends AnyTypes,
     D extends AnyTypes,
-    E extends AnyTypes
+    E extends AnyTypes,
   >(
     op1: (input: Builder<T>) => Builder<A>,
     op2: (input: Builder<A>) => Builder<B>,
     op3: (input: Builder<B>) => Builder<C>,
     op4: (input: Builder<C>) => Builder<D>,
-    op5: (input: Builder<D>) => Builder<E>
+    op5: (input: Builder<D>) => Builder<E>,
   ): Builder<E>
 
   with<
@@ -60,14 +60,14 @@ export interface BuilderMethods<T extends AnyTypes> {
     C extends AnyTypes,
     D extends AnyTypes,
     E extends AnyTypes,
-    F extends AnyTypes
+    F extends AnyTypes,
   >(
     op1: (input: Builder<T>) => Builder<A>,
     op2: (input: Builder<A>) => Builder<B>,
     op3: (input: Builder<B>) => Builder<C>,
     op4: (input: Builder<C>) => Builder<D>,
     op5: (input: Builder<D>) => Builder<E>,
-    op6: (input: Builder<E>) => Builder<F>
+    op6: (input: Builder<E>) => Builder<F>,
   ): Builder<F>
 
   with<
@@ -77,7 +77,7 @@ export interface BuilderMethods<T extends AnyTypes> {
     D extends AnyTypes,
     E extends AnyTypes,
     F extends AnyTypes,
-    G extends AnyTypes
+    G extends AnyTypes,
   >(
     op1: (input: Builder<T>) => Builder<A>,
     op2: (input: Builder<A>) => Builder<B>,
@@ -85,7 +85,7 @@ export interface BuilderMethods<T extends AnyTypes> {
     op4: (input: Builder<C>) => Builder<D>,
     op5: (input: Builder<D>) => Builder<E>,
     op6: (input: Builder<E>) => Builder<F>,
-    op7: (input: Builder<F>) => Builder<G>
+    op7: (input: Builder<F>) => Builder<G>,
   ): Builder<G>
 
   with<
@@ -96,7 +96,7 @@ export interface BuilderMethods<T extends AnyTypes> {
     E extends AnyTypes,
     F extends AnyTypes,
     G extends AnyTypes,
-    H extends AnyTypes
+    H extends AnyTypes,
   >(
     op1: (input: Builder<T>) => Builder<A>,
     op2: (input: Builder<A>) => Builder<B>,
@@ -105,7 +105,7 @@ export interface BuilderMethods<T extends AnyTypes> {
     op5: (input: Builder<D>) => Builder<E>,
     op6: (input: Builder<E>) => Builder<F>,
     op7: (input: Builder<F>) => Builder<G>,
-    op8: (input: Builder<G>) => Builder<H>
+    op8: (input: Builder<G>) => Builder<H>,
   ): Builder<H>
 
   with<
@@ -117,7 +117,7 @@ export interface BuilderMethods<T extends AnyTypes> {
     F extends AnyTypes,
     G extends AnyTypes,
     H extends AnyTypes,
-    I extends AnyTypes
+    I extends AnyTypes,
   >(
     op1: (input: Builder<T>) => Builder<A>,
     op2: (input: Builder<A>) => Builder<B>,
@@ -127,7 +127,7 @@ export interface BuilderMethods<T extends AnyTypes> {
     op6: (input: Builder<E>) => Builder<F>,
     op7: (input: Builder<F>) => Builder<G>,
     op8: (input: Builder<G>) => Builder<H>,
-    op9: (input: Builder<H>) => Builder<I>
+    op9: (input: Builder<H>) => Builder<I>,
   ): Builder<I>
 
   with<
@@ -140,7 +140,7 @@ export interface BuilderMethods<T extends AnyTypes> {
     G extends AnyTypes,
     H extends AnyTypes,
     I extends AnyTypes,
-    J extends AnyTypes
+    J extends AnyTypes,
   >(
     op1: (input: Builder<T>) => Builder<A>,
     op2: (input: Builder<A>) => Builder<B>,
@@ -151,325 +151,6 @@ export interface BuilderMethods<T extends AnyTypes> {
     op7: (input: Builder<F>) => Builder<G>,
     op8: (input: Builder<G>) => Builder<H>,
     op9: (input: Builder<H>) => Builder<I>,
-    op10: (input: Builder<I>) => Builder<J>
+    op10: (input: Builder<I>) => Builder<J>,
   ): Builder<J>
-
-  // /**
-  //  * Add model to the builder
-  //  */
-  // model<
-  //   A extends AnyTypes
-  // >(
-  //   op1: (input: ModelBuilder<T>) => ModelBuilder<A>
-  // ): Builder<A>
-
-  // model<
-  //   A extends AnyTypes,
-  //   B extends AnyTypes
-  // >(
-  //   op1: (input: ModelBuilder<T>) => ModelBuilder<A>,
-  //   op2: (input: ModelBuilder<A>) => ModelBuilder<B>
-  // ): Builder<B>
-  // model<
-  //   A extends AnyTypes,
-  //   B extends AnyTypes,
-  //   C extends AnyTypes
-  // >(
-  //   op1: (input: ModelBuilder<T>) => ModelBuilder<A>,
-  //   op2: (input: ModelBuilder<A>) => ModelBuilder<B>,
-  //   op3: (input: ModelBuilder<B>) => ModelBuilder<C>
-  // ): Builder<C>
-
-  // model<
-  //   A extends AnyTypes,
-  //   B extends AnyTypes,
-  //   C extends AnyTypes,
-  //   D extends AnyTypes
-  // >(
-  //   op1: (input: ModelBuilder<T>) => ModelBuilder<A>,
-  //   op2: (input: ModelBuilder<A>) => ModelBuilder<B>,
-  //   op3: (input: ModelBuilder<B>) => ModelBuilder<C>,
-  //   op4: (input: ModelBuilder<C>) => ModelBuilder<D>
-  // ): Builder<D>
-
-  // model<
-  //   A extends AnyTypes,
-  //   B extends AnyTypes,
-  //   C extends AnyTypes,
-  //   D extends AnyTypes,
-  //   E extends AnyTypes
-  // >(
-  //   op1: (input: ModelBuilder<T>) => ModelBuilder<A>,
-  //   op2: (input: ModelBuilder<A>) => ModelBuilder<B>,
-  //   op3: (input: ModelBuilder<B>) => ModelBuilder<C>,
-  //   op4: (input: ModelBuilder<C>) => ModelBuilder<D>,
-  //   op5: (input: ModelBuilder<D>) => ModelBuilder<E>
-  // ): Builder<E>
-
-  // model<
-  //   A extends AnyTypes,
-  //   B extends AnyTypes,
-  //   C extends AnyTypes,
-  //   D extends AnyTypes,
-  //   E extends AnyTypes,
-  //   F extends AnyTypes
-  // >(
-  //   op1: (input: ModelBuilder<T>) => ModelBuilder<A>,
-  //   op2: (input: ModelBuilder<A>) => ModelBuilder<B>,
-  //   op3: (input: ModelBuilder<B>) => ModelBuilder<C>,
-  //   op4: (input: ModelBuilder<C>) => ModelBuilder<D>,
-  //   op5: (input: ModelBuilder<D>) => ModelBuilder<E>,
-  //   op6: (input: ModelBuilder<E>) => ModelBuilder<F>
-  // ): Builder<F>
-
-  // model<
-  //   A extends AnyTypes,
-  //   B extends AnyTypes,
-  //   C extends AnyTypes,
-  //   D extends AnyTypes,
-  //   E extends AnyTypes,
-  //   F extends AnyTypes,
-  //   G extends AnyTypes
-  // >(
-  //   op1: (input: ModelBuilder<T>) => ModelBuilder<A>,
-  //   op2: (input: ModelBuilder<A>) => ModelBuilder<B>,
-  //   op3: (input: ModelBuilder<B>) => ModelBuilder<C>,
-  //   op4: (input: ModelBuilder<C>) => ModelBuilder<D>,
-  //   op5: (input: ModelBuilder<D>) => ModelBuilder<E>,
-  //   op6: (input: ModelBuilder<E>) => ModelBuilder<F>,
-  //   op7: (input: ModelBuilder<F>) => ModelBuilder<G>
-  // ): Builder<G>
-
-  // model<
-  //   A extends AnyTypes,
-  //   B extends AnyTypes,
-  //   C extends AnyTypes,
-  //   D extends AnyTypes,
-  //   E extends AnyTypes,
-  //   F extends AnyTypes,
-  //   G extends AnyTypes,
-  //   H extends AnyTypes
-  // >(
-  //   op1: (input: ModelBuilder<T>) => ModelBuilder<A>,
-  //   op2: (input: ModelBuilder<A>) => ModelBuilder<B>,
-  //   op3: (input: ModelBuilder<B>) => ModelBuilder<C>,
-  //   op4: (input: ModelBuilder<C>) => ModelBuilder<D>,
-  //   op5: (input: ModelBuilder<D>) => ModelBuilder<E>,
-  //   op6: (input: ModelBuilder<E>) => ModelBuilder<F>,
-  //   op7: (input: ModelBuilder<F>) => ModelBuilder<G>,
-  //   op8: (input: ModelBuilder<G>) => ModelBuilder<H>
-  // ): Builder<H>
-
-  // model<
-  //   A extends AnyTypes,
-  //   B extends AnyTypes,
-  //   C extends AnyTypes,
-  //   D extends AnyTypes,
-  //   E extends AnyTypes,
-  //   F extends AnyTypes,
-  //   G extends AnyTypes,
-  //   H extends AnyTypes,
-  //   I extends AnyTypes
-  // >(
-  //   op1: (input: ModelBuilder<T>) => ModelBuilder<A>,
-  //   op2: (input: ModelBuilder<A>) => ModelBuilder<B>,
-  //   op3: (input: ModelBuilder<B>) => ModelBuilder<C>,
-  //   op4: (input: ModelBuilder<C>) => ModelBuilder<D>,
-  //   op5: (input: ModelBuilder<D>) => ModelBuilder<E>,
-  //   op6: (input: ModelBuilder<E>) => ModelBuilder<F>,
-  //   op7: (input: ModelBuilder<F>) => ModelBuilder<G>,
-  //   op8: (input: ModelBuilder<G>) => ModelBuilder<H>,
-  //   op9: (input: ModelBuilder<H>) => ModelBuilder<I>
-  // ): Builder<I>
-
-  // model<
-  //   A extends AnyTypes,
-  //   B extends AnyTypes,
-  //   C extends AnyTypes,
-  //   D extends AnyTypes,
-  //   E extends AnyTypes,
-  //   F extends AnyTypes,
-  //   G extends AnyTypes,
-  //   H extends AnyTypes,
-  //   I extends AnyTypes,
-  //   J extends AnyTypes
-  // >(
-  //   op1: (input: ModelBuilder<T>) => ModelBuilder<A>,
-  //   op2: (input: ModelBuilder<A>) => ModelBuilder<B>,
-  //   op3: (input: ModelBuilder<B>) => ModelBuilder<C>,
-  //   op4: (input: ModelBuilder<C>) => ModelBuilder<D>,
-  //   op5: (input: ModelBuilder<D>) => ModelBuilder<E>,
-  //   op6: (input: ModelBuilder<E>) => ModelBuilder<F>,
-  //   op7: (input: ModelBuilder<F>) => ModelBuilder<G>,
-  //   op8: (input: ModelBuilder<G>) => ModelBuilder<H>,
-  //   op9: (input: ModelBuilder<H>) => ModelBuilder<I>,
-  //   op10: (input: ModelBuilder<I>) => ModelBuilder<J>
-  // ): Builder<J>
-
-  // model<
-  //   A extends AnyTypes,
-  //   B extends AnyTypes,
-  //   C extends AnyTypes,
-  //   D extends AnyTypes,
-  //   E extends AnyTypes,
-  //   F extends AnyTypes,
-  //   G extends AnyTypes,
-  //   H extends AnyTypes,
-  //   I extends AnyTypes,
-  //   J extends AnyTypes,
-  //   K extends AnyTypes
-  // >(
-  //   op1: (input: ModelBuilder<T>) => ModelBuilder<A>,
-  //   op2: (input: ModelBuilder<A>) => ModelBuilder<B>,
-  //   op3: (input: ModelBuilder<B>) => ModelBuilder<C>,
-  //   op4: (input: ModelBuilder<C>) => ModelBuilder<D>,
-  //   op5: (input: ModelBuilder<D>) => ModelBuilder<E>,
-  //   op6: (input: ModelBuilder<E>) => ModelBuilder<F>,
-  //   op7: (input: ModelBuilder<F>) => ModelBuilder<G>,
-  //   op8: (input: ModelBuilder<G>) => ModelBuilder<H>,
-  //   op9: (input: ModelBuilder<H>) => ModelBuilder<I>,
-  //   op10: (input: ModelBuilder<I>) => ModelBuilder<J>,
-  //   op11: (input: ModelBuilder<J>) => ModelBuilder<K>
-  // ): Builder<K>
-
-  // model<
-  //   A extends AnyTypes,
-  //   B extends AnyTypes,
-  //   C extends AnyTypes,
-  //   D extends AnyTypes,
-  //   E extends AnyTypes,
-  //   F extends AnyTypes,
-  //   G extends AnyTypes,
-  //   H extends AnyTypes,
-  //   I extends AnyTypes,
-  //   J extends AnyTypes,
-  //   K extends AnyTypes,
-  //   L extends AnyTypes
-  // >(
-  //   op1: (input: ModelBuilder<T>) => ModelBuilder<A>,
-  //   op2: (input: ModelBuilder<A>) => ModelBuilder<B>,
-  //   op3: (input: ModelBuilder<B>) => ModelBuilder<C>,
-  //   op4: (input: ModelBuilder<C>) => ModelBuilder<D>,
-  //   op5: (input: ModelBuilder<D>) => ModelBuilder<E>,
-  //   op6: (input: ModelBuilder<E>) => ModelBuilder<F>,
-  //   op7: (input: ModelBuilder<F>) => ModelBuilder<G>,
-  //   op8: (input: ModelBuilder<G>) => ModelBuilder<H>,
-  //   op9: (input: ModelBuilder<H>) => ModelBuilder<I>,
-  //   op10: (input: ModelBuilder<I>) => ModelBuilder<J>,
-  //   op11: (input: ModelBuilder<J>) => ModelBuilder<K>,
-  //   op12: (input: ModelBuilder<K>) => ModelBuilder<L>
-  // ): Builder<L>
-
-  // model<
-  //   A extends AnyTypes,
-  //   B extends AnyTypes,
-  //   C extends AnyTypes,
-  //   D extends AnyTypes,
-  //   E extends AnyTypes,
-  //   F extends AnyTypes,
-  //   G extends AnyTypes,
-  //   H extends AnyTypes,
-  //   I extends AnyTypes,
-  //   J extends AnyTypes,
-  //   K extends AnyTypes,
-  //   L extends AnyTypes,
-  //   M extends AnyTypes
-  // >(
-  //   op1: (input: ModelBuilder<T>) => ModelBuilder<A>,
-  //   op2: (input: ModelBuilder<A>) => ModelBuilder<B>,
-  //   op3: (input: ModelBuilder<B>) => ModelBuilder<C>,
-  //   op4: (input: ModelBuilder<C>) => ModelBuilder<D>,
-  //   op5: (input: ModelBuilder<D>) => ModelBuilder<E>,
-  //   op6: (input: ModelBuilder<E>) => ModelBuilder<F>,
-  //   op7: (input: ModelBuilder<F>) => ModelBuilder<G>,
-  //   op8: (input: ModelBuilder<G>) => ModelBuilder<H>,
-  //   op9: (input: ModelBuilder<H>) => ModelBuilder<I>,
-  //   op10: (input: ModelBuilder<I>) => ModelBuilder<J>,
-  //   op11: (input: ModelBuilder<J>) => ModelBuilder<K>,
-  //   op12: (input: ModelBuilder<K>) => ModelBuilder<L>,
-  //   op13: (input: ModelBuilder<L>) => ModelBuilder<M>
-  // ): Builder<M>
-
-  // model<
-  //   A extends AnyTypes,
-  //   B extends AnyTypes,
-  //   C extends AnyTypes,
-  //   D extends AnyTypes,
-  //   E extends AnyTypes,
-  //   F extends AnyTypes,
-  //   G extends AnyTypes,
-  //   H extends AnyTypes,
-  //   I extends AnyTypes,
-  //   J extends AnyTypes,
-  //   K extends AnyTypes,
-  //   L extends AnyTypes,
-  //   M extends AnyTypes,
-  //   N extends AnyTypes
-  // >(
-  //   op1: (input: ModelBuilder<T>) => ModelBuilder<A>,
-  //   op2: (input: ModelBuilder<A>) => ModelBuilder<B>,
-  //   op3: (input: ModelBuilder<B>) => ModelBuilder<C>,
-  //   op4: (input: ModelBuilder<C>) => ModelBuilder<D>,
-  //   op5: (input: ModelBuilder<D>) => ModelBuilder<E>,
-  //   op6: (input: ModelBuilder<E>) => ModelBuilder<F>,
-  //   op7: (input: ModelBuilder<F>) => ModelBuilder<G>,
-  //   op8: (input: ModelBuilder<G>) => ModelBuilder<H>,
-  //   op9: (input: ModelBuilder<H>) => ModelBuilder<I>,
-  //   op10: (input: ModelBuilder<I>) => ModelBuilder<J>,
-  //   op11: (input: ModelBuilder<J>) => ModelBuilder<K>,
-  //   op12: (input: ModelBuilder<K>) => ModelBuilder<L>,
-  //   op13: (input: ModelBuilder<L>) => ModelBuilder<M>,
-  //   op14: (input: ModelBuilder<M>) => ModelBuilder<N>
-  // ): Builder<N>
-
-  // model<
-  //   A extends AnyTypes,
-  //   B extends AnyTypes,
-  //   C extends AnyTypes,
-  //   D extends AnyTypes,
-  //   E extends AnyTypes,
-  //   F extends AnyTypes,
-  //   G extends AnyTypes,
-  //   H extends AnyTypes,
-  //   I extends AnyTypes,
-  //   J extends AnyTypes,
-  //   K extends AnyTypes,
-  //   L extends AnyTypes,
-  //   M extends AnyTypes,
-  //   N extends AnyTypes,
-  //   O extends AnyTypes
-  // >(
-  //   op1: (input: ModelBuilder<T>) => ModelBuilder<A>,
-  //   op2: (input: ModelBuilder<A>) => ModelBuilder<B>,
-  //   op3: (input: ModelBuilder<B>) => ModelBuilder<C>,
-  //   op4: (input: ModelBuilder<C>) => ModelBuilder<D>,
-  //   op5: (input: ModelBuilder<D>) => ModelBuilder<E>,
-  //   op6: (input: ModelBuilder<E>) => ModelBuilder<F>,
-  //   op7: (input: ModelBuilder<F>) => ModelBuilder<G>,
-  //   op8: (input: ModelBuilder<G>) => ModelBuilder<H>,
-  //   op9: (input: ModelBuilder<H>) => ModelBuilder<I>,
-  //   op10: (input: ModelBuilder<I>) => ModelBuilder<J>,
-  //   op11: (input: ModelBuilder<J>) => ModelBuilder<K>,
-  //   op12: (input: ModelBuilder<K>) => ModelBuilder<L>,
-  //   op13: (input: ModelBuilder<L>) => ModelBuilder<M>,
-  //   op14: (input: ModelBuilder<M>) => ModelBuilder<N>,
-  //   op15: (input: ModelBuilder<N>) => ModelBuilder<O>
-  // ): Builder<O>
-
-  // /**
-  //  * Add deployment model to the builder
-  //  */
-  // deployment<
-  //   A extends AnyTypes
-  // >(
-  //   op1: (input: DeploymentModelBuilder<T>) => DeploymentModelBuilder<A>
-  // ): Builder<A>
-
-  // deployment<
-  //   A extends AnyTypes,
-  //   B extends AnyTypes
-  // >(
-  //   op1: (input: DeploymentModelBuilder<T>) => DeploymentModelBuilder<A>,
-  //   op2: (input: DeploymentModelBuilder<A>) => DeploymentModelBuilder<B>
-  // ): Builder<B>
 }

package/src/compute-view/dynamic-view/compute.ts

@@ -8,22 +8,22 @@ import {
   type Color,
   type ComputedDynamicView,
   type ComputedEdge,
-  DefaultArrowType,
-  DefaultLineStyle,
-  DefaultRelationshipColor,
   type DynamicView,
   type DynamicViewStep,
-  isDynamicViewParallelSteps,
-  isViewRuleAutoLayout,
-  isViewRulePredicate,
   type NonEmptyArray,
   type RelationId,
   type RelationshipArrowType,
   type RelationshipLineType,
   type StepEdgeId,
-  stepEdgeId,
   type Tag,
-  type ViewId
+  type ViewId,
+  DefaultArrowType,
+  DefaultLineStyle,
+  DefaultRelationshipColor,
+  isDynamicViewParallelSteps,
+  isViewRuleAutoLayout,
+  isViewRulePredicate,
+  stepEdgeId,
 } from '../../types'
 import { ancestorsFqn, commonAncestor, parentFqn } from '../../utils/fqn'
 import { applyCustomElementProperties } from '../utils/applyCustomElementProperties'
@@ -62,7 +62,7 @@ class DynamicViewCompute {
 
   constructor(
     protected model: LikeC4Model,
-    protected view: DynamicView
+    protected view: DynamicView,
   ) {}
 
   private addStep(
@@ -75,7 +75,7 @@ class DynamicViewCompute {
       ...step
     }: DynamicViewStep,
     index: number,
-    parent?: number
+    parent?: number,
   ) {
     const id = parent ? stepEdgeId(parent, index) : stepEdgeId(index)
     const source = this.model.element(stepSource)
@@ -89,11 +89,8 @@ class DynamicViewCompute {
       relations,
       tags,
       navigateTo: derivedNavigateTo,
-      head,
-      tail,
       color,
       line,
-      notation
     } = this.findRelations(source, target)
 
     const navigateTo = isTruthy(stepNavigateTo) && stepNavigateTo !== this.view.id ? stepNavigateTo : derivedNavigateTo
@@ -108,11 +105,8 @@ class DynamicViewCompute {
       isBackward: isBackward ?? false,
       ...(navigateTo ? { navigateTo } : {}),
       ...(tags ? { tags } : {}),
-      ...(head ? { head } : {}),
-      ...(tail ? { tail } : {}),
       ...(color ? { color } : {}),
       ...(line ? { line } : {}),
-      ...(notation ? { notation } : {})
     })
   }
 
@@ -171,7 +165,7 @@ class DynamicViewCompute {
         color: DefaultRelationshipColor,
         line: DefaultLineStyle,
         head: DefaultArrowType,
-        ...step
+        ...step,
       }
       if (isBackward) {
         edge.dir = 'back'
@@ -204,8 +198,8 @@ class DynamicViewCompute {
       applyViewRuleStyles(
         rules,
         // Keep order of elements
-        elements.map(e => nonNullable(nodesMap.get(e.id)))
-      )
+        elements.map(e => nonNullable(nodesMap.get(e.id))),
+      ),
     )
 
     const autoLayoutRule = findLast(rules, isViewRuleAutoLayout)
@@ -217,7 +211,7 @@ class DynamicViewCompute {
       autoLayout: {
         direction: autoLayoutRule?.direction ?? 'LR',
         ...(autoLayoutRule?.nodeSep && { nodeSep: autoLayoutRule.nodeSep }),
-        ...(autoLayoutRule?.rankSep && { rankSep: autoLayoutRule.rankSep })
+        ...(autoLayoutRule?.rankSep && { rankSep: autoLayoutRule.rankSep }),
       },
       nodes: map(nodes, n => {
         // omit notation
@@ -230,9 +224,9 @@ class DynamicViewCompute {
       edges,
       ...(elementNotations.length > 0 && {
         notation: {
-          elements: elementNotations
-        }
-      })
+          elements: elementNotations,
+        },
+      }),
     })
   }
 
@@ -241,11 +235,8 @@ class DynamicViewCompute {
     tags: NonEmptyArray<Tag> | null
     relations: NonEmptyArray<RelationId> | null
     navigateTo: ViewId | null
-    tail: RelationshipArrowType | null
-    head: RelationshipArrowType | null
     color: Color | null
     line: RelationshipLineType | null
-    notation: string | null
   } {
     const relationships = findConnection(source, target, 'directed').flatMap(r => [...r.relations])
     if (relationships.length === 0) {
@@ -254,18 +245,15 @@ class DynamicViewCompute {
         tags: null,
         relations: null,
         navigateTo: null,
-        tail: null,
-        head: null,
         color: null,
         line: null,
-        notation: null
       }
     }
     const alltags = pipe(
       relationships,
       flatMap(r => r.tags),
       filter(isTruthy),
-      unique()
+      unique(),
     )
     const tags = hasAtLeast(alltags, 1) ? alltags : null
     const relations = hasAtLeast(relationships, 1) ? map(relationships, r => r.id) : null
@@ -280,27 +268,21 @@ class DynamicViewCompute {
       filter(isTruthy),
       filter(v => v !== this.view.id),
       unique(),
-      only()
+      only(),
     )
 
     const commonProperties = pipe(
       relationships,
       reduce((acc, { title, $relationship: r }) => {
         isTruthy(title) && acc.title.add(title)
-        isTruthy(r.tail) && acc.tail.add(r.tail)
-        isTruthy(r.head) && acc.head.add(r.head)
         isTruthy(r.color) && acc.color.add(r.color)
         isTruthy(r.line) && acc.line.add(r.line)
-
         return acc
       }, {
-        tail: new Set<RelationshipArrowType>(),
-        head: new Set<RelationshipArrowType>(),
         color: new Set<Color>(),
         line: new Set<RelationshipLineType>(),
-        notation: new Set<string>(),
-        title: new Set<string>()
-      })
+        title: new Set<string>(),
+      }),
     )
 
     return {
@@ -308,17 +290,14 @@ class DynamicViewCompute {
       relations,
       navigateTo: navigateTo ?? null,
       title: only([...commonProperties.title]) ?? null,
-      tail: only([...commonProperties.tail]) ?? null,
-      head: only([...commonProperties.head]) ?? null,
       color: only([...commonProperties.color]) ?? null,
       line: only([...commonProperties.line]) ?? null,
-      notation: only([...commonProperties.notation]) ?? null
     }
   }
 }
 export function computeDynamicView<M extends AnyAux>(
   model: LikeC4Model<M>,
-  view: DynamicView
+  view: DynamicView,
 ): ComputedDynamicView {
   return new DynamicViewCompute(model, view).compute()
 }

package/src/compute-view/utils/resolve-extended-views.ts

@@ -1,18 +1,19 @@
-import { values } from 'remeda'
-import { type ExtendsElementView, isElementView, isExtendsElementView, type LikeC4View } from '../../types/view'
+import { unique, values } from 'remeda'
+import { type ExtendsElementView, type LikeC4View, isElementView, isExtendsElementView } from '../../types/view'
 
 import Graph from 'graphology'
 import { topologicalSort } from 'graphology-dag/topological-sort'
 import willCreateCycle from 'graphology-dag/will-create-cycle'
+import { isNonEmptyArray } from '../../utils'
 /**
  * Resolve rules of extended views
  * (Removes invalid views)
  */
 export function resolveRulesExtendedViews<V extends Record<any, LikeC4View>>(
-  unresolvedViews: V
+  unresolvedViews: V,
 ): V {
   const g = new Graph<{ view: LikeC4View }>({
-    type: 'directed'
+    type: 'directed',
   })
   const extendedViews = [] as ExtendsElementView<any, any>[]
   for (const view of values(unresolvedViews)) {
@@ -53,10 +54,24 @@ export function resolveRulesExtendedViews<V extends Record<any, LikeC4View>>(
       return acc
     }
 
+    const tags = unique([
+      ...(extendsFrom.tags ?? []),
+      ...(view.tags ?? []),
+    ])
+
+    const links = [
+      ...(extendsFrom.links ?? []),
+      ...(view.links ?? []),
+    ]
+
     acc[view.id] = {
       ...extendsFrom,
       ...view,
-      rules: [...extendsFrom.rules, ...view.rules]
+      title: view.title ?? extendsFrom.title ?? null,
+      description: view.description ?? extendsFrom.description ?? null,
+      tags: isNonEmptyArray(tags) ? tags : null,
+      links: isNonEmptyArray(links) ? links : null,
+      rules: [...extendsFrom.rules, ...view.rules],
     }
     return acc
   }, {} as Record<string, LikeC4View>) as V