@likec4/core 1.43.0 → 1.45.0

package/dist/shared/{core.727Qoh_W.mjs → core.CdNCAwq7.mjs}

@@ -1,103 +1,4 @@
-import { g as getDefaultExportFromCjs } from './core.B85MJLTf.mjs';
-import { e } from './core.CqAJJpK_.mjs';
-
-var naturalCompareLite = {exports: {}};
-
-var hasRequiredNaturalCompareLite;
-
-function requireNaturalCompareLite () {
-	if (hasRequiredNaturalCompareLite) return naturalCompareLite.exports;
-	hasRequiredNaturalCompareLite = 1;
-	/*
-	 * @version    1.4.0
-	 * @date       2015-10-26
-	 * @stability  3 - Stable
-	 * @author     Lauri Rooden (https://github.com/litejs/natural-compare-lite)
-	 * @license    MIT License
-	 */
-
-
-	var naturalCompare = function(a, b) {
-		var i, codeA
-		, codeB = 1
-		, posA = 0
-		, posB = 0
-		, alphabet = String.alphabet;
-
-		function getCode(str, pos, code) {
-			if (code) {
-				for (i = pos; code = getCode(str, i), code < 76 && code > 65;) ++i;
-				return +str.slice(pos - 1, i)
-			}
-			code = alphabet && alphabet.indexOf(str.charAt(pos));
-			return code > -1 ? code + 76 : ((code = str.charCodeAt(pos) || 0), code < 45 || code > 127) ? code
-				: code < 46 ? 65               // -
-				: code < 48 ? code - 1
-				: code < 58 ? code + 18        // 0-9
-				: code < 65 ? code - 11
-				: code < 91 ? code + 11        // A-Z
-				: code < 97 ? code - 37
-				: code < 123 ? code + 5        // a-z
-				: code - 63
-		}
-
-
-		if ((a+="") != (b+="")) for (;codeB;) {
-			codeA = getCode(a, posA++);
-			codeB = getCode(b, posB++);
-
-			if (codeA < 76 && codeB < 76 && codeA > 66 && codeB > 66) {
-				codeA = getCode(a, posA, posA);
-				codeB = getCode(b, posB, posA = i);
-				posB = i;
-			}
-
-			if (codeA != codeB) return (codeA < codeB) ? -1 : 1
-		}
-		return 0
-	};
-
-	try {
-		naturalCompareLite.exports = naturalCompare;
-	} catch (e) {
-		String.naturalCompare = naturalCompare;
-	}
-	return naturalCompareLite.exports;
-}
-
-var naturalCompareLiteExports = requireNaturalCompareLite();
-const compare = /*@__PURE__*/getDefaultExportFromCjs(naturalCompareLiteExports);
-
-function compareNatural(a, b) {
-  if (a === b) return 0;
-  if (e(a)) {
-    if (e(b)) {
-      return compare(a, b);
-    }
-    return 1;
-  }
-  return e(b) ? -1 : 0;
-}
-function compareNaturalHierarchically(separator = ".", deepestFirst = false) {
-  return (a, b) => {
-    if (a === b) return 0;
-    if (!a) return -1;
-    if (!b) return 1;
-    const aParts = a.split(separator);
-    const bParts = b.split(separator);
-    const minLength = Math.min(aParts.length, bParts.length);
-    for (let i = 0; i < minLength; i++) {
-      const aPart = aParts[i];
-      const bPart = bParts[i];
-      const comparison = compare(aPart, bPart);
-      if (comparison !== 0) {
-        return comparison;
-      }
-    }
-    const diff = aParts.length - bParts.length;
-    return deepestFirst ? -1 * diff : diff;
-  };
-}
+import { c as compareNatural } from './core.3ZhnKAlZ.mjs';
 
 function isString(value) {
   return value != null && typeof value === "string";
@@ -272,4 +173,4 @@ function sortNaturalByFqn(array, sort) {
   }).map(({ item }) => item);
 }
 
-export { ancestorsFqn as a, isDescendantOf as b, isNonEmptyArray as c, isSameHierarchy as d, isString as e, sortParentsFirst as f, compareNatural as g, hasProp as h, isAncestor as i, compareNaturalHierarchically as j, commonAncestor as k, compareByFqnHierarchically as l, compareFqnHierarchically as m, nameFromFqn as n, hierarchyDistance as o, parentFqn as p, hierarchyLevel as q, sortByFqnHierarchically as r, sortNaturalByFqn as s, isAnyOf as t };
+export { ancestorsFqn as a, isDescendantOf as b, isNonEmptyArray as c, isSameHierarchy as d, isString as e, sortParentsFirst as f, commonAncestor as g, hasProp as h, isAncestor as i, compareByFqnHierarchically as j, compareFqnHierarchically as k, hierarchyDistance as l, hierarchyLevel as m, nameFromFqn as n, sortByFqnHierarchically as o, parentFqn as p, isAnyOf as q, sortNaturalByFqn as s };

package/dist/shared/{core.QJD_fcrc.mjs → core.CmPXpJ8l.mjs}

@@ -18,17 +18,4 @@ function ifind(arg1, arg2) {
   return _find(arg1);
 }
 
-function ihead(iterable) {
-  if (!iterable) {
-    return _head;
-  }
-  return _head(iterable);
-}
-function _head(iter) {
-  for (const value of iter) {
-    return value;
-  }
-  return;
-}
-
-export { ihead as a, ifind as i };
+export { ifind as i };

package/dist/shared/{core.DTdfiejA.d.mts → core.Cog93roC.d.mts}

@@ -1,5 +1,5 @@
-import { E as ElementModel, e as DeploymentElementModel } from './core.CcJ1FZ7h.mjs';
-import { A as Any } from './core.hNWo20Ym.mjs';
+import { E as ElementModel, e as DeploymentElementModel } from './core.CpURdWRM.mjs';
+import { A as Any } from './core.B73yxfPi.mjs';
 import { F as Fqn } from './core.DX-WYEPA.mjs';
 
 interface Connection<Elem = ElementModel<Any> | DeploymentElementModel<Any>, Id = string> {

package/dist/shared/core.Coi_LOUZ.mjs

@@ -0,0 +1,7 @@
+import { t as t$2 } from './core.BsSXS-_R.mjs';
+
+function t$1(...t){return t$2(Object.entries,t)}
+
+function e(e,...n){return typeof e==`string`||typeof e==`number`||typeof e==`symbol`?r=>t(r,e,...n):t(e,...n)}function t(e,...t){let n=e;for(let e of t){if(n==null)return;n=n[e];}return n}
+
+export { e, t$1 as t };

package/dist/shared/{core.CcJ1FZ7h.d.mts → core.CpURdWRM.d.mts}

@@ -1,12 +1,12 @@
-import { L as LikeC4Styles } from './core.CT1xBp4R.mjs';
-import { A as Any, R as RelationKind, m as Tags, y as Metadata, u as MetadataKey, L as LooseTag, F as Fqn, k as ElementId, j as ElementKind, t as DeploymentKind, E as ExtractOnStage, z as RelationId$1, h as StrictViewId, g as _type, B as LooseElementId, C as LooseDeploymentId, s as DeploymentFqn, G as toComputed, H as toLayouted, I as Stage, D as DeploymentId, U as Unknown, V as ViewId, T as Tag, J as toParsed, P as ProjectId$1, K as LooseViewId, a as Aux, S as SpecAux, d as UnknownParsed, b as UnknownComputed, c as UnknownLayouted } from './core.hNWo20Ym.mjs';
+import { SetRequired, IsAny } from 'type-fest';
+import { L as LikeC4Styles } from './core.Dvh1H0T2.mjs';
+import { A as Any, R as RelationKind, r as Tags, H as Metadata, C as MetadataKey, I as LooseTag, F as Fqn, a as ElementId, E as ElementKind, y as DeploymentKind, c as AnyLayouted, J as RelationId$1, S as StrictViewId, n as _type, m as _stage, K as LooseElementId, O as LooseDeploymentId, x as DeploymentFqn, t as toComputed, b as AnyComputed, Q as Stage, D as DeploymentId, V as ViewId, T as Tag, d as AnyParsed, P as ProjectId$1, X as LooseViewId, U as Unknown, e as Aux, i as UnknownParsed, g as UnknownComputed, h as UnknownLayouted } from './core.B73yxfPi.mjs';
 import { d as RelationId, P as ProjectId, a as IconUrl, N as NodeId, G as GroupElementKind, j as EdgeId, k as StepEdgeId, V as ViewId$1 } from './core.DX-WYEPA.mjs';
 import { D as DefaultMap } from './core.CywrQs86.mjs';
-import { SetRequired } from 'type-fest';
-import { b as RichTextOrEmpty, x as ViewWithType, u as ComputedView, s as LayoutedView, P as ParsedLikeC4ModelData, C as ComputedLikeC4ModelData, L as LayoutedLikeC4ModelData, d as DeployedInstance, h as DeploymentRelationship, e as DeploymentElement, D as DeploymentNode, l as LikeC4ModelDump, n as AuxFromDump, q as Specification } from './core.BT-9gaqQ.mjs';
-import { c as IteratorLike, L as Link, N as NonEmptyArray } from './core.D5fzJWbF.mjs';
-import { Q as Color, v as RelationshipLineType, y as RelationshipArrowType, u as ElementShape, W as WhereOperator } from './core.CDvVInBp.mjs';
-import { g as Relationship, f as Element, E as ElementStyle, F as ComputedNodeStyle, a1 as DynamicViewDisplayVariant, k as LikeC4Project, M as ModelGlobals } from './core.CvLjw3bH.mjs';
+import { b as RichTextOrEmpty, L as LayoutedView, V as ViewManualLayoutSnapshot, r as ComputedView, v as ViewWithType, P as ParsedLikeC4ModelData, C as ComputedLikeC4ModelData, c as LayoutedLikeC4ModelData, e as DeployedInstance, j as DeploymentRelationship, f as DeploymentElement, D as DeploymentNode, m as LikeC4ModelDump, o as AuxFromDump } from './core.DnCLhN8C.mjs';
+import { c as IteratorLike, L as Link, N as NonEmptyArray } from './core.DB0Ue5Wx.mjs';
+import { C as Color, f as RelationshipLineType, g as RelationshipArrowType, h as ElementShape, W as WhereOperator } from './core.0zAQeenX.mjs';
+import { g as Relationship, f as Element, E as ElementStyle, C as ComputedNodeStyle, B as BBox, a7 as DynamicViewDisplayVariant, o as LikeC4Project, S as Specification, M as ModelGlobals } from './core.mUnpvHtA.mjs';
 import { FqnRef } from '../types/fqnRef.mjs';
 
 type RelationshipsIterator<A extends Any> = IteratorLike<RelationshipModel<A>>;
@@ -19,6 +19,8 @@ interface AnyRelationshipModel<A extends Any = Any> extends WithTags<A>, WithMet
     readonly expression: string;
     readonly title: string | null;
     readonly technology: string | null;
+    readonly hasSummary: boolean;
+    readonly summary: RichTextOrEmpty;
     readonly description: RichTextOrEmpty;
     readonly navigateTo: LikeC4ViewModel<A> | null;
     readonly kind: RelationKind<A> | null;
@@ -46,6 +48,20 @@ declare class RelationshipModel<A extends Any = Any> implements AnyRelationshipM
     get expression(): string;
     get title(): string | null;
     get technology(): string | null;
+    /**
+     * Returns true if the relationship has a summary and a description
+     * (if one is missing - it falls back to another)
+     */
+    get hasSummary(): boolean;
+    /**
+     * Short description of the relationship.
+     * Falls back to description if summary is not provided.
+     */
+    get summary(): RichTextOrEmpty;
+    /**
+     * Long description of the relationship.
+     * Falls back to summary if description is not provided.
+     */
     get description(): RichTextOrEmpty;
     get navigateTo(): LikeC4ViewModel<A> | null;
     get tags(): Tags<A>;
@@ -74,6 +90,10 @@ type ElementsIterator<M extends Any> = IteratorLike<ElementModel<M>>;
 declare class ElementModel<A extends Any = Any> implements WithTags<A>, WithMetadata<A> {
     readonly $model: LikeC4Model<A>;
     readonly $element: Element<A>;
+    /**
+     * Don't use in runtime, only for type inference
+     */
+    readonly Aux: A;
     readonly id: Fqn<A>;
     readonly _literalId: ElementId<A>;
     readonly hierarchyLevel: number;
@@ -175,10 +195,11 @@ declare class ElementModel<A extends Any = Any> implements WithTags<A>, WithMeta
 
 type NodesIterator<M extends Any, V extends $View<M>> = IteratorLike<NodeModel<M, V>>;
 declare class NodeModel<A extends Any = Any, V extends $View<A> = $View<A>> implements WithTags<A> {
-    #private;
-    readonly $view: LikeC4ViewModel<A, V>;
+    readonly Aux: A;
+    readonly $viewModel: LikeC4ViewModel<A, V>;
+    readonly $view: V;
     readonly $node: V['nodes'][number];
-    constructor($view: LikeC4ViewModel<A, V>, $node: V['nodes'][number]);
+    constructor($viewModel: LikeC4ViewModel<A, V>, $node: V['nodes'][number]);
     get id(): NodeId;
     get title(): string;
     get kind(): ElementKind<A> | DeploymentKind<A> | typeof GroupElementKind | 'instance';
@@ -194,6 +215,10 @@ declare class NodeModel<A extends Any = Any, V extends $View<A> = $View<A>> impl
     get links(): ReadonlyArray<Link>;
     get navigateTo(): LikeC4ViewModel<A> | null;
     get style(): ComputedNodeStyle;
+    get x(): number | undefined;
+    get y(): number | undefined;
+    get width(): number | undefined;
+    get height(): number | undefined;
     children(): ReadonlySet<NodeModel<A, V>>;
     /**
      * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
@@ -205,7 +230,7 @@ declare class NodeModel<A extends Any = Any, V extends $View<A> = $View<A>> impl
     incomers(filter?: IncomingFilter): NodesIterator<A, V>;
     outgoing(filter?: OutgoingFilter): EdgesIterator<A, V>;
     outgoers(filter?: OutgoingFilter): NodesIterator<A, V>;
-    isDiagramNode(this: NodeModel<any, any>): this is NodeModel<A, ExtractOnStage<V, 'layouted'>>;
+    isLayouted(): this is NodeModel.Layouted<A>;
     hasChildren(): boolean;
     hasParent(): this is NodeModel.WithParent<A, V>;
     /**
@@ -228,43 +253,50 @@ declare class NodeModel<A extends Any = Any, V extends $View<A> = $View<A>> impl
     isTagged(tag: LooseTag<A>): boolean;
 }
 declare namespace NodeModel {
-    interface WithParent<A extends Any = Any, V extends $View<A> = $View<A>> extends NodeModel<A, V> {
-        parent: NodeModel<A, V>;
+    type Layouted<A> = A extends AnyLayouted ? NodeModel<A, LayoutedView<A>> & {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } : never;
+    interface WithParent<A extends Any, V extends $View<A> = $View<A>> extends NodeModel<A, V> {
+        readonly parent: NodeModel<A, V>;
     }
-    interface WithElement<A extends Any = Any, V extends $View<A> = $View<A>> extends NodeModel<A, V> {
-        kind: ElementKind<A>;
-        element: ElementModel<A>;
+    interface WithElement<A extends Any, V extends $View<A> = $View<A>> extends NodeModel<A, V> {
+        readonly kind: ElementKind<A>;
+        readonly element: ElementModel<A>;
     }
-    interface WithDeploymentElement<A extends Any = Any, V extends $View<A> = $View<A>> extends NodeModel<A, V> {
-        kind: DeploymentKind<A>;
-        deployment: DeploymentElementModel<A>;
+    interface WithDeploymentElement<A extends Any, V extends $View<A> = $View<A>> extends NodeModel<A, V> {
+        readonly kind: DeploymentKind<A>;
+        readonly deployment: DeploymentElementModel<A>;
     }
-    interface WithDeployedInstance<A extends Any = Any, V extends $View<A> = $View<A>> extends NodeModel<A, V> {
-        kind: 'instance';
-        element: ElementModel<A>;
-        deployment: DeployedInstanceModel<A>;
+    interface WithDeployedInstance<A extends Any, V extends $View<A> = $View<A>> extends NodeModel<A, V> {
+        readonly kind: 'instance';
+        readonly element: ElementModel<A>;
+        readonly deployment: DeployedInstanceModel<A>;
     }
-    interface IsGroup<A extends Any = Any, V extends $View<A> = $View<A>> extends NodeModel<A, V> {
-        kind: typeof GroupElementKind;
-        element: null;
-        deployment: null;
+    interface IsGroup<A extends Any, V extends $View<A> = $View<A>> extends NodeModel<A, V> {
+        readonly kind: typeof GroupElementKind;
+        readonly element: null;
+        readonly deployment: null;
     }
 }
 
 type EdgesIterator<A extends Any, V extends $View<A>> = IteratorLike<EdgeModel<A, V>>;
-declare class EdgeModel<A extends Any = Any, View extends $View<A> = $View<A>> implements WithTags<A> {
-    #private;
-    readonly view: LikeC4ViewModel<A, View>;
-    readonly $edge: View['edges'][number];
-    readonly source: NodeModel<A, View>;
-    readonly target: NodeModel<A, View>;
-    constructor(view: LikeC4ViewModel<A, View>, $edge: View['edges'][number], source: NodeModel<A, View>, target: NodeModel<A, View>);
+declare class EdgeModel<A extends Any = Any, V extends $View<A> = $View<A>> implements WithTags<A> {
+    readonly source: NodeModel<A, V>;
+    readonly target: NodeModel<A, V>;
+    readonly Aux: A;
+    readonly $viewModel: LikeC4ViewModel<A, V>;
+    readonly $view: V;
+    readonly $edge: V['edges'][number];
+    constructor($viewModel: LikeC4ViewModel<A, V>, $edge: V['edges'][number], source: NodeModel<A, V>, target: NodeModel<A, V>);
     get id(): EdgeId;
-    get parent(): NodeModel<A, View> | null;
+    get parent(): NodeModel<A, V> | null;
     get label(): string | null;
     get description(): RichTextOrEmpty;
     get technology(): string | null;
-    hasParent(): this is EdgeModel.WithParent<A, View>;
+    hasParent(): this is EdgeModel.WithParent<A, V>;
     get tags(): Tags<A>;
     get stepNumber(): number | null;
     get navigateTo(): LikeC4ViewModel<A> | null;
@@ -272,7 +304,7 @@ declare class EdgeModel<A extends Any = Any, View extends $View<A> = $View<A>> i
     get line(): RelationshipLineType;
     get head(): RelationshipArrowType;
     get tail(): RelationshipArrowType | undefined;
-    isStep(): this is EdgeModel.StepEdge<A, View>;
+    isStep(): this is EdgeModel.StepEdge<A, V>;
     relationships(type: 'model'): IteratorLike<RelationshipModel<A>>;
     relationships(type: 'deployment'): IteratorLike<DeploymentRelationModel<A>>;
     relationships(type?: 'model' | 'deployment'): IteratorLike<RelationshipModel<A> | DeploymentRelationModel<A>>;
@@ -283,11 +315,11 @@ declare class EdgeModel<A extends Any = Any, View extends $View<A> = $View<A>> i
 }
 declare namespace EdgeModel {
     interface StepEdge<A extends Any, V extends $View<A>> extends EdgeModel<A, V> {
-        id: StepEdgeId;
-        stepNumber: number;
+        readonly id: StepEdgeId;
+        readonly stepNumber: number;
     }
     interface WithParent<A extends Any, V extends $View<A>> extends EdgeModel<A, V> {
-        parent: NodeModel<A, V>;
+        readonly parent: NodeModel<A, V>;
     }
 }
 
@@ -372,8 +404,14 @@ declare class LikeC4ViewModel<A extends Any = Any, V extends $View<A> = $View<A>
      * Don't use in runtime, only for type inference
      */
     readonly Aux: A;
-    readonly $view: V;
+    readonly id: StrictViewId<A>;
+    /**
+     * The model this view belongs to
+     */
     readonly $model: LikeC4Model<A>;
+    /**
+     * The title of the view
+     */
     readonly title: string | null;
     /**
      * View folder this view belongs to.
@@ -387,9 +425,14 @@ declare class LikeC4ViewModel<A extends Any = Any, V extends $View<A> = $View<A>
      * "Group 1/Group 2/View"
      */
     readonly viewPath: string;
-    constructor(model: LikeC4Model<A>, view: V, folder: LikeC4ViewsFolder<A>);
+    constructor(model: LikeC4Model<A>, folder: LikeC4ViewsFolder<A>, view: V, manualLayoutSnapshot?: ViewManualLayoutSnapshot | undefined);
+    /**
+     * Returns the styles configuration for the project.
+     */
+    get $styles(): LikeC4Styles;
     get _type(): V[_type];
-    get id(): StrictViewId<A>;
+    get stage(): V[_stage];
+    get bounds(): Readonly<BBox>;
     /**
      * Returns title if defined, otherwise returns title of the element it is based on, otherwise returns its {@link id}
      */
@@ -420,11 +463,28 @@ declare class LikeC4ViewModel<A extends Any = Any, V extends $View<A> = $View<A>
      * Available for dynamic views only
      * throws error if view is not dynamic
      */
-    get mode(): DynamicViewDisplayVariant;
+    get mode(): DynamicViewDisplayVariant | null;
     /**
      * All tags from nodes and edges.
      */
     get includedTags(): Tags<A>;
+    /**
+     * The original view from the model.
+     * In case of layouted model, this is the latest auto-layouted view without manual changes applied
+     * @see {@link $layouted} should be used for rendering in the UI
+     */
+    get $view(): V;
+    /**
+     * Returns the view with manual layout applied if it exists, otherwise returns the original view
+     * This should be used for rendering in the UI
+     */
+    get $layouted(): V;
+    get hasManualLayout(): boolean;
+    get hasLayoutDrifts(): boolean;
+    /**
+     * If view has manual layout, returns it with manual layout applied
+     */
+    get $manual(): V | null;
     roots(): NodesIterator<A, V>;
     /**
      * Iterate over all nodes that have children.
@@ -488,32 +548,44 @@ declare class LikeC4ViewModel<A extends Any = Any, V extends $View<A> = $View<A>
     /**
      * Below are type guards.
      */
-    isComputed(this: LikeC4ViewModel<any, any>): this is LikeC4ViewModel<toComputed<A>>;
-    isDiagram(this: LikeC4ViewModel<any, any>): this is LikeC4ViewModel<toLayouted<A>>;
+    isComputed(this: LikeC4ViewModel<any, any>): this is LikeC4ViewModel.Computed<toComputed<A>>;
+    isLayouted(): this is LikeC4ViewModel.Layouted<A>;
+    /**
+     * @deprecated Use {@link isLayouted} instead
+     */
+    isDiagram(): this is LikeC4ViewModel.Layouted<A>;
     isElementView(this: LikeC4ViewModel<any, any>): this is LikeC4ViewModel.ElementView<A, V>;
     isScopedElementView(this: LikeC4ViewModel<any, any>): this is LikeC4ViewModel.ScopedElementView<A>;
     isDeploymentView(this: LikeC4ViewModel<any, any>): this is LikeC4ViewModel.DeploymentView<A, V>;
     isDynamicView(this: LikeC4ViewModel<any, any>): this is LikeC4ViewModel.DynamicView<A, V>;
 }
 declare namespace LikeC4ViewModel {
+    type Computed<A> = A extends AnyComputed ? LikeC4ViewModel<A, ComputedView<A>> : never;
+    type Layouted<A> = A extends AnyLayouted ? LikeC4ViewModel<A, LayoutedView<A>> : never;
     interface ElementView<A extends Any, V extends $View<A> = $View<A>> extends LikeC4ViewModel<A, ViewWithType<V, 'element'>> {
+        readonly mode: never;
     }
     interface ScopedElementView<A extends Any> extends LikeC4ViewModel<A, ViewWithType<$View<A>, 'element'> & {
         viewOf: Fqn<A>;
     }> {
-        viewOf: ElementModel<A>;
+        readonly mode: never;
+        readonly viewOf: ElementModel<A>;
     }
     interface DeploymentView<A extends Any, V extends $View<A> = $View<A>> extends LikeC4ViewModel<A, ViewWithType<V, 'deployment'>> {
+        readonly mode: never;
+    }
+    interface DynamicView<A extends Any, V extends $View<A>> extends LikeC4ViewModel<A, ViewWithType<V, 'dynamic'>> {
+        readonly mode: DynamicViewDisplayVariant;
+        readonly viewOf: never;
     }
-    type DynamicView<A extends Any, V extends $View<A> = $View<A>> = LikeC4ViewModel<A, ViewWithType<V, 'dynamic'>>;
 }
 
 type IncomingFilter = 'all' | 'direct' | 'to-descendants';
 type OutgoingFilter = 'all' | 'direct' | 'from-descendants';
-type ElementOrFqn<A extends Any> = ElementId<A> | {
+type ElementOrFqn<A> = ElementId<A> | {
     id: Fqn<A>;
 };
-type DeploymentOrFqn<A extends Any> = DeploymentId<A> | {
+type DeploymentOrFqn<A> = DeploymentId<A> | {
     id: DeploymentFqn<A>;
 };
 type NodeOrId = string | {
@@ -532,8 +604,8 @@ type $View<A extends Any> = {
 }[Stage<A>];
 type $ViewModel<A extends Any> = {
     parsed: never;
-    computed: LikeC4ViewModel<A>;
-    layouted: LikeC4ViewModel<A>;
+    computed: LikeC4ViewModel<A, $View<A>>;
+    layouted: LikeC4ViewModel<A, $View<A>>;
 }[Stage<A>];
 type $ModelData<A extends Any> = {
     parsed: ParsedLikeC4ModelData<A>;
@@ -636,6 +708,10 @@ type DeployedInstancesIterator<A extends Any> = IteratorLike<DeployedInstanceMod
 type DeploymentNodesIterator<A extends Any> = IteratorLike<DeploymentNodeModel<A>>;
 type DeploymentElementModel<A extends Any = Any> = DeploymentNodeModel<A> | DeployedInstanceModel<A>;
 declare abstract class AbstractDeploymentElementModel<A extends Any> implements WithTags<A>, WithMetadata<A> {
+    /**
+     * Don't use in runtime, only for type inference
+     */
+    readonly Aux: A;
     abstract readonly id: DeploymentFqn<A>;
     abstract readonly _literalId: DeploymentId<A>;
     abstract readonly parent: DeploymentNodeModel<A> | null;
@@ -805,6 +881,20 @@ declare class DeploymentRelationModel<A extends Any = Any> implements AnyRelatio
     get expression(): string;
     get title(): string | null;
     get technology(): string | null;
+    /**
+     * Returns true if the relationship has a summary and a description
+     * (if one is missing - it falls back to another)
+     */
+    get hasSummary(): boolean;
+    /**
+     * Short description of the relationship.
+     * Falls back to description if summary is not provided.
+     */
+    get summary(): RichTextOrEmpty;
+    /**
+     * Long description of the relationship.
+     * Falls back to summary if description is not provided.
+     */
     get description(): RichTextOrEmpty;
     get tags(): Tags<A>;
     get kind(): RelationKind<A> | null;
@@ -856,7 +946,7 @@ declare class RelationshipsAccum<A extends Any = Any> {
  *  When you do not need types in the model
  */
 type AnyLikeC4Model = LikeC4Model<any>;
-declare class LikeC4Model<A extends Any = Unknown> {
+declare class LikeC4Model<A extends Any = Any> {
     /**
      * Don't use in runtime, only for type inference
      */
@@ -872,9 +962,9 @@ declare class LikeC4Model<A extends Any = Unknown> {
     protected readonly _views: Map<ViewId<A>, LikeC4ViewModel<A, $View<A>>>;
     protected readonly _rootViewFolder: LikeC4ViewsFolder<A>;
     protected readonly _viewFolders: Map<string, LikeC4ViewsFolder<A>>;
-    protected readonly _viewFolderItems: DefaultMap<string, Set<LikeC4ViewModel<A, $View<A>> | LikeC4ViewsFolder<A>>>;
-    protected readonly _allTags: DefaultMap<Tag<A>, Set<ElementModel<A> | LikeC4ViewModel<A, $View<A>> | RelationshipModel<A>>>;
-    static fromParsed<T extends Any>(model: ParsedLikeC4ModelData<T>): LikeC4Model.Parsed<T>;
+    protected readonly _viewFolderItems: DefaultMap<string, Set<LikeC4ViewsFolder<A> | LikeC4ViewModel<A, $View<A>>>>;
+    protected readonly _allTags: DefaultMap<Tag<A>, Set<ElementModel<A> | RelationshipModel<A> | LikeC4ViewModel<A, $View<A>>>>;
+    static fromParsed<T extends AnyParsed>(model: ParsedLikeC4ModelData<T>): LikeC4Model<T>;
     /**
      * Creates a new LikeC4Model instance from the provided model data.
      * Model with parsed data will not have views, as they must be computed
@@ -884,9 +974,10 @@ declare class LikeC4Model<A extends Any = Unknown> {
      * @param model - The model data to create a LikeC4Model from
      * @returns A new LikeC4Model instance with the type derived from the input model
      */
-    static create<T extends Any>(model: ParsedLikeC4ModelData<T>): LikeC4Model.Parsed<T>;
-    static create<T extends Any>(model: LayoutedLikeC4ModelData<T>): LikeC4Model.Layouted<T>;
-    static create<T extends Any>(model: ComputedLikeC4ModelData<T>): LikeC4Model.Computed<T>;
+    static create<T extends AnyParsed>(model: ParsedLikeC4ModelData<T>): LikeC4Model<T>;
+    static create<T extends AnyComputed>(model: ComputedLikeC4ModelData<T>): LikeC4Model<T>;
+    static create<T extends AnyLayouted>(model: LayoutedLikeC4ModelData<T>): LikeC4Model<T>;
+    static create<T extends Any>(model: $ModelData<T>): LikeC4Model<T>;
     /**
      * Creates a new LikeC4Model instance and infers types from a model dump.\
      * Model dump expected to be computed or layouted.
@@ -921,15 +1012,15 @@ declare class LikeC4Model<A extends Any = Unknown> {
     /**
      * Type guard the model to the parsed stage.
      */
-    isParsed(this: LikeC4Model<any>): this is LikeC4Model<toParsed<A>>;
+    isParsed(this: LikeC4Model<any>): this is LikeC4Model.Parsed<A>;
     /**
      * Type guard the model to the layouted stage.
      */
-    isLayouted(this: LikeC4Model<any>): this is LikeC4Model<toLayouted<A>>;
+    isLayouted(this: LikeC4Model<any>): this is LikeC4Model.Layouted<A>;
     /**
      * Type guard the model to the computed stage.
      */
-    isComputed(this: LikeC4Model<any>): this is LikeC4Model<toComputed<A>>;
+    isComputed(this: LikeC4Model<any>): this is LikeC4Model.Computed<A>;
     /**
      * Keeping here for backward compatibility
      * @deprecated use {@link $data}
@@ -963,7 +1054,9 @@ declare class LikeC4Model<A extends Any = Unknown> {
      *   id: 'dashboard',
      * })
      */
-    element(el: ElementOrFqn<A>): ElementModel<A>;
+    element(el: ElementId<A> | {
+        id: Fqn<A>;
+    }): ElementModel<A>;
     /**
      * Returns the element with the given FQN.
      *
@@ -1016,7 +1109,7 @@ declare class LikeC4Model<A extends Any = Unknown> {
      */
     view(viewId: ViewId<A> | {
         id: ViewId$1<ViewId<A>>;
-    }): LikeC4ViewModel<A, $View<A>>;
+    }): $ViewModel<A>;
     /**
      * Returns a specific view by its ID.
      * @note Method is not type-safe as {@link view}
@@ -1024,7 +1117,11 @@ declare class LikeC4Model<A extends Any = Unknown> {
      * @example
      * model.findView('index')
      */
-    findView(viewId: LooseViewId<A>): LikeC4ViewModel<A, $View<A>> | null;
+    findView(viewId: LooseViewId<A>): $ViewModel<A> | null;
+    /**
+     * Returns manual layout snapshot for given view ID, if any.
+     */
+    findManualLayout(viewId: LooseViewId<A>): ViewManualLayoutSnapshot | null;
     /**
      * Returns a view folder by its path.
      * Path is extracted from the view title, e.g. "Group 1/Group 2/View" -> "Group 1/Group 2"
@@ -1147,17 +1244,18 @@ declare class LikeC4Model<A extends Any = Unknown> {
     private addRelation;
 }
 declare namespace LikeC4Model {
-    const EMPTY: LikeC4Model<Aux<"computed", string, string, string, string, SpecAux<string, string, string, string, string>>>;
-    type Parsed<A = Unknown> = Unknown extends A ? LikeC4Model<UnknownParsed> : A extends Aux<any, infer E, infer D, infer V, infer PID, infer Spec> ? LikeC4Model<Aux<'parsed', E, D, V, PID, Spec>> : never;
-    type Computed<A = Unknown> = Unknown extends A ? LikeC4Model<UnknownComputed> : A extends Aux<any, infer E, infer D, infer V, infer PID, infer Spec> ? LikeC4Model<Aux<'computed', E, D, V, PID, Spec>> : never;
-    type Layouted<A = Unknown> = Unknown extends A ? LikeC4Model<UnknownLayouted> : A extends Aux<any, infer E, infer D, infer V, infer PID, infer Spec> ? LikeC4Model<Aux<'layouted', E, D, V, PID, Spec>> : never;
-    type Node<A = Unknown> = A extends Any ? NodeModel<A> : never;
-    type Element<A = Unknown> = A extends Any ? ElementModel<A> : never;
-    type Relationship<A = Unknown> = A extends Any ? RelationshipModel<A> : never;
-    type View<A = Unknown> = A extends Any ? $ViewModel<A> : never;
-    type DeploymentNode<A = Unknown> = A extends Any ? DeploymentNodeModel<A> : never;
-    type DeployedInstance<A = Unknown> = A extends Any ? DeployedInstanceModel<A> : never;
-    type AnyRelation<M = Unknown> = M extends Any ? RelationshipModel<M> | DeploymentRelationModel<M> : never;
+    const EMPTY: LikeC4Model<Unknown>;
+    type Parsed<A = unknown> = IsAny<A> extends true ? LikeC4Model<AnyParsed> : A extends Aux<any, infer E, infer D, infer V, infer PID, infer Spec> ? LikeC4Model<Aux<'parsed', E, D, V, PID, Spec>> : LikeC4Model<UnknownParsed>;
+    type Computed<A = unknown> = IsAny<A> extends true ? LikeC4Model<AnyComputed> : A extends Aux<any, infer E, infer D, infer V, infer PID, infer Spec> ? LikeC4Model<Aux<'computed', E, D, V, PID, Spec>> : LikeC4Model<UnknownComputed>;
+    type Layouted<A = unknown> = IsAny<A> extends true ? LikeC4Model<AnyLayouted> : A extends Aux<any, infer E, infer D, infer V, infer PID, infer Spec> ? LikeC4Model<Aux<'layouted', E, D, V, PID, Spec>> : LikeC4Model<UnknownLayouted>;
+    type Node<A = Any> = A extends Any ? NodeModel<A> : never;
+    type Element<A = Any> = A extends Any ? ElementModel<A> : never;
+    type Relationship<A = Any> = A extends Any ? RelationshipModel<A> : never;
+    type View<A = Any> = A extends Any ? $ViewModel<A> : never;
+    type DeploymentNode<A = Any> = A extends Any ? DeploymentNodeModel<A> : never;
+    type DeploymentRelation<A = Any> = A extends Any ? DeploymentRelationModel<A> : never;
+    type DeployedInstance<A = Any> = A extends Any ? DeployedInstanceModel<A> : never;
+    type AnyRelation<M = Any> = M extends Any ? RelationshipModel<M> | DeploymentRelationModel<M> : never;
 }
 
 export { type AnyRelationshipModel as A, DeploymentNodeModel as D, ElementModel as E, type IncomingFilter as I, LikeC4ViewModel as L, NestedElementOfDeployedInstanceModel as N, type OutgoingFilter as O, RelationshipModel as R, type WithMetadata as W, DeployedInstanceModel as a, DeploymentRelationModel as b, NodeModel as c, EdgeModel as d, type DeploymentElementModel as e, LikeC4Model as f, type AnyLikeC4Model as g, RelationshipsAccum as h, type DeploymentRelationEndpoint as i, LikeC4DeploymentModel as j, LikeC4ViewsFolder as k, type DeploymentOrFqn as l, type EdgeOrId as m, type ElementOrFqn as n, type NodeOrId as o, type WithTags as p };

package/dist/shared/{core.D5fzJWbF.d.mts → core.DB0Ue5Wx.d.mts}

@@ -38,7 +38,7 @@ type ExclusiveUnion<Expressions, All = AllNever<Expressions>> = Expressions exte
     [Name in keyof Expressions]: Simplify<Omit<All, keyof Expressions[Name]> & Expressions[Name]>;
 }[keyof Expressions] : never;
 /**
- * Copy from https://github.com/remeda/remeda/blob/main/src/internal/types/NTuple.ts
+ * Copy from https://github.com/remeda/remeda/blob/main/packages/remeda/src/internal/types/NTuple.ts
  * An array with *exactly* N elements in it.
  *
  * Only literal N values are supported. For very large N the type might result