@likec4/core 1.19.1 → 1.19.2

package/dist/shared/{index.DafVOuVd.js → index.KOeaSlL8.js}

@@ -1,5 +1,5 @@
-import { O as x, P as s$1, Q as a$4, k as hierarchyLevel, o as isAncestor, f as commonAncestor, r as sortNaturalByFqn, m as m$3, c as commonHead, R as getDefaultExportFromCjs, S as requireForeach, T as requireIterator, U as u$7, N as objectHash, J as intersection, H as difference, L as union, M as stringHash, I as equals, x as isString, q as isDescendantOf, a as isSameHierarchy, C as isome, y as ifilter, B as isIterable, G as toSet, u as sortParentsFirst, F as toArray, D as DefaultMap, A as imap, i as i$9, V as d$6, p as parentFqn, W as n$5, g as compareByFqnHierarchically, w as isNonEmptyArray, d as compareNatural, n as nameFromFqn, t as t$6, l as l$7, X as hasIntersection, s as sortByFqnHierarchically, e as ancestorsFqn, E as iunique, z as iflat, v as getOrCreate } from './object_hash.CE_oF3I3.js';
-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, a4 as isViewRulePredicate, R as RelationExpr, 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 './view.CyZrG8BJ.js';
+import { O as x, P as s$1, Q as a$4, k as hierarchyLevel, o as isAncestor, f as commonAncestor, r as sortNaturalByFqn, m as m$3, c as commonHead, R as getDefaultExportFromCjs, S as requireForeach, T as requireIterator, U as u$7, N as objectHash, J as intersection, H as difference, L as union, M as stringHash, I as equals, x as isString, q as isDescendantOf, a as isSameHierarchy, C as isome, y as ifilter, B as isIterable, G as toSet, u as sortParentsFirst, F as toArray, D as DefaultMap, A as imap, i as i$9, V as d$6, p as parentFqn, W as n$5, g as compareByFqnHierarchically, w as isNonEmptyArray, d as compareNatural, n as nameFromFqn, t as t$6, X as hasIntersection, l as l$7, s as sortByFqnHierarchically, e as ancestorsFqn, E as iunique, z as iflat, v as getOrCreate } from './object_hash.CE_oF3I3.js';
+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 './view.DrmaOfjr.js';
 import { u as u$6, a as nonNullable, i as invariant, n as nonexhaustive } from './chunk-RAAYCPUM.M-JWF7SS.js';
 
 function r$3(...t){return u$6(Object.values,t)}
@@ -1538,6 +1538,9 @@ class AbstractDeploymentElementModel {
   get tags() {
     return this.$node.tags ?? [];
   }
+  get kind() {
+    return this.$node.kind ?? null;
+  }
   get description() {
     return this.$node.description ?? null;
   }
@@ -1797,6 +1800,9 @@ class DeployedInstanceModel extends AbstractDeploymentElementModel {
   get tags() {
     return this.$instance.tags ?? [];
   }
+  get kind() {
+    return this.$instance.kind ?? null;
+  }
   get description() {
     return this.$instance.description ?? this.element.description;
   }
@@ -1912,6 +1918,9 @@ class DeploymentRelationModel {
   get tags() {
     return this.$relationship.tags ?? [];
   }
+  get kind() {
+    return this.$relationship.kind ?? null;
+  }
   get navigateTo() {
     return this.$relationship.navigateTo ? this.$model.$model.view(this.$relationship.navigateTo) : null;
   }
@@ -2053,11 +2062,10 @@ class DeploymentConnectionModel {
     yield* this.relations.model;
     yield* this.relations.deployment;
   }
-  /**
-   * Merge with another connection, if it has the same source and target.
-   * Returns new connection with union of relationships.
-   */
   mergeWith(other) {
+    if (Array.isArray(other)) {
+      return other.reduce((acc, o) => acc.mergeWith(o), this);
+    }
     invariant(this.source.id === other.source.id, "Cannot merge connections with different sources");
     invariant(this.target.id === other.target.id, "Cannot merge connections with different targets");
     return new DeploymentConnectionModel(
@@ -3736,103 +3744,283 @@ function findConnectedElements(stage) {
   );
 }
 
-const IncomingRelationPredicate = {
-  include: ({ expr, model, memory, stage }) => {
-    const sources = [...memory.elements];
-    if (FqnExpr.isWildcard(expr.incoming)) {
-      for (const source of sources) {
-        if (source.allOutgoing.isEmpty) {
+const OutgoingRelationPredicate = {
+  include: ({ expr, model, memory, stage, where }) => {
+    const targets = [...memory.elements];
+    if (FqnExpr.isWildcard(expr.outgoing)) {
+      for (const target of targets) {
+        if (target.allIncoming.isEmpty) {
           continue;
         }
-        const targets2 = [...resolveAscendingSiblings(source)];
-        stage.addConnections(findConnectionsBetween(source, targets2, "directed"));
+        for (const source of resolveAscendingSiblings(target)) {
+          const toInclude = applyPredicate(findConnection(source, target, "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);
+    invariant(FqnExpr.isDeploymentRef(expr.outgoing), "Only deployment refs are supported in include");
+    const sources = resolveElements$1(model, expr.outgoing);
     for (const source of sources) {
-      stage.addConnections(findConnectionsBetween(source, targets, "directed"));
+      const toInclude = applyPredicate(findConnectionsBetween(source, targets, "directed"), where);
+      stage.addConnections(toInclude);
     }
     return stage;
   },
-  exclude: ({ expr, model, memory, stage }) => {
-    if (FqnExpr.isModelRef(expr.incoming)) {
-      const excludedRelations = resolveAllImcomingRelations(model, expr.incoming);
-      return excludeModelRelations(excludedRelations, { stage, memory });
+  exclude: ({ expr, model, memory, stage, where }) => {
+    if (FqnExpr.isModelRef(expr.outgoing)) {
+      const excludedRelations = resolveAllOutgoingRelations(model, expr.outgoing);
+      return excludeModelRelations(excludedRelations, { stage, memory }, where);
     }
-    if (FqnExpr.isWildcard(expr.incoming)) {
+    if (FqnExpr.isWildcard(expr.outgoing)) {
       return stage;
     }
-    const isIncoming = filterIncomingConnections(resolveElements$1(model, expr.incoming));
-    const toExclude = memory.connections.filter(isIncoming);
+    const isOutgoing = filterOutgoingConnections(resolveElements$1(model, expr.outgoing));
+    const toExclude = x(
+      memory.connections,
+      T(isOutgoing),
+      applyPredicate(where)
+    );
     stage.excludeConnections(toExclude);
     return stage;
   }
 };
-function filterIncomingConnections(targets) {
+function filterOutgoingConnections(sources) {
   return y$1(
-    targets.map((target) => {
-      const satisfies = (el) => el === target || isAncestor(target, el);
+    sources.map((source) => {
+      const satisfies = (el) => el === source || isAncestor(source, el);
       return (connection) => {
-        return !satisfies(connection.source) && satisfies(connection.target);
+        return satisfies(connection.source) && !satisfies(connection.target);
       };
     })
   );
 }
-function resolveAllImcomingRelations(model, moodelRef) {
+function resolveAllOutgoingRelations(model, moodelRef) {
   const targets = resolveModelElements(model, moodelRef);
-  return new Set(targets.flatMap((e) => [...e.allIncoming]));
+  return new Set(targets.flatMap((e) => [...e.allOutgoing]));
 }
 
-const OutgoingRelationPredicate = {
+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$1(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$1(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);
+    }
+    if (FqnExpr.isWildcard(expr.inout)) {
+      return stage;
+    }
+    const elements = resolveElements$1(model, expr.inout);
+    const isIncoming = filterIncomingConnections(elements);
+    const isOutgoing = filterOutgoingConnections(elements);
+    const toExclude = x(
+      memory.connections,
+      T((c) => isIncoming(c) !== isOutgoing(c)),
+      applyPredicate(where)
+    );
+    stage.excludeConnections(toExclude);
+    return stage;
+  }
+};
+
+const WhereRelationPredicate = {
   include: ({ expr, model, memory, stage }) => {
-    const targets = [...memory.elements];
-    if (FqnExpr.isWildcard(expr.outgoing)) {
-      for (const target of targets) {
-        if (target.allIncoming.isEmpty) {
+    const where = whereOperatorAsPredicate(expr.where.condition);
+    return predicateToPatch("include", { expr: expr.where.expr, model, stage, memory, where });
+  },
+  exclude: ({ expr, model, memory, stage }) => {
+    const where = whereOperatorAsPredicate(expr.where.condition);
+    return predicateToPatch("exclude", { expr: expr.where.expr, model, stage, memory, where });
+  }
+};
+
+const WildcardPredicate$1 = {
+  include: ({ model, stage }) => {
+    const children = [];
+    const rootElements = [...model.roots()].map((root) => {
+      if (!root.onlyOneInstance()) {
+        children.push(...root.children());
+      }
+      return root;
+    });
+    stage.addExplicit(rootElements);
+    if (children.length > 1) {
+      stage.addConnections(findConnectionsWithin([
+        ...rootElements,
+        ...children
+      ]));
+    }
+    return stage;
+  },
+  exclude: ({ stage, memory }) => {
+    stage.exclude(memory.elements);
+    return stage;
+  }
+};
+
+function predicateToPatch(op, { expr, where, ...ctx }) {
+  switch (true) {
+    case FqnExpr.isModelRef(expr):
+      return void 0;
+    case FqnExpr.isDeploymentRef(expr):
+      return DeploymentRefPredicate[op]({ ...ctx, expr, where });
+    case FqnExpr.isWildcard(expr):
+      return WildcardPredicate$1[op]({ ...ctx, expr, where });
+    case RelationExpr.isDirect(expr):
+      return DirectRelationPredicate[op]({ ...ctx, expr, where });
+    case RelationExpr.isInOut(expr):
+      return InOutRelationPredicate$1[op]({ ...ctx, expr, where });
+    case RelationExpr.isOutgoing(expr):
+      return OutgoingRelationPredicate[op]({ ...ctx, expr, where });
+    case RelationExpr.isIncoming(expr):
+      return IncomingRelationPredicate[op]({ ...ctx, expr, where });
+    case RelationExpr.isWhere(expr):
+      return WhereRelationPredicate[op]({ ...ctx, expr, where });
+    default:
+      nonexhaustive(expr);
+  }
+}
+function excludeModelRelations(relationsToExclude, { stage, memory }, where, filterConnections = () => true) {
+  if (relationsToExclude.size === 0) {
+    return stage;
+  }
+  const toExclude = x(
+    memory.connections,
+    T((c) => filterConnections(c)),
+    // Find connections that have at least one relation in common with the excluded relations
+    T((c) => hasIntersection(c.relations.model, relationsToExclude)),
+    m$3(
+      (c) => c.update({
+        deployment: null,
+        model: intersection(c.relations.model, relationsToExclude)
+      })
+    ),
+    applyPredicate(where),
+    T((c) => c.nonEmpty())
+  );
+  if (toExclude.length === 0) {
+    return stage;
+  }
+  return stage.excludeConnections(toExclude);
+}
+function matchConnection$1(c, where) {
+  return applyPredicate(c, where).nonEmpty();
+}
+function applyPredicate(...args) {
+  if (args.length === 1) {
+    return (x) => applyPredicate(x, args[0]);
+  }
+  const [c, where] = args;
+  if (where === null) {
+    return c;
+  }
+  if (o$a(c)) {
+    return c.map((x) => applyPredicate(x, where)).filter((x) => x.nonEmpty());
+  }
+  const map2 = toFilterableRelation$1(c.source, c.target);
+  return c.update({
+    model: new Set([...c.relations.model.values()].filter((r) => where(map2(r)))),
+    deployment: new Set([...c.relations.deployment.values()].filter((r) => where(map2(r))))
+  });
+}
+function matchConnections$1(connections, where) {
+  if (!where) {
+    return connections;
+  }
+  return x(
+    connections,
+    T((c) => matchConnection$1(c, where))
+  );
+}
+function elementToFilterable$1(element) {
+  return i$7(element, ["tags", "kind"]);
+}
+function toFilterableRelation$1(source, target) {
+  return (relation) => ({
+    tags: relation.tags,
+    kind: relation.kind,
+    source: elementToFilterable$1(source),
+    target: elementToFilterable$1(target)
+  });
+}
+
+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;
         }
-        for (const source of resolveAscendingSiblings(target)) {
-          stage.addConnections(findConnection(source, target, "directed"));
-        }
+        const targets2 = [...resolveAscendingSiblings(source)];
+        const toInclude = applyPredicate(findConnectionsBetween(source, targets2, "directed"), where);
+        stage.addConnections(toInclude);
       }
       return stage;
     }
-    invariant(FqnExpr.isDeploymentRef(expr.outgoing), "Only deployment refs are supported in include");
-    const sources = resolveElements$1(model, expr.outgoing);
+    invariant(FqnExpr.isDeploymentRef(expr.incoming), "Only deployment refs are supported in include");
+    const targets = resolveElements$1(model, expr.incoming);
     for (const source of sources) {
-      stage.addConnections(findConnectionsBetween(source, targets, "directed"));
+      const toInclude = applyPredicate(findConnectionsBetween(source, targets, "directed"), where);
+      stage.addConnections(toInclude);
     }
     return stage;
   },
-  exclude: ({ expr, model, memory, stage }) => {
-    if (FqnExpr.isModelRef(expr.outgoing)) {
-      const excludedRelations = resolveAllOutgoingRelations(model, expr.outgoing);
-      return excludeModelRelations(excludedRelations, { stage, memory });
+  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.outgoing)) {
+    if (FqnExpr.isWildcard(expr.incoming)) {
       return stage;
     }
-    const isOutgoing = filterOutgoingConnections(resolveElements$1(model, expr.outgoing));
-    const toExclude = memory.connections.filter(isOutgoing);
+    const isIncoming = filterIncomingConnections(resolveElements$1(model, expr.incoming));
+    const toExclude = x(
+      memory.connections,
+      T(isIncoming),
+      applyPredicate(where)
+    );
     stage.excludeConnections(toExclude);
     return stage;
   }
 };
-function filterOutgoingConnections(sources) {
+function filterIncomingConnections(targets) {
   return y$1(
-    sources.map((source) => {
-      const satisfies = (el) => el === source || isAncestor(source, el);
+    targets.map((target) => {
+      const satisfies = (el) => el === target || isAncestor(target, el);
       return (connection) => {
-        return satisfies(connection.source) && !satisfies(connection.target);
+        return !satisfies(connection.source) && satisfies(connection.target);
       };
     })
   );
 }
-function resolveAllOutgoingRelations(model, moodelRef) {
+function resolveAllImcomingRelations(model, moodelRef) {
   const targets = resolveModelElements(model, moodelRef);
-  return new Set(targets.flatMap((e) => [...e.allOutgoing]));
+  return new Set(targets.flatMap((e) => [...e.allIncoming]));
 }
 
 const resolveAscendingSiblings = (element) => {
@@ -3843,7 +4031,7 @@ const resolveAscendingSiblings = (element) => {
   return siblings;
 };
 const DirectRelationPredicate = {
-  include: ({ expr: { source, target, isBidirectional = false }, model, stage }) => {
+  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);
@@ -3898,7 +4086,7 @@ const DirectRelationPredicate = {
         const isTarget = filterIncomingConnections(targets);
         connections = x(
           sources,
-          u$1((s) => findConnectionsBetween(s, targets, dir)),
+          u$1((s) => matchConnections(findConnectionsBetween(s, targets, dir), where)),
           T((c) => isSource(c) && isTarget(c))
         );
       }
@@ -3912,72 +4100,64 @@ const DirectRelationPredicate = {
     }
     return stage;
   },
-  exclude: ({ expr, model, memory, stage }) => {
-    if (FqnExpr.isWildcard(expr.source) && FqnExpr.isWildcard(expr.target)) {
-      stage.excludeConnections(memory.connections);
-      return stage;
-    }
-    if (FqnExpr.isModelRef(expr.source) && FqnExpr.isModelRef(expr.target)) {
-      const toExclude2 = resolveRelationsBetweenModelElements({
-        source: expr.source,
-        target: expr.target,
-        expr,
-        model
-      });
-      return excludeModelRelations(toExclude2, { stage, memory });
-    }
-    if (FqnExpr.isModelRef(expr.source)) {
-      if (FqnExpr.isWildcard(expr.target)) {
-        const toExclude2 = resolveAllOutgoingRelations(model, expr.source);
-        return excludeModelRelations(toExclude2, { stage, memory });
-      }
-      const allOutgoing = resolveAllOutgoingRelations(model, expr.source);
-      const isTarget2 = deploymentExpressionToPredicate(expr.target);
-      return excludeModelRelations(
-        allOutgoing,
-        { stage, memory },
-        (c) => isTarget2(c.target)
-      );
-    }
-    if (FqnExpr.isModelRef(expr.target)) {
-      const toExclude2 = resolveAllImcomingRelations(model, expr.target);
-      const isSource2 = deploymentExpressionToPredicate(expr.source);
-      return excludeModelRelations(
-        toExclude2,
-        { stage, memory },
-        (c) => isSource2(c.source)
-      );
-    }
-    const isSource = deploymentExpressionToPredicate(expr.source);
+  exclude: ({ expr, model, memory, stage, where }) => {
     const isTarget = deploymentExpressionToPredicate(expr.target);
-    const satisfies = (connection) => {
-      return isSource(connection.source) && isTarget(connection.target) || expr.isBidirectional && isSource(connection.target) && isTarget(connection.source);
-    };
-    const toExclude = memory.connections.filter(satisfies);
-    stage.excludeConnections(toExclude);
-    return stage;
+    const isSource = deploymentExpressionToPredicate(expr.source);
+    let modelRelationsToExclude;
+    switch (true) {
+      // * -> *
+      case (FqnExpr.isWildcard(expr.source) && FqnExpr.isWildcard(expr.target)):
+        stage.excludeConnections(matchConnections(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 excludeModelRelations(relationsToExclude, { stage, memory }, filterConnections = () => true) {
-  if (relationsToExclude.size === 0) {
-    return stage;
-  }
-  const toExclude = x(
-    memory.connections,
-    // Find connections that have at least one relation in common with the excluded relations
-    T((c) => filterConnections(c) && hasIntersection(c.relations.model, relationsToExclude)),
-    m$3(
-      (c) => c.update({
-        deployment: null,
-        model: intersection(c.relations.model, relationsToExclude)
-      })
-    )
-  );
-  if (toExclude.length === 0) {
-    return stage;
-  }
-  return stage.excludeConnections(toExclude);
-}
 function resolveRelationsBetweenModelElements({
   source,
   target,
@@ -3993,71 +4173,35 @@ function resolveRelationsBetweenModelElements({
   }
   return new Set(modelConnections.flatMap((c) => [...c.relations]));
 }
-
-const InOutRelationPredicate$1 = {
-  include: ({ expr, model, memory, stage }) => {
-    const sources = [...memory.elements];
-    if (FqnExpr.isWildcard(expr.inout)) {
-      for (const source of sources) {
-        const targets2 = [...resolveAscendingSiblings(source)];
-        stage.addConnections(findConnectionsBetween(source, targets2, "both"));
-      }
-      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) {
-      stage.addConnections(findConnectionsBetween(source, targets, "both"));
-    }
-    return stage;
-  },
-  exclude: ({ expr, model, memory, stage }) => {
-    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 });
-    }
-    if (FqnExpr.isWildcard(expr.inout)) {
-      return stage;
-    }
-    const elements = resolveElements$1(model, expr.inout);
-    const isIncoming = filterIncomingConnections(elements);
-    const isOutgoing = filterOutgoingConnections(elements);
-    const toExclude = memory.connections.filter((c) => isIncoming(c) !== isOutgoing(c));
-    stage.excludeConnections(toExclude);
-    return stage;
+function elementToFilterable(element) {
+  return i$7(element, ["tags", "kind"]);
+}
+function toFilterableRelation(source, target) {
+  return (relation) => ({
+    tags: relation.tags,
+    kind: relation.kind,
+    source: elementToFilterable(source),
+    target: elementToFilterable(target)
+  });
+}
+function matchConnection(c, where) {
+  if (!where) {
+    return true;
   }
-};
-
-const WildcardPredicate$1 = {
-  include: ({ model, stage }) => {
-    const children = [];
-    const rootElements = [...model.roots()].map((root) => {
-      if (!root.onlyOneInstance()) {
-        children.push(...root.children());
-      }
-      return root;
-    });
-    stage.addExplicit(rootElements);
-    if (children.length > 1) {
-      stage.addConnections(findConnectionsWithin([
-        ...rootElements,
-        ...children
-      ]));
-    }
-    return stage;
-  },
-  exclude: ({ stage, memory }) => {
-    stage.exclude(memory.elements);
-    return stage;
+  return [
+    ...Array.from(c.relations.deployment.values()).map(toFilterableRelation(c.source, c.target)),
+    ...Array.from(c.relations.model.values()).map(toFilterableRelation(c.source, c.target))
+  ].filter(where).length > 0;
+}
+function matchConnections(connections, where) {
+  if (!where) {
+    return connections;
   }
-};
+  return x(
+    connections,
+    T((c) => matchConnection(c, where))
+  );
+}
 
 let StageFinal$1 = class StageFinal {
   constructor(memory) {
@@ -4235,31 +4379,8 @@ function processPredicates$1(model, rules) {
       const exprs = rule.include ?? rule.exclude;
       for (const expr of exprs) {
         let stage = op === "include" ? memory.stageInclude(expr) : memory.stageExclude(expr);
-        const ctx = { model, stage, memory };
-        switch (true) {
-          case FqnExpr.isModelRef(expr):
-            break;
-          case FqnExpr.isDeploymentRef(expr):
-            stage = DeploymentRefPredicate[op]({ ...ctx, expr }) ?? stage;
-            break;
-          case FqnExpr.isWildcard(expr):
-            stage = WildcardPredicate$1[op]({ ...ctx, expr }) ?? stage;
-            break;
-          case RelationExpr.isDirect(expr):
-            stage = DirectRelationPredicate[op]({ ...ctx, expr }) ?? stage;
-            break;
-          case RelationExpr.isInOut(expr):
-            stage = InOutRelationPredicate$1[op]({ ...ctx, expr }) ?? stage;
-            break;
-          case RelationExpr.isOutgoing(expr):
-            stage = OutgoingRelationPredicate[op]({ ...ctx, expr }) ?? stage;
-            break;
-          case RelationExpr.isIncoming(expr):
-            stage = IncomingRelationPredicate[op]({ ...ctx, expr }) ?? stage;
-            break;
-          default:
-            nonexhaustive(expr);
-        }
+        const ctx = { expr, model, stage, memory, where: null };
+        stage = predicateToPatch(op, ctx) ?? stage;
         memory = stage.commit();
       }
     }
@@ -4273,7 +4394,7 @@ function computeDeploymentView(likec4model, {
   // exclude rules
   ...view
 }) {
-  let memory = processPredicates$1(likec4model.deployment, rules);
+  const memory = processPredicates$1(likec4model.deployment, rules);
   const nodesMap = buildNodes$1(memory);
   const computedEdges = toComputedEdges$1(memory.connections);
   linkNodesWithEdges(nodesMap, computedEdges);
@@ -6718,6 +6839,9 @@ class RelationshipModel {
   get tags() {
     return this.$relationship.tags ?? [];
   }
+  get kind() {
+    return this.$relationship.kind ?? null;
+  }
   get links() {
     return this.$relationship.links ?? [];
   }