@likec4/core 1.27.3 → 1.28.1

package/dist/types/index.d.mts

@@ -1,7 +1,7 @@
-import { X as XYPoint, N as NonEmptyArray, P as Point, l as BorderStyle, p as ElementShape, Q as ThemeColor, F as Fqn } from '../shared/core.30yYKXcZ.mjs';
-export { A as AsFqn, B as BorderStyles, x as Color, y as ColorLiteral, C as CustomColor, D as DefaultElementShape, f as DefaultPaddingSize, g as DefaultShapeSize, h as DefaultTextSize, i as DefaultThemeColor, m as Element, j as ElementKind, n as ElementKindSpecification, o as ElementKindSpecificationStyle, k as ElementShapes, q as ElementStyle, G as ElementThemeColorValues, z as ElementThemeColors, E as ExclusiveUnion, H as HexColorLiteral, I as IconUrl, a as IteratorLike, K as KeysOf, L as LikeC4Theme, r as Link, c as NTuple, b as NonEmptyReadonlyArray, d as Predicate, e as ProjectId, J as RelationshipThemeColorValues, R as RelationshipThemeColors, S as ShapeSize, M as SpacingSize, s as Tag, t as TagSpec, O as TextSize, T as ThemeColorValues, w as ThemeColors, u as TypedElement, v as isThemeColor } from '../shared/core.30yYKXcZ.mjs';
-import { bo as ViewId, a_ as BBox, bp as ViewManualLayout, aX as AutoLayoutDirection } from '../shared/core.CFDwncxs.mjs';
-export { aw as AbstractRelation, ah as AllNever, ai as AndOperator, a5 as AnyParsedLikeC4ModelData, aY as BasicElementView, aZ as BasicView, a$ as ComputedDeploymentView, b0 as ComputedDynamicView, b1 as ComputedEdge, b2 as ComputedElementView, C as ComputedLikeC4ModelData, aD as ComputedNode, a as ComputedView, b3 as CustomColorDefinitions, A as CustomElementExpr, B as CustomRelationExpr, at as DefaultArrowType, au as DefaultLineStyle, av as DefaultRelationshipColor, b as DeployedInstance, D as DeploymentElement, c as DeploymentElementStyle, d as DeploymentNode, f as DeploymentNodeKind, g as DeploymentNodeKindSpecification, h as DeploymentRef, i as DeploymentRelation, b4 as DeploymentView, b5 as DeploymentViewRule, b6 as DeploymentViewRulePredicate, b7 as DeploymentViewRuleStyle, b8 as DiagramEdge, aE as DiagramNode, b9 as DiagramView, E as DirectRelationExpr, ba as DynamicView, bb as DynamicViewIncludeRule, bc as DynamicViewParallelSteps, bd as DynamicViewRule, be as DynamicViewStep, bf as DynamicViewStepOrParallel, bg as EdgeId, F as ElementExpression, G as ElementKindExpr, bA as ElementNotation, H as ElementPredicateExpression, I as ElementRefExpr, J as ElementTagExpr, bh as ElementView, K as ElementWhereExpr, aj as EqualOperator, M as ExpandedElementExpr, N as Expression, X as ExpressionV2, bi as ExtendsElementView, ak as Filterable, Y as FqnExpr, Z as FqnRef, a6 as GenericLikeC4ModelData, $ as GlobalDynamicPredicates, a0 as GlobalPredicateId, a1 as GlobalPredicates, a2 as GlobalStyleID, a3 as GlobalStyles, Q as InOutExpr, O as IncomingExpr, al as KindEqual, a7 as LayoutedLikeC4ModelData, a8 as LikeC4ModelDump, L as LikeC4View, a4 as ModelGlobals, ax as ModelRelation, bj as NodeId, R as NonWilcard, am as NotOperator, an as OperatorPredicate, ao as OrOperator, S as OutgoingExpr, a9 as ParsedLikeC4ModelData, ap as Participant, aq as ParticipantOperator, P as PredicateSelector, _ as RelationExpr, T as RelationExpression, ay as RelationId, U as RelationPredicateExpression, V as RelationWhereExpr, az as RelationshipArrowType, aA as RelationshipKind, aB as RelationshipKindSpecification, aC as RelationshipLineType, bk as ScopedElementView, bl as StepEdgeId, bm as StepEdgeIdLiteral, ar as TagEqual, bn as ViewAutoLayout, bq as ViewRule, br as ViewRuleAutoLayout, bs as ViewRuleGlobalPredicateRef, bt as ViewRuleGlobalStyle, bu as ViewRuleGroup, bv as ViewRulePredicate, bw as ViewRuleStyle, bx as ViewRuleStyleOrGlobalRef, by as ViewWithHash, bz as ViewWithNotation, as as WhereOperator, W as WildcardExpr, aF as extractStep, aG as getBBoxCenter, aH as getParallelStepsPrefix, aa as isAndOperator, aI as isAutoLayoutDirection, j as isCustomElement, k as isCustomRelationExpr, aJ as isDeploymentView, aK as isDynamicView, aL as isDynamicViewParallelSteps, l as isElement, m as isElementKindExpr, n as isElementPredicateExpr, o as isElementRef, p as isElementTagExpr, aM as isElementView, q as isElementWhere, r as isExpandedElementExpr, aN as isExtendsElementView, t as isInOut, s as isIncoming, ab as isKindEqual, ac as isNotOperator, ad as isOrOperator, u as isOutgoing, ae as isParticipantOperator, v as isRelation, w as isRelationExpression, x as isRelationPredicateExpr, y as isRelationWhere, aO as isScopedElementView, aP as isStepEdgeId, af as isTagEqual, aQ as isViewRuleAutoLayout, aR as isViewRuleGlobalPredicateRef, aS as isViewRuleGlobalStyle, aT as isViewRuleGroup, aU as isViewRulePredicate, aV as isViewRuleStyle, z as isWildcard, aW as stepEdgeId, ag as whereOperatorAsPredicate } from '../shared/core.CFDwncxs.mjs';
+import { X as XYPoint, N as NonEmptyArray, P as Point, F as Fqn } from '../shared/core.SjLhMA7a.mjs';
+export { A as AsFqn, C as CustomColor, E as ExclusiveUnion, G as GlobalFqn, d as IconUrl, I as IteratorLike, K as KeysOf, b as NTuple, a as NonEmptyReadonlyArray, c as Predicate, e as ProjectId, T as Tag, i as isGlobalFqn, s as splitGlobalFqn } from '../shared/core.SjLhMA7a.mjs';
+import { bk as ViewId, aW as BBox, p as BorderStyle, t as ElementShape, ay as ThemeColor, bl as ViewManualLayout, aT as AutoLayoutDirection } from '../shared/core.DJvmfnEi.mjs';
+export { ag as AbstractRelation, a1 as AllNever, a2 as AndOperator, O as AnyParsedLikeC4ModelData, aU as BasicElementView, aV as BasicView, B as BorderStyles, ap as Color, aq as ColorLiteral, aX as ComputedDeploymentView, aY as ComputedDynamicView, aZ as ComputedEdge, a_ as ComputedElementView, C as ComputedLikeC4ModelData, az as ComputedNode, a as ComputedView, a$ as CustomColorDefinitions, ad as DefaultArrowType, j as DefaultElementShape, ae as DefaultLineStyle, k as DefaultPaddingSize, af as DefaultRelationshipColor, l as DefaultShapeSize, m as DefaultTextSize, n as DefaultThemeColor, c as DeployedInstance, D as DeploymentElement, d as DeploymentElementStyle, e as DeploymentNode, f as DeploymentNodeKind, g as DeploymentNodeKindSpecification, h as DeploymentRef, i as DeploymentRelation, b0 as DeploymentView, b1 as DeploymentViewRule, b2 as DeploymentViewRulePredicate, b3 as DeploymentViewRuleStyle, b4 as DiagramEdge, aA as DiagramNode, b5 as DiagramView, b6 as DynamicView, b7 as DynamicViewIncludeRule, b8 as DynamicViewParallelSteps, b9 as DynamicViewRule, ba as DynamicViewStep, bb as DynamicViewStepOrParallel, bc as EdgeId, q as Element, E as ElementKind, r as ElementKindSpecification, s as ElementKindSpecificationStyle, bw as ElementNotation, o as ElementShapes, u as ElementStyle, as as ElementThemeColorValues, ar as ElementThemeColors, bd as ElementView, a3 as EqualOperator, y as ExpressionV2, be as ExtendsElementView, a4 as Filterable, F as FqnExpr, z as FqnRef, Q as GenericLikeC4ModelData, G as GlobalDynamicPredicates, A as GlobalPredicateId, I as GlobalPredicates, J as GlobalStyleID, K as GlobalStyles, H as HexColorLiteral, a5 as KindEqual, S as LayoutedLikeC4ModelData, U as LikeC4ModelDump, b as LikeC4Theme, L as LikeC4View, v as Link, N as ModelGlobals, M as ModelLayer, ah as ModelRelation, bf as NodeId, a6 as NotOperator, a7 as OperatorPredicate, a8 as OrOperator, V as ParsedLikeC4ModelData, a9 as Participant, aa as ParticipantOperator, P as PredicateSelector, R as RelationExpr, ai as RelationId, aj as RelationshipArrowType, ak as RelationshipKind, al as RelationshipKindSpecification, am as RelationshipLineType, au as RelationshipThemeColorValues, at as RelationshipThemeColors, bg as ScopedElementView, av as ShapeSize, aw as SpacingSize, bh as StepEdgeId, bi as StepEdgeIdLiteral, ab as TagEqual, w as TagSpec, ax as TextSize, T as ThemeColorValues, ao as ThemeColors, x as TypedElement, bj as ViewAutoLayout, bm as ViewRule, bn as ViewRuleAutoLayout, bo as ViewRuleGlobalPredicateRef, bp as ViewRuleGlobalStyle, bq as ViewRuleGroup, br as ViewRulePredicate, bs as ViewRuleStyle, bt as ViewRuleStyleOrGlobalRef, bu as ViewWithHash, bv as ViewWithNotation, ac as WhereOperator, aB as extractStep, aC as getBBoxCenter, aD as getParallelStepsPrefix, W as isAndOperator, aE as isAutoLayoutDirection, aF as isDeploymentView, aG as isDynamicView, aH as isDynamicViewParallelSteps, aI as isElementView, aJ as isExtendsElementView, X as isKindEqual, Y as isNotOperator, Z as isOrOperator, _ as isParticipantOperator, aK as isScopedElementView, aL as isStepEdgeId, $ as isTagEqual, an as isThemeColor, aM as isViewRuleAutoLayout, aN as isViewRuleGlobalPredicateRef, aO as isViewRuleGlobalStyle, aP as isViewRuleGroup, aQ as isViewRulePredicate, aR as isViewRuleStyle, aS as stepEdgeId, a0 as whereOperatorAsPredicate } from '../shared/core.DJvmfnEi.mjs';
 import 'type-fest';
 
 /**

package/dist/types/index.mjs

@@ -1,4 +1,4 @@
-export { A as AsFqn, B as BorderStyles, V as ComputedNode, W as ComputedView, S as DefaultArrowType, D as DefaultElementShape, T as DefaultLineStyle, g as DefaultPaddingSize, U as DefaultRelationshipColor, h as DefaultShapeSize, j as DefaultTextSize, c as DefaultThemeColor, d as DeploymentElement, X as DiagramNode, E as ElementKind, k as ElementShapes, H as ExpressionV2, I as FqnExpr, J as FqnRef, R as RelationExpr, Y as extractStep, Z as getBBoxCenter, _ as getParallelStepsPrefix, K as isAndOperator, $ as isAutoLayoutDirection, l as isCustomElement, m as isCustomRelationExpr, a0 as isDeploymentView, a1 as isDynamicView, a2 as isDynamicViewParallelSteps, p as isElement, q as isElementKindExpr, b as isElementPredicateExpr, r as isElementRef, s as isElementTagExpr, a as isElementView, t as isElementWhere, u as isExpandedElementExpr, i as isExtendsElementView, w as isInOut, v as isIncoming, L as isKindEqual, M as isNotOperator, N as isOrOperator, x as isOutgoing, O as isParticipantOperator, y as isRelation, z as isRelationExpression, C as isRelationPredicateExpr, F as isRelationWhere, e as isScopedElementView, a3 as isStepEdgeId, P as isTagEqual, a4 as isViewRuleAutoLayout, a5 as isViewRuleGlobalPredicateRef, a6 as isViewRuleGlobalStyle, a7 as isViewRuleGroup, a8 as isViewRulePredicate, a9 as isViewRuleStyle, G as isWildcard, aa as stepEdgeId, Q as whereOperatorAsPredicate } from '../shared/core.BMep80lJ.mjs';
+export { A as AsFqn, B as BorderStyles, C as ComputedNode, z as ComputedView, v as DefaultArrowType, D as DefaultElementShape, x as DefaultLineStyle, f as DefaultPaddingSize, y as DefaultRelationshipColor, g as DefaultShapeSize, h as DefaultTextSize, b as DefaultThemeColor, c as DeploymentElement, H as DiagramNode, E as ElementKind, j as ElementShapes, k as ExpressionV2, F as FqnExpr, l as FqnRef, G as GlobalFqn, M as ModelLayer, R as RelationExpr, I as extractStep, J as getBBoxCenter, K as getParallelStepsPrefix, m as isAndOperator, L as isAutoLayoutDirection, N as isDeploymentView, O as isDynamicView, P as isDynamicViewParallelSteps, a as isElementView, i as isExtendsElementView, e as isGlobalFqn, p as isKindEqual, q as isNotOperator, r as isOrOperator, t as isParticipantOperator, d as isScopedElementView, Q as isStepEdgeId, u as isTagEqual, S as isViewRuleAutoLayout, T as isViewRuleGlobalPredicateRef, U as isViewRuleGlobalStyle, V as isViewRuleGroup, W as isViewRulePredicate, X as isViewRuleStyle, s as splitGlobalFqn, Y as stepEdgeId, w as whereOperatorAsPredicate } from '../shared/core.DgfwjBtu.mjs';
 
 const ThemeColors = [
   "amber",

package/dist/utils/index.d.mts

@@ -1,5 +1,5 @@
-export { I as IterableContainer, R as ReorderedArray, a as ancestorsFqn, c as commonAncestor, b as compareByFqnHierarchically, d as compareFqnHierarchically, h as hierarchyDistance, e as hierarchyLevel, i as isAncestor, f as isDescendantOf, g as isSameHierarchy, n as nameFromFqn, p as parentFqn, s as sortByFqnHierarchically, j as sortNaturalByFqn, k as sortParentsFirst } from '../shared/core.HKn0jlo_.mjs';
-import { N as NonEmptyArray, a as IteratorLike } from '../shared/core.30yYKXcZ.mjs';
+export { I as IterableContainer, R as ReorderedArray, a as ancestorsFqn, c as commonAncestor, b as compareByFqnHierarchically, d as compareFqnHierarchically, h as hierarchyDistance, e as hierarchyLevel, i as isAncestor, f as isDescendantOf, g as isSameHierarchy, n as nameFromFqn, p as parentFqn, s as sortByFqnHierarchically, j as sortNaturalByFqn, k as sortParentsFirst } from '../shared/core.D2830qgg.mjs';
+import { N as NonEmptyArray, I as IteratorLike } from '../shared/core.SjLhMA7a.mjs';
 import { IsNumericLiteral } from 'type-fest';
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@likec4/core",
-  "version": "1.27.3",
+  "version": "1.28.1",
   "license": "MIT",
   "homepage": "https://likec4.dev",
   "author": "Denis Davydkov <denis@davydkov.com>",
@@ -84,11 +84,11 @@
     "access": "public"
   },
   "dependencies": {
-    "type-fest": "^4.38.0"
+    "type-fest": "^4.39.1"
   },
   "devDependencies": {
     "@dagrejs/dagre": "1.1.4",
-    "@mantine/colors-generator": "7.17.3",
+    "@mantine/colors-generator": "7.17.4",
     "@types/natural-compare-lite": "^1.4.2",
     "@types/object-hash": "^3.0.6",
     "chroma-js": "^3.1.2",
@@ -102,11 +102,11 @@
     "object-hash": "^3.0.0",
     "obliterator": "^2.0.5",
     "remeda": "^2.21.2",
-    "turbo": "^2.4.4",
-    "typescript": "^5.8.2",
+    "turbo": "^2.5.0",
+    "typescript": "^5.8.3",
     "unbuild": "^3.5.0",
-    "vitest": "^3.0.9",
-    "@likec4/tsconfig": "1.27.3"
+    "vitest": "^3.1.1",
+    "@likec4/tsconfig": "1.28.1"
   },
   "scripts": {
     "typecheck": "tsc --noEmit",

package/src/builder/Builder.ts

@@ -340,6 +340,7 @@ function builder<Spec extends BuilderSpecification, T extends AnyTypes>(
           Array.from(_views.entries()),
         ),
       ),
+      imports: {},
     } as any),
     toLikeC4Model: () => {
       const parsed = self.build()

package/src/builder/Builder.view-common.ts

@@ -2,15 +2,12 @@ import { isArray, isString, map } from 'remeda'
 import type { LiteralUnion, Simplify } from 'type-fest'
 import {
   type AutoLayoutDirection,
-  type CustomElementExpr,
-  type CustomRelationExpr,
-  type ElementExpression as C4ElementExpression,
-  type Expression as C4Expression,
+  type ExpressionV2,
   type NonEmptyArray,
   type ViewRuleStyle,
   type WhereOperator,
-  isElementPredicateExpr,
 } from '../types'
+import { ModelLayer } from '../types/expression-v2-model'
 import type { KindEqual, Participant, TagEqual } from '../types/operators'
 import type { AnyTypes, Types } from './_types'
 
@@ -87,7 +84,10 @@ export namespace ViewPredicate {
   export type Custom<Types extends AnyTypes> = {
     where?: ViewPredicate.WhereOperator<Types>
     with?: Simplify<
-      Omit<CustomElementExpr['custom'] & CustomRelationExpr['customRelation'], 'expr' | 'relation' | 'navigateTo'> & {
+      Omit<
+        ModelLayer.FqnExpr.Custom['custom'] & ModelLayer.RelationExpr.Custom['customRelation'],
+        'expr' | 'relation' | 'navigateTo'
+      > & {
         navigateTo?: Types['ViewId']
       }
     >
@@ -181,7 +181,7 @@ function $include<B extends LikeC4ViewBuilder<AnyTypes, any, any>>(
 
       const custom = args[1].with
       if (custom) {
-        const isElement = isElementPredicateExpr(expr)
+        const isElement = ModelLayer.FqnExpr.is(expr)
         if (isElement) {
           expr = {
             custom: {
@@ -193,7 +193,7 @@ function $include<B extends LikeC4ViewBuilder<AnyTypes, any, any>>(
           expr = {
             customRelation: {
               ...custom,
-              relation: expr as any,
+              expr: expr as any,
             },
           }
         }
@@ -212,7 +212,7 @@ function $exclude<B extends LikeC4ViewBuilder<AnyTypes, any, any>>(
     | [B['TypedExpr'], ViewPredicate.Custom<B['Types']>]
 ): (b: B) => B {
   return (b) => {
-    let expr = b.$expr(args[0]) as C4Expression
+    let expr = b.$expr(args[0]) as ExpressionV2
     if (args.length === 2 && args[1].where) {
       const condition = parseWhere(args[1].where)
       expr = {
@@ -233,7 +233,7 @@ function $style<B extends LikeC4ViewBuilder<AnyTypes, any, any>>(
 ): (b: B) => B {
   return (b) =>
     b.style({
-      targets: (isArray(element) ? element : [element]).map(e => b.$expr(e as any) as C4ElementExpression),
+      targets: (isArray(element) ? element : [element]).map(e => b.$expr(e as any) as ModelLayer.FqnExpr),
       ...(notation ? { notation } : {}),
       style: {
         ...style,

package/src/builder/Builder.view-element.ts

@@ -1,11 +1,12 @@
 import { isString } from 'remeda'
 import type { IsStringLiteral } from 'type-fest/source/is-literal'
-import { type Expression as C4Expression, type Fqn } from '../types'
+import { type ExpressionV2 } from '../types/expression-v2'
+import { type Fqn } from '../types/scalars'
 import type { AnyTypes, Invalid, Types } from './_types'
 import type { LikeC4ViewBuilder, ViewPredicate } from './Builder.view-common'
 import type { ViewsBuilder } from './Builder.views'
 
-export interface ElementViewBuilder<T extends AnyTypes> extends LikeC4ViewBuilder<T, T['Fqn'], C4Expression> {
+export interface ElementViewBuilder<T extends AnyTypes> extends LikeC4ViewBuilder<T, T['Fqn'], Types.ToExpression<T>> {
 }
 
 export type ElementViewRulesBuilder<T extends AnyTypes> = (b: ElementViewBuilder<T>) => ElementViewBuilder<T>
@@ -125,13 +126,15 @@ export interface TypedAddViewOfHelper<A extends AnyTypes> {
   }
 }
 // To hook types
-const asTypedExpr = (expr: C4Expression): C4Expression => {
-  return expr as C4Expression
+const asTypedExpr = (expr: ExpressionV2): ExpressionV2 => {
+  return expr as ExpressionV2
 }
 
-export function $expr<Types extends AnyTypes>(expr: ViewPredicate.Expression<Types> | C4Expression): C4Expression {
+export function $expr<Types extends AnyTypes>(
+  expr: ViewPredicate.Expression<Types> | ExpressionV2,
+): ExpressionV2 {
   if (!isString(expr)) {
-    return expr as C4Expression
+    return expr as ExpressionV2
   }
   if (expr === '*') {
     return asTypedExpr({ wildcard: true })
@@ -168,22 +171,31 @@ export function $expr<Types extends AnyTypes>(expr: ViewPredicate.Expression<Typ
   }
   if (expr.endsWith('._')) {
     return asTypedExpr({
-      expanded: expr.replace('._', '') as Fqn,
+      ref: {
+        model: expr.replace('._', '') as Fqn,
+      },
+      selector: 'expanded',
     })
   }
-  if (expr.endsWith('.*')) {
+  if (expr.endsWith('.**')) {
     return asTypedExpr({
-      element: expr.replace('.*', '') as Fqn,
-      isChildren: true,
+      ref: {
+        model: expr.replace('.**', '') as Fqn,
+      },
+      selector: 'descendants',
     })
   }
-  if (expr.endsWith('.**')) {
+  if (expr.endsWith('.*')) {
     return asTypedExpr({
-      element: expr.replace('.**', '') as Fqn,
-      isDescendants: true,
+      ref: {
+        model: expr.replace('.*', '') as Fqn,
+      },
+      selector: 'children',
     })
   }
   return asTypedExpr({
-    element: expr as any as Fqn,
+    ref: {
+      model: expr as any as Fqn,
+    },
   })
 }

package/src/builder/__snapshots__/Builder-style1.spec.ts.snap

@@ -99,6 +99,7 @@ exports[`Builder (style1) > should build nested elements and relTo 1`] = `
     "predicates": {},
     "styles": {},
   },
+  "imports": {},
   "relations": {
     "rel1": {
       "id": "rel1",
@@ -192,6 +193,7 @@ exports[`Builder (style1) > should build view  1`] = `
     "predicates": {},
     "styles": {},
   },
+  "imports": {},
   "relations": {},
   "specification": {
     "deployments": {},
@@ -237,8 +239,10 @@ exports[`Builder (style1) > should build view  1`] = `
         {
           "include": [
             {
-              "element": "c2",
-              "isChildren": true,
+              "ref": {
+                "model": "c2",
+              },
+              "selector": "children",
             },
           ],
         },
@@ -256,7 +260,10 @@ exports[`Builder (style1) > should build view  1`] = `
         {
           "include": [
             {
-              "expanded": "c3",
+              "ref": {
+                "model": "c3",
+              },
+              "selector": "expanded",
             },
           ],
         },
@@ -329,6 +336,7 @@ exports[`Builder (style1) > should build viewOf  1`] = `
     "predicates": {},
     "styles": {},
   },
+  "imports": {},
   "relations": {},
   "specification": {
     "deployments": {},
@@ -357,8 +365,10 @@ exports[`Builder (style1) > should build viewOf  1`] = `
           "include": [
             {
               "inout": {
-                "element": "c2.c3",
-                "isChildren": true,
+                "ref": {
+                  "model": "c2.c3",
+                },
+                "selector": "children",
               },
             },
           ],
@@ -367,11 +377,16 @@ exports[`Builder (style1) > should build viewOf  1`] = `
           "exclude": [
             {
               "source": {
-                "expanded": "c1",
+                "ref": {
+                  "model": "c1",
+                },
+                "selector": "expanded",
               },
               "target": {
-                "element": "c2.c3",
-                "isChildren": true,
+                "ref": {
+                  "model": "c2.c3",
+                },
+                "selector": "children",
               },
             },
           ],

package/src/builder/__snapshots__/Builder-style2.spec.ts.snap

@@ -105,6 +105,7 @@ exports[`Builder (style 2) > should build  1`] = `
     "predicates": {},
     "styles": {},
   },
+  "imports": {},
   "relations": {},
   "specification": {
     "deployments": {
@@ -143,8 +144,10 @@ exports[`Builder (style 2) > should build  1`] = `
                 "wildcard": true,
               },
               "target": {
-                "element": "cloud",
-                "isDescendants": true,
+                "ref": {
+                  "model": "cloud",
+                },
+                "selector": "descendants",
               },
             },
           ],
@@ -185,8 +188,10 @@ exports[`Builder (style 2) > should build  1`] = `
         {
           "include": [
             {
-              "element": "cloud",
-              "isChildren": true,
+              "ref": {
+                "model": "cloud",
+              },
+              "selector": "children",
             },
           ],
         },

package/src/compute-view/deployment-view/predicates/deploymentRefs-where.ts

@@ -0,0 +1,18 @@
+import { type FqnExpr, type RelationExpr, whereOperatorAsPredicate } from '../../../types'
+import type { PredicateExecutor } from '../_types'
+import type { StageExclude, StageInclude } from '../memory'
+import { predicateToPatch } from './utils'
+
+// relation matches the condition
+export const WhereDeploymentRefPredicate: PredicateExecutor<FqnExpr.Where> = {
+  include: ({ expr, model, memory, stage }) => {
+    const where = whereOperatorAsPredicate(expr.where.condition)
+
+    return predicateToPatch('include', { expr: expr.where.expr, model, stage, memory, where }) as StageInclude
+  },
+  exclude: ({ expr, model, memory, stage }) => {
+    const where = whereOperatorAsPredicate(expr.where.condition)
+
+    return predicateToPatch('exclude', { expr: expr.where.expr, model, stage, memory, where }) as StageExclude
+  },
+}

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

@@ -40,6 +40,12 @@ const resolveWildcard = (model: LikeC4DeploymentModel, nonWildcard: FqnExpr.Depl
 
 export const DirectRelationPredicate: PredicateExecutor<RelationExpr.Direct> = {
   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)

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

@@ -36,6 +36,9 @@ export const InOutRelationPredicate: PredicateExecutor<RelationExpr.InOut> = {
     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')
+    }
     // Exclude all connections that have model relationshps with the elements
     if (FqnExpr.isModelRef(expr.inout)) {
       const elements = resolveModelElements(model, expr.inout)

package/src/compute-view/deployment-view/predicates/relation-incoming.ts

@@ -38,6 +38,9 @@ export const IncomingRelationPredicate: PredicateExecutor<RelationExpr.Incoming>
     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')
+    }
     // Exclude all connections that have model relationshps with the elements
     if (FqnExpr.isModelRef(expr.incoming)) {
       const excludedRelations = resolveAllImcomingRelations(model, expr.incoming)

package/src/compute-view/deployment-view/predicates/relation-outgoing.ts

@@ -39,6 +39,9 @@ export const OutgoingRelationPredicate: PredicateExecutor<RelationExpr.Outgoing>
     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')
+    }
     // Exclude all connections that have model relationshps with the elements
     if (FqnExpr.isModelRef(expr.outgoing)) {
       const excludedRelations = resolveAllOutgoingRelations(model, expr.outgoing)

package/src/compute-view/deployment-view/predicates/utils.ts

@@ -15,6 +15,7 @@ import { hasIntersection, intersection } from '../../../utils/set'
 import type { ExcludePredicateCtx, PredicateCtx } from '../_types'
 import type { StageExclude, StageInclude } from '../memory'
 import { DeploymentRefPredicate } from './deploymentRefs'
+import { WhereDeploymentRefPredicate } from './deploymentRefs-where'
 import { DirectRelationPredicate } from './relation-direct'
 import { InOutRelationPredicate } from './relation-in-out'
 import { IncomingRelationPredicate } from './relation-incoming'
@@ -30,14 +31,22 @@ export function predicateToPatch(
   { expr, where, ...ctx }: PredicateCtx,
 ): StageExclude | StageInclude | undefined {
   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):
       // Ignore model refs in deployment view
       return undefined
+    case FqnExpr.isWhere(expr):
+      return WhereDeploymentRefPredicate[op]({ ...ctx, expr, where } as any)
+    case RelationExpr.isWhere(expr):
+      return WhereRelationPredicate[op]({ ...ctx, expr, where } as any)
     case FqnExpr.isDeploymentRef(expr):
       return DeploymentRefPredicate[op]({ ...ctx, expr, where } as any)
     case FqnExpr.isWildcard(expr):
       return WildcardPredicate[op]({ ...ctx, expr, where } as any)
-
     case RelationExpr.isDirect(expr):
       return DirectRelationPredicate[op]({ ...ctx, expr, where } as any)
     case RelationExpr.isInOut(expr):
@@ -46,8 +55,6 @@ export function predicateToPatch(
       return OutgoingRelationPredicate[op]({ ...ctx, expr, where } as any)
     case RelationExpr.isIncoming(expr):
       return IncomingRelationPredicate[op]({ ...ctx, expr, where } as any)
-    case RelationExpr.isWhere(expr):
-      return WhereRelationPredicate[op]({ ...ctx, expr, where } as any)
     default:
       nonexhaustive(expr)
   }

package/src/compute-view/deployment-view/utils.ts

@@ -7,18 +7,18 @@ import type { AnyAux } from '../../model/types'
 import {
   type ComputedEdge,
   type ComputedNode,
-  DefaultArrowType,
   type DeploymentNodeKind,
   type DeploymentViewRule,
   type Fqn,
-  FqnExpr,
-  isViewRuleStyle,
   type NonEmptyArray,
   type Tag,
+  DefaultArrowType,
+  FqnExpr,
+  isViewRuleStyle,
 } from '../../types'
 import { nameFromFqn, parentFqn } from '../../utils'
 import { applyViewRuleStyle } from '../utils/applyViewRuleStyles'
-import { buildComputedNodes, type ComputedNodeSource } from '../utils/buildComputedNodes'
+import { type ComputedNodeSource, buildComputedNodes } from '../utils/buildComputedNodes'
 import { mergePropsFromRelationships } from '../utils/merge-props-from-relationships'
 import { uniqueTags } from '../utils/uniqueTags'
 import type { Elem, Memory } from './_types'
@@ -67,6 +67,9 @@ export function deploymentExpressionToPredicate<T extends { id: string; modelRef
   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') {