@likec4/core 1.20.3 → 1.21.1

package/dist/shared/{core.BG1hfxpq.mjs → core.Cz9Oy_FA.mjs}

@@ -1,16 +1,16 @@
-import { R as x, T as s$1, U as a$4, s as hierarchyLevel, u as isAncestor, j as commonAncestor, x as sortNaturalByFqn, m as m$3, f as commonHead, V as getDefaultExportFromCjs, W as requireForeach, X as requireIterator, Y as u$7, Q as objectHash, M as intersection, K as difference, O as union, P as stringHash, L as equals, B as isString, v as isDescendantOf, c as isSameHierarchy, H as isome, C as ifilter, G as isIterable, t as toSet, y as sortParentsFirst, J as toArray, D as DefaultMap, F as imap, a as i$9, Z as d$6, p as parentFqn, _ as n$5, k as compareByFqnHierarchically, A as isNonEmptyArray, g as compareNatural, n as nameFromFqn, b as t$6, $ as hasIntersection, l as l$7, w as sortByFqnHierarchically, h as ancestorsFqn, S as Stack, I as iunique, E as iflat, z as getOrCreate, i as ifind } from './core.CCyhaU-4.mjs';
-import { e as DefaultElementShape, d as DefaultThemeColor, a7 as o$9, q as isElementWhere, M as whereOperatorAsPredicate, z as isWildcard, l as isElementKindExpr, p as isElementTagExpr, n as n$4, r as isExpandedElementExpr, m as isElementRef, h as isCustomElement, a5 as isViewRuleStyle, a8 as y$1, Q as ComputedNode, E as ElementKind, N as DefaultArrowType, F as FqnExpr, R as RelationExpr, o as o$a, a4 as isViewRulePredicate, a0 as isViewRuleAutoLayout, a3 as isViewRuleGroup, a1 as isViewRuleGlobalPredicateRef, a2 as isViewRuleGlobalStyle, a6 as stepEdgeId, _ as isDynamicViewParallelSteps, P as DefaultRelationshipColor, O as DefaultLineStyle, u as isOutgoing$1, s as isIncoming$1, t as isInOut, v as isRelation, y as isRelationWhere, j as isCustomRelationExpr, x as isRelationPredicateExpr, b as isElementPredicateExpr, a as isElementView, Z as isDynamicView, Y as isDeploymentView, D as DeploymentElement, U as extractStep, $ as isStepEdgeId, c as isScopedElementView } from './core.0PxLtLpP.mjs';
-import { u as u$6, a as nonNullable, i as invariant, n as nonexhaustive } from './core.Bezy7K65.mjs';
+import { d as DefaultElementShape, e as DefaultThemeColor, h as DefaultShapeSize, aa as o$8, t as isElementWhere, P as whereOperatorAsPredicate, G as isWildcard, q as isElementKindExpr, s as isElementTagExpr, n as n$4, u as isExpandedElementExpr, r as isElementRef, l as isCustomElement, a8 as isViewRuleStyle, ab as y$2, U as ComputedNode, E as ElementKind, Q as DefaultArrowType, I as FqnExpr, R as RelationExpr, o as o$9, a7 as isViewRulePredicate, a3 as isViewRuleAutoLayout, a6 as isViewRuleGroup, a4 as isViewRuleGlobalPredicateRef, a5 as isViewRuleGlobalStyle, a9 as stepEdgeId, a1 as isDynamicViewParallelSteps, S as DefaultLineStyle, T as DefaultRelationshipColor, x as isOutgoing$1, v as isIncoming$1, w as isInOut, y as isRelation, F as isRelationWhere, m as isCustomRelationExpr, C as isRelationPredicateExpr, b as isElementPredicateExpr, a as isElementView, a0 as isDynamicView, $ as isDeploymentView, D as DeploymentElement, X as extractStep, a2 as isStepEdgeId, c as isScopedElementView } from './core.CYNYaH2U.mjs';
+import { R as C, T as s$1, U as a$5, s as hierarchyLevel, u as isAncestor, j as commonAncestor, x as sortNaturalByFqn, m as m$3, f as commonHead, V as getDefaultExportFromCjs, W as requireForeach, X as requireIterator, Y as u$7, Q as objectHash, M as intersection, K as difference, O as union, P as stringHash, L as equals, v as isDescendantOf, B as isString, c as isSameHierarchy, H as isome, C as ifilter, G as isIterable, t as toSet, y as sortParentsFirst, J as toArray, D as DefaultMap, F as imap, a as i$9, Z as d$6, p as parentFqn, _ as n$5, k as compareByFqnHierarchically, A as isNonEmptyArray, g as compareNatural, n as nameFromFqn, b as t$6, l as l$7, $ as hasIntersection, w as sortByFqnHierarchically, h as ancestorsFqn, S as Stack, I as iunique, E as iflat, z as getOrCreate, i as ifind } from './core.CeefT_JU.mjs';
+import { u as u$6, a as nonNullable, i as invariant, n as nonexhaustive } from './core.BfZZXtur.mjs';
 
-function f(t,i){let o=i.length-t.length;if(o===1){let[n,...r]=i;return x(n,{lazy:t,lazyArgs:r})}if(o===0){let n={lazy:t,lazyArgs:i};return Object.assign(e=>x(e,n),n)}throw new Error("Wrong number of arguments")}
+function y$1(t,i){let a=i.length-t.length;if(a===1){let[n,...r]=i;return C(n,{lazy:t,lazyArgs:r})}if(a===0){let n={lazy:t,lazyArgs:i};return Object.assign(e=>C(e,n),n)}throw new Error("Wrong number of arguments")}
 
 function r$3(...t){return u$6(Object.values,t)}
 
 function d$5(...e){return e.length===2?(n,...r)=>t$5(n,...e,...r):t$5(...e)}var t$5=(e,n,r,...a)=>n(e,...a)?typeof r=="function"?r(e,...a):r.onTrue(e,...a):typeof r=="function"?e:r.onFalse(e,...a);
 
-function i$8(...e){return f(o$8,e)}function o$8(){let e=new Set;return t=>e.has(t)?s$1:(e.add(t),{done:false,hasNext:true,next:t})}
+function i$8(...e){return y$1(a$4,e)}function a$4(){let e=new Set;return t=>e.has(t)?s$1:(e.add(t),{done:false,hasNext:true,next:t})}
 
-function l$6(...e){return u$6(o$7,e,u$5)}var o$7=(e,r)=>r<0?[]:e.slice(0,r);function u$5(e){if(e<=0)return a$4;let r=e;return a=>(r-=1,{done:r<=0,hasNext:true,next:a})}
+function l$6(...r){return u$6(o$7,r,u$5)}var o$7=(r,e)=>e<0?[]:r.slice(0,e);function u$5(r){if(r<=0)return a$5;let e=r;return a=>(e-=1,{done:e<=0,hasNext:true,next:a})}
 
 var T$1={asc:(r,n)=>r>n,desc:(r,n)=>r<n};function s(r,n){let[e,...o]=n;if(!m$2(e)){let t=u$4(...o);return r(e,t)}let a=u$4(e,...o);return t=>r(t,a)}function u$4(r,n,...e){let o=typeof r=="function"?r:r[0],a=typeof r=="function"?"asc":r[1],{[a]:t}=T$1,i=n===undefined?undefined:u$4(n,...e);return (y,c)=>{let p=o(y),l=o(c);return t(p,l)?1:t(l,p)?-1:i?.(y,c)??0}}function m$2(r){if(d$4(r))return  true;if(typeof r!="object"||!Array.isArray(r))return  false;let[n,e,...o]=r;return d$4(n)&&typeof e=="string"&&e in T$1&&o.length===0}var d$4=r=>typeof r=="function"&&r.length===1;
 
@@ -30,7 +30,7 @@ function i$6(...e){return u$6(o$5,e)}function o$5(e,n){let t={};for(let r of n)r
 
 function d$2(...e){return u$6(i$5,e)}function i$5(e,o){let t={};for(let[r,n]of Object.entries(e))o(n,r,e)&&(t[r]=n);return t}
 
-function i$4(...n){return o=>x(o,...n)}
+function i$4(...n){return o=>C(o,...n)}
 
 function d$1(...e){return u$6(l$4,e)}function l$4(e,a){let t={...e};for(let[n,o]of Object.entries(t))a(o,n,e)&&delete t[n];return t}
 
@@ -56,11 +56,11 @@ function k(...n){return u$6(u$2,n)}function u$2(n,e){if(n===e||Object.is(n,e))re
 
 function u$1(...a){return u$6(o$2,a,l$1)}var o$2=(a,r)=>a.flatMap(r),l$1=a=>(r,t,y)=>{let n=a(r,t,y);return Array.isArray(n)?{done:false,hasNext:true,hasMany:true,next:n}:{done:false,hasNext:true,next:n}};
 
-function u(...e){return u$6(o$1,e,i$1)}function o$1(e,r){return e.forEach(r),e}var i$1=e=>(r,n,t)=>(e(r,n,t),{done:false,hasNext:true,next:r});
+function u(...e){return u$6(o$1,e,i$1)}function o$1(e,a){return e.forEach(a),e}var i$1=e=>(a,n,t)=>(e(a,n,t),{done:false,hasNext:true,next:a});
 
 function t$1(...r){return u$6(Object.entries,r)}
 
-function T(...a){return u$6(l,a,y)}var l=(a,e)=>a.filter(e),y=a=>(e,t,o)=>a(e,t,o)?{done:false,hasNext:true,next:e}:s$1;
+function T(...a){return u$6(l,a,y)}var l=(a,r)=>a.filter(r),y=a=>(r,t,o)=>a(r,t,o)?{done:false,hasNext:true,next:r}:s$1;
 
 function o(...e){return u$6(t,e)}var t=(e,r)=>{for(let n=e.length-1;n>=0;n--){let a=e[n];if(r(a,n,e))return a}};
 
@@ -115,6 +115,12 @@ class ElementModel {
   get isRoot() {
     return this.parent === null;
   }
+  get style() {
+    return {
+      size: DefaultShapeSize,
+      ...this.$element.style
+    };
+  }
   isAncestorOf(another) {
     return isAncestor(this, another);
   }
@@ -252,7 +258,7 @@ function isElementModel(element) {
 }
 
 function buildElementNotations(nodes) {
-  return x(
+  return C(
     nodes,
     i$2(p$1("notation")),
     i$3(
@@ -1353,7 +1359,7 @@ function topologicalSort(param) {
     allowSelfLoops: true,
     type: "directed"
   });
-  const enrichedEdges = x(
+  const enrichedEdges = C(
     edges,
     m$3((edge, __dirname) => {
       const source = getNode(edge.source), target = getNode(edge.target), parent = edge.parent ? getNode(edge.parent) : null;
@@ -1387,7 +1393,7 @@ function topologicalSort(param) {
   for (const { edge, source, target } of edgesBetweenLeafs) {
     addEdgeToGraph(edge);
     if (target.parent && target.parent !== edge.parent) {
-      x(
+      C(
         ancestorsOfNode(target, param.nodes),
         u$7((ancestor) => ancestor.inEdges.includes(edge.id)),
         u((ancestor) => {
@@ -1453,12 +1459,12 @@ function calcViewLayoutHash(view) {
     id: view.id,
     __: view.__ ?? "element",
     autoLayout: view.autoLayout,
-    nodes: x(
+    nodes: C(
       view.nodes,
       m$3(i$6(["id", "title", "description", "technology", "shape", "icon", "children"])),
       l$3(({ id, icon, ...node }) => [id, { ...node, icon: n$2(icon) ? "Y" : "N" }])
     ),
-    edges: x(
+    edges: C(
       view.edges,
       m$3(i$6(["source", "target", "label", "description", "technology", "dir", "head", "tail", "line"])),
       l$3(({ source, target, ...edge }) => [`${source}:${target}`, edge])
@@ -1535,6 +1541,7 @@ class AbstractDeploymentElementModel {
     return {
       shape: DefaultElementShape,
       color: DefaultThemeColor,
+      size: DefaultShapeSize,
       ...this.$node.style
     };
   }
@@ -1795,6 +1802,7 @@ class DeployedInstanceModel extends AbstractDeploymentElementModel {
     return {
       shape: this.element.shape,
       color: this.element.color,
+      size: DefaultShapeSize,
       ...icon && { icon },
       ...style,
       ...this.$instance.style
@@ -2173,7 +2181,7 @@ function sortConnectionsByBoundaryHierarchy(connections, sort) {
   return _sortByBoundary(connections, sort ?? "asc");
 }
 function _sortByBoundary(connections, order) {
-  return x(
+  return C(
     connections,
     m$3((conn) => ({
       id: boundaryHierarchy(conn),
@@ -2367,7 +2375,7 @@ class ConnectionModel {
    * Returns true if includes relations between nested elements of the source and target elements.
    */
   get isImplicit() {
-    return this.nonEmpty() && isome(this.relations, o$9(hasSameSourceTarget(this)));
+    return this.nonEmpty() && isome(this.relations, o$8(hasSameSourceTarget(this)));
   }
   get directRelations() {
     return new Set(ifilter(this.relations, hasSameSourceTarget(this)));
@@ -2587,7 +2595,7 @@ class AbstractStageExclude {
       disconnected,
       state.elements
     );
-    disconnected = x(
+    disconnected = C(
       disconnected,
       ifilter((el) => {
         return state.explicits.has(el) && !isome(state.final, isDescendantOf(el));
@@ -2675,7 +2683,6 @@ class AbstractStageExclude {
     if (this.excluded.elements.size > 0) {
       state = this.removeElements(state);
     }
-    state = this.moveDisconnectedExplicitsToImplicits(state);
     return this.memory.update(this.postcommit(state));
   }
 }
@@ -2881,7 +2888,7 @@ function findCrossBoundarySameSourceOrTarget(connections) {
     if (!i$9(sameRelationGroup, 2)) {
       continue;
     }
-    x(
+    C(
       sameRelationGroup,
       u$1((conn) => [
         { group: `$source-${conn.source.id}`, conn },
@@ -2944,7 +2951,7 @@ function findCrossBoundaryConnections(connections) {
       }
     }
   }
-  return x(
+  return C(
     excludedRelations.entries(),
     imap(
       ([c, excluded]) => c.update({
@@ -2962,7 +2969,7 @@ function cleanCrossBoundary(connections) {
   );
 }
 function findRedundantConnections$1(connections) {
-  return x(
+  return C(
     connections,
     mergeConnections,
     l$5((redundants, connection) => {
@@ -3044,17 +3051,17 @@ let StageInclude$1 = class StageInclude extends AbstractStageInclude {
     return hasChanged();
   }
   processConnections(connections) {
-    const clean = x(
+    const clean = C(
       connections,
       cleanCrossBoundary,
       cleanRedundantRelationships
     );
-    x(
+    C(
       clean,
       // Process only connection from this stage
       // filter(c => this._connections.some(c2 => c2.id === c.id)),
       u(({ source, target, boundary }) => {
-        x(
+        C(
           d$6(
             [...toArray(source.ancestors()).reverse(), source],
             [...toArray(target.ancestors()).reverse(), target]
@@ -3173,10 +3180,10 @@ function elementExprToPredicate(target) {
 }
 
 function applyViewRuleStyle(rule, predicates, nodes) {
-  x(
+  C(
     nodes,
-    T(o$9(ComputedNode.isNodesGroup)),
-    T(y$1(predicates)),
+    T(o$8(ComputedNode.isNodesGroup)),
+    T(y$2(predicates)),
     u((n) => {
       n.shape = rule.style.shape ?? n.shape;
       n.color = rule.style.color ?? n.color;
@@ -3196,6 +3203,15 @@ function applyViewRuleStyle(rule, predicates, nodes) {
       if (n$5(rule.style.multiple)) {
         styleOverride = { ...styleOverride, multiple: rule.style.multiple };
       }
+      if (n$5(rule.style.padding)) {
+        styleOverride = { ...styleOverride, padding: rule.style.padding };
+      }
+      if (n$5(rule.style.size)) {
+        styleOverride = { ...styleOverride, size: rule.style.size };
+      }
+      if (n$5(rule.style.textSize)) {
+        styleOverride = { ...styleOverride, textSize: rule.style.textSize };
+      }
       if (styleOverride) {
         n.style = {
           ...n.style,
@@ -3261,7 +3277,11 @@ function buildComputedNodes(elements, groups) {
       links: null,
       style: {
         border: viewRule.border ?? "dashed",
-        opacity: viewRule.opacity ?? 0
+        opacity: viewRule.opacity ?? 0,
+        size: viewRule.size ?? "md",
+        multiple: viewRule.multiple ?? false,
+        padding: viewRule.padding ?? "md",
+        textSize: viewRule.textSize ?? "md"
       }
     });
     for (const e of elements2) {
@@ -3351,7 +3371,7 @@ function pickRelationshipProps(relation) {
   };
 }
 function mergePropsFromRelationships(relations, prefer) {
-  const allprops = x(
+  const allprops = C(
     relations,
     l$5(
       (acc, r) => {
@@ -3435,7 +3455,7 @@ function mergePropsFromRelationships(relations, prefer) {
 }
 
 function uniqueTags(elements) {
-  const tags = x(
+  const tags = C(
     elements,
     u$1((e) => e.tags ?? []),
     i$8(),
@@ -3657,108 +3677,6 @@ function applyDeploymentViewRuleStyles(rules, nodes) {
   return nodes;
 }
 
-const DeploymentRefPredicate = {
-  include: (ctx) => {
-    const { expr } = ctx;
-    const el = ctx.model.element(expr.ref.deployment);
-    if (isDeployedInstance(el)) {
-      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: {
-        ctx.stage.addExplicit(el);
-        ctx.stage.connectWithExisting(el);
-      }
-    }
-    return ctx.stage;
-  },
-  exclude: ({ expr, stage, memory }) => {
-    const exprPredicate = deploymentExpressionToPredicate(expr);
-    stage.exclude([...memory.elements].filter(exprPredicate));
-    return stage;
-  }
-};
-function includeDeployedNodeChildren(node, { stage }) {
-  const children = [...node.children()];
-  if (children.length === 0) {
-    return;
-  }
-  stage.addImplicit(node);
-  stage.addConnections(findConnectionsWithin(children));
-  stage.connectWithExisting(children);
-  stage.addExplicit(children);
-}
-function includeDeployedNodeWithExpanded(node, { memory, stage }) {
-  const children = [...node.children()];
-  stage.addImplicit(node);
-  stage.connectWithExisting(node);
-  let hasConnectionsWithVisible = false;
-  for (const child of children) {
-    if (findConnectionsBetween(child, memory.elements).length > 0) {
-      hasConnectionsWithVisible = true;
-      break;
-    }
-  }
-  if (hasConnectionsWithVisible) {
-    stage.connectWithExisting(children, "in");
-    stage.addConnections(findConnectionsWithin(children));
-    stage.connectWithExisting(children, "out");
-  }
-  stage.addImplicit(children);
-  if (stage.connections.length > 0) {
-    stage.addExplicit(node);
-  }
-}
-function includeDeployedNodeDescendants(node, { stage }) {
-  const dfs = (node2) => {
-    const children = [];
-    for (const child of node2.children()) {
-      if (child.isDeploymentNode()) {
-        children.push(...dfs(child));
-      }
-      children.push(child);
-    }
-    stage.connectWithExisting(children, "in");
-    stage.addConnections(findConnectionsWithin(children));
-    stage.addImplicit(children);
-    return children;
-  };
-  const descendants = dfs(node);
-  if (descendants.length === 0) {
-    return;
-  }
-  stage.connectWithExisting(descendants, "out");
-  const allconnected = findConnectedElements(stage);
-  descendants.forEach((desc) => {
-    if (allconnected.has(desc)) {
-      stage.addExplicit(desc);
-    }
-  });
-}
-function findConnectedElements(stage) {
-  return x(
-    stage.mergedConnections(),
-    cleanCrossBoundary,
-    cleanRedundantRelationships,
-    l$5((acc, c) => {
-      acc.add(c.source);
-      acc.add(c.target);
-      return acc;
-    }, /* @__PURE__ */ new Set())
-  );
-}
-
 function isDeploymentNode(model) {
   return model.isDeploymentNode();
 }
@@ -3772,6 +3690,61 @@ function isDeploymentElementModel(x) {
   return x instanceof DeploymentNodeModel || x instanceof DeployedInstanceModel;
 }
 
+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 targets2 = [...resolveAscendingSiblings(source)];
+        const toInclude = applyPredicate(findConnectionsBetween(source, targets2, "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(source, targets, "directed"), where);
+      stage.addConnections(toInclude);
+    }
+    return stage;
+  },
+  exclude: ({ expr, model, memory, stage, where }) => {
+    if (FqnExpr.isModelRef(expr.incoming)) {
+      const excludedRelations = resolveAllImcomingRelations(model, expr.incoming);
+      return excludeModelRelations(excludedRelations, { stage, memory }, where);
+    }
+    if (FqnExpr.isWildcard(expr.incoming)) {
+      return stage;
+    }
+    const isIncoming = filterIncomingConnections(resolveElements$1(model, expr.incoming));
+    const toExclude = C(
+      memory.connections,
+      T(isIncoming),
+      applyPredicate(where)
+    );
+    stage.excludeConnections(toExclude);
+    return stage;
+  }
+};
+function filterIncomingConnections(targets) {
+  return y$2(
+    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]));
+}
+
 const OutgoingRelationPredicate = {
   include: ({ expr, model, memory, stage, where }) => {
     const targets = [...memory.elements];
@@ -3804,7 +3777,7 @@ const OutgoingRelationPredicate = {
       return stage;
     }
     const isOutgoing = filterOutgoingConnections(resolveElements$1(model, expr.outgoing));
-    const toExclude = x(
+    const toExclude = C(
       memory.connections,
       T(isOutgoing),
       applyPredicate(where)
@@ -3814,7 +3787,7 @@ const OutgoingRelationPredicate = {
   }
 };
 function filterOutgoingConnections(sources) {
-  return y$1(
+  return y$2(
     sources.map((source) => {
       const satisfies = (el) => el === source || isAncestor(source, el);
       return (connection) => {
@@ -3828,33 +3801,199 @@ function resolveAllOutgoingRelations(model, moodelRef) {
   return new Set(targets.flatMap((e) => [...e.allOutgoing]));
 }
 
-const InOutRelationPredicate$1 = {
-  include: ({ expr, model, memory, stage, where }) => {
-    const sources = [...memory.elements];
-    if (FqnExpr.isWildcard(expr.inout)) {
-      for (const source of sources) {
-        const targets2 = [...resolveAscendingSiblings(source)];
-        const toInclude = matchConnections(findConnectionsBetween(source, targets2, "both"), where);
-        stage.addConnections(toInclude);
+const resolveAscendingSiblings = (element) => {
+  const siblings = /* @__PURE__ */ new Set();
+  for (let sibling of element.descendingSiblings()) {
+    siblings.add(sibling);
+  }
+  return siblings;
+};
+const DirectRelationPredicate = {
+  include: ({ expr: { source, target, isBidirectional = false }, model, stage, where }) => {
+    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 = C(
+          findConnectionsWithin(model.instances()),
+          applyPredicate(where),
+          m$3((c) => {
+            stage.addImplicit(c.boundary);
+            return c;
+          })
+        );
+        break;
+      }
+      // source -> *; source <-> *
+      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 = C(
+          sources,
+          u$1((source2) => {
+            const targets = resolveAscendingSiblings(source2);
+            return findConnectionsBetween(source2, targets, dir);
+          }),
+          T(postFilter),
+          applyPredicate(where)
+        );
+        break;
+      }
+      // * -> target; * <-> target
+      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 = C(
+          targets,
+          u$1((target2) => {
+            const sources = resolveAscendingSiblings(target2);
+            return [...sources].flatMap((source2) => findConnection(source2, target2, dir));
+          }),
+          T(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 = C(
+          sources,
+          u$1((s) => findConnectionsBetween(s, targets, dir)),
+          T((c) => isSource(c) && isTarget(c)),
+          applyPredicate(where)
+        );
       }
-      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(source, targets, "both"), where);
-      stage.addConnections(toInclude);
+    stage.addConnections(connections);
+    if (FqnExpr.isDeploymentRef(source) && l$7(source.selector)) {
+      stage.addImplicit(model.element(source.ref.deployment));
+    }
+    if (FqnExpr.isDeploymentRef(target) && l$7(target.selector)) {
+      stage.addImplicit(model.element(target.ref.deployment));
     }
     return stage;
   },
   exclude: ({ expr, model, memory, stage, where }) => {
-    if (FqnExpr.isModelRef(expr.inout)) {
-      const elements2 = resolveModelElements(model, expr.inout);
-      if (elements2.length === 0) {
+    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;
-      }
-      const excludedRelations = union(
-        /* @__PURE__ */ new Set(),
+      // model -> model
+      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);
+      // model -> *
+      case (FqnExpr.isModelRef(expr.source) && FqnExpr.isWildcard(expr.target)):
+        modelRelationsToExclude = resolveAllOutgoingRelations(model, expr.source);
+        return excludeModelRelations(modelRelationsToExclude, { stage, memory }, where);
+      // model -> deployment
+      case FqnExpr.isModelRef(expr.source):
+        modelRelationsToExclude = resolveAllOutgoingRelations(model, expr.source);
+        return excludeModelRelations(
+          modelRelationsToExclude,
+          { stage, memory },
+          where,
+          (c) => isTarget(c.target)
+        );
+      // deployment -> model
+      case FqnExpr.isModelRef(expr.target):
+        modelRelationsToExclude = resolveAllImcomingRelations(model, expr.target);
+        return excludeModelRelations(
+          modelRelationsToExclude,
+          { stage, memory },
+          where,
+          (c) => isSource(c.source)
+        );
+      // deployment -> deployment
+      default:
+        const satisfies = (connection) => {
+          return isSource(connection.source) && isTarget(connection.target) || expr.isBidirectional === true && isSource(connection.target) && isTarget(connection.source);
+        };
+        const deploymentRelationsToExclude = C(
+          memory.connections,
+          T(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 source2 of sources) {
+    modelConnections.push(...findConnectionsBetween$1(source2, targets, dir));
+  }
+  return new Set(modelConnections.flatMap((c) => [...c.relations]));
+}
+
+const InOutRelationPredicate$1 = {
+  include: ({ expr, model, memory, stage, where }) => {
+    const sources = [...memory.elements];
+    if (FqnExpr.isWildcard(expr.inout)) {
+      for (const source of sources) {
+        const targets2 = [...resolveAscendingSiblings(source)];
+        const toInclude = matchConnections(findConnectionsBetween(source, targets2, "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(source, targets, "both"), where);
+      stage.addConnections(toInclude);
+    }
+    return stage;
+  },
+  exclude: ({ expr, model, memory, stage, where }) => {
+    if (FqnExpr.isModelRef(expr.inout)) {
+      const elements2 = resolveModelElements(model, expr.inout);
+      if (elements2.length === 0) {
+        return stage;
+      }
+      const excludedRelations = union(
+        /* @__PURE__ */ new Set(),
         ...elements2.flatMap((e) => [e.allIncoming, e.allOutgoing])
       );
       return excludeModelRelations(excludedRelations, { stage, memory }, where);
@@ -3865,7 +4004,7 @@ const InOutRelationPredicate$1 = {
     const elements = resolveElements$1(model, expr.inout);
     const isIncoming = filterIncomingConnections(elements);
     const isOutgoing = filterOutgoingConnections(elements);
-    const toExclude = x(
+    const toExclude = C(
       memory.connections,
       T((c) => isIncoming(c) !== isOutgoing(c)),
       applyPredicate(where)
@@ -3887,14 +4026,18 @@ const WhereRelationPredicate = {
 };
 
 const WildcardPredicate$1 = {
-  include: ({ model, stage }) => {
+  include: ({ model, stage, where }) => {
     const children = [];
-    const rootElements = [...model.roots()].map((root) => {
-      if (!root.onlyOneInstance()) {
-        children.push(...root.children());
-      }
-      return root;
-    });
+    const rootElements = C(
+      [...model.roots()],
+      applyElementPredicate(where),
+      m$3((root) => {
+        if (!root.onlyOneInstance()) {
+          children.push(...root.children());
+        }
+        return root;
+      })
+    );
     stage.addExplicit(rootElements);
     if (children.length > 1) {
       stage.addConnections(findConnectionsWithin([
@@ -3904,8 +4047,12 @@ const WildcardPredicate$1 = {
     }
     return stage;
   },
-  exclude: ({ stage, memory }) => {
-    stage.exclude(memory.elements);
+  exclude: ({ stage, memory, where }) => {
+    const elementsToExclude = C(
+      [...memory.elements],
+      applyElementPredicate(where)
+    );
+    stage.exclude(elementsToExclude);
     return stage;
   }
 };
@@ -3936,7 +4083,7 @@ function excludeModelRelations(relationsToExclude, { stage, memory }, where, fil
   if (relationsToExclude.size === 0) {
     return stage;
   }
-  const toExclude = x(
+  const toExclude = C(
     memory.connections,
     T((c) => filterConnections(c)),
     // Find connections that have at least one relation in common with the excluded relations
@@ -3966,7 +4113,7 @@ function applyPredicate(...args) {
   if (where === null) {
     return c;
   }
-  if (o$a(c)) {
+  if (o$9(c)) {
     return c.map((x) => applyPredicate(x, where)).filter((x) => x.nonEmpty());
   }
   return c.update({
@@ -3974,11 +4121,21 @@ function applyPredicate(...args) {
     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 (o$9(c)) {
+    return c.filter((x) => applyElementPredicate(x, where));
+  }
+  return where?.(toFilterable(c, c)) ?? true;
+}
 function matchConnections(connections, where) {
   if (!where) {
     return connections;
   }
-  return x(
+  return C(
     connections,
     T((c) => matchConnection(c, where))
   );
@@ -4014,225 +4171,117 @@ function toFilterableRelation(c) {
   });
 }
 
-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 targets2 = [...resolveAscendingSiblings(source)];
-        const toInclude = applyPredicate(findConnectionsBetween(source, targets2, "directed"), where);
-        stage.addConnections(toInclude);
+const DeploymentRefPredicate = {
+  include: (ctx) => {
+    const { expr, where } = ctx;
+    const el = ctx.model.element(expr.ref.deployment);
+    if (isDeployedInstance(el)) {
+      if (applyElementPredicate(el, where)) {
+        ctx.stage.addExplicit(el);
+        ctx.stage.connectWithExisting(el);
       }
-      return stage;
+      return ctx.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(source, targets, "directed"), where);
-      stage.addConnections(toInclude);
+    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 stage;
+    return ctx.stage;
   },
-  exclude: ({ expr, model, memory, stage, where }) => {
-    if (FqnExpr.isModelRef(expr.incoming)) {
-      const excludedRelations = resolveAllImcomingRelations(model, expr.incoming);
-      return excludeModelRelations(excludedRelations, { stage, memory }, where);
-    }
-    if (FqnExpr.isWildcard(expr.incoming)) {
-      return stage;
-    }
-    const isIncoming = filterIncomingConnections(resolveElements$1(model, expr.incoming));
-    const toExclude = x(
-      memory.connections,
-      T(isIncoming),
-      applyPredicate(where)
+  exclude: ({ expr, stage, memory, where }) => {
+    const exprPredicate = deploymentExpressionToPredicate(expr);
+    const toExclude = C(
+      [...memory.elements],
+      T(exprPredicate),
+      applyElementPredicate(where)
     );
-    stage.excludeConnections(toExclude);
+    stage.exclude(toExclude);
     return stage;
   }
 };
-function filterIncomingConnections(targets) {
-  return y$1(
-    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]));
+function includeDeployedNodeChildren(node, { stage, where }) {
+  const children = applyElementPredicate([...node.children()], where);
+  if (children.length === 0) {
+    return;
+  }
+  stage.addImplicit(node);
+  stage.addConnections(findConnectionsWithin(children));
+  stage.connectWithExisting(children);
+  stage.addExplicit(children);
 }
-
-const resolveAscendingSiblings = (element) => {
-  const siblings = /* @__PURE__ */ new Set();
-  for (let sibling of element.descendingSiblings()) {
-    siblings.add(sibling);
+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(child, memory.elements).length > 0) {
+      hasConnectionsWithVisible = true;
+      break;
+    }
   }
-  return siblings;
-};
-const DirectRelationPredicate = {
-  include: ({ expr: { source, target, isBidirectional = false }, model, stage, where }) => {
-    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 = x(
-          findConnectionsWithin(model.instances()),
-          applyPredicate(where),
-          m$3((c) => {
-            stage.addImplicit(c.boundary);
-            return c;
-          })
-        );
-        break;
-      }
-      // source -> *; source <-> *
-      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 = x(
-          sources,
-          u$1((source2) => {
-            const targets = resolveAscendingSiblings(source2);
-            return findConnectionsBetween(source2, targets, dir);
-          }),
-          T(postFilter),
-          applyPredicate(where)
-        );
-        break;
-      }
-      // * -> target; * <-> target
-      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 = x(
-          targets,
-          u$1((target2) => {
-            const sources = resolveAscendingSiblings(target2);
-            return [...sources].flatMap((source2) => findConnection(source2, target2, dir));
-          }),
-          T(postFilter),
-          applyPredicate(where)
-        );
-        break;
+  if (hasConnectionsWithVisible) {
+    stage.connectWithExisting(children, "in");
+    stage.addConnections(findConnectionsWithin(children));
+    stage.connectWithExisting(children, "out");
+  }
+  stage.addImplicit(children);
+  if (stage.connections.length > 0) {
+    stage.addExplicit(node);
+  }
+}
+function includeDeployedNodeDescendants(node, { stage, where }) {
+  const dfs = (node2) => {
+    const children = [];
+    for (const child of node2.children()) {
+      if (child.isDeploymentNode()) {
+        children.push(...dfs(child));
       }
-      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 = x(
-          sources,
-          u$1((s) => findConnectionsBetween(s, targets, dir)),
-          T((c) => isSource(c) && isTarget(c)),
-          applyPredicate(where)
-        );
+      if (applyElementPredicate(child, where)) {
+        children.push(child);
       }
     }
-    stage.addConnections(connections);
-    if (FqnExpr.isDeploymentRef(source) && l$7(source.selector)) {
-      stage.addImplicit(model.element(source.ref.deployment));
-    }
-    if (FqnExpr.isDeploymentRef(target) && l$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;
-      // model -> model
-      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);
-      // model -> *
-      case (FqnExpr.isModelRef(expr.source) && FqnExpr.isWildcard(expr.target)):
-        modelRelationsToExclude = resolveAllOutgoingRelations(model, expr.source);
-        return excludeModelRelations(modelRelationsToExclude, { stage, memory }, where);
-      // model -> deployment
-      case FqnExpr.isModelRef(expr.source):
-        modelRelationsToExclude = resolveAllOutgoingRelations(model, expr.source);
-        return excludeModelRelations(
-          modelRelationsToExclude,
-          { stage, memory },
-          where,
-          (c) => isTarget(c.target)
-        );
-      // deployment -> model
-      case FqnExpr.isModelRef(expr.target):
-        modelRelationsToExclude = resolveAllImcomingRelations(model, expr.target);
-        return excludeModelRelations(
-          modelRelationsToExclude,
-          { stage, memory },
-          where,
-          (c) => isSource(c.source)
-        );
-      // deployment -> deployment
-      default:
-        const satisfies = (connection) => {
-          return isSource(connection.source) && isTarget(connection.target) || expr.isBidirectional === true && isSource(connection.target) && isTarget(connection.source);
-        };
-        const deploymentRelationsToExclude = x(
-          memory.connections,
-          T(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 source2 of sources) {
-    modelConnections.push(...findConnectionsBetween$1(source2, targets, dir));
+    stage.connectWithExisting(children, "in");
+    stage.addConnections(findConnectionsWithin(children));
+    stage.addImplicit(children);
+    return children;
+  };
+  const descendants = dfs(node);
+  if (descendants.length === 0) {
+    return;
   }
-  return new Set(modelConnections.flatMap((c) => [...c.relations]));
+  stage.connectWithExisting(descendants, "out");
+  const allConnected = findConnectedElements(stage);
+  C(
+    descendants,
+    T((desc) => allConnected.has(desc)),
+    u((desc) => stage.addExplicit(desc))
+  );
+}
+function findConnectedElements(stage) {
+  return C(
+    stage.mergedConnections(),
+    cleanCrossBoundary,
+    cleanRedundantRelationships,
+    l$5((acc, c) => {
+      acc.add(c.source);
+      acc.add(c.target);
+      return acc;
+    }, /* @__PURE__ */ new Set())
+  );
 }
 
 let StageFinal$1 = class StageFinal {
@@ -4246,7 +4295,7 @@ let StageFinal$1 = class StageFinal {
     if (memory.connections.length < 2) {
       return memory;
     }
-    const connections = x(
+    const connections = C(
       memory.connections,
       // Keep connections
       // - between leafs
@@ -4298,7 +4347,7 @@ let StageFinal$1 = class StageFinal {
       }
       return false;
     };
-    x(
+    C(
       difference(implicits, snapshot),
       ifilter((e) => e.isDeploymentNode()),
       toArray(),
@@ -4483,7 +4532,15 @@ function applyCustomElementProperties(_rules, _nodes) {
   for (const {
     custom: { expr, ...props }
   } of rules) {
-    const { border, opacity, multiple, ...rest } = d$1(props, n$4);
+    const {
+      border,
+      opacity,
+      multiple,
+      padding,
+      size,
+      textSize,
+      ...rest
+    } = d$1(props, n$4);
     const notEmpty = !n(rest);
     const satisfies = elementExprToPredicate(expr);
     nodes.forEach((node, i) => {
@@ -4507,6 +4564,15 @@ function applyCustomElementProperties(_rules, _nodes) {
       if (multiple !== undefined) {
         styleOverride = { ...styleOverride, multiple };
       }
+      if (padding !== undefined) {
+        styleOverride = { ...styleOverride, padding };
+      }
+      if (size !== undefined) {
+        styleOverride = { ...styleOverride, size };
+      }
+      if (textSize !== undefined) {
+        styleOverride = { ...styleOverride, textSize };
+      }
       if (styleOverride) {
         node = {
           ...node,
@@ -4737,7 +4803,7 @@ class DynamicViewCompute {
         notation: null
       };
     }
-    const alltags = x(
+    const alltags = C(
       relationships,
       u$1((r) => r.tags),
       T(n$2),
@@ -4747,7 +4813,7 @@ class DynamicViewCompute {
     const relations = i$9(relationships, 1) ? m$3(relationships, (r) => r.id) : null;
     const relation = t$2(relationships) || relationships.find((r) => r.source === source && r.target === target);
     const relationNavigateTo = relation?.$relationship.navigateTo ?? null;
-    const navigateTo = relationNavigateTo && relationNavigateTo !== this.view.id ? relationNavigateTo : x(
+    const navigateTo = relationNavigateTo && relationNavigateTo !== this.view.id ? relationNavigateTo : C(
       relationships,
       m$3((r) => r.$relationship.navigateTo),
       T(n$2),
@@ -4755,7 +4821,7 @@ class DynamicViewCompute {
       i$8(),
       t$2()
     );
-    const commonProperties = x(
+    const commonProperties = C(
       relationships,
       l$5((acc, { title, $relationship: r }) => {
         n$2(title) && acc.title.add(title);
@@ -4882,7 +4948,7 @@ class NodesGroup {
 
 class StageExclude extends AbstractStageExclude {
   excludeRelations(excluded) {
-    x(
+    C(
       this.memory.connections,
       T((c) => hasIntersection(c.relations, excluded)),
       u((c) => {
@@ -4979,10 +5045,10 @@ class StageInclude extends AbstractStageInclude {
     if (isRelationPredicateExpr(this.expression)) {
       return connections;
     }
-    x(
+    C(
       connections,
       u(({ source, target, boundary }) => {
-        x(
+        C(
           d$6(
             [...toArray(source.ancestors()).reverse(), source],
             [...toArray(target.ancestors()).reverse(), target]
@@ -5142,7 +5208,7 @@ class ActiveGroupMemory extends Memory {
 }
 
 function findRedundantConnections(connections) {
-  return x(
+  return C(
     [...connections],
     mergeConnections,
     l$5((reducedConnections, connection, _, all) => {
@@ -5222,7 +5288,7 @@ class StageFinal {
       }
       return false;
     };
-    x(
+    C(
       difference(implicits, snapshot),
       toArray(),
       sortByFqnHierarchically,
@@ -5335,7 +5401,7 @@ function includeDescendantsFromMemory(elements, memory) {
   if (memory.isEmpty() || elements.length === 0) {
     return elements;
   }
-  const descedantsOf = y$1(elements.map((e) => isDescendantOf(e)));
+  const descedantsOf = y$2(elements.map((e) => isDescendantOf(e)));
   const fromMemory = toArray(
     ifilter(
       memory.elements,
@@ -5458,7 +5524,7 @@ const DirectRelationExprPredicate = {
       // This is a special case, we look for all relationships that satisfy the where clause
       // * -> * ; Empty memory; Where clause
       case (sourceIsWildcard && targetIsWildcard && memory.isEmpty() && where !== NoWhere): {
-        const connections2 = x(
+        const connections2 = C(
           model.relationships(),
           ifilter(where),
           toArray(),
@@ -5486,10 +5552,10 @@ const DirectRelationExprPredicate = {
       // element -> *; Where clause
       case (!sourceIsWildcard && targetIsWildcard && where !== NoWhere): {
         const sources = resolveElements(model, source);
-        const connections2 = x(
+        const connections2 = C(
           sources,
           u$1(
-            (source2) => x(
+            (source2) => C(
               source2,
               d$5(r(isBidirectional === true), {
                 onTrue: (s) => union(s.allIncoming, s.allOutgoing),
@@ -5500,7 +5566,7 @@ const DirectRelationExprPredicate = {
               toArray(),
               d$3((r) => r.source === source2),
               ([outgoing, incoming]) => a(
-                x(
+                C(
                   outgoing,
                   m$3(
                     (outgoing2) => new ConnectionModel(
@@ -5510,7 +5576,7 @@ const DirectRelationExprPredicate = {
                     )
                   )
                 ),
-                x(
+                C(
                   incoming,
                   m$3(
                     (incoming2) => new ConnectionModel(
@@ -5542,10 +5608,10 @@ const DirectRelationExprPredicate = {
       // * -> element; Where clause
       case (sourceIsWildcard && !targetIsWildcard && where !== NoWhere): {
         const targets = resolveElements(model, target);
-        const connections2 = x(
+        const connections2 = C(
           targets,
           u$1(
-            (target2) => x(
+            (target2) => C(
               target2,
               d$5(r(isBidirectional === true), {
                 onTrue: (s) => union(s.allIncoming, s.allOutgoing),
@@ -5555,7 +5621,7 @@ const DirectRelationExprPredicate = {
               toArray(),
               d$3((r) => r.target === target2),
               ([incoming, outgoing]) => a(
-                x(
+                C(
                   outgoing,
                   m$3(
                     (outgoing2) => new ConnectionModel(
@@ -5565,7 +5631,7 @@ const DirectRelationExprPredicate = {
                     )
                   )
                 ),
-                x(
+                C(
                   incoming,
                   m$3(
                     (incoming2) => new ConnectionModel(
@@ -5618,7 +5684,7 @@ const DirectRelationExprPredicate = {
     switch (true) {
       // * -> *
       case (sourceIsWildcard && targetIsWildcard): {
-        relations = x(
+        relations = C(
           memory.connections,
           u$1(i$4(
             p$1("relations"),
@@ -5632,10 +5698,10 @@ const DirectRelationExprPredicate = {
       // element -> *
       case (!sourceIsWildcard && targetIsWildcard): {
         const sources = resolveElements(model, source);
-        relations = x(
+        relations = C(
           sources,
           u$1(
-            (source2) => x(
+            (source2) => C(
               source2,
               d$5(r(isBidirectional === true), {
                 onTrue: (s) => union(s.allIncoming, s.allOutgoing),
@@ -5652,10 +5718,10 @@ const DirectRelationExprPredicate = {
       // * -> element
       case (sourceIsWildcard && !targetIsWildcard): {
         const targets = resolveElements(model, target);
-        relations = x(
+        relations = C(
           targets,
           u$1(
-            (target2) => x(
+            (target2) => C(
               target2,
               d$5(r(isBidirectional === true), {
                 onTrue: (s) => union(s.allIncoming, s.allOutgoing),
@@ -5707,7 +5773,7 @@ function resolveWildcard(nonWildcard, { memory, model }) {
       includeDescendantsFromMemory(targets2, memory)
     ];
   }
-  const targets = x(
+  const targets = C(
     sources,
     m$3((el) => el.ascendingSiblings()),
     iflat(),
@@ -5786,14 +5852,14 @@ function incomingConnectionPredicate(model, expr) {
       return (connection) => isElement(connection.target);
     }
     case (isElementRef(expr) && expr.isChildren): {
-      return y$1(
+      return y$2(
         [...model.children(expr.element)].map(
           (el) => Connection.isIncoming(el.id)
         )
       );
     }
     case (isElementRef(expr) && expr.isDescendants): {
-      return y$1([
+      return y$2([
         Connection.isInside(expr.element),
         ...[...model.children(expr.element)].map(
           (el) => Connection.isIncoming(el.id)
@@ -5801,7 +5867,7 @@ function incomingConnectionPredicate(model, expr) {
       ]);
     }
     case isExpandedElementExpr(expr): {
-      return y$1([
+      return y$2([
         Connection.isIncoming(expr.expanded),
         Connection.isInside(expr.expanded)
       ]);
@@ -5936,14 +6002,14 @@ function outgoingConnectionPredicate(model, expr) {
       return (connection) => isElement(connection.source);
     }
     case (isElementRef(expr) && expr.isChildren): {
-      return y$1(
+      return y$2(
         [...model.children(expr.element)].map(
           (el) => Connection.isOutgoing(el.id)
         )
       );
     }
     case (isElementRef(expr) && expr.isDescendants): {
-      return y$1([
+      return y$2([
         Connection.isInside(expr.element),
         ...[...model.children(expr.element)].map(
           (el) => Connection.isOutgoing(el.id)
@@ -5951,7 +6017,7 @@ function outgoingConnectionPredicate(model, expr) {
       ]);
     }
     case isExpandedElementExpr(expr): {
-      return y$1([
+      return y$2([
         Connection.isOutgoing(expr.expanded),
         Connection.isInside(expr.expanded)
       ]);
@@ -6072,7 +6138,7 @@ function processRelationtPredicate(expr, op, ctx) {
         return new Set(T([...relations], where));
       };
       const filterWhere = (connections) => {
-        return x(
+        return C(
           connections,
           m$3((c) => new ConnectionModel(c.source, c.target, filterRelations(c.relations))),
           T((c) => c.nonEmpty())
@@ -6230,7 +6296,7 @@ function assignElementsToGroups(memory) {
     }
     return false;
   };
-  x(
+  C(
     sortParentsFirst([...memory.explicitFirstSeenIn.keys()]),
     u((el) => {
       if (!isAncestorAssigned(el)) {
@@ -6240,7 +6306,7 @@ function assignElementsToGroups(memory) {
       }
     })
   );
-  x(
+  C(
     sortParentsFirst([...memory.lastSeenIn.keys()]),
     T((el) => !assignedTo.has(el)),
     u((el) => {
@@ -7088,7 +7154,7 @@ class LikeC4Model {
       }
     }
     this.deployment = new LikeC4DeploymentModel(this, $model.deployments);
-    const views = x(
+    const views = C(
       r$3($model.views),
       m$1((a, b) => compareNatural(a.title ?? "untitled", b.title ?? "untitled"))
     );