@likec4/core 1.27.3 → 1.28.0

package/dist/shared/{core.RjpTh3vE.mjs → core.Bjl6Kmc8.mjs}

@@ -1,4 +1,4 @@
-import { D as DefaultElementShape, c as DefaultThemeColor, h as DefaultShapeSize, U as DefaultRelationshipColor, T as DefaultLineStyle, ab as o$8, t as isElementWhere, Q as whereOperatorAsPredicate, G as isWildcard, q as isElementKindExpr, s as isElementTagExpr, n as n$4, u as isExpandedElementExpr, r as isElementRef, l as isCustomElement, a9 as isViewRuleStyle, ac as y$2, V as ComputedNode, E as ElementKind, S as DefaultArrowType, I as FqnExpr, R as RelationExpr, o as o$9, a8 as isViewRulePredicate, a4 as isViewRuleAutoLayout, a7 as isViewRuleGroup, a5 as isViewRuleGlobalPredicateRef, a6 as isViewRuleGlobalStyle, aa as stepEdgeId, a2 as isDynamicViewParallelSteps, x as isOutgoing$1, v as isIncoming$1, w as isInOut, y as isRelation, F as isRelationWhere, m as isCustomRelationExpr, C as isRelationPredicateExpr, b as isElementPredicateExpr, a as isElementView, a1 as isDynamicView, a0 as isDeploymentView, d as DeploymentElement, Y as extractStep, a3 as isStepEdgeId, e as isScopedElementView } from './core.BMep80lJ.mjs';
+import { s as splitGlobalFqn, D as DefaultElementShape, b as DefaultThemeColor, g as DefaultShapeSize, Z as n$3, y as DefaultRelationshipColor, x as DefaultLineStyle, _ as o$8, M as ModelLayer, w as whereOperatorAsPredicate, n as n$4, X as isViewRuleStyle, $ as y$2, C as ComputedNode, E as ElementKind, v as DefaultArrowType, F as FqnExpr, R as RelationExpr, o as o$9, W as isViewRulePredicate, S as isViewRuleAutoLayout, V as isViewRuleGroup, T as isViewRuleGlobalPredicateRef, U as isViewRuleGlobalStyle, Y as stepEdgeId, P as isDynamicViewParallelSteps, a as isElementView, O as isDynamicView, N as isDeploymentView, c as DeploymentElement, I as extractStep, Q as isStepEdgeId, d as isScopedElementView, e as isGlobalFqn, G as GlobalFqn } from './core.DgfwjBtu.mjs';
 import { C, y as s$1, z as a$5, u as hierarchyLevel, a as isAncestor, m as commonAncestor, w as sortNaturalByFqn, j as getDefaultExportFromCjs, i as isDescendantOf, x as isString, g as isSameHierarchy, c as ifilter, t as toSet, s as sortParentsFirst, b as toArray, D as DefaultMap, d as imap, p as parentFqn, o as compareByFqnHierarchically, e as isNonEmptyArray, k as compareNatural, n as nameFromFqn, f as t$6, v as sortByFqnHierarchically, l as ancestorsFqn } from './core.CQXU9DF7.mjs';
 import { u as u$6 } from './core.DbRvwARP.mjs';
 import { n as nonNullable, i as invariant, a as nonexhaustive } from './core.C-YXI-43.mjs';
@@ -18,7 +18,7 @@ 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
 
 function m$1(...r){return u$6(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 a$3(...r){return s(n$2,r)}var n$2=(r,t)=>[...r].sort(t);
 
 function l$5(...e){return u$6(u$3,e)}var u$3=(e,a,n)=>e.reduce(a,n);
 
@@ -40,8 +40,6 @@ function t$2(...n){return u$6(o$4,n)}var o$4=n=>n.length===1?n[0]:void 0;
 
 function i$3(...e){return u$6(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 u$6(n$1,e)}var n$1=e=>e.at(-1);
 
 function l$3(...n){return u$6(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}
@@ -78,11 +76,22 @@ class ElementModel {
     this.$element = $element;
     this.id = this.$element.id;
     this._literalId = this.$element.id;
-    this.hierarchyLevel = hierarchyLevel(this.id);
+    const [projectId, fqn] = splitGlobalFqn(this.id);
+    if (projectId) {
+      this.imported = {
+        from: projectId,
+        fqn
+      };
+      this.hierarchyLevel = hierarchyLevel(fqn);
+    } else {
+      this.imported = null;
+      this.hierarchyLevel = hierarchyLevel(this.id);
+    }
   }
   id;
   _literalId;
   hierarchyLevel;
+  imported;
   get parent() {
     return this.$model.parent(this);
   }
@@ -251,7 +260,7 @@ class ElementModel {
    * @returns true if the element is deployed
    */
   isDeployed() {
-    return n$2(this.deployments().next().value);
+    return n$3(this.deployments().next().value);
   }
   deployments() {
     return this.$model.deployment.instancesOf(this);
@@ -1466,7 +1475,7 @@ function calcViewLayoutHash(view) {
     nodes: C(
       view.nodes,
       m$3(i$6(["id", "title", "description", "technology", "shape", "icon", "children"])),
-      l$3(({ id, icon, ...node }) => [id, { ...node, icon: n$2(icon) ? "Y" : "N" }])
+      l$3(({ id, icon, ...node }) => [id, { ...node, icon: n$3(icon) ? "Y" : "N" }])
     ),
     edges: C(
       view.edges,
@@ -3156,29 +3165,39 @@ let Memory$1 = class Memory extends AbstractMemory {
 };
 
 function elementExprToPredicate(target) {
-  if (isElementWhere(target)) {
+  if (ModelLayer.FqnExpr.isCustom(target)) {
+    return elementExprToPredicate(target.custom.expr);
+  }
+  if (ModelLayer.FqnExpr.isWhere(target)) {
     const predicate = elementExprToPredicate(target.where.expr);
     const where = whereOperatorAsPredicate(target.where.condition);
     return (n) => predicate(n) && where(n);
   }
-  if (isWildcard(target)) {
-    return () => true;
-  }
-  if (isElementKindExpr(target)) {
+  if (ModelLayer.FqnExpr.isElementKindExpr(target)) {
     return target.isEqual ? (n) => n.kind === target.elementKind : (n) => n.kind !== target.elementKind;
   }
-  if (isElementTagExpr(target)) {
+  if (ModelLayer.FqnExpr.isElementTagExpr(target)) {
     return target.isEqual ? ({ tags }) => !!tags && tags.includes(target.elementTag) : ({ tags }) => n$4(tags) || !tags.includes(target.elementTag);
   }
-  if (isExpandedElementExpr(target)) {
-    return (n) => n.id === target.expanded || parentFqn(n.id) === target.expanded;
-  }
-  if (isElementRef(target)) {
-    const { element, isChildren, isDescendants } = target;
-    return isChildren || isDescendants ? (n) => n.id.startsWith(element + ".") : (n) => n.id === element;
+  if (ModelLayer.FqnExpr.isWildcard(target)) {
+    return () => true;
   }
-  if (isCustomElement(target)) {
-    return elementExprToPredicate(target.custom.expr);
+  if (ModelLayer.FqnExpr.isModelRef(target)) {
+    const fqn = ModelLayer.FqnRef.toFqn(target.ref);
+    if (target.selector === "expanded") {
+      return (n) => {
+        return n.id === fqn || parentFqn(n.id) === fqn;
+      };
+    }
+    if (target.selector === "descendants" || target.selector === "children") {
+      const fqnWithDot = fqn + ".";
+      return (n) => {
+        return n.id.startsWith(fqnWithDot);
+      };
+    }
+    return (n) => {
+      return n.id === fqn;
+    };
   }
   nonexhaustive(target);
 }
@@ -3379,31 +3398,31 @@ function mergePropsFromRelationships(relations, prefer) {
     relations,
     l$5(
       (acc, r) => {
-        if (n$2(r.title) && !acc.title.includes(r.title)) {
+        if (n$3(r.title) && !acc.title.includes(r.title)) {
           acc.title.push(r.title);
         }
-        if (n$2(r.description) && !acc.description.includes(r.description)) {
+        if (n$3(r.description) && !acc.description.includes(r.description)) {
           acc.description.push(r.description);
         }
-        if (n$2(r.technology) && !acc.technology.includes(r.technology)) {
+        if (n$3(r.technology) && !acc.technology.includes(r.technology)) {
           acc.technology.push(r.technology);
         }
-        if (n$2(r.kind) && !acc.kind.includes(r.kind)) {
+        if (n$3(r.kind) && !acc.kind.includes(r.kind)) {
           acc.kind.push(r.kind);
         }
-        if (n$2(r.color) && !acc.color.includes(r.color)) {
+        if (n$3(r.color) && !acc.color.includes(r.color)) {
           acc.color.push(r.color);
         }
-        if (n$2(r.line) && !acc.line.includes(r.line)) {
+        if (n$3(r.line) && !acc.line.includes(r.line)) {
           acc.line.push(r.line);
         }
-        if (n$2(r.head) && !acc.head.includes(r.head)) {
+        if (n$3(r.head) && !acc.head.includes(r.head)) {
           acc.head.push(r.head);
         }
-        if (n$2(r.tail) && !acc.tail.includes(r.tail)) {
+        if (n$3(r.tail) && !acc.tail.includes(r.tail)) {
           acc.tail.push(r.tail);
         }
-        if (n$2(r.navigateTo) && !acc.navigateTo.includes(r.navigateTo)) {
+        if (n$3(r.navigateTo) && !acc.navigateTo.includes(r.navigateTo)) {
           acc.navigateTo.push(r.navigateTo);
         }
         if (r.tags) {
@@ -3447,12 +3466,12 @@ function mergePropsFromRelationships(relations, prefer) {
       ...isNonEmptyArray(allprops.links) && { links: allprops.links },
       ...isNonEmptyArray(tags) && { tags }
     },
-    n$2
+    n$3
   );
   if (prefer) {
     return {
       ...merged,
-      ...d$2(pickRelationshipProps(prefer), n$2)
+      ...d$2(pickRelationshipProps(prefer), n$3)
     };
   }
   return merged;
@@ -3500,6 +3519,9 @@ function deploymentExpressionToPredicate(target) {
   if (FqnExpr.isWildcard(target)) {
     return () => true;
   }
+  if (FqnExpr.isElementTagExpr(target) || FqnExpr.isElementKindExpr(target)) {
+    throw new Error("element kind and tag expressions are not supported in deployment view rules");
+  }
   if (FqnExpr.isDeploymentRef(target)) {
     const fqn = target.ref.deployment;
     if (target.selector === "expanded") {
@@ -3694,6 +3716,17 @@ function isDeploymentElementModel(x) {
   return x instanceof DeploymentNodeModel || x instanceof DeployedInstanceModel;
 }
 
+const WhereDeploymentRefPredicate = {
+  include: ({ expr, model, memory, stage }) => {
+    const where = whereOperatorAsPredicate(expr.where.condition);
+    return predicateToPatch("include", { expr: expr.where.expr, model, stage, memory, where });
+  },
+  exclude: ({ expr, model, memory, stage }) => {
+    const where = whereOperatorAsPredicate(expr.where.condition);
+    return predicateToPatch("exclude", { expr: expr.where.expr, model, stage, memory, where });
+  }
+};
+
 const IncomingRelationPredicate = {
   include: ({ expr, model, memory, stage, where }) => {
     const sources = [...memory.elements];
@@ -3717,6 +3750,9 @@ const IncomingRelationPredicate = {
     return stage;
   },
   exclude: ({ expr, model, memory, stage, where }) => {
+    if (FqnExpr.isElementTagExpr(expr.incoming) || FqnExpr.isElementKindExpr(expr.incoming)) {
+      throw new Error("element kind and tag expressions are not supported in exclude");
+    }
     if (FqnExpr.isModelRef(expr.incoming)) {
       const excludedRelations = resolveAllImcomingRelations(model, expr.incoming);
       return excludeModelRelations(excludedRelations, { stage, memory }, where);
@@ -3773,6 +3809,9 @@ const OutgoingRelationPredicate = {
     return stage;
   },
   exclude: ({ expr, model, memory, stage, where }) => {
+    if (FqnExpr.isElementTagExpr(expr.outgoing) || FqnExpr.isElementKindExpr(expr.outgoing)) {
+      throw new Error("element kind and tag expressions are not supported in exclude");
+    }
     if (FqnExpr.isModelRef(expr.outgoing)) {
       const excludedRelations = resolveAllOutgoingRelations(model, expr.outgoing);
       return excludeModelRelations(excludedRelations, { stage, memory }, where);
@@ -3814,6 +3853,12 @@ const resolveAscendingSiblings = (element) => {
 };
 const DirectRelationPredicate = {
   include: ({ expr: { source, target, isBidirectional = false }, model, stage, where }) => {
+    if (FqnExpr.isElementTagExpr(source) || FqnExpr.isElementKindExpr(source)) {
+      throw new Error("element kind and tag expressions are not supported in include");
+    }
+    if (FqnExpr.isElementTagExpr(target) || FqnExpr.isElementKindExpr(target)) {
+      throw new Error("element kind and tag expressions are not supported in include");
+    }
     invariant(!FqnExpr.isModelRef(source), "Invalid source model ref in direct relation");
     invariant(!FqnExpr.isModelRef(target), "Invalid target model ref in direct relation");
     const sourceIsWildcard = FqnExpr.isWildcard(source);
@@ -3991,6 +4036,9 @@ const InOutRelationPredicate$1 = {
     return stage;
   },
   exclude: ({ expr, model, memory, stage, where }) => {
+    if (FqnExpr.isElementTagExpr(expr.inout) || FqnExpr.isElementKindExpr(expr.inout)) {
+      throw new Error("element kind and tag expressions are not supported in exclude");
+    }
     if (FqnExpr.isModelRef(expr.inout)) {
       const elements2 = resolveModelElements(model, expr.inout);
       if (elements2.length === 0) {
@@ -4063,8 +4111,17 @@ const WildcardPredicate$1 = {
 
 function predicateToPatch(op, { expr, where, ...ctx }) {
   switch (true) {
+    case FqnExpr.isElementTagExpr(expr):
+    case FqnExpr.isElementKindExpr(expr):
+      throw new Error("element kind and tag expressions are not supported in deployment view rules");
+    case RelationExpr.isCustom(expr):
+    case FqnExpr.isCustom(expr):
     case FqnExpr.isModelRef(expr):
       return void 0;
+    case FqnExpr.isWhere(expr):
+      return WhereDeploymentRefPredicate[op]({ ...ctx, expr, where });
+    case RelationExpr.isWhere(expr):
+      return WhereRelationPredicate[op]({ ...ctx, expr, where });
     case FqnExpr.isDeploymentRef(expr):
       return DeploymentRefPredicate[op]({ ...ctx, expr, where });
     case FqnExpr.isWildcard(expr):
@@ -4077,8 +4134,6 @@ function predicateToPatch(op, { expr, where, ...ctx }) {
       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);
   }
@@ -4527,7 +4582,7 @@ function flattenGroupRules(guard) {
   };
 }
 function applyCustomElementProperties(_rules, _nodes) {
-  const rules = _rules.flatMap(flattenGroupRules(isCustomElement));
+  const rules = _rules.flatMap(flattenGroupRules(ModelLayer.FqnExpr.isCustom));
   if (rules.length === 0) {
     return _nodes;
   }
@@ -4662,7 +4717,7 @@ class DynamicViewCompute {
       color,
       line
     } = this.findRelations(source, target);
-    const navigateTo = n$2(stepNavigateTo) && stepNavigateTo !== this.view.id ? stepNavigateTo : derivedNavigateTo;
+    const navigateTo = n$3(stepNavigateTo) && stepNavigateTo !== this.view.id ? stepNavigateTo : derivedNavigateTo;
     this.steps.push({
       id,
       ...step,
@@ -4799,7 +4854,7 @@ class DynamicViewCompute {
     const alltags = C(
       relationships,
       u$1((r) => r.tags),
-      T(n$2),
+      T(n$3),
       i$8()
     );
     const tags = i$9(alltags, 1) ? alltags : null;
@@ -4809,7 +4864,7 @@ class DynamicViewCompute {
     const navigateTo = relationNavigateTo && relationNavigateTo !== this.view.id ? relationNavigateTo : C(
       relationships,
       m$3((r) => r.$relationship.navigateTo),
-      T(n$2),
+      T(n$3),
       T((v) => v !== this.view.id),
       i$8(),
       t$2()
@@ -4817,9 +4872,9 @@ class DynamicViewCompute {
     const commonProperties = C(
       relationships,
       l$5((acc, { title, $relationship: r }) => {
-        n$2(title) && acc.title.add(title);
-        n$2(r.color) && acc.color.add(r.color);
-        n$2(r.line) && acc.line.add(r.line);
+        n$3(title) && acc.title.add(title);
+        n$3(r.color) && acc.color.add(r.color);
+        n$3(r.line) && acc.line.add(r.line);
         return acc;
       }, {
         color: /* @__PURE__ */ new Set(),
@@ -4843,7 +4898,10 @@ function computeDynamicView(model, view) {
 
 function relationExpressionToPredicates(expr) {
   switch (true) {
-    case isRelationWhere(expr): {
+    case ModelLayer.RelationExpr.isCustom(expr): {
+      return relationExpressionToPredicates(expr.customRelation.expr);
+    }
+    case ModelLayer.RelationExpr.isWhere(expr): {
       const predicate = relationExpressionToPredicates(expr.where.expr);
       const where = whereOperatorAsPredicate(expr.where.condition);
       return (e) => predicate(e) && where({
@@ -4853,22 +4911,22 @@ function relationExpressionToPredicates(expr) {
         ...e.kind && { kind: e.kind }
       });
     }
-    case isRelation(expr): {
+    case ModelLayer.RelationExpr.isDirect(expr): {
       const isSource = elementExprToPredicate(expr.source);
       const isTarget = elementExprToPredicate(expr.target);
       return (edge) => {
         return isSource(edge.source) && isTarget(edge.target) || !!expr.isBidirectional && isSource(edge.target) && isTarget(edge.source);
       };
     }
-    case isInOut(expr): {
-      const isInOut2 = elementExprToPredicate(expr.inout);
-      return (edge) => isInOut2(edge.source) || isInOut2(edge.target);
+    case ModelLayer.RelationExpr.isInOut(expr): {
+      const isInOut = elementExprToPredicate(expr.inout);
+      return (edge) => isInOut(edge.source) || isInOut(edge.target);
     }
-    case isIncoming$1(expr): {
+    case ModelLayer.RelationExpr.isIncoming(expr): {
       const isTarget = elementExprToPredicate(expr.incoming);
       return (edge) => isTarget(edge.target);
     }
-    case isOutgoing$1(expr): {
+    case ModelLayer.RelationExpr.isOutgoing(expr): {
       const isSource = elementExprToPredicate(expr.outgoing);
       return (edge) => isSource(edge.source);
     }
@@ -4878,16 +4936,20 @@ function relationExpressionToPredicates(expr) {
 }
 
 function applyCustomRelationProperties(_rules, nodes, _edges) {
-  const rules = _rules.flatMap(flattenGroupRules(isCustomRelationExpr));
+  const rules = _rules.flatMap(flattenGroupRules(ModelLayer.RelationExpr.isCustom));
   const edges = Array.from(_edges);
   if (rules.length === 0 || edges.length === 0) {
     return edges;
   }
   for (const {
-    customRelation: { relation, title, ...customprops }
+    customRelation: {
+      expr,
+      title,
+      ...customprops
+    }
   } of rules) {
     const props = d$1(customprops, n$4);
-    const satisfies = relationExpressionToPredicates(relation);
+    const satisfies = relationExpressionToPredicates(expr);
     edges.forEach((edge, i) => {
       const source = nodes.find((n) => n.id === edge.source);
       const target = nodes.find((n) => n.id === edge.target);
@@ -5027,7 +5089,7 @@ class StageInclude extends AbstractStageInclude {
     }
   }
   processConnections(connections) {
-    if (isRelationPredicateExpr(this.expression)) {
+    if (ModelLayer.isAnyRelationExpr(this.expression)) {
       return connections;
     }
     C(
@@ -5322,62 +5384,34 @@ class StageFinal {
   }
 }
 
-const ExpandedElementPredicate = {
-  include: ({ expr, model, stage, where }) => {
-    const parent = model.element(expr.expanded);
-    if (where(parent)) {
-      stage.addExplicit(parent);
-      stage.connectWithExisting(parent);
-    }
-    const children = [...parent.children()].filter(where);
-    const expanded = [];
-    for (const child of children) {
-      stage.addImplicit(child);
-      if (stage.connectWithExisting(child)) {
-        expanded.push(child);
-      }
-    }
-    stage.addConnections(findConnectionsWithin$1(expanded));
-    return stage;
-  },
-  exclude: ({ expr, model, stage, where }) => {
-    const parent = model.element(expr.expanded);
-    const elements = [
-      parent,
-      ...parent.children()
-    ].filter(where);
-    stage.exclude(elements);
-    return stage;
-  }
-};
-
 function resolveElements(model, expr) {
   switch (true) {
-    case isExpandedElementExpr(expr): {
-      const element = model.element(expr.expanded);
+    case ModelLayer.FqnExpr.isElementKindExpr(expr): {
+      return [...ifilter(model.elements(), (el) => {
+        return expr.isEqual === (el.kind === expr.elementKind);
+      })];
+    }
+    case ModelLayer.FqnExpr.isElementTagExpr(expr): {
+      return [...ifilter(model.elements(), (el) => {
+        return expr.isEqual === el.tags.includes(expr.elementTag);
+      })];
+    }
+    case expr.selector === "expanded": {
+      const element = model.element(ModelLayer.FqnRef.toFqn(expr.ref));
       return [
         element,
         ...element.children()
       ];
     }
-    case isElementRef(expr): {
-      const element = model.element(expr.element);
-      let children;
-      if (expr.isChildren) {
-        children = toArray(element.children());
-      } else if (expr.isDescendants) {
-        children = toArray(element.descendants());
-      }
+    case expr.selector === "children":
+    case expr.selector === "descendants": {
+      const element = model.element(ModelLayer.FqnRef.toFqn(expr.ref));
+      let children = expr.selector === "children" ? toArray(element.children()) : toArray(element.descendants());
       return children && children.length > 0 ? children : [element];
     }
-    case isElementKindExpr(expr):
-      return [...ifilter(model.elements(), (el) => {
-        return expr.isEqual === (el.kind === expr.elementKind);
-      })];
-    case isElementTagExpr(expr):
-      return [...ifilter(model.elements(), (el) => {
-        return expr.isEqual === el.tags.includes(expr.elementTag);
-      })];
+    case ModelLayer.FqnExpr.isModelRef(expr): {
+      return [model.element(ModelLayer.FqnRef.toFqn(expr.ref))];
+    }
     default:
       nonexhaustive(expr);
   }
@@ -5400,8 +5434,8 @@ function includeDescendantsFromMemory(elements, memory) {
 }
 function resolveAndIncludeFromMemory(nonWildcard, { memory, model }) {
   const resolved = resolveElements(model, nonWildcard);
-  if (isExpandedElementExpr(nonWildcard) || isElementRef(nonWildcard)) {
-    if (nonWildcard.isDescendants === true) {
+  if (ModelLayer.FqnExpr.isModelRef(nonWildcard)) {
+    if (nonWildcard.selector === "descendants") {
       return resolved;
     }
     return includeDescendantsFromMemory(resolved, memory);
@@ -5409,6 +5443,31 @@ function resolveAndIncludeFromMemory(nonWildcard, { memory, model }) {
   return resolved;
 }
 
+const ExpandedElementPredicate = {
+  include: ({ expr, model, stage, where }) => {
+    const parent = model.element(ModelLayer.FqnRef.toFqn(expr.ref));
+    if (where(parent)) {
+      stage.addExplicit(parent);
+      stage.connectWithExisting(parent);
+    }
+    const children = [...parent.children()].filter(where);
+    const expanded = [];
+    for (const child of children) {
+      stage.addImplicit(child);
+      if (stage.connectWithExisting(child)) {
+        expanded.push(child);
+      }
+    }
+    stage.addConnections(findConnectionsWithin$1(expanded));
+    return stage;
+  },
+  exclude: ({ expr, model, stage, filterWhere }) => {
+    const elements = filterWhere(resolveElements(model, expr));
+    stage.exclude(elements);
+    return stage;
+  }
+};
+
 const ElementKindOrTagPredicate = {
   include: ({ expr, model, stage, filterWhere }) => {
     const elements = filterWhere(resolveElements(model, expr));
@@ -5427,19 +5486,9 @@ const ElementKindOrTagPredicate = {
   }
 };
 
-function applyElementSelector(elem, expr) {
-  let children;
-  if (expr.isChildren) {
-    children = [...elem.children()];
-  } else if (expr.isDescendants) {
-    children = [...elem.descendants()];
-  }
-  return children && children.length > 0 ? children : [elem];
-}
 const ElementRefPredicate = {
-  include: ({ expr, model, stage, where }) => {
-    const element = model.element(expr.element);
-    const elements = applyElementSelector(element, expr).filter(where);
+  include: ({ expr, model, stage, filterWhere }) => {
+    const elements = filterWhere(resolveElements(model, expr));
     if (elements.length === 0) {
       return;
     }
@@ -5449,8 +5498,7 @@ const ElementRefPredicate = {
     return stage;
   },
   exclude: ({ expr, model, stage, filterWhere }) => {
-    const element = model.element(expr.element);
-    const elements = filterWhere(applyElementSelector(element, expr));
+    const elements = filterWhere(resolveElements(model, expr));
     stage.exclude(elements);
     return stage;
   }
@@ -5500,6 +5548,7 @@ function buildNodes(memory) {
   return buildComputedNodes([...memory.final].map(toNodeSource), memory.groups);
 }
 
+const isWildcard = ModelLayer.FqnExpr.isWildcard;
 const DirectRelationExprPredicate = {
   include: ({ expr: { source, target, isBidirectional = false }, memory, model, stage, where, filterWhere }) => {
     const sourceIsWildcard = isWildcard(source);
@@ -5750,8 +5799,8 @@ function resolveWildcard(nonWildcard, { memory, model }) {
   if (!i$9(sources, 1)) {
     return [[], []];
   }
-  if (isExpandedElementExpr(nonWildcard) || isElementRef(nonWildcard)) {
-    const parent = model.element(nonWildcard.element ?? nonWildcard.expanded);
+  if (ModelLayer.FqnExpr.isModelRef(nonWildcard)) {
+    const parent = model.element(ModelLayer.FqnRef.toFqn(nonWildcard.ref));
     const targets2 = toArray(parent.ascendingSiblings());
     return [
       includeDescendantsFromMemory(sources, memory),
@@ -5773,7 +5822,7 @@ const IncomingExprPredicate = {
   include: ({ expr, scope, model, memory, stage, filterWhere }) => {
     const target = expr.incoming;
     const connections = [];
-    if (isWildcard(target)) {
+    if (ModelLayer.FqnExpr.isWildcard(target)) {
       if (!scope) {
         return;
       }
@@ -5814,7 +5863,7 @@ const IncomingExprPredicate = {
   },
   exclude: ({ expr: { incoming }, model, scope, stage, where }) => {
     const excluded = [];
-    if (isWildcard(incoming)) {
+    if (ModelLayer.FqnExpr.isWildcard(incoming)) {
       if (!scope) {
         return;
       }
@@ -5831,34 +5880,38 @@ const IncomingExprPredicate = {
 };
 function incomingConnectionPredicate(model, expr) {
   switch (true) {
-    case isElementKindExpr(expr):
-    case isElementTagExpr(expr): {
+    case ModelLayer.FqnExpr.isElementKindExpr(expr):
+    case ModelLayer.FqnExpr.isElementTagExpr(expr): {
       const isElement = elementExprToPredicate(expr);
       return (connection) => isElement(connection.target);
     }
-    case (isElementRef(expr) && expr.isChildren): {
+    case (ModelLayer.FqnExpr.isModelRef(expr) && expr.selector === "children"): {
+      const fqn = ModelLayer.FqnRef.toFqn(expr.ref);
       return y$2(
-        [...model.children(expr.element)].map(
+        [...model.children(fqn)].map(
           (el) => Connection.isIncoming(el.id)
         )
       );
     }
-    case (isElementRef(expr) && expr.isDescendants): {
+    case (ModelLayer.FqnExpr.isModelRef(expr) && expr.selector === "descendants"): {
+      const fqn = ModelLayer.FqnRef.toFqn(expr.ref);
       return y$2([
-        Connection.isInside(expr.element),
-        ...[...model.children(expr.element)].map(
+        Connection.isInside(fqn),
+        ...[...model.children(fqn)].map(
           (el) => Connection.isIncoming(el.id)
         )
       ]);
     }
-    case isExpandedElementExpr(expr): {
+    case (ModelLayer.FqnExpr.isModelRef(expr) && expr.selector === "expanded"): {
+      const fqn = ModelLayer.FqnRef.toFqn(expr.ref);
       return y$2([
-        Connection.isIncoming(expr.expanded),
-        Connection.isInside(expr.expanded)
+        Connection.isIncoming(fqn),
+        Connection.isInside(fqn)
       ]);
     }
-    case isElementRef(expr): {
-      return Connection.isIncoming(expr.element);
+    case ModelLayer.FqnExpr.isModelRef(expr): {
+      const fqn = ModelLayer.FqnRef.toFqn(expr.ref);
+      return Connection.isIncoming(fqn);
     }
     default:
       nonexhaustive(expr);
@@ -5868,7 +5921,7 @@ function incomingConnectionPredicate(model, expr) {
 const InOutRelationPredicate = {
   include: ({ expr: { inout }, scope, model, memory, stage, filterWhere }) => {
     const connections = [];
-    if (isWildcard(inout)) {
+    if (ModelLayer.FqnExpr.isWildcard(inout)) {
       if (!scope) {
         return;
       }
@@ -5902,7 +5955,7 @@ const InOutRelationPredicate = {
   },
   exclude: ({ expr: { inout }, model, scope, stage, where }) => {
     const excluded = [];
-    if (isWildcard(inout)) {
+    if (ModelLayer.FqnExpr.isWildcard(inout)) {
       if (!scope) {
         return;
       }
@@ -5923,7 +5976,7 @@ const OutgoingExprPredicate = {
   include: ({ expr, scope, model, memory, stage, filterWhere }) => {
     const target = expr.outgoing;
     const connections = [];
-    if (isWildcard(target)) {
+    if (ModelLayer.FqnExpr.isWildcard(target)) {
       if (!scope) {
         return;
       }
@@ -5962,7 +6015,7 @@ const OutgoingExprPredicate = {
   },
   exclude: ({ expr: { outgoing }, model, scope, stage, where }) => {
     const excluded = [];
-    if (isWildcard(outgoing)) {
+    if (ModelLayer.FqnExpr.isWildcard(outgoing)) {
       if (!scope) {
         return;
       }
@@ -5981,34 +6034,38 @@ const OutgoingExprPredicate = {
 };
 function outgoingConnectionPredicate(model, expr) {
   switch (true) {
-    case isElementKindExpr(expr):
-    case isElementTagExpr(expr): {
+    case ModelLayer.FqnExpr.isElementKindExpr(expr):
+    case ModelLayer.FqnExpr.isElementTagExpr(expr): {
       const isElement = elementExprToPredicate(expr);
       return (connection) => isElement(connection.source);
     }
-    case (isElementRef(expr) && expr.isChildren): {
+    case (ModelLayer.FqnExpr.isModelRef(expr) && expr.selector === "children"): {
+      const fqn = ModelLayer.FqnRef.toFqn(expr.ref);
       return y$2(
-        [...model.children(expr.element)].map(
+        [...model.children(fqn)].map(
           (el) => Connection.isOutgoing(el.id)
         )
       );
     }
-    case (isElementRef(expr) && expr.isDescendants): {
+    case (ModelLayer.FqnExpr.isModelRef(expr) && expr.selector === "descendants"): {
+      const fqn = ModelLayer.FqnRef.toFqn(expr.ref);
       return y$2([
-        Connection.isInside(expr.element),
-        ...[...model.children(expr.element)].map(
+        Connection.isInside(fqn),
+        ...[...model.children(fqn)].map(
           (el) => Connection.isOutgoing(el.id)
         )
       ]);
     }
-    case isExpandedElementExpr(expr): {
+    case (ModelLayer.FqnExpr.isModelRef(expr) && expr.selector === "expanded"): {
+      const fqn = ModelLayer.FqnRef.toFqn(expr.ref);
       return y$2([
-        Connection.isOutgoing(expr.expanded),
-        Connection.isInside(expr.expanded)
+        Connection.isOutgoing(fqn),
+        Connection.isInside(fqn)
       ]);
     }
-    case isElementRef(expr): {
-      return Connection.isOutgoing(expr.element);
+    case ModelLayer.FqnExpr.isModelRef(expr): {
+      const fqn = ModelLayer.FqnRef.toFqn(expr.ref);
+      return Connection.isOutgoing(fqn);
     }
     default:
       nonexhaustive(expr);
@@ -6083,41 +6140,43 @@ const WildcardPredicate = {
 
 function processElementPredicate(expr, op, ctx) {
   switch (true) {
-    case isCustomElement(expr): {
+    case ModelLayer.FqnExpr.isCustom(expr): {
       if (op === "include") {
         return processElementPredicate(expr.custom.expr, op, ctx);
       }
       return ctx.stage;
     }
-    case isElementWhere(expr): {
+    case ModelLayer.FqnExpr.isWhere(expr): {
       const where = whereOperatorAsPredicate(expr.where.condition);
       const filterWhere = T(where);
       return processElementPredicate(expr.where.expr, op, { ...ctx, where, filterWhere });
     }
-    case isExpandedElementExpr(expr): {
+    case (ModelLayer.FqnExpr.isModelRef(expr) && expr.selector === "expanded"): {
       return ExpandedElementPredicate[op]({ ...ctx, expr }) ?? ctx.stage;
     }
-    case isElementRef(expr): {
-      return ElementRefPredicate[op]({ ...ctx, expr }) ?? ctx.stage;
-    }
-    case isWildcard(expr):
+    case ModelLayer.FqnExpr.isWildcard(expr): {
       return WildcardPredicate[op]({ ...ctx, expr }) ?? ctx.stage;
-    case isElementKindExpr(expr):
-    case isElementTagExpr(expr):
+    }
+    case ModelLayer.FqnExpr.isElementKindExpr(expr):
+    case ModelLayer.FqnExpr.isElementTagExpr(expr): {
       return ElementKindOrTagPredicate[op]({ ...ctx, expr }) ?? ctx.stage;
+    }
+    case ModelLayer.FqnExpr.isModelRef(expr): {
+      return ElementRefPredicate[op]({ ...ctx, expr }) ?? ctx.stage;
+    }
     default:
       nonexhaustive(expr);
   }
 }
 function processRelationtPredicate(expr, op, ctx) {
   switch (true) {
-    case isCustomRelationExpr(expr): {
+    case ModelLayer.RelationExpr.isCustom(expr): {
       if (op === "include") {
-        return processRelationtPredicate(expr.customRelation.relation, op, ctx);
+        return processRelationtPredicate(expr.customRelation.expr, op, ctx);
       }
       return ctx.stage;
     }
-    case isRelationWhere(expr): {
+    case ModelLayer.RelationExpr.isWhere(expr): {
       const where = whereOperatorAsPredicate(expr.where.condition);
       const filterRelations = (relations) => {
         return new Set(T([...relations], where));
@@ -6135,16 +6194,16 @@ function processRelationtPredicate(expr, op, ctx) {
         filterWhere
       });
     }
-    case isInOut(expr): {
+    case ModelLayer.RelationExpr.isInOut(expr): {
       return InOutRelationPredicate[op]({ ...ctx, expr }) ?? ctx.stage;
     }
-    case isRelation(expr): {
+    case ModelLayer.RelationExpr.isDirect(expr): {
       return DirectRelationExprPredicate[op]({ ...ctx, expr }) ?? ctx.stage;
     }
-    case isOutgoing$1(expr): {
+    case ModelLayer.RelationExpr.isOutgoing(expr): {
       return OutgoingExprPredicate[op]({ ...ctx, expr }) ?? ctx.stage;
     }
-    case isIncoming$1(expr): {
+    case ModelLayer.RelationExpr.isIncoming(expr): {
       return IncomingExprPredicate[op]({ ...ctx, expr }) ?? ctx.stage;
     }
     default:
@@ -6172,14 +6231,14 @@ function processPredicates(model, memory, rules) {
       for (const expr of exprs) {
         let stage = op === "include" ? memory.stageInclude(expr) : memory.stageExclude(expr);
         switch (true) {
-          case isElementPredicateExpr(expr):
+          case ModelLayer.isAnyFqnExpr(expr):
             stage = processElementPredicate(expr, op, {
               ...ctx,
               stage,
               memory
             }) ?? stage;
             break;
-          case isRelationPredicateExpr(expr):
+          case ModelLayer.isAnyRelationExpr(expr):
             stage = processRelationtPredicate(expr, op, {
               ...ctx,
               stage,
@@ -7146,6 +7205,11 @@ class LikeC4Model {
         this.#allTags.get(tag).add(el);
       }
     }
+    for (const [projectId, elements] of t$1($model.imports)) {
+      for (const element of sortParentsFirst(elements)) {
+        this.addImportedElement(projectId, element);
+      }
+    }
     for (const relation of r$3($model.relations)) {
       const el = this.addRelation(relation);
       for (const tag of el.tags) {
@@ -7410,7 +7474,7 @@ class LikeC4Model {
     if (this.#elements.has(element.id)) {
       throw new Error(`Element ${element.id} already exists`);
     }
-    const el = new ElementModel(this, Object.freeze(structuredClone(element)));
+    const el = new ElementModel(this, Object.freeze(element));
     this.#elements.set(el.id, el);
     const parentId = parentFqn(el.id);
     if (parentId) {
@@ -7422,13 +7486,39 @@ class LikeC4Model {
     }
     return el;
   }
+  addImportedElement(projectId, element) {
+    invariant(!isGlobalFqn(element.id), `Imported element already has global FQN`);
+    const id = GlobalFqn(projectId, element.id);
+    if (this.#elements.has(id)) {
+      throw new Error(`Element ${id} already exists`);
+    }
+    const el = new ElementModel(
+      this,
+      Object.freeze({
+        ...element,
+        id
+      })
+    );
+    this.#elements.set(el.id, el);
+    let parentId = parentFqn(el.id);
+    while (parentId) {
+      if (parentId.includes(".") && this.#elements.has(parentId)) {
+        this.#parents.set(el.id, this.element(parentId));
+        this.#children.get(parentId).add(el);
+        return el;
+      }
+      parentId = parentFqn(parentId);
+    }
+    this.#rootElements.add(el);
+    return el;
+  }
   addRelation(relation) {
     if (this.#relations.has(relation.id)) {
       throw new Error(`Relation ${relation.id} already exists`);
     }
     const rel = new RelationshipModel(
       this,
-      Object.freeze(structuredClone(relation))
+      Object.freeze(relation)
     );
     const { source, target } = rel;
     this.#relations.set(rel.id, rel);
@@ -7457,6 +7547,7 @@ class LikeC4Model {
 }
 ((LikeC4Model2) => {
   LikeC4Model2.EMPTY = LikeC4Model2.create({
+    projectId: "default",
     specification: {
       elements: {},
       relationships: {},
@@ -7474,7 +7565,8 @@ class LikeC4Model {
     },
     elements: {},
     relations: {},
-    views: {}
+    views: {},
+    imports: {}
   });
 })(LikeC4Model || (LikeC4Model = {}));