@likec4/core 1.58.0 → 1.59.1

package/dist/{_chunks → chunks}/index.d.mts

@@ -1,13 +1,13 @@
+import { n as __exportAll, r as __name } from "./rolldown-runtime.mjs";
 import { c as XYPoint, i as BBox, s as Point } from "./index2.mjs";
-import { IfNever, IsAny, IsLiteral, IsNever, IsUnknown, KeysOfUnion, Or, PartialDeep, SetNonNullable, SetRequired, Simplify, Tagged, TupleToUnion, UnionToIntersection, WritableDeep } from "type-fest";
-
+import { IfNever, IsAny, IsEqual, IsLiteral, IsNever, IsUnknown, KeysOfUnion, Or, PartialDeep, SetNonNullable, SetRequired, Simplify, Tagged, TupleToUnion, UnionToIntersection, WritableDeep } from "type-fest";
 //#region src/types/_common.d.ts
 type NonEmptyArray<T> = [T, ...T[]];
 type NonEmptyReadonlyArray<T> = readonly [T, ...T[]];
 type IterableContainer<T = unknown> = ReadonlyArray<T> | readonly [];
-type ReorderedArray<T extends IterableContainer> = { -readonly [P in keyof T]: T[number] };
-type KeysOf<T> = keyof T extends infer K extends string ? K : never;
-type AllNever$1<Expressions> = UnionToIntersection<{ [Name in keyof Expressions]: { -readonly [Key in keyof Expressions[Name]]?: never } }[keyof Expressions]>;
+type ReorderedArray<T extends IterableContainer> = { -readonly [P in keyof T]: T[number]; };
+type KeysOf<T> = keyof T extends (infer K extends string) ? K : never;
+type AllNever$1<Expressions> = UnionToIntersection<{ [Name in keyof Expressions]: { -readonly [Key in keyof Expressions[Name]]?: never; }; }[keyof Expressions]>;
 /**
  * @example
  * ```ts
@@ -30,7 +30,7 @@ type AllNever$1<Expressions> = UnionToIntersection<{ [Name in keyof Expressions]
  *   }
  * ```
  */
-type ExclusiveUnion<Expressions, All = AllNever$1<Expressions>> = Expressions extends object ? { [Name in keyof Expressions]: Simplify<Omit<All, keyof Expressions[Name]> & Expressions[Name]> }[keyof Expressions] : never;
+type ExclusiveUnion<Expressions, All = AllNever$1<Expressions>> = Expressions extends object ? { [Name in keyof Expressions]: Simplify<Omit<All, keyof Expressions[Name]> & Expressions[Name]>; }[keyof Expressions] : never;
 /**
  * Copy from https://github.com/remeda/remeda/blob/main/packages/remeda/src/internal/types/NTuple.ts
  * An array with *exactly* N elements in it.
@@ -47,17 +47,22 @@ interface Link {
   url: string;
   relative?: string;
 }
+/**
+ * @see {@link LiteralUnion} from type-fest (https://github.com/sindresorhus/type-fest/blob/main/source/literal-union.d.ts)
+ */
+type OrString = string & Record<never, never>;
 /**
  * Coalesce `V` to a string if it is `any`
  */
 type Coalesce<V extends string, OrIfAny = string> = IsAny<V> extends true ? OrIfAny : V;
-type ExactObject<T, InputType = unknown> = { [KeyType in keyof T]: undefined extends T[KeyType] ? T[KeyType] | undefined : T[KeyType] } & Record<Exclude<keyof InputType, KeysOfUnion<T>>, never>;
+type ExactObject<T, InputType = unknown> = { [KeyType in keyof T]: undefined extends T[KeyType] ? T[KeyType] | undefined : T[KeyType]; } & Record<Exclude<keyof InputType, KeysOfUnion<T>>, never>;
 /**
  * Allows only exact properties of `U` to be present in `T` and omits undefined values
  *
  * See {@link Exact} for more details (this version is non-deep)
  */
 declare function exact<Expected, T extends ExactObject<Expected, T>>(a: T): Expected;
+type IsAnyOrNever<T> = Or<IsAny<T>, IsNever<T>>;
 //#endregion
 //#region src/types/const.d.ts
 /**
@@ -82,21 +87,34 @@ declare function isOnStage<T extends {
  */
 declare const _stage = "_stage";
 type _stage = typeof _stage;
+type inferStage<A> = A extends {
+  ['_stage']: infer S extends ModelStage;
+} ? IsAnyOrNever<S> extends true ? never : S : never;
 /**
- * Property name to store type information, used to identify the type of the view
+ * Property name to store type information, used to identify the type
+ * (of the view or view element)
  *
  * @internal
  */
 declare const _type = "_type";
 type _type = typeof _type;
+type inferType<A> = A extends {
+  ['_type']: infer T;
+} ? IsAnyOrNever<T> extends true ? never : T : never;
 /**
  * Property name to store layout type information, used to identify the type of the layout*
  * @internal
  */
 declare const _layout = "_layout";
 type _layout = typeof _layout;
+/**
+ * Property name to store version information (for migration purposes)
+ * @internal
+ */
+declare const _v = "_v";
+type _v = typeof _v;
 declare namespace scalar_d_exports {
-  export { AnyFqn, BuiltInIcon, DeploymentFqn$1 as DeploymentFqn, DeploymentKind$1 as DeploymentKind, EdgeId$1 as EdgeId, ElementKind$1 as ElementKind, Fqn$1 as Fqn, GlobalFqn, GroupElementKind, Icon, IconUrl, MarkdownOrString, NodeId$1 as NodeId, NoneIcon, ProjectId$1 as ProjectId, RelationId$1 as RelationId, RelationKind$1 as RelationKind, RelationshipKind, StepEdgeId, StepEdgeIdLiteral, StepEdgeKind, Tag$1 as Tag, ViewId$1 as ViewId, extractStep, flattenMarkdownOrString, isGlobalFqn, isGroupElementKind, isStepEdgeId, splitGlobalFqn, stepEdgeId };
+  export { AnyFqn, BuiltInIcon, DeploymentFqn$1 as DeploymentFqn, DeploymentKind$1 as DeploymentKind, EdgeId$1 as EdgeId, ElementKind$1 as ElementKind, Fqn$1 as Fqn, GlobalFqn, GroupElementKind, Icon, IconUrl, MarkdownOrString, NodeId$1 as NodeId, NoneIcon, ProjectId$1 as ProjectId, RelationId$1 as RelationId, RelationKind$1 as RelationKind, RelationshipKind, StepEdgeKind, StepPath, Tag$1 as Tag, ViewId$1 as ViewId, flattenMarkdownOrString, isGlobalFqn, isGroupElementKind, isStepPath, splitGlobalFqn };
 }
 type ProjectId$1<T = string> = Tagged<T, 'ProjectID'>;
 declare function ProjectId$1(name: string): ProjectId$1;
@@ -191,14 +209,42 @@ type NodeId$1 = Tagged<string, 'NodeId' | 'Fqn' | 'DeploymentFqn'>;
 declare function NodeId$1(id: string): NodeId$1;
 type EdgeId$1 = Tagged<string, 'EdgeId'>;
 declare function EdgeId$1(id: string): EdgeId$1;
-type StepEdgeIdLiteral = `step-${number}` | `step-${number}.${number}`;
-type StepEdgeId = Tagged<StepEdgeIdLiteral, 'EdgeId'>;
-declare function stepEdgeId(step: number, parallelStep?: number): StepEdgeId;
 declare const StepEdgeKind = "@step";
-declare function isStepEdgeId(id: string): id is StepEdgeId;
-declare function extractStep(id: EdgeId$1): number;
+type StepPath = Tagged<Tagged<`step-${string}`, 'EdgeId'>, 'StepPath'>;
+declare function isStepPath(id: unknown): id is StepPath;
+/**
+ * Path to a step, also acting as EdgeId
+ *
+ * Format: step-{segment1}.{segment2}...{segmentN}
+ * Where segment can be:
+ * - {index} (index in array, 1-based, represents A -> B)
+ * - {index}:{kind} (subflow of a kind, 1-based, i.e. "03:loop" - 3rd step starts a loop)
+ *
+ * @example
+ * ```
+ * dynamic view {
+ *   A -> B          // step-01
+ *   alt {           // step-02:alt - step 2 is alt subflow
+ *     when {        // step-02:alt.01:when - step 1 in alt is when subflow
+ *       try {       // step-02:alt.01:when.01:try - step 1 in when is try subflow
+ *         B -> C    // step-02:alt.01:when.01:try.01:block.01 - step 1 in try block
+ *       } catch {
+ *         B -> D    // step-02:alt.01:when.01:try.02:catch.01
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @param segments - Array of segments, where each segment can be:
+ *   - string: literal segment
+ *   - number: index segment (will be padded to 2 digits)
+ *   - [number, string]: index:kind segment (will be padded to 2 digits)
+ *   - undefined: will be filtered out
+ */
+declare function StepPath(...segments: Array<string | number | [number, string] | undefined>): StepPath;
 declare namespace _aux_d_exports {
-  export { AllKinds, Any, Any as AnyAux, AnyComputed, AnyLayouted, AnyOnStage, AnyParsed, AnySpec, Aux, DeploymentFqn, DeploymentId, DeploymentKind, EdgeId, ElementId, ElementKind, Fqn, LooseDeploymentId, LooseDeploymentKind, LooseElementId, LooseElementKind, LooseLiteral, LooseRelationKind, LooseTag, LooseTags, LooseViewId, Metadata, MetadataKey, Never, NodeId, OrString, PickByStage, ProjectId, RelationId, RelationKind, Spec, SpecAux, Stage, DeploymentFqn as StrictDeploymentFqn, StrictDeploymentKind, StrictElementKind, Fqn as StrictFqn, StrictProjectId, StrictRelationKind, StrictTag, StrictViewId, Tag, Tags, Unknown, UnknownComputed, UnknownLayouted, UnknownParsed, ViewId, WithDescriptionAndTech, WithLinks, WithMetadata, WithNotation, WithOptionalLinks, WithOptionalTags, WithTags, preferDescription, preferSummary, setProject, setStage, toComputed, toLayouted, toParsed };
+  export { AllKinds, Any, Any as AnyAux, AnyComputed, AnyLayouted, AnyOnStage, AnyParsed, AnySpec, Aux, DeploymentFqn, DeploymentId, DeploymentKind, EdgeId, ElementId, ElementKind, Fqn, LooseDeploymentId, LooseDeploymentKind, LooseElementId, LooseElementKind, LooseLiteral, LooseRelationKind, LooseTag, LooseTags, LooseViewId, Metadata, MetadataKey, Never, NodeId, PickByStage, ProjectId, RelationId, RelationKind, Spec, SpecAux, Stage, DeploymentFqn as StrictDeploymentFqn, StrictDeploymentKind, StrictElementKind, Fqn as StrictFqn, StrictProjectId, StrictRelationKind, StrictTag, StrictViewId, Tag, Tags, Unknown, UnknownComputed, UnknownLayouted, UnknownParsed, ViewId, WithDescriptionAndTech, WithLinks, WithMetadata, WithNotation, WithOptionalLinks, WithOptionalTags, WithTags, preferDescription, preferSummary, setProject, setStage, toComputed, toLayouted, toParsed };
 }
 /**
  * Specification types (kinds, tags, metadata keys)
@@ -325,7 +371,7 @@ type MetadataKey<A> = A extends Any ? Coalesce<A['MetadataKey']> : never;
 /**
  * Metadata object from Aux
  */
-type Metadata<A extends Any> = IsNever<A['MetadataKey']> extends true ? never : IsLiteral<A['MetadataKey']> extends true ? { [key in A['MetadataKey']]?: string | string[] } : Record<string, string | string[]>;
+type Metadata<A extends Any> = IsNever<A['MetadataKey']> extends true ? never : IsLiteral<A['MetadataKey']> extends true ? { [key in A['MetadataKey']]?: string | string[]; } : Record<string, string | string[]>;
 /**
  * All known kinds from Aux as a literal union.
  */
@@ -334,12 +380,12 @@ type AllKinds<A> = ElementKind<A> | DeploymentKind<A> | RelationKind<A>;
  * Specification from Aux
  */
 type Spec<A> = A extends Aux<any, any, any, any, any, SpecAux<infer E, infer D, infer R, infer T, infer M>> ? SpecAux<E, D, R, T, M> : never;
-type StrictProjectId<A> = A extends infer T extends Any ? ProjectId$1<ProjectId<T>> : never;
-type StrictViewId<A> = A extends infer T extends Any ? ViewId$1<ViewId<T>> : never;
-type StrictTag<A> = A extends infer T extends Any ? Tag$1<Tag<T>> : never;
-type StrictElementKind<A> = A extends infer T extends Any ? ElementKind$1<ElementKind<T>> : never;
-type StrictDeploymentKind<A> = A extends infer T extends Any ? DeploymentKind$1<DeploymentKind<T>> : never;
-type StrictRelationKind<A> = A extends infer T extends Any ? RelationshipKind<RelationKind<T>> : never;
+type StrictProjectId<A> = A extends (infer T extends Any) ? ProjectId$1<ProjectId<T>> : never;
+type StrictViewId<A> = A extends (infer T extends Any) ? ViewId$1<ViewId<T>> : never;
+type StrictTag<A> = A extends (infer T extends Any) ? Tag$1<Tag<T>> : never;
+type StrictElementKind<A> = A extends (infer T extends Any) ? ElementKind$1<ElementKind<T>> : never;
+type StrictDeploymentKind<A> = A extends (infer T extends Any) ? DeploymentKind$1<DeploymentKind<T>> : never;
+type StrictRelationKind<A> = A extends (infer T extends Any) ? RelationshipKind<RelationKind<T>> : never;
 type WithDescriptionAndTech = {
   readonly summary?: MarkdownOrString | null;
   readonly description?: MarkdownOrString | null;
@@ -371,10 +417,6 @@ type WithMetadata<A extends Any> = {
 type WithNotation = {
   readonly notation?: string | null;
 };
-/**
- * @see {@link LiteralUnion} from type-fest (https://github.com/sindresorhus/type-fest/blob/main/source/literal-union.d.ts)
- */
-type OrString = string & Record<never, never>;
 /**
  * Allows any string value, but still auto-completes to the possible values in IDE
  */
@@ -388,7 +430,7 @@ type LooseElementKind<A> = A extends Any ? LooseLiteral<A['ElementKind']> : stri
 type LooseDeploymentKind<A> = A extends Any ? LooseLiteral<A['DeploymentKind']> : string;
 type LooseRelationKind<A> = A extends Any ? LooseLiteral<A['RelationKind']> : string;
 //#endregion
-//#region ../../styled-system/preset/dist/defaults/index.d.mts
+//#region ../../styled-system/preset/dist/defaults/types.d.mts
 //#region src/defaults/types.d.ts
 declare const Sizes: readonly ["xs", "sm", "md", "lg", "xl"];
 declare const IconPositions: readonly ["left", "right", "top", "bottom"];
@@ -396,6 +438,7 @@ declare const BorderStyles: readonly ["solid", "dashed", "dotted", "none"];
 declare const ElementShapes: readonly ["rectangle", "person", "browser", "mobile", "cylinder", "storage", "queue", "bucket", "document", "component"];
 declare const ThemeColors: readonly ["amber", "blue", "gray", "slate", "green", "indigo", "muted", "primary", "red", "secondary", "sky"];
 declare const DefaultTagColors: readonly ["tomato", "grass", "blue", "ruby", "orange", "indigo", "pink", "teal", "purple", "amber", "crimson", "red", "lime", "yellow", "violet"];
+type DefaultTagColors = typeof DefaultTagColors[number];
 //#endregion
 //#region src/styles/types.d.ts
 /**
@@ -411,7 +454,8 @@ type BorderStyle = typeof BorderStyles[number];
 type ElementShape = typeof ElementShapes[number];
 type HexColor = `#${string}`;
 type ColorLiteral = HexColor | `rgb(${number},${number},${number})` | `rgba(${number},${number},${number},${number})`;
-type RelationshipLineType = 'dashed' | 'solid' | 'dotted';
+declare const RelationshipLineTypes: readonly ["dashed", "solid", "dotted"];
+type RelationshipLineType = TupleToUnion<typeof RelationshipLineTypes>;
 declare const RelationshipArrowTypes: readonly ["none", "normal", "onormal", "dot", "odot", "diamond", "odiamond", "crow", "open", "vee"];
 type RelationshipArrowType = TupleToUnion<typeof RelationshipArrowTypes>;
 type ThemeColor = typeof ThemeColors[number];
@@ -562,7 +606,7 @@ type KindEqual<A extends Any> = Omit<AllNever, 'kind'> & {
 declare function isKindEqual<A extends Any>(operator: WhereOperator<A>): operator is KindEqual<A>;
 type MetadataEqual<A extends Any> = Omit<AllNever, 'metadata'> & {
   metadata: {
-    key: string;
+    key: MetadataKey<A>;
     value?: EqualOperator<string> | string;
   };
 };
@@ -1143,7 +1187,7 @@ interface ParsedElementView<A extends Any = Any> extends BaseParsedViewPropertie
 }
 //#endregion
 //#region src/types/view-parsed.dynamic.d.ts
-interface DynamicStep<A extends Any = Any> {
+interface Step$1<A extends Any = Any> {
   readonly source: Fqn<A>;
   readonly target: Fqn<A>;
   readonly title?: string | null;
@@ -1164,23 +1208,106 @@ interface DynamicStep<A extends Any = Any> {
    */
   readonly astPath: string;
 }
-interface DynamicStepsSeries<A extends Any = Any> {
-  readonly seriesId: string;
-  readonly __series: NonEmptyReadonlyArray<DynamicStep<A>>;
+type AnyStep<A extends Any = Any> = ExclusiveUnion<{
+  Step: Step$1<A>;
+  Series: Step$1.Series<A>;
+  Parallel: Step$1.Parallel<A>;
+  Opt: Step$1.Opt<A>;
+  Loop: Step$1.Loop<A>;
+  Try: Step$1.Try<A>;
+  Alt: Step$1.Alt<A>;
+  Break: Step$1.Break<A>;
+}>;
+declare const stepGuards: {
+  isStep: <A extends Any>(step: AnyStep<A> | undefined | null) => step is Step$1<A>;
+  isSeries: <A extends Any>(step: AnyStep<A> | undefined | null) => step is Step$1.Series<A>;
+  isParallel: <A extends Any>(step: AnyStep<A> | undefined | null) => step is Step$1.Parallel<A>;
+  isOpt: <A extends Any>(step: AnyStep<A> | undefined | null) => step is Step$1.Opt<A>;
+  isLoop: <A extends Any>(step: AnyStep<A> | undefined | null) => step is Step$1.Loop<A>;
+  isTry: <A extends Any>(step: AnyStep<A> | undefined | null) => step is Step$1.Try<A>;
+  isAlt: <A extends Any>(step: AnyStep<A> | undefined | null) => step is Step$1.Alt<A>;
+  isBreak: <A extends Any>(step: AnyStep<A> | undefined | null) => step is Step$1.Break<A>;
+};
+interface WithSteps<A extends Any> {
+  readonly steps: NonEmptyReadonlyArray<AnyStep<A>>;
 }
-interface DynamicStepsParallel<A extends Any = Any> {
-  readonly parallelId: string;
-  readonly __parallel: NonEmptyReadonlyArray<DynamicStep<A> | DynamicStepsSeries<A>>;
+declare namespace Step$1 {
+  type Any<A extends Any = Any> = AnyStep<A>;
+  /**
+   * Chain of steps (used for sequential execution)
+   */
+  interface Series<A extends Any = Any> {
+    readonly [_type]: 'series';
+    readonly steps: NonEmptyReadonlyArray<Step$1<A>>;
+  }
+  /**
+   * Block of parallel steps
+   */
+  interface Parallel<A extends Any = Any> extends WithSteps<A> {
+    readonly [_type]: 'par';
+    readonly title?: string;
+  }
+  /**
+   * Try-catch-finally block
+   */
+  interface Try<A extends Any = Any> {
+    readonly [_type]: 'try';
+    /**
+     * Try section
+     */
+    readonly try: WithSteps<A> & {
+      readonly title?: string;
+    };
+    /**
+     * Catch section (optional)
+     */
+    readonly catch?: WithSteps<A> & {
+      readonly title?: string;
+    };
+    /**
+     * Finally section (optional)
+     */
+    readonly finally?: WithSteps<A> & {
+      readonly title?: string;
+    };
+  }
+  /**
+   * Opt block (opt)
+   */
+  interface Opt<A extends Any = Any> extends WithSteps<A> {
+    readonly [_type]: 'opt';
+    readonly title?: string;
+  }
+  /**
+   * Break block
+   */
+  interface Break<A extends Any = Any> extends WithSteps<A> {
+    readonly [_type]: 'break';
+    readonly title?: string;
+  }
+  /**
+   * Loop block (loop)
+   */
+  interface Loop<A extends Any = Any> extends WithSteps<A> {
+    readonly [_type]: 'loop';
+    readonly title?: string;
+  }
+  /**
+   * Group of alternative branches (alt)
+   */
+  interface Alt<A extends Any = Any> {
+    readonly [_type]: 'alt';
+    readonly title?: string;
+    readonly branches: NonEmptyReadonlyArray<AltBranch<A>>;
+  }
+  /**
+   * Branch block (if/else/if, when, opt)
+   */
+  interface AltBranch<A extends Any = Any> extends WithSteps<A> {
+    readonly [_type]: 'when' | 'if' | 'else';
+    readonly title?: string;
+  }
 }
-declare function getParallelStepsPrefix(id: string): string | null;
-type DynamicViewStep<A extends Any = Any> = ExclusiveUnion<{
-  Step: DynamicStep<A>;
-  Series: DynamicStepsSeries<A>;
-  Parallel: DynamicStepsParallel<A>;
-}>;
-declare function isDynamicStep<A extends Any>(step: DynamicViewStep<A> | undefined): step is DynamicStep<A>;
-declare function isDynamicStepsParallel<A extends Any>(step: DynamicViewStep<A> | undefined): step is DynamicStepsParallel<A>;
-declare function isDynamicStepsSeries<A extends Any>(step: DynamicViewStep<A> | undefined): step is DynamicStepsSeries<A>;
 interface DynamicViewIncludeRule<A extends Any = Any> {
   include: ModelFqnExpr.Any<A>[];
 }
@@ -1202,7 +1329,7 @@ interface ParsedDynamicView<A extends Any = Any> extends BaseParsedViewPropertie
    * @default 'diagram'
    */
   readonly variant?: DynamicViewDisplayVariant;
-  readonly steps: DynamicViewStep<A>[];
+  readonly steps: Step$1.Any<A>[];
   readonly rules: DynamicViewRule<A>[];
 }
 //#endregion
@@ -1251,13 +1378,7 @@ type WithSizes = Pick<ElementStyle, 'size' | 'padding' | 'textSize' | 'iconSize'
 /**
  * Ensures that the sizes are set to default values if they are not set
  */
-declare function ensureSizes<S extends WithSizes>({
-  size,
-  padding,
-  textSize,
-  iconSize,
-  ...rest
-}: S, defaultSize?: "xs" | "sm" | "md" | "lg" | "xl"): Omit<S, keyof WithSizes> & Required<WithSizes>;
+declare function ensureSizes<S extends WithSizes>({ size, padding, textSize, iconSize, ...rest }: S, defaultSize?: "xs" | "sm" | "md" | "lg" | "xl"): Omit<S, keyof WithSizes> & Required<WithSizes>;
 interface Element<A extends Any = Any> extends WithDescriptionAndTech, WithOptionalTags<A>, WithOptionalLinks, WithMetadata<A>, WithNotation {
   readonly id: Fqn<A>;
   readonly kind: ElementKind<A>;
@@ -1368,8 +1489,12 @@ declare function isTagColorSpecified(spec: string | TagSpecification): spec is {
   color: ColorLiteral;
 };
 interface RelationshipSpecification {
+  tags?: Tag$1[];
+  title?: string;
+  description?: MarkdownOrString;
   technology?: string;
   notation?: string;
+  links?: NonEmptyArray<Link>;
   color?: Color;
   line?: RelationshipLineType;
   head?: RelationshipArrowType;
@@ -1382,10 +1507,10 @@ interface RelationshipSpecification {
   multiple?: boolean;
 }
 type Specification<A> = A extends Any ? {
-  tags: { [key in Tag<A>]: TagSpecification };
-  elements: { [key in ElementKind<A>]: Partial<ElementSpecification> };
-  deployments: { [key in DeploymentKind<A>]: Partial<ElementSpecification> };
-  relationships: { [key in RelationKind<A>]: Partial<RelationshipSpecification> };
+  tags: { [key in Tag<A>]: TagSpecification; };
+  elements: { [key in ElementKind<A>]: Partial<ElementSpecification>; };
+  deployments: { [key in DeploymentKind<A>]: Partial<ElementSpecification>; };
+  relationships: { [key in RelationKind<A>]: Partial<RelationshipSpecification>; };
   metadataKeys?: IsNever<MetadataKey<A>> extends true ? never : MetadataKey<A>[];
   customColors?: CustomColorDefinitions;
 } : never;
@@ -1448,146 +1573,40 @@ interface LikeC4Project {
   inferTechnologyFromIcon?: boolean | undefined;
 }
 //#endregion
-//#region src/types/view-computed.d.ts
-type ComputedNodeStyle = Simplify<ElementStyle & {
-  icon?: never;
-  shape?: never;
-  color?: never;
-}>;
-interface ComputedNode<A extends Any = Any> extends WithTags<A>, WithOptionalLinks {
-  /**
-   * Element metadata, propagated from the model.
-   * Uses a loose record type (instead of aux.WithMetadata<A>) to avoid
-   * exactOptionalPropertyTypes conflicts when MetadataKey is a literal union.
-   */
-  readonly metadata?: Readonly<Record<string, string | string[] | undefined>> | null;
-  id: NodeId$1;
-  kind: ElementKind<A> | DeploymentKind<A> | '@group';
-  parent: NodeId$1 | null;
-  /**
-   * Reference to model element
-   */
-  modelRef?: Fqn<A>;
-  /**
-   * Reference to deployment element
-   */
-  deploymentRef?: DeploymentFqn<A>;
-  title: string;
-  /**
-   * Description of the node
-   * either summary or description
-   */
-  description?: MarkdownOrString | null;
-  technology?: string | null;
-  children: NodeId$1[];
-  inEdges: EdgeId$1[];
-  outEdges: EdgeId$1[];
-  shape: ElementShape;
-  color: Color;
-  icon?: Icon | null;
-  style: ComputedNodeStyle;
-  navigateTo?: StrictViewId<A> | null;
-  level: number;
-  depth?: number | null;
-  /**
-   * If this node was customized in the view
-   */
-  isCustomized?: boolean;
-  notation?: string | null;
-  notes?: MarkdownOrString | undefined;
-}
-interface ComputedEdge<A extends Any = Any> extends WithOptionalTags<A> {
-  id: EdgeId$1;
-  parent: NodeId$1 | null;
-  source: NodeId$1;
-  target: NodeId$1;
-  label: string | null;
-  description?: MarkdownOrString | null;
-  technology?: string | null;
-  relations: RelationId$1[];
-  kind?: RelationKind<A> | typeof StepEdgeKind;
-  notation?: string;
-  notes?: MarkdownOrString;
-  color: Color;
-  line: RelationshipLineType;
-  head?: RelationshipArrowType;
-  tail?: RelationshipArrowType;
-  navigateTo?: StrictViewId<A> | null;
-  /**
-   * If this edge is derived from custom relationship predicate
-   */
-  isCustomized?: boolean;
-  /**
-   * Path to the AST node relative to the view body ast
-   * Available only in dynamic views
-   * @internal
-   */
-  astPath?: string;
-  /**
-   * For layouting purposes
-   * @default 'forward'
-   */
-  dir?: 'forward' | 'back' | 'both';
-}
-interface ComputedRankConstraint {
-  type: RankValue;
-  nodes: NodeId$1[];
-}
-interface BaseComputedViewProperties<A extends Any> extends BaseViewProperties<A>, ViewWithHash, ViewWithNotation {
-  readonly [_stage]: 'computed';
-  readonly autoLayout: ViewAutoLayout;
-  readonly nodes: ReadonlyArray<ComputedNode<A>>;
-  readonly edges: ReadonlyArray<ComputedEdge<A>>;
-  /**
-   * If the view has manual layout (v2)
-   */
-  readonly hasManualLayout?: boolean;
-}
-interface ComputedElementView<A extends Any = Any> extends BaseComputedViewProperties<A> {
-  readonly [_type]: 'element';
-  readonly viewOf?: Fqn<A>;
-  readonly extends?: StrictViewId<A>;
-  readonly ranks?: ComputedRankConstraint[];
-}
-interface ComputedDeploymentView<A extends Any = Any> extends BaseComputedViewProperties<A> {
-  readonly [_type]: 'deployment';
-}
-interface ComputedDynamicView<A extends Any = Any> extends BaseComputedViewProperties<A> {
-  readonly [_type]: 'dynamic';
-  /**
-   * How to display the dynamic view
-   * - `diagram`: display as a regular likec4 view
-   * - `sequence`: display as a sequence diagram
-   */
-  readonly variant: DynamicViewDisplayVariant;
-}
-//#endregion
 //#region src/types/view-manual-layout.d.ts
 type LayoutedViewDriftReason = 'not-exists' | 'type-changed' | 'nodes-added' | 'nodes-removed' | 'nodes-drift' | 'edges-added' | 'edges-removed' | 'edges-drift';
 type DiagramNodeDriftReason = 'removed' | 'added' | 'label-changed' | 'modelRef-changed' | 'parent-changed' | 'children-changed' | 'became-compound' | 'became-leaf' | 'shape-changed';
 type DiagramEdgeDriftReason = 'removed' | 'added' | 'label-added' | 'label-removed' | 'label-changed' | 'notes-changed' | 'direction-changed' | 'source-changed' | 'target-changed';
-type ViewManualLayoutSnapshotPerType = {
-  readonly [_type]: 'element';
-  readonly viewOf?: Fqn$1;
-  readonly extends?: ViewId$1;
-} | {
-  readonly [_type]: 'deployment';
-} | {
-  readonly [_type]: 'dynamic';
-  readonly sequenceLayout: LayoutedDynamicView.Sequence.Layout;
-};
-type ViewManualLayoutSnapshot<Type extends ViewType = ViewType> = Simplify<ViewManualLayoutSnapshotPerType & {
+type ViewManualLayoutSnapshotPerType = Simplify<{
   readonly id: ViewId$1;
   readonly title: string | null;
   readonly description: MarkdownOrString | null;
-  readonly [_type]: Type;
   readonly [_stage]: 'layouted';
   readonly hash: string;
   readonly nodes: ReadonlyArray<DiagramNode>;
   readonly edges: ReadonlyArray<DiagramEdge>;
   readonly bounds: BBox;
   readonly autoLayout: ViewAutoLayout;
-} & ViewWithNotation>;
+} & ViewWithNotation & ({
+  readonly [_type]: 'element';
+  readonly viewOf?: Fqn$1;
+  readonly extends?: ViewId$1;
+} | {
+  readonly [_type]: 'deployment';
+} | {
+  readonly [_type]: 'dynamic';
+  readonly flow?: DynamicViewFlowData;
+  readonly sequenceLayout: LayoutedDynamicView.Sequence.Layout;
+})>;
+/**
+ * Snapshot of a view's manual layout.
+ *
+ * When Type is `any`, returns the union of all possible snapshot types.
+ * When Type is a specific view type, returns the corresponding snapshot type.
+ */
+type ViewManualLayoutSnapshot<Type extends ViewType = ViewType> = IsAnyOrNever<Type> extends true ? never : Type extends (infer T extends string) ? Extract<ViewManualLayoutSnapshotPerType, {
+  [_type]: T;
+}> : ViewManualLayoutSnapshotPerType;
 //#endregion
 //#region src/types/view-layouted.d.ts
 interface DiagramNode<A extends Any = Any> extends ComputedNode<A>, BBox {
@@ -1681,6 +1700,13 @@ interface LayoutedDynamicView<A extends Any = Any> extends BaseLayoutedViewPrope
    * - `sequence`: display as a sequence diagram
    */
   readonly variant: DynamicViewDisplayVariant;
+  /**
+   * Represents the complete flow structure for dynamic views, as a sequence of steps.
+   * Can include nested flows, branches, loops, and conditional statements.
+   *
+   * (this can be undefined if read from manual snapshot)
+   */
+  readonly flow?: DynamicViewFlowSteps;
   /**
    * Sequence layout of this dynamic view
    */
@@ -1697,7 +1723,7 @@ declare namespace LayoutedDynamicView {
       readonly position: 'left' | 'right' | 'top' | 'bottom';
     }
     interface Actor {
-      readonly id: NodeId;
+      readonly id: NodeId$1;
       readonly x: number;
       readonly y: number;
       readonly width: number;
@@ -1705,17 +1731,20 @@ declare namespace LayoutedDynamicView {
       readonly ports: ReadonlyArray<ActorPort>;
     }
     interface Compound {
-      readonly id: NodeId;
+      readonly id: NodeId$1;
       /**
        * Original node id, since multiple compound nodes can be built from one node
        */
-      readonly origin: NodeId;
+      readonly origin: NodeId$1;
       readonly x: number;
       readonly y: number;
       readonly width: number;
       readonly height: number;
       readonly depth: number;
     }
+    /**
+     * @deprecated Use SubflowArea instead
+     */
     interface ParallelArea {
       readonly parallelPrefix: string;
       readonly x: number;
@@ -1723,14 +1752,29 @@ declare namespace LayoutedDynamicView {
       readonly width: number;
       readonly height: number;
     }
+    /**
+     * Represents an area around some flow control block
+     * (the rest my be read from `view.flow`)
+     */
+    interface SubflowArea {
+      readonly id: StepPath;
+      readonly x: number;
+      readonly y: number;
+      readonly width: number;
+      readonly height: number;
+    }
     interface Step {
-      readonly id: EdgeId;
+      readonly id: StepPath;
       readonly labelBBox?: {
         width: number;
         height: number;
       } | undefined;
       readonly sourceHandle: string;
       readonly targetHandle: string;
+      /**
+       * Step is hidden if it is inside a collapsed subflow
+       */
+      readonly hidden?: boolean;
     }
     interface Layout {
       readonly actors: ReadonlyArray<Actor>;
@@ -1739,12 +1783,700 @@ declare namespace LayoutedDynamicView {
        */
       readonly steps: ReadonlyArray<Step>;
       readonly compounds: ReadonlyArray<Compound>;
+      /**
+       * @deprecated Use subflows instead
+       */
       readonly parallelAreas: ReadonlyArray<ParallelArea>;
+      readonly subflows: ReadonlyArray<SubflowArea>;
       readonly bounds: BBox;
     }
   }
 }
 //#endregion
+//#region src/types/view-dynamic-flow.d.ts
+type WithFlowBase<Dict extends {}> = { [T in keyof Dict]: Simplify<{
+  readonly '_type': T;
+  /**
+   * Prefix for step IDs in this flow (undefined for top-level flow)
+   */
+  readonly id: StepPath;
+  readonly title?: string | undefined;
+} & Dict[T]>; };
+/**
+ * All possible sub-flow types
+ */
+type SubFlows = WithFlowBase<{ [T in 'loop' | 'opt' | 'par' | 'break']: {
+  readonly flow: DynamicViewFlowSteps;
+}; } & { [B in `try-${'block' | 'catch' | 'finally'}` | `alt-${'when' | 'else' | 'if'}`]: {
+  readonly flow: DynamicViewFlowSteps;
+}; } & {
+  'try': {
+    /**
+     * Allowed flows:
+     * try, try-catch, try-finally, try-catch-finally,
+     */
+    readonly flow: readonly [Subflow<'try-block'>] | readonly [Subflow<'try-block'>, Subflow<'try-catch' | 'try-finally'>] | readonly [Subflow<'try-block'>, Subflow<'try-catch'>, Subflow<'try-finally'>];
+  };
+  'alt': {
+    /**
+     * Allowed branch flows:
+     * when, else, if
+     */
+    readonly flow: readonly Subflow<'alt-when' | 'alt-else' | 'alt-if'>[];
+  };
+}>;
+type SubflowType = keyof SubFlows;
+type Subflow<T extends SubflowType> = SubFlows[T];
+type AnySubflow = SubFlows[SubflowType];
+type NestedOf<T extends SubflowType> = SubFlows[T] extends {
+  flow: IterableContainer<infer F>;
+} ? F : never;
+type ParentOf<T extends SubflowType> = IsAnyOrNever<T> extends true ? never : IsEqual<SubflowType, T> extends true ? SubflowType : T extends `try-${string}` ? 'try' : T extends `alt-${string}` ? 'alt' : Exclude<SubflowType, 'alt' | 'try'>;
+/**
+ * Sub-flows that can be used in dynamic view flows: `alt`, `try`, `loop`, `opt`, `par`, `break`
+ *
+ * (excluding branch flows like `try-block`, `alt-when`, etc. - as they exist only within their parent)
+ */
+type DynamicViewSubFlow = Subflow<'alt' | 'try' | 'loop' | 'opt' | 'par' | 'break'>;
+/**
+ * Generic step in a dynamic view flow
+ * Either a String, meaning it is relation `A -> B`, lookup in edges) or a sub-flow
+ *
+ * @see DynamicViewSubFlow
+ */
+type DynamicViewFlowStep = StepPath | DynamicViewSubFlow;
+/**
+ * Generic steps in a dynamic view flow
+ * @see DynamicViewFlowStep
+ */
+type DynamicViewFlowSteps = ReadonlyArray<DynamicViewFlowStep>;
+/**
+ * Represents the complete flow structure for dynamic views, as a sequence of steps.
+ * Can include nested flows, branches, loops, and conditional statements.
+ */
+type DynamicViewFlowData = DynamicViewFlowSteps;
+declare namespace DynamicViewFlow {
+  type SubFlowType = SubflowType;
+  /**
+   * Sub-flow types that can be used in dynamic view flows (excluding nested blocks like try-block, alt-when, etc.)
+   * alt, try, loop, opt, par
+   */
+  type SubFlow = DynamicViewSubFlow;
+  type Step = DynamicViewFlowStep;
+  type Steps = DynamicViewFlowSteps;
+  type AnyStep = StepPath | AnySubflow;
+  namespace SubFlow {
+    /**
+     * Any subflow type, including nested branches (alt-when, alt-else, alt-if, try-catch, try-finally)
+     */
+    type Any = AnySubflow;
+    /**
+     * Generic subflow type for a given subflow type
+     * @example
+     * ```ts
+     * type AltOrTry = DynamicViewFlow.SubFlow.Of<'alt' | 'try'>
+     * ```
+     */
+    type Of<T extends SubflowType> = Subflow<T>;
+    type Alt = Subflow<'alt'>;
+    namespace Alt {
+      type Branch = Subflow<'alt-when' | 'alt-else' | 'alt-if'>;
+    }
+    type Try = Subflow<'try'>;
+    namespace Try {
+      type Block = Subflow<'try-block'>;
+      type Catch = Subflow<'try-catch'>;
+      type Finally = Subflow<'try-finally'>;
+      type Any = Block | Catch | Finally;
+    }
+    type Loop = Subflow<'loop'>;
+    type Opt = Subflow<'opt'>;
+    type Par = Subflow<'par'>;
+    type Break = Subflow<'break'>;
+  }
+}
+type StepPathOrFlow = StepPath | {
+  readonly id: StepPath;
+};
+declare function isSubFlow<T extends AnyStep>(step: T): step is Exclude<T, string>;
+declare function isSubFlow(step: unknown): step is AnySubflow;
+declare const flowGuards: {
+  isStepPath: typeof isStepPath;
+  isSubFlow: typeof isSubFlow;
+  isTry: (step: unknown) => step is DynamicViewFlow.SubFlow.Try;
+  isTryBlock: (step: unknown) => step is DynamicViewFlow.SubFlow.Try.Block;
+  isAlt: (step: unknown) => step is DynamicViewFlow.SubFlow.Alt;
+  isAltBranch: (step: unknown) => step is DynamicViewFlow.SubFlow.Alt.Branch;
+  isTryBranch: (step: unknown) => step is DynamicViewFlow.SubFlow.Try.Any;
+  isAltOrTry: (step: unknown) => step is DynamicViewFlow.SubFlow.Try | DynamicViewFlow.SubFlow.Alt;
+  isAltOrTryBranch: (step: unknown) => step is DynamicViewFlow.SubFlow.Try.Any | DynamicViewFlow.SubFlow.Alt.Branch;
+  type: {
+    isAltOrTry: (value: unknown) => value is "alt" | "try";
+    isAltBranch: (value: unknown) => value is DynamicViewFlow.SubFlow.Alt.Branch["_type"];
+    isTryBlock: (value: unknown) => value is "try-block";
+    isTryBranch: (value: unknown) => value is DynamicViewFlow.SubFlow.Try.Any["_type"];
+    isAltOrTryBranch: <V>(value: V) => value is Extract<V, `${"alt" | "try"}-${string}`>;
+  };
+};
+/**
+ * Returns a function that checks if flow has a step (either directly or as a subflow)
+ */
+declare function includes(step: StepPathOrFlow): (flow: StepPathOrFlow) => boolean;
+/**
+ * Checks if flow has a step (either directly or as a subflow)
+ * @example
+ * ```ts
+ * includes(flow, 'step-path')
+ * includes(flow, anotherFlow)
+ * ```
+ */
+declare function includes(flow: StepPathOrFlow, step: StepPathOrFlow): boolean;
+/**
+ * Returns a function that checks if a step is before other step,
+ */
+declare function isBefore(other: StepPathOrFlow): (step: StepPathOrFlow) => boolean;
+/**
+ * Checks if a step is before another step
+ */
+declare function isBefore(step: StepPathOrFlow, other: StepPathOrFlow): boolean;
+declare const flowHelpers: {
+  unwindTry: (step: {
+    flow: DynamicViewFlow.SubFlow.Try["flow"];
+  }) => {
+    tryBlock: DynamicViewFlow.SubFlow.Try.Block;
+    catchBlock: DynamicViewFlow.SubFlow.Try.Catch | null;
+    finallyBlock: DynamicViewFlow.SubFlow.Try.Finally | null;
+  };
+  /**
+   * Returns first step in flow
+   */
+  firstStep: (anystepOrFlow: DynamicViewFlow.AnyStep | readonly DynamicViewFlow.AnyStep[]) => StepPath | null;
+  hasSteps: <F extends AnySubflow>(subflow: F) => boolean;
+  /**
+   * Returns steps of the subflow (excluding nested subflows) (non-recursive)
+   */
+  steps: (subflow: {
+    flow: IterableContainer<StepPath>;
+  }) => StepPath[];
+  /**
+   * Returns nested subflows (excluding steps) (non-recursive)
+   */
+  subflows: <N extends {
+    _type: string;
+  }>(subflow: {
+    flow: IterableContainer<StepPath | N>;
+  }) => N[];
+  /**
+   * Returns true if the subflow has nested subflows
+   */
+  hasSubflows: (subflow: {
+    flow: IterableContainer<StepPath | AnySubflow>;
+  }) => boolean;
+  isBefore: typeof isBefore;
+  includes: typeof includes;
+};
+/**
+ * Returns the ids of all ancestor subflows that enclose the given step path,
+ * ordered from the outermost flow to the innermost (closest) one.
+ *
+ * A {@link scalar.StepPath} is a `.`-joined chain of segments where every
+ * subflow segment carries a `NN:type` suffix (e.g. `02:opt`, `03:try`,
+ * `01:block`), while a plain step segment is just its number (`NN`). Every
+ * prefix that ends in such a `:`-bearing segment is therefore an ancestor flow.
+ *
+ * The path itself is never included — a flow is not its own ancestor — so
+ * passing a flow id returns only the flows above it.
+ *
+ * @example
+ * flowAncestors('step-01.02:opt.03:try.04' as StepPath)
+ * // => ['step-01.02:opt', 'step-01.02:opt.03:try']
+ */
+declare function flowAncestors(path: EdgeId$1 | StepPath): StepPath[];
+/**
+ * Returns the id of the immediate parent flow that directly encloses the given
+ * step path, or `null` when the path lives at the top level.
+ *
+ * The parent is the innermost of {@link flowAncestors} — the longest prefix that
+ * ends in a `:`-bearing subflow segment, excluding the path itself.
+ *
+ * @example
+ * parentFlow('step-02:opt.03:try.04' as StepPath) // => 'step-02:opt.03:try'
+ * parentFlow('step-02:opt.03:try' as StepPath)    // => 'step-02:opt'
+ * parentFlow('step-04' as StepPath)               // => null
+ */
+declare function parentFlow(path: EdgeId$1 | StepPath | undefined | null): StepPath | null;
+type StepCtx<V extends ProcessedDynamicView<any>, R = DynamicViewFlow.AnyStep> = {
+  readonly step: StepPath;
+  readonly edge: V['edges'][number];
+  readonly source: V['nodes'][number];
+  readonly target: V['nodes'][number];
+  readonly stepnum: {
+    /**
+     * Step number within current flow (1-based)
+     */
+    readonly index: number;
+    /**
+     * Global step number across all flows (1-based)
+     */
+    readonly global: number;
+  };
+  readonly level: number;
+  readonly parent: SubflowHookCtx | null;
+  readonly stopAndReturn: (step?: R | undefined) => never;
+};
+type SubflowHookCtx<T extends SubflowType = SubflowType, R = DynamicViewFlow.AnyStep> = {
+  readonly id: StepPath;
+  readonly type: T;
+  readonly subflow: Subflow<T>;
+  readonly previous: SubFlows[ParentOf<T>]['flow'][number] | null;
+  readonly parent: SubflowHookCtx<ParentOf<T>> | null;
+  readonly level: number;
+  readonly stopAndReturn: (step?: R | undefined) => never;
+};
+type OnLeave<T extends SubflowType = SubflowType> = (onleave: {
+  visited: Array<NestedOf<T>>;
+  lastVisited: NestedOf<T> | null;
+}) => void;
+type SubflowHookResult<T extends SubflowType = SubflowType> = {
+  /**
+   * Next subflow(s) to visit, or undefined to continue with the default behavior
+   *
+   * @example
+   * { next: 'step-02:opt.03:try' } // Single subflow
+   * { next: ['step-02:opt.03:try', 'step-02:opt.04:catch'] } // Multiple subflows
+   * { next: undefined } // Continue with default behavior
+   */
+  next?: undefined | NestedOf<T> | ArrayLike<NestedOf<T> | undefined>;
+  /**
+   * Callback function that is called when leaving the subflow
+   */
+  onLeave?: OnLeave<T>;
+};
+interface SubflowHook<T extends SubflowType = SubflowType, R = DynamicViewFlow.AnyStep> {
+  /**
+   * Callback function that is called on entry to each subflow.
+   *
+   * @param ctx - The context of the subflow
+   * @returns {true} - Continue walking
+   * @returns {void} - Continue walking
+   * @returns {false} - Stop walking
+   * @returns {OnLeave} - Continue walking with onLeave callback
+   * @returns {SubflowHookResult<T>} - Continue walking with custom configuration
+   */
+  (ctx: SubflowHookCtx<T, R>): boolean | void | OnLeave<T> | SubflowHookResult<T>;
+}
+type SubflowHookPerType<R> = Partial<Simplify<{ [K in SubflowType]: SubflowHook<K, R> | boolean; } & {
+  default: SubflowHook<SubflowType, R>;
+}>>;
+type WalkCallback<V extends ProcessedDynamicView<any>, R = DynamicViewFlow.AnyStep> = {
+  step?: (ctx: StepCtx<V, R>) => void;
+  subflow?: SubflowHook<SubflowType, R> | SubflowHookPerType<R>;
+};
+/**
+ * Walks through the dynamic view flow and calls the callback for each step and subflow.
+ * (Tree walker)
+ *
+ * @param view - The dynamic view to walk through
+ * @param callback - The callback to call for each step and subflow
+ *
+ * @example
+ * ```ts
+ * walkthroughFlow(view, {
+ *   step: ({step, stepnum}) => {
+ *     console.log(`Step ${stepnum.global}: ${step}`)
+ *   },
+ *   subflow: ({subflow}) => {
+ *     console.log(`Subflow ${subflow._type}: ${subflow.id}`)
+ *     return {
+ *       next: subflow.flow,
+ *       onLeave: () => {
+ *        console.log(`Left subflow ${subflow._type}`)
+ *       }
+ *     }
+ *   }
+ * })
+ * ```
+ */
+declare function walkthroughFlow<R extends DynamicViewFlow.AnyStep = DynamicViewFlow.AnyStep>(callback: WalkCallback<ProcessedDynamicView<any>, R>): (view: ProcessedDynamicView<any>) => R | undefined;
+declare function walkthroughFlow<V extends ProcessedDynamicView<any> = ProcessedDynamicView<any>, R extends DynamicViewFlow.AnyStep = DynamicViewFlow.AnyStep>(view: V, callback: WalkCallback<V, R>): R | undefined;
+declare namespace walkthroughFlow {
+  var onSubflows: {
+    <const T extends SubflowType & string, R = DynamicViewFlow.AnyStep>(types: T, callback: SubflowHook<NoInfer<T>, NoInfer<R>>): { [K in T]: SubflowHook<K, R>; };
+    <const T extends readonly [SubflowType, ...SubflowType[]], R = DynamicViewFlow.AnyStep>(types: T, callback: SubflowHook<NoInfer<T>[number], NoInfer<R>>): { [K in T[number]]: SubflowHook<K, R>; };
+  };
+}
+/**
+ * Creates a map of  hooks for the given subflow types.
+ * Each hook will be called when the corresponding subflow is entered.
+ * @example
+ * ```ts
+ * walkthrough({
+ *   view,
+ *   subflow: {
+ *     ...walkthrough.onSubflows(['try', 'alt'], ({subflow}) => {
+ *       //  ...
+ *       // subflow is typed
+ *     }),
+ *   },
+ * })
+ * ```
+ */
+declare function onSubflows<const T extends SubflowType & string, R = DynamicViewFlow.AnyStep>(types: T, callback: SubflowHook<NoInfer<T>, NoInfer<R>>): { [K in T]: SubflowHook<K, R>; };
+declare function onSubflows<const T extends readonly [SubflowType, ...SubflowType[]], R = DynamicViewFlow.AnyStep>(types: T, callback: SubflowHook<NoInfer<T>[number], NoInfer<R>>): { [K in T[number]]: SubflowHook<K, R>; };
+/**
+ * Creates a DynamicViewFlow instance from a dynamic view.
+ * This is a convenience function that wraps DynamicViewFlowOps.from().
+ */
+declare function dynamicViewFlow<V extends ProcessedDynamicView<any>>(view: V): DynamicViewFlow<V>;
+declare class DynamicViewFlow<V extends ProcessedDynamicView<any> = LayoutedDynamicView> {
+  private static cache;
+  static from<V extends ProcessedDynamicView<any>>(view: V): DynamicViewFlow<V>;
+  static readonly guards: {
+    isStepPath: typeof isStepPath;
+    isSubFlow: typeof isSubFlow;
+    isTry: (step: unknown) => step is DynamicViewFlow.SubFlow.Try;
+    isTryBlock: (step: unknown) => step is DynamicViewFlow.SubFlow.Try.Block;
+    isAlt: (step: unknown) => step is DynamicViewFlow.SubFlow.Alt;
+    isAltBranch: (step: unknown) => step is DynamicViewFlow.SubFlow.Alt.Branch;
+    isTryBranch: (step: unknown) => step is DynamicViewFlow.SubFlow.Try.Any;
+    isAltOrTry: (step: unknown) => step is DynamicViewFlow.SubFlow.Try | DynamicViewFlow.SubFlow.Alt;
+    isAltOrTryBranch: (step: unknown) => step is DynamicViewFlow.SubFlow.Try.Any | DynamicViewFlow.SubFlow.Alt.Branch;
+    type: {
+      isAltOrTry: (value: unknown) => value is "alt" | "try";
+      isAltBranch: (value: unknown) => value is DynamicViewFlow.SubFlow.Alt.Branch["_type"];
+      isTryBlock: (value: unknown) => value is "try-block";
+      isTryBranch: (value: unknown) => value is DynamicViewFlow.SubFlow.Try.Any["_type"];
+      isAltOrTryBranch: <V_1>(value: V_1) => value is Extract<V_1, `${"alt" | "try"}-${string}`>;
+    };
+  };
+  static readonly helpers: {
+    unwindTry: (step: {
+      flow: DynamicViewFlow.SubFlow.Try["flow"];
+    }) => {
+      tryBlock: DynamicViewFlow.SubFlow.Try.Block;
+      catchBlock: DynamicViewFlow.SubFlow.Try.Catch | null;
+      finallyBlock: DynamicViewFlow.SubFlow.Try.Finally | null;
+    };
+    /**
+     * Returns first step in flow
+     */
+    firstStep: (anystepOrFlow: DynamicViewFlow.AnyStep | readonly DynamicViewFlow.AnyStep[]) => StepPath | null;
+    hasSteps: <F extends AnySubflow>(subflow: F) => boolean;
+    /**
+     * Returns steps of the subflow (excluding nested subflows) (non-recursive)
+     */
+    steps: (subflow: {
+      flow: IterableContainer<StepPath>;
+    }) => StepPath[];
+    /**
+     * Returns nested subflows (excluding steps) (non-recursive)
+     */
+    subflows: <N extends {
+      _type: string;
+    }>(subflow: {
+      flow: IterableContainer<StepPath | N>;
+    }) => N[];
+    /**
+     * Returns true if the subflow has nested subflows
+     */
+    hasSubflows: (subflow: {
+      flow: IterableContainer<StepPath | AnySubflow>;
+    }) => boolean;
+    isBefore: typeof isBefore;
+    includes: typeof includes;
+  };
+  readonly unwindTry: (step: {
+    flow: DynamicViewFlow.SubFlow.Try["flow"];
+  }) => {
+    tryBlock: DynamicViewFlow.SubFlow.Try.Block;
+    catchBlock: DynamicViewFlow.SubFlow.Try.Catch | null;
+    finallyBlock: DynamicViewFlow.SubFlow.Try.Finally | null;
+  };
+  readonly isBefore: typeof isBefore;
+  readonly includes: typeof includes;
+  readonly onSubflows: typeof onSubflows;
+  readonly guards: {
+    isStepPath: typeof isStepPath;
+    isSubFlow: typeof isSubFlow;
+    isTry: (step: unknown) => step is DynamicViewFlow.SubFlow.Try;
+    isTryBlock: (step: unknown) => step is DynamicViewFlow.SubFlow.Try.Block;
+    isAlt: (step: unknown) => step is DynamicViewFlow.SubFlow.Alt;
+    isAltBranch: (step: unknown) => step is DynamicViewFlow.SubFlow.Alt.Branch;
+    isTryBranch: (step: unknown) => step is DynamicViewFlow.SubFlow.Try.Any;
+    isAltOrTry: (step: unknown) => step is DynamicViewFlow.SubFlow.Try | DynamicViewFlow.SubFlow.Alt;
+    isAltOrTryBranch: (step: unknown) => step is DynamicViewFlow.SubFlow.Try.Any | DynamicViewFlow.SubFlow.Alt.Branch;
+    type: {
+      isAltOrTry: (value: unknown) => value is "alt" | "try";
+      isAltBranch: (value: unknown) => value is DynamicViewFlow.SubFlow.Alt.Branch["_type"];
+      isTryBlock: (value: unknown) => value is "try-block";
+      isTryBranch: (value: unknown) => value is DynamicViewFlow.SubFlow.Try.Any["_type"];
+      isAltOrTryBranch: <V_1>(value: V_1) => value is Extract<V_1, `${"alt" | "try"}-${string}`>;
+    };
+  };
+  readonly helpers: {
+    unwindTry: (step: {
+      flow: DynamicViewFlow.SubFlow.Try["flow"];
+    }) => {
+      tryBlock: DynamicViewFlow.SubFlow.Try.Block;
+      catchBlock: DynamicViewFlow.SubFlow.Try.Catch | null;
+      finallyBlock: DynamicViewFlow.SubFlow.Try.Finally | null;
+    };
+    /**
+     * Returns first step in flow
+     */
+    firstStep: (anystepOrFlow: DynamicViewFlow.AnyStep | readonly DynamicViewFlow.AnyStep[]) => StepPath | null;
+    hasSteps: <F extends AnySubflow>(subflow: F) => boolean;
+    /**
+     * Returns steps of the subflow (excluding nested subflows) (non-recursive)
+     */
+    steps: (subflow: {
+      flow: IterableContainer<StepPath>;
+    }) => StepPath[];
+    /**
+     * Returns nested subflows (excluding steps) (non-recursive)
+     */
+    subflows: <N extends {
+      _type: string;
+    }>(subflow: {
+      flow: IterableContainer<StepPath | N>;
+    }) => N[];
+    /**
+     * Returns true if the subflow has nested subflows
+     */
+    hasSubflows: (subflow: {
+      flow: IterableContainer<StepPath | AnySubflow>;
+    }) => boolean;
+    isBefore: typeof isBefore;
+    includes: typeof includes;
+  };
+  /**
+   * View (flow is defined)
+   */
+  readonly view: V & {
+    flow: DynamicViewFlowData;
+  };
+  private levelById;
+  private byId;
+  readonly stepsCount: number;
+  private constructor();
+  /**
+   * Returns all known step paths in the flow
+   */
+  get paths(): readonly StepPath[];
+  /**
+   * Returns level in hierarchy (for z-indexes)
+   */
+  level(step: StepPath | {
+    id: StepPath;
+  }): number;
+  /**
+   * Returns the parent subflow of the given step path, or undefined if the step is not nested.
+   * @param step The step path to find the parent for.
+   * @returns The parent subflow, or undefined if the step is not nested.
+   */
+  parent<N extends AnySubflow>(subflow: N): Subflow<ParentOf<N['_type']>> | undefined;
+  parent(step: StepPath | EdgeId$1 | {
+    id: StepPath;
+  }): DynamicViewFlow.SubFlow.Any | undefined;
+  /**
+   * Returns very first step in dynamic view
+   */
+  firstStep(): StepPath;
+  /**
+   * Returns very first step in subflow
+   */
+  firstStep(subflow: StepPath | {
+    id: StepPath;
+  }): StepPath | null;
+  /**
+   * Checks if the given path is a step (i.e `A -> B>)
+   */
+  isStep(path: StepPath): boolean;
+  /**
+   * Checks if the given path is a flow
+   */
+  isSubflow(path: StepPath): boolean;
+  /**
+   * Returns top level steps
+   */
+  steps(): readonly StepPath[];
+  /**
+   * Returns steps in subflow
+   */
+  steps(subflow: StepPath | {
+    id: StepPath;
+  }): readonly StepPath[];
+  /**
+   * Returns previous and next steps for the given step
+   * (only steps are considered, subflows are excluded)
+   */
+  prevAndNext(targetStep: StepPath, skipFlow?: (flowId: StepPath) => boolean): {
+    prev: StepPath | null;
+    next: StepPath | null;
+  };
+  /**
+   * Lookup a subflow by its path.
+   * @param id The path of the subflow to lookup.
+   * @param assertType Optional type to assert the subflow type. If provided, throws if the subflow is not of the given type.
+   * @returns The subflow with the given path, or throws if not found.
+   */
+  lookup<T extends SubflowType = SubflowType>(id: StepPath, assertType?: T): DynamicViewFlow.SubFlow.Of<T>;
+  /**
+   * Returns top level subflows in the view
+   */
+  subflows(): DynamicViewFlow.SubFlow[];
+  /**
+   * Returns nested subflows of a given subflow.
+   * @param id The path of the subflow to lookup.
+   * @returns The subflow with the given path, or throws if not found.
+   */
+  subflows<N extends AnySubflow>(subflow: N): NestedOf<N['_type']>[];
+  subflows(id: StepPath): DynamicViewFlow.SubFlow.Any[];
+  /**
+   * Checks if has nested subflows
+   */
+  hasSubflows(check: AnySubflow | StepPath): boolean;
+  /**
+   * @see Sequence Layout
+   */
+  walk<R extends DynamicViewFlow.AnyStep = DynamicViewFlow.AnyStep>(callback: WalkCallback<V, R>): R | undefined;
+  /**
+   * Returns all steps that come before the given step in the flow.
+   * @param step The step to find predecessors for.
+   * @returns An array of step paths that come before the given step.
+   */
+  stepsBefore(step: StepPath): DynamicViewFlow.AnyStep[];
+  /**
+   * Returns all step paths that come before the given step in the flow.
+   * @param step The step to find predecessors for.
+   * @returns An array of step paths that come before the given step.
+   */
+  stepPathsBefore(step: StepPath): StepPath[];
+}
+/**
+ * Returns all steps that come before the given step in the flow.
+ */
+declare function stepsBefore(view: ProcessedDynamicView<any>, _step: StepPath): DynamicViewFlow.AnyStep[];
+//#endregion
+//#region src/types/view-computed.d.ts
+type ComputedNodeStyle = Simplify<ElementStyle & {
+  icon?: never;
+  shape?: never;
+  color?: never;
+}>;
+interface ComputedNode<A extends Any = Any> extends WithTags<A>, WithOptionalLinks {
+  /**
+   * Element metadata, propagated from the model.
+   * Uses a loose record type (instead of aux.WithMetadata<A>) to avoid
+   * exactOptionalPropertyTypes conflicts when MetadataKey is a literal union.
+   */
+  readonly metadata?: Readonly<Record<string, string | string[] | undefined>> | null;
+  id: NodeId$1;
+  kind: ElementKind<A> | DeploymentKind<A> | '@group';
+  parent: NodeId$1 | null;
+  /**
+   * Reference to model element
+   */
+  modelRef?: Fqn<A>;
+  /**
+   * Reference to deployment element
+   */
+  deploymentRef?: DeploymentFqn<A>;
+  title: string;
+  /**
+   * Description of the node
+   * either summary or description
+   */
+  description?: MarkdownOrString | null;
+  technology?: string | null;
+  children: NodeId$1[];
+  inEdges: EdgeId$1[];
+  outEdges: EdgeId$1[];
+  shape: ElementShape;
+  color: Color;
+  icon?: Icon | null;
+  style: ComputedNodeStyle;
+  navigateTo?: StrictViewId<A> | null;
+  level: number;
+  depth?: number | null;
+  /**
+   * If this node was customized in the view
+   */
+  isCustomized?: boolean;
+  notation?: string | null;
+  notes?: MarkdownOrString | undefined;
+}
+interface ComputedEdge<A extends Any = Any> extends WithOptionalTags<A> {
+  id: EdgeId$1;
+  parent: NodeId$1 | null;
+  source: NodeId$1;
+  target: NodeId$1;
+  label: string | null;
+  description?: MarkdownOrString | null;
+  technology?: string | null;
+  relations: RelationId$1[];
+  kind?: RelationKind<A> | typeof StepEdgeKind;
+  notation?: string;
+  notes?: MarkdownOrString;
+  color: Color;
+  line: RelationshipLineType;
+  head?: RelationshipArrowType;
+  tail?: RelationshipArrowType;
+  navigateTo?: StrictViewId<A> | null;
+  /**
+   * If this edge is derived from custom relationship predicate
+   */
+  isCustomized?: boolean;
+  /**
+   * Path to the AST node relative to the view body ast
+   * Available only in dynamic views
+   * @internal
+   */
+  astPath?: string;
+  /**
+   * For layouting purposes
+   * @default 'forward'
+   */
+  dir?: 'forward' | 'back' | 'both';
+}
+interface ComputedRankConstraint {
+  type: RankValue;
+  nodes: NodeId$1[];
+}
+interface BaseComputedViewProperties<A extends Any> extends BaseViewProperties<A>, ViewWithHash, ViewWithNotation {
+  readonly [_stage]: 'computed';
+  readonly autoLayout: ViewAutoLayout;
+  readonly nodes: ReadonlyArray<ComputedNode<A>>;
+  readonly edges: ReadonlyArray<ComputedEdge<A>>;
+  /**
+   * If the view has manual layout (v2)
+   */
+  readonly hasManualLayout?: boolean;
+}
+interface ComputedElementView<A extends Any = Any> extends BaseComputedViewProperties<A> {
+  readonly [_type]: 'element';
+  readonly viewOf?: Fqn<A>;
+  readonly extends?: StrictViewId<A>;
+  readonly ranks?: ComputedRankConstraint[];
+}
+interface ComputedDeploymentView<A extends Any = Any> extends BaseComputedViewProperties<A> {
+  readonly [_type]: 'deployment';
+}
+interface ComputedDynamicView<A extends Any = Any> extends BaseComputedViewProperties<A> {
+  readonly [_type]: 'dynamic';
+  /**
+   * How to display the dynamic view
+   * - `diagram`: display as a regular likec4 view
+   * - `sequence`: display as a sequence diagram
+   */
+  readonly variant: DynamicViewDisplayVariant;
+  /**
+   * Represents the complete flow structure for dynamic views, as a sequence of steps.
+   * Can include nested flows, branches, loops, and conditional statements.
+   */
+  readonly flow: DynamicViewFlowSteps;
+}
+//#endregion
 //#region src/types/view-parsed.deployment.d.ts
 /**
  * Predicates scoped to deployment model
@@ -1760,7 +2492,7 @@ type DeploymentViewRule<A extends Any = Unknown> = ExclusiveUnion<{
   AutoLayout: ViewRuleAutoLayout;
   IncludeAncestors: ParsedViewRuleAncestors;
 }>;
-interface ParsedViewRuleAncestors<A extends Any = Unknown> {
+interface ParsedViewRuleAncestors {
   /**
    * When true, ancestor elements of included deployment nodes are also included in the view.
    * @default false (ancestors are not included)
@@ -1777,13 +2509,15 @@ type ParsedView<A extends Any = Any> = ParsedElementView<A> | ParsedDeploymentVi
 type ComputedView<A extends Any = Any> = ComputedElementView<A> | ComputedDeploymentView<A> | ComputedDynamicView<A>;
 type LayoutedView<A extends Any = Any> = LayoutedElementView<A> | LayoutedDeploymentView<A> | LayoutedDynamicView<A>;
 type ProcessedView<A extends Any = Any> = ComputedView<A> | LayoutedView<A>;
+type ProcessedDynamicView<A extends Any = Any> = ComputedDynamicView<A> | LayoutedDynamicView<A>;
 type AnyView<A extends Any = Any> = ParsedElementView<A> | ParsedDeploymentView<A> | ParsedDynamicView<A> | ComputedElementView<A> | ComputedDeploymentView<A> | ComputedDynamicView<A> | LayoutedElementView<A> | LayoutedDeploymentView<A> | LayoutedDynamicView<A>;
 type ViewOnStage<V extends AnyView<Any>, T extends ModelStage> = Extract<V, {
   [_stage]: T;
 }>;
-type ViewWithType<V extends AnyView<Any>, T extends ViewType> = Extract<V, {
+type ViewWithType<V extends AnyView<any>, T extends ViewType> = Extract<V, {
   [_type]: T;
 }>;
+type InferViewAux<V> = V extends AnyView<infer A extends Any> ? Or<IsAny<A>, IsNever<A>> extends true ? never : A : never;
 type ViewRule<A extends Any = Any> = ParsedView<A>['rules'][number];
 type ViewRulePredicate<A extends Any = Any> = Extract<ViewRule<A>, {
   include: any[];
@@ -1834,7 +2568,7 @@ interface BaseLikeC4ModelData<A extends Any> {
   globals: ModelGlobals;
   imports: Record<string, NonEmptyArray<Element<A>>>;
 }
-type AuxFromLikeC4ModelData<D> = D extends BaseLikeC4ModelData<infer A extends Any> ? IsAny<A> extends true ? never : A : never;
+type AuxFromLikeC4ModelData<D> = D extends BaseLikeC4ModelData<infer A extends Any> ? IsAnyOrNever<A> extends true ? never : A : never;
 interface ParsedLikeC4ModelData<A extends AnyParsed = UnknownParsed> extends BaseLikeC4ModelData<A> {
   [_stage]: 'parsed';
   views: Record<ViewId<A>, ParsedView<A>>;
@@ -1913,7 +2647,7 @@ type ProjectDump = {
   name?: string;
   title?: string | undefined;
 };
-type AuxFromDump<D> = D extends LikeC4ModelDump ? Aux<D[_stage] extends infer S extends 'computed' | 'layouted' ? S : 'computed' | 'layouted' | 'parsed', KeysOf<D['elements']>, KeysOf<D['deployments']['elements']>, KeysOf<D['views']>, D['projectId'] extends infer PID extends string ? PID : never, SpecTypesFromDump<D['specification']>> : Never;
+type AuxFromDump<D> = D extends LikeC4ModelDump ? Aux<D[_stage] extends (infer S extends 'computed' | 'layouted') ? S : 'computed' | 'layouted' | 'parsed', KeysOf<D['elements']>, KeysOf<D['deployments']['elements']>, KeysOf<D['views']>, D['projectId'] extends (infer PID extends string) ? PID : never, SpecTypesFromDump<D['specification']>> : Never;
 //#endregion
 //#region src/types/view-changes.d.ts
 declare namespace ViewChange {
@@ -2062,7 +2796,7 @@ type Guard<To = unknown> = (value: any) => value is To;
  * GuardedBy<typeof isString>; // string
  * ```
  */
-type GuardedBy<G> = G extends Guard<infer To> ? Or<IsAny<To>, IsUnknown<To>> extends true ? never : To : never;
+type GuardedBy<G extends Function> = G extends Guard<infer To> ? Or<IsAny<To>, IsUnknown<To>> extends true ? never : To : never;
 /**
  * Creates a type guard that checks if a value matches any of the provided predicates.
  *
@@ -2081,5 +2815,10 @@ type GuardedBy<G> = G extends Guard<infer To> ? Or<IsAny<To>, IsUnknown<To>> ext
  * ```
  */
 declare function isAnyOf<const Predicates extends NonEmptyArray<Guard<any>>>(...predicates: Predicates): <T>(value: T) => value is T & GuardedBy<Predicates[number]>;
+declare function hasChildren<C, A extends {
+  children: C[];
+}>(value: A): value is A & {
+  children: NonEmptyArray<C>;
+};
 //#endregion
-export { DiagramNodeDriftReason as $, Coalesce as $i, isTagEqual as $n, RelationId as $r, ElementViewIncludePredicate as $t, isComputedView as A, ProjectId$1 as Ai, ModelRelationExpr as An, IconPositions as Ar, ElementStyle as At, DeploymentViewIncludePredicate as B, flattenMarkdownOrString as Bi, NotOperator as Bn, DeploymentKind as Br, DynamicStep as Bt, LayoutedView as C, GlobalFqn as Ci, ViewWithNotation as Cn, ThemeColor as Cr, DeploymentNode as Ct, ViewRule as D, MarkdownOrString as Di, isViewRuleGlobalStyle as Dn, BorderStyles as Dr, isDeploymentNode as Dt, ViewOnStage as E, IconUrl as Ei, isViewRuleGlobalPredicateRef as En, isThemeColor as Er, isDeployedInstance as Et, isExtendsElementView as F, StepEdgeIdLiteral as Fi, AndOperator as Fn, AnyLayouted as Fr, GlobalPredicateId as Ft, ParsedViewRuleAncestors as G, splitGlobalFqn as Gi, TagEqual as Gn, LooseDeploymentId as Gr, DynamicViewRule as Gt, DeploymentViewRule as H, isGroupElementKind as Hi, OrOperator as Hn, ElementId as Hr, DynamicStepsSeries as Ht, isScopedElementView as I, StepEdgeKind as Ii, EqualOperator as In, AnyParsed as Ir, GlobalPredicates as It, LayoutType as J, ModelStage as Ji, isKindEqual as Jn, LooseTag as Jr, getParallelStepsPrefix as Jt, DiagramEdge as K, stepEdgeId as Ki, WhereOperator as Kn, LooseElementId as Kr, DynamicViewStep as Kt, isViewRulePredicate as L, Tag$1 as Li, Filterable as Ln, Aux as Lr, GlobalStyleID as Lt, isDiagramView as M, RelationKind$1 as Mi, FqnExpr as Mn, ThemeColors as Mr, Relationship as Mt, isDynamicView as N, RelationshipKind as Ni, PredicateSelector as Nn, Any as Nr, ensureSizes as Nt, ViewRulePredicate as O, NodeId$1 as Oi, ModelExpression as On, DefaultTagColors as Or, AbstractRelationship as Ot, isElementView as P, StepEdgeId as Pi, RelationExpr as Pn, AnyComputed as Pr, GlobalDynamicPredicates as Pt, DiagramEdgeDriftReason as Q, isOnStage as Qi, isParticipantOperator as Qn, ProjectId as Qr, ElementViewExcludePredicate as Qt, isViewRuleStyle as R, ViewId$1 as Ri, KindEqual as Rn, DeploymentFqn as Rr, GlobalStyles as Rt, ComputedView as S, Fqn$1 as Si, ViewWithHash as Sn, TextSize as Sr, DeploymentElementRef$1 as St, ProcessedView as T, Icon as Ti, isViewRuleAutoLayout as Tn, isCustomColor as Tr, DeploymentRelationship as Tt, DeploymentViewRuleStyle as U, isStepEdgeId as Ui, Participant as Un, ElementKind as Ur, DynamicViewDisplayVariant as Ut, DeploymentViewPredicate as V, isGlobalFqn as Vi, OperatorPredicate as Vn, EdgeId as Vr, DynamicStepsParallel as Vt, ParsedDeploymentView as W, scalar_d_exports as Wi, ParticipantOperator as Wn, Fqn as Wr, DynamicViewIncludeRule as Wt, LayoutedDynamicView as X, _stage as Xi, isNotOperator as Xn, Metadata as Xr, isDynamicStepsParallel as Xt, LayoutedDeploymentView as Y, _layout as Yi, isMetadataEqual as Yn, LooseViewId as Yr, isDynamicStep as Yt, LayoutedElementView as Z, _type as Zi, isOrOperator as Zn, MetadataKey as Zr, isDynamicStepsSeries as Zt, ComputedLikeC4ModelData as _, BuiltInIcon as _i, ViewRuleAutoLayout as _n, RelationshipColorValues as _r, Specification as _t, isNonEmptyArray as a, NTuple as aa, Tags as ai, ParsedElementView as an, CustomColor as ar, ComputedElementView as at, ParsedLikeC4ModelData as b, EdgeId$1 as bi, ViewRuleRank as bn, Size as br, DeployedInstance as bt, RichTextEmpty as c, Predicate as ca, UnknownLayouted as ci, AnyExcludePredicate as cn, ElementShape as cr, ComputedRankConstraint as ct, AuxFromDump as d, _aux_d_exports as di, AutoLayoutDirection as dn, IconSize as dr, LikeC4ProjectStyleDefaults as dt, ExclusiveUnion as ea, RelationKind as ei, ElementViewPredicate as en, whereOperatorAsPredicate as er, LayoutedViewDriftReason as et, LikeC4ModelDump as f, preferDescription as fi, BaseParsedViewProperties as fn, LikeC4StyleDefaults as fr, LikeC4ProjectStylesConfig as ft, AuxFromLikeC4ModelData as g, AnyFqn as gi, ViewAutoLayout as gn, RelationshipArrowTypes as gr, RelationshipSpecification as gt, SpecificationDump as h, toComputed as hi, RankValue as hn, RelationshipArrowType as hr, ElementSpecification as ht, isAnyOf as i, Link as ia, Tag as ii, ElementViewRuleStyle as in, ColorLiteral as ir, ComputedEdge as it, isDeploymentView as j, RelationId$1 as ji, Expression as jn, Sizes as jr, ModelRelation as jt, ViewWithType as k, NoneIcon as ki, ModelFqnExpr as kn, ElementShapes as kr, Element as kt, RichTextOrEmpty as l, ReorderedArray as la, UnknownParsed as li, AnyIncludePredicate as ln, HexColor as lr, LikeC4Project as lt, SpecTypesFromDump as m, setProject as mi, NodeNotation as mn, LikeC4Theme as mr, LikeC4ProjectTheme as mt, GuardedBy as n, IteratorLike as na, Stage as ni, ElementViewRuleGroup as nn, BorderStyle as nr, ComputedDeploymentView as nt, isString as o, NonEmptyArray as oa, Unknown as oi, isViewRuleGroup as on, CustomColorDefinitions as or, ComputedNode as ot, ProjectDump as p, preferSummary as pi, BaseViewProperties as pn, LikeC4StylesConfig as pr, LikeC4ProjectStylesCustomStylesheets as pt, DiagramNode as q, ExtractOnStage as qi, isAndOperator as qn, LooseLiteral as qr, ParsedDynamicView as qt, hasProp as r, KeysOf as ra, StrictViewId as ri, ElementViewRuleRank as rn, Color as rr, ComputedDynamicView as rt, RichText as s, NonEmptyReadonlyArray as sa, UnknownComputed as si, isViewRuleRank as sn, ElementColorValues as sr, ComputedNodeStyle as st, Guard as t, IterableContainer as ta, SpecAux as ti, ElementViewRule as tn, FqnRef as tr, ViewManualLayoutSnapshot as tt, ViewChange as u, exact as ua, ViewId as ui, AnyViewRuleStyle as un, IconPosition as ur, LikeC4ProjectManualLayoutsConfig as ut, LayoutedLikeC4ModelData as v, DeploymentFqn$1 as vi, ViewRuleGlobalPredicateRef as vn, RelationshipLineType as vr, TagSpecification as vt, ParsedView as w, GroupElementKind as wi, isAutoLayoutDirection as wn, ThemeColorValues as wr, DeploymentRelation as wt, AnyView as x, ElementKind$1 as xi, ViewType as xn, SpacingSize as xr, DeploymentElement as xt, LikeC4ModelData as y, DeploymentKind$1 as yi, ViewRuleGlobalStyle as yn, ShapeSize as yr, isTagColorSpecified as yt, DeploymentViewExcludePredicate as z, extractStep as zi, MetadataEqual as zn, DeploymentId as zr, ModelGlobals as zt };
+export { ComputedNode as $, isStepPath as $i, OrOperator as $n, EdgeId as $r, GlobalStyles as $t, ViewRule as A, DeploymentFqn$1 as Ai, ViewRuleGlobalStyle as An, RelationshipLineTypes as Ar, ElementSpecification as At, isViewRulePredicate as B, NodeId$1 as Bi, ModelFqnExpr as Bn, DefaultTagColors as Br, DeploymentRelationship as Bt, ComputedView as C, ReorderedArray as Ca, _aux_d_exports as Ci, BaseParsedViewProperties as Cn, LikeC4StyleDefaults as Cr, ViewManualLayoutSnapshot as Ct, ProcessedDynamicView as D, toComputed as Di, ViewAutoLayout as Dn, RelationshipArrowTypes as Dr, LikeC4ProjectStylesConfig as Dt, ParsedView as E, setProject as Ei, RankValue as En, RelationshipArrowType as Er, LikeC4ProjectStyleDefaults as Et, isDiagramView as F, GlobalFqn as Fi, isAutoLayoutDirection as Fn, ThemeColor as Fr, DeployedInstance as Ft, DeploymentViewRule as G, RelationshipKind as Gi, RelationExpr as Gn, Any as Gr, ElementStyle as Gt, DeploymentViewExcludePredicate as H, ProjectId$1 as Hi, Expression as Hn, IconPositions as Hr, isDeploymentNode as Ht, isDynamicView as I, GroupElementKind as Ii, isViewRuleAutoLayout as In, ThemeColorValues as Ir, DeploymentElement as It, ParsedViewRuleAncestors as J, Tag$1 as Ji, Filterable as Jn, AnyParsed as Jr, ensureSizes as Jt, DeploymentViewRuleStyle as K, StepEdgeKind as Ki, AndOperator as Kn, AnyComputed as Kr, ModelRelation as Kt, isElementView as L, Icon as Li, isViewRuleGlobalPredicateRef as Ln, isCustomColor as Lr, DeploymentElementRef$1 as Lt, ViewWithType as M, EdgeId$1 as Mi, ViewType as Mn, Size as Mr, Specification as Mt, isComputedView as N, ElementKind$1 as Ni, ViewWithHash as Nn, SpacingSize as Nr, TagSpecification as Nt, ProcessedView as O, AnyFqn as Oi, ViewRuleAutoLayout as On, RelationshipColorValues as Or, LikeC4ProjectStylesCustomStylesheets as Ot, isDeploymentView as P, Fqn$1 as Pi, ViewWithNotation as Pn, TextSize as Pr, isTagColorSpecified as Pt, ComputedElementView as Q, isGroupElementKind as Qi, OperatorPredicate as Qn, DeploymentKind as Qr, GlobalStyleID as Qt, isExtendsElementView as R, IconUrl as Ri, isViewRuleGlobalStyle as Rn, isThemeColor as Rr, DeploymentNode as Rt, AnyView as S, Predicate as Sa, ViewId as Si, AutoLayoutDirection as Sn, IconSize as Sr, LayoutedViewDriftReason as St, LayoutedView as T, preferSummary as Ti, NodeNotation as Tn, LikeC4Theme as Tr, LikeC4ProjectManualLayoutsConfig as Tt, DeploymentViewIncludePredicate as U, RelationId$1 as Ui, FqnExpr as Un, Sizes as Ur, AbstractRelationship as Ut, isViewRuleStyle as V, NoneIcon as Vi, ModelRelationExpr as Vn, ElementShapes as Vr, isDeployedInstance as Vt, DeploymentViewPredicate as W, RelationKind$1 as Wi, PredicateSelector as Wn, ThemeColors as Wr, Element as Wt, ComputedDynamicView as X, flattenMarkdownOrString as Xi, MetadataEqual as Xn, DeploymentFqn as Xr, GlobalPredicateId as Xt, ComputedDeploymentView as Y, ViewId$1 as Yi, KindEqual as Yn, Aux as Yr, GlobalDynamicPredicates as Yt, ComputedEdge as Z, isGlobalFqn as Zi, NotOperator as Zn, DeploymentId as Zr, GlobalPredicates as Zt, AuxFromLikeC4ModelData as _, Link as _a, Tags as _i, isViewRuleGroup as _n, CustomColorDefinitions as _r, LayoutedDeploymentView as _t, isAnyOf as a, _stage as aa, LooseLiteral as ai, ParsedDynamicView as an, isKindEqual as ar, DynamicViewFlowSteps as at, LikeC4ModelData as b, NonEmptyReadonlyArray as ba, UnknownLayouted as bi, AnyIncludePredicate as bn, HexColor as br, DiagramEdgeDriftReason as bt, RichText as c, inferStage as ca, Metadata as ci, stepGuards as cn, isOrOperator as cr, flowAncestors as ct, ViewChange as d, Coalesce as da, RelationId as di, ElementViewPredicate as dn, whereOperatorAsPredicate as dr, parentFlow as dt, scalar_d_exports as ea, ElementId as ei, ModelGlobals as en, Participant as er, ComputedNodeStyle as et, AuxFromDump as f, ExclusiveUnion as fa, RelationKind as fi, ElementViewRule as fn, FqnRef as fr, stepsBefore as ft, SpecificationDump as g, KeysOf as ga, Tag as gi, ParsedElementView as gn, CustomColor as gr, LayoutType as gt, SpecTypesFromDump as h, IteratorLike as ha, StrictViewId as hi, ElementViewRuleStyle as hn, ColorLiteral as hr, DiagramNode as ht, hasProp as i, _layout as ia, LooseElementId as ii, DynamicViewRule as in, isAndOperator as ir, DynamicViewFlowStep as it, ViewRulePredicate as j, DeploymentKind$1 as ji, ViewRuleRank as jn, ShapeSize as jr, RelationshipSpecification as jt, ViewOnStage as k, BuiltInIcon as ki, ViewRuleGlobalPredicateRef as kn, RelationshipLineType as kr, LikeC4ProjectTheme as kt, RichTextEmpty as l, inferType as la, MetadataKey as li, ElementViewExcludePredicate as ln, isParticipantOperator as lr, flowGuards as lt, ProjectDump as m, IterableContainer as ma, Stage as mi, ElementViewRuleRank as mn, Color as mr, DiagramEdge as mt, GuardedBy as n, ExtractOnStage as na, Fqn as ni, DynamicViewDisplayVariant as nn, TagEqual as nr, DynamicViewFlow as nt, isNonEmptyArray as o, _type as oa, LooseTag as oi, Step$1 as on, isMetadataEqual as or, DynamicViewSubFlow as ot, LikeC4ModelDump as p, IsAnyOrNever as pa, SpecAux as pi, ElementViewRuleGroup as pn, BorderStyle as pr, walkthroughFlow as pt, ParsedDeploymentView as q, StepPath as qi, EqualOperator as qn, AnyLayouted as qr, Relationship as qt, hasChildren as r, ModelStage as ra, LooseDeploymentId as ri, DynamicViewIncludeRule as rn, WhereOperator as rr, DynamicViewFlowData as rt, isString as s, _v as sa, LooseViewId as si, WithSteps as sn, isNotOperator as sr, dynamicViewFlow as st, Guard as t, splitGlobalFqn as ta, ElementKind as ti, AnyStep as tn, ParticipantOperator as tr, ComputedRankConstraint as tt, RichTextOrEmpty as u, isOnStage as ua, ProjectId as ui, ElementViewIncludePredicate as un, isTagEqual as ur, flowHelpers as ut, ComputedLikeC4ModelData as v, NTuple as va, Unknown as vi, isViewRuleRank as vn, ElementColorValues as vr, LayoutedDynamicView as vt, InferViewAux as w, exact as wa, preferDescription as wi, BaseViewProperties as wn, LikeC4StylesConfig as wr, LikeC4Project as wt, ParsedLikeC4ModelData as x, OrString as xa, UnknownParsed as xi, AnyViewRuleStyle as xn, IconPosition as xr, DiagramNodeDriftReason as xt, LayoutedLikeC4ModelData as y, NonEmptyArray as ya, UnknownComputed as yi, AnyExcludePredicate as yn, ElementShape as yr, LayoutedElementView as yt, isScopedElementView as z, MarkdownOrString as zi, ModelExpression as zn, BorderStyles as zr, DeploymentRelation as zt };