@likec4/core 1.32.2 → 1.34.0

package/dist/shared/{core.CBxTtXMi.d.mts → core.DAj3LuFH.d.mts}

@@ -1,5 +1,6 @@
 import { IfNever, IsNever, IsLiteral } from 'type-fest';
-import { D as DeploymentFqn$1, C as Coalesce, F as Fqn$1, R as RelationId$1, N as NodeId$1, E as EdgeId$1, P as ProjectId$1, V as ViewId$1, T as Tag$1, a as ElementKind$1, b as DeploymentKind$1, c as RelationshipKind, L as Link } from './core.BuO4ncfY.mjs';
+import { C as Coalesce, L as Link } from './core.DuSLYTG6.mjs';
+import { D as DeploymentFqn$1, F as Fqn$1, d as RelationId$1, N as NodeId$1, j as EdgeId$1, P as ProjectId$1, V as ViewId$1, T as Tag$1, E as ElementKind$1, b as DeploymentKind$1, c as RelationshipKind } from './core.668kXpZq.mjs';
 
 /**
  * Determines the stage of the model:
@@ -198,61 +199,61 @@ type LooseElementKind<A extends Any> = Coalesce<A['ElementKind']> | OrString;
 type LooseDeploymentKind<A extends Any> = Coalesce<A['DeploymentKind']> | OrString;
 type LooseRelationKind<A extends Any> = Coalesce<A['RelationKind']> | OrString;
 
-type aux_AllKinds<A> = AllKinds<A>;
-type aux_Any = Any;
-type aux_AnySpec = AnySpec;
-type aux_Aux<Stage extends ModelStage, Element extends string, Deployment extends string, View extends string, Project extends string, Spec extends SpecAux<string, string, string, string, string>> = Aux<Stage, Element, Deployment, View, Project, Spec>;
-type aux_DeploymentFqn<A> = DeploymentFqn<A>;
-type aux_DeploymentId<A> = DeploymentId<A>;
-type aux_DeploymentKind<A> = DeploymentKind<A>;
-type aux_EdgeId = EdgeId;
-type aux_ElementId<A> = ElementId<A>;
-type aux_ElementKind<A> = ElementKind<A>;
-type aux_Fqn<A> = Fqn<A>;
-type aux_LooseDeploymentId<A extends Any> = LooseDeploymentId<A>;
-type aux_LooseDeploymentKind<A extends Any> = LooseDeploymentKind<A>;
-type aux_LooseElementId<A extends Any> = LooseElementId<A>;
-type aux_LooseElementKind<A extends Any> = LooseElementKind<A>;
-type aux_LooseRelationKind<A extends Any> = LooseRelationKind<A>;
-type aux_LooseTag<A extends Any> = LooseTag<A>;
-type aux_LooseTags<A extends Any> = LooseTags<A>;
-type aux_LooseViewId<A extends Any> = LooseViewId<A>;
-type aux_Metadata<A extends Any> = Metadata<A>;
-type aux_MetadataKey<A> = MetadataKey<A>;
-type aux_Never = Never;
-type aux_NodeId = NodeId;
-type aux_OrString = OrString;
-type aux_PickByStage<A extends Any, OnParsed, OnComputed, OnLayouted = OnComputed> = PickByStage<A, OnParsed, OnComputed, OnLayouted>;
-type aux_ProjectId<A> = ProjectId<A>;
-type aux_RelationId = RelationId;
-type aux_RelationKind<A> = RelationKind<A>;
-type aux_Spec<A> = Spec<A>;
-type aux_SpecAux<ElementKind extends string, DeploymentKind extends string, RelationKind extends string, Tag extends string, MetadataKey extends string> = SpecAux<ElementKind, DeploymentKind, RelationKind, Tag, MetadataKey>;
-type aux_Stage<A> = Stage<A>;
-type aux_StrictDeploymentKind<A> = StrictDeploymentKind<A>;
-type aux_StrictElementKind<A> = StrictElementKind<A>;
-type aux_StrictProjectId<A> = StrictProjectId<A>;
-type aux_StrictRelationKind<A> = StrictRelationKind<A>;
-type aux_StrictTag<A> = StrictTag<A>;
-type aux_StrictViewId<A> = StrictViewId<A>;
-type aux_Tag<A> = Tag<A>;
-type aux_Tags<A extends Any> = Tags<A>;
-type aux_Unknown = Unknown;
-type aux_UnknownComputed = UnknownComputed;
-type aux_UnknownLayouted = UnknownLayouted;
-type aux_UnknownParsed = UnknownParsed;
-type aux_ViewId<A> = ViewId<A>;
-type aux_WithLinks = WithLinks;
-type aux_WithMetadata<A extends Any> = WithMetadata<A>;
-type aux_WithOptionalLinks = WithOptionalLinks;
-type aux_WithOptionalTags<A extends Any> = WithOptionalTags<A>;
-type aux_WithTags<A extends Any> = WithTags<A>;
-type aux_setStage<A, S extends ModelStage> = setStage<A, S>;
-type aux_toComputed<A> = toComputed<A>;
-type aux_toLayouted<A> = toLayouted<A>;
-type aux_toParsed<A> = toParsed<A>;
-declare namespace aux {
-  export type { aux_AllKinds as AllKinds, aux_Any as Any, Any as AnyAux, aux_AnySpec as AnySpec, aux_Aux as Aux, aux_DeploymentFqn as DeploymentFqn, aux_DeploymentId as DeploymentId, aux_DeploymentKind as DeploymentKind, aux_EdgeId as EdgeId, aux_ElementId as ElementId, aux_ElementKind as ElementKind, aux_Fqn as Fqn, aux_LooseDeploymentId as LooseDeploymentId, aux_LooseDeploymentKind as LooseDeploymentKind, aux_LooseElementId as LooseElementId, aux_LooseElementKind as LooseElementKind, aux_LooseRelationKind as LooseRelationKind, aux_LooseTag as LooseTag, aux_LooseTags as LooseTags, aux_LooseViewId as LooseViewId, aux_Metadata as Metadata, aux_MetadataKey as MetadataKey, aux_Never as Never, aux_NodeId as NodeId, aux_OrString as OrString, aux_PickByStage as PickByStage, aux_ProjectId as ProjectId, aux_RelationId as RelationId, aux_RelationKind as RelationKind, aux_Spec as Spec, aux_SpecAux as SpecAux, aux_Stage as Stage, DeploymentFqn as StrictDeploymentFqn, aux_StrictDeploymentKind as StrictDeploymentKind, aux_StrictElementKind as StrictElementKind, Fqn as StrictFqn, aux_StrictProjectId as StrictProjectId, aux_StrictRelationKind as StrictRelationKind, aux_StrictTag as StrictTag, aux_StrictViewId as StrictViewId, aux_Tag as Tag, aux_Tags as Tags, aux_Unknown as Unknown, aux_UnknownComputed as UnknownComputed, aux_UnknownLayouted as UnknownLayouted, aux_UnknownParsed as UnknownParsed, aux_ViewId as ViewId, aux_WithLinks as WithLinks, aux_WithMetadata as WithMetadata, aux_WithOptionalLinks as WithOptionalLinks, aux_WithOptionalTags as WithOptionalTags, aux_WithTags as WithTags, aux_setStage as setStage, aux_toComputed as toComputed, aux_toLayouted as toLayouted, aux_toParsed as toParsed };
+type _aux_AllKinds<A> = AllKinds<A>;
+type _aux_Any = Any;
+type _aux_AnySpec = AnySpec;
+type _aux_Aux<Stage extends ModelStage, Element extends string, Deployment extends string, View extends string, Project extends string, Spec extends SpecAux<string, string, string, string, string>> = Aux<Stage, Element, Deployment, View, Project, Spec>;
+type _aux_DeploymentFqn<A> = DeploymentFqn<A>;
+type _aux_DeploymentId<A> = DeploymentId<A>;
+type _aux_DeploymentKind<A> = DeploymentKind<A>;
+type _aux_EdgeId = EdgeId;
+type _aux_ElementId<A> = ElementId<A>;
+type _aux_ElementKind<A> = ElementKind<A>;
+type _aux_Fqn<A> = Fqn<A>;
+type _aux_LooseDeploymentId<A extends Any> = LooseDeploymentId<A>;
+type _aux_LooseDeploymentKind<A extends Any> = LooseDeploymentKind<A>;
+type _aux_LooseElementId<A extends Any> = LooseElementId<A>;
+type _aux_LooseElementKind<A extends Any> = LooseElementKind<A>;
+type _aux_LooseRelationKind<A extends Any> = LooseRelationKind<A>;
+type _aux_LooseTag<A extends Any> = LooseTag<A>;
+type _aux_LooseTags<A extends Any> = LooseTags<A>;
+type _aux_LooseViewId<A extends Any> = LooseViewId<A>;
+type _aux_Metadata<A extends Any> = Metadata<A>;
+type _aux_MetadataKey<A> = MetadataKey<A>;
+type _aux_Never = Never;
+type _aux_NodeId = NodeId;
+type _aux_OrString = OrString;
+type _aux_PickByStage<A extends Any, OnParsed, OnComputed, OnLayouted = OnComputed> = PickByStage<A, OnParsed, OnComputed, OnLayouted>;
+type _aux_ProjectId<A> = ProjectId<A>;
+type _aux_RelationId = RelationId;
+type _aux_RelationKind<A> = RelationKind<A>;
+type _aux_Spec<A> = Spec<A>;
+type _aux_SpecAux<ElementKind extends string, DeploymentKind extends string, RelationKind extends string, Tag extends string, MetadataKey extends string> = SpecAux<ElementKind, DeploymentKind, RelationKind, Tag, MetadataKey>;
+type _aux_Stage<A> = Stage<A>;
+type _aux_StrictDeploymentKind<A> = StrictDeploymentKind<A>;
+type _aux_StrictElementKind<A> = StrictElementKind<A>;
+type _aux_StrictProjectId<A> = StrictProjectId<A>;
+type _aux_StrictRelationKind<A> = StrictRelationKind<A>;
+type _aux_StrictTag<A> = StrictTag<A>;
+type _aux_StrictViewId<A> = StrictViewId<A>;
+type _aux_Tag<A> = Tag<A>;
+type _aux_Tags<A extends Any> = Tags<A>;
+type _aux_Unknown = Unknown;
+type _aux_UnknownComputed = UnknownComputed;
+type _aux_UnknownLayouted = UnknownLayouted;
+type _aux_UnknownParsed = UnknownParsed;
+type _aux_ViewId<A> = ViewId<A>;
+type _aux_WithLinks = WithLinks;
+type _aux_WithMetadata<A extends Any> = WithMetadata<A>;
+type _aux_WithOptionalLinks = WithOptionalLinks;
+type _aux_WithOptionalTags<A extends Any> = WithOptionalTags<A>;
+type _aux_WithTags<A extends Any> = WithTags<A>;
+type _aux_setStage<A, S extends ModelStage> = setStage<A, S>;
+type _aux_toComputed<A> = toComputed<A>;
+type _aux_toLayouted<A> = toLayouted<A>;
+type _aux_toParsed<A> = toParsed<A>;
+declare namespace _aux {
+  export type { _aux_AllKinds as AllKinds, _aux_Any as Any, Any as AnyAux, _aux_AnySpec as AnySpec, _aux_Aux as Aux, _aux_DeploymentFqn as DeploymentFqn, _aux_DeploymentId as DeploymentId, _aux_DeploymentKind as DeploymentKind, _aux_EdgeId as EdgeId, _aux_ElementId as ElementId, _aux_ElementKind as ElementKind, _aux_Fqn as Fqn, _aux_LooseDeploymentId as LooseDeploymentId, _aux_LooseDeploymentKind as LooseDeploymentKind, _aux_LooseElementId as LooseElementId, _aux_LooseElementKind as LooseElementKind, _aux_LooseRelationKind as LooseRelationKind, _aux_LooseTag as LooseTag, _aux_LooseTags as LooseTags, _aux_LooseViewId as LooseViewId, _aux_Metadata as Metadata, _aux_MetadataKey as MetadataKey, _aux_Never as Never, _aux_NodeId as NodeId, _aux_OrString as OrString, _aux_PickByStage as PickByStage, _aux_ProjectId as ProjectId, _aux_RelationId as RelationId, _aux_RelationKind as RelationKind, _aux_Spec as Spec, _aux_SpecAux as SpecAux, _aux_Stage as Stage, DeploymentFqn as StrictDeploymentFqn, _aux_StrictDeploymentKind as StrictDeploymentKind, _aux_StrictElementKind as StrictElementKind, Fqn as StrictFqn, _aux_StrictProjectId as StrictProjectId, _aux_StrictRelationKind as StrictRelationKind, _aux_StrictTag as StrictTag, _aux_StrictViewId as StrictViewId, _aux_Tag as Tag, _aux_Tags as Tags, _aux_Unknown as Unknown, _aux_UnknownComputed as UnknownComputed, _aux_UnknownLayouted as UnknownLayouted, _aux_UnknownParsed as UnknownParsed, _aux_ViewId as ViewId, _aux_WithLinks as WithLinks, _aux_WithMetadata as WithMetadata, _aux_WithOptionalLinks as WithOptionalLinks, _aux_WithOptionalTags as WithOptionalTags, _aux_WithTags as WithTags, _aux_setStage as setStage, _aux_toComputed as toComputed, _aux_toLayouted as toLayouted, _aux_toParsed as toParsed };
 }
 
-export { type WithLinks as $, type Any as A, type WithMetadata as B, type AnySpec as C, type DeploymentKind as D, type ExtractOnStage as E, type Fqn as F, type PickByStage as G, type setStage as H, type NodeId as I, type Spec as J, type StrictProjectId as K, type LooseTag as L, type ModelStage as M, type Never as N, type StrictTag as O, type ProjectId as P, type StrictElementKind as Q, type RelationKind as R, type SpecAux as S, type Tags as T, type Unknown as U, type ViewId as V, type WithOptionalTags as W, type StrictDeploymentKind as X, type StrictRelationKind as Y, type WithTags as Z, _stage as _, aux as a, type OrString as a0, type LooseTags as a1, type LooseElementKind as a2, type LooseDeploymentKind as a3, type LooseRelationKind as a4, type Aux as b, type UnknownComputed as c, type UnknownLayouted as d, type UnknownParsed as e, _type as f, type ElementId as g, type EdgeId as h, isOnStage as i, type Metadata as j, type MetadataKey as k, type ElementKind as l, type RelationId as m, type StrictViewId as n, type LooseElementId as o, type LooseDeploymentId as p, type DeploymentFqn as q, type toLayouted as r, type Stage as s, type toComputed as t, type DeploymentId as u, type Tag as v, type toParsed as w, type LooseViewId as x, type AllKinds as y, type WithOptionalLinks as z };
+export { type WithLinks as $, type Any as A, type EdgeId as B, type AnySpec as C, type DeploymentKind as D, type ExtractOnStage as E, type Fqn as F, type PickByStage as G, type setStage as H, type NodeId as I, type Spec as J, type StrictProjectId as K, type LooseTag as L, type ModelStage as M, type Never as N, type StrictTag as O, type ProjectId as P, type StrictElementKind as Q, type RelationKind as R, type SpecAux as S, type Tags as T, type Unknown as U, type ViewId as V, type WithOptionalTags as W, type StrictDeploymentKind as X, type StrictRelationKind as Y, type WithTags as Z, _aux as _, type Aux as a, type OrString as a0, type LooseTags as a1, type LooseElementKind as a2, type LooseDeploymentKind as a3, type LooseRelationKind as a4, type UnknownComputed as b, type UnknownLayouted as c, type UnknownParsed as d, _stage as e, _type as f, type ElementId as g, type Metadata as h, isOnStage as i, type MetadataKey as j, type ElementKind as k, type RelationId as l, type StrictViewId as m, type LooseElementId as n, type LooseDeploymentId as o, type DeploymentFqn as p, type toLayouted as q, type Stage as r, type DeploymentId as s, type toComputed as t, type Tag as u, type toParsed as v, type LooseViewId as w, type AllKinds as x, type WithOptionalLinks as y, type WithMetadata as z };

package/dist/shared/{core.Bk7wEZFG.mjs → core.DXRAwwDB.mjs}

@@ -1,4 +1,5 @@
-import { F as FqnRef, c as n, d as isStepEdgeId } from './core.CUYDgv2-.mjs';
+import { F as FqnRef, q as isStepEdgeId } from './core.Br7Fab9l.mjs';
+import { n } from './core.D56nCp7e.mjs';
 
 function o(r){return Array.isArray(r)}
 
@@ -273,4 +274,4 @@ function isViewRuleGroup(rule) {
   return "title" in rule && "groupRules" in rule && Array.isArray(rule.groupRules);
 }
 
-export { Expression as E, FqnExpr as F, ModelFqnExpr as M, RelationExpr as R, isElementView as a, isViewRuleStyle as b, isViewRulePredicate as c, isViewRuleAutoLayout as d, isViewRuleGroup as e, isViewRuleGlobalPredicateRef as f, isViewRuleGlobalStyle as g, isDynamicViewParallelSteps as h, isExtendsElementView as i, ModelRelationExpr as j, ModelExpression as k, isDynamicView as l, isDeploymentView as m, isComputedView as n, o, isDiagramView as p, isScopedElementView as q, isAutoLayoutDirection as r, getParallelStepsPrefix as s };
+export { Expression as E, FqnExpr as F, ModelFqnExpr as M, RelationExpr as R, ModelRelationExpr as a, ModelExpression as b, isViewRuleStyle as c, isComputedView as d, isDiagramView as e, isElementView as f, isScopedElementView as g, isExtendsElementView as h, isViewRulePredicate as i, isDeploymentView as j, isDynamicView as k, isViewRuleGlobalStyle as l, isViewRuleGlobalPredicateRef as m, isAutoLayoutDirection as n, isViewRuleAutoLayout as o, getParallelStepsPrefix as p, isDynamicViewParallelSteps as q, isViewRuleGroup as r, o as s };

package/dist/shared/core.DcS-0zys.mjs

@@ -0,0 +1,10 @@
+function getOrCreate(map, key, create) {
+  let entry = map.get(key);
+  if (!entry) {
+    entry = create(key);
+    map.set(key, entry);
+  }
+  return entry;
+}
+
+export { getOrCreate as g };

package/dist/shared/core.Di7__sMg.d.mts

@@ -0,0 +1,87 @@
+import { C as Connection, c as customInspectSymbol } from './core.D3xEWj5B.mjs';
+import { e as DeploymentElementModel, i as RelationshipsAccum, D as DeploymentNodeModel, R as RelationshipModel, b as DeploymentRelationModel } from './core.DrS4Bf4y.mjs';
+import { A as Any, B as EdgeId } from './core.DAj3LuFH.mjs';
+import { I as IteratorLike } from './core.DuSLYTG6.mjs';
+
+/**
+ * Connection is ephemeral entity, result of a resolving relationships between source and target.
+ * Includes direct relationships and/or between their nested elements.
+ */
+declare class DeploymentConnectionModel<A extends Any = Any> implements Connection<DeploymentElementModel<A>, EdgeId> {
+    readonly source: DeploymentElementModel<A>;
+    readonly target: DeploymentElementModel<A>;
+    readonly relations: RelationshipsAccum<A>;
+    readonly id: EdgeId;
+    constructor(source: DeploymentElementModel<A>, target: DeploymentElementModel<A>, relations: RelationshipsAccum<A>);
+    /**
+     * Human readable expression of the connection
+     * Mostly used for testing and debugging
+     */
+    get expression(): string;
+    private _boundary;
+    /**
+     * Common ancestor of the source and target elements.
+     * Represents the boundary of the connection.
+     */
+    get boundary(): DeploymentNodeModel<A> | null;
+    nonEmpty(): boolean;
+    [customInspectSymbol](depth: any, inspectOptions: any, inspect: any): string;
+    toString(): string;
+    /**
+     * Check if connection contains deployment relation,
+     * that is directly connected to source or target.
+     */
+    hasDirectDeploymentRelation(): boolean;
+    values(): IteratorLike<RelationshipModel<A> | DeploymentRelationModel<A>>;
+    /**
+     * Merge with another connections, if it has the same source and target.
+     * Returns new connection with union of relationships.
+     */
+    mergeWith(others: DeploymentConnectionModel<A>[]): DeploymentConnectionModel<A>;
+    /**
+     * Merge with another connection, if it has the same source and target.
+     * Returns new connection with union of relationships.
+     */
+    mergeWith(other: DeploymentConnectionModel<A>): DeploymentConnectionModel<A>;
+    difference(other: DeploymentConnectionModel<A>): DeploymentConnectionModel<A>;
+    intersect(other: DeploymentConnectionModel<A>): DeploymentConnectionModel<A>;
+    equals(other: Connection): boolean;
+    /**
+     * Creates a clone of the current `DeploymentConnectionModel` instance with optional overrides.
+     * if `null` is provided in overrides, the corresponding relation set will be empty.
+     */
+    update(overrides?: {
+        model?: ReadonlySet<RelationshipModel<A>> | null;
+        deployment?: ReadonlySet<DeploymentRelationModel<A>> | null;
+    }): DeploymentConnectionModel<A>;
+}
+
+/**
+ * Resolve connection from source to target
+ * If direction is `both`, also look for reverse connection
+ *
+ * @default direction directed
+ */
+declare function findConnection<M extends Any>(source: DeploymentElementModel<M>, target: DeploymentElementModel<NoInfer<M>>, direction: 'directed'): readonly [DeploymentConnectionModel<M>] | readonly [];
+declare function findConnection<M extends Any>(source: DeploymentElementModel<M>, target: DeploymentElementModel<NoInfer<M>>, direction: 'both'): readonly [DeploymentConnectionModel<M>, DeploymentConnectionModel<M>] | readonly [DeploymentConnectionModel<M>] | readonly [];
+declare function findConnection<M extends Any>(source: DeploymentElementModel<M>, target: DeploymentElementModel<NoInfer<M>>, direction?: 'directed' | 'both'): readonly [DeploymentConnectionModel<M>, DeploymentConnectionModel<M>] | readonly [DeploymentConnectionModel<M>] | readonly [];
+/**
+ * Resolve all connections between element and others
+ * By default, look for both directions.
+ *
+ * @default direction both
+ */
+declare function findConnectionsBetween<M extends Any>(element: DeploymentElementModel<M>, others: Iterable<DeploymentElementModel<NoInfer<M>>>, direction?: 'directed' | 'both'): readonly DeploymentConnectionModel<M>[];
+/**
+ * Resolve all connections within a given set of elements
+ */
+declare function findConnectionsWithin<M extends Any>(elements: Iterable<DeploymentElementModel<M>>): readonly DeploymentConnectionModel<M>[];
+
+declare const find_findConnection: typeof findConnection;
+declare const find_findConnectionsBetween: typeof findConnectionsBetween;
+declare const find_findConnectionsWithin: typeof findConnectionsWithin;
+declare namespace find {
+  export { find_findConnection as findConnection, find_findConnectionsBetween as findConnectionsBetween, find_findConnectionsWithin as findConnectionsWithin };
+}
+
+export { DeploymentConnectionModel as D, findConnection as a, findConnectionsBetween as b, findConnectionsWithin as c, find as f };

package/dist/shared/{core.DaAyklhe.d.mts → core.DrS4Bf4y.d.mts}

@@ -1,8 +1,10 @@
-import { A as Any, R as RelationKind, T as Tags, j as Metadata, k as MetadataKey, L as LooseTag, F as Fqn, g as ElementId, l as ElementKind, D as DeploymentKind, E as ExtractOnStage, m as RelationId$1, f as _type, n as StrictViewId, o as LooseElementId, p as LooseDeploymentId, q as DeploymentFqn, t as toComputed, r as toLayouted, s as Stage, u as DeploymentId, U as Unknown, V as ViewId, v as Tag, w as toParsed, P as ProjectId$1, x as LooseViewId, b as Aux, S as SpecAux, e as UnknownParsed, c as UnknownComputed, d as UnknownLayouted } from './core.CBxTtXMi.mjs';
+import { A as Any, R as RelationKind, T as Tags, h as Metadata, j as MetadataKey, L as LooseTag, F as Fqn, g as ElementId, k as ElementKind, D as DeploymentKind, E as ExtractOnStage, l as RelationId$1, f as _type, m as StrictViewId, n as LooseElementId, o as LooseDeploymentId, p as DeploymentFqn, t as toComputed, q as toLayouted, r as Stage, s as DeploymentId, U as Unknown, V as ViewId, u as Tag, v as toParsed, P as ProjectId$1, w as LooseViewId, a as Aux, S as SpecAux, d as UnknownParsed, b as UnknownComputed, c as UnknownLayouted } from './core.DAj3LuFH.mjs';
 import { D as DefaultMap } from './core.CywrQs86.mjs';
 import { SetRequired } from 'type-fest';
-import { I as IteratorLike, R as RelationId, L as Link, P as ProjectId, j as IconUrl, N as NodeId, G as GroupElementKind, E as EdgeId, p as StepEdgeId, V as ViewId$1 } from './core.BuO4ncfY.mjs';
-import { az as Color, av as RelationshipLineType, Y as Relationship, O as Element, ar as ElementShape, N as ElementStyle, aM as ViewWithType, aI as ComputedView, aG as LayoutedView, k as ParsedLikeC4ModelData, l as ComputedLikeC4ModelData, m as LayoutedLikeC4ModelData, c as FqnRef, p as DeployedInstance, D as DeploymentElementStyle, u as DeploymentRelationship, q as DeploymentElement, o as DeploymentNode, x as LikeC4ModelDump, y as AuxFromDump, a2 as Specification, j as ModelGlobals, ah as WhereOperator } from './core.Bdz6fBF1.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.668kXpZq.mjs';
+import { b as RichTextOrEmpty, Y as Relationship, Q as Element, O as ElementStyle, as as ViewWithType, ao as ComputedView, am as LayoutedView, n as ParsedLikeC4ModelData, C as ComputedLikeC4ModelData, L as LayoutedLikeC4ModelData, f as FqnRef, q as DeployedInstance, D as DeploymentElementStyle, v as DeploymentRelationship, r as DeploymentElement, p as DeploymentNode, y as LikeC4ModelDump, z as AuxFromDump, a2 as Specification, m as ModelGlobals, ah as WhereOperator } from './core.IWLie-Ma.mjs';
+import { I as IteratorLike, L as Link } from './core.DuSLYTG6.mjs';
+import { i as Color, R as RelationshipLineType, c as ElementShape } from './core.CzdwsPmY.mjs';
 
 type RelationshipsIterator<A extends Any> = IteratorLike<RelationshipModel<A>>;
 /**
@@ -10,16 +12,16 @@ type RelationshipsIterator<A extends Any> = IteratorLike<RelationshipModel<A>>;
  * use {@link isDeploymentRelationModel} guard to check if the relationship is a deployment relationship
  */
 interface AnyRelationshipModel<A extends Any> extends WithTags<A>, WithMetadata<A> {
-    get id(): RelationId;
-    get expression(): string;
-    get title(): string | null;
-    get technology(): string | null;
-    get description(): string | null;
-    get navigateTo(): LikeC4ViewModel<A> | null;
-    get kind(): RelationKind<A> | null;
-    get links(): ReadonlyArray<Link>;
-    get color(): Color;
-    get line(): RelationshipLineType;
+    readonly id: RelationId;
+    readonly expression: string;
+    readonly title: string | null;
+    readonly technology: string | null;
+    readonly description: RichTextOrEmpty;
+    readonly navigateTo: LikeC4ViewModel<A> | null;
+    readonly kind: RelationKind<A> | null;
+    readonly links: ReadonlyArray<Link>;
+    readonly color: Color;
+    readonly line: RelationshipLineType;
     isDeploymentRelation(): this is DeploymentRelationModel<A>;
     isModelRelation(): this is RelationshipModel<A>;
     views(): ViewsIterator<A>;
@@ -39,7 +41,7 @@ declare class RelationshipModel<A extends Any = Any> implements AnyRelationshipM
     get expression(): string;
     get title(): string | null;
     get technology(): string | null;
-    get description(): string | null;
+    get description(): RichTextOrEmpty;
     get navigateTo(): LikeC4ViewModel<A> | null;
     get tags(): Tags<A>;
     get kind(): RelationKind<A> | null;
@@ -52,6 +54,7 @@ declare class RelationshipModel<A extends Any = Any> implements AnyRelationshipM
     views(): ViewsIterator<A>;
     isDeploymentRelation(): this is DeploymentRelationModel<A>;
     isModelRelation(): this is RelationshipModel<A>;
+    hasMetadata(): boolean;
     getMetadata(): Metadata<A>;
     getMetadata(field: MetadataKey<A>): string | undefined;
     /**
@@ -72,6 +75,7 @@ declare class ElementModel<A extends Any = Any> implements WithTags<A>, WithMeta
         fqn: Fqn<A>;
     };
     constructor($model: LikeC4Model<A>, $element: Element<A>);
+    get name(): string;
     get parent(): ElementModel<A> | null;
     get kind(): ElementKind<A>;
     get shape(): ElementShape;
@@ -83,7 +87,7 @@ declare class ElementModel<A extends Any = Any> implements WithTags<A>, WithMeta
      */
     get tags(): Tags<A>;
     get title(): string;
-    get description(): string | null;
+    get description(): RichTextOrEmpty;
     get technology(): string | null;
     get links(): ReadonlyArray<Link>;
     get defaultView(): LikeC4ViewModel.ScopedElementView<A> | null;
@@ -139,6 +143,7 @@ declare class ElementModel<A extends Any = Any> implements WithTags<A>, WithMeta
      */
     isDeployed(): boolean;
     deployments(): DeployedInstancesIterator<A>;
+    hasMetadata(): boolean;
     getMetadata(): Metadata<A>;
     getMetadata(field: MetadataKey<A>): string | undefined;
     /**
@@ -156,7 +161,7 @@ declare class NodeModel<A extends Any = Any, V extends $View<A> = $View<A>> impl
     get id(): NodeId;
     get title(): string;
     get kind(): ElementKind<A> | DeploymentKind<A> | typeof GroupElementKind | 'instance';
-    get description(): string | null;
+    get description(): RichTextOrEmpty;
     get technology(): string | null;
     get parent(): NodeModel<A, V> | null;
     get element(): ElementModel<A> | null;
@@ -236,7 +241,7 @@ declare class EdgeModel<A extends Any = Any, View extends $View<A> = $View<A>> i
     get id(): EdgeId;
     get parent(): NodeModel<A, View> | null;
     get label(): string | null;
-    get description(): string | null;
+    get description(): RichTextOrEmpty;
     get technology(): string | null;
     hasParent(): this is EdgeModel.WithParent<A, View>;
     get tags(): Tags<A>;
@@ -276,6 +281,7 @@ declare class LikeC4ViewModel<A extends Any = Any, V extends $View<A> = $View<A>
     get _type(): V[_type];
     get id(): StrictViewId<A>;
     get title(): string | null;
+    get description(): RichTextOrEmpty;
     get tags(): Tags<A>;
     get links(): ReadonlyArray<Link>;
     get viewOf(): ElementModel<A> | null;
@@ -397,6 +403,7 @@ interface WithTags<A extends Any> {
     isTagged(tag: LooseTag<A>): boolean;
 }
 interface WithMetadata<A extends Any> {
+    hasMetadata(): boolean;
     getMetadata(): Metadata<A>;
     getMetadata(field: MetadataKey<A>): string | undefined;
 }
@@ -497,7 +504,7 @@ declare abstract class AbstractDeploymentElementModel<A extends Any> implements
     get style(): SetRequired<DeploymentElementStyle, 'shape' | 'color' | 'size'>;
     get shape(): ElementShape;
     get color(): Color;
-    get description(): string | null;
+    get description(): RichTextOrEmpty;
     get technology(): string | null;
     get links(): ReadonlyArray<Link>;
     /**
@@ -541,6 +548,7 @@ declare abstract class AbstractDeploymentElementModel<A extends Any> implements
     abstract incomingModelRelationships(): RelationshipsIterator<A>;
     get allOutgoing(): RelationshipsAccum<A>;
     get allIncoming(): RelationshipsAccum<A>;
+    hasMetadata(): boolean;
     getMetadata(): Metadata<A>;
     getMetadata(field: MetadataKey<A>): string | undefined;
     /**
@@ -605,7 +613,7 @@ declare class DeployedInstanceModel<A extends Any = Any> extends AbstractDeploym
     get color(): Color;
     get tags(): Tags<A>;
     get kind(): ElementKind<A>;
-    get description(): string | null;
+    get description(): RichTextOrEmpty;
     get technology(): string | null;
     get links(): ReadonlyArray<Link>;
     isInstance(): this is DeployedInstanceModel<A>;
@@ -627,7 +635,7 @@ declare class NestedElementOfDeployedInstanceModel<A extends Any = Any> {
     get shape(): ElementShape;
     get color(): Color;
     get title(): string;
-    get description(): string | null;
+    get description(): RichTextOrEmpty;
     get technology(): string | null;
     isDeploymentNode(): this is DeploymentNodeModel<A>;
     isInstance(): this is DeployedInstanceModel<A>;
@@ -644,7 +652,7 @@ declare class DeploymentRelationModel<A extends Any = Any> implements AnyRelatio
     get expression(): string;
     get title(): string | null;
     get technology(): string | null;
-    get description(): string | null;
+    get description(): RichTextOrEmpty;
     get tags(): Tags<A>;
     get kind(): RelationKind<A> | null;
     get navigateTo(): LikeC4ViewModel<A> | null;
@@ -654,6 +662,7 @@ declare class DeploymentRelationModel<A extends Any = Any> implements AnyRelatio
     views(): IteratorLike<LikeC4ViewModel.DeploymentView<A>>;
     isDeploymentRelation(): this is DeploymentRelationModel<A>;
     isModelRelation(): this is RelationshipModel<A>;
+    hasMetadata(): boolean;
     getMetadata(): Metadata<A>;
     getMetadata(field: MetadataKey<A>): string | undefined;
     /**
@@ -916,4 +925,4 @@ declare namespace LikeC4Model {
     type AnyRelation<M = Unknown> = M extends Any ? RelationshipModel<M> | DeploymentRelationModel<M> : never;
 }
 
-export { type AnyRelationshipModel as A, type DeploymentElementModel as D, ElementModel as E, type IncomingFilter as I, LikeC4Model as L, NestedElementOfDeployedInstanceModel as N, type OutgoingFilter as O, RelationshipModel as R, type WithMetadata as W, RelationshipsAccum as a, DeploymentNodeModel as b, DeploymentRelationModel as c, DeployedInstanceModel as d, LikeC4ViewModel as e, NodeModel as f, EdgeModel as g, type AnyLikeC4Model as h, type DeploymentRelationEndpoint as i, LikeC4DeploymentModel as j, type DeploymentOrFqn as k, type EdgeOrId as l, type ElementOrFqn as m, type NodeOrId as n, type WithTags as o };
+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, type AnyLikeC4Model as f, LikeC4Model as g, type DeploymentRelationEndpoint as h, RelationshipsAccum as i, LikeC4DeploymentModel as j, type DeploymentOrFqn as k, type EdgeOrId as l, type ElementOrFqn as m, type NodeOrId as n, type WithTags as o };

package/dist/shared/core.DsMrjY2q.mjs

@@ -0,0 +1,34 @@
+import { t } from './core.BH9nN-_I.mjs';
+import { i as invariant } from './core.D4npX2q8.mjs';
+
+function ifind(arg1, arg2) {
+  const pred = arg2 ?? arg1;
+  invariant(t(pred));
+  function _find(iter) {
+    for (const value of iter) {
+      if (pred(value)) {
+        return value;
+      }
+    }
+    return;
+  }
+  if (!arg2) {
+    return _find;
+  }
+  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 };

package/dist/shared/core.DuSLYTG6.d.mts

@@ -0,0 +1,57 @@
+import { IsAny, UnionToIntersection, Simplify } from 'type-fest';
+
+type NonEmptyArray<T> = [T, ...T[]];
+type NonEmptyReadonlyArray<T> = readonly [T, ...T[]];
+type KeysOf<T> = keyof T extends infer K extends string ? K : never;
+type AllNever<Expressions> = UnionToIntersection<{
+    [Name in keyof Expressions]: {
+        -readonly [Key in keyof Expressions[Name]]?: never;
+    };
+}[keyof Expressions]>;
+/**
+ * @example
+ * ```ts
+ *   type Variant1 = {
+ *     a: string
+ *   }
+ *   type Variant2 = {
+ *     b: number
+ *   }
+ *
+ *   type Variants = ExclusiveUnion<{
+ *     Variant1: Variant1,
+ *     Variant2: Variant2
+ *   }>
+ *
+ *   // Fail here
+ *   const variant1: Variants = {
+ *      a: 'one',
+ *      b: 1
+ *   }
+ * ```
+ */
+type ExclusiveUnion<Expressions, All = AllNever<Expressions>> = Expressions extends object ? {
+    [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
+ * An array with *exactly* N elements in it.
+ *
+ * Only literal N values are supported. For very large N the type might result
+ * in a recurse depth error. For negative N the type would result in an infinite
+ * recursion. None of these have protections because this is an internal type!
+ */
+type NTuple<T, N extends number, Result extends Array<unknown> = []> = Result['length'] extends N ? Result : NTuple<T, N, [...Result, T]>;
+type IteratorLike<T> = IteratorObject<T, BuiltinIteratorReturn>;
+type Predicate<T> = (x: T) => boolean;
+interface Link {
+    title?: string;
+    url: string;
+    relative?: string;
+}
+/**
+ * Coalesce `V` to a string if it is `any`
+ */
+type Coalesce<V extends string, OrIfAny = string> = IsAny<V> extends true ? OrIfAny : V;
+
+export type { Coalesce as C, ExclusiveUnion as E, IteratorLike as I, KeysOf as K, Link as L, NonEmptyArray as N, Predicate as P, NonEmptyReadonlyArray as a, NTuple as b };