@likec4/core 1.27.2 → 1.28.0

package/src/compute-view/element-view/compute.ts

@@ -7,14 +7,12 @@ import type { RelationshipModel } from '../../model/RelationModel'
 import type { AnyAux } from '../../model/types'
 import type {
   ComputedElementView,
-  ElementPredicateExpression,
   ElementView,
   NodeId,
-  RelationPredicateExpression,
   ViewRule,
 } from '../../types'
 import { isViewRuleAutoLayout, isViewRuleGroup, isViewRulePredicate, whereOperatorAsPredicate } from '../../types'
-import * as Expr from '../../types/expression'
+import { ModelLayer } from '../../types/expression-v2-model'
 import { sortParentsFirst } from '../../utils'
 import { DefaultMap } from '../../utils/mnemonist'
 import { applyCustomElementProperties } from '../utils/applyCustomElementProperties'
@@ -41,52 +39,54 @@ import { buildNodes, NoFilter, NoWhere, toComputedEdges } from './utils'
 
 function processElementPredicate(
   // ...args:
-  //   | [expr: ElementPredicateExpression, op: 'include', IncludePredicateCtx<ElementPredicateExpression>]
-  //   | [expr: ElementPredicateExpression, op: 'exclude', ExcludePredicateCtx<ElementPredicateExpression>]
-  expr: ElementPredicateExpression,
+  //   | [expr: ModelLayer.AnyFqnExpr, op: 'include', IncludePredicateCtx<ModelLayer.AnyFqnExpr>]
+  //   | [expr: ModelLayer.AnyFqnExpr, op: 'exclude', ExcludePredicateCtx<ModelLayer.AnyFqnExpr>]
+  expr: ModelLayer.AnyFqnExpr,
   op: 'include' | 'exclude',
-  ctx: Omit<PredicateCtx<RelationPredicateExpression>, 'expr'>,
+  ctx: Omit<PredicateCtx<ModelLayer.AnyFqnExpr>, 'expr'>,
 ): Stage {
   switch (true) {
-    case Expr.isCustomElement(expr): {
+    case ModelLayer.FqnExpr.isCustom(expr): {
       if (op === 'include') {
         return processElementPredicate(expr.custom.expr, op, ctx)
       }
       return ctx.stage
     }
-    case Expr.isElementWhere(expr): {
+    case ModelLayer.FqnExpr.isWhere(expr): {
       const where = whereOperatorAsPredicate(expr.where.condition)
       const filterWhere = filter<Elem>(where)
       return processElementPredicate(expr.where.expr, op, { ...ctx, where, filterWhere } as any)
     }
-    case Expr.isExpandedElementExpr(expr): {
+    case ModelLayer.FqnExpr.isModelRef(expr) && expr.selector === 'expanded': {
       return ExpandedElementPredicate[op]({ ...ctx, expr } as any) ?? ctx.stage
     }
-    case Expr.isElementRef(expr): {
-      return ElementRefPredicate[op]({ ...ctx, expr } as any) ?? ctx.stage
-    }
-    case Expr.isWildcard(expr):
+    case ModelLayer.FqnExpr.isWildcard(expr): {
       return WildcardPredicate[op]({ ...ctx, expr } as any) ?? ctx.stage
-    case Expr.isElementKindExpr(expr):
-    case Expr.isElementTagExpr(expr):
+    }
+    case ModelLayer.FqnExpr.isElementKindExpr(expr):
+    case ModelLayer.FqnExpr.isElementTagExpr(expr): {
       return ElementKindOrTagPredicate[op]({ ...ctx, expr } as any) ?? ctx.stage
+    }
+    case ModelLayer.FqnExpr.isModelRef(expr): {
+      return ElementRefPredicate[op]({ ...ctx, expr } as any) ?? ctx.stage
+    }
     default:
       nonexhaustive(expr)
   }
 }
 function processRelationtPredicate(
-  expr: RelationPredicateExpression,
+  expr: ModelLayer.AnyRelationExpr,
   op: 'include' | 'exclude',
-  ctx: Omit<PredicateCtx<RelationPredicateExpression>, 'expr'>,
+  ctx: Omit<PredicateCtx<ModelLayer.AnyRelationExpr>, 'expr'>,
 ): Stage {
   switch (true) {
-    case Expr.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 Expr.isRelationWhere(expr): {
+    case ModelLayer.RelationExpr.isWhere(expr): {
       const where = whereOperatorAsPredicate(expr.where.condition)
       const filterRelations = (relations: ReadonlySet<RelationshipModel>) => {
         return new Set(filter([...relations], where))
@@ -104,16 +104,16 @@ function processRelationtPredicate(
         filterWhere,
       })
     }
-    case Expr.isInOut(expr): {
+    case ModelLayer.RelationExpr.isInOut(expr): {
       return InOutRelationPredicate[op]({ ...ctx, expr } as any) ?? ctx.stage
     }
-    case Expr.isRelation(expr): {
+    case ModelLayer.RelationExpr.isDirect(expr): {
       return DirectRelationExprPredicate[op]({ ...ctx, expr } as any) ?? ctx.stage
     }
-    case Expr.isOutgoing(expr): {
+    case ModelLayer.RelationExpr.isOutgoing(expr): {
       return OutgoingExprPredicate[op]({ ...ctx, expr } as any) ?? ctx.stage
     }
-    case Expr.isIncoming(expr): {
+    case ModelLayer.RelationExpr.isIncoming(expr): {
       return IncomingExprPredicate[op]({ ...ctx, expr } as any) ?? ctx.stage
     }
     default:
@@ -146,14 +146,14 @@ export function processPredicates<M extends AnyAux>(
       for (const expr of exprs) {
         let stage = op === 'include' ? memory.stageInclude(expr) : memory.stageExclude(expr)
         switch (true) {
-          case Expr.isElementPredicateExpr(expr):
+          case ModelLayer.isAnyFqnExpr(expr):
             stage = processElementPredicate(expr, op, {
               ...ctx,
               stage,
               memory,
             } as any) ?? stage
             break
-          case Expr.isRelationPredicateExpr(expr):
+          case ModelLayer.isAnyRelationExpr(expr):
             stage = processRelationtPredicate(expr, op, {
               ...ctx,
               stage,

package/src/compute-view/element-view/memory/NodeGroup.ts

@@ -1,4 +1,5 @@
-import { ElementKind, type NodeId, type ViewRuleGroup } from '../../../types'
+import { ElementKind } from '../../../types/element'
+import { type NodeId, type ViewRuleGroup } from '../../../types/view'
 import type { Elem } from '../_types'
 
 export class NodesGroup {
@@ -8,7 +9,7 @@ export class NodesGroup {
     public readonly id: NodeId,
     public readonly viewRule: ViewRuleGroup,
     public readonly parent: NodeId | null = null,
-    public readonly elements: ReadonlySet<Elem> = new Set<Elem>()
+    public readonly elements: ReadonlySet<Elem> = new Set<Elem>(),
   ) {
   }
 
@@ -21,7 +22,7 @@ export class NodesGroup {
       this.id,
       this.viewRule,
       this.parent,
-      elements
+      elements,
     )
   }
 

package/src/compute-view/element-view/memory/memory.ts

@@ -1,7 +1,8 @@
 import { nonNullable } from '../../../errors'
 import type { ConnectionModel } from '../../../model/connection'
 import type { ElementModel } from '../../../model/ElementModel'
-import type { Expression, NodeId, ViewRuleGroup } from '../../../types'
+import type { ModelLayer } from '../../../types/expression-v2-model'
+import type { NodeId, ViewRuleGroup } from '../../../types/view'
 import { Stack } from '../../../utils/mnemonist'
 import { type ComputeCtx, type CtxElement, type MutableState, type StageExpression, AbstractMemory } from '../../memory'
 import { NodesGroup } from './NodeGroup'
@@ -15,7 +16,7 @@ export interface Ctx extends
     Memory<Ctx>,
     StageInclude<Ctx>,
     StageExclude,
-    Expression
+    ModelLayer.Expression
   >
 {
   MutableState: {

package/src/compute-view/element-view/memory/stage-include.ts

@@ -1,6 +1,6 @@
 import { dropWhile, forEach, pipe, take, zip } from 'remeda'
-import { Expr } from '../../..'
 import { findConnection, findConnectionsBetween } from '../../../model/connection/model'
+import { ModelLayer } from '../../../types/expression-v2-model'
 import { difference, isAncestor, isIterable } from '../../../utils'
 import { toArray } from '../../../utils/iterable'
 import { type CtxConnection, type StageExpression, AbstractStageInclude } from '../../memory'
@@ -62,7 +62,7 @@ export class StageInclude<C extends Ctx = Ctx> extends AbstractStageInclude<C> {
   }
 
   protected override processConnections(connections: CtxConnection<Ctx>[]) {
-    if (Expr.isRelationPredicateExpr(this.expression)) {
+    if (ModelLayer.isAnyRelationExpr(this.expression)) {
       return connections
     }
 

package/src/compute-view/element-view/predicates/_utils.ts

@@ -1,7 +1,7 @@
 import { anyPass } from 'remeda'
 import { nonexhaustive } from '../../../errors'
-import type { LikeC4Model } from '../../../model'
-import * as Expr from '../../../types/expression'
+import type { LikeC4Model } from '../../../model/LikeC4Model'
+import { ModelLayer } from '../../../types/expression-v2-model'
 import { isDescendantOf } from '../../../utils/fqn'
 import { ifilter, toArray } from '../../../utils/iterable'
 import type { Elem, Memory, PredicateCtx } from '../_types'
@@ -10,33 +10,34 @@ import type { Elem, Memory, PredicateCtx } from '../_types'
  * Resolve elements from the model based on the given expression
  */
 
-export function resolveElements(model: LikeC4Model, expr: Exclude<Expr.ElementExpression, Expr.WildcardExpr>): Elem[] {
+export function resolveElements(model: LikeC4Model, expr: ModelLayer.FqnExpr.NonWildcard): Elem[] {
   switch (true) {
-    case Expr.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 Expr.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 Expr.isElementKindExpr(expr):
-      return [...ifilter(model.elements(), el => {
-        return expr.isEqual === (el.kind === expr.elementKind)
-      })]
-    case Expr.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)
   }
@@ -69,15 +70,15 @@ export function includeDescendantsFromMemory(elements: Elem[], memory: Memory):
  * Combination of `resolveElements` and `includeDescendantsFromMemory`
  */
 export function resolveAndIncludeFromMemory(
-  nonWildcard: Expr.NonWilcard,
+  nonWildcard: ModelLayer.FqnExpr.NonWildcard,
   { memory, model }: Pick<PredicateCtx, 'model' | 'memory'>,
 ): Elem[] {
   const resolved = resolveElements(model, nonWildcard)
   // We include from memory only if the expression is:
   // - expanded element
   // - element reference with or with children (but not descendants - they are already included)
-  if (Expr.isExpandedElementExpr(nonWildcard) || Expr.isElementRef(nonWildcard)) {
-    if (nonWildcard.isDescendants === true) {
+  if (ModelLayer.FqnExpr.isModelRef(nonWildcard)) {
+    if (nonWildcard.selector === 'descendants') {
       return resolved
     }
     return includeDescendantsFromMemory(resolved, memory)

package/src/compute-view/element-view/predicates/element-expand.ts

@@ -1,10 +1,11 @@
 import { findConnectionsWithin } from '../../../model/connection/model'
-import type * as Expr from '../../../types/expression'
+import { ModelLayer } from '../../../types/expression-v2-model'
 import type { Elem, PredicateExecutor } from '../_types'
+import { resolveElements } from './_utils'
 
-export const ExpandedElementPredicate: PredicateExecutor<Expr.ExpandedElementExpr> = {
+export const ExpandedElementPredicate: PredicateExecutor<ModelLayer.FqnExpr.ModelRef> = {
   include: ({ expr, model, stage, where }) => {
-    const parent = model.element(expr.expanded)
+    const parent = model.element(ModelLayer.FqnRef.toFqn(expr.ref))
     if (where(parent)) {
       stage.addExplicit(parent)
       stage.connectWithExisting(parent)
@@ -21,13 +22,9 @@ export const ExpandedElementPredicate: PredicateExecutor<Expr.ExpandedElementExp
     stage.addConnections(findConnectionsWithin(expanded))
     return stage
   },
-  exclude: ({ expr, model, stage, where }) => {
-    const parent = model.element(expr.expanded)
-    const elements = [
-      parent,
-      ...parent.children()
-    ].filter(where)
+  exclude: ({ expr, model, stage, filterWhere }) => {
+    const elements = filterWhere(resolveElements(model, expr))
     stage.exclude(elements)
     return stage
-  }
+  },
 }

package/src/compute-view/element-view/predicates/element-kind-tag.ts

@@ -1,9 +1,11 @@
 import { findConnectionsWithin } from '../../../model/connection/model'
-import * as Expr from '../../../types/expression'
+import type { ModelLayer } from '../../../types/expression-v2-model'
 import type { PredicateExecutor } from '../_types'
 import { resolveElements } from './_utils'
 
-export const ElementKindOrTagPredicate: PredicateExecutor<Expr.ElementKindExpr | Expr.ElementTagExpr> = {
+export const ElementKindOrTagPredicate: PredicateExecutor<
+  ModelLayer.FqnExpr.ElementKindExpr | ModelLayer.FqnExpr.ElementTagExpr
+> = {
   include: ({ expr, model, stage, filterWhere }) => {
     const elements = filterWhere(resolveElements(model, expr))
     if (elements.length === 0) {
@@ -22,5 +24,5 @@ export const ElementKindOrTagPredicate: PredicateExecutor<Expr.ElementKindExpr |
     stage.exclude(elements)
 
     return stage
-  }
+  },
 }

package/src/compute-view/element-view/predicates/element-ref.ts

@@ -1,22 +1,11 @@
 import { findConnectionsWithin } from '../../../model/connection/model'
-import type { ElementRefExpr } from '../../../types/expression'
-import * as Expr from '../../../types/expression'
+import { ModelLayer } from '../../../types/expression-v2-model'
 import type { Elem, PredicateExecutor } from '../_types'
+import { resolveElements } from './_utils'
 
-function applyElementSelector(elem: Elem, expr: Expr.ElementRefExpr) {
-  let children
-  if (expr.isChildren) {
-    children = [...elem.children()]
-  } else if (expr.isDescendants) {
-    children = [...elem.descendants()]
-  }
-  return children && children.length > 0 ? children : [elem]
-}
-
-export const ElementRefPredicate: PredicateExecutor<ElementRefExpr> = {
-  include: ({ expr, model, stage, where }) => {
-    const element = model.element(expr.element)
-    const elements = applyElementSelector(element, expr).filter(where)
+export const ElementRefPredicate: PredicateExecutor<ModelLayer.FqnExpr.ModelRef> = {
+  include: ({ expr, model, stage, filterWhere }) => {
+    const elements = filterWhere(resolveElements(model, expr))
     if (elements.length === 0) {
       return
     }
@@ -28,10 +17,9 @@ export const ElementRefPredicate: PredicateExecutor<ElementRefExpr> = {
     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
-  }
+  },
 }

package/src/compute-view/element-view/predicates/relation-direct.ts

@@ -3,7 +3,7 @@ import { invariant } from '../../../errors'
 import { ConnectionModel, findConnectionsBetween, findConnectionsWithin } from '../../../model/connection/model'
 import type { RelationshipModel } from '../../../model/RelationModel'
 import type { AnyAux } from '../../../model/types'
-import * as Expr from '../../../types/expression'
+import { ModelLayer } from '../../../types/expression-v2-model'
 import { isSameHierarchy } from '../../../utils'
 import { ifilter, iflat, iunique, toArray, toSet } from '../../../utils/iterable'
 import { intersection, union } from '../../../utils/set'
@@ -11,10 +11,12 @@ import type { Elem, PredicateCtx, PredicateExecutor } from '../_types'
 import { NoWhere } from '../utils'
 import { includeDescendantsFromMemory, resolveAndIncludeFromMemory, resolveElements } from './_utils'
 
-export const DirectRelationExprPredicate: PredicateExecutor<Expr.DirectRelationExpr> = {
+const isWildcard = ModelLayer.FqnExpr.isWildcard
+
+export const DirectRelationExprPredicate: PredicateExecutor<ModelLayer.RelationExpr.Direct> = {
   include: ({ expr: { source, target, isBidirectional = false }, memory, model, stage, where, filterWhere }) => {
-    const sourceIsWildcard = Expr.isWildcard(source)
-    const targetIsWildcard = Expr.isWildcard(target)
+    const sourceIsWildcard = isWildcard(source)
+    const targetIsWildcard = isWildcard(target)
 
     const connections = [] as ConnectionModel<AnyAux>[]
     switch (true) {
@@ -166,8 +168,8 @@ export const DirectRelationExprPredicate: PredicateExecutor<Expr.DirectRelationE
       }
 
       default: {
-        invariant(!Expr.isWildcard(source), 'Inference failed - source must be not a wildcard')
-        invariant(!Expr.isWildcard(target), 'Inference failed - target must be not a wildcard')
+        invariant(!isWildcard(source), 'Inference failed - source must be not a wildcard')
+        invariant(!isWildcard(target), 'Inference failed - target must be not a wildcard')
         const sources = resolveAndIncludeFromMemory(source, { memory, model })
         const targets = resolveAndIncludeFromMemory(target, { memory, model })
         const dir = isBidirectional ? 'both' : 'directed'
@@ -186,8 +188,8 @@ export const DirectRelationExprPredicate: PredicateExecutor<Expr.DirectRelationE
     return stage
   },
   exclude: ({ expr: { source, target, isBidirectional }, model, memory, stage, where }) => {
-    const sourceIsWildcard = Expr.isWildcard(source)
-    const targetIsWildcard = Expr.isWildcard(target)
+    const sourceIsWildcard = isWildcard(source)
+    const targetIsWildcard = isWildcard(target)
 
     let relations: Set<RelationshipModel<AnyAux>>
 
@@ -249,8 +251,8 @@ export const DirectRelationExprPredicate: PredicateExecutor<Expr.DirectRelationE
       }
 
       default: {
-        invariant(!Expr.isWildcard(source), 'Inferrence failed - source must be not a wildcard')
-        invariant(!Expr.isWildcard(target), 'Inferrence failed - target must be not a wildcard')
+        invariant(!isWildcard(source), 'Inferrence failed - source must be not a wildcard')
+        invariant(!isWildcard(target), 'Inferrence failed - target must be not a wildcard')
         const sources = resolveElements(model, source)
         const targets = resolveElements(model, target)
 
@@ -281,7 +283,7 @@ export const DirectRelationExprPredicate: PredicateExecutor<Expr.DirectRelationE
  * Resolve elements for both source and target, when one of them is a wildcard
  */
 function resolveWildcard(
-  nonWildcard: Expr.NonWilcard,
+  nonWildcard: ModelLayer.FqnExpr.NonWildcard,
   { memory, model }: Pick<PredicateCtx, 'model' | 'memory'>,
 ): [elements: Elem[], wildcard: Elem[]] {
   let sources = resolveElements(model, nonWildcard)
@@ -289,8 +291,8 @@ function resolveWildcard(
     return [[], []]
   }
 
-  if (Expr.isExpandedElementExpr(nonWildcard) || Expr.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 targets = toArray(parent.ascendingSiblings())
     return [
       includeDescendantsFromMemory(sources, memory),

package/src/compute-view/element-view/predicates/relation-in-out.ts

@@ -2,16 +2,15 @@ import { unique } from 'remeda'
 import { type ConnectionModel, findConnectionsBetween } from '../../../model/connection/model'
 import type { RelationshipModel } from '../../../model/RelationModel'
 import type { AnyAux } from '../../../model/types'
-import * as Expr from '../../../types/expression'
-import { toArray } from '../../../utils/iterable'
-import { toSet } from '../../../utils/iterable/to'
+import { ModelLayer } from '../../../types/expression-v2-model'
+import { toArray, toSet } from '../../../utils/iterable/to'
 import type { PredicateExecutor } from '../_types'
 import { resolveAndIncludeFromMemory, resolveElements } from './_utils'
 
-export const InOutRelationPredicate: PredicateExecutor<Expr.InOutExpr> = {
+export const InOutRelationPredicate: PredicateExecutor<ModelLayer.RelationExpr.InOut> = {
   include: ({ expr: { inout }, scope, model, memory, stage, filterWhere }) => {
     const connections = [] as ConnectionModel<AnyAux>[]
-    if (Expr.isWildcard(inout)) {
+    if (ModelLayer.FqnExpr.isWildcard(inout)) {
       if (!scope) {
         return
       }
@@ -47,7 +46,7 @@ export const InOutRelationPredicate: PredicateExecutor<Expr.InOutExpr> = {
   },
   exclude: ({ expr: { inout }, model, scope, stage, where }) => {
     const excluded = [] as RelationshipModel[]
-    if (Expr.isWildcard(inout)) {
+    if (ModelLayer.FqnExpr.isWildcard(inout)) {
       if (!scope) {
         return
       }

package/src/compute-view/element-view/predicates/relation-in.ts

@@ -2,23 +2,23 @@ import { anyPass, unique } from 'remeda'
 import { nonexhaustive } from '../../../errors'
 import type { LikeC4Model } from '../../../model'
 import {
-  Connection,
   type ConnectionModel,
+  Connection,
   findConnection,
-  findConnectionsBetween
+  findConnectionsBetween,
 } from '../../../model/connection/model'
 import type { RelationshipModel } from '../../../model/RelationModel'
 import type { AnyAux } from '../../../model/types'
-import * as Expr from '../../../types/expression'
+import { ModelLayer } from '../../../types/expression-v2-model'
 import { elementExprToPredicate } from '../../utils/elementExpressionToPredicate'
 import type { ConnectionWhere, PredicateExecutor } from '../_types'
 import { resolveAndIncludeFromMemory, resolveElements } from './_utils'
 
-export const IncomingExprPredicate: PredicateExecutor<Expr.IncomingExpr> = {
+export const IncomingExprPredicate: PredicateExecutor<ModelLayer.RelationExpr.Incoming> = {
   include: ({ expr, scope, model, memory, stage, filterWhere }) => {
     const target = expr.incoming
     const connections = [] as ConnectionModel<AnyAux>[]
-    if (Expr.isWildcard(target)) {
+    if (ModelLayer.FqnExpr.isWildcard(target)) {
       if (!scope) {
         return
       }
@@ -27,8 +27,8 @@ export const IncomingExprPredicate: PredicateExecutor<Expr.IncomingExpr> = {
           ...findConnection(
             sibling,
             scope,
-            'directed'
-          )
+            'directed',
+          ),
         )
       }
     } else {
@@ -37,8 +37,8 @@ export const IncomingExprPredicate: PredicateExecutor<Expr.IncomingExpr> = {
       if (visibleElements.length === 0) {
         visibleElements.push(
           ...unique(
-            targets.flatMap(el => [...el.ascendingSiblings()])
-          )
+            targets.flatMap(el => [...el.ascendingSiblings()]),
+          ),
         )
       }
       const ensureIncoming = incomingConnectionPredicate(model, target)
@@ -47,21 +47,21 @@ export const IncomingExprPredicate: PredicateExecutor<Expr.IncomingExpr> = {
           ...findConnectionsBetween(
             visible,
             targets,
-            'directed'
-          ).filter(ensureIncoming)
+            'directed',
+          ).filter(ensureIncoming),
         )
       }
     }
 
     stage.addConnections(
-      filterWhere(connections)
+      filterWhere(connections),
     )
 
     return stage
   },
   exclude: ({ expr: { incoming }, model, scope, stage, where }) => {
     const excluded = [] as RelationshipModel[]
-    if (Expr.isWildcard(incoming)) {
+    if (ModelLayer.FqnExpr.isWildcard(incoming)) {
       if (!scope) {
         return
       }
@@ -69,48 +69,52 @@ export const IncomingExprPredicate: PredicateExecutor<Expr.IncomingExpr> = {
     } else {
       const elements = resolveElements(model, incoming)
       excluded.push(
-        ...elements.flatMap(e => [...e.allIncoming])
+        ...elements.flatMap(e => [...e.allIncoming]),
       )
     }
     stage.excludeRelations(new Set(excluded.filter(where)))
 
     return stage
-  }
+  },
 }
 
 export function incomingConnectionPredicate(
   model: LikeC4Model,
-  expr: Exclude<Expr.ElementExpression, Expr.WildcardExpr>
+  expr: ModelLayer.FqnExpr.NonWildcard,
 ): ConnectionWhere {
   switch (true) {
-    case Expr.isElementKindExpr(expr):
-    case Expr.isElementTagExpr(expr): {
+    case ModelLayer.FqnExpr.isElementKindExpr(expr):
+    case ModelLayer.FqnExpr.isElementTagExpr(expr): {
       const isElement = elementExprToPredicate(expr)
       return (connection) => isElement(connection.target)
     }
-    case Expr.isElementRef(expr) && expr.isChildren: {
+    case ModelLayer.FqnExpr.isModelRef(expr) && expr.selector === 'children': {
+      const fqn = ModelLayer.FqnRef.toFqn(expr.ref)
       return anyPass(
-        [...model.children(expr.element)].map(
-          el => Connection.isIncoming(el.id)
-        )
+        [...model.children(fqn)].map(
+          el => Connection.isIncoming(el.id),
+        ),
       )
     }
-    case Expr.isElementRef(expr) && expr.isDescendants: {
+    case ModelLayer.FqnExpr.isModelRef(expr) && expr.selector === 'descendants': {
+      const fqn = ModelLayer.FqnRef.toFqn(expr.ref)
       return anyPass([
-        Connection.isInside(expr.element),
-        ...[...model.children(expr.element)].map(
-          el => Connection.isIncoming(el.id)
-        )
+        Connection.isInside(fqn),
+        ...[...model.children(fqn)].map(
+          el => Connection.isIncoming(el.id),
+        ),
       ])
     }
-    case Expr.isExpandedElementExpr(expr): {
+    case ModelLayer.FqnExpr.isModelRef(expr) && expr.selector === 'expanded': {
+      const fqn = ModelLayer.FqnRef.toFqn(expr.ref)
       return anyPass([
-        Connection.isIncoming(expr.expanded),
-        Connection.isInside(expr.expanded)
+        Connection.isIncoming(fqn),
+        Connection.isInside(fqn),
       ])
     }
-    case Expr.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)