@likec4/core 1.57.0 → 1.59.0

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

@@ -1,7 +1,7 @@
-import { An as ModelRelationExpr, Cr as ThemeColor, Di as MarkdownOrString, Lr as Aux, Nr as Any, Si as Fqn, Sr as TextSize, Tt as DeploymentRelationship, Un as Participant, W as ParsedDeploymentView, an as ParsedElementView, b as ParsedLikeC4ModelData, cr as ElementShape, dn as AutoLayoutDirection, ft as LikeC4ProjectStylesConfig, gt as RelationshipSpecification, hr as RelationshipArrowType, ht as ElementSpecification$1, jn as Expression, jt as ModelRelation, kn as ModelFqnExpr, kt as Element, mi as setProject, nr as BorderStyle, oa as NonEmptyArray, ra as KeysOf, ti as SpecAux, un as AnyViewRuleStyle, ur as IconPosition, vi as DeploymentFqn, vr as RelationshipLineType, vt as TagSpecification, w as ParsedView, xr as SpacingSize, xt as DeploymentElement, yr as ShapeSize } from "./index.mjs";
+import { r as __name } from "./rolldown-runtime.mjs";
+import { Ai as DeploymentFqn, At as ElementSpecification$1, Bn as ModelFqnExpr, Bt as DeploymentRelationship, Dt as LikeC4ProjectStylesConfig, E as ParsedView, Ei as setProject, Er as RelationshipArrowType, Fr as ThemeColor, Gr as Any, Hn as Expression, It as DeploymentElement, Kt as ModelRelation, Nr as SpacingSize, Nt as TagSpecification, Pi as Fqn, Pr as TextSize, Sn as AutoLayoutDirection, Vn as ModelRelationExpr, Wt as Element$1, Yr as Aux, an as ParsedDynamicView, er as Participant, ga as KeysOf, gn as ParsedElementView, jr as ShapeSize, jt as RelationshipSpecification, kr as RelationshipLineType, on as Step, pi as SpecAux, pr as BorderStyle, q as ParsedDeploymentView, x as ParsedLikeC4ModelData, xn as AnyViewRuleStyle, xr as IconPosition, ya as NonEmptyArray, yr as ElementShape, zi as MarkdownOrString } from "./index.mjs";
 import { n as LikeC4Model } from "./LikeC4Model.mjs";
 import { IfNever, IsLiteral, IsNever, LastArrayElement, PartialDeep, Simplify, Split, Tagged, TupleToUnion, Writable } from "type-fest";
-
 //#region src/builder/Builder.deployment.d.ts
 type ToNested$1<T, Id extends string> = T extends TypesNested<infer P, any, any, any, any, any, any, any, infer F> ? TypesNested<`${P}.${Id}`, T['ElementKind'], T['Fqn'], T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey'], T['DeploymentKind'], `${P}.${Id}` | F> : T extends AnyTypes ? TypesNested<Id, T['ElementKind'], T['Fqn'], T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey'], T['DeploymentKind'], Id | T['DeploymentFqn']> : never;
 type FromNested$1<T extends AnyTypes, N> = N extends TypesNested<any, any, any, any, any, any, any, any, infer F> ? T extends TypesNested<infer P, any, any, any, any, any, any, any, any> ? TypesNested<P, T['ElementKind'], T['Fqn'], T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey'], T['DeploymentKind'], F> : T extends AnyTypes ? Types<T['ElementKind'], T['Fqn'], T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey'], T['DeploymentKind'], F> : never : never;
@@ -110,7 +110,7 @@ type AddDeploymentNodeHelper<T = unknown> =
  *  )
  */
 <const Id extends string>(id: ValidId<Id>, titleOrProps?: string | T) => AddDeploymentNode<Id>;
-type AddDeploymentNodeHelpers<T extends AnyTypes> = T extends Types<any, any, any, any, any, any, infer Kinds extends string, any> ? { [Kind in Kinds]: AddDeploymentNodeHelper<T['NewDeploymentNodeProps']> } : Invalid<'No Deployment Kinds'>;
+type AddDeploymentNodeHelpers<T extends AnyTypes> = T extends Types<any, any, any, any, any, any, infer Kinds extends string, any> ? { [Kind in Kinds]: AddDeploymentNodeHelper<T['NewDeploymentNodeProps']>; } : Invalid<'No Deployment Kinds'>;
 type AddDeploymentRelation<Props = unknown> =
 /**
  * @example
@@ -174,7 +174,7 @@ interface AddElement<Id extends string> {
 //#endregion
 //#region src/builder/Builder.model.d.ts
 interface ModelBuilder<T extends AnyTypes> extends Builder<T> {
-  __addElement(this: void, element: Element): Builder<T>;
+  __addElement(this: void, element: Element$1): Builder<T>;
   __addRelation(this: void, relation: Omit<ModelRelation, 'id'>): Builder<T>;
   /**
    * Create a fully qualified name from an id (for nested models)
@@ -252,7 +252,7 @@ type AddElementHelper<T = unknown> =
  * ```
  */
 <const Id extends string>(id: ValidId<Id>, titleOrProps?: string | T) => AddElement<Id>;
-type AddElementHelpers<T extends AnyTypes> = T extends Types<infer Kinds extends string, any, any, any, any, any, any, any> ? { [Kind in Kinds]: AddElementHelper<T['NewElementProps']> } : Invalid<'No Element Kinds'>;
+type AddElementHelpers<T extends AnyTypes> = T extends Types<infer Kinds extends string, any, any, any, any, any, any, any> ? { [Kind in Kinds]: AddElementHelper<T['NewElementProps']>; } : Invalid<'No Element Kinds'>;
 type ModelHelpers<T extends AnyTypes> = AddElementHelpers<T> & {
   model: typeof model;
   rel: RelationshipHelper<T['NewRelationshipProps']>;
@@ -264,6 +264,7 @@ type ModelBuilderFunction<A extends AnyTypes, B extends AnyTypes> = (helpers: Mo
 //#endregion
 //#region src/builder/Builder.view-common.d.ts
 interface LikeC4ViewBuilder<Types extends AnyTypes, Fqn extends string, TypedExpr, ElementExpr extends string = ViewPredicate.ElementExpr<Fqn>, Expr extends string = ViewPredicate.AllExpression<ElementExpr>> {
+  Fqn: Fqn;
   Types: Types;
   ElementExpr: ElementExpr;
   Expr: Expr;
@@ -272,6 +273,7 @@ interface LikeC4ViewBuilder<Types extends AnyTypes, Fqn extends string, TypedExp
   include(...exprs: TypedExpr[]): this;
   exclude(...exprs: TypedExpr[]): this;
   style(rule: AnyViewRuleStyle<any>): this;
+  step(step: Omit<Step.Any, 'id'>): this;
   autoLayout(layout: AutoLayoutDirection, margins: {
     rank: number;
     node: number;
@@ -304,12 +306,15 @@ declare namespace ViewPredicate {
   type Custom<Types extends AnyTypes> = {
     where?: ViewPredicate.WhereOperator<Types>;
     with?: Simplify<Omit<ModelFqnExpr.Custom['custom'] & ModelRelationExpr.Custom['customRelation'], 'expr' | 'relation' | 'navigateTo'> & {
+      kind?: Types['RelationshipKind'];
       navigateTo?: Types['ViewId'];
     }>;
   };
 }
-declare function $include<B extends LikeC4ViewBuilder<AnyTypes, any, any>>(...args: [B['Expr']] | [B['TypedExpr']] | [B['Expr'], ViewPredicate.Custom<B['Types']>] | [B['Expr'], B['Expr'], ...B['Expr'][]]): (b: B) => B;
-declare function $exclude<B extends LikeC4ViewBuilder<AnyTypes, any, any>>(...args: [B['Expr']] | [B['TypedExpr']] | [B['Expr'], ViewPredicate.Custom<B['Types']>] | [B['TypedExpr'], ViewPredicate.Custom<B['Types']>]): (b: B) => B;
+type $IncludeArgs<B extends LikeC4ViewBuilder<any, any, any>> = [B['Expr']] | [B['TypedExpr']] | [B['Expr'], ViewPredicate.Custom<B['Types']>] | [B['Expr'], B['Expr'], ...B['Expr'][]];
+declare function $include<B extends LikeC4ViewBuilder<any, any, any>>(...args: $IncludeArgs<NoInfer<B>>): (b: B) => B;
+type $ExcludeArgs<B extends LikeC4ViewBuilder<any, any, any>> = [B['Expr']] | [B['TypedExpr']] | [B['Expr'], ViewPredicate.Custom<B['Types']>] | [B['TypedExpr'], ViewPredicate.Custom<B['Types']>];
+declare function $exclude<B extends LikeC4ViewBuilder<any, any, any>>(...args: $ExcludeArgs<NoInfer<B>>): (b: B) => B;
 /**
  * @example
  *  builder.views(({ view, $style }, _) =>
@@ -325,18 +330,14 @@ declare function $exclude<B extends LikeC4ViewBuilder<AnyTypes, any, any>>(...ar
  *    )
  *  )
  */
-declare function $style<B extends LikeC4ViewBuilder<AnyTypes, any, any>>(element: B['ElementExpr'] | B['TypedExpr'] | NonEmptyArray<B['ElementExpr']>, {
-  notation,
-  ...style
-}: AnyViewRuleStyle<any>['style'] & {
+declare function $style<B extends LikeC4ViewBuilder<any, any, any>>(element: B['ElementExpr'] | B['TypedExpr'] | NonEmptyArray<B['ElementExpr']>, { notation, ...style }: AnyViewRuleStyle<any>['style'] & {
   notation?: string;
 }): (b: B) => B;
-declare function $autoLayout<B extends LikeC4ViewBuilder<AnyTypes, any, any>>(layout: AutoLayoutDirection, margins?: {
+declare function $autoLayout<B extends LikeC4ViewBuilder<any, any, any>>(layout: AutoLayoutDirection, margins?: {
   rank: number;
   node: number;
 }): (b: B) => B;
-type Op<T> = (b: T) => T;
-declare function $rules<B extends LikeC4ViewBuilder<AnyTypes, any, any>>(...rules: Op<B>[]): (b: B) => B;
+declare function $rules<B extends LikeC4ViewBuilder<any, any, any>>(...rules: Array<(b: B) => B>): (b: B) => B;
 //#endregion
 //#region src/builder/Builder.view-deployment.d.ts
 interface DeploymentViewBuilder<T extends AnyTypes> extends LikeC4ViewBuilder<T, T['DeploymentFqn'], Types.ToExpression<T>> {
@@ -362,40 +363,115 @@ interface AddDeploymentViewHelper {
 declare function $deploymentExpr<T extends AnyTypes>(expr: ViewPredicate.DeploymentExpression<T> | Expression): Types.ToExpression<T>;
 declare function $includeAncestors<B extends DeploymentViewBuilder<AnyTypes>>(value: boolean): (b: B) => B;
 //#endregion
+//#region src/builder/Builder.view-dynamic.d.ts
+interface DynamicViewBuilder<T extends AnyTypes> extends LikeC4ViewBuilder<T, T['Fqn'], Expression<Types.ToAux<T>>> {}
+type DynamicViewRulesBuilder<T extends AnyTypes> = (b: DynamicViewBuilder<T>) => any;
+interface AltBranchBuilder<T extends AnyTypes> {
+  readonly Types: T;
+  addBranch(alias: Step.Alt['branches'][number]): this;
+}
+interface AddDynamicViewRules<Id extends string> {
+  with<S extends AnyTypes>(...rules: Array<(b: DynamicViewBuilder<NoInfer<S>>) => any>): (builder: ViewsBuilder<S>) => ViewsBuilder<Types.AddView<S, Id>>;
+}
+interface AddDynamicViewHelper {
+  <const Id extends string, T extends AnyTypes>(id: Id): AddDynamicViewRules<Id> & {
+    (builder: ViewsBuilder<T>): ViewsBuilder<Types.AddView<T, Id>>;
+  };
+  <const Id extends string, T extends AnyTypes>(id: Id, builder: DynamicViewRulesBuilder<NoInfer<T>>): {
+    (builder: ViewsBuilder<T>): ViewsBuilder<Types.AddView<T, Id>>;
+  };
+  <const Id extends string, T extends AnyTypes>(id: Id, propsOrTitle: NoInfer<T>['NewViewProps'] | string): AddDynamicViewRules<Id> & {
+    (builder: ViewsBuilder<T>): ViewsBuilder<Types.AddView<T, Id>>;
+  };
+  <const Id extends string, T extends AnyTypes>(id: Id, propsOrTitle: NoInfer<T>['NewViewProps'] | string | undefined, builder: DynamicViewRulesBuilder<NoInfer<T>>): {
+    (builder: ViewsBuilder<T>): ViewsBuilder<Types.AddView<T, Id>>;
+  };
+}
+type $StepArg<T extends AnyTypes> = `${T['Fqn']} -> ${T['Fqn']}`;
+type $StepArgs<B extends {
+  Types: AnyTypes;
+}> = [step: $StepArg<B['Types']>] | [step: $StepArg<B['Types']>, props: {
+  title?: string;
+} & ViewPredicate.Custom<B['Types']>] | [source: B['Types']['Fqn'], target: B['Types']['Fqn']] | [source: B['Types']['Fqn'], target: B['Types']['Fqn'], props: string] | [source: B['Types']['Fqn'], target: B['Types']['Fqn'], props: {
+  title?: string;
+} & ViewPredicate.Custom<B['Types']>];
+/**
+ * Adds a step to a dynamic view
+ * @example
+ * ```ts
+ * $step('alice -> bob')
+ * $step('alice -> bob', { title: 'Alice calls Bob' })
+ * $step('alice', 'bob')
+ * $step('alice', 'bob', 'Alice calls Bob')
+ * $step('alice', 'bob', { title: 'Alice calls Bob' })
+ * ```
+ * @see $step.series - Sequential steps
+ * @see $step.parallel - Parallel steps
+ * @see $step.try - Try-catch block
+ * @see $step.alt - Alternative steps
+ */
+declare function $step<B extends LikeC4ViewBuilder<AnyTypes, any, any>>(...args: $StepArgs<NoInfer<B>>): (b: B) => B;
+declare namespace $step {
+  export var series: <B extends LikeC4ViewBuilder<AnyTypes, any, any>>(series_0: NoInfer<B>["Types"]["Fqn"], series_1: `-> ${NoInfer<B>["Types"]["Fqn"]}`, ...series: `-> ${NoInfer<B>["Types"]["Fqn"]}`[]) => (b: B) => B;
+  var _a: <B extends LikeC4ViewBuilder<AnyTypes, any, any>>(opts: $StepTry<$StepOps<NoInfer<B>>>) => (b: B) => B;
+  export var parallel: <B extends LikeC4ViewBuilder<AnyTypes, any, any>>(...stepOps: $StepOps<NoInfer<B>>) => (b: B) => any;
+  export var loop: <B extends LikeC4ViewBuilder<AnyTypes, any, any>>(...stepOps: $StepOps<NoInfer<B>>) => (b: B) => any;
+  export var opt: <B extends LikeC4ViewBuilder<AnyTypes, any, any>>(...stepOps: $StepOps<NoInfer<B>>) => (b: B) => any;
+  var _b: <B extends LikeC4ViewBuilder<AnyTypes, any, any>>(...stepOps: $StepOps<NoInfer<B>>) => (b: B) => any;
+  export var alt: <B extends LikeC4ViewBuilder<AnyTypes, any, any>>(...stepOps: Array<(b: AltBranchBuilder<NoInfer<B>["Types"]>) => any>) => (b: B) => B;
+  export var when: <B extends AltBranchBuilder<AnyTypes>>(...stepOps: $StepOps<NoInfer<B>>) => (b: B) => B;
+  var _c: <B extends AltBranchBuilder<AnyTypes>>(...stepOps: $StepOps<NoInfer<B>>) => (b: B) => B;
+  var _d: <B extends AltBranchBuilder<AnyTypes>>(...stepOps: $StepOps<NoInfer<B>>) => (b: B) => B;
+  export { _a as try, _b as break, _c as if, _d as else };
+}
+type $StepOp<T extends AnyTypes> = ((b: LikeC4ViewBuilder<T, any, any>) => any) | `${T['Fqn']} -> ${T['Fqn']}`;
+type $StepOps<B extends {
+  Types: AnyTypes;
+}> = Array<$StepOp<B['Types']>>;
+type $StepTry<OPS> = {
+  try: OPS;
+  catch?: OPS;
+  finally?: OPS;
+};
+//#endregion
 //#region src/builder/Builder.view-element.d.ts
 interface ElementViewBuilder<T extends AnyTypes> extends LikeC4ViewBuilder<T, T['Fqn'], Expression<Types.ToAux<T>>> {}
 type ElementViewRulesBuilder<T extends AnyTypes> = (b: ElementViewBuilder<T>) => ElementViewBuilder<T>;
 interface AddViewRules<Id extends string> {
-  with<S extends AnyTypes>(...rules: ElementViewRulesBuilder<S>[]): (builder: ViewsBuilder<S>) => ViewsBuilder<Types.AddView<S, Id>>;
+  with<B extends ViewsBuilder<any>>(...rules: Array<((b: ElementViewBuilder<NoInfer<B>['Types']>) => any)>): (builder: B) => ViewsBuilder<Types.AddView<B['Types'], Id>>;
 }
 interface AddViewHelper {
   <const Id extends string, T extends AnyTypes>(id: Id): AddViewRules<Id> & {
     (builder: ViewsBuilder<T>): ViewsBuilder<Types.AddView<T, Id>>;
   };
-  <const Id extends string, T extends AnyTypes>(id: Id, builder: (b: ElementViewBuilder<T>) => ElementViewBuilder<T>): AddViewRules<Id> & {
-    (builder: ViewsBuilder<T>): ViewsBuilder<Types.AddView<T, Id>>;
+  <const Id extends string, B extends ViewsBuilder<any>>(id: Id, builder: (b: ElementViewBuilder<NoInfer<B>['Types']>) => any): {
+    (builder: B): ViewsBuilder<Types.AddView<B['Types'], Id>>;
   };
-  <const Id extends string, T extends AnyTypes>(id: Id, propsOrTitle: NoInfer<T['NewViewProps']> | string): AddViewRules<Id> & {
+  <const Id extends string, T extends AnyTypes>(id: Id, propsOrTitle: NoInfer<T>['NewViewProps'] | string): AddViewRules<Id> & {
     (builder: ViewsBuilder<T>): ViewsBuilder<Types.AddView<T, Id>>;
   };
-  <const Id extends string, T extends AnyTypes>(id: Id, propsOrTitle: NoInfer<T['NewViewProps']> | string | undefined, builder: (b: ElementViewBuilder<T>) => ElementViewBuilder<T>): AddViewRules<Id> & {
-    (builder: ViewsBuilder<T>): ViewsBuilder<Types.AddView<T, Id>>;
+  <const Id extends string, B extends ViewsBuilder<any>>(id: Id, propsOrTitle: NoInfer<B>['Types']['NewViewProps'] | string | undefined, builder: (b: ElementViewBuilder<NoInfer<B>['Types']>) => any): {
+    (builder: B): ViewsBuilder<Types.AddView<B['Types'], Id>>;
   };
 }
 type ValidFqn<T extends AnyTypes> = IsLiteral<T['Fqn']> extends true ? T['Fqn'] : Invalid<'Fqn must be a literal'>;
 interface AddViewOfHelper {
-  <const Id extends string, T extends AnyTypes>(id: Id, of: ValidFqn<T>): (builder: ViewsBuilder<T>) => ViewsBuilder<Types.AddView<T, Id>>;
-  <const Id extends string, T extends AnyTypes>(id: Id, of: ValidFqn<T>, propsOrTitle: T['NewViewProps'] | string | ElementViewRulesBuilder<T>): (builder: ViewsBuilder<T>) => ViewsBuilder<Types.AddView<T, Id>>;
-  <const Id extends string, T extends AnyTypes>(id: Id, of: ValidFqn<T>, propsOrTitle: NoInfer<T>['NewViewProps'] | string, builder: (b: ElementViewBuilder<T>) => ElementViewBuilder<T>): (builder: ViewsBuilder<T>) => ViewsBuilder<Types.AddView<T, Id>>;
+  <const Id extends string, T extends AnyTypes>(id: Id, of: NoInfer<T>['Fqn']): (builder: ViewsBuilder<T>) => ViewsBuilder<Types.AddView<T, Id>>;
+  <const Id extends string, T extends AnyTypes>(id: Id, of: NoInfer<T['Fqn']>, rules: ElementViewRulesBuilder<NoInfer<T>>): (builder: ViewsBuilder<T>) => ViewsBuilder<Types.AddView<T, Id>>;
+  <const Id extends string, T extends AnyTypes>(id: Id, of: NoInfer<T>['Fqn'], propsOrTitle: NoInfer<T>['NewViewProps'] | string): (builder: ViewsBuilder<T>) => ViewsBuilder<Types.AddView<T, Id>>;
+  <const Id extends string, T extends AnyTypes>(id: Id, of: NoInfer<T>['Fqn'], propsOrTitle: NoInfer<T>['NewViewProps'] | string, rules: ElementViewRulesBuilder<NoInfer<T>>): (builder: ViewsBuilder<T>) => ViewsBuilder<Types.AddView<T, Id>>;
 }
 interface TypedAddViewOfHelper<A extends AnyTypes> {
   <const Id extends string, T extends AnyTypes>(id: Id, of: ValidFqn<A>): AddViewRules<Id> & {
     (builder: ViewsBuilder<T>): ViewsBuilder<Types.AddView<T, Id>>;
   };
-  <const Id extends string, T extends AnyTypes>(id: Id, of: ValidFqn<A>, builder: ((b: ElementViewBuilder<A>) => ElementViewBuilder<A>) | A['NewViewProps'] | string): AddViewRules<Id> & {
+  <const Id extends string, T extends AnyTypes>(id: Id, of: ValidFqn<A>, rules: ElementViewRulesBuilder<A>): {
     (builder: ViewsBuilder<T>): ViewsBuilder<Types.AddView<T, Id>>;
   };
-  <const Id extends string, T extends AnyTypes>(id: Id, of: ValidFqn<A>, propsOrTitle: A['NewViewProps'] | string, builder: (b: ElementViewBuilder<A>) => ElementViewBuilder<A>): AddViewRules<Id> & {
+  <const Id extends string, T extends AnyTypes>(id: Id, of: ValidFqn<A>, propsOrTitle: A['NewViewProps'] | string): {
+    (builder: ViewsBuilder<T>): ViewsBuilder<Types.AddView<T, Id>>;
+  };
+  <const Id extends string, T extends AnyTypes>(id: Id, of: ValidFqn<A>, propsOrTitle: A['NewViewProps'] | string, rules: ElementViewRulesBuilder<A>): {
     (builder: ViewsBuilder<T>): ViewsBuilder<Types.AddView<T, Id>>;
   };
 }
@@ -426,10 +502,12 @@ type ViewsHelpers = {
   view: AddViewHelper;
   viewOf: AddViewOfHelper;
   deploymentView: AddDeploymentViewHelper;
+  dynamicView: AddDynamicViewHelper;
   $include: typeof $include;
   $exclude: typeof $exclude;
   $style: typeof $style;
   $rules: typeof $rules;
+  $step: typeof $step;
   $autoLayout: typeof $autoLayout;
   $includeAncestors: typeof $includeAncestors;
 };
@@ -439,6 +517,7 @@ type ViewsBuilderFunction<A extends AnyTypes, B extends AnyTypes> = (helpers: Si
 }>, add: ViewsHelpers['views']) => ((builder: ViewsBuilder<A>) => ViewsBuilder<B>) | ((builder: Builder<A>) => Builder<B>);
 declare function mkViewBuilder(view: Writable<ParsedDeploymentView<any>>): DeploymentViewBuilder<AnyTypes>;
 declare function mkViewBuilder(view: Writable<ParsedElementView<any>>): ElementViewBuilder<AnyTypes>;
+declare function mkViewBuilder(view: Writable<ParsedDynamicView<any>>): DynamicViewBuilder<AnyTypes>;
 //#endregion
 //#region src/builder/Builder.with.d.ts
 interface BuilderMethods<T extends AnyTypes> {
@@ -462,6 +541,26 @@ interface Builder<T extends AnyTypes> extends BuilderMethods<T> {
    */
   readonly Types: T;
   clone(): Builder<T>;
+  /**
+   * Extends the builder with additional specification — new element kinds,
+   * deployment kinds, relationship kinds, tags or metadata keys. Existing kinds
+   * with the same name are overridden by the new spec.
+   *
+   * The returned builder's `Types` are the *union* of the current types and the
+   * ones derived from `spec` (see {@link Types.Merge}), so element-kind helpers,
+   * tags, etc. accumulate rather than narrowing.
+   *
+   * @example
+   * ```ts
+   * Builder.fromParsed(data)
+   *   .specification({
+   *     elements: { database: { style: { shape: 'storage' } } },
+   *     tags: { experimental: { color: '#f00' } },
+   *   })
+   *   .model(({ database }, _) => _(database('warehouse', { tags: ['experimental'] })))
+   * ```
+   */
+  specification<const Spec extends BuilderSpecification>(spec: Spec): Builder<Types.Merge<T, Types.FromSpecification<Spec>>>;
   /**
    * Builders for each element kind
    */
@@ -521,36 +620,85 @@ interface Builder<T extends AnyTypes> extends BuilderMethods<T> {
    * Adds views
    *
    * @example
-   *  builder.views(({ view, viewOf, deploymentView, $include, $style, $rules }, _) =>
-   *    _(
-   *      view('view1').with(
-   *        $include('a -> b'),
-   *      ),
-   *      view('view2', {
-   *        title: 'View 2',
-   *      }).with(
-   *        $include('*')
-   *      ),
-   *      view(
-   *        'view3',
-   *        {
-   *          title: 'View 3',
-   *        },
-   *        $rules(
-   *          $include('*'),
-   *          $style(['*', 'alice'], {
-   *            color: 'red',
-   *          }),
-   *        ),
-   *      ),
-   *      viewOf('viewOfA', 'a').with(
-   *        $include('*')
-   *      ),
-   *      deploymentView('deploymentView1').with(
-   *        $include('a -> b')
+   * ```ts
+   * // Element views
+   * builder.views(({ view, viewOf, $include, $style, $rules }, _) =>
+   *   _(
+   *     view('view1').with(
+   *       $include('a -> b'),
+   *     ),
+   *     view('view2', {
+   *       title: 'View 2',
+   *     }).with(
+   *       $include('*')
+   *     ),
+   *     view(
+   *       'view3',
+   *       {
+   *         title: 'View 3',
+   *       },
+   *       $rules(
+   *         $include('*'),
+   *         $style(['*', 'alice'], {
+   *           color: 'red',
+   *         }),
+   *       ),
+   *     ),
+   *     viewOf('viewOfA', 'a', $rules(
+   *       $include('*')
+   *     )),
+   *   )
+   * )
+   * ```
+   *
+   * @example
+   * ```ts
+   * // Deployment views
+   * builder.views(({ deploymentView, $include, $style, $rules }, _) =>
+   *   _(
+   *     deploymentView('deploymentView1').with(
+   *       $include('a -> b')
+   *     ),
+   *     deploymentView(
+   *       'deploymentView2'
+   *       { title: 'View 2' },
+   *       $rules(
+   *         $include('*'),
+   *         $style(['*', 'alice'], {
+   *           color: 'red',
+   *         }),
+   *       ),
+   *     ),
+   *   )
+   * )
+   * ```
+   *
+   * @example
+   * ```ts
+   * // Dynamic views
+   * builder.views(({ dynamicView, $step, $rules }, _) =>
+   *   _(
+   *     dynamicView('dynamicView1').with(
+   *       $step('a -> b'),
+   *       $step.alt(
+   *         $step.when('b -> c'),
+   *         $step.else('b -> e'),
+   *       ),
+   *     ),
+   *     dynamicView(
+   *       'dynamic-b',
+   *       $rules(
+   *         $step('a', 'b'),
+   *         $step('a -> b'),
+   *         $step.loop(
+   *           'a -> b',
+   *           $step.opt('a -> b'),
+   *         ),
+   *       ),
    *      ),
-   *    )
-   *  )
+   *   )
+   * )
+   * ```
    */
   views<Out extends AnyTypes>(callback: ViewsBuilderFunction<T, Out>): Builder<Out>;
   /**
@@ -568,6 +716,34 @@ interface Builder<T extends AnyTypes> extends BuilderMethods<T> {
   toLikeC4Model<const Project extends BuilderProjectSpecification>(project: Project): LikeC4Model.Computed<setProject<Types.ToAux<T>, Project['id']>>;
   toLikeC4Model(): LikeC4Model.Computed<Types.ToAux<T>>;
 }
+/**
+ * The shape of a {@link Specification} this module reads when checking
+ * compatibility — only the name-bearing slots that affect {@link Types.FromSpecification}.
+ */
+interface SpecificationShape {
+  elements?: string[] | Record<string, unknown>;
+  deployments?: string[] | Record<string, unknown>;
+  relationships?: string[] | Record<string, unknown>;
+  tags?: string[] | Record<string, unknown>;
+  metadataKeys?: readonly string[];
+}
+/**
+ * Asserts that `declared` is a subset of `loaded`: every element / deployment /
+ * relationship kind, tag and metadata key declared must be present in the loaded
+ * specification. The reverse is allowed — the loaded specification may contain
+ * extra kinds/tags that are not declared (you simply won't get typed helpers for
+ * them).
+ *
+ * Styles and other per-kind props are intentionally ignored — only the *names*
+ * that feed {@link Types.FromSpecification} are compared.
+ *
+ * Used by `LikeC4.toTypedBuilder` to back its typed cast with a runtime check:
+ * if a declared kind is missing from the loaded model, the produced types would
+ * lie, so we throw instead.
+ *
+ * @throws Error listing every declared-but-missing entry.
+ */
+declare function assertSpecificationCompatible(declared: BuilderSpecification, loaded: SpecificationShape): void;
 declare const Builder: {
   /**
    * Creates a builder with compositional methods
@@ -632,17 +808,69 @@ declare const Builder: {
    * ```
    */
   specification<const Spec extends BuilderSpecification>(spec: Spec): Builder<Types.FromSpecification<Spec>>;
+  /**
+   * Creates a builder seeded from an existing {@link ParsedLikeC4ModelData}.
+   *
+   * Use this to enrich a model that was loaded from disk (e.g. via
+   * `LikeC4.fromWorkspace(...).toBuilder()`) — the returned builder already
+   * contains the model's elements, relations, views, deployments, globals and
+   * imports, so calls to `.model(...)`, `.deployment(...)` and `.views(...)` will
+   * extend it.
+   *
+   * Type-safety:
+   * - When the data carries a typed {@link Aux} (e.g. the output of
+   *   `builder.build()`), the returned builder preserves those types — element
+   *   kinds, FQNs, view ids and tags are statically known.
+   * - When the data has an `Unknown` Aux (e.g. loaded from a workspace via
+   *   `LikeC4.toBuilder()`), the returned builder is `Builder<AnyTypes>` —
+   *   kinds and FQNs are only known at runtime.
+   * - You can also override the type explicitly via the generic parameter
+   *   (`Builder.fromParsed<typeof mySpec.Types>(data)`) — this is an unchecked
+   *   promise: the caller takes responsibility for the cast.
+   *
+   * The optional `mode` controls duplicate handling (see {@link BuilderMode}):
+   * - `editable` (default): re-declaring an existing FQN with the same kind
+   *   replaces it, so loaded elements can be edited in place.
+   * - `strict`: re-declaring an existing FQN throws.
+   *
+   * @example
+   * ```ts
+   * const likec4 = await LikeC4.fromWorkspace('/path/to/workspace')
+   * const builder = Builder.fromParsed((await likec4.parsedModel()).$data)
+   * const enriched = builder
+   *   .model(({ system, component, relTo }, _) =>
+   *     _(system('monitoring').with(component('grafana'))),
+   *   )
+   *   .toLikeC4Model()
+   * ```
+   */
+  fromParsed: {
+    <A extends Any>(data: ParsedLikeC4ModelData<A>, mode?: BuilderMode): Builder<Types.FromAux<A>>;
+    <T extends AnyTypes>(data: ParsedLikeC4ModelData<Any>, mode?: BuilderMode): Builder<T>;
+  };
 };
 declare namespace Builder {
   type Any = Builder<AnyTypes>;
 }
 //#endregion
 //#region src/builder/_types.d.ts
+/**
+ * Duplicate-handling mode for a {@link Builder}.
+ *
+ * - `editable` (default): re-declaring an existing FQN with the **same kind** replaces the
+ *   existing entry (so `.with(...)` can both edit and descend). Different-kind
+ *   redeclaration still throws.
+ * - `strict`: re-declaring an FQN that already exists throws.
+ *
+ * Pass `'strict'` when duplicates should be treated as programmer errors — see
+ * {@link Builder.fromParsed} and `LikeC4.toBuilder`.
+ */
+type BuilderMode = 'strict' | 'editable';
 type ElementSpecification = Omit<ElementSpecification$1, 'tags'> & {
   tags?: string[];
 };
 type BuilderSpecification = {
-  elements: string[] | {
+  elements?: string[] | {
     [kind: string]: Partial<ElementSpecification>;
   };
   relationships?: string[] | {
@@ -666,7 +894,7 @@ type BuilderProjectSpecification = {
   title?: string;
   styles?: PartialDeep<LikeC4ProjectStylesConfig>;
 };
-type Metadata<MetadataKey extends string> = IsNever<MetadataKey> extends true ? never : IsLiteral<MetadataKey> extends true ? { [key in MetadataKey]?: string | NonEmptyArray<string> } : Record<string, string | NonEmptyArray<string>>;
+type Metadata<MetadataKey extends string> = IsNever<MetadataKey> extends true ? never : IsLiteral<MetadataKey> extends true ? { [key in MetadataKey]?: string | NonEmptyArray<string>; } : Record<string, string | NonEmptyArray<string>>;
 type NewElementProps<Tag, Metadata> = {
   title?: string;
   summary?: MarkdownOrString | string;
@@ -781,9 +1009,26 @@ declare namespace Types {
   type AddDeploymentFqn<T, Id extends string> = T extends TypesNested<infer P, any, any, any, any, any, any, any, any> ? TypesNested<P, T['ElementKind'], T['Fqn'], T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey'], T['DeploymentKind'], `${P}.${Id}` | T['DeploymentFqn']> : T extends AnyTypes ? Types<T['ElementKind'], T['Fqn'], T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey'], T['DeploymentKind'], Id | T['DeploymentFqn']> : never;
   type AddView<T, Id extends string> = T extends TypesNested<infer P, any, any, any, any, any, any, any, any> ? TypesNested<P, T['ElementKind'], T['Fqn'], Id | T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey'], T['DeploymentKind'], T['DeploymentFqn']> : T extends AnyTypes ? Types<T['ElementKind'], T['Fqn'], Id | T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey'], T['DeploymentKind'], T['DeploymentFqn']> : never;
   type ToAux<T> = T extends AnyTypes ? Aux<'parsed', T['Fqn'], T['DeploymentFqn'], T['ViewId'], 'from-builder', SpecAux<T['ElementKind'], T['DeploymentKind'], T['RelationshipKind'], T['Tag'], T['MetadataKey']>> : Any;
+  /**
+   * Merges two {@link Types} by unioning every slot (element kinds, FQNs,
+   * relationship kinds, tags, metadata keys, deployment kinds and FQNs).
+   *
+   * Used by `Builder.specification(...)` to combine the existing builder's
+   * types with a newly-declared specification. A plain `A & B` intersection
+   * would *narrow* the unions (e.g. `'a' | 'b' & 'c' | 'd'` = `never`), which
+   * is the opposite of what we want when adding new kinds.
+   */
+  type Merge<A, B> = A extends Types<infer AK extends string, infer AF extends string, infer AV extends string, infer AR extends string, infer AT extends string, infer AM extends string, infer ADK extends string, infer ADF extends string> ? B extends Types<infer BK extends string, infer BF extends string, infer BV extends string, infer BR extends string, infer BT extends string, infer BM extends string, infer BDK extends string, infer BDF extends string> ? Types<AK | BK, AF | BF, AV | BV, AR | BR, AT | BT, AM | BM, ADK | BDK, ADF | BDF> : A : B;
+  /**
+   * Inverse of {@link ToAux} — derives builder {@link Types} from an {@link Aux}.
+   *
+   * Useful when a `Builder` needs to be reconstructed from a runtime value whose
+   * Aux is already known statically (e.g. the result of `builder.build()`).
+   */
+  type FromAux<A> = A extends Aux<any, infer Element extends string, infer Deployment extends string, infer View extends string, any, SpecAux<infer ElementKind extends string, infer DeploymentKind extends string, infer RelationshipKind extends string, infer Tag extends string, infer MetadataKey extends string>> ? Types<ElementKind, Element, View, RelationshipKind, Tag, MetadataKey, DeploymentKind, Deployment> : AnyTypes;
   type ToExpression<T> = T extends AnyTypes ? Expression<ToAux<T>> : never;
   type From<B> = B extends Builder<infer T> ? B['Types'] extends AnyTypes ? T : AnyTypes : never;
   type DeploymentRules<B> = DeploymentRulesBuilderOp<From<B>>;
 }
 //#endregion
-export { DeloymentModelBuildFunction as $, $includeAncestors as A, LikeC4ViewBuilder as B, AddViewHelper as C, ElementViewRulesBuilder as D, ElementViewBuilder as E, $autoLayout as F, ModelHelpers as G, AddElementHelpers as H, $exclude as I, model as J, NestedRelationshipHelper as K, $include as L, AddDeploymentViewRules as M, DeploymentRulesBuilderOp as N, TypedAddViewOfHelper as O, DeploymentViewBuilder as P, AddDeploymentRelation as Q, $rules as R, $expr as S, AddViewRules as T, ModelBuilder as U, ViewPredicate as V, ModelBuilderFunction as W, AddDeployedInstance as X, AddElement as Y, AddDeploymentNodeHelpers as Z, ViewsBuilder as _, Invalid as a, mkViewBuilder as b, NewElementProps as c, Types as d, DeloymentModelHelpers as et, TypesNested as f, BuilderMethods as g, Builder as h, BuilderSpecification as i, AddDeploymentViewHelper as j, $deploymentExpr as k, NewRelationProps as l, Warn as m, AnyTypesNested as n, deployment as nt, Metadata as o, ValidId as p, RelationshipHelper as q, BuilderProjectSpecification as r, AddDeploymentNode as rt, NewDeploymentNodeProps as s, AnyTypes as t, DeploymentModelBuilder as tt, NewViewProps as u, ViewsBuilderFunction as v, AddViewOfHelper as w, views as x, ViewsHelpers as y, $style as z };
+export { AddDeploymentNodeHelpers as $, TypedAddViewOfHelper as A, $rules as B, views as C, AddViewRules as D, AddViewOfHelper as E, DeploymentRulesBuilderOp as F, ModelBuilder as G, LikeC4ViewBuilder as H, DeploymentViewBuilder as I, NestedRelationshipHelper as J, ModelBuilderFunction as K, $autoLayout as L, $includeAncestors as M, AddDeploymentViewHelper as N, ElementViewBuilder as O, AddDeploymentViewRules as P, AddDeployedInstance as Q, $exclude as R, mkViewBuilder as S, AddViewHelper as T, ViewPredicate as U, $style as V, AddElementHelpers as W, model as X, RelationshipHelper as Y, AddElement as Z, assertSpecificationCompatible as _, BuilderSpecification as a, AddDeploymentNode as at, ViewsBuilderFunction as b, NewDeploymentNodeProps as c, NewViewProps as d, AddDeploymentRelation as et, Types as f, Builder as g, Warn as h, BuilderProjectSpecification as i, deployment as it, $deploymentExpr as j, ElementViewRulesBuilder as k, NewElementProps as l, ValidId as m, AnyTypesNested as n, DeloymentModelHelpers as nt, Invalid as o, TypesNested as p, ModelHelpers as q, BuilderMode as r, DeploymentModelBuilder as rt, Metadata as s, AnyTypes as t, DeloymentModelBuildFunction as tt, NewRelationProps as u, BuilderMethods as v, $expr as w, ViewsHelpers as x, ViewsBuilder as y, $include as z };

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

@@ -1,6 +1,6 @@
-import { Ai as ProjectId, K as DiagramEdge, Xi as _stage, Zi as _type, gn as ViewAutoLayout, it as ComputedEdge, ot as ComputedNode, pn as BaseViewProperties, q as DiagramNode } from "./index.mjs";
+import { r as __name } from "./rolldown-runtime.mjs";
+import { $ as ComputedNode, Dn as ViewAutoLayout, Hi as ProjectId, Z as ComputedEdge, aa as _stage, ht as DiagramNode, mt as DiagramEdge, oa as _type, wn as BaseViewProperties } from "./index.mjs";
 import { i as BBox } from "./index2.mjs";
-
 //#region src/compute-view/projects-view/_types.d.ts
 interface ComputedProjectNode extends ComputedNode {
   readonly projectId: ProjectId;

package/dist/chunks/assignTagColors.mjs

@@ -0,0 +1 @@
+import"./rolldown-runtime.mjs";import{U as e,jn as t,wn as n}from"./types.mjs";import{E as r,Q as i,Y as a,l as o,m as s,nt as c,p as l,w as u}from"./libs/remeda.mjs";function assignTagColors(d){let f=[],p=[];for(let[e,t]of a(d))r(t.color)?f.push({tag:e,spec:{color:t.color}}):p.push(e);return i(p,o(n),u((n,r)=>({tag:n,spec:{color:t(e[r%e.length])}})),c(f),o((e,t)=>n(e.tag,t.tag)),l(s(`tag`),s(`spec`)))}export{assignTagColors as t};

package/dist/chunks/calcDriftsFromSnapshot.mjs

@@ -0,0 +1 @@
+import"./rolldown-runtime.mjs";import{An as e,Rt as t,St as n,Zt as r,b as i,nn as a,x as o}from"./types.mjs";import{A as s,B as c,E as l,J as u,Q as d,S as f,U as p,V as m,Y as h,Z as g,_,c as v,h as y,i as b,k as x,m as S,w as C}from"./libs/remeda.mjs";import{castDraft as w,produce as T}from"immer";function buildElementNotations(e){return d(e,u(e=>!!e.notation),m(S(`notation`)),f(y(m(S(`shape`)),f(y(m(S(`color`)),f(y(C(S(`kind`)),b())),h(),C(([e,t])=>({kinds:t,color:e})))),h(),p(([e,t])=>t.map(({color:t,kinds:n})=>({shape:e,color:t,kinds:n}))))),h(),p(([e,t])=>t.map(({shape:t,color:n,kinds:r})=>({title:e,shape:t,color:n,kinds:r}))),v(S(`shape`),S(`title`),[e=>e.kinds.length,`desc`]))}const changed=(e,t)=>e===t||s(e)&&s(t)?!1:!c(e,t);function autoApplyMetaAndStyles(e,t){e.color=t.color,e.kind=t.kind,e.navigateTo=t.navigateTo??null,e.links=t.links?[...t.links]:null,e.tags=[...t.tags],s(t.style.border)?delete e.style.border:e.style.border=t.style.border,x(t.style.opacity)?e.style.opacity=t.style.opacity:delete e.style.opacity,s(t.style.multiple)?delete e.style.multiple:e.style.multiple=t.style.multiple}function autoApplyIcon(e,t,n){if(changed(t.icon??`none`,e.icon??`none`)){let r=l(e.icon)&&e.icon!==`none`;switch(!0){case r&&l(t.icon)&&t.icon!==`none`:return e.icon=t.icon,!0;case r&&(s(t.icon)||t.icon===`none`):return e.icon=`none`,!0;case!r&&l(t.icon)&&t.icon!==`none`:return n?(e.icon=t.icon,!0):!1}}return!0}function autoApplyIconStyles(e,t,n){let r=!0;return changed(e.style.iconColor,t.style.iconColor)&&(s(t.style.iconColor)?delete e.style.iconColor:e.style.iconColor=t.style.iconColor),changed(e.style.iconSize,t.style.iconSize)&&(n?s(t.style.iconSize)?delete e.style.iconSize:e.style.iconSize=t.style.iconSize:r=!1),changed(e.style.iconPosition,t.style.iconPosition)&&(n?s(t.style.iconPosition)?delete e.style.iconPosition:e.style.iconPosition=t.style.iconPosition:r=!1),r}function patchMarkdownOrString(e,t){return e?`md`in t?(e.md=t.md,delete e.txt,e):(`txt`in t&&(e.txt=t.txt,delete e.md),e):t}function autoApplyLabelsToLeaf(e,t,n){let r=!0;return changed(e.title,t.title)&&(n?e.title=t.title:r=!1),changed(e.description,t.description)&&(s(t.description)?delete e.description:n?e.description=patchMarkdownOrString(e.description,t.description):r=!1),changed(e.technology,t.technology)&&(s(t.technology)?delete e.technology:n?e.technology=t.technology:r=!1),r}function autoApplyLabelsToCompound(e,t,n){return e.title=t.title,s(t.description)?delete e.description:e.description=patchMarkdownOrString(e.description,t.description),s(t.technology)?delete e.technology:e.technology=t.technology,!0}function applyManualLayout(t,r){e(t.id===r.id,`applyManualLayout: view ids do not match`),e(t._stage===`layouted`,`applyManualLayout: expected layouted view`),e(r._stage===`layouted`,`applyManualLayout: expected layouted snapshot`),e(t._layout!==`manual`,`applyManualLayout: expected auto-layouted view`);let a=new Set;t._type!==r._type&&a.add(`type-changed`);let s=applyNodesManualLayout(r.nodes,t.nodes,a),c=applyEdgesManualLayout(r.edges,t.edges,a),l=buildElementNotations(s);return T(r,e=>{e.title=t.title??r.title,e.description=t.description??r.description,e.tags=t.tags?[...t.tags]:null,e.links=t.links?[...t.links]:null,e.sourcePath=t.sourcePath,e[n]=`manual`,l&&l.length>0?e.notation={nodes:l}:delete e.notation,e.nodes=w(s),e.edges=w(c),i(t)&&e._type===`dynamic`&&(e.variant=t.variant),o(t)&&e._type===`element`&&(t.viewOf?e.viewOf=t.viewOf:delete e.viewOf,t.extends?e.extends=t.extends:delete e.extends);let u=[...a];g(u,1)?e.drifts=u:(e.hash=t.hash,delete e.drifts)})}function applyNodesManualLayout(e,n,r){let i=new Map(n.map(e=>[e.id,e])),a=e.map(e=>{let n=i.get(e.id);return n?(i.delete(n.id),T(e,i=>{autoApplyMetaAndStyles(i,n);let a=new Set,o=e.children.length>0,c=n.children.length>0;(changed(i.modelRef,n.modelRef)||changed(i.deploymentRef,n.deploymentRef))&&a.add(`modelRef-changed`),c&&!o&&a.add(`became-compound`),!c&&o&&a.add(`became-leaf`),changed(i.parent,n.parent)&&a.add(`parent-changed`);let l=i.width+5>=n.width&&i.height+5>=n.height;changed(i.shape,n.shape)&&(l?i.shape=n.shape:a.add(`shape-changed`)),autoApplyIconStyles(i,n,l)||a.add(`label-changed`),autoApplyIcon(i,n,l&&c===o)||a.add(`label-changed`),(o?autoApplyLabelsToCompound:autoApplyLabelsToLeaf)(i,n,l)||a.add(`label-changed`),changed(i.notes,n.notes)&&(s(n.notes)?delete i.notes:i.notes=patchMarkdownOrString(i.notes,n.notes)),changed(e.notation,n.notation)&&(i.notation=n.notation??null),o&&c&&t(new Set(e.children),new Set(n.children)).size>0&&a.add(`children-changed`);let u=[...a];g(u,1)?(r.add(`nodes-drift`),i.drifts=u):delete i.drifts})):(r.add(`nodes-removed`),{...e,drifts:[`removed`]})});return i.size>0&&r.add(`nodes-added`),a}function applyEdgesManualLayout(t,n,i){let o=new Map(n.map(e=>[e.id,e])),c=t.map(t=>{let n=o.get(t.id)??d(o.values(),a(e=>e.source===t.source&&e.target===t.target),r());return n&&o.delete(n.id),T(t,r=>{if(!n){r.drifts=[`removed`],i.add(`edges-removed`);return}let a=new Set,o=t.id===n.id;switch(!0){case o&&t.source==n.source&&t.target==n.target:changed(r.dir??`forward`,n.dir??`forward`)&&a.add(`direction-changed`);break;case o&&t.source==n.target&&t.target==n.source:t.source!==t.target&&a.add(`direction-changed`);break;case o:t.source!=n.source&&a.add(`source-changed`),t.target!=n.target&&a.add(`target-changed`);break;default:e(t.id!=n.id,`Unexpected case in edge drift detection, ids should not match`),e(t.source==n.source,`Unexpected case in edge drift detection, sources should match`),e(t.target==n.target,`Unexpected case in edge drift detection, targets should match`),changed(r.dir??`forward`,n.dir??`forward`)&&a.add(`direction-changed`);break}r.color=n.color,r.line=n.line,r.navigateTo=n.navigateTo??null,r.tags=n.tags?[...n.tags]:null,changed(t.notes,n.notes)&&(s(t.notes)!==s(n.notes)&&a.add(`notes-changed`),r.notes=n.notes??t.notes),n.astPath?r.astPath=n.astPath:delete r.astPath;let c=_(t,[`label`,`description`,`technology`,`labelBBox`]),l=_(n,[`label`,`description`,`technology`,`labelBBox`]);if(changed(c,l))switch(!0){case n.labelBBox&&!t.labelBBox:a.add(`label-added`);break;case t.labelBBox&&!n.labelBBox:a.add(`label-removed`);break;case!!t.labelBBox&&!!n.labelBBox:n.labelBBox.width*n.labelBBox.height>(t.labelBBox.width+5)*(t.labelBBox.height+5)&&(r.labelBBox.width=Math.round(n.labelBBox.width),r.labelBBox.height=Math.round(n.labelBBox.height)),changed(t.label,n.label)&&(s(n.label)!==s(t.label)&&a.add(`label-changed`),r.label=n.label??t.label),changed(t.description,n.description)&&(s(n.description)!==s(t.description)&&a.add(`label-changed`),n.description&&(r.description=patchMarkdownOrString(t.description,n.description))),changed(t.technology,n.technology)&&(s(n.technology)!==s(t.technology)&&a.add(`label-changed`),r.technology=n.technology??t.technology??null);break;default:e(!t.labelBBox,`Unexpected case in edge labelBBox drift detection`),e(!n.labelBBox,`Unexpected case in next labelBBox drift detection`);break}let u=[...a];g(u,1)?(i.add(`edges-drift`),r.drifts=u):delete r.drifts})});return o.size>0&&i.add(`edges-added`),c}function calcDriftsFromSnapshot(e,t){let{drifts:i,...o}=applyManualLayout(e,t);if(!i||i.length===0)return T(e,e=>{delete e.drifts,e[n]=`auto`});let s=new Set;i.includes(`type-changed`)&&s.add(`type-changed`);let c=new Map(o.nodes.map(e=>[e.id,e])),l=new Map(o.edges.map(e=>[e.id,e])),u=e.nodes.map(e=>{let t=c.get(e.id);return t&&c.delete(t.id),T(e,e=>{if(!t){s.add(`nodes-added`),e.drifts=[`added`];return}t.drifts?(s.add(`nodes-drift`),e.drifts=[...t.drifts]):delete e.drifts})});c.size>0&&s.add(`nodes-removed`);let f=e.edges.map(e=>{let t=l.get(e.id)??d(l.values(),a(t=>t.source===e.source&&t.target===e.target),r());return t&&l.delete(t.id),T(e,e=>{if(!t){s.add(`edges-added`),e.drifts=[`added`];return}t.drifts?(s.add(`edges-drift`),e.drifts=[...t.drifts]):delete e.drifts})});l.size>0&&s.add(`edges-removed`);let p=[...s];return T(e,e=>{g(p,1)?e.drifts=p:delete e.drifts,e.nodes=w(u),e.edges=w(f),e[n]=`auto`})}export{applyManualLayout as n,buildElementNotations as r,calcDriftsFromSnapshot as t};

package/dist/chunks/default-map.d.mts

@@ -0,0 +1,29 @@
+import { r as __name } from "./rolldown-runtime.mjs";
+//#region ../../node_modules/.pnpm/mnemonist@0.40.4/node_modules/mnemonist/default-map.d.ts
+/**
+ * Mnemonist DefaultMap Typings
+ * =============================
+ */
+declare class DefaultMap<K, V> implements Iterable<[K, V]> {
+  // Members
+  size: number;
+  // Constructor
+  constructor(factory: (key: K, index: number) => V);
+  // Methods
+  clear(): void;
+  set(key: K, value: V): this;
+  delete(key: K): boolean;
+  has(key: K): boolean;
+  get(key: K): V;
+  peek(key: K): V | undefined;
+  forEach(callback: (value: V, key: K, map: this) => void, scope?: any): void;
+  keys(): IterableIterator<K>;
+  values(): IterableIterator<V>;
+  entries(): IterableIterator<[K, V]>;
+  [Symbol.iterator](): IterableIterator<[K, V]>;
+  inspect(): any;
+  // Statics
+  static autoIncrement(): number;
+}
+//#endregion
+export { DefaultMap as t };