@likec4/core 1.20.3 → 1.21.0

package/dist/shared/{core.DRfrKNT6.cjs → core.D91uYrqI.cjs}

@@ -1,50 +1,50 @@
 'use strict';
 
-const object_hash = require('./core.FACQZmma.cjs');
-const view = require('./core.uxHtIZaH.cjs');
-const chunkRAAYCPUM = require('./core.CKYxnFEl.cjs');
+const view = require('./core.CAkSSvJ6.cjs');
+const object_hash = require('./core.BjR0D3IO.cjs');
+const chunkWIMGWYZL = require('./core.DqQrj2oQ.cjs');
 
-function f(t,i){let o=i.length-t.length;if(o===1){let[n,...r]=i;return object_hash.x(n,{lazy:t,lazyArgs:r})}if(o===0){let n={lazy:t,lazyArgs:i};return Object.assign(e=>object_hash.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 object_hash.C(n,{lazy:t,lazyArgs:r})}if(a===0){let n={lazy:t,lazyArgs:i};return Object.assign(e=>object_hash.C(e,n),n)}throw new Error("Wrong number of arguments")}
 
-function r$3(...t){return chunkRAAYCPUM.u(Object.values,t)}
+function r$3(...t){return chunkWIMGWYZL.u(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)?object_hash.s:(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)?object_hash.s:(e.add(t),{done:false,hasNext:true,next:t})}
 
-function l$6(...e){return chunkRAAYCPUM.u(o$7,e,u$5)}var o$7=(e,r)=>r<0?[]:e.slice(0,r);function u$5(e){if(e<=0)return object_hash.a;let r=e;return a=>(r-=1,{done:r<=0,hasNext:true,next:a})}
+function l$6(...r){return chunkWIMGWYZL.u(o$7,r,u$5)}var o$7=(r,e)=>e<0?[]:r.slice(0,e);function u$5(r){if(r<=0)return object_hash.a;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;
 
-function m$1(...r){return chunkRAAYCPUM.u(o$6,r)}function o$6(r,t){let e=[...r];return e.sort(t),e}
+function m$1(...r){return chunkWIMGWYZL.u(o$6,r)}function o$6(r,t){let e=[...r];return e.sort(t),e}
 
 function a$3(...r){return s(n$3,r)}var n$3=(r,t)=>[...r].sort(t);
 
-function l$5(...e){return chunkRAAYCPUM.u(u$3,e)}var u$3=(e,a,n)=>e.reduce(a,n);
+function l$5(...e){return chunkWIMGWYZL.u(u$3,e)}var u$3=(e,a,n)=>e.reduce(a,n);
 
-function t$4(...e){return chunkRAAYCPUM.u(r$2,e)}function r$2(e){return [...e].reverse()}
+function t$4(...e){return chunkWIMGWYZL.u(r$2,e)}function r$2(e){return [...e].reverse()}
 
-function p$1(...e){return chunkRAAYCPUM.u(t$3,e)}var t$3=(e,o)=>e[o];
+function p$1(...e){return chunkWIMGWYZL.u(t$3,e)}var t$3=(e,o)=>e[o];
 
-function d$3(...r){return chunkRAAYCPUM.u(i$7,r)}var i$7=(r,t)=>{let a=[[],[]];for(let[o,e]of r.entries())t(e,o,r)?a[0].push(e):a[1].push(e);return a};
+function d$3(...r){return chunkWIMGWYZL.u(i$7,r)}var i$7=(r,t)=>{let a=[[],[]];for(let[o,e]of r.entries())t(e,o,r)?a[0].push(e):a[1].push(e);return a};
 
-function i$6(...e){return chunkRAAYCPUM.u(o$5,e)}function o$5(e,n){let t={};for(let r of n)r in e&&(t[r]=e[r]);return t}
+function i$6(...e){return chunkWIMGWYZL.u(o$5,e)}function o$5(e,n){let t={};for(let r of n)r in e&&(t[r]=e[r]);return t}
 
-function d$2(...e){return chunkRAAYCPUM.u(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 d$2(...e){return chunkWIMGWYZL.u(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=>object_hash.x(o,...n)}
+function i$4(...n){return o=>object_hash.C(o,...n)}
 
-function d$1(...e){return chunkRAAYCPUM.u(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}
+function d$1(...e){return chunkWIMGWYZL.u(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}
 
-function t$2(...n){return chunkRAAYCPUM.u(o$4,n)}var o$4=n=>n.length===1?n[0]:undefined;
+function t$2(...n){return chunkWIMGWYZL.u(o$4,n)}var o$4=n=>n.length===1?n[0]:undefined;
 
-function i$3(...e){return chunkRAAYCPUM.u(o$3,e)}function o$3(e,r){let a={};for(let[n,u]of Object.entries(e)){let l=r(u,n,e);a[n]=l;}return a}
+function i$3(...e){return chunkWIMGWYZL.u(o$3,e)}function o$3(e,r){let a={};for(let[n,u]of Object.entries(e)){let l=r(u,n,e);a[n]=l;}return a}
 
 function n$2(e){return !!e}
 
-function a$2(...e){return chunkRAAYCPUM.u(n$1,e)}var n$1=e=>e.at(-1);
+function a$2(...e){return chunkWIMGWYZL.u(n$1,e)}var n$1=e=>e.at(-1);
 
-function l$3(...n){return chunkRAAYCPUM.u(d,n)}function d(n,o){let e={};for(let[a,t]of n.entries()){let[y,u]=o(t,a,n);e[y]=u;}return e}
+function l$3(...n){return chunkWIMGWYZL.u(d,n)}function d(n,o){let e={};for(let[a,t]of n.entries()){let[y,u]=o(t,a,n);e[y]=u;}return e}
 
 function e$1(r){return typeof r=="number"&&!Number.isNaN(r)}
 
@@ -52,23 +52,23 @@ function n(e){return e===undefined?true:typeof e=="string"||Array.isArray(e)?e.l
 
 function e(o){return typeof o=="boolean"}
 
-function i$2(...e){return chunkRAAYCPUM.u(p,e)}var p=(e,a)=>{let n={};for(let[d,t]of e.entries()){let y=a(t,d,e);if(y!==undefined){let{[y]:r}=n;r===undefined&&(r=[],n[y]=r),r.push(t);}}return n};
+function i$2(...e){return chunkWIMGWYZL.u(p,e)}var p=(e,a)=>{let n={};for(let[d,t]of e.entries()){let y=a(t,d,e);if(y!==undefined){let{[y]:r}=n;r===undefined&&(r=[],n[y]=r),r.push(t);}}return n};
 
-function k(...n){return chunkRAAYCPUM.u(u$2,n)}function u$2(n,e){if(n===e||Object.is(n,e))return  true;if(typeof n!="object"||typeof e!="object"||n===null||e===null||Object.getPrototypeOf(n)!==Object.getPrototypeOf(e))return  false;if(Array.isArray(n))return l$2(n,e);if(n instanceof Map)return a$1(n,e);if(n instanceof Set)return c(n,e);if(n instanceof Date)return n.getTime()===e.getTime();if(n instanceof RegExp)return n.toString()===e.toString();if(Object.keys(n).length!==Object.keys(e).length)return  false;for(let[r,t]of Object.entries(n))if(!(r in e)||!u$2(t,e[r]))return  false;return  true}function l$2(n,e){if(n.length!==e.length)return  false;for(let[r,t]of n.entries())if(!u$2(t,e[r]))return  false;return  true}function a$1(n,e){if(n.size!==e.size)return  false;for(let[r,t]of n.entries())if(!e.has(r)||!u$2(t,e.get(r)))return  false;return  true}function c(n,e){if(n.size!==e.size)return  false;let r=[...e];for(let t of n){let o=false;for(let[s,f]of r.entries())if(u$2(t,f)){o=true,r.splice(s,1);break}if(!o)return  false}return  true}
+function k(...n){return chunkWIMGWYZL.u(u$2,n)}function u$2(n,e){if(n===e||Object.is(n,e))return  true;if(typeof n!="object"||typeof e!="object"||n===null||e===null||Object.getPrototypeOf(n)!==Object.getPrototypeOf(e))return  false;if(Array.isArray(n))return l$2(n,e);if(n instanceof Map)return a$1(n,e);if(n instanceof Set)return c(n,e);if(n instanceof Date)return n.getTime()===e.getTime();if(n instanceof RegExp)return n.toString()===e.toString();if(Object.keys(n).length!==Object.keys(e).length)return  false;for(let[r,t]of Object.entries(n))if(!(r in e)||!u$2(t,e[r]))return  false;return  true}function l$2(n,e){if(n.length!==e.length)return  false;for(let[r,t]of n.entries())if(!u$2(t,e[r]))return  false;return  true}function a$1(n,e){if(n.size!==e.size)return  false;for(let[r,t]of n.entries())if(!e.has(r)||!u$2(t,e.get(r)))return  false;return  true}function c(n,e){if(n.size!==e.size)return  false;let r=[...e];for(let t of n){let o=false;for(let[s,f]of r.entries())if(u$2(t,f)){o=true,r.splice(s,1);break}if(!o)return  false}return  true}
 
-function u$1(...a){return chunkRAAYCPUM.u(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$1(...a){return chunkWIMGWYZL.u(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 chunkRAAYCPUM.u(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 chunkWIMGWYZL.u(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 chunkRAAYCPUM.u(Object.entries,r)}
+function t$1(...r){return chunkWIMGWYZL.u(Object.entries,r)}
 
-function T(...a){return chunkRAAYCPUM.u(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}:object_hash.s;
+function T(...a){return chunkWIMGWYZL.u(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}:object_hash.s;
 
-function o(...e){return chunkRAAYCPUM.u(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}};
+function o(...e){return chunkWIMGWYZL.u(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}};
 
-function m(...e){return chunkRAAYCPUM.u(i,e)}function i(e,t){for(let[n,o]of e.entries())if(!t(o,n,e))return e.slice(n);return []}
+function m(...e){return chunkWIMGWYZL.u(i,e)}function i(e,t){for(let[n,o]of e.entries())if(!t(o,n,e))return e.slice(n);return []}
 
-function a(...e){return chunkRAAYCPUM.u(r$1,e)}var r$1=(e,t)=>[...e,...t];
+function a(...e){return chunkWIMGWYZL.u(r$1,e)}var r$1=(e,t)=>[...e,...t];
 
 function r(n){return ()=>n}
 
@@ -117,6 +117,12 @@ class ElementModel {
   get isRoot() {
     return this.parent === null;
   }
+  get style() {
+    return {
+      size: view.DefaultShapeSize,
+      ...this.$element.style
+    };
+  }
   isAncestorOf(another) {
     return object_hash.isAncestor(this, another);
   }
@@ -254,7 +260,7 @@ function isElementModel(element) {
 }
 
 function buildElementNotations(nodes) {
-  return object_hash.x(
+  return object_hash.C(
     nodes,
     i$2(p$1("notation")),
     i$3(
@@ -310,7 +316,7 @@ function ancestorsOfNode(node, nodes) {
   const ancestors = [];
   let parentId = node.parent;
   while (parentId) {
-    const parentNode = chunkRAAYCPUM.nonNullable(nodes.get(parentId), `Parent node ${parentId} not found`);
+    const parentNode = chunkWIMGWYZL.nonNullable(nodes.get(parentId), `Parent node ${parentId} not found`);
     ancestors.push(parentNode);
     parentId = parentNode.parent;
   }
@@ -321,8 +327,8 @@ function linkNodesWithEdges(nodesMap, edges) {
   for (const edge of edges) {
     const source = nodesMap.get(edge.source);
     const target = nodesMap.get(edge.target);
-    chunkRAAYCPUM.invariant(source, `Source node ${edge.source} not found`);
-    chunkRAAYCPUM.invariant(target, `Target node ${edge.target} not found`);
+    chunkWIMGWYZL.invariant(source, `Source node ${edge.source} not found`);
+    chunkWIMGWYZL.invariant(target, `Target node ${edge.target} not found`);
     source.outEdges.push(edge.id);
     target.inEdges.push(edge.id);
     const sourceAncestors = ancestorsOfNode(source, nodesMap);
@@ -1349,13 +1355,13 @@ function topologicalSort(param) {
       edges
     };
   }
-  const getNode = (id) => chunkRAAYCPUM.nonNullable(param.nodes.get(id));
+  const getNode = (id) => chunkWIMGWYZL.nonNullable(param.nodes.get(id));
   const g = new Graph({
     multi: true,
     allowSelfLoops: true,
     type: "directed"
   });
-  const enrichedEdges = object_hash.x(
+  const enrichedEdges = object_hash.C(
     edges,
     object_hash.m((edge, __dirname) => {
       const source = getNode(edge.source), target = getNode(edge.target), parent = edge.parent ? getNode(edge.parent) : null;
@@ -1389,7 +1395,7 @@ function topologicalSort(param) {
   for (const { edge, source, target } of edgesBetweenLeafs) {
     addEdgeToGraph(edge);
     if (target.parent && target.parent !== edge.parent) {
-      object_hash.x(
+      object_hash.C(
         ancestorsOfNode(target, param.nodes),
         object_hash.u((ancestor) => ancestor.inEdges.includes(edge.id)),
         u((ancestor) => {
@@ -1419,13 +1425,13 @@ function topologicalSort(param) {
   for (const { edge } of edgesWithCompounds) {
     addEdgeToGraph(edge);
   }
-  chunkRAAYCPUM.invariant(sortedEdges.length === edges.length, "Not all edges were added to the graph");
+  chunkWIMGWYZL.invariant(sortedEdges.length === edges.length, "Not all edges were added to the graph");
   const sortedIds = topologicalSortExports.topologicalSort(g);
   let sorted = [];
   let unsorted = nodes.slice();
   for (const sortedId of sortedIds) {
     const indx = unsorted.findIndex((n) => n.id === sortedId);
-    chunkRAAYCPUM.invariant(indx >= 0, `Node "${sortedId}" not found`);
+    chunkWIMGWYZL.invariant(indx >= 0, `Node "${sortedId}" not found`);
     sorted.push(...unsorted.splice(indx, 1));
   }
   if (unsorted.length > 0 && sorted.length > 0) {
@@ -1455,12 +1461,12 @@ function calcViewLayoutHash(view) {
     id: view.id,
     __: view.__ ?? "element",
     autoLayout: view.autoLayout,
-    nodes: object_hash.x(
+    nodes: object_hash.C(
       view.nodes,
       object_hash.m(i$6(["id", "title", "description", "technology", "shape", "icon", "children"])),
       l$3(({ id, icon, ...node }) => [id, { ...node, icon: n$2(icon) ? "Y" : "N" }])
     ),
-    edges: object_hash.x(
+    edges: object_hash.C(
       view.edges,
       object_hash.m(i$6(["source", "target", "label", "description", "technology", "dir", "head", "tail", "line"])),
       l$3(({ source, target, ...edge }) => [`${source}:${target}`, edge])
@@ -1537,6 +1543,7 @@ class AbstractDeploymentElementModel {
     return {
       shape: view.DefaultElementShape,
       color: view.DefaultThemeColor,
+      size: view.DefaultShapeSize,
       ...this.$node.style
     };
   }
@@ -1790,13 +1797,14 @@ class DeployedInstanceModel extends AbstractDeploymentElementModel {
     return this.$instance;
   }
   get parent() {
-    return chunkRAAYCPUM.nonNullable(this.$model.parent(this), `Parent of ${this.id} not found`);
+    return chunkWIMGWYZL.nonNullable(this.$model.parent(this), `Parent of ${this.id} not found`);
   }
   get style() {
     const { icon, style } = this.element.$element;
     return {
       shape: this.element.shape,
       color: this.element.color,
+      size: view.DefaultShapeSize,
       ...icon && { icon },
       ...style,
       ...this.$instance.style
@@ -2080,8 +2088,8 @@ class DeploymentConnectionModel {
     if (Array.isArray(other)) {
       return other.reduce((acc, o) => acc.mergeWith(o), this);
     }
-    chunkRAAYCPUM.invariant(this.source.id === other.source.id, "Cannot merge connections with different sources");
-    chunkRAAYCPUM.invariant(this.target.id === other.target.id, "Cannot merge connections with different targets");
+    chunkWIMGWYZL.invariant(this.source.id === other.source.id, "Cannot merge connections with different sources");
+    chunkWIMGWYZL.invariant(this.target.id === other.target.id, "Cannot merge connections with different targets");
     return new DeploymentConnectionModel(
       this.source,
       this.target,
@@ -2103,7 +2111,7 @@ class DeploymentConnectionModel {
     );
   }
   equals(other) {
-    chunkRAAYCPUM.invariant(other instanceof DeploymentConnectionModel, "Other should ne DeploymentConnectionModel");
+    chunkWIMGWYZL.invariant(other instanceof DeploymentConnectionModel, "Other should ne DeploymentConnectionModel");
     return this.id === other.id && this.source.id === other.source.id && this.target.id === other.target.id && object_hash.equals(this.relations.model, other.relations.model) && object_hash.equals(this.relations.deployment, other.relations.deployment);
   }
   /**
@@ -2175,7 +2183,7 @@ function sortConnectionsByBoundaryHierarchy(connections, sort) {
   return _sortByBoundary(connections, sort ?? "asc");
 }
 function _sortByBoundary(connections, order) {
-  return object_hash.x(
+  return object_hash.C(
     connections,
     object_hash.m((conn) => ({
       id: boundaryHierarchy(conn),
@@ -2378,8 +2386,8 @@ class ConnectionModel {
     return this.relations.size > 0;
   }
   mergeWith(other) {
-    chunkRAAYCPUM.invariant(this.source.id === other.source.id, "Cannot merge connections with different sources");
-    chunkRAAYCPUM.invariant(this.target.id === other.target.id, "Cannot merge connections with different targets");
+    chunkWIMGWYZL.invariant(this.source.id === other.source.id, "Cannot merge connections with different sources");
+    chunkWIMGWYZL.invariant(this.target.id === other.target.id, "Cannot merge connections with different targets");
     return new ConnectionModel(
       this.source,
       this.target,
@@ -2394,7 +2402,7 @@ class ConnectionModel {
     );
   }
   intersect(other) {
-    chunkRAAYCPUM.invariant(other instanceof ConnectionModel, "Cannot intersect connection with different type");
+    chunkWIMGWYZL.invariant(other instanceof ConnectionModel, "Cannot intersect connection with different type");
     return new ConnectionModel(
       this.source,
       this.target,
@@ -2402,7 +2410,7 @@ class ConnectionModel {
     );
   }
   equals(other) {
-    chunkRAAYCPUM.invariant(other instanceof ConnectionModel, "Cannot merge connection with different type");
+    chunkWIMGWYZL.invariant(other instanceof ConnectionModel, "Cannot merge connection with different type");
     return this.id === other.id && this.source.id === other.source.id && this.target.id === other.target.id && object_hash.equals(this.relations, other.relations);
   }
   /**
@@ -2548,7 +2556,7 @@ class AbstractStageExclude {
    */
   excludeConnections(connection, moveExplicitToImplicit) {
     if (e(moveExplicitToImplicit)) {
-      chunkRAAYCPUM.invariant(!this.markedToMoveExplicitToImplicit, "Already marked to move explicits");
+      chunkWIMGWYZL.invariant(!this.markedToMoveExplicitToImplicit, "Already marked to move explicits");
       this.markedToMoveExplicitToImplicit = moveExplicitToImplicit;
     }
     if (object_hash.isIterable(connection)) {
@@ -2589,7 +2597,7 @@ class AbstractStageExclude {
       disconnected,
       state.elements
     );
-    disconnected = object_hash.x(
+    disconnected = object_hash.C(
       disconnected,
       object_hash.ifilter((el) => {
         return state.explicits.has(el) && !object_hash.isome(state.final, object_hash.isDescendantOf(el));
@@ -2658,8 +2666,8 @@ class AbstractStageExclude {
    * Postcommit hook
    */
   postcommit(state) {
-    chunkRAAYCPUM.invariant(object_hash.difference(state.explicits, state.elements).size === 0, "Explicits must be subset of elements");
-    chunkRAAYCPUM.invariant(object_hash.difference(state.final, state.elements).size === 0, "Final elements must be subset of elements");
+    chunkWIMGWYZL.invariant(object_hash.difference(state.explicits, state.elements).size === 0, "Explicits must be subset of elements");
+    chunkWIMGWYZL.invariant(object_hash.difference(state.final, state.elements).size === 0, "Final elements must be subset of elements");
     return state;
   }
   commit() {
@@ -2677,7 +2685,6 @@ class AbstractStageExclude {
     if (this.excluded.elements.size > 0) {
       state = this.removeElements(state);
     }
-    state = this.moveDisconnectedExplicitsToImplicits(state);
     return this.memory.update(this.postcommit(state));
   }
 }
@@ -2883,7 +2890,7 @@ function findCrossBoundarySameSourceOrTarget(connections) {
     if (!object_hash.i(sameRelationGroup, 2)) {
       continue;
     }
-    object_hash.x(
+    object_hash.C(
       sameRelationGroup,
       u$1((conn) => [
         { group: `$source-${conn.source.id}`, conn },
@@ -2918,7 +2925,7 @@ function findCrossBoundaryConnections(connections) {
     const connectionModelRelations = c.relations.model;
     if (source.isDeploymentNode() !== target.isDeploymentNode()) {
       const node = source.isDeploymentNode() ? source : c.target;
-      chunkRAAYCPUM.invariant(node.isDeploymentNode());
+      chunkWIMGWYZL.invariant(node.isDeploymentNode());
       const nodeInternals = node.internalModelRelationships();
       const toExclude = object_hash.intersection(
         connectionModelRelations,
@@ -2946,7 +2953,7 @@ function findCrossBoundaryConnections(connections) {
       }
     }
   }
-  return object_hash.x(
+  return object_hash.C(
     excludedRelations.entries(),
     object_hash.imap(
       ([c, excluded]) => c.update({
@@ -2964,7 +2971,7 @@ function cleanCrossBoundary(connections) {
   );
 }
 function findRedundantConnections$1(connections) {
-  return object_hash.x(
+  return object_hash.C(
     connections,
     mergeConnections,
     l$5((redundants, connection) => {
@@ -3046,17 +3053,17 @@ let StageInclude$1 = class StageInclude extends AbstractStageInclude {
     return hasChanged();
   }
   processConnections(connections) {
-    const clean = object_hash.x(
+    const clean = object_hash.C(
       connections,
       cleanCrossBoundary,
       cleanRedundantRelationships
     );
-    object_hash.x(
+    object_hash.C(
       clean,
       // Process only connection from this stage
       // filter(c => this._connections.some(c2 => c2.id === c.id)),
       u(({ source, target, boundary }) => {
-        object_hash.x(
+        object_hash.C(
           object_hash.d(
             [...object_hash.toArray(source.ancestors()).reverse(), source],
             [...object_hash.toArray(target.ancestors()).reverse(), target]
@@ -3171,11 +3178,11 @@ function elementExprToPredicate(target) {
   if (view.isCustomElement(target)) {
     return elementExprToPredicate(target.custom.expr);
   }
-  chunkRAAYCPUM.nonexhaustive(target);
+  chunkWIMGWYZL.nonexhaustive(target);
 }
 
 function applyViewRuleStyle(rule, predicates, nodes) {
-  object_hash.x(
+  object_hash.C(
     nodes,
     T(view.o$1(view.ComputedNode.isNodesGroup)),
     T(view.y(predicates)),
@@ -3198,6 +3205,15 @@ function applyViewRuleStyle(rule, predicates, nodes) {
       if (object_hash.n(rule.style.multiple)) {
         styleOverride = { ...styleOverride, multiple: rule.style.multiple };
       }
+      if (object_hash.n(rule.style.padding)) {
+        styleOverride = { ...styleOverride, padding: rule.style.padding };
+      }
+      if (object_hash.n(rule.style.size)) {
+        styleOverride = { ...styleOverride, size: rule.style.size };
+      }
+      if (object_hash.n(rule.style.textSize)) {
+        styleOverride = { ...styleOverride, textSize: rule.style.textSize };
+      }
       if (styleOverride) {
         n.style = {
           ...n.style,
@@ -3243,7 +3259,7 @@ function buildComputedNodes(elements, groups) {
   const elementToGroup = /* @__PURE__ */ new Map();
   groups?.forEach(({ id, parent, viewRule, elements: elements2 }) => {
     if (parent) {
-      chunkRAAYCPUM.nonNullable(nodesMap.get(parent), `Parent group node ${parent} not found`).children.push(id);
+      chunkWIMGWYZL.nonNullable(nodesMap.get(parent), `Parent group node ${parent} not found`).children.push(id);
     }
     nodesMap.set(id, {
       id,
@@ -3263,7 +3279,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) {
@@ -3317,10 +3337,10 @@ function buildComputedNodes(elements, groups) {
   });
   const orderedMap = /* @__PURE__ */ new Map();
   groups?.forEach(({ id }) => {
-    orderedMap.set(id, chunkRAAYCPUM.nonNullable(nodesMap.get(id)));
+    orderedMap.set(id, chunkWIMGWYZL.nonNullable(nodesMap.get(id)));
   });
   elements.forEach(({ id }) => {
-    orderedMap.set(id, chunkRAAYCPUM.nonNullable(nodesMap.get(id)));
+    orderedMap.set(id, chunkWIMGWYZL.nonNullable(nodesMap.get(id)));
   });
   return orderedMap;
 }
@@ -3353,7 +3373,7 @@ function pickRelationshipProps(relation) {
   };
 }
 function mergePropsFromRelationships(relations, prefer) {
-  const allprops = object_hash.x(
+  const allprops = object_hash.C(
     relations,
     l$5(
       (acc, r) => {
@@ -3437,7 +3457,7 @@ function mergePropsFromRelationships(relations, prefer) {
 }
 
 function uniqueTags(elements) {
-  const tags = object_hash.x(
+  const tags = object_hash.C(
     elements,
     u$1((e) => e.tags ?? []),
     i$8(),
@@ -3541,7 +3561,7 @@ function deploymentExpressionToPredicate(target) {
       return m === fqn;
     };
   }
-  chunkRAAYCPUM.nonexhaustive(target);
+  chunkWIMGWYZL.nonexhaustive(target);
 }
 function toNodeSource$1(el) {
   if (el.isDeploymentNode()) {
@@ -3569,7 +3589,7 @@ function toNodeSource$1(el) {
       id
     };
   }
-  chunkRAAYCPUM.invariant(el.isInstance(), "Expected Instance");
+  chunkWIMGWYZL.invariant(el.isInstance(), "Expected Instance");
   const instance = el.$instance;
   const element = el.element.$element;
   const icon = instance.style?.icon ?? element.icon;
@@ -3611,7 +3631,7 @@ function toComputedEdges$1(connections) {
       ...e.relations.model,
       ...e.relations.deployment
     ];
-    chunkRAAYCPUM.invariant(object_hash.i(relations, 1), "Edge must have at least one relation");
+    chunkWIMGWYZL.invariant(object_hash.i(relations, 1), "Edge must have at least one relation");
     const source = e.source.id;
     const target = e.target.id;
     const {
@@ -3659,108 +3679,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 object_hash.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();
 }
@@ -3774,6 +3692,61 @@ function isDeploymentElementModel(x) {
   return x instanceof DeploymentNodeModel || x instanceof DeployedInstanceModel;
 }
 
+const IncomingRelationPredicate = {
+  include: ({ expr, model, memory, stage, where }) => {
+    const sources = [...memory.elements];
+    if (view.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;
+    }
+    chunkWIMGWYZL.invariant(view.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 (view.FqnExpr.isModelRef(expr.incoming)) {
+      const excludedRelations = resolveAllImcomingRelations(model, expr.incoming);
+      return excludeModelRelations(excludedRelations, { stage, memory }, where);
+    }
+    if (view.FqnExpr.isWildcard(expr.incoming)) {
+      return stage;
+    }
+    const isIncoming = filterIncomingConnections(resolveElements$1(model, expr.incoming));
+    const toExclude = object_hash.C(
+      memory.connections,
+      T(isIncoming),
+      applyPredicate(where)
+    );
+    stage.excludeConnections(toExclude);
+    return stage;
+  }
+};
+function filterIncomingConnections(targets) {
+  return view.y(
+    targets.map((target) => {
+      const satisfies = (el) => el === target || object_hash.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];
@@ -3789,7 +3762,7 @@ const OutgoingRelationPredicate = {
       }
       return stage;
     }
-    chunkRAAYCPUM.invariant(view.FqnExpr.isDeploymentRef(expr.outgoing), "Only deployment refs are supported in include");
+    chunkWIMGWYZL.invariant(view.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(source, targets, "directed"), where);
@@ -3806,7 +3779,7 @@ const OutgoingRelationPredicate = {
       return stage;
     }
     const isOutgoing = filterOutgoingConnections(resolveElements$1(model, expr.outgoing));
-    const toExclude = object_hash.x(
+    const toExclude = object_hash.C(
       memory.connections,
       T(isOutgoing),
       applyPredicate(where)
@@ -3830,44 +3803,210 @@ 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 (view.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 }) => {
+    chunkWIMGWYZL.invariant(!view.FqnExpr.isModelRef(source), "Invalid source model ref in direct relation");
+    chunkWIMGWYZL.invariant(!view.FqnExpr.isModelRef(target), "Invalid target model ref in direct relation");
+    const sourceIsWildcard = view.FqnExpr.isWildcard(source);
+    const targetIsWildcard = view.FqnExpr.isWildcard(target);
+    const dir = isBidirectional ? "both" : "directed";
+    let connections;
+    switch (true) {
+      // * -> *
+      case (sourceIsWildcard && targetIsWildcard): {
+        connections = object_hash.C(
+          findConnectionsWithin(model.instances()),
+          applyPredicate(where),
+          object_hash.m((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 = object_hash.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 = object_hash.C(
+          targets,
+          u$1((target2) => {
+            const sources = resolveAscendingSiblings(target2);
+            return [...sources].flatMap((source2) => findConnection(source2, target2, dir));
+          }),
+          T(postFilter),
+          applyPredicate(where)
+        );
+        break;
+      }
+      default: {
+        chunkWIMGWYZL.invariant(!sourceIsWildcard, "Inferrence failed - source should be a deployment ref");
+        chunkWIMGWYZL.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 = object_hash.C(
+          sources,
+          u$1((s) => findConnectionsBetween(s, targets, dir)),
+          T((c) => isSource(c) && isTarget(c)),
+          applyPredicate(where)
+        );
       }
-      return stage;
     }
-    chunkRAAYCPUM.invariant(view.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 (view.FqnExpr.isDeploymentRef(source) && object_hash.l(source.selector)) {
+      stage.addImplicit(model.element(source.ref.deployment));
+    }
+    if (view.FqnExpr.isDeploymentRef(target) && object_hash.l(target.selector)) {
+      stage.addImplicit(model.element(target.ref.deployment));
     }
     return stage;
   },
   exclude: ({ expr, model, memory, stage, where }) => {
-    if (view.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 (view.FqnExpr.isWildcard(expr.source) && view.FqnExpr.isWildcard(expr.target)):
+        stage.excludeConnections(applyPredicate(memory.connections, where));
         return stage;
-      }
-      const excludedRelations = object_hash.union(
-        /* @__PURE__ */ new Set(),
-        ...elements2.flatMap((e) => [e.allIncoming, e.allOutgoing])
-      );
-      return excludeModelRelations(excludedRelations, { stage, memory }, where);
-    }
-    if (view.FqnExpr.isWildcard(expr.inout)) {
+      // model -> model
+      case (view.FqnExpr.isModelRef(expr.source) && view.FqnExpr.isModelRef(expr.target)):
+        modelRelationsToExclude = resolveRelationsBetweenModelElements({
+          source: expr.source,
+          target: expr.target,
+          expr,
+          model
+        });
+        return excludeModelRelations(modelRelationsToExclude, { stage, memory }, where);
+      // model -> *
+      case (view.FqnExpr.isModelRef(expr.source) && view.FqnExpr.isWildcard(expr.target)):
+        modelRelationsToExclude = resolveAllOutgoingRelations(model, expr.source);
+        return excludeModelRelations(modelRelationsToExclude, { stage, memory }, where);
+      // model -> deployment
+      case view.FqnExpr.isModelRef(expr.source):
+        modelRelationsToExclude = resolveAllOutgoingRelations(model, expr.source);
+        return excludeModelRelations(
+          modelRelationsToExclude,
+          { stage, memory },
+          where,
+          (c) => isTarget(c.target)
+        );
+      // deployment -> model
+      case view.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 = object_hash.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 (view.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;
+    }
+    chunkWIMGWYZL.invariant(view.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 (view.FqnExpr.isModelRef(expr.inout)) {
+      const elements2 = resolveModelElements(model, expr.inout);
+      if (elements2.length === 0) {
+        return stage;
+      }
+      const excludedRelations = object_hash.union(
+        /* @__PURE__ */ new Set(),
+        ...elements2.flatMap((e) => [e.allIncoming, e.allOutgoing])
+      );
+      return excludeModelRelations(excludedRelations, { stage, memory }, where);
+    }
+    if (view.FqnExpr.isWildcard(expr.inout)) {
       return stage;
     }
     const elements = resolveElements$1(model, expr.inout);
     const isIncoming = filterIncomingConnections(elements);
     const isOutgoing = filterOutgoingConnections(elements);
-    const toExclude = object_hash.x(
+    const toExclude = object_hash.C(
       memory.connections,
       T((c) => isIncoming(c) !== isOutgoing(c)),
       applyPredicate(where)
@@ -3889,14 +4028,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 = object_hash.C(
+      [...model.roots()],
+      applyElementPredicate(where),
+      object_hash.m((root) => {
+        if (!root.onlyOneInstance()) {
+          children.push(...root.children());
+        }
+        return root;
+      })
+    );
     stage.addExplicit(rootElements);
     if (children.length > 1) {
       stage.addConnections(findConnectionsWithin([
@@ -3906,8 +4049,12 @@ const WildcardPredicate$1 = {
     }
     return stage;
   },
-  exclude: ({ stage, memory }) => {
-    stage.exclude(memory.elements);
+  exclude: ({ stage, memory, where }) => {
+    const elementsToExclude = object_hash.C(
+      [...memory.elements],
+      applyElementPredicate(where)
+    );
+    stage.exclude(elementsToExclude);
     return stage;
   }
 };
@@ -3931,14 +4078,14 @@ function predicateToPatch(op, { expr, where, ...ctx }) {
     case view.RelationExpr.isWhere(expr):
       return WhereRelationPredicate[op]({ ...ctx, expr, where });
     default:
-      chunkRAAYCPUM.nonexhaustive(expr);
+      chunkWIMGWYZL.nonexhaustive(expr);
   }
 }
 function excludeModelRelations(relationsToExclude, { stage, memory }, where, filterConnections = () => true) {
   if (relationsToExclude.size === 0) {
     return stage;
   }
-  const toExclude = object_hash.x(
+  const toExclude = object_hash.C(
     memory.connections,
     T((c) => filterConnections(c)),
     // Find connections that have at least one relation in common with the excluded relations
@@ -3976,11 +4123,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 (view.o(c)) {
+    return c.filter((x) => applyElementPredicate(x, where));
+  }
+  return where?.(toFilterable(c, c)) ?? true;
+}
 function matchConnections(connections, where) {
   if (!where) {
     return connections;
   }
-  return object_hash.x(
+  return object_hash.C(
     connections,
     T((c) => matchConnection(c, where))
   );
@@ -4005,7 +4162,7 @@ function toFilterable(relationEndpoint, connectionEndpoint) {
   if (isDeploymentNode(relationEndpoint)) {
     return i$6(relationEndpoint, ["tags", "kind"]);
   }
-  chunkRAAYCPUM.nonexhaustive(relationEndpoint);
+  chunkWIMGWYZL.nonexhaustive(relationEndpoint);
 }
 function toFilterableRelation(c) {
   return (relation) => ({
@@ -4016,225 +4173,117 @@ function toFilterableRelation(c) {
   });
 }
 
-const IncomingRelationPredicate = {
-  include: ({ expr, model, memory, stage, where }) => {
-    const sources = [...memory.elements];
-    if (view.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;
     }
-    chunkRAAYCPUM.invariant(view.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 (view.FqnExpr.isModelRef(expr.incoming)) {
-      const excludedRelations = resolveAllImcomingRelations(model, expr.incoming);
-      return excludeModelRelations(excludedRelations, { stage, memory }, where);
-    }
-    if (view.FqnExpr.isWildcard(expr.incoming)) {
-      return stage;
-    }
-    const isIncoming = filterIncomingConnections(resolveElements$1(model, expr.incoming));
-    const toExclude = object_hash.x(
-      memory.connections,
-      T(isIncoming),
-      applyPredicate(where)
+  exclude: ({ expr, stage, memory, where }) => {
+    const exprPredicate = deploymentExpressionToPredicate(expr);
+    const toExclude = object_hash.C(
+      [...memory.elements],
+      T(exprPredicate),
+      applyElementPredicate(where)
     );
-    stage.excludeConnections(toExclude);
+    stage.exclude(toExclude);
     return stage;
   }
 };
-function filterIncomingConnections(targets) {
-  return view.y(
-    targets.map((target) => {
-      const satisfies = (el) => el === target || object_hash.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 }) => {
-    chunkRAAYCPUM.invariant(!view.FqnExpr.isModelRef(source), "Invalid source model ref in direct relation");
-    chunkRAAYCPUM.invariant(!view.FqnExpr.isModelRef(target), "Invalid target model ref in direct relation");
-    const sourceIsWildcard = view.FqnExpr.isWildcard(source);
-    const targetIsWildcard = view.FqnExpr.isWildcard(target);
-    const dir = isBidirectional ? "both" : "directed";
-    let connections;
-    switch (true) {
-      // * -> *
-      case (sourceIsWildcard && targetIsWildcard): {
-        connections = object_hash.x(
-          findConnectionsWithin(model.instances()),
-          applyPredicate(where),
-          object_hash.m((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 = object_hash.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 = object_hash.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: {
-        chunkRAAYCPUM.invariant(!sourceIsWildcard, "Inferrence failed - source should be a deployment ref");
-        chunkRAAYCPUM.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 = object_hash.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 (view.FqnExpr.isDeploymentRef(source) && object_hash.l(source.selector)) {
-      stage.addImplicit(model.element(source.ref.deployment));
-    }
-    if (view.FqnExpr.isDeploymentRef(target) && object_hash.l(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 (view.FqnExpr.isWildcard(expr.source) && view.FqnExpr.isWildcard(expr.target)):
-        stage.excludeConnections(applyPredicate(memory.connections, where));
-        return stage;
-      // model -> model
-      case (view.FqnExpr.isModelRef(expr.source) && view.FqnExpr.isModelRef(expr.target)):
-        modelRelationsToExclude = resolveRelationsBetweenModelElements({
-          source: expr.source,
-          target: expr.target,
-          expr,
-          model
-        });
-        return excludeModelRelations(modelRelationsToExclude, { stage, memory }, where);
-      // model -> *
-      case (view.FqnExpr.isModelRef(expr.source) && view.FqnExpr.isWildcard(expr.target)):
-        modelRelationsToExclude = resolveAllOutgoingRelations(model, expr.source);
-        return excludeModelRelations(modelRelationsToExclude, { stage, memory }, where);
-      // model -> deployment
-      case view.FqnExpr.isModelRef(expr.source):
-        modelRelationsToExclude = resolveAllOutgoingRelations(model, expr.source);
-        return excludeModelRelations(
-          modelRelationsToExclude,
-          { stage, memory },
-          where,
-          (c) => isTarget(c.target)
-        );
-      // deployment -> model
-      case view.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 = object_hash.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);
+  object_hash.C(
+    descendants,
+    T((desc) => allConnected.has(desc)),
+    u((desc) => stage.addExplicit(desc))
+  );
+}
+function findConnectedElements(stage) {
+  return object_hash.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 {
@@ -4248,7 +4297,7 @@ let StageFinal$1 = class StageFinal {
     if (memory.connections.length < 2) {
       return memory;
     }
-    const connections = object_hash.x(
+    const connections = object_hash.C(
       memory.connections,
       // Keep connections
       // - between leafs
@@ -4300,7 +4349,7 @@ let StageFinal$1 = class StageFinal {
       }
       return false;
     };
-    object_hash.x(
+    object_hash.C(
       object_hash.difference(implicits, snapshot),
       object_hash.ifilter((e) => e.isDeploymentNode()),
       object_hash.toArray(),
@@ -4485,7 +4534,15 @@ function applyCustomElementProperties(_rules, _nodes) {
   for (const {
     custom: { expr, ...props }
   } of rules) {
-    const { border, opacity, multiple, ...rest } = d$1(props, view.n);
+    const {
+      border,
+      opacity,
+      multiple,
+      padding,
+      size,
+      textSize,
+      ...rest
+    } = d$1(props, view.n);
     const notEmpty = !n(rest);
     const satisfies = elementExprToPredicate(expr);
     nodes.forEach((node, i) => {
@@ -4509,6 +4566,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,
@@ -4657,8 +4723,8 @@ class DynamicViewCompute {
     const elements = [...this.explicits].map((e) => e.$element);
     const nodesMap = buildComputedNodesFromElements(elements);
     const edges = this.steps.map(({ source, target, relations, title, isBackward, ...step }) => {
-      const sourceNode = chunkRAAYCPUM.nonNullable(nodesMap.get(source.id), `Source node ${source.id} not found`);
-      const targetNode = chunkRAAYCPUM.nonNullable(nodesMap.get(target.id), `Target node ${target.id} not found`);
+      const sourceNode = chunkWIMGWYZL.nonNullable(nodesMap.get(source.id), `Source node ${source.id} not found`);
+      const targetNode = chunkWIMGWYZL.nonNullable(nodesMap.get(target.id), `Target node ${target.id} not found`);
       const edge = {
         parent: object_hash.commonAncestor(source.id, target.id),
         source: source.id,
@@ -4697,7 +4763,7 @@ class DynamicViewCompute {
       applyViewRuleStyles(
         rules,
         // Keep order of elements
-        elements.map((e) => chunkRAAYCPUM.nonNullable(nodesMap.get(e.id)))
+        elements.map((e) => chunkWIMGWYZL.nonNullable(nodesMap.get(e.id)))
       )
     );
     const autoLayoutRule = o(rules, view.isViewRuleAutoLayout);
@@ -4739,7 +4805,7 @@ class DynamicViewCompute {
         notation: null
       };
     }
-    const alltags = object_hash.x(
+    const alltags = object_hash.C(
       relationships,
       u$1((r) => r.tags),
       T(n$2),
@@ -4749,7 +4815,7 @@ class DynamicViewCompute {
     const relations = object_hash.i(relationships, 1) ? object_hash.m(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 : object_hash.x(
+    const navigateTo = relationNavigateTo && relationNavigateTo !== this.view.id ? relationNavigateTo : object_hash.C(
       relationships,
       object_hash.m((r) => r.$relationship.navigateTo),
       T(n$2),
@@ -4757,7 +4823,7 @@ class DynamicViewCompute {
       i$8(),
       t$2()
     );
-    const commonProperties = object_hash.x(
+    const commonProperties = object_hash.C(
       relationships,
       l$5((acc, { title, $relationship: r }) => {
         n$2(title) && acc.title.add(title);
@@ -4824,7 +4890,7 @@ function relationExpressionToPredicates(expr) {
       return (edge) => isSource(edge.source);
     }
     default:
-      chunkRAAYCPUM.nonexhaustive(expr);
+      chunkWIMGWYZL.nonexhaustive(expr);
   }
 }
 
@@ -4884,7 +4950,7 @@ class NodesGroup {
 
 class StageExclude extends AbstractStageExclude {
   excludeRelations(excluded) {
-    object_hash.x(
+    object_hash.C(
       this.memory.connections,
       T((c) => object_hash.hasIntersection(c.relations, excluded)),
       u((c) => {
@@ -4981,10 +5047,10 @@ class StageInclude extends AbstractStageInclude {
     if (view.isRelationPredicateExpr(this.expression)) {
       return connections;
     }
-    object_hash.x(
+    object_hash.C(
       connections,
       u(({ source, target, boundary }) => {
-        object_hash.x(
+        object_hash.C(
           object_hash.d(
             [...object_hash.toArray(source.ancestors()).reverse(), source],
             [...object_hash.toArray(target.ancestors()).reverse(), target]
@@ -5107,7 +5173,7 @@ class ActiveGroupMemory extends Memory {
     return new ActiveGroupMemory(state, memory.scope, stack);
   }
   get activeGroupId() {
-    return chunkRAAYCPUM.nonNullable(this.stack.peek(), "Stack must not be empty");
+    return chunkWIMGWYZL.nonNullable(this.stack.peek(), "Stack must not be empty");
   }
   mutableState() {
     const state = super.mutableState();
@@ -5144,7 +5210,7 @@ class ActiveGroupMemory extends Memory {
 }
 
 function findRedundantConnections(connections) {
-  return object_hash.x(
+  return object_hash.C(
     [...connections],
     mergeConnections,
     l$5((reducedConnections, connection, _, all) => {
@@ -5224,7 +5290,7 @@ class StageFinal {
       }
       return false;
     };
-    object_hash.x(
+    object_hash.C(
       object_hash.difference(implicits, snapshot),
       object_hash.toArray(),
       object_hash.sortByFqnHierarchically,
@@ -5330,7 +5396,7 @@ function resolveElements(model, expr) {
         return expr.isEqual === el.tags.includes(expr.elementTag);
       })];
     default:
-      chunkRAAYCPUM.nonexhaustive(expr);
+      chunkWIMGWYZL.nonexhaustive(expr);
   }
 }
 function includeDescendantsFromMemory(elements, memory) {
@@ -5420,7 +5486,7 @@ function toComputedEdges(connections) {
     const relations = [
       ...e.relations
     ];
-    chunkRAAYCPUM.invariant(object_hash.i(relations, 1), "Edge must have at least one relation");
+    chunkWIMGWYZL.invariant(object_hash.i(relations, 1), "Edge must have at least one relation");
     const source = e.source.id;
     const target = e.target.id;
     const {
@@ -5460,7 +5526,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 = object_hash.x(
+        const connections2 = object_hash.C(
           model.relationships(),
           object_hash.ifilter(where),
           object_hash.toArray(),
@@ -5488,10 +5554,10 @@ const DirectRelationExprPredicate = {
       // element -> *; Where clause
       case (!sourceIsWildcard && targetIsWildcard && where !== NoWhere): {
         const sources = resolveElements(model, source);
-        const connections2 = object_hash.x(
+        const connections2 = object_hash.C(
           sources,
           u$1(
-            (source2) => object_hash.x(
+            (source2) => object_hash.C(
               source2,
               d$5(r(isBidirectional === true), {
                 onTrue: (s) => object_hash.union(s.allIncoming, s.allOutgoing),
@@ -5502,7 +5568,7 @@ const DirectRelationExprPredicate = {
               object_hash.toArray(),
               d$3((r) => r.source === source2),
               ([outgoing, incoming]) => a(
-                object_hash.x(
+                object_hash.C(
                   outgoing,
                   object_hash.m(
                     (outgoing2) => new ConnectionModel(
@@ -5512,7 +5578,7 @@ const DirectRelationExprPredicate = {
                     )
                   )
                 ),
-                object_hash.x(
+                object_hash.C(
                   incoming,
                   object_hash.m(
                     (incoming2) => new ConnectionModel(
@@ -5544,10 +5610,10 @@ const DirectRelationExprPredicate = {
       // * -> element; Where clause
       case (sourceIsWildcard && !targetIsWildcard && where !== NoWhere): {
         const targets = resolveElements(model, target);
-        const connections2 = object_hash.x(
+        const connections2 = object_hash.C(
           targets,
           u$1(
-            (target2) => object_hash.x(
+            (target2) => object_hash.C(
               target2,
               d$5(r(isBidirectional === true), {
                 onTrue: (s) => object_hash.union(s.allIncoming, s.allOutgoing),
@@ -5557,7 +5623,7 @@ const DirectRelationExprPredicate = {
               object_hash.toArray(),
               d$3((r) => r.target === target2),
               ([incoming, outgoing]) => a(
-                object_hash.x(
+                object_hash.C(
                   outgoing,
                   object_hash.m(
                     (outgoing2) => new ConnectionModel(
@@ -5567,7 +5633,7 @@ const DirectRelationExprPredicate = {
                     )
                   )
                 ),
-                object_hash.x(
+                object_hash.C(
                   incoming,
                   object_hash.m(
                     (incoming2) => new ConnectionModel(
@@ -5596,8 +5662,8 @@ const DirectRelationExprPredicate = {
         break;
       }
       default: {
-        chunkRAAYCPUM.invariant(!view.isWildcard(source), "Inference failed - source must be not a wildcard");
-        chunkRAAYCPUM.invariant(!view.isWildcard(target), "Inference failed - target must be not a wildcard");
+        chunkWIMGWYZL.invariant(!view.isWildcard(source), "Inference failed - source must be not a wildcard");
+        chunkWIMGWYZL.invariant(!view.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";
@@ -5620,7 +5686,7 @@ const DirectRelationExprPredicate = {
     switch (true) {
       // * -> *
       case (sourceIsWildcard && targetIsWildcard): {
-        relations = object_hash.x(
+        relations = object_hash.C(
           memory.connections,
           u$1(i$4(
             p$1("relations"),
@@ -5634,10 +5700,10 @@ const DirectRelationExprPredicate = {
       // element -> *
       case (!sourceIsWildcard && targetIsWildcard): {
         const sources = resolveElements(model, source);
-        relations = object_hash.x(
+        relations = object_hash.C(
           sources,
           u$1(
-            (source2) => object_hash.x(
+            (source2) => object_hash.C(
               source2,
               d$5(r(isBidirectional === true), {
                 onTrue: (s) => object_hash.union(s.allIncoming, s.allOutgoing),
@@ -5654,10 +5720,10 @@ const DirectRelationExprPredicate = {
       // * -> element
       case (sourceIsWildcard && !targetIsWildcard): {
         const targets = resolveElements(model, target);
-        relations = object_hash.x(
+        relations = object_hash.C(
           targets,
           u$1(
-            (target2) => object_hash.x(
+            (target2) => object_hash.C(
               target2,
               d$5(r(isBidirectional === true), {
                 onTrue: (s) => object_hash.union(s.allIncoming, s.allOutgoing),
@@ -5672,8 +5738,8 @@ const DirectRelationExprPredicate = {
         break;
       }
       default: {
-        chunkRAAYCPUM.invariant(!view.isWildcard(source), "Inferrence failed - source must be not a wildcard");
-        chunkRAAYCPUM.invariant(!view.isWildcard(target), "Inferrence failed - target must be not a wildcard");
+        chunkWIMGWYZL.invariant(!view.isWildcard(source), "Inferrence failed - source must be not a wildcard");
+        chunkWIMGWYZL.invariant(!view.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();
@@ -5709,7 +5775,7 @@ function resolveWildcard(nonWildcard, { memory, model }) {
       includeDescendantsFromMemory(targets2, memory)
     ];
   }
-  const targets = object_hash.x(
+  const targets = object_hash.C(
     sources,
     object_hash.m((el) => el.ascendingSiblings()),
     object_hash.iflat(),
@@ -5812,7 +5878,7 @@ function incomingConnectionPredicate(model, expr) {
       return exports.Connection.isIncoming(expr.element);
     }
     default:
-      chunkRAAYCPUM.nonexhaustive(expr);
+      chunkWIMGWYZL.nonexhaustive(expr);
   }
 }
 
@@ -5962,7 +6028,7 @@ function outgoingConnectionPredicate(model, expr) {
       return exports.Connection.isOutgoing(expr.element);
     }
     default:
-      chunkRAAYCPUM.nonexhaustive(expr);
+      chunkWIMGWYZL.nonexhaustive(expr);
   }
 }
 
@@ -6057,7 +6123,7 @@ function processElementPredicate(expr, op, ctx) {
     case view.isElementTagExpr(expr):
       return ElementKindOrTagPredicate[op]({ ...ctx, expr }) ?? ctx.stage;
     default:
-      chunkRAAYCPUM.nonexhaustive(expr);
+      chunkWIMGWYZL.nonexhaustive(expr);
   }
 }
 function processRelationtPredicate(expr, op, ctx) {
@@ -6074,7 +6140,7 @@ function processRelationtPredicate(expr, op, ctx) {
         return new Set(T([...relations], where));
       };
       const filterWhere = (connections) => {
-        return object_hash.x(
+        return object_hash.C(
           connections,
           object_hash.m((c) => new ConnectionModel(c.source, c.target, filterRelations(c.relations))),
           T((c) => c.nonEmpty())
@@ -6099,7 +6165,7 @@ function processRelationtPredicate(expr, op, ctx) {
       return IncomingExprPredicate[op]({ ...ctx, expr }) ?? ctx.stage;
     }
     default:
-      chunkRAAYCPUM.nonexhaustive(expr);
+      chunkWIMGWYZL.nonexhaustive(expr);
   }
 }
 function processPredicates(model, memory, rules) {
@@ -6113,7 +6179,7 @@ function processPredicates(model, memory, rules) {
     if (view.isViewRuleGroup(rule)) {
       const groupMemory = ActiveGroupMemory.enter(memory, rule);
       memory = processPredicates(model, groupMemory, rule.groupRules);
-      chunkRAAYCPUM.invariant(memory instanceof ActiveGroupMemory, "processPredicates must return ActiveGroupMemory");
+      chunkWIMGWYZL.invariant(memory instanceof ActiveGroupMemory, "processPredicates must return ActiveGroupMemory");
       memory = memory.leave();
       continue;
     }
@@ -6138,7 +6204,7 @@ function processPredicates(model, memory, rules) {
             }) ?? stage;
             break;
           default:
-            chunkRAAYCPUM.nonexhaustive(expr);
+            chunkWIMGWYZL.nonexhaustive(expr);
         }
         memory = stage.commit();
       }
@@ -6232,17 +6298,17 @@ function assignElementsToGroups(memory) {
     }
     return false;
   };
-  object_hash.x(
+  object_hash.C(
     object_hash.sortParentsFirst([...memory.explicitFirstSeenIn.keys()]),
     u((el) => {
       if (!isAncestorAssigned(el)) {
-        const groupId = chunkRAAYCPUM.nonNullable(memory.explicitFirstSeenIn.get(el));
+        const groupId = chunkWIMGWYZL.nonNullable(memory.explicitFirstSeenIn.get(el));
         assignedTo.set(el, groupId);
         groupAssignments.get(groupId).add(el);
       }
     })
   );
-  object_hash.x(
+  object_hash.C(
     object_hash.sortParentsFirst([...memory.lastSeenIn.keys()]),
     T((el) => !assignedTo.has(el)),
     u((el) => {
@@ -6252,7 +6318,7 @@ function assignElementsToGroups(memory) {
       if (isDescendantAssigned(el)) {
         return;
       }
-      const groupId = chunkRAAYCPUM.nonNullable(memory.lastSeenIn.get(el));
+      const groupId = chunkWIMGWYZL.nonNullable(memory.lastSeenIn.get(el));
       assignedTo.set(el, groupId);
       groupAssignments.get(groupId).add(el);
     })
@@ -6280,7 +6346,7 @@ function unsafeComputeView(viewsource, likec4model) {
     case view.isElementView(viewsource):
       return computeElementView(likec4model, viewsource);
     default:
-      chunkRAAYCPUM.nonexhaustive(viewsource);
+      chunkWIMGWYZL.nonexhaustive(viewsource);
   }
 }
 function computeView(viewsource, likec4model) {
@@ -6367,14 +6433,14 @@ class LikeC4DeploymentModel {
       return el;
     }
     const id = getId(el);
-    return chunkRAAYCPUM.nonNullable(this.#elements.get(id), `Element ${id} not found`);
+    return chunkWIMGWYZL.nonNullable(this.#elements.get(id), `Element ${id} not found`);
   }
   findElement(el) {
     return this.#elements.get(el) ?? null;
   }
   node(el) {
     const element = this.element(el);
-    chunkRAAYCPUM.invariant(element.isDeploymentNode(), `Element ${element.id} is not a deployment node`);
+    chunkWIMGWYZL.invariant(element.isDeploymentNode(), `Element ${element.id} is not a deployment node`);
     return element;
   }
   findNode(el) {
@@ -6382,12 +6448,12 @@ class LikeC4DeploymentModel {
     if (!element) {
       return null;
     }
-    chunkRAAYCPUM.invariant(element.isDeploymentNode(), `Element ${element?.id} is not a deployment node`);
+    chunkWIMGWYZL.invariant(element.isDeploymentNode(), `Element ${element?.id} is not a deployment node`);
     return element;
   }
   instance(el) {
     const element = this.element(el);
-    chunkRAAYCPUM.invariant(element.isInstance(), `Element ${element.id} is not a deployed instance`);
+    chunkWIMGWYZL.invariant(element.isInstance(), `Element ${element.id} is not a deployed instance`);
     return element;
   }
   findInstance(el) {
@@ -6395,7 +6461,7 @@ class LikeC4DeploymentModel {
     if (!element) {
       return null;
     }
-    chunkRAAYCPUM.invariant(element.isInstance(), `Element ${element?.id} is not a deployed instance`);
+    chunkWIMGWYZL.invariant(element.isInstance(), `Element ${element?.id} is not a deployed instance`);
     return element;
   }
   /**
@@ -6459,7 +6525,7 @@ class LikeC4DeploymentModel {
    * Returns a specific relationship by its ID.
    */
   relationship(id) {
-    return chunkRAAYCPUM.nonNullable(this.#relations.get(id), `DeploymentRelationModel ${id} not found`);
+    return chunkWIMGWYZL.nonNullable(this.#relations.get(id), `DeploymentRelationModel ${id} not found`);
   }
   findRelationship(id) {
     return this.#relations.get(id) ?? null;
@@ -6574,11 +6640,11 @@ class LikeC4DeploymentModel {
     this.#elements.set(el.id, el);
     const parentId = object_hash.parentFqn(el.id);
     if (parentId) {
-      chunkRAAYCPUM.invariant(this.#elements.has(parentId), `Parent ${parentId} of ${el.id} not found`);
+      chunkWIMGWYZL.invariant(this.#elements.has(parentId), `Parent ${parentId} of ${el.id} not found`);
       this.#parents.set(el.id, this.node(parentId));
       this.#children.get(parentId).add(el);
     } else {
-      chunkRAAYCPUM.invariant(el.isDeploymentNode(), `Root element ${el.id} is not a deployment node`);
+      chunkWIMGWYZL.invariant(el.isDeploymentNode(), `Root element ${el.id} is not a deployment node`);
       this.#rootElements.add(el);
     }
     return el;
@@ -6987,7 +7053,7 @@ class LikeC4ViewModel {
    */
   node(node) {
     const nodeId = getId(node);
-    return chunkRAAYCPUM.nonNullable(this.#nodes.get(nodeId), `Node ${nodeId} not found in view ${this.$view.id}`);
+    return chunkWIMGWYZL.nonNullable(this.#nodes.get(nodeId), `Node ${nodeId} not found in view ${this.$view.id}`);
   }
   /**
    * Find node by id.
@@ -7012,7 +7078,7 @@ class LikeC4ViewModel {
    */
   edge(edge) {
     const edgeId = getId(edge);
-    return chunkRAAYCPUM.nonNullable(this.#edges.get(edgeId), `Edge ${edgeId} not found in view ${this.$view.id}`);
+    return chunkWIMGWYZL.nonNullable(this.#edges.get(edgeId), `Edge ${edgeId} not found in view ${this.$view.id}`);
   }
   findEdge(edge) {
     return this.#edges.get(getId(edge)) ?? null;
@@ -7090,7 +7156,7 @@ class LikeC4Model {
       }
     }
     this.deployment = new LikeC4DeploymentModel(this, $model.deployments);
-    const views = object_hash.x(
+    const views = object_hash.C(
       r$3($model.views),
       m$1((a, b) => object_hash.compareNatural(a.title ?? "untitled", b.title ?? "untitled"))
     );
@@ -7182,7 +7248,7 @@ class LikeC4Model {
       return el;
     }
     const id = getId(el);
-    return chunkRAAYCPUM.nonNullable(this.findElement(id), `Element ${getId(el)} not found`);
+    return chunkWIMGWYZL.nonNullable(this.findElement(id), `Element ${getId(el)} not found`);
   }
   findElement(el) {
     return this.#elements.get(el) ?? null;
@@ -7211,9 +7277,9 @@ class LikeC4Model {
     }
     let model = this.#relations.get(id) ?? null;
     if (model || type === "model") {
-      return chunkRAAYCPUM.nonNullable(model, `Model relation ${id} not found`);
+      return chunkWIMGWYZL.nonNullable(model, `Model relation ${id} not found`);
     }
-    return chunkRAAYCPUM.nonNullable(this.deployment.findRelationship(id), `No model/deployment relation ${id} not found`);
+    return chunkWIMGWYZL.nonNullable(this.deployment.findRelationship(id), `No model/deployment relation ${id} not found`);
   }
   findRelationship(id, type) {
     if (type === "deployment") {
@@ -7235,7 +7301,7 @@ class LikeC4Model {
    * Returns a specific view by its ID.
    */
   view(viewId) {
-    return chunkRAAYCPUM.nonNullable(this.#views.get(viewId), `View ${viewId} not found`);
+    return chunkWIMGWYZL.nonNullable(this.#views.get(viewId), `View ${viewId} not found`);
   }
   findView(viewId) {
     return this.#views.get(viewId) ?? null;
@@ -7348,7 +7414,7 @@ class LikeC4Model {
     this.#elements.set(el.id, el);
     const parentId = object_hash.parentFqn(el.id);
     if (parentId) {
-      chunkRAAYCPUM.invariant(this.#elements.has(parentId), `Parent ${parentId} of ${el.id} not found`);
+      chunkWIMGWYZL.invariant(this.#elements.has(parentId), `Parent ${parentId} of ${el.id} not found`);
       this.#parents.set(el.id, this.element(parentId));
       this.#children.get(parentId).add(el);
     } else {