@likec4/core 1.47.0 → 1.48.0

package/dist/_chunks/Builder.view-element.mjs

@@ -0,0 +1,3284 @@
+import { r as __toESM } from "./rolldown-runtime.mjs";
+import { $ as e$10, B as t$13, C as t$7, D as e, G as t$17, I as e$2, J as n, K as n$4, L as e$4, M as e$3, N as e$7, O as e$11, Q as t$3, R as e$1, S as t$24, T as t, V as t$18, W as t$6, X as t$10, Z as t$16, _ as t$11, a as t$5, b as t$22, d as t$12, et as t$23, g as t$15, h as t$20, i as n$3, j as e$5, m as e$6, n as e$9, o as n$1, q as t$21, r as t$19, t as t$9, tt as t$8, u as t$1, v as t$2, w as t$4, x as n$2, y as t$14, z as e$8 } from "./libs/remeda.mjs";
+import { D as whereOperatorAsPredicate, I as exact, N as _stage, P as _type, b as isViewRuleStyle, d as isViewRuleGlobalStyle, g as isElementView, h as isDynamicView, l as isViewRuleAutoLayout, n as isViewRuleGroup, o as isDynamicStepsParallel, p as isDeploymentView, r as isViewRuleRank, s as isDynamicStepsSeries, u as isViewRuleGlobalPredicateRef, y as isViewRulePredicate } from "./LikeC4Styles.mjs";
+import { A as sortParentsFirst, C as isAncestor, D as parentFqn, F as commonHead, N as isNonEmptyArray, O as sortByFqnHierarchically, T as isSameHierarchy, _ as ancestorsFqn, a as difference, c as intersection, d as compareRelations, i as objectHash, s as hasIntersection, u as union, v as commonAncestor, w as isDescendantOf, y as compareByFqnHierarchically } from "./utils.mjs";
+import { n as nonNullable, r as nonexhaustive, t as invariant } from "./invariant.mjs";
+import { n as require_topological_sort, t as require_will_create_cycle } from "./libs/graphology-dag.mjs";
+import { l as import_stack, n as import_default_map } from "./libs/mnemonist.mjs";
+import { f as ifilter, i as isome, l as iflat, n as toArray, o as imap, p as isIterable, r as toSet, t as iunique } from "./iterable.mjs";
+import { n as preferSummary } from "./_aux.mjs";
+import { a as GroupElementKind, h as isGroupElementKind, p as flattenMarkdownOrString, y as stepEdgeId } from "./scalar.mjs";
+import { t as FqnRef } from "./fqnRef.mjs";
+import { n as FqnExpr, r as RelationExpr } from "./expression.mjs";
+import { n as ModelFqnExpr, r as ModelRelationExpr, t as ModelExpression } from "./expression-model.mjs";
+import { r as buildElementNotations } from "./calcDriftsFromSnapshot.mjs";
+import { c as isNestedElementOfDeployedInstanceModel, d as LikeC4Model, n as isDeploymentElementModel, o as isElementModel, r as isDeploymentNodeModel, t as isDeployedInstanceModel } from "./model.mjs";
+import { a as DeploymentConnectionModel, i as find_exports, u as RelationshipsAccum } from "./find.mjs";
+import { n as Connection, t as customInspectSymbol } from "./const.mjs";
+import { _ as mergeConnections, a as ConnectionModel, c as findDeepestNestedConnection, g as isOutgoing, h as isNestedConnection, i as find_exports$1, l as findDescendantConnections, m as isIncoming, n as findConnectionsBetween$3, o as differenceConnections, p as isAnyInOut, s as findAscendingConnections, t as findConnection$3, v as sortConnectionsByBoundaryHierarchy } from "./find2.mjs";
+import { t as Graph } from "./libs/graphology.mjs";
+
+//#region src/compute-view/utils/ancestorsOfNode.ts
+/**
+* Returns the ancestors of given computed node, starting with the direct parent and ending with the root node.
+*/
+function ancestorsOfNode(node, nodes) {
+	const ancestors = [];
+	let parentId = node.parent;
+	while (parentId) {
+		const parentNode = nonNullable(nodes.get(parentId), `Parent node ${parentId} not found`);
+		ancestors.push(parentNode);
+		parentId = parentNode.parent;
+	}
+	return ancestors;
+}
+
+//#endregion
+//#region src/compute-view/utils/link-nodes-with-edges.ts
+/**
+* Update `inEdges` and `outEdges` props of nodes based on the edges
+* Mutates nodes and updates their in/out edges
+*/
+function linkNodesWithEdges(nodesMap, edges) {
+	for (const edge of edges) {
+		const source = nodesMap.get(edge.source);
+		const target = nodesMap.get(edge.target);
+		invariant(source, `Source node ${edge.source} not found`);
+		invariant(target, `Target node ${edge.target} not found`);
+		source.outEdges.push(edge.id);
+		target.inEdges.push(edge.id);
+		const sourceAncestors = ancestorsOfNode(source, nodesMap);
+		const targetAncestors = ancestorsOfNode(target, nodesMap);
+		const edgeParent = sourceAncestors.length > 0 && targetAncestors.length > 0 ? t(commonHead(t$1(sourceAncestors), t$1(targetAncestors))) : null;
+		edge.parent = edgeParent ? edgeParent.id : null;
+		for (const sourceAncestor of sourceAncestors) {
+			if (sourceAncestor === edgeParent) break;
+			sourceAncestor.outEdges.push(edge.id);
+		}
+		for (const targetAncestor of targetAncestors) {
+			if (targetAncestor === edgeParent) break;
+			targetAncestor.inEdges.push(edge.id);
+		}
+	}
+}
+
+//#endregion
+//#region src/compute-view/utils/topological-sort.ts
+var import_topological_sort = require_topological_sort();
+var import_will_create_cycle = /* @__PURE__ */ __toESM(require_will_create_cycle(), 1);
+/**
+* Keeps initial order of the elements, but ensures parents are placed before children
+*/
+function ensureParentsFirst(array) {
+	const result = [];
+	const items = [...array];
+	let item;
+	while (item = items.shift()) {
+		let parent = item.parent;
+		if (parent) {
+			const ancestors = [];
+			while (parent) {
+				const parentIndx = items.findIndex((i) => i.id === parent);
+				if (parentIndx < 0) break;
+				const [parentItem] = items.splice(parentIndx, 1);
+				if (!parentItem) throw new Error("Invalid state, should not happen");
+				ancestors.unshift(parentItem);
+				parent = parentItem.parent;
+			}
+			result.push(...ancestors);
+		}
+		result.push(item);
+	}
+	return result;
+}
+/**
+* Side effect, mutates node.children field to preserve same order as in the input
+*/
+function updateChildren(nodes) {
+	nodes.forEach((parent) => {
+		if (parent.children.length > 0) parent.children = nodes.reduce((acc, n) => {
+			if (n.parent === parent.id) acc.push(n.id);
+			return acc;
+		}, []);
+	});
+	return nodes;
+}
+function topologicalSort(param) {
+	let nodes = ensureParentsFirst([...param.nodes.values()]);
+	let edges = [...param.edges];
+	if (nodes.length < 2 || edges.length === 0) return {
+		nodes,
+		edges
+	};
+	const getNode = (id) => nonNullable(param.nodes.get(id));
+	const g = new Graph({
+		multi: true,
+		allowSelfLoops: true,
+		type: "directed"
+	});
+	const [edgesBetweenLeafs, edgesWithCompounds] = t$2(t$3(edges, t$4((edge) => {
+		const source = getNode(edge.source), target = getNode(edge.target), parent = edge.parent ? getNode(edge.parent) : null;
+		return {
+			id: edge.id,
+			edge,
+			parent,
+			source,
+			target
+		};
+	})), ({ source, target }) => source.children.length === 0 && target.children.length === 0);
+	const sortedEdges = [];
+	const addEdgeToGraph = (edge) => {
+		g.mergeNode(edge.source);
+		g.mergeNode(edge.target);
+		sortedEdges.push(edge);
+		if (!(0, import_will_create_cycle.default)(g, edge.source, edge.target)) g.mergeDirectedEdge(edge.source, edge.target);
+	};
+	for (const { edge, source, target } of edgesBetweenLeafs) {
+		addEdgeToGraph(edge);
+		if (target.parent && target.parent !== edge.parent) t$3(ancestorsOfNode(target, param.nodes), t$5((ancestor) => ancestor.inEdges.includes(edge.id)), t$6((ancestor) => {
+			g.mergeNode(ancestor.id);
+			if (!(0, import_will_create_cycle.default)(g, edge.source, ancestor.id)) g.mergeDirectedEdge(edge.source, ancestor.id);
+			if (!(0, import_will_create_cycle.default)(g, ancestor.id, edge.target)) g.mergeDirectedEdge(ancestor.id, edge.target);
+		}));
+		if (source.parent) {
+			const sourceParent = getNode(source.parent);
+			g.mergeNode(sourceParent.id);
+			if (!(0, import_will_create_cycle.default)(g, sourceParent.id, source.id)) g.mergeDirectedEdge(sourceParent.id, source.id);
+			if (target.parent && target.parent !== source.parent) {
+				if (!(0, import_will_create_cycle.default)(g, sourceParent.id, target.parent)) g.mergeDirectedEdge(sourceParent.id, target.parent);
+			}
+		}
+	}
+	for (const { edge } of edgesWithCompounds) addEdgeToGraph(edge);
+	invariant(sortedEdges.length === edges.length, "Not all edges were added to the graph");
+	const sortedIds = (0, import_topological_sort.topologicalSort)(g);
+	let sorted = [];
+	let unsorted = nodes.slice();
+	for (const sortedId of sortedIds) {
+		const indx = unsorted.findIndex((n) => n.id === sortedId);
+		invariant(indx >= 0, `Node "${sortedId}" not found`);
+		sorted.push(...unsorted.splice(indx, 1));
+	}
+	if (unsorted.length > 0 && sorted.length > 0) sorted = sorted.flatMap((node) => {
+		if (unsorted.length === 0) return node;
+		const wereBefore = nodes.slice(0, nodes.indexOf(node)).filter((n) => unsorted.includes(n));
+		if (wereBefore.length > 0) {
+			unsorted = unsorted.filter((n) => !wereBefore.includes(n));
+			return [...wereBefore, node];
+		}
+		return node;
+	});
+	sorted.push(...unsorted);
+	return {
+		nodes: updateChildren(ensureParentsFirst(sorted)),
+		edges: sortedEdges
+	};
+}
+
+//#endregion
+//#region src/compute-view/utils/view-hash.ts
+function calcViewLayoutHash(view) {
+	view.hash = objectHash({
+		id: view.id,
+		__: view._type ?? "element",
+		autoLayout: view.autoLayout,
+		nodes: t$3(view.nodes, t$4((n) => ({
+			id: n.id,
+			icon: e(n.icon) && n.icon !== "none" ? "Y" : "N",
+			title: n.title,
+			description: flattenMarkdownOrString(n.description),
+			technology: n.technology ?? null,
+			shape: n.shape,
+			size: n.style.size ?? null,
+			iconSize: n.style.iconSize ?? null,
+			iconPosition: n.style.iconPosition ?? null,
+			textSize: n.style.textSize ?? null,
+			padding: n.style.padding ?? null,
+			children: n.children
+		})), t$7(({ id, ...node }) => [id, node])),
+		edges: t$3(view.edges, t$4((e) => ({
+			source: e.source,
+			target: e.target,
+			label: e.label,
+			description: flattenMarkdownOrString(e.description),
+			technology: e.technology ?? null,
+			dir: e.dir,
+			head: e.head,
+			tail: e.tail,
+			line: e.line
+		})), t$7(({ source, target, ...edge }) => [`${source}:${target}`, edge]))
+	});
+	return view;
+}
+
+//#endregion
+//#region src/compute-view/memory/AbstractMemory.ts
+var AbstractMemory = class {
+	/**
+	* Provides access to context types
+	* !IMPORTANT: Should not be called in runtime
+	*
+	* @example
+	* ```ts
+	*   type State = SomeMemory['Ctx']['MutableState']
+	* ```
+	*/
+	get Ctx() {
+		throw new Error("Should not be called in runtime");
+	}
+	constructor(state) {
+		this.state = state;
+	}
+	get elements() {
+		return this.state.elements;
+	}
+	get explicits() {
+		return this.state.explicits;
+	}
+	get final() {
+		return this.state.final;
+	}
+	get connections() {
+		return this.state.connections;
+	}
+	isEmpty() {
+		return this.elements.size === 0 && this.connections.length === 0 && this.explicits.size === 0 && this.final.size === 0;
+	}
+};
+
+//#endregion
+//#region src/compute-view/memory/AbstractStageExclude.ts
+var AbstractStageExclude = class {
+	excluded = {
+		elements: /* @__PURE__ */ new Set(),
+		connections: []
+	};
+	constructor(memory, expression) {
+		this.memory = memory;
+		this.expression = expression;
+	}
+	markedToMoveExplicitToImplicit = false;
+	_removeElement(element) {
+		this.excluded.elements.add(element);
+	}
+	exclude(element) {
+		if (!element) return this;
+		if (isIterable(element)) {
+			for (const el of element) this._removeElement(el);
+			return this;
+		}
+		this._removeElement(element);
+		return this;
+	}
+	_removeConnection(connection) {
+		this.excluded.connections.push(connection);
+	}
+	/**
+	* Excludes from the memory relationships from given connections (still connection may be included, but without given relationships)
+	* @param moveExplicitToImplicit - if true, disconnected explicit elements will be moved to implicit
+	* @default false
+	*/
+	excludeConnections(connection, moveExplicitToImplicit) {
+		if (e$1(moveExplicitToImplicit)) {
+			invariant(!this.markedToMoveExplicitToImplicit, "Already marked to move explicits");
+			this.markedToMoveExplicitToImplicit = moveExplicitToImplicit;
+		}
+		if (isIterable(connection)) {
+			for (const c of connection) this._removeConnection(c);
+			return this;
+		}
+		this._removeConnection(connection);
+		return this;
+	}
+	isDirty() {
+		return this.excluded.elements.size > 0 || this.excluded.connections.length > 0;
+	}
+	isEmpty() {
+		return !this.isDirty();
+	}
+	/**
+	* Determines whether disconnected explicits should become implicits.
+	* By default moves all disconnected explicits to implicits, if there were operation to exclude elements.
+	*
+	* Override this method to change the behavior.
+	*/
+	filterForMoveToImplicits(disconnectedExplicits) {
+		if (this.markedToMoveExplicitToImplicit || this.excluded.elements.size > 0) return disconnectedExplicits;
+		return /* @__PURE__ */ new Set();
+	}
+	moveDisconnectedExplicitsToImplicits(state) {
+		let disconnected = difference(new Set(this.memory.connections.flatMap((c) => [c.source, c.target])), new Set(state.connections.flatMap((c) => [c.source, c.target])));
+		disconnected = intersection(disconnected, state.elements);
+		disconnected = t$3(disconnected, ifilter((el) => {
+			return state.explicits.has(el) && !isome(state.final, isDescendantOf(el));
+		}), toSet());
+		if (disconnected.size > 0) {
+			disconnected = this.filterForMoveToImplicits(disconnected);
+			state.explicits = difference(state.explicits, disconnected);
+			state.final = difference(state.final, disconnected);
+		}
+		return state;
+	}
+	removeElements(state) {
+		state.elements = difference(state.elements, this.excluded.elements);
+		state.explicits = difference(state.explicits, this.excluded.elements);
+		state.final = difference(state.final, this.excluded.elements);
+		return state;
+	}
+	removeConnections(state) {
+		const excludedMap = this.excluded.connections.reduce((acc, c) => {
+			const existing = acc.get(c.id);
+			if (existing) acc.set(c.id, existing.mergeWith(c));
+			else acc.set(c.id, c);
+			return acc;
+		}, /* @__PURE__ */ new Map());
+		let disconnected = /* @__PURE__ */ new Set();
+		state.connections = state.connections.reduce((acc, c) => {
+			const excluded = excludedMap.get(c.id);
+			if (excluded) {
+				disconnected.add(c.source);
+				disconnected.add(c.target);
+				const diff = c.difference(excluded);
+				if (diff.nonEmpty()) acc.push(diff);
+			} else acc.push(c);
+			return acc;
+		}, []);
+		for (const stillExists of state.connections) {
+			disconnected.delete(stillExists.source);
+			disconnected.delete(stillExists.target);
+			if (stillExists.boundary && state.elements.has(stillExists.boundary)) disconnected.delete(stillExists.boundary);
+		}
+		if (disconnected.size === 0) return state;
+		disconnected = difference(disconnected, state.explicits);
+		state.final = difference(state.final, disconnected);
+		return state;
+	}
+	/**
+	* Precommit hook
+	*/
+	precommit(state) {
+		return state;
+	}
+	/**
+	* Postcommit hook
+	*/
+	postcommit(state) {
+		invariant(difference(state.explicits, state.elements).size === 0, "Explicits must be subset of elements");
+		invariant(difference(state.final, state.elements).size === 0, "Final elements must be subset of elements");
+		return state;
+	}
+	commit() {
+		let state = this.precommit(this.memory.mutableState());
+		if (this.excluded.elements.size > 0) {
+			const excludedConnections = state.connections.filter((c) => this.excluded.elements.has(c.source) || this.excluded.elements.has(c.target)).flatMap((c) => [c, ...findAscendingConnections(state.connections, c).map((asc) => asc.intersect(c))]).filter((asc) => asc.nonEmpty());
+			this.excludeConnections(excludedConnections);
+		}
+		if (this.excluded.connections.length > 0) state = this.removeConnections(state);
+		if (this.excluded.elements.size > 0) state = this.removeElements(state);
+		return this.memory.update(this.postcommit(state));
+	}
+};
+
+//#endregion
+//#region src/compute-view/memory/AbstractStageInclude.ts
+var AbstractStageInclude = class {
+	explicits = /* @__PURE__ */ new Set();
+	implicits = /* @__PURE__ */ new Set();
+	_ordered = /* @__PURE__ */ new Set();
+	_connections = [];
+	constructor(memory, expression) {
+		this.memory = memory;
+		this.expression = expression;
+	}
+	get elements() {
+		return this.explicits;
+	}
+	/**
+	* Connections from this stage
+	*/
+	get connections() {
+		return this._connections;
+	}
+	mergedConnections() {
+		return mergeConnections([...this.memory.connections, ...this._connections]);
+	}
+	connectWithExisting(_element, _direction) {
+		throw new Error("Method not implements, depends on the model");
+	}
+	/**
+	* Possible to override
+	*/
+	_addExplicit(elements) {
+		this._ordered.add(elements);
+		this.explicits.add(elements);
+		this.implicits.delete(elements);
+	}
+	addExplicit(element) {
+		if (!element) return this;
+		if (isIterable(element)) {
+			for (const el of element) this._addExplicit(el);
+			return this;
+		}
+		this._addExplicit(element);
+		return this;
+	}
+	/**
+	* Possible to override
+	*/
+	_addImplicit(elements) {
+		if (this.explicits.has(elements)) return;
+		this._ordered.add(elements);
+		this.implicits.add(elements);
+	}
+	addImplicit(elements) {
+		if (!elements) return this;
+		if (isIterable(elements)) {
+			for (const el of elements) this._addImplicit(el);
+			return this;
+		}
+		this._addImplicit(elements);
+		return this;
+	}
+	/**
+	* Possible to override
+	*/
+	_addConnection(connection) {
+		this._connections.push(connection);
+		this._addImplicit(connection.source);
+		this._addImplicit(connection.target);
+	}
+	addConnections(connection) {
+		if (isIterable(connection)) {
+			for (const c of connection) this._addConnection(c);
+			return this;
+		}
+		this._addConnection(connection);
+		return this;
+	}
+	isDirty() {
+		return this.explicits.size > 0 || this.implicits.size > 0 || this._connections.length > 0;
+	}
+	isEmpty() {
+		return !this.isDirty();
+	}
+	/**
+	* Precommit hook
+	*/
+	precommit(state) {
+		return state;
+	}
+	/**
+	* Postcommit hook
+	*/
+	postcommit(state) {
+		return state;
+	}
+	processConnections(connections) {
+		return connections;
+	}
+	commit() {
+		let state = this.precommit(this.memory.mutableState());
+		let fromConnections = /* @__PURE__ */ new Set();
+		if (this._connections.length > 0) {
+			const [fromKnown, rest] = t$2(this._connections, (c) => state.final.has(c.source));
+			state.connections = this.processConnections(mergeConnections([
+				...state.connections,
+				...fromKnown,
+				...rest
+			]));
+			fromConnections = new Set(state.connections.flatMap((c) => [c.source, c.target]));
+		}
+		state.elements = union(state.elements, this._ordered, this.explicits, fromConnections, this.implicits);
+		state.explicits = intersection(state.elements, union(state.explicits, this.explicits));
+		state.final = intersection(state.elements, union(state.final, this.explicits, fromConnections));
+		return this.memory.update(this.postcommit(state));
+	}
+};
+
+//#endregion
+//#region src/compute-view/memory/ops.ts
+function treeFromMemoryState(memory, filter = "final") {
+	const sorted = sortParentsFirst(toArray(filter === "final" ? memory.final : memory.elements));
+	const connected = new Set(memory.connections.flatMap((c) => [c.source, c.target]));
+	const root = new Set(sorted);
+	const parents = new import_default_map.default(() => null);
+	const children = sorted.reduce((acc, parent, index, all) => {
+		acc.set(parent, all.slice(index + 1).filter((e) => isAncestor(parent, e)).map((e) => {
+			root.delete(e);
+			return e;
+		}).reduce((acc, el) => {
+			if (!acc.some((e) => isAncestor(e, el))) {
+				acc.push(el);
+				parents.set(el, parent);
+			}
+			return acc;
+		}, []));
+		return acc;
+	}, new import_default_map.default(() => []));
+	return {
+		root,
+		connected,
+		hasInOut: (el) => memory.connections.some(Connection.isAnyInOut(el.id)),
+		parent: (el) => parents.get(el),
+		children: (el) => children.get(el)
+	};
+}
+
+//#endregion
+//#region src/compute-view/deployment-view/stages/stage-exclude.ts
+var StageExclude$1 = class extends AbstractStageExclude {};
+
+//#endregion
+//#region src/compute-view/utils/elementExpressionToPredicate.ts
+function elementExprToPredicate(target) {
+	if (ModelFqnExpr.isCustom(target)) return elementExprToPredicate(target.custom.expr);
+	if (ModelFqnExpr.isWhere(target)) {
+		const predicate = elementExprToPredicate(target.where.expr);
+		const where = whereOperatorAsPredicate(target.where.condition);
+		return (n) => predicate(n) && where(n);
+	}
+	if (ModelFqnExpr.isElementKindExpr(target)) return target.isEqual ? (n) => n.kind === target.elementKind : (n) => n.kind !== target.elementKind;
+	if (ModelFqnExpr.isElementTagExpr(target)) return target.isEqual ? ({ tags }) => tags.includes(target.elementTag) : ({ tags }) => !tags.includes(target.elementTag);
+	if (ModelFqnExpr.isWildcard(target)) return () => true;
+	if (ModelFqnExpr.isModelRef(target)) {
+		const fqn = FqnRef.flatten(target.ref);
+		if (target.selector === "expanded") return (n) => {
+			return n.id === fqn || parentFqn(n.id) === fqn;
+		};
+		if (target.selector === "descendants" || target.selector === "children") {
+			const fqnWithDot = fqn + ".";
+			return (n) => {
+				return n.id.startsWith(fqnWithDot);
+			};
+		}
+		return (n) => {
+			return n.id === fqn;
+		};
+	}
+	nonexhaustive(target);
+}
+
+//#endregion
+//#region src/compute-view/utils/applyViewRuleStyles.ts
+function applyViewRuleStyle(rule, predicate, nodes) {
+	const { shape, color, icon, ...rest } = rule.style;
+	const nonEmptyStyle = !e$2(rest);
+	t$3(nodes, n(e$3(isGroupElementKind)), n(predicate), t$6((n) => {
+		n.shape = shape ?? n.shape;
+		n.color = color ?? n.color;
+		if (e$4(icon)) n.icon = icon;
+		if (e$4(rule.notation)) n.notation = rule.notation;
+		if (nonEmptyStyle) n.style = {
+			...n.style,
+			...rest
+		};
+	}));
+}
+function applyViewRuleStyles(rules, nodes) {
+	for (const rule of rules) {
+		if (!isViewRuleStyle(rule) || rule.targets.length === 0) continue;
+		applyViewRuleStyle(rule, t$8(rule.targets.map(elementExprToPredicate)), nodes);
+	}
+	return nodes;
+}
+
+//#endregion
+//#region src/compute-view/element-view/memory/NodeGroup.ts
+var NodesGroup = class NodesGroup {
+	static kind = GroupElementKind;
+	constructor(id, viewRule, parent = null, elements = /* @__PURE__ */ new Set()) {
+		this.id = id;
+		this.viewRule = viewRule;
+		this.parent = parent;
+		this.elements = elements;
+	}
+	isEmpty() {
+		return this.elements.size === 0;
+	}
+	update(elements) {
+		return new NodesGroup(this.id, this.viewRule, this.parent, elements);
+	}
+	clone() {
+		return new NodesGroup(this.id, this.viewRule, this.parent, new Set(this.elements));
+	}
+};
+
+//#endregion
+//#region src/compute-view/element-view/memory/stage-exclude.ts
+var StageExclude = class extends AbstractStageExclude {
+	excludeRelations(excluded) {
+		t$3(this.memory.connections, n((c) => hasIntersection(c.relations, excluded)), t$6((c) => {
+			this.excludeConnections(c.update(intersection(c.relations, excluded)));
+		}));
+		return this;
+	}
+	/**
+	* Precommit hook
+	*/
+	precommit(state) {
+		if (this.excluded.elements.size > 0) {
+			const excludeRelationships = new Set([...this.excluded.elements].flatMap((el) => [...el.incoming("direct"), ...el.outgoing("direct")]));
+			this.excludeRelations(excludeRelationships);
+		}
+		return state;
+	}
+	postcommit(state) {
+		const leftExplicits = difference(this.memory.explicits, state.explicits);
+		for (const explicit of leftExplicits) state.explicitFirstSeenIn.delete(explicit);
+		const left = difference(this.memory.elements, state.elements);
+		for (const el of left) state.lastSeenIn.delete(el);
+		return state;
+	}
+};
+var ActiveGroupStageExclude = class extends StageExclude {
+	constructor(memory, expression) {
+		super(memory, expression);
+		this.memory = memory;
+		this.expression = expression;
+	}
+};
+
+//#endregion
+//#region src/compute-view/element-view/memory/stage-include.ts
+const { findConnection: findConnection$2, findConnectionsBetween: findConnectionsBetween$2 } = find_exports$1;
+var StageInclude$1 = class extends AbstractStageInclude {
+	/**
+	* Connects elements with existing ones in the memory
+	*/
+	connectWithExisting(elements, direction = "both") {
+		const before = this._connections.length;
+		const hasChanged = () => this._connections.length > before;
+		if (!isIterable(elements)) {
+			if (direction === "in" || direction === "both") for (const el of this.memory.elements) this.addConnections(findConnection$2(el, elements, "directed"));
+			if (direction === "out" || direction === "both") this.addConnections(findConnectionsBetween$2(elements, this.memory.elements, "directed"));
+			return hasChanged();
+		}
+		const targets = [...elements];
+		if (direction === "in" || direction === "both") for (const el of this.memory.elements) this.addConnections(findConnectionsBetween$2(el, targets, "directed"));
+		if (direction === "out" || direction === "both") for (const el of targets) this.addConnections(findConnectionsBetween$2(el, this.memory.elements, "directed"));
+		return hasChanged();
+	}
+	addImplicitWithinScope(element) {
+		if (!element) return;
+		if (!this.memory.scope || isAncestor(this.memory.scope, element)) this.addImplicit(element);
+	}
+	processConnections(connections) {
+		if (ModelExpression.isRelationExpr(this.expression)) return connections;
+		t$3(connections, t$6(({ source, target, boundary }) => {
+			t$3(t$9([...toArray(source.ancestors()).reverse(), source], [...toArray(target.ancestors()).reverse(), target]), t$10(([sourceAncestor, targetAncestor]) => sourceAncestor === targetAncestor), n$1(1), t$6(([sourceAncestor, targetAncestor]) => {
+				if (sourceAncestor === source && targetAncestor === target) {
+					this.addImplicitWithinScope(boundary);
+					return;
+				}
+				if (sourceAncestor !== source) this.addImplicitWithinScope(sourceAncestor);
+				if (targetAncestor !== target) this.addImplicitWithinScope(targetAncestor);
+			}));
+		}));
+		return connections;
+	}
+	postcommit(state) {
+		const newExplicits = difference(state.explicits, this.memory.explicits);
+		for (const explicit of newExplicits) state.explicitFirstSeenIn.set(explicit, "@root");
+		return state;
+	}
+};
+var ActiveGroupStageInclude = class extends StageInclude$1 {
+	constructor(memory, expression) {
+		super(memory, expression);
+		this.memory = memory;
+		this.expression = expression;
+	}
+	postcommit(state) {
+		const newExplicits = difference(state.explicits, this.memory.explicits);
+		for (const explicit of newExplicits) state.explicitFirstSeenIn.set(explicit, this.memory.activeGroupId);
+		for (const implicit of [...this.explicits, ...this.implicits]) state.lastSeenIn.set(implicit, this.memory.activeGroupId);
+		return state;
+	}
+};
+
+//#endregion
+//#region src/compute-view/element-view/memory/memory.ts
+var Memory$1 = class Memory$1 extends AbstractMemory {
+	static empty(scope) {
+		return new Memory$1({
+			elements: /* @__PURE__ */ new Set(),
+			explicits: /* @__PURE__ */ new Set(),
+			final: /* @__PURE__ */ new Set(),
+			connections: [],
+			groups: [],
+			explicitFirstSeenIn: /* @__PURE__ */ new Map(),
+			lastSeenIn: /* @__PURE__ */ new Map()
+		}, scope);
+	}
+	constructor(state, scope) {
+		super(state);
+		this.state = state;
+		this.scope = scope;
+	}
+	get groups() {
+		return this.state.groups;
+	}
+	get explicitFirstSeenIn() {
+		return this.state.explicitFirstSeenIn;
+	}
+	get lastSeenIn() {
+		return this.state.lastSeenIn;
+	}
+	stageInclude(expr) {
+		return new StageInclude$1(this, expr);
+	}
+	stageExclude(expr) {
+		return new StageExclude(this, expr);
+	}
+	mutableState() {
+		return {
+			elements: new Set(this.state.elements),
+			explicits: new Set(this.state.explicits),
+			final: new Set(this.state.final),
+			connections: [...this.state.connections],
+			groups: this.state.groups.map((g) => g.clone()),
+			explicitFirstSeenIn: new Map(this.state.explicitFirstSeenIn),
+			lastSeenIn: new Map(this.state.lastSeenIn)
+		};
+	}
+	update(newstate) {
+		return new Memory$1({
+			...this.state,
+			...newstate
+		}, this.scope);
+	}
+};
+var ActiveGroupMemory = class ActiveGroupMemory extends Memory$1 {
+	static enter(memory, rule) {
+		const groupId = `@gr${memory.groups.length + 1}`;
+		if (memory instanceof ActiveGroupMemory) {
+			const stack = import_stack.default.from([...memory.stack].reverse());
+			const state = memory.mutableState();
+			state.groups.push(new NodesGroup(groupId, rule, memory.activeGroupId));
+			stack.push(groupId);
+			return new ActiveGroupMemory(state, memory.scope, stack);
+		}
+		const state = memory.mutableState();
+		state.groups.push(new NodesGroup(groupId, rule, null));
+		const stack = import_stack.default.of(groupId);
+		return new ActiveGroupMemory(state, memory.scope, stack);
+	}
+	constructor(state, scope, stack) {
+		super(state, scope);
+		this.state = state;
+		this.scope = scope;
+		this.stack = stack;
+	}
+	get activeGroupId() {
+		return nonNullable(this.stack.peek(), "Stack must not be empty");
+	}
+	mutableState() {
+		return { ...super.mutableState() };
+	}
+	update(newstate) {
+		return new ActiveGroupMemory({
+			...this.state,
+			...newstate
+		}, this.scope, this.stack);
+	}
+	stageInclude(expr) {
+		return new ActiveGroupStageInclude(this, expr);
+	}
+	stageExclude(expr) {
+		return new ActiveGroupStageExclude(this, expr);
+	}
+	leave() {
+		const state = this.mutableState();
+		this.stack.pop();
+		if (this.stack.peek()) return new ActiveGroupMemory(state, this.scope, this.stack);
+		return new Memory$1(state, this.scope);
+	}
+};
+
+//#endregion
+//#region src/compute-view/utils/buildComputedNodes.ts
+function updateDepthOfAncestors(node, nodes) {
+	let parentNd;
+	while (!!node.parent && (parentNd = nodes.get(node.parent))) {
+		const depth = parentNd.depth ?? 1;
+		parentNd.depth = Math.max(depth, (node.depth ?? 0) + 1);
+		if (parentNd.depth === depth) break;
+		node = parentNd;
+	}
+}
+function elementModelToNodeSource(el) {
+	const { id, title, ...rest } = n$2(el.$element, [
+		"summary",
+		"description",
+		"metadata",
+		"style",
+		"tags"
+	]);
+	const { color, icon, shape, ...style } = el.style;
+	return exact({
+		id,
+		title,
+		modelRef: id,
+		shape,
+		color,
+		icon,
+		style,
+		description: /* @__PURE__ */ preferSummary(el.$element),
+		tags: [...el.tags],
+		...rest
+	});
+}
+function buildComputedNodes({ defaults }, elements, groups) {
+	const nodesMap = /* @__PURE__ */ new Map();
+	const elementToGroup = /* @__PURE__ */ new Map();
+	groups?.forEach(({ id, parent, viewRule, elements }) => {
+		if (parent) nonNullable(nodesMap.get(parent), `Parent group node ${parent} not found`).children.push(id);
+		nodesMap.set(id, {
+			id,
+			parent,
+			kind: GroupElementKind,
+			title: viewRule.title ?? "",
+			color: viewRule.color ?? defaults.group?.color ?? defaults.color,
+			shape: "rectangle",
+			children: [],
+			inEdges: [],
+			outEdges: [],
+			level: 0,
+			depth: 0,
+			tags: [],
+			style: exact({
+				border: viewRule.border ?? defaults.group?.border ?? defaults.border,
+				opacity: viewRule.opacity ?? defaults.group?.opacity ?? defaults.opacity,
+				size: viewRule.size,
+				multiple: viewRule.multiple,
+				padding: viewRule.padding,
+				textSize: viewRule.textSize
+			})
+		});
+		for (const e of elements) elementToGroup.set(e.id, id);
+	});
+	Array.from(elements).sort(compareByFqnHierarchically).forEach(({ id, ...el }) => {
+		let parent = parentFqn(id);
+		let level = 0;
+		let parentNd;
+		while (parent) {
+			parentNd = nodesMap.get(parent);
+			if (parentNd) break;
+			parent = parentFqn(parent);
+		}
+		const fqn = el.modelRef ?? id;
+		if (!parentNd && elementToGroup.has(fqn)) {
+			const parentGroupId = nonNullable(elementToGroup.get(fqn));
+			parentNd = nodesMap.get(parentGroupId);
+			parent = parentGroupId;
+		}
+		if (parentNd) {
+			if (parentNd.children.length == 0) {
+				parentNd.depth = 1;
+				updateDepthOfAncestors(parentNd, nodesMap);
+			}
+			parentNd.children.push(id);
+			level = parentNd.level + 1;
+		}
+		const node = exact({
+			id,
+			parent,
+			level,
+			children: [],
+			inEdges: [],
+			outEdges: [],
+			...el
+		});
+		nodesMap.set(id, node);
+	});
+	const orderedMap = /* @__PURE__ */ new Map();
+	groups?.forEach(({ id }) => {
+		orderedMap.set(id, nonNullable(nodesMap.get(id)));
+	});
+	elements.forEach(({ id }) => {
+		orderedMap.set(id, nonNullable(nodesMap.get(id)));
+	});
+	return orderedMap;
+}
+
+//#endregion
+//#region src/compute-view/utils/merge-props-from-relationships.ts
+function pickRelationshipProps(relation) {
+	const { title, description = null } = relation;
+	return {
+		...title && {
+			title,
+			description
+		},
+		...t$11(relation, [
+			"color",
+			"technology",
+			"head",
+			"line",
+			"tail",
+			"kind",
+			"navigateTo"
+		])
+	};
+}
+/**
+* Merges properties from multiple relationships into a single object.
+* @param relations - The relationships to merge.
+* @param prefer - The relationship to prefer when merging.
+*/
+function mergePropsFromRelationships(relations, prefer) {
+	const allprops = t$3(relations, t$12((acc, r) => {
+		if (e(r.title) && !acc.title.includes(r.title)) acc.title.push(r.title);
+		if (e(r.description) && !acc.description.some(t$13(r.description))) acc.description.push(r.description);
+		if (e(r.technology) && !acc.technology.includes(r.technology)) acc.technology.push(r.technology);
+		if (e(r.kind) && !acc.kind.includes(r.kind)) acc.kind.push(r.kind);
+		if (e(r.color) && !acc.color.includes(r.color)) acc.color.push(r.color);
+		if (e(r.line) && !acc.line.includes(r.line)) acc.line.push(r.line);
+		if (e(r.head) && !acc.head.includes(r.head)) acc.head.push(r.head);
+		if (e(r.tail) && !acc.tail.includes(r.tail)) acc.tail.push(r.tail);
+		if (e(r.navigateTo) && !acc.navigateTo.includes(r.navigateTo)) acc.navigateTo.push(r.navigateTo);
+		if (r.tags) acc.tags.push(...r.tags);
+		return acc;
+	}, {
+		title: [],
+		description: [],
+		technology: [],
+		kind: [],
+		head: [],
+		tail: [],
+		color: [],
+		tags: [],
+		line: [],
+		navigateTo: []
+	}));
+	let title = t$14(allprops.title) ?? (allprops.title.length > 1 ? "[...]" : void 0);
+	const tags = n$3(allprops.tags);
+	let merged = exact({
+		title,
+		description: t$14(allprops.description),
+		technology: t$14(allprops.technology),
+		kind: t$14(allprops.kind),
+		head: t$14(allprops.head),
+		tail: t$14(allprops.tail),
+		color: t$14(allprops.color),
+		line: t$14(allprops.line),
+		navigateTo: t$14(allprops.navigateTo),
+		...isNonEmptyArray(tags) && { tags }
+	});
+	if (prefer) {
+		const preferred = pickRelationshipProps(prefer);
+		merged = t$15({
+			...merged,
+			...preferred
+		}, e);
+	}
+	if (e$5(merged.title) && e(merged.technology)) {
+		merged.title = `[${merged.technology}]`;
+		delete merged.technology;
+	}
+	return merged;
+}
+
+//#endregion
+//#region src/compute-view/deployment-view/utils.ts
+const { findConnection: findConnection$1, findConnectionsBetween: findConnectionsBetween$1, findConnectionsWithin: findConnectionsWithin$1 } = find_exports;
+function resolveElements$1(model, expr) {
+	const ref = model.element(expr.ref.deployment);
+	if (ref.isDeploymentNode()) {
+		if (expr.selector === "children") return [...ref.children()];
+		if (expr.selector === "expanded") return [ref, ...ref.children()];
+		if (expr.selector === "descendants") return [...ref.descendants()];
+	}
+	return [ref];
+}
+function resolveModelElements(model, expr) {
+	const ref = model.$model.element(expr.ref.model);
+	if (expr.selector === "children") return [...ref.children()];
+	if (expr.selector === "expanded") return [ref, ...ref.children()];
+	if (expr.selector === "descendants") return [...ref.descendants()];
+	return [ref];
+}
+function deploymentExpressionToPredicate(target) {
+	if (FqnExpr.isWildcard(target)) return () => true;
+	if (FqnExpr.isElementTagExpr(target) || FqnExpr.isElementKindExpr(target)) throw new Error("element kind and tag expressions are not supported in deployment view rules");
+	if (FqnExpr.isDeploymentRef(target)) {
+		const fqn = target.ref.deployment;
+		if (target.selector === "expanded") {
+			const fqnWithDot = fqn + ".";
+			return (n) => n.id === fqn || n.id.startsWith(fqnWithDot);
+		}
+		if (target.selector === "descendants") {
+			const fqnWithDot = fqn + ".";
+			return (n) => n.id.startsWith(fqnWithDot);
+		}
+		if (target.selector === "children") return (n) => parentFqn(n.id) === fqn;
+		return (n) => n.id === fqn;
+	}
+	if (FqnExpr.isModelRef(target)) {
+		const fqn = target.ref.model;
+		if (target.selector === "expanded") {
+			const fqnWithDot = fqn + ".";
+			return (n) => {
+				const m = n.modelRef ?? null;
+				if (!m) return true;
+				return m === fqn || m.startsWith(fqnWithDot);
+			};
+		}
+		if (target.selector === "descendants") {
+			const fqnWithDot = fqn + ".";
+			return (n) => {
+				const m = n.modelRef ?? null;
+				if (!m) return true;
+				return m.startsWith(fqnWithDot);
+			};
+		}
+		if (target.selector === "children") return (n) => {
+			const m = n.modelRef ?? null;
+			if (!m) return true;
+			return parentFqn(m) === fqn;
+		};
+		return (n) => {
+			const m = n.modelRef ?? null;
+			if (!m) return true;
+			return m === fqn;
+		};
+	}
+	nonexhaustive(target);
+}
+function instanceSummary(model) {
+	return /* @__PURE__ */ preferSummary(model.$instance) ?? /* @__PURE__ */ preferSummary(model.element.$element);
+}
+function deploymentNodeToNodeSource(el) {
+	const id = el.id;
+	const onlyOneInstance = el.onlyOneInstance();
+	return exact({
+		id,
+		deploymentRef: id,
+		title: el.title,
+		kind: el.kind,
+		technology: el.technology ?? void 0,
+		links: t$16(el.links, 1) ? [...el.links] : void 0,
+		notation: el.$node.notation ?? void 0,
+		color: el.color,
+		shape: el.shape,
+		modelRef: onlyOneInstance?.element.id,
+		icon: el.style.icon,
+		description: /* @__PURE__ */ preferSummary(el.$node) ?? void 0,
+		tags: [...el.tags],
+		style: n$2(el.style, [
+			"icon",
+			"shape",
+			"color"
+		])
+	});
+}
+function instanceToNodeSource(el) {
+	const instance = el.$instance;
+	const element = el.element;
+	const { icon, color, shape, ...style } = el.style;
+	const links = [...element.links, ...instance.links ?? []];
+	return exact({
+		id: el.id,
+		kind: "instance",
+		title: el.title,
+		description: instanceSummary(el) ?? void 0,
+		technology: el.technology ?? void 0,
+		tags: [...el.tags],
+		links: t$16(links, 1) ? links : void 0,
+		icon,
+		color,
+		shape,
+		style,
+		deploymentRef: instance.id,
+		modelRef: element.id,
+		notation: instance.notation
+	});
+}
+function toNodeSource(el) {
+	if (el.isInstance()) return instanceToNodeSource(el);
+	return deploymentNodeToNodeSource(el);
+}
+function toComputedEdges$1(connections) {
+	return connections.reduce((acc, e) => {
+		const relations = [...e.relations.model, ...e.relations.deployment];
+		invariant(t$16(relations, 1), "Edge must have at least one relation");
+		const defaults = e.source.$model.$styles.defaults;
+		const source = e.source.id;
+		const target = e.target.id;
+		const { title, color = defaults.relationship.color, line = defaults.relationship.line, head = defaults.relationship.arrow, ...props } = mergePropsFromRelationships(relations.map((r) => r.$relationship));
+		const edge = exact({
+			id: e.id,
+			parent: e.boundary?.id ?? null,
+			source,
+			target,
+			label: title ?? null,
+			relations: relations.map((r) => r.id),
+			color,
+			line,
+			head,
+			...props
+		});
+		const existing = acc.find((e) => e.source === target && e.target === source);
+		if (existing && edge.label === existing.label) {
+			existing.dir = "both";
+			const head = existing.head ?? edge.head ?? e.source.$model.$styles.defaults.relationship.arrow;
+			existing.head ??= head;
+			existing.tail ??= head;
+			if (edge.color) existing.color ??= edge.color;
+			if (edge.line) existing.line ??= edge.line;
+			return acc;
+		}
+		acc.push(edge);
+		return acc;
+	}, []);
+}
+function buildNodes$1(model, memory) {
+	const nodesMap = buildComputedNodes(model.$styles, [...memory.final].map(toNodeSource));
+	for (const node of nodesMap.values()) {
+		if (!node.deploymentRef || !node.modelRef || node.children.length > 0) continue;
+		const deploymentNode = model.deployment.element(node.deploymentRef);
+		const onlyOneInstance = deploymentNode.isDeploymentNode() && deploymentNode.onlyOneInstance();
+		if (!onlyOneInstance) continue;
+		if (node.title === deploymentNode.name) node.title = onlyOneInstance.title;
+		node.description ??= instanceSummary(onlyOneInstance) ?? null;
+		node.technology ??= onlyOneInstance.technology;
+		if (e$2(node.tags)) node.tags = [...onlyOneInstance.tags];
+		if ((!node.links || e$2(node.links)) && t$16(onlyOneInstance.links, 1)) node.links = [...onlyOneInstance.links];
+		const defaults = model.$styles.defaults;
+		if (node.shape === defaults.shape && node.shape !== onlyOneInstance.shape) {
+			node.shape = onlyOneInstance.shape;
+			node.notation = null;
+		}
+		if (node.color === defaults.color && node.color !== onlyOneInstance.color) {
+			node.color = onlyOneInstance.color;
+			node.notation = null;
+		}
+		if (!node.icon && onlyOneInstance.icon) node.icon = onlyOneInstance.icon;
+	}
+	return nodesMap;
+}
+function applyDeploymentViewRuleStyles(rules, nodes) {
+	for (const rule of rules) {
+		if (!isViewRuleStyle(rule) || rule.targets.length === 0) continue;
+		applyViewRuleStyle(rule, t$8(rule.targets.map(deploymentExpressionToPredicate)), nodes);
+	}
+	return nodes;
+}
+
+//#endregion
+//#region src/compute-view/deployment-view/clean-connections.ts
+function findCrossBoundarySameSourceOrTarget(connections) {
+	const groupedByRelation = new import_default_map.default(() => []);
+	for (const conn of connections) for (const relation of conn.relations.model) groupedByRelation.get(relation).push(conn);
+	const excludedRelations = new import_default_map.default(() => /* @__PURE__ */ new Set());
+	for (const [relation, sameRelationGroup] of groupedByRelation) {
+		if (!t$16(sameRelationGroup, 2)) continue;
+		t$3(sameRelationGroup, t$17((conn) => [{
+			group: `$source-${conn.source.id}`,
+			conn
+		}, {
+			group: `$target-${conn.target.id}`,
+			conn
+		}]), t$18(e$6("group")), t$19(), n(t$16(2)), t$6(t$20(t$4(e$6("conn")), sortConnectionsByBoundaryHierarchy("desc"), t$10((conn, i, all) => i === 0 || conn.boundary === all[i - 1].boundary), t$6((conn) => {
+			excludedRelations.get(conn).add(relation);
+		}))));
+	}
+	return excludedRelations;
+}
+/**
+* Identifies and processes cross-boundary connections in a deployment diagram.
+* This function analyzes connections between nodes and removes redundant relations
+* when multiple connections exist between the same elements across different boundaries.
+*
+* The function performs the following:
+* 1. Groups connections by their relationship type
+* 2. For each relationship group, identifies connections that:
+*    - Share the same source
+*    - Share the same target
+* 3. When multiple connections are found in the same group, keeps only the most specific
+*    (deepest in hierarchy) connection and removes the relationship from others
+*
+* @param connections - The input collection of deployment connections to analyze
+* @returns connections with redundant cross-boundary relationships
+*/
+function findCrossBoundaryConnections(connections) {
+	connections = mergeConnections(connections);
+	const excludedRelations = findCrossBoundarySameSourceOrTarget(connections);
+	for (const c of connections) {
+		const { source, target } = c;
+		const connectionModelRelations = c.relations.model;
+		if (source.isDeploymentNode() !== target.isDeploymentNode()) {
+			const node = source.isDeploymentNode() ? source : c.target;
+			invariant(node.isDeploymentNode());
+			const toExclude = intersection(connectionModelRelations, node.internalModelRelationships());
+			for (const relation of toExclude) excludedRelations.get(c).add(relation);
+			continue;
+		}
+		if (source.isDeploymentNode() && target.isDeploymentNode()) {
+			const toExclude = union(intersection(c.relations.model, source.internalModelRelationships()), intersection(c.relations.model, target.internalModelRelationships()));
+			for (const relation of toExclude) excludedRelations.get(c).add(relation);
+		}
+	}
+	return t$3(excludedRelations.entries(), imap(([c, excluded]) => c.update({
+		model: excluded,
+		deployment: null
+	})), toArray());
+}
+/**
+* Cleans connections that cross boundaries by removing overlapping parts.
+* @example
+* ```ts
+* const connections = getConnections();
+* const cleanedConnections = cleanCrossBoundary(connections);
+* ```
+*/
+function cleanCrossBoundary(connections) {
+	return differenceConnections(connections, findCrossBoundaryConnections(connections));
+}
+/**
+* Identifies and returns redundant connections in a deployment view.
+* A connection is considered redundant if its relationships are already implied
+* through other connections
+*
+* @returns Array of redundant connections that can be safely removed
+*/
+function findRedundantConnections$1(connections) {
+	return t$3(connections, mergeConnections, t$12((redundants, connection) => {
+		const { source, target, relations } = connection;
+		if (source.isInstance() && target.isInstance()) return redundants;
+		let redundantAccum = RelationshipsAccum.empty();
+		if (source.isDeploymentNode() && target.isDeploymentNode()) {
+			const [reversed] = findConnection$1(target, source, "directed");
+			if (reversed) redundantAccum = relations.intersect(reversed.relations);
+		}
+		for (const c of connections) if (isNestedConnection(c, connection)) redundantAccum = redundantAccum.union(relations.intersect(c.relations));
+		if (redundantAccum.nonEmpty) redundants.push(new DeploymentConnectionModel(source, target, redundantAccum));
+		return redundants;
+	}, []));
+}
+/**
+* Remove relationships from connection model, that are already included in the connections between descendants.
+* In other words - if there is same connection down the hierarchy.
+*
+* @returns New connection without redundant relationships
+*          Connection may be empty if all relationships are redundant, in this case it should be removed
+*/
+function cleanRedundantRelationships(connections) {
+	return differenceConnections(connections, findRedundantConnections$1(connections));
+}
+
+//#endregion
+//#region src/compute-view/deployment-view/stages/stage-include.ts
+var StageInclude = class extends AbstractStageInclude {
+	/**
+	* Connects elements with existing ones in the memory
+	*/
+	connectWithExisting(elements, direction = "both") {
+		const before = this._connections.length;
+		const hasChanged = () => this._connections.length > before;
+		if (!isIterable(elements)) {
+			if (direction === "in" || direction === "both") for (const el of this.memory.elements) this.addConnections(findConnection$1(el, elements, "directed"));
+			if (direction === "out" || direction === "both") this.addConnections(findConnectionsBetween$1(elements, this.memory.elements, "directed"));
+			return hasChanged();
+		}
+		const targets = [...elements];
+		if (direction === "in" || direction === "both") for (const el of this.memory.elements) this.addConnections(findConnectionsBetween$1(el, targets, "directed"));
+		if (direction === "out" || direction === "both") for (const el of targets) this.addConnections(findConnectionsBetween$1(el, this.memory.elements, "directed"));
+		return hasChanged();
+	}
+	processConnections(connections) {
+		const clean = t$3(connections, cleanCrossBoundary, cleanRedundantRelationships);
+		t$3(clean, t$6(({ source, target, boundary }) => {
+			t$3(t$9([...toArray(source.ancestors()).reverse(), source], [...toArray(target.ancestors()).reverse(), target]), t$10(([sourceAncestor, targetAncestor]) => sourceAncestor === targetAncestor), n$1(1), t$6(([sourceAncestor, targetAncestor]) => {
+				if (source === sourceAncestor && target === targetAncestor) {
+					this.addImplicit(boundary);
+					return;
+				}
+				if (sourceAncestor !== source && sourceAncestor.isDeploymentNode() && !sourceAncestor.onlyOneInstance()) this.addImplicit(sourceAncestor);
+				if (targetAncestor !== target && targetAncestor.isDeploymentNode() && !targetAncestor.onlyOneInstance()) this.addImplicit(targetAncestor);
+			}));
+		}));
+		return clean;
+	}
+};
+
+//#endregion
+//#region src/compute-view/deployment-view/memory/memory.ts
+var Memory = class Memory extends AbstractMemory {
+	static empty() {
+		return new Memory({
+			elements: /* @__PURE__ */ new Set(),
+			explicits: /* @__PURE__ */ new Set(),
+			final: /* @__PURE__ */ new Set(),
+			connections: []
+		});
+	}
+	stageInclude(expr) {
+		return new StageInclude(this, expr);
+	}
+	stageExclude(expr) {
+		return new StageExclude$1(this, expr);
+	}
+	mutableState() {
+		return {
+			elements: new Set(this.state.elements),
+			explicits: new Set(this.state.explicits),
+			final: new Set(this.state.final),
+			connections: [...this.state.connections]
+		};
+	}
+	update(newstate) {
+		return new Memory({
+			...this.state,
+			...newstate
+		});
+	}
+	equals(other) {
+		return other instanceof Memory && t$13(this.state, other.state);
+	}
+	diff(state) {
+		return {
+			added: {
+				elements: toArray(difference(state.elements, this.elements)),
+				explicits: toArray(difference(state.explicits, this.explicits)),
+				final: toArray(difference(state.final, this.final)),
+				connections: toArray(differenceConnections(state.connections, this.connections))
+			},
+			removed: {
+				elements: toArray(difference(this.elements, state.elements)),
+				explicits: toArray(difference(this.explicits, state.explicits)),
+				final: toArray(difference(this.final, state.final)),
+				connections: differenceConnections(this.connections, state.connections)
+			}
+		};
+	}
+	toString() {
+		return [
+			"final:",
+			...[...this.final].map((e) => "  " + e.id),
+			"connections:",
+			...this.connections.map((c) => "  " + c.expression)
+		].join("\n");
+	}
+	[customInspectSymbol](_depth, _inspectOptions, _inspect) {
+		return this.toString();
+	}
+};
+
+//#endregion
+//#region src/compute-view/deployment-view/predicates/deploymentRefs-where.ts
+const WhereDeploymentRefPredicate = {
+	include: ({ expr, model, memory, stage }) => {
+		const where = whereOperatorAsPredicate(expr.where.condition);
+		return predicateToPatch("include", {
+			expr: expr.where.expr,
+			model,
+			stage,
+			memory,
+			where
+		});
+	},
+	exclude: ({ expr, model, memory, stage }) => {
+		const where = whereOperatorAsPredicate(expr.where.condition);
+		return predicateToPatch("exclude", {
+			expr: expr.where.expr,
+			model,
+			stage,
+			memory,
+			where
+		});
+	}
+};
+
+//#endregion
+//#region src/compute-view/deployment-view/predicates/relation-incoming.ts
+const IncomingRelationPredicate = {
+	include: ({ expr, model, memory, stage, where }) => {
+		const sources = [...memory.elements];
+		if (FqnExpr.isWildcard(expr.incoming)) {
+			for (const source of sources) {
+				if (source.allOutgoing.isEmpty) continue;
+				const toInclude = applyPredicate(findConnectionsBetween$1(source, [...resolveAscendingSiblings(source)], "directed"), where);
+				stage.addConnections(toInclude);
+			}
+			return stage;
+		}
+		invariant(FqnExpr.isDeploymentRef(expr.incoming), "Only deployment refs are supported in include");
+		const targets = resolveElements$1(model, expr.incoming);
+		for (const source of sources) {
+			const toInclude = applyPredicate(findConnectionsBetween$1(source, targets, "directed"), where);
+			stage.addConnections(toInclude);
+		}
+		return stage;
+	},
+	exclude: ({ expr, model, memory, stage, where }) => {
+		if (FqnExpr.isElementTagExpr(expr.incoming) || FqnExpr.isElementKindExpr(expr.incoming)) throw new Error("element kind and tag expressions are not supported in exclude");
+		if (FqnExpr.isModelRef(expr.incoming)) return excludeModelRelations(resolveAllImcomingRelations(model, expr.incoming), {
+			stage,
+			memory
+		}, where);
+		if (FqnExpr.isWildcard(expr.incoming)) return stage;
+		const isIncoming = filterIncomingConnections(resolveElements$1(model, expr.incoming));
+		const toExclude = t$3(memory.connections, n(isIncoming), applyPredicate(where));
+		stage.excludeConnections(toExclude);
+		return stage;
+	}
+};
+function filterIncomingConnections(targets) {
+	return t$8(targets.map((target) => {
+		const satisfies = (el) => el === target || isAncestor(target, el);
+		return (connection) => {
+			return !satisfies(connection.source) && satisfies(connection.target);
+		};
+	}));
+}
+function resolveAllImcomingRelations(model, moodelRef) {
+	const targets = resolveModelElements(model, moodelRef);
+	return new Set(targets.flatMap((e) => [...e.allIncoming]));
+}
+
+//#endregion
+//#region src/compute-view/deployment-view/predicates/relation-outgoing.ts
+const OutgoingRelationPredicate = {
+	include: ({ expr, model, memory, stage, where }) => {
+		const targets = [...memory.elements];
+		if (FqnExpr.isWildcard(expr.outgoing)) {
+			for (const target of targets) {
+				if (target.allIncoming.isEmpty) continue;
+				for (const source of resolveAscendingSiblings(target)) {
+					const toInclude = applyPredicate(findConnection$1(source, target, "directed"), where);
+					stage.addConnections(toInclude);
+				}
+			}
+			return stage;
+		}
+		invariant(FqnExpr.isDeploymentRef(expr.outgoing), "Only deployment refs are supported in include");
+		const sources = resolveElements$1(model, expr.outgoing);
+		for (const source of sources) {
+			const toInclude = applyPredicate(findConnectionsBetween$1(source, targets, "directed"), where);
+			stage.addConnections(toInclude);
+		}
+		return stage;
+	},
+	exclude: ({ expr, model, memory, stage, where }) => {
+		if (FqnExpr.isElementTagExpr(expr.outgoing) || FqnExpr.isElementKindExpr(expr.outgoing)) throw new Error("element kind and tag expressions are not supported in exclude");
+		if (FqnExpr.isModelRef(expr.outgoing)) return excludeModelRelations(resolveAllOutgoingRelations(model, expr.outgoing), {
+			stage,
+			memory
+		}, where);
+		if (FqnExpr.isWildcard(expr.outgoing)) return stage;
+		const isOutgoing = filterOutgoingConnections(resolveElements$1(model, expr.outgoing));
+		const toExclude = t$3(memory.connections, n(isOutgoing), applyPredicate(where));
+		stage.excludeConnections(toExclude);
+		return stage;
+	}
+};
+function filterOutgoingConnections(sources) {
+	return t$8(sources.map((source) => {
+		const satisfies = (el) => el === source || isAncestor(source, el);
+		return (connection) => {
+			return satisfies(connection.source) && !satisfies(connection.target);
+		};
+	}));
+}
+function resolveAllOutgoingRelations(model, moodelRef) {
+	const targets = resolveModelElements(model, moodelRef);
+	return new Set(targets.flatMap((e) => [...e.allOutgoing]));
+}
+
+//#endregion
+//#region src/compute-view/deployment-view/predicates/relation-direct.ts
+const DirectRelationPredicate = {
+	include: ({ expr: { source, target, isBidirectional = false }, model, stage, where }) => {
+		if (FqnExpr.isElementTagExpr(source) || FqnExpr.isElementKindExpr(source)) throw new Error("element kind and tag expressions are not supported in include");
+		if (FqnExpr.isElementTagExpr(target) || FqnExpr.isElementKindExpr(target)) throw new Error("element kind and tag expressions are not supported in include");
+		invariant(!FqnExpr.isModelRef(source), "Invalid source model ref in direct relation");
+		invariant(!FqnExpr.isModelRef(target), "Invalid target model ref in direct relation");
+		const sourceIsWildcard = FqnExpr.isWildcard(source);
+		const targetIsWildcard = FqnExpr.isWildcard(target);
+		const dir = isBidirectional ? "both" : "directed";
+		let connections;
+		switch (true) {
+			case sourceIsWildcard && targetIsWildcard:
+				connections = t$3(findConnectionsWithin$1(model.instances()), applyPredicate(where), t$4((c) => {
+					stage.addImplicit(c.boundary);
+					return c;
+				}));
+				break;
+			case !sourceIsWildcard && targetIsWildcard: {
+				const sources = resolveElements$1(model, source);
+				const isSource = filterOutgoingConnections(sources);
+				let postFilter = isSource;
+				if (isBidirectional) {
+					const isTarget = filterIncomingConnections(sources);
+					postFilter = (c) => isSource(c) !== isTarget(c);
+				}
+				connections = t$3(sources, t$17((source) => {
+					return findConnectionsBetween$1(source, resolveAscendingSiblings(source), dir);
+				}), n(postFilter), applyPredicate(where));
+				break;
+			}
+			case sourceIsWildcard && !targetIsWildcard: {
+				const targets = resolveElements$1(model, target);
+				const isTarget = filterIncomingConnections(targets);
+				let postFilter = isTarget;
+				if (isBidirectional) {
+					const isSource = filterOutgoingConnections(targets);
+					postFilter = (c) => isSource(c) !== isTarget(c);
+				}
+				connections = t$3(targets, t$17((target) => {
+					return [...resolveAscendingSiblings(target)].flatMap((source) => findConnection$1(source, target, dir));
+				}), n(postFilter), applyPredicate(where));
+				break;
+			}
+			default: {
+				invariant(!sourceIsWildcard, "Inferrence failed - source should be a deployment ref");
+				invariant(!targetIsWildcard, "Inferrence failed - target should be a deployment ref");
+				const sources = resolveElements$1(model, source);
+				const targets = resolveElements$1(model, target);
+				const isSource = filterOutgoingConnections(sources);
+				const isTarget = filterIncomingConnections(targets);
+				connections = t$3(sources, t$17((s) => findConnectionsBetween$1(s, targets, dir)), n((c) => isSource(c) && isTarget(c)), applyPredicate(where));
+			}
+		}
+		stage.addConnections(connections);
+		if (FqnExpr.isDeploymentRef(source) && e$7(source.selector)) stage.addImplicit(model.element(source.ref.deployment));
+		if (FqnExpr.isDeploymentRef(target) && e$7(target.selector)) stage.addImplicit(model.element(target.ref.deployment));
+		return stage;
+	},
+	exclude: ({ expr, model, memory, stage, where }) => {
+		const isTarget = deploymentExpressionToPredicate(expr.target);
+		const isSource = deploymentExpressionToPredicate(expr.source);
+		let modelRelationsToExclude;
+		switch (true) {
+			case FqnExpr.isWildcard(expr.source) && FqnExpr.isWildcard(expr.target):
+				stage.excludeConnections(applyPredicate(memory.connections, where));
+				return stage;
+			case FqnExpr.isModelRef(expr.source) && FqnExpr.isModelRef(expr.target):
+				modelRelationsToExclude = resolveRelationsBetweenModelElements({
+					source: expr.source,
+					target: expr.target,
+					expr,
+					model
+				});
+				return excludeModelRelations(modelRelationsToExclude, {
+					stage,
+					memory
+				}, where);
+			case FqnExpr.isModelRef(expr.source) && FqnExpr.isWildcard(expr.target):
+				modelRelationsToExclude = resolveAllOutgoingRelations(model, expr.source);
+				return excludeModelRelations(modelRelationsToExclude, {
+					stage,
+					memory
+				}, where);
+			case FqnExpr.isModelRef(expr.source):
+				modelRelationsToExclude = resolveAllOutgoingRelations(model, expr.source);
+				return excludeModelRelations(modelRelationsToExclude, {
+					stage,
+					memory
+				}, where, (c) => isTarget(c.target));
+			case FqnExpr.isModelRef(expr.target):
+				modelRelationsToExclude = resolveAllImcomingRelations(model, expr.target);
+				return excludeModelRelations(modelRelationsToExclude, {
+					stage,
+					memory
+				}, where, (c) => isSource(c.source));
+			default:
+				const satisfies = (connection) => {
+					return isSource(connection.source) && isTarget(connection.target) || expr.isBidirectional === true && isSource(connection.target) && isTarget(connection.source);
+				};
+				const deploymentRelationsToExclude = t$3(memory.connections, n(satisfies), applyPredicate(where));
+				if (deploymentRelationsToExclude.length === 0) return stage;
+				stage.excludeConnections(deploymentRelationsToExclude);
+				return stage;
+		}
+	}
+};
+function resolveRelationsBetweenModelElements({ source, target, expr, model }) {
+	const sources = resolveModelElements(model, source);
+	const targets = resolveModelElements(model, target);
+	const dir = expr.isBidirectional ? "both" : "directed";
+	const modelConnections = [];
+	for (const source of sources) modelConnections.push(...findConnectionsBetween$3(source, targets, dir));
+	return new Set(modelConnections.flatMap((c) => [...c.relations]));
+}
+
+//#endregion
+//#region src/compute-view/deployment-view/predicates/relation-in-out.ts
+const InOutRelationPredicate$1 = {
+	include: ({ expr, model, memory, stage, where }) => {
+		const sources = [...memory.elements];
+		if (FqnExpr.isWildcard(expr.inout)) {
+			for (const source of sources) {
+				const toInclude = matchConnections(findConnectionsBetween$1(source, [...resolveAscendingSiblings(source)], "both"), where);
+				stage.addConnections(toInclude);
+			}
+			return stage;
+		}
+		invariant(FqnExpr.isDeploymentRef(expr.inout), "Only deployment refs are supported in include");
+		const targets = resolveElements$1(model, expr.inout);
+		for (const source of sources) {
+			const toInclude = matchConnections(findConnectionsBetween$1(source, targets, "both"), where);
+			stage.addConnections(toInclude);
+		}
+		return stage;
+	},
+	exclude: ({ expr, model, memory, stage, where }) => {
+		if (FqnExpr.isElementTagExpr(expr.inout) || FqnExpr.isElementKindExpr(expr.inout)) throw new Error("element kind and tag expressions are not supported in exclude");
+		if (FqnExpr.isModelRef(expr.inout)) {
+			const elements = resolveModelElements(model, expr.inout);
+			if (elements.length === 0) return stage;
+			return excludeModelRelations(union(/* @__PURE__ */ new Set(), ...elements.flatMap((e) => [e.allIncoming, e.allOutgoing])), {
+				stage,
+				memory
+			}, where);
+		}
+		if (FqnExpr.isWildcard(expr.inout)) return stage;
+		const elements = resolveElements$1(model, expr.inout);
+		const isIncoming = filterIncomingConnections(elements);
+		const isOutgoing = filterOutgoingConnections(elements);
+		const toExclude = t$3(memory.connections, n((c) => isIncoming(c) !== isOutgoing(c)), applyPredicate(where));
+		stage.excludeConnections(toExclude);
+		return stage;
+	}
+};
+
+//#endregion
+//#region src/compute-view/deployment-view/predicates/relation-where.ts
+const WhereRelationPredicate = {
+	include: ({ expr, model, memory, stage }) => {
+		const where = whereOperatorAsPredicate(expr.where.condition);
+		return predicateToPatch("include", {
+			expr: expr.where.expr,
+			model,
+			stage,
+			memory,
+			where
+		});
+	},
+	exclude: ({ expr, model, memory, stage }) => {
+		const where = whereOperatorAsPredicate(expr.where.condition);
+		return predicateToPatch("exclude", {
+			expr: expr.where.expr,
+			model,
+			stage,
+			memory,
+			where
+		});
+	}
+};
+
+//#endregion
+//#region src/compute-view/deployment-view/predicates/wildcard.ts
+const WildcardPredicate$1 = {
+	include: ({ model, stage, where }) => {
+		const children = [];
+		const rootElements = t$3([...model.roots()], applyElementPredicate(where), t$4((root) => {
+			if (!root.onlyOneInstance()) children.push(...root.children());
+			return root;
+		}));
+		stage.addExplicit(rootElements);
+		if (children.length > 1) stage.addConnections(findConnectionsWithin$1([...rootElements, ...children]));
+		return stage;
+	},
+	exclude: ({ stage, memory, where }) => {
+		const elementsToExclude = t$3([...memory.elements], applyElementPredicate(where));
+		stage.exclude(elementsToExclude);
+		return stage;
+	}
+};
+
+//#endregion
+//#region src/compute-view/deployment-view/predicates/utils.ts
+/**
+* Builds a patch object from an expression
+*/
+function predicateToPatch(op, { expr, where, ...ctx }) {
+	switch (true) {
+		case FqnExpr.isElementTagExpr(expr):
+		case FqnExpr.isElementKindExpr(expr): throw new Error("element kind and tag expressions are not supported in deployment view rules");
+		case RelationExpr.isCustom(expr):
+		case FqnExpr.isCustom(expr):
+		case FqnExpr.isModelRef(expr): return;
+		case FqnExpr.isWhere(expr): return WhereDeploymentRefPredicate[op]({
+			...ctx,
+			expr,
+			where
+		});
+		case RelationExpr.isWhere(expr): return WhereRelationPredicate[op]({
+			...ctx,
+			expr,
+			where
+		});
+		case FqnExpr.isDeploymentRef(expr): return DeploymentRefPredicate[op]({
+			...ctx,
+			expr,
+			where
+		});
+		case FqnExpr.isWildcard(expr): return WildcardPredicate$1[op]({
+			...ctx,
+			expr,
+			where
+		});
+		case RelationExpr.isDirect(expr): return DirectRelationPredicate[op]({
+			...ctx,
+			expr,
+			where
+		});
+		case RelationExpr.isInOut(expr): return InOutRelationPredicate$1[op]({
+			...ctx,
+			expr,
+			where
+		});
+		case RelationExpr.isOutgoing(expr): return OutgoingRelationPredicate[op]({
+			...ctx,
+			expr,
+			where
+		});
+		case RelationExpr.isIncoming(expr): return IncomingRelationPredicate[op]({
+			...ctx,
+			expr,
+			where
+		});
+		default: nonexhaustive(expr);
+	}
+}
+function excludeModelRelations(relationsToExclude, { stage, memory }, where, filterConnections = () => true) {
+	if (relationsToExclude.size === 0) return stage;
+	const toExclude = t$3(memory.connections, n((c) => filterConnections(c)), n((c) => hasIntersection(c.relations.model, relationsToExclude)), t$4((c) => c.update({
+		deployment: null,
+		model: intersection(c.relations.model, relationsToExclude)
+	})), applyPredicate(where), n((c) => c.nonEmpty()));
+	if (toExclude.length === 0) return stage;
+	return stage.excludeConnections(toExclude);
+}
+function matchConnection(c, where) {
+	return applyPredicate(c, where).nonEmpty();
+}
+function applyPredicate(...args) {
+	if (args.length === 1) return (x) => applyPredicate(x, args[0]);
+	const [c, where] = args;
+	if (where === null) return c;
+	if (e$8(c)) return c.map((x) => applyPredicate(x, where)).filter((x) => x.nonEmpty());
+	return c.update({
+		model: new Set([...c.relations.model.values()].filter((r) => where(toFilterableRelation(c)(r)))),
+		deployment: new Set([...c.relations.deployment.values()].filter((r) => where(toFilterableRelation(c)(r))))
+	});
+}
+function applyElementPredicate(...args) {
+	if (args.length === 1) return (x) => applyElementPredicate(x, args[0]);
+	const [c, where] = args;
+	if (e$8(c)) return c.filter((x) => applyElementPredicate(x, where));
+	return where?.(toFilterable(c, c)) ?? true;
+}
+function matchConnections(connections, where) {
+	if (!where) return connections;
+	return t$3(connections, n((c) => matchConnection(c, where)));
+}
+/**
+* Builds filterable presentation for relation endpoint. Enriches model properties with deployment properties when needed.
+* @param relationEndpoint Endpoint for which to build presentation
+* @param connectionEndpoint Endpoint of connection which was build from the relation.
+* @returns Presentation of the endpoint for usage in predicates
+*/
+function toFilterable(relationEndpoint, connectionEndpoint) {
+	if (isElementModel(relationEndpoint)) {
+		const deployedInstance = isDeploymentElementModel(connectionEndpoint) && isDeployedInstanceModel(connectionEndpoint) ? connectionEndpoint : null;
+		return {
+			kind: relationEndpoint.kind,
+			tags: [...relationEndpoint.tags, ...deployedInstance?.tags ?? []]
+		};
+	}
+	if (isNestedElementOfDeployedInstanceModel(relationEndpoint)) return t$11(relationEndpoint.element, ["tags", "kind"]);
+	if (isDeployedInstanceModel(relationEndpoint)) return {
+		kind: relationEndpoint.element.kind,
+		tags: [...relationEndpoint.tags, ...relationEndpoint.element.tags]
+	};
+	if (isDeploymentNodeModel(relationEndpoint)) return t$11(relationEndpoint, ["tags", "kind"]);
+	nonexhaustive(relationEndpoint);
+}
+function toFilterableRelation(c) {
+	return (relation) => ({
+		tags: relation.tags,
+		kind: relation.kind,
+		source: toFilterable(relation.source, c.source),
+		target: toFilterable(relation.target, c.target)
+	});
+}
+function resolveAscendingSiblings(element) {
+	const siblings = /* @__PURE__ */ new Set();
+	for (let sibling of element.descendingSiblings()) siblings.add(sibling);
+	return siblings;
+}
+
+//#endregion
+//#region src/compute-view/deployment-view/predicates/deploymentRefs.ts
+const DeploymentRefPredicate = {
+	include: (ctx) => {
+		const { expr, where } = ctx;
+		const el = ctx.model.element(expr.ref.deployment);
+		if (isDeployedInstanceModel(el)) {
+			if (applyElementPredicate(el, where)) {
+				ctx.stage.addExplicit(el);
+				ctx.stage.connectWithExisting(el);
+			}
+			return ctx.stage;
+		}
+		switch (true) {
+			case expr.selector === "expanded":
+				includeDeployedNodeWithExpanded(el, ctx);
+				break;
+			case expr.selector === "children":
+				includeDeployedNodeChildren(el, ctx);
+				break;
+			case expr.selector === "descendants":
+				includeDeployedNodeDescendants(el, ctx);
+				break;
+			default: if (applyElementPredicate(el, where)) {
+				ctx.stage.addExplicit(el);
+				ctx.stage.connectWithExisting(el);
+			}
+		}
+		return ctx.stage;
+	},
+	exclude: ({ expr, stage, memory, where }) => {
+		const exprPredicate = deploymentExpressionToPredicate(expr);
+		const toExclude = t$3([...memory.elements], n(exprPredicate), applyElementPredicate(where));
+		stage.exclude(toExclude);
+		return stage;
+	}
+};
+/**
+* include node.*
+*/
+function includeDeployedNodeChildren(node, { stage, where }) {
+	const children = applyElementPredicate([...node.children()], where);
+	if (children.length === 0) return;
+	stage.addImplicit(node);
+	stage.addConnections(findConnectionsWithin$1(children));
+	stage.connectWithExisting(children);
+	stage.addExplicit(children);
+}
+/**
+* include node._
+*/
+function includeDeployedNodeWithExpanded(node, { memory, stage, where }) {
+	stage.addImplicit(node);
+	stage.connectWithExisting(node);
+	const children = applyElementPredicate([...node.children()], where);
+	let hasConnectionsWithVisible = false;
+	for (const child of children) if (findConnectionsBetween$1(child, memory.elements).length > 0) {
+		hasConnectionsWithVisible = true;
+		break;
+	}
+	if (hasConnectionsWithVisible) {
+		stage.connectWithExisting(children, "in");
+		stage.addConnections(findConnectionsWithin$1(children));
+		stage.connectWithExisting(children, "out");
+	}
+	stage.addImplicit(children);
+	if (stage.connections.length > 0) stage.addExplicit(node);
+}
+/**
+* include node.**
+*/
+function includeDeployedNodeDescendants(node, { stage, where }) {
+	const dfs = (node) => {
+		const children = [];
+		for (const child of node.children()) {
+			if (child.isDeploymentNode()) children.push(...dfs(child));
+			if (applyElementPredicate(child, where)) children.push(child);
+		}
+		stage.connectWithExisting(children, "in");
+		stage.addConnections(findConnectionsWithin$1(children));
+		stage.addImplicit(children);
+		return children;
+	};
+	const descendants = dfs(node);
+	if (descendants.length === 0) return;
+	stage.connectWithExisting(descendants, "out");
+	const allConnected = findConnectedElements(stage);
+	t$3(descendants, n((desc) => allConnected.has(desc)), t$6((desc) => stage.addExplicit(desc)));
+}
+function findConnectedElements(stage) {
+	return t$3(stage.mergedConnections(), cleanCrossBoundary, cleanRedundantRelationships, t$12((acc, c) => {
+		acc.add(c.source);
+		acc.add(c.target);
+		return acc;
+	}, /* @__PURE__ */ new Set()));
+}
+
+//#endregion
+//#region src/compute-view/deployment-view/stages/stage-final.ts
+/**
+* This patch:
+* 1. Keeps connections between leafs or having direct deployment relations
+* 2. Removes cross-boundary model relations, that already exist inside boundaries
+*    (e.g. prefer relations inside same deployment node over relations between nodes)
+* 3. Removes implicit connections between elements, if their descendants have same connection
+*/
+var StageFinal$1 = class StageFinal$1 {
+	static for(memory) {
+		return new StageFinal$1(memory);
+	}
+	constructor(memory) {
+		this.memory = memory;
+	}
+	step1CleanConnections(memory) {
+		if (memory.connections.length < 2) return memory;
+		const connections = t$3(memory.connections, cleanCrossBoundary, cleanRedundantRelationships);
+		const connectionsToExclude = differenceConnections(memory.connections, connections);
+		if (connectionsToExclude.length === 0) return memory;
+		const stage = memory.stageExclude({});
+		stage.excludeConnections(connectionsToExclude, true);
+		return stage.commit();
+	}
+	step2ProcessImplicits(memory) {
+		const implicits = union(this.memory.elements, memory.elements);
+		const final = union(memory.final, this.memory.explicits);
+		const groupedByRelation = new import_default_map.default(() => /* @__PURE__ */ new Set());
+		for (const conn of memory.connections) if (conn.boundary) for (const relation of conn.relations.model) groupedByRelation.get(relation).add(conn.boundary);
+		for (const [_, boundaries] of groupedByRelation) {
+			if (boundaries.size < 2) continue;
+			for (const boundary of boundaries) if (implicits.delete(boundary)) final.add(boundary);
+		}
+		const snapshot = new Set(final);
+		const isFinalOrHasIncludedDescendant = (el) => {
+			for (const final of snapshot) if (el === final || isAncestor(el, final)) return true;
+			return false;
+		};
+		t$3(difference(implicits, snapshot), ifilter((e) => e.isDeploymentNode()), toArray(), sortByFqnHierarchically, t$6((el) => {
+			const childrensToWrap = [...el.children()].filter(isFinalOrHasIncludedDescendant).length;
+			if (childrensToWrap >= 2) {
+				final.add(el);
+				return;
+			}
+			if (childrensToWrap === 1 && isome(el.siblings(), isFinalOrHasIncludedDescendant)) final.add(el);
+		}));
+		return memory.update({ final });
+	}
+	step3ProcessBoundaries(memory) {
+		const boundaries = /* @__PURE__ */ new Set();
+		for (const conn of memory.connections) if (conn.boundary) boundaries.add(conn.boundary);
+		const tree = treeFromMemoryState(memory, "final");
+		const stage = memory.stageExclude({});
+		const isRemovable = (el) => !(boundaries.has(el) || memory.explicits.has(el) || tree.hasInOut(el) || tree.root.has(el));
+		const singleRoot = t$14([...tree.root]);
+		if (singleRoot && !memory.explicits.has(singleRoot)) stage.exclude(singleRoot);
+		for (const el of memory.final) {
+			const singleChild = t$14(tree.children(el));
+			if (singleChild && !tree.hasInOut(singleChild) && isRemovable(el)) stage.exclude(el);
+		}
+		if (stage.isDirty()) return stage.commit();
+		return memory;
+	}
+	commit() {
+		const step1 = this.step1CleanConnections(this.memory);
+		const step2 = this.step2ProcessImplicits(step1);
+		return this.step3ProcessBoundaries(step2);
+	}
+};
+
+//#endregion
+//#region src/compute-view/deployment-view/compute.ts
+function processPredicates$1(model, rules) {
+	let memory = Memory.empty();
+	for (const rule of rules) if (isViewRulePredicate(rule)) {
+		const op = "include" in rule ? "include" : "exclude";
+		const exprs = rule.include ?? rule.exclude;
+		for (const expr of exprs) {
+			let stage = op === "include" ? memory.stageInclude(expr) : memory.stageExclude(expr);
+			stage = predicateToPatch(op, {
+				expr,
+				model,
+				stage,
+				memory,
+				where: null
+			}) ?? stage;
+			memory = stage.commit();
+		}
+	}
+	return StageFinal$1.for(memory).commit();
+}
+function computeDeploymentView(likec4model, { docUri: _docUri, rules, ...view }) {
+	const memory = processPredicates$1(likec4model.deployment, rules);
+	const nodesMap = buildNodes$1(likec4model, memory);
+	const computedEdges = toComputedEdges$1(memory.connections);
+	linkNodesWithEdges(nodesMap, computedEdges);
+	const sorted = topologicalSort({
+		nodes: nodesMap,
+		edges: computedEdges
+	});
+	const nodes = applyDeploymentViewRuleStyles(rules, sorted.nodes);
+	const autoLayoutRule = t$21(rules, isViewRuleAutoLayout);
+	const elementNotations = buildElementNotations(nodes);
+	return calcViewLayoutHash({
+		...view,
+		[_stage]: "computed",
+		[_type]: "deployment",
+		autoLayout: {
+			direction: autoLayoutRule?.direction ?? "TB",
+			...autoLayoutRule?.nodeSep && { nodeSep: autoLayoutRule.nodeSep },
+			...autoLayoutRule?.rankSep && { rankSep: autoLayoutRule.rankSep }
+		},
+		edges: sorted.edges,
+		nodes: t$4(nodes, (n) => {
+			if (n.icon === "none") delete n.icon;
+			return n;
+		}),
+		...elementNotations.length > 0 && { notation: { nodes: elementNotations } }
+	});
+}
+
+//#endregion
+//#region src/compute-view/utils/applyCustomElementProperties.ts
+function flattenGroupRules(guard) {
+	return (rule) => {
+		if (isViewRuleGroup(rule)) return rule.groupRules.flatMap(flattenGroupRules(guard));
+		if (isViewRulePredicate(rule)) return "include" in rule ? rule.include.filter(guard) : [];
+		return [];
+	};
+}
+function applyCustomElementProperties(_rules, _nodes) {
+	const rules = _rules.flatMap(flattenGroupRules(ModelFqnExpr.isCustom));
+	if (rules.length === 0) return _nodes;
+	const nodes = [..._nodes];
+	for (const { custom: { expr, ...props } } of rules) {
+		const { border, opacity, multiple, iconColor, iconSize, iconPosition, padding, size, textSize, description, ...rest } = t$22(props, e$5);
+		const style = exact({
+			border,
+			opacity,
+			multiple,
+			iconColor,
+			iconSize,
+			iconPosition,
+			padding,
+			size,
+			textSize
+		});
+		const styleNotEmpty = !e$2(style);
+		const propsNotEmpty = !e$2(rest);
+		const satisfies = elementExprToPredicate(expr);
+		nodes.forEach((node, i) => {
+			if (isGroupElementKind(node) || !satisfies(node)) return;
+			if (propsNotEmpty) node = {
+				...node,
+				isCustomized: true,
+				...rest
+			};
+			if (description !== void 0) node = {
+				...node,
+				isCustomized: true,
+				description
+			};
+			if (styleNotEmpty) node = {
+				...node,
+				isCustomized: true,
+				style: {
+					...node.style,
+					...style
+				}
+			};
+			nodes[i] = node;
+		});
+	}
+	return nodes;
+}
+
+//#endregion
+//#region src/compute-view/utils/resolve-global-rules.ts
+function resolveGlobalRulesInElementView(rules, globals) {
+	return rules.reduce((acc, rule) => {
+		if (isViewRuleGlobalPredicateRef(rule)) {
+			const globalPredicates = globals.predicates[rule.predicateId];
+			if (e$5(globalPredicates)) return acc;
+			return acc.concat(globalPredicates);
+		}
+		if (isViewRuleGlobalStyle(rule)) {
+			const globalStyles = globals.styles[rule.styleId];
+			if (e$5(globalStyles)) return acc;
+			return acc.concat(globalStyles);
+		}
+		acc.push(rule);
+		return acc;
+	}, []);
+}
+function resolveGlobalRulesInDynamicView(rules, globals) {
+	return rules.reduce((acc, rule) => {
+		if (isViewRuleGlobalPredicateRef(rule)) {
+			const globalPredicates = globals.dynamicPredicates[rule.predicateId];
+			if (e$5(globalPredicates)) return acc;
+			return acc.concat(globalPredicates);
+		}
+		if (isViewRuleGlobalStyle(rule)) {
+			const globalStyles = globals.styles[rule.styleId];
+			if (e$5(globalStyles)) return acc;
+			return acc.concat(globalStyles);
+		}
+		acc.push(rule);
+		return acc;
+	}, []);
+}
+
+//#endregion
+//#region src/compute-view/dynamic-view/utils.ts
+function elementsFromIncludeProperties(model, resolvedRules) {
+	const explicits = /* @__PURE__ */ new Set();
+	for (const rule of resolvedRules) if (isViewRulePredicate(rule)) for (const expr of rule.include) {
+		const satisfies = elementExprToPredicate(expr);
+		for (const e of model.elements()) if (satisfies(e)) explicits.add(e);
+	}
+	return explicits;
+}
+const flattenSteps = (s) => {
+	if (isDynamicStepsParallel(s)) {
+		const heads = [];
+		const tails = [];
+		for (const step of s.__parallel) if (isDynamicStepsSeries(step)) {
+			const [head, ...tail] = step.__series;
+			heads.push(head);
+			tails.push(...tail);
+		} else heads.push(step);
+		return [...heads, ...tails];
+	}
+	if (isDynamicStepsSeries(s)) return [...s.__series];
+	return s;
+};
+function elementsFromSteps(model, steps) {
+	const actors = [];
+	const addActor = (...[source, target]) => {
+		if (!actors.includes(source)) {
+			const indexOfTarget = actors.indexOf(target);
+			if (indexOfTarget > 0) {
+				actors.splice(indexOfTarget, 0, source);
+				return;
+			} else actors.push(source);
+		}
+		if (!actors.includes(target)) actors.push(target);
+	};
+	for (const step of t$17(steps, flattenSteps)) {
+		const source = model.element(step.source);
+		const target = model.element(step.target);
+		let sourceColumn = actors.indexOf(source);
+		let targetColumn = actors.indexOf(target);
+		if (sourceColumn >= 0 && targetColumn >= 0) continue;
+		if (step.isBackward) addActor(target, source);
+		else addActor(source, target);
+	}
+	return new Set(actors);
+}
+function findRelations(source, target, currentViewId) {
+	const relationships = findConnection$3(source, target, "directed").flatMap((r) => [...r.relations]).sort(compareRelations);
+	if (!isNonEmptyArray(relationships)) return {};
+	if (relationships.length === 1) {
+		const relation = relationships[0];
+		return exact({
+			title: relation.title ?? void 0,
+			kind: relation.kind ?? void 0,
+			tags: relation.tags,
+			relations: [relation.id],
+			navigateTo: relation.$relationship.navigateTo,
+			color: relation.$relationship.color,
+			line: relation.$relationship.line,
+			technology: relation.technology ?? void 0,
+			description: relation.$relationship.description ?? void 0
+		});
+	}
+	const alltags = t$3(relationships, t$17((r) => r.tags), n$3());
+	const tags = t$16(alltags, 1) ? alltags : void 0;
+	const relations = t$4(relationships, (r) => r.id);
+	let navigateTo = n$4(relationships).$relationship.navigateTo;
+	if (navigateTo === currentViewId) navigateTo = void 0;
+	if (!navigateTo) navigateTo = t$3(relationships, t$17((r) => r.$relationship.navigateTo && r.$relationship.navigateTo !== currentViewId ? r.$relationship.navigateTo : []), n$3(), t$14());
+	const commonProperties = t$3(relationships, t$12((acc, { title, technology, $relationship: r }) => {
+		e(title) && acc.title.add(title);
+		e(r.color) && acc.color.add(r.color);
+		e(r.line) && acc.line.add(r.line);
+		e(r.kind) && acc.kind.add(r.kind);
+		e(technology) && acc.technology.add(technology);
+		if (e(r.description) && !acc.description.some(t$13(r.description))) acc.description.push(r.description);
+		return acc;
+	}, {
+		kind: /* @__PURE__ */ new Set(),
+		color: /* @__PURE__ */ new Set(),
+		line: /* @__PURE__ */ new Set(),
+		title: /* @__PURE__ */ new Set(),
+		technology: /* @__PURE__ */ new Set(),
+		description: []
+	}));
+	return exact({
+		tags: tags ?? void 0,
+		relations,
+		navigateTo,
+		kind: t$14([...commonProperties.kind]),
+		title: t$14([...commonProperties.title]),
+		color: t$14([...commonProperties.color]),
+		line: t$14([...commonProperties.line]),
+		technology: t$14([...commonProperties.technology]),
+		description: t$14(commonProperties.description)
+	});
+}
+
+//#endregion
+//#region src/compute-view/dynamic-view/compute.ts
+var DynamicViewCompute = class {
+	steps = [];
+	constructor(model, view) {
+		this.model = model;
+		this.view = view;
+	}
+	compute() {
+		const { docUri: _docUri, rules: _rules, steps: viewSteps, ...view } = this.view;
+		const rules = resolveGlobalRulesInDynamicView(_rules, this.model.globals);
+		const explicits = elementsFromIncludeProperties(this.model, rules);
+		const fromSteps = elementsFromSteps(this.model, viewSteps);
+		const actors = t$3(union(intersection(explicits, fromSteps), fromSteps, explicits), toArray(), sortParentsFirst);
+		const compounds = actors.reduce((acc, actor, index, all) => {
+			for (let i = index + 1; i < all.length; i++) {
+				const other = all[i];
+				if (isAncestor(actor, other)) {
+					acc.push(actor);
+					break;
+				}
+			}
+			return acc;
+		}, []);
+		const processStep = (step, stepNum, prefix) => {
+			if (isDynamicStepsSeries(step)) {
+				for (const s of step.__series) stepNum = processStep(s, stepNum, prefix);
+				return stepNum;
+			}
+			const id = prefix ? stepEdgeId(prefix, stepNum) : stepEdgeId(stepNum);
+			const { source: stepSource, target: stepTarget, title: stepTitle, isBackward: _isBackward, navigateTo: stepNavigateTo, notation: _notation, ...rest } = step;
+			const source = this.model.element(stepSource);
+			const sourceColumn = actors.indexOf(source);
+			invariant(sourceColumn >= 0, `Source ${stepSource} not found`);
+			const target = this.model.element(stepTarget);
+			const targetColumn = actors.indexOf(target);
+			invariant(targetColumn >= 0, `Target ${stepTarget} not found`);
+			if (compounds.includes(source) || compounds.includes(target)) console.error(`Step ${source.id} -> ${target.id} because it involves a compound`);
+			const { title, relations, navigateTo: derivedNavigateTo, ...derived } = findRelations(source, target, this.view.id);
+			const navigateTo = e(stepNavigateTo) && stepNavigateTo !== this.view.id ? stepNavigateTo : derivedNavigateTo;
+			const kindTechnology = step.kind && !step.technology ? this.model.specification.relationships[step.kind]?.technology : void 0;
+			this.steps.push(exact({
+				...derived,
+				...rest,
+				...kindTechnology && { technology: kindTechnology },
+				id,
+				source,
+				target,
+				navigateTo,
+				title: stepTitle ?? title,
+				relations: relations ?? [],
+				isBackward: sourceColumn > targetColumn
+			}));
+			return stepNum + 1;
+		};
+		let stepNum = 1;
+		for (const step of viewSteps) {
+			if (isDynamicStepsParallel(step)) {
+				let nestedStepNum = 1;
+				for (const s of step.__parallel) nestedStepNum = processStep(s, nestedStepNum, stepNum);
+				stepNum++;
+				continue;
+			}
+			stepNum = processStep(step, stepNum);
+		}
+		const nodesMap = buildComputedNodes(this.model.$styles, actors.map(elementModelToNodeSource));
+		const defaults = this.model.$styles.defaults.relationship;
+		const edges = this.steps.map(({ id, source, target, relations, title, isBackward, tags, ...step }) => {
+			const sourceNode = nonNullable(nodesMap.get(source.id), `Source node ${source.id} not found`);
+			const targetNode = nonNullable(nodesMap.get(target.id), `Target node ${target.id} not found`);
+			const edge = {
+				id,
+				parent: commonAncestor(source.id, target.id),
+				source: sourceNode.id,
+				target: targetNode.id,
+				label: title ?? null,
+				relations,
+				color: defaults.color,
+				line: defaults.line,
+				head: defaults.arrow,
+				tags: tags ?? [],
+				...step
+			};
+			if (isBackward) edge.dir = "back";
+			while (edge.parent && !nodesMap.has(edge.parent)) edge.parent = parentFqn(edge.parent);
+			sourceNode.outEdges.push(edge.id);
+			targetNode.inEdges.push(edge.id);
+			for (const sourceAncestor of ancestorsFqn(edge.source)) {
+				if (sourceAncestor === edge.parent) break;
+				nodesMap.get(sourceAncestor)?.outEdges.push(edge.id);
+			}
+			for (const targetAncestor of ancestorsFqn(edge.target)) {
+				if (targetAncestor === edge.parent) break;
+				nodesMap.get(targetAncestor)?.inEdges.push(edge.id);
+			}
+			return edge;
+		});
+		const nodes = applyCustomElementProperties(rules, applyViewRuleStyles(rules, actors.map((e) => nonNullable(nodesMap.get(e.id)))));
+		const autoLayoutRule = t$21(rules, isViewRuleAutoLayout);
+		const nodeNotations = buildElementNotations(nodes);
+		return calcViewLayoutHash({
+			...view,
+			[_type]: "dynamic",
+			[_stage]: "computed",
+			variant: view.variant ?? "diagram",
+			autoLayout: {
+				direction: autoLayoutRule?.direction ?? "LR",
+				...autoLayoutRule?.nodeSep && { nodeSep: autoLayoutRule.nodeSep },
+				...autoLayoutRule?.rankSep && { rankSep: autoLayoutRule.rankSep }
+			},
+			nodes: t$4(nodes, (n) => {
+				if (n.icon === "none") delete n.icon;
+				return n;
+			}),
+			edges,
+			...nodeNotations.length > 0 && { notation: { nodes: nodeNotations } }
+		});
+	}
+};
+function computeDynamicView(model, view) {
+	return new DynamicViewCompute(model, view).compute();
+}
+
+//#endregion
+//#region src/compute-view/utils/relationExpressionToPredicates.ts
+function relationExpressionToPredicates(expr) {
+	switch (true) {
+		case ModelRelationExpr.isCustom(expr): return relationExpressionToPredicates(expr.customRelation.expr);
+		case ModelRelationExpr.isWhere(expr): {
+			const predicate = relationExpressionToPredicates(expr.where.expr);
+			const where = whereOperatorAsPredicate(expr.where.condition);
+			return (e) => predicate(e) && where({
+				source: {
+					tags: e.source.tags,
+					kind: e.source.kind
+				},
+				target: {
+					tags: e.target.tags,
+					kind: e.target.kind
+				},
+				...e.tags && { tags: e.tags },
+				...e.kind && { kind: e.kind }
+			});
+		}
+		case ModelRelationExpr.isDirect(expr): {
+			const isSource = elementExprToPredicate(expr.source);
+			const isTarget = elementExprToPredicate(expr.target);
+			return (edge) => {
+				return isSource(edge.source) && isTarget(edge.target) || !!expr.isBidirectional && isSource(edge.target) && isTarget(edge.source);
+			};
+		}
+		case ModelRelationExpr.isInOut(expr): {
+			const isInOut = elementExprToPredicate(expr.inout);
+			return (edge) => isInOut(edge.source) || isInOut(edge.target);
+		}
+		case ModelRelationExpr.isIncoming(expr): {
+			const isTarget = elementExprToPredicate(expr.incoming);
+			return (edge) => isTarget(edge.target);
+		}
+		case ModelRelationExpr.isOutgoing(expr): {
+			const isSource = elementExprToPredicate(expr.outgoing);
+			return (edge) => isSource(edge.source);
+		}
+		default: nonexhaustive(expr);
+	}
+}
+
+//#endregion
+//#region src/compute-view/utils/applyCustomRelationProperties.ts
+function applyCustomRelationProperties(_rules, nodes, _edges) {
+	const rules = _rules.flatMap(flattenGroupRules(ModelRelationExpr.isCustom));
+	const edges = Array.from(_edges);
+	if (rules.length === 0 || edges.length === 0) return edges;
+	for (const { customRelation: { expr, title, description: _description, notes: _notes, ...customprops } } of rules) {
+		const description = _description ? { description: { txt: _description } } : {};
+		const notes = _notes ? { notes: { txt: _notes } } : {};
+		const props = t$22(customprops, e$5);
+		const satisfies = relationExpressionToPredicates(expr);
+		edges.forEach((edge, i) => {
+			let source, target;
+			for (const node of nodes) {
+				if (node.id === edge.source) source = node;
+				if (node.id === edge.target) target = node;
+				if (source && target) break;
+			}
+			if (!source || !target) return;
+			if (satisfies({
+				source,
+				target,
+				...t$11(edge, ["kind", "tags"])
+			})) edges[i] = {
+				...edge,
+				...props,
+				...description,
+				...notes,
+				label: title ?? edge.label,
+				isCustomized: true
+			};
+		});
+	}
+	return edges;
+}
+
+//#endregion
+//#region src/compute-view/element-view/clean-connections.ts
+function findRedundantConnections(connections) {
+	return t$3([...connections], mergeConnections, t$12((reducedConnections, connection, _, all) => {
+		const descendants = findDescendantConnections(all, connection);
+		const nestedRelations = union(...descendants.map(e$6("relations")));
+		let accum = intersection(connection.relations, nestedRelations);
+		if (descendants.length > 0) accum = union(accum, connection.directRelations);
+		if (findDeepestNestedConnection(all, connection.reversed())) accum = union(accum, connection.directRelations);
+		if (accum.size < connection.relations.size) {
+			const isSourceExpanded = all.some(isAnyInOut(connection.source));
+			const isTargetExpanded = all.some(isAnyInOut(connection.target));
+			if (isSourceExpanded) accum = union(accum, toSet(ifilter(connection.relations, isOutgoing(connection.source))));
+			if (isTargetExpanded) accum = union(accum, toSet(ifilter(connection.relations, isIncoming(connection.target))));
+		}
+		if (accum.size > 0) reducedConnections.push(connection.update(accum));
+		return reducedConnections;
+	}, []));
+}
+
+//#endregion
+//#region src/compute-view/element-view/memory/stage-final.ts
+var StageFinal = class StageFinal {
+	static for(memory) {
+		return new StageFinal(memory);
+	}
+	constructor(memory) {
+		this.memory = memory;
+	}
+	step1CleanConnections(memory) {
+		if (memory.connections.length < 2) return memory;
+		const connectionsToExclude = findRedundantConnections(memory.connections);
+		if (connectionsToExclude.length === 0) return memory;
+		const stage = memory.stageExclude({});
+		stage.excludeConnections(connectionsToExclude, true);
+		return stage.commit();
+	}
+	step2ProcessImplicits(memory) {
+		const implicits = union(this.memory.elements, memory.elements);
+		const final = union(memory.final, this.memory.explicits);
+		const snapshot = new Set(final);
+		const isFinalOrHasIncludedDescendant = (el) => {
+			for (const final of snapshot) if (el === final || isAncestor(el, final)) return true;
+			return false;
+		};
+		t$3(difference(implicits, snapshot), toArray(), sortByFqnHierarchically, t$6((el) => {
+			const childrensToWrap = [...el.children()].filter(isFinalOrHasIncludedDescendant).length;
+			if (childrensToWrap >= 2) {
+				final.add(el);
+				return;
+			}
+			if (childrensToWrap === 1 && isome(el.siblings(), isFinalOrHasIncludedDescendant)) final.add(el);
+		}));
+		return memory.update({ final });
+	}
+	step3ProcessBoundaries(memory) {
+		const boundaries = /* @__PURE__ */ new Set();
+		for (const conn of memory.connections) if (conn.boundary && conn.boundary !== conn.source && conn.boundary !== conn.target) boundaries.add(conn.boundary);
+		const tree = treeFromMemoryState(memory, "final");
+		const stage = memory.stageExclude({});
+		const isRemovable = (el) => !(boundaries.has(el) || memory.explicits.has(el) || tree.hasInOut(el) || tree.root.has(el));
+		const singleRoot = t$14([...tree.root]);
+		if (singleRoot && !memory.explicits.has(singleRoot)) stage.exclude(singleRoot);
+		for (const el of memory.final) {
+			const singleChild = t$14(tree.children(el));
+			if (singleChild && !tree.hasInOut(singleChild) && isRemovable(el)) stage.exclude(el);
+		}
+		if (stage.isDirty()) return stage.commit();
+		return memory;
+	}
+	commit() {
+		const step1 = this.step1CleanConnections(this.memory);
+		const step2 = this.step2ProcessImplicits(step1);
+		return this.step3ProcessBoundaries(step2);
+	}
+};
+
+//#endregion
+//#region src/compute-view/element-view/predicates/_utils.ts
+const { findConnection, findConnectionsBetween, findConnectionsWithin } = find_exports$1;
+/**
+* Resolve elements from the model based on the given expression
+*/
+function resolveElements(model, expr) {
+	switch (true) {
+		case ModelFqnExpr.isElementKindExpr(expr): return [...ifilter(model.elements(), (el) => {
+			return expr.isEqual === (el.kind === expr.elementKind);
+		})];
+		case ModelFqnExpr.isElementTagExpr(expr): return [...ifilter(model.elements(), (el) => {
+			return expr.isEqual === el.tags.includes(expr.elementTag);
+		})];
+		case expr.selector === "expanded": {
+			const element = model.element(FqnRef.flatten(expr.ref));
+			return [element, ...element.children()];
+		}
+		case expr.selector === "children":
+		case expr.selector === "descendants": {
+			const element = model.element(FqnRef.flatten(expr.ref));
+			let children = expr.selector === "children" ? toArray(element.children()) : toArray(element.descendants());
+			return children && children.length > 0 ? children : [element];
+		}
+		case ModelFqnExpr.isModelRef(expr): return [model.element(FqnRef.flatten(expr.ref))];
+		default: nonexhaustive(expr);
+	}
+}
+/**
+* Include elements that are not in the given set but are descendants of the current set
+* Consider the following example:
+*    a1.* -> b1
+* If there are a1.a2.a3 and b1.b2 in the memory, but not connected yet - we connect them
+*/
+function includeDescendantsFromMemory(elements, memory) {
+	if (memory.isEmpty() || elements.length === 0) return elements;
+	const descedantsOf = t$8(elements.map((e) => isDescendantOf(e)));
+	const fromMemory = toArray(ifilter(memory.elements, (el) => !elements.includes(el) && descedantsOf(el)));
+	return [...elements, ...fromMemory];
+}
+/**
+* Combination of `resolveElements` and `includeDescendantsFromMemory`
+*/
+function resolveAndIncludeFromMemory(nonWildcard, { memory, model }) {
+	const resolved = resolveElements(model, nonWildcard);
+	if (ModelFqnExpr.isModelRef(nonWildcard)) {
+		if (nonWildcard.selector === "descendants") return resolved;
+		return includeDescendantsFromMemory(resolved, memory);
+	}
+	return resolved;
+}
+
+//#endregion
+//#region src/compute-view/element-view/predicates/element-expand.ts
+const ExpandedElementPredicate = {
+	include: ({ expr, model, stage, where }) => {
+		const parent = model.element(FqnRef.flatten(expr.ref));
+		if (where(parent)) {
+			stage.addExplicit(parent);
+			stage.connectWithExisting(parent);
+		}
+		const children = [...parent.children()].filter(where);
+		const expanded = [];
+		for (const child of children) {
+			stage.addImplicit(child);
+			if (stage.connectWithExisting(child)) expanded.push(child);
+		}
+		stage.addConnections(findConnectionsWithin(expanded));
+		return stage;
+	},
+	exclude: ({ expr, model, stage, filterWhere }) => {
+		const elements = filterWhere(resolveElements(model, expr));
+		stage.exclude(elements);
+		return stage;
+	}
+};
+
+//#endregion
+//#region src/compute-view/element-view/predicates/element-kind-tag.ts
+const ElementKindOrTagPredicate = {
+	include: ({ expr, model, stage, filterWhere }) => {
+		const elements = filterWhere(resolveElements(model, expr));
+		if (elements.length === 0) return;
+		stage.addExplicit(elements);
+		stage.connectWithExisting(elements);
+		stage.addConnections(findConnectionsWithin(elements));
+		return stage;
+	},
+	exclude: ({ expr, model, stage, filterWhere }) => {
+		const elements = filterWhere(resolveElements(model, expr));
+		stage.exclude(elements);
+		return stage;
+	}
+};
+
+//#endregion
+//#region src/compute-view/element-view/predicates/element-ref.ts
+const ElementRefPredicate = {
+	include: ({ expr, model, stage, filterWhere }) => {
+		const elements = filterWhere(resolveElements(model, expr));
+		if (elements.length === 0) return;
+		stage.addExplicit(elements);
+		stage.connectWithExisting(elements);
+		stage.addConnections(findConnectionsWithin(elements));
+		return stage;
+	},
+	exclude: ({ expr, model, stage, filterWhere }) => {
+		const elements = filterWhere(resolveElements(model, expr));
+		stage.exclude(elements);
+		return stage;
+	}
+};
+
+//#endregion
+//#region src/compute-view/element-view/utils.ts
+const NoWhere = () => true;
+const NoFilter = (x) => x;
+function toComputedEdges(connections) {
+	return connections.reduce((acc, e) => {
+		const relations = [...e.relations];
+		invariant(t$16(relations, 1), "Edge must have at least one relation");
+		const $defaults = e.source.$model.$styles.defaults;
+		const source = e.source.id;
+		const target = e.target.id;
+		const { title, color = $defaults.relationship.color, line = $defaults.relationship.line, head = $defaults.relationship.arrow, ...props } = mergePropsFromRelationships(relations.map((r) => r.$relationship), t$14(n(relations, (r) => r.source.id === source && r.target.id === target))?.$relationship);
+		const edge = exact({
+			id: e.id,
+			parent: e.boundary?.id ?? null,
+			source,
+			target,
+			label: title ?? null,
+			relations: relations.map((r) => r.id),
+			color,
+			line,
+			head,
+			...props
+		});
+		acc.push(edge);
+		return acc;
+	}, []);
+}
+function buildNodes(model, memory) {
+	return buildComputedNodes(model.$styles, [...memory.final].map(elementModelToNodeSource), memory.groups);
+}
+
+//#endregion
+//#region src/compute-view/element-view/predicates/relation-direct.ts
+const isWildcard = ModelFqnExpr.isWildcard;
+const isAncestorOrDescendantOf = (a, b) => a.isAncestorOf(b) || a.isDescendantOf(b);
+const DirectRelationExprPredicate = {
+	include: ({ expr: { source, target, isBidirectional = false }, memory, model, stage, where, filterWhere }) => {
+		const sourceIsWildcard = isWildcard(source);
+		const targetIsWildcard = isWildcard(target);
+		const connections = [];
+		switch (true) {
+			case sourceIsWildcard && targetIsWildcard && memory.isEmpty() && where !== NoWhere: {
+				const connections = t$3(model.relationships(), ifilter(where), toArray(), t$4((r) => new ConnectionModel(r.source, r.target, new Set([r]))));
+				stage.addConnections(connections);
+				return stage;
+			}
+			case sourceIsWildcard && targetIsWildcard && !memory.isEmpty() && where !== NoWhere:
+				connections.push(...findConnectionsWithin(memory.elements));
+				break;
+			case sourceIsWildcard && targetIsWildcard:
+				connections.push(...findConnectionsWithin(model.roots()));
+				break;
+			case !sourceIsWildcard && targetIsWildcard && where !== NoWhere: {
+				const connections = t$3(resolveElements(model, source), t$17((source) => t$3(source, e$9(e$10(isBidirectional === true), {
+					onTrue: (s) => union(s.allIncoming, s.allOutgoing),
+					onFalse: (s) => s.allOutgoing
+				}), ifilter(where), iunique(), toArray(), t$2((r) => r.source === source), ([outgoing, incoming]) => t$23(t$3(outgoing, n((r) => !isAncestorOrDescendantOf(source, r.target)), t$4((outgoing) => new ConnectionModel(source, outgoing.target, new Set([outgoing])))), t$3(incoming, n((r) => !isAncestorOrDescendantOf(source, r.source)), t$4((incoming) => new ConnectionModel(incoming.source, source, new Set([incoming]))))))));
+				stage.addConnections(connections);
+				return stage;
+			}
+			case !sourceIsWildcard && targetIsWildcard: {
+				const [sources, targets] = resolveWildcard(source, {
+					memory,
+					model
+				});
+				const dir = isBidirectional ? "both" : "directed";
+				for (const source of sources) connections.push(...findConnectionsBetween(source, targets, dir));
+				break;
+			}
+			case sourceIsWildcard && !targetIsWildcard && where !== NoWhere: {
+				const connections = t$3(resolveElements(model, target), t$17((target) => t$3(target, e$9(e$10(isBidirectional === true), {
+					onTrue: (s) => union(s.allIncoming, s.allOutgoing),
+					onFalse: (s) => s.allIncoming
+				}), ifilter(where), toArray(), t$2((r) => r.target === target), ([incoming, outgoing]) => t$23(t$3(outgoing, n((r) => !isAncestorOrDescendantOf(target, r.target)), t$4((outgoing) => new ConnectionModel(target, outgoing.target, new Set([outgoing])))), t$3(incoming, n((r) => !isAncestorOrDescendantOf(target, r.source)), t$4((incoming) => new ConnectionModel(incoming.source, target, new Set([incoming]))))))));
+				stage.addConnections(connections);
+				return stage;
+			}
+			case sourceIsWildcard && !targetIsWildcard: {
+				const [targets, sources] = resolveWildcard(target, {
+					memory,
+					model
+				});
+				const dir = isBidirectional ? "both" : "directed";
+				for (const source of sources) connections.push(...findConnectionsBetween(source, targets, dir));
+				break;
+			}
+			default: {
+				invariant(!isWildcard(source), "Inference failed - source must be not a wildcard");
+				invariant(!isWildcard(target), "Inference failed - target must be not a wildcard");
+				const sources = resolveAndIncludeFromMemory(source, {
+					memory,
+					model
+				});
+				const targets = resolveAndIncludeFromMemory(target, {
+					memory,
+					model
+				});
+				const dir = isBidirectional ? "both" : "directed";
+				for (const source of sources) connections.push(...findConnectionsBetween(source, targets, dir));
+			}
+		}
+		stage.addConnections(filterWhere(connections));
+		return stage;
+	},
+	exclude: ({ expr: { source, target, isBidirectional }, model, memory, stage, where }) => {
+		const sourceIsWildcard = isWildcard(source);
+		const targetIsWildcard = isWildcard(target);
+		let relations;
+		switch (true) {
+			case sourceIsWildcard && targetIsWildcard:
+				relations = t$3(memory.connections, t$17(t$20(e$6("relations"), ifilter(where), toArray())), toSet());
+				break;
+			case !sourceIsWildcard && targetIsWildcard:
+				relations = t$3(resolveElements(model, source), t$17((source) => t$3(source, e$9(e$10(isBidirectional === true), {
+					onTrue: (s) => union(s.allIncoming, s.allOutgoing),
+					onFalse: (s) => s.allOutgoing
+				}), ifilter(where), toArray())), toSet());
+				break;
+			case sourceIsWildcard && !targetIsWildcard:
+				relations = t$3(resolveElements(model, target), t$17((target) => t$3(target, e$9(e$10(isBidirectional === true), {
+					onTrue: (s) => union(s.allIncoming, s.allOutgoing),
+					onFalse: (s) => s.allIncoming
+				}), ifilter(where), toArray())), toSet());
+				break;
+			default: {
+				invariant(!isWildcard(source), "Inferrence failed - source must be not a wildcard");
+				invariant(!isWildcard(target), "Inferrence failed - target must be not a wildcard");
+				const sources = resolveElements(model, source);
+				const targets = resolveElements(model, target);
+				let accum = /* @__PURE__ */ new Set();
+				for (const source of sources) for (const target of targets) {
+					if (isSameHierarchy(source, target)) continue;
+					accum = union(accum, intersection(source.allOutgoing, target.allIncoming), isBidirectional ? intersection(target.allOutgoing, source.allIncoming) : /* @__PURE__ */ new Set());
+				}
+				relations = toSet(ifilter(accum, where));
+			}
+		}
+		stage.excludeRelations(relations);
+		return stage;
+	}
+};
+/**
+* Resolve elements for both source and target, when one of them is a wildcard
+*/
+function resolveWildcard(nonWildcard, { memory, model }) {
+	let sources = resolveElements(model, nonWildcard);
+	if (!t$16(sources, 1)) return [[], []];
+	if (ModelFqnExpr.isModelRef(nonWildcard)) {
+		const targets = toArray(model.element(FqnRef.flatten(nonWildcard.ref)).ascendingSiblings());
+		return [includeDescendantsFromMemory(sources, memory), includeDescendantsFromMemory(targets, memory)];
+	}
+	return [sources, t$3(sources, t$4((el) => el.ascendingSiblings()), iflat(), iunique(), toArray(), (all) => includeDescendantsFromMemory(all, memory))];
+}
+
+//#endregion
+//#region src/compute-view/element-view/predicates/relation-in.ts
+const IncomingExprPredicate = {
+	include: ({ expr, scope, model, memory, stage, filterWhere }) => {
+		const target = expr.incoming;
+		const connections = [];
+		if (ModelFqnExpr.isWildcard(target)) {
+			if (!scope) return;
+			for (const sibling of scope.ascendingSiblings()) connections.push(...findConnection(sibling, scope, "directed"));
+		} else {
+			const targets = resolveAndIncludeFromMemory(target, {
+				memory,
+				model
+			});
+			const visibleElements = [...memory.elements];
+			if (visibleElements.length === 0) visibleElements.push(...n$3(targets.flatMap((el) => [...el.ascendingSiblings()])));
+			const ensureIncoming = incomingConnectionPredicate(model, target);
+			for (const visible of visibleElements) connections.push(...findConnectionsBetween(visible, targets, "directed").filter(ensureIncoming));
+		}
+		stage.addConnections(filterWhere(connections));
+		return stage;
+	},
+	exclude: ({ expr: { incoming }, model, scope, stage, where }) => {
+		const excluded = [];
+		if (ModelFqnExpr.isWildcard(incoming)) {
+			if (!scope) return;
+			excluded.push(...scope.allIncoming);
+		} else {
+			const elements = resolveElements(model, incoming);
+			excluded.push(...elements.flatMap((e) => [...e.allIncoming]));
+		}
+		stage.excludeRelations(new Set(excluded.filter(where)));
+		return stage;
+	}
+};
+function incomingConnectionPredicate(model, expr) {
+	switch (true) {
+		case ModelFqnExpr.isElementKindExpr(expr):
+		case ModelFqnExpr.isElementTagExpr(expr): {
+			const isElement = elementExprToPredicate(expr);
+			return (connection) => isElement(connection.target);
+		}
+		case ModelFqnExpr.isModelRef(expr) && expr.selector === "children": {
+			const fqn = FqnRef.flatten(expr.ref);
+			return t$8([...model.children(fqn)].map((el) => Connection.isIncoming(el.id)));
+		}
+		case ModelFqnExpr.isModelRef(expr) && expr.selector === "descendants": {
+			const fqn = FqnRef.flatten(expr.ref);
+			return t$8([Connection.isInside(fqn), ...[...model.children(fqn)].map((el) => Connection.isIncoming(el.id))]);
+		}
+		case ModelFqnExpr.isModelRef(expr) && expr.selector === "expanded": {
+			const fqn = FqnRef.flatten(expr.ref);
+			return t$8([Connection.isIncoming(fqn), Connection.isInside(fqn)]);
+		}
+		case ModelFqnExpr.isModelRef(expr): {
+			const fqn = FqnRef.flatten(expr.ref);
+			return Connection.isIncoming(fqn);
+		}
+		default: nonexhaustive(expr);
+	}
+}
+
+//#endregion
+//#region src/compute-view/element-view/predicates/relation-in-out.ts
+const InOutRelationPredicate = {
+	include: ({ expr: { inout }, scope, model, memory, stage, filterWhere }) => {
+		const connections = [];
+		if (ModelFqnExpr.isWildcard(inout)) {
+			if (!scope) return;
+			connections.push(...findConnectionsBetween(scope, scope.ascendingSiblings()));
+		} else {
+			const elements = resolveAndIncludeFromMemory(inout, {
+				memory,
+				model
+			});
+			let visibleElements = [...memory.elements];
+			if (visibleElements.length === 0) visibleElements = n$3(elements.flatMap((el) => toArray(el.ascendingSiblings())));
+			for (const el of elements) connections.push(...findConnectionsBetween(el, visibleElements));
+		}
+		stage.addConnections(filterWhere(connections));
+		return stage;
+	},
+	exclude: ({ expr: { inout }, model, scope, stage, where }) => {
+		const excluded = [];
+		if (ModelFqnExpr.isWildcard(inout)) {
+			if (!scope) return;
+			excluded.push(...scope.allOutgoing);
+			excluded.push(...scope.allIncoming);
+		} else {
+			const elements = resolveElements(model, inout);
+			excluded.push(...elements.flatMap((e) => [...e.allOutgoing, ...e.allIncoming]));
+		}
+		stage.excludeRelations(toSet(excluded.filter(where)));
+		return stage;
+	}
+};
+
+//#endregion
+//#region src/compute-view/element-view/predicates/relation-out.ts
+const OutgoingExprPredicate = {
+	include: ({ expr, scope, model, memory, stage, filterWhere }) => {
+		const target = expr.outgoing;
+		const connections = [];
+		if (ModelFqnExpr.isWildcard(target)) {
+			if (!scope) return;
+			connections.push(...findConnectionsBetween(scope, scope.ascendingSiblings(), "directed"));
+		} else {
+			const elements = resolveAndIncludeFromMemory(target, {
+				memory,
+				model
+			});
+			const visibleElements = [...memory.elements];
+			if (visibleElements.length === 0) visibleElements.push(...n$3(elements.flatMap((el) => [...el.ascendingSiblings()])));
+			const ensureOutgoing = outgoingConnectionPredicate(model, target);
+			for (const source of elements) connections.push(...findConnectionsBetween(source, visibleElements, "directed").filter(ensureOutgoing));
+		}
+		stage.addConnections(filterWhere(connections));
+		return stage;
+	},
+	exclude: ({ expr: { outgoing }, model, scope, stage, where }) => {
+		const excluded = [];
+		if (ModelFqnExpr.isWildcard(outgoing)) {
+			if (!scope) return;
+			excluded.push(...scope.allOutgoing);
+		} else {
+			const elements = resolveElements(model, outgoing);
+			excluded.push(...elements.flatMap((e) => [...e.allOutgoing]));
+		}
+		stage.excludeRelations(toSet(excluded.filter(where)));
+		return stage;
+	}
+};
+function outgoingConnectionPredicate(model, expr) {
+	switch (true) {
+		case ModelFqnExpr.isElementKindExpr(expr):
+		case ModelFqnExpr.isElementTagExpr(expr): {
+			const isElement = elementExprToPredicate(expr);
+			return (connection) => isElement(connection.source);
+		}
+		case ModelFqnExpr.isModelRef(expr) && expr.selector === "children": {
+			const fqn = FqnRef.flatten(expr.ref);
+			return t$8([...model.children(fqn)].map((el) => Connection.isOutgoing(el.id)));
+		}
+		case ModelFqnExpr.isModelRef(expr) && expr.selector === "descendants": {
+			const fqn = FqnRef.flatten(expr.ref);
+			return t$8([Connection.isInside(fqn), ...[...model.children(fqn)].map((el) => Connection.isOutgoing(el.id))]);
+		}
+		case ModelFqnExpr.isModelRef(expr) && expr.selector === "expanded": {
+			const fqn = FqnRef.flatten(expr.ref);
+			return t$8([Connection.isOutgoing(fqn), Connection.isInside(fqn)]);
+		}
+		case ModelFqnExpr.isModelRef(expr): {
+			const fqn = FqnRef.flatten(expr.ref);
+			return Connection.isOutgoing(fqn);
+		}
+		default: nonexhaustive(expr);
+	}
+}
+
+//#endregion
+//#region src/compute-view/element-view/predicates/wildcard.ts
+const WildcardPredicate = {
+	include: ({ scope, model, stage, memory, where }) => {
+		if (!scope) {
+			const rootElements = [...model.roots()].filter(where);
+			if (rootElements.length === 0) return;
+			const [projectElements, importedElements] = t$2(rootElements, (e) => !e.imported);
+			stage.addExplicit(projectElements);
+			stage.addImplicit(importedElements);
+			stage.addConnections(findConnectionsWithin(rootElements));
+			stage.connectWithExisting(rootElements);
+			return stage;
+		}
+		const root = where(scope) ? scope : null;
+		const children = toArray(ifilter(scope.children(), where));
+		const hasChildren = children.length > 0;
+		if (!hasChildren) if (!root) return stage;
+		else {
+			if (findConnectionsBetween(root, root.siblings()).length === 0) {
+				const parent = root.parent;
+				if (parent && where(parent)) stage.addExplicit(parent);
+			}
+			children.push(root);
+		}
+		if (root) stage.addExplicit(root);
+		const neighbours = toSet([...memory.elements, ...scope.descendingSiblings()]);
+		for (const neighbour of neighbours) stage.addConnections(findConnectionsBetween(neighbour, children, "directed"));
+		if (hasChildren) {
+			stage.addConnections(findConnectionsWithin(children));
+			stage.addExplicit(children);
+		}
+		for (const child of children) stage.addConnections(findConnectionsBetween(child, neighbours, "directed"));
+		return stage;
+	},
+	exclude: ({ scope, memory, stage, where }) => {
+		if (where !== NoWhere) {
+			stage.exclude(n([...memory.elements], where));
+			return stage;
+		}
+		if (scope) {
+			stage.exclude([scope, ...scope.descendants()]);
+			return stage;
+		}
+		return Memory$1.empty(memory.scope).stageExclude(stage.expression);
+	}
+};
+
+//#endregion
+//#region src/compute-view/element-view/compute.ts
+function processElementPredicate(expr, op, ctx) {
+	switch (true) {
+		case ModelFqnExpr.isCustom(expr):
+			if (op === "include") return processElementPredicate(expr.custom.expr, op, ctx);
+			return ctx.stage;
+		case ModelFqnExpr.isWhere(expr): {
+			const where = whereOperatorAsPredicate(expr.where.condition);
+			const filterWhere = (elements) => {
+				return n(elements, where);
+			};
+			return processElementPredicate(expr.where.expr, op, {
+				...ctx,
+				where,
+				filterWhere
+			});
+		}
+		case ModelFqnExpr.isModelRef(expr) && expr.selector === "expanded": return ExpandedElementPredicate[op]({
+			...ctx,
+			expr
+		}) ?? ctx.stage;
+		case ModelFqnExpr.isWildcard(expr): return WildcardPredicate[op]({
+			...ctx,
+			expr
+		}) ?? ctx.stage;
+		case ModelFqnExpr.isElementKindExpr(expr):
+		case ModelFqnExpr.isElementTagExpr(expr): return ElementKindOrTagPredicate[op]({
+			...ctx,
+			expr
+		}) ?? ctx.stage;
+		case ModelFqnExpr.isModelRef(expr): return ElementRefPredicate[op]({
+			...ctx,
+			expr
+		}) ?? ctx.stage;
+		default: nonexhaustive(expr);
+	}
+}
+function processRelationtPredicate(expr, op, ctx) {
+	switch (true) {
+		case ModelRelationExpr.isCustom(expr):
+			if (op === "include") return processRelationtPredicate(expr.customRelation.expr, op, ctx);
+			return ctx.stage;
+		case ModelRelationExpr.isWhere(expr): {
+			const where = whereOperatorAsPredicate(expr.where.condition);
+			const filterRelations = (relations) => {
+				return new Set(n([...relations], where));
+			};
+			const filterWhere = (connections) => {
+				return t$3(connections, t$4((c) => new ConnectionModel(c.source, c.target, filterRelations(c.relations))), n((c) => c.nonEmpty()));
+			};
+			return processRelationtPredicate(expr.where.expr, op, {
+				...ctx,
+				where,
+				filterWhere
+			});
+		}
+		case ModelRelationExpr.isInOut(expr): return InOutRelationPredicate[op]({
+			...ctx,
+			expr
+		}) ?? ctx.stage;
+		case ModelRelationExpr.isDirect(expr): return DirectRelationExprPredicate[op]({
+			...ctx,
+			expr
+		}) ?? ctx.stage;
+		case ModelRelationExpr.isOutgoing(expr): return OutgoingExprPredicate[op]({
+			...ctx,
+			expr
+		}) ?? ctx.stage;
+		case ModelRelationExpr.isIncoming(expr): return IncomingExprPredicate[op]({
+			...ctx,
+			expr
+		}) ?? ctx.stage;
+		default: nonexhaustive(expr);
+	}
+}
+/**
+* Iterates over the rules and applies them to the memory.
+* If the rule is a group, it recursively processes the group rules.
+*/
+function process_predicates(model, memory, rules) {
+	const ctx = {
+		model,
+		scope: memory.scope,
+		where: NoWhere,
+		filterWhere: NoFilter
+	};
+	for (const rule of rules) {
+		if (isViewRuleGroup(rule)) {
+			memory = process_predicates(model, ActiveGroupMemory.enter(memory, rule), rule.groupRules);
+			invariant(memory instanceof ActiveGroupMemory, "processPredicates must return ActiveGroupMemory");
+			memory = memory.leave();
+			continue;
+		}
+		if (isViewRulePredicate(rule)) {
+			const op = "include" in rule ? "include" : "exclude";
+			const exprs = rule.include ?? rule.exclude;
+			for (const expr of exprs) {
+				let stage = op === "include" ? memory.stageInclude(expr) : memory.stageExclude(expr);
+				switch (true) {
+					case ModelExpression.isFqnExpr(expr):
+						stage = processElementPredicate(expr, op, {
+							...ctx,
+							stage,
+							memory
+						}) ?? stage;
+						break;
+					case ModelExpression.isRelationExpr(expr):
+						stage = processRelationtPredicate(expr, op, {
+							...ctx,
+							stage,
+							memory
+						}) ?? stage;
+						break;
+					default: nonexhaustive(expr);
+				}
+				memory = stage.commit();
+			}
+		}
+	}
+	return memory;
+}
+function processPredicates(model, memory, rules) {
+	memory = process_predicates(model, memory, rules);
+	return StageFinal.for(memory).commit();
+}
+function computeElementView(likec4model, { docUri: _docUri, rules: _rules, ...view }) {
+	const rules = resolveGlobalRulesInElementView(_rules, likec4model.globals);
+	const scope = view.viewOf ? likec4model.asComputed.element(view.viewOf) : null;
+	let memory = processPredicates(likec4model, Memory$1.empty(scope), rules);
+	if (memory.isEmpty() && scope) memory = memory.update({ final: new Set([scope]) });
+	memory = assignElementsToGroups(memory);
+	const nodesMap = buildNodes(likec4model, memory);
+	const computedEdges = toComputedEdges(memory.connections);
+	linkNodesWithEdges(nodesMap, computedEdges);
+	const sorted = topologicalSort({
+		nodes: nodesMap,
+		edges: computedEdges
+	});
+	const nodes = applyCustomElementProperties(rules, applyViewRuleStyles(rules, sorted.nodes));
+	const autoLayoutRule = t$21(rules, isViewRuleAutoLayout);
+	const nodeNotations = buildElementNotations(nodes);
+	const ranks = collectRankConstraints(rules, nodes);
+	return calcViewLayoutHash({
+		...view,
+		_stage: "computed",
+		autoLayout: {
+			direction: autoLayoutRule?.direction ?? "TB",
+			...autoLayoutRule?.nodeSep && { nodeSep: autoLayoutRule.nodeSep },
+			...autoLayoutRule?.rankSep && { rankSep: autoLayoutRule.rankSep }
+		},
+		edges: applyCustomRelationProperties(rules, nodes, sorted.edges),
+		nodes: t$4(nodes, (n) => {
+			if (n.icon === "none") delete n.icon;
+			return n;
+		}),
+		...nodeNotations.length > 0 && { notation: { nodes: nodeNotations } },
+		...ranks.length > 0 && { ranks }
+	});
+}
+function collectRankConstraints(rules, nodes) {
+	const constraints = [];
+	for (const rule of rules) {
+		if (!isViewRuleRank(rule) || rule.targets.length === 0) continue;
+		const nodesInRank = t$3(nodes, n(t$8(rule.targets.map(elementExprToPredicate))), t$4((n) => n.id));
+		if (!t$16(nodesInRank, 1)) continue;
+		constraints.push({
+			type: rule.rank,
+			nodes: nodesInRank
+		});
+	}
+	return constraints;
+}
+/**
+* Clean up group.explicits and group.implicits
+*/
+function assignElementsToGroups(memory) {
+	if (memory.groups.length === 0) return memory;
+	const groupAssignments = new import_default_map.default(() => /* @__PURE__ */ new Set());
+	const assignedTo = /* @__PURE__ */ new Map();
+	const isAncestorAssigned = (el) => {
+		for (const parent of el.ancestors()) {
+			const groupId = assignedTo.get(parent);
+			if (groupId) {
+				assignedTo.set(el, groupId);
+				groupAssignments.get(groupId).add(el);
+				return true;
+			}
+		}
+		return false;
+	};
+	const isDescendantAssigned = (el) => {
+		for (const descendant of el.descendants("asc")) {
+			const groupId = assignedTo.get(descendant);
+			if (groupId) {
+				assignedTo.set(el, groupId);
+				groupAssignments.get(groupId).add(el);
+				return true;
+			}
+		}
+		return false;
+	};
+	t$3(sortParentsFirst([...memory.explicitFirstSeenIn.keys()]), t$6((el) => {
+		if (!isAncestorAssigned(el)) {
+			const groupId = nonNullable(memory.explicitFirstSeenIn.get(el));
+			assignedTo.set(el, groupId);
+			groupAssignments.get(groupId).add(el);
+		}
+	}));
+	t$3(sortParentsFirst([...memory.lastSeenIn.keys()]), n((el) => !assignedTo.has(el)), t$6((el) => {
+		if (isAncestorAssigned(el)) return;
+		if (isDescendantAssigned(el)) return;
+		const groupId = nonNullable(memory.lastSeenIn.get(el));
+		assignedTo.set(el, groupId);
+		groupAssignments.get(groupId).add(el);
+	}));
+	if (groupAssignments.size === 0) return memory;
+	let groups = memory.groups.map((group) => {
+		const explicits = groupAssignments.get(group.id);
+		if (!explicits) return group;
+		return group.update(explicits);
+	});
+	return memory.update({ groups });
+}
+
+//#endregion
+//#region src/compute-view/compute-view.ts
+function unsafeComputeView(viewsource, likec4model) {
+	switch (true) {
+		case isElementView(viewsource): return computeElementView(likec4model, viewsource);
+		case isDeploymentView(viewsource): return computeDeploymentView(likec4model, viewsource);
+		case isDynamicView(viewsource): return computeDynamicView(likec4model, viewsource);
+		default: nonexhaustive(viewsource);
+	}
+}
+function computeView(viewsource, likec4model) {
+	try {
+		return {
+			isSuccess: true,
+			view: unsafeComputeView(viewsource, likec4model)
+		};
+	} catch (e) {
+		return {
+			isSuccess: false,
+			error: e instanceof Error ? e : /* @__PURE__ */ new Error(`Unknown error: ${e}`),
+			view: void 0
+		};
+	}
+}
+function computeParsedModelData(parsed) {
+	const likec4model = LikeC4Model.create(parsed);
+	let { views: _views, _stage: __omitted, ...rest } = parsed;
+	const views = t$24(_views, (v) => unsafeComputeView(v, likec4model));
+	return {
+		[_stage]: "computed",
+		...rest,
+		views
+	};
+}
+function computeLikeC4Model(parsed) {
+	return LikeC4Model.create(computeParsedModelData(parsed));
+}
+
+//#endregion
+//#region src/builder/Builder.view-element.ts
+const asTypedExpr = (expr) => {
+	return expr;
+};
+function $expr(expr) {
+	if (!e$11(expr)) return expr;
+	if (expr === "*") return asTypedExpr({ wildcard: true });
+	if (expr.startsWith("->")) {
+		if (expr.endsWith("->")) return asTypedExpr({ inout: $expr(expr.replace(/->/g, "").trim()) });
+		return asTypedExpr({ incoming: $expr(expr.replace("-> ", "")) });
+	}
+	if (expr.endsWith(" ->")) return asTypedExpr({ outgoing: $expr(expr.replace(" ->", "")) });
+	if (expr.includes(" <-> ")) {
+		const [source, target] = expr.split(" <-> ");
+		return asTypedExpr({
+			source: $expr(source),
+			target: $expr(target),
+			isBidirectional: true
+		});
+	}
+	if (expr.includes(" -> ")) {
+		const [source, target] = expr.split(" -> ");
+		return asTypedExpr({
+			source: $expr(source),
+			target: $expr(target)
+		});
+	}
+	if (expr.endsWith("._")) return asTypedExpr({
+		ref: { model: expr.replace("._", "") },
+		selector: "expanded"
+	});
+	if (expr.endsWith(".**")) return asTypedExpr({
+		ref: { model: expr.replace(".**", "") },
+		selector: "descendants"
+	});
+	if (expr.endsWith(".*")) return asTypedExpr({
+		ref: { model: expr.replace(".*", "") },
+		selector: "children"
+	});
+	return asTypedExpr({ ref: { model: expr } });
+}
+
+//#endregion
+export { unsafeComputeView as a, linkNodesWithEdges as c, computeView as i, computeLikeC4Model as n, computeElementView as o, computeParsedModelData as r, topologicalSort as s, $expr as t };