@likec4/core 1.27.3 → 1.28.1

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

@@ -4,28 +4,19 @@ import {
   type BorderStyle,
   type Color,
   type ComputedView,
-  type CustomElementExpr as C4CustomElementExpr,
-  type CustomRelationExpr as C4CustomRelationExpr,
   type Element,
-  type ElementExpression as C4ElementExpression,
   type ElementKind,
   type ElementShape,
-  type ElementWhereExpr,
-  type Expression as C4Expression,
   type Fqn,
   type GlobalPredicateId,
   type GlobalStyleID,
   type IconUrl,
-  type IncomingExpr as C4IncomingExpr,
-  type InOutExpr as C4InOutExpr,
   type KindEqual,
   type ModelRelation,
   type NonEmptyArray,
-  type OutgoingExpr as C4OutgoingExpr,
   type RelationId,
   type RelationshipArrowType,
   type RelationshipLineType,
-  type RelationWhereExpr,
   type Tag,
   type TagEqual,
   type ViewId,
@@ -36,12 +27,8 @@ import {
   type ViewRulePredicate,
   type ViewRuleStyle,
   type WhereOperator,
-  isElementRef,
-  isElementWhere,
-  isRelationExpression,
-  isRelationWhere,
+  ModelLayer,
 } from '../../../types'
-import { type DirectRelationExpr as C4RelationExpr } from '../../../types/expression'
 import type { Participant } from '../../../types/operators'
 import { withReadableEdges } from '../../utils/with-readable-edges'
 import { computeElementView } from '../compute'
@@ -365,6 +352,7 @@ const fakeParsedModel = {
     relations: {},
   },
   views: {},
+  imports: {},
   globals: {
     predicates: {
       'remove_tag_old': [
@@ -441,19 +429,8 @@ export type Expression =
 
 export function $custom(
   expr: ElementRefExpr,
-  props: {
-    title?: string
-    description?: string
-    technology?: string
-    shape?: ElementShape
-    color?: Color
-    border?: BorderStyle
-    icon?: string
-    opacity?: number
-    navigateTo?: string
-    multiple?: boolean
-  },
-): C4CustomElementExpr {
+  props: Omit<ModelLayer.FqnExpr.Custom['custom'], 'expr'>,
+): ModelLayer.FqnExpr.Custom {
   return {
     custom: {
       expr: $expr(expr) as any,
@@ -463,21 +440,33 @@ export function $custom(
 }
 
 export function $customRelation(
-  relation: RelationExpr,
-  props: Omit<C4CustomRelationExpr['customRelation'], 'relation'>,
-): C4CustomRelationExpr {
+  relation: ModelLayer.RelationExprOrWhere,
+  props: Omit<ModelLayer.RelationExpr.Custom['customRelation'], 'expr'>,
+): ModelLayer.RelationExpr.Custom {
   return {
     customRelation: {
-      relation: $expr(relation) as any,
+      expr: $expr(relation) as any,
       ...props,
     },
   }
 }
 
 export function $where(
-  expr: Expression | C4Expression,
+  expr: Expression,
   operator: WhereOperator<TestTag, string>,
-): ElementWhereExpr | RelationWhereExpr {
+): ModelLayer.Expression.Where
+export function $where(
+  expr: ModelLayer.RelationExpr,
+  operator: WhereOperator<TestTag, string>,
+): ModelLayer.RelationExpr.Where
+export function $where(
+  expr: ModelLayer.FqnExpr,
+  operator: WhereOperator<TestTag, string>,
+): ModelLayer.FqnExpr.Where
+export function $where(
+  expr: Expression | ModelLayer.Expression,
+  operator: WhereOperator<TestTag, string>,
+): ModelLayer.Expression {
   return {
     where: {
       expr: $expr(expr) as any,
@@ -497,38 +486,38 @@ export function $participant(
 }
 
 export function $inout(
-  expr: InOutExpr | C4ElementExpression,
-): C4InOutExpr {
+  expr: InOutExpr | ModelLayer.FqnExpr,
+): ModelLayer.RelationExpr.InOut {
   const innerExpression = !isString(expr)
-    ? expr as C4Expression
-    : $expr(expr.replace(/->/g, '').trim() as ElementRefExpr) as any
+    ? expr as ModelLayer.FqnExpr
+    : $expr(expr.replace(/->/g, '').trim() as any)
 
   return { inout: innerExpression }
 }
 
 export function $incoming(
-  expr: IncomingExpr | C4ElementExpression,
-): C4IncomingExpr {
+  expr: IncomingExpr | ModelLayer.FqnExpr,
+): ModelLayer.RelationExpr.Incoming {
   const innerExpression = !isString(expr)
-    ? expr as C4Expression
-    : $expr(expr.replace('-> ', '') as ElementRefExpr) as any
+    ? expr as ModelLayer.FqnExpr
+    : $expr(expr.replace('-> ', '') as any)
 
   return { incoming: innerExpression }
 }
 
 export function $outgoing(
-  expr: OutgoingExpr | C4ElementExpression,
-): C4OutgoingExpr {
+  expr: OutgoingExpr | ModelLayer.FqnExpr,
+): ModelLayer.RelationExpr.Outgoing {
   const innerExpression = !isString(expr)
-    ? expr as C4Expression
-    : $expr(expr.replace(' ->', '') as ElementRefExpr) as any
+    ? expr as ModelLayer.FqnExpr
+    : $expr(expr.replace(' ->', '') as any)
 
   return { outgoing: innerExpression }
 }
 
 export function $relation(
   expr: RelationExpr,
-): C4RelationExpr {
+): ModelLayer.RelationExpr {
   const [source, target] = expr.split(/ -> | <-> /)
   const isBidirectional = expr.includes(' <-> ')
 
@@ -539,9 +528,9 @@ export function $relation(
   }
 }
 
-export function $expr(expr: Expression | C4Expression): C4Expression {
+export function $expr(expr: Expression | ModelLayer.Expression): ModelLayer.Expression {
   if (!isString(expr)) {
-    return expr as C4Expression
+    return expr as ModelLayer.Expression
   }
   if (expr === '*') {
     return { wildcard: true }
@@ -557,23 +546,32 @@ export function $expr(expr: Expression | C4Expression): C4Expression {
   }
   if (expr.endsWith('._')) {
     return {
-      expanded: expr.replace('._', '') as Fqn,
+      ref: {
+        model: expr.replace('._', '') as Fqn,
+      },
+      selector: 'expanded',
     }
   }
   if (expr.endsWith('.*')) {
     return {
-      element: expr.replace('.*', '') as Fqn,
-      isChildren: true,
+      ref: {
+        model: expr.replace('.*', '') as Fqn,
+      },
+      selector: 'children',
     }
   }
   if (expr.endsWith('.**')) {
     return {
-      element: expr.replace('.**', '') as Fqn,
-      isDescendants: true,
+      ref: {
+        model: expr.replace('.**', '') as Fqn,
+      },
+      selector: 'descendants',
     }
   }
   return {
-    element: expr as Fqn,
+    ref: {
+      model: expr as Fqn,
+    },
   }
 }
 
@@ -590,27 +588,33 @@ type CustomProps = {
     opacity?: number
     navigateTo?: string
     multiple?: boolean
-  } & Omit<C4CustomRelationExpr['customRelation'], 'relation' | 'navigateTo'>
+  } & Omit<ModelLayer.RelationExpr.Custom['customRelation'], 'expr' | 'navigateTo'>
 }
-export function $include(expr: Expression | C4Expression, props?: CustomProps): ViewRulePredicate {
-  let _expr = props?.where ? $where(expr, props.where) : $expr(expr)
+export function $include(
+  expr: Expression | ModelLayer.Expression,
+  props?: CustomProps,
+): ViewRulePredicate {
+  let _expr = props?.where ? $where(expr as any, props.where) : $expr(expr)
   _expr = props?.with ? $with(_expr, props.with) : _expr
   return {
     include: [_expr],
   }
 }
-export function $with(expr: C4Expression, props?: CustomProps['with']): C4CustomRelationExpr | C4CustomElementExpr {
-  if (isRelationExpression(expr) || isRelationWhere(expr)) {
+export function $with(
+  expr: ModelLayer.Expression,
+  props?: CustomProps['with'],
+): ModelLayer.RelationExpr.Custom | ModelLayer.FqnExpr.Custom {
+  if (ModelLayer.RelationExpr.is(expr) || ModelLayer.RelationExpr.isWhere(expr)) {
     return {
       customRelation: {
-        relation: expr,
+        expr,
         ...props as any,
       },
     }
-  } else if (isElementRef(expr) || isElementWhere(expr)) {
+  } else if (ModelLayer.FqnExpr.is(expr) || ModelLayer.FqnExpr.isWhere(expr)) {
     return {
       custom: {
-        expr: expr,
+        expr,
         ...props as any,
       },
     }
@@ -618,8 +622,11 @@ export function $with(expr: C4Expression, props?: CustomProps['with']): C4Custom
 
   throw 'Unsupported type of internal expression'
 }
-export function $exclude(expr: Expression | C4Expression, where?: WhereOperator<TestTag, string>): ViewRulePredicate {
-  let _expr = where ? $where(expr, where) : $expr(expr)
+export function $exclude(
+  expr: Expression | ModelLayer.Expression,
+  where?: WhereOperator<TestTag, string>,
+): ViewRulePredicate {
+  let _expr = where ? $where(expr as any, where) : $expr(expr)
   return {
     exclude: [_expr],
   }
@@ -633,7 +640,7 @@ export function $group(groupRules: ViewRuleGroup['groupRules']): ViewRuleGroup {
 
 export function $style(element: ElementRefExpr, style: ViewRuleStyle['style']): ViewRuleStyle {
   return {
-    targets: [$expr(element) as C4ElementExpression],
+    targets: [$expr(element) as ModelLayer.FqnExpr],
     style: Object.assign({}, style),
   }
 }

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

@@ -2,7 +2,7 @@ import { type LikeC4Model } from '../../model'
 import type { ConnectionModel } from '../../model/connection/model'
 import type { RelationshipModel } from '../../model/RelationModel'
 import type { AnyAux } from '../../model/types'
-import type { ElementExpression, Expression, RelationExpression } from '../../types/expression'
+import type { ModelLayer } from '../../types/expression-v2-model'
 
 import type { Ctx, Memory, Stage, StageExclude, StageInclude } from './memory'
 
@@ -21,28 +21,32 @@ export { Memory } from './memory'
 
 export type Connections = ReadonlyArray<ConnectionModel<AnyAux>>
 
-export interface PredicateCtx<Expr extends Expression = Expression> {
+export interface PredicateCtx<Expr extends ModelLayer.Expression = ModelLayer.Expression> {
   expr: Expr
   stage: Stage
   // View scope
   scope: Elem | null
   model: LikeC4Model<AnyAux>
   memory: Memory
-  where: Expr extends RelationExpression ? RelationshipWhere
-    : Expr extends ElementExpression ? ElementWhere
+  where: Expr extends ModelLayer.RelationExpr ? RelationshipWhere
+    : Expr extends ModelLayer.FqnExpr ? ElementWhere
     : never
-  filterWhere: Expr extends RelationExpression ? ConnectionWhereFilter
-    : Expr extends ElementExpression ? ElementWhereFilter
+  filterWhere: Expr extends ModelLayer.RelationExpr ? ConnectionWhereFilter
+    : Expr extends ModelLayer.FqnExpr ? ElementWhereFilter
     : never
 }
-export interface IncludePredicateCtx<Expr extends Expression = Expression> extends PredicateCtx<Expr> {
+export interface IncludePredicateCtx<Expr extends ModelLayer.Expression = ModelLayer.Expression>
+  extends PredicateCtx<Expr>
+{
   stage: StageInclude
 }
-export interface ExcludePredicateCtx<Expr extends Expression = Expression> extends PredicateCtx<Expr> {
+export interface ExcludePredicateCtx<Expr extends ModelLayer.Expression = ModelLayer.Expression>
+  extends PredicateCtx<Expr>
+{
   stage: StageExclude
 }
 
-export interface PredicateExecutor<Expr extends Expression> {
+export interface PredicateExecutor<Expr extends ModelLayer.Expression = ModelLayer.Expression> {
   include(ctx: IncludePredicateCtx<Expr>): StageInclude | undefined
   exclude(ctx: ExcludePredicateCtx<Expr>): StageExclude | undefined
 }

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
-  }
+  },
 }