likec4 1.57.0 → 1.59.0

package/dist/chunks/index2.d.mts

@@ -1,754 +1,1577 @@
 import { i as __name } from "./rolldown-runtime.mjs";
 import { a as LikeC4ProjectConfig, i as IncludeConfig, o as LikeC4ProjectConfigInput } from "./index.mjs";
-import { t as Logger } from "./libs/@logtape/logtape.mjs";
-import { $ as FileSystemProvider, A as DefaultValueConverter, B as AsyncDisposable, C as CodeLensParams, D as ValidationOptions, E as DefaultDocumentValidator, F as JSDocDocumentationProvider, G as Reference, H as AstNode, I as DefaultIndexManager, J as LangiumDocument, K as ReferenceInfo, L as ReferenceDescription, M as MaybePromise, N as DefaultScopeProvider, O as DiagnosticInfo, P as Scope, Q as FileSystemNode, R as DefaultNameProvider, S as CodeActionParams, T as DocumentSymbolParams, U as AstNodeDescription, V as Disposable$1, W as CstNode, X as PrecomputedScopes, Y as LangiumDocumentFactory, Z as Stream, _ as CodeLensProvider, _t as SymbolKind, a as LangiumServices, at as CodeAction, b as FileSelector, c as AbstractSemanticTokenProvider, ct as CompletionItemKind, d as AbstractFormatter, dt as DocumentLink, et as Keyword, f as FormattingRegion, ft as DocumentSymbol, g as DefaultDocumentHighlightProvider, gt as Range, h as DocumentLinkProvider, ht as Location, i as NextFeature, it as RequestType, j as ValueType, k as DefaultScopeComputation, l as SemanticTokenAcceptor, lt as Diagnostic, m as NodeKindProvider, mt as Hover, n as CompletionContext, nt as CancellationToken$1, o as LangiumSharedServices, ot as CodeLens, p as DocumentSymbolProvider, pt as FormattingOptions, q as DefaultLangiumDocuments, r as DefaultCompletionProvider, rt as NotificationType, s as DefaultWorkspaceSymbolProvider, st as Command, t as CompletionAcceptor, tt as URI, u as AstNodeHoverProvider, ut as DocumentHighlight, v as CodeActionProvider, vt as TextEdit, w as DocumentLinkParams, x as BuildOptions, y as DefaultWorkspaceManager, yt as WorkspaceFolder, z as WorkspaceCache } from "./libs/langium.mjs";
+import { $ as Stream, A as DefaultScopeComputation, B as WorkspaceCache, C as DocumentLinkParams, D as DefaultDocumentValidator, E as RequestType, F as Scope, G as CstNode, H as Disposable$1, I as JSDocDocumentationProvider, J as DefaultLangiumDocuments, K as Reference, L as DefaultIndexManager, M as ValueType, N as MaybePromise, O as ValidationOptions, P as DefaultScopeProvider, Q as CancellationToken$1, R as ReferenceDescription, S as CodeLensParams, T as NotificationType, U as AstNode, V as AsyncDisposable, W as AstNodeDescription, X as LangiumDocumentFactory, Y as LangiumDocument, Z as PrecomputedScopes, _ as CodeLensProvider, _t as Keyword, a as LangiumServices, at as CompletionItemKind, b as BuildOptions, c as AbstractSemanticTokenProvider, ct as DocumentLink, d as AbstractFormatter, dt as Hover, et as FileSystemNode, f as FormattingRegion, ft as Location, g as DefaultDocumentHighlightProvider, gt as WorkspaceFolder, h as DocumentLinkProvider, ht as TextEdit, i as NextFeature, it as Command, j as DefaultValueConverter, k as DiagnosticInfo, l as SemanticTokenAcceptor, lt as DocumentSymbol, m as NodeKindProvider, mt as SymbolKind, n as CompletionContext, nt as CodeAction, o as LangiumSharedServices, ot as Diagnostic, p as DocumentSymbolProvider, pt as Range, q as ReferenceInfo, r as DefaultCompletionProvider, rt as CodeLens, s as DefaultWorkspaceSymbolProvider, st as DocumentHighlight, t as CompletionAcceptor, tt as FileSystemProvider, u as AstNodeHoverProvider, ut as FormattingOptions, v as CodeActionProvider, vt as URI, w as DocumentSymbolParams, x as CodeActionParams, y as DefaultWorkspaceManager, z as DefaultNameProvider } from "./libs/langium.mjs";
 import { t as $keywords } from "./libs/@ts-graphviz/common.mjs";
+import "./libs/unstorage.mjs";
 import { LikeC4Styles } from "@likec4/core/styles";
 import { EdgeId, Fqn, GuardedBy, LayoutedView, NodeId, NonEmptyArray, NonEmptyReadonlyArray, ProjectId, ViewId } from "@likec4/core/types";
+import { AnyTypes, Builder, BuilderMode, BuilderSpecification, Types } from "@likec4/core/builder";
 import * as c4 from "@likec4/core";
 import { AnyAux, ComputedView, DeploymentFqn, DiagramView, EdgeId as EdgeId$1, Fqn as Fqn$1, LayoutType, LayoutedView as LayoutedView$1, LikeC4Styles as LikeC4Styles$1, NonEmptyArray as NonEmptyArray$1, NonEmptyReadonlyArray as NonEmptyReadonlyArray$1, ProjectId as ProjectId$1, RelationId, Tag, UnknownComputed, UnknownLayouted, UnknownParsed, ViewChange, ViewId as ViewId$1, aux as aux$1 } from "@likec4/core";
 import { DefaultWeakMap, MultiMap } from "@likec4/core/utils";
 import { ElementModel, LikeC4Model } from "@likec4/core/model";
 import { AdhocViewPredicate, ComputedProjectsView, LayoutedProjectsView } from "@likec4/core/compute-view";
-import * as type_fest0 from "type-fest";
 import { ConditionalPick, MergeExclusive, Simplify, Tagged, ValueOf, Writable } from "type-fest";
-
-//#region ../layouts/dist/_chunks/types.d.mts
+//#region ../../node_modules/.pnpm/@logtape+logtape@2.1.1/node_modules/@logtape/logtape/dist/level.d.ts
+//#region src/level.d.ts
+declare const logLevels: readonly ["trace", "debug", "info", "warning", "error", "fatal"];
 /**
- * invisible edge added by AI to enforce better layout
+ * The severity level of a {@link LogRecord}.
  */
-interface AIEnforcementEdge {
-  source: NodeId;
-  target: NodeId;
-  weight?: number;
-  minlen?: number;
-}
+type LogLevel = typeof logLevels[number];
+//#endregion
+//#region ../../node_modules/.pnpm/@logtape+logtape@2.1.1/node_modules/@logtape/logtape/dist/record.d.ts
+//#region src/record.d.ts
 /**
- * Complete set of AI-generated layout hints.
- * This is the JSON schema the LLM must produce.
+ * A log record.
  */
-interface AILayoutHints {
-  direction?: 'TB' | 'BT' | 'LR' | 'RL';
-  ranks: ReadonlyArray<{
-    rank: 'same' | 'source' | 'sink' | 'min' | 'max';
-    nodes: NonEmptyArray<NodeId>;
-  }>;
-  edgeWeight: Record<EdgeId, number>;
-  edgeMinlen: Record<EdgeId, number>;
+interface LogRecord {
   /**
-   * These edges should be reversed in DOT
-   * Unique array of EdgeIds.
+   * The category of the logger that produced the log record.
    */
-  reverseRank?: NonEmptyReadonlyArray<EdgeId>;
+  readonly category: readonly string[];
   /**
-   * These edges should be excluded, i.e. `constraint=false` in Graphviz, to allow more flexible layouts.
-   * Unique array of EdgeIds.
+   * The log level.
    */
-  excludeFromRanking?: NonEmptyReadonlyArray<EdgeId>;
+  readonly level: LogLevel;
   /**
-   * Suggested order of edges for DOT output, to influence edge routing.
+   * The log message.  This is the result of substituting the message template
+   * with the values.  The number of elements in this array is always odd,
+   * with the message template values interleaved between the substitution
+   * values.
    */
-  edgeOrder?: NonEmptyReadonlyArray<EdgeId>;
+  readonly message: readonly unknown[];
   /**
-   * Suggested order of nodes for DOT output, to influence node placement.
+   * The raw log message.  This is the original message template without any
+   * further processing.  It can be either:
+   *
+   * - A string without any substitutions if the log record was created with
+   *   a method call syntax, e.g., "Hello, {name}!" for
+   *   `logger.info("Hello, {name}!", { name })`.
+   * - A template string array if the log record was created with a tagged
+   *   template literal syntax, e.g., `["Hello, ", "!"]` for
+   *   ``logger.info`Hello, ${name}!```.
+   *
+   * @since 0.6.0
    */
-  nodeOrder?: NonEmptyReadonlyArray<NodeId>;
+  readonly rawMessage: string | TemplateStringsArray;
   /**
-   * Invisible edges added by AI to enforce better layout
+   * The timestamp of the log record in milliseconds since the Unix epoch.
    */
-  invisibleEdges?: NonEmptyReadonlyArray<AIEnforcementEdge>;
+  readonly timestamp: number;
   /**
-   * LLM reasoning for debugging/display
+   * The extra properties of the log record.
    */
-  reasoning: string;
-} //#endregion
-//#endregion
-//#region ../language-server/dist/_chunks/protocol.d.mts
-/**
- * When server requests to open a likec4 preview panel
- * (available only in the editor).
- * (not the best place, but seems to be working)
- */
-declare namespace DidRequestOpenViewNotification {
-  type Params = {
-    viewId: ViewId$1;
-    projectId: ProjectId$1;
-  };
-  const type: NotificationType<Params>;
-  type Type = typeof type;
+  readonly properties: Record<string, unknown>;
 }
+//#endregion
+//#region ../../node_modules/.pnpm/@logtape+logtape@2.1.1/node_modules/@logtape/logtape/dist/logger.d.ts
 /**
- * Request to fetch the computed model data
- * If LSP has multiple projects, the projectId is required.
- * otherwise throws an error.
- */
-/**
- * Request to locate an element, relation, deployment or view.
- * If LSP has multiple projects, the projectId is required.
+ * A logger interface.  It provides methods to log messages at different
+ * severity levels.
+ *
+ * ```typescript
+ * const logger = getLogger("category");
+ * logger.trace `A trace message with ${value}`
+ * logger.debug `A debug message with ${value}.`;
+ * logger.info `An info message with ${value}.`;
+ * logger.warn `A warning message with ${value}.`;
+ * logger.error `An error message with ${value}.`;
+ * logger.fatal `A fatal error message with ${value}.`;
+ * ```
+ *
+ * Callback-based string-message overloads should be treated as
+ * fire-and-forget.  Async callbacks return `Promise<void>`, and when a
+ * callback is filtered out because the level is disabled an implementation may
+ * still return an already-resolved promise so the async path remains awaitable
+ * without invoking the callback.  Call sites should not branch on these
+ * return values.
  */
-declare namespace Locate {
-  type Params =
+interface Logger {
   /**
-   * Locate an element by its fqn
+   * The category of the logger.  It is an array of strings.
    */
-  {
-    element: Fqn$1;
-    projectId?: string | undefined;
-    property?: string;
-  }
+  readonly category: readonly string[];
   /**
-   * Locate a relation by its id
+   * The logger with the supercategory of the current logger.  If the current
+   * logger is the root logger, this is `null`.
    */
-  | {
-    projectId?: string | undefined;
-    relation: RelationId;
-  }
+  readonly parent: Logger | null;
   /**
-   * Locate a deployment by its fqn
+   * Get a child logger with the given subcategory.
+   *
+   * ```typescript
+   * const logger = getLogger("category");
+   * const subLogger = logger.getChild("sub-category");
+   * ```
+   *
+   * The above code is equivalent to:
+   *
+   * ```typescript
+   * const logger = getLogger("category");
+   * const subLogger = getLogger(["category", "sub-category"]);
+   * ```
+   *
+   * @param subcategory The subcategory.
+   * @returns The child logger.
    */
-  | {
-    deployment: DeploymentFqn;
-    projectId?: string | undefined;
-    property?: string;
-  }
+  getChild(subcategory: string | readonly [string] | readonly [string, ...string[]]): Logger;
   /**
-   * Locate a step in a dynamic view by its astPath
+   * Get a logger with contextual properties.  This is useful for
+   * log multiple messages with the shared set of properties.
+   *
+   * ```typescript
+   * const logger = getLogger("category");
+   * const ctx = logger.with({ foo: 123, bar: "abc" });
+   * ctx.info("A message with {foo} and {bar}.");
+   * ctx.warn("Another message with {foo}, {bar}, and {baz}.", { baz: true });
+   * ```
+   *
+   * The above code is equivalent to:
+   *
+   * ```typescript
+   * const logger = getLogger("category");
+   * logger.info("A message with {foo} and {bar}.", { foo: 123, bar: "abc" });
+   * logger.warn(
+   *   "Another message with {foo}, {bar}, and {baz}.",
+   *   { foo: 123, bar: "abc", baz: true },
+   * );
+   * ```
+   *
+   * @param properties
+   * @returns
+   * @since 0.5.0
    */
-  | {
-    view: ViewId$1;
-    astPath: string;
-    projectId?: string | undefined;
-  }
+  with(properties: Record<string, unknown>): Logger;
   /**
-   * Locate a view by its id
+   * Log a trace message.  Use this as a template string prefix.
+   *
+   * ```typescript
+   * logger.trace `A trace message with ${value}.`;
+   * ```
+   *
+   * @param message The message template strings array.
+   * @param values The message template values.
+   * @since 0.12.0
    */
-  | {
-    view: ViewId$1;
-    projectId?: string | undefined;
-  };
-  type Res = Location | null;
-  const req: RequestType<Params, Res, void>;
-  type Req = typeof req;
-}
-/**
- * Request to change the view
- * If LSP has multiple projects, the projectId is required.
- */
-declare namespace ChangeView {
-  type Params = {
-    viewId: ViewId$1;
-    change: ViewChange;
-    projectId?: string | undefined;
-  };
-  type Res = {
-    success: true;
-    location: Location | null;
-  } | {
-    success: false;
-    location?: Location | null;
-    error: string;
-  };
-  const req: RequestType<Params, Res, void>;
-  type Req = typeof req;
-}
-/**
- * Request to fetch telemetry metrics
- */
-//#endregion
-//#region ../layouts/dist/_chunks/GraphvizLayoter.d.mts
-//#region src/graphviz/types.d.ts
-/**
- * Partially implements CancellationToken interface from vscode-jsonrpc
- */
-type CancellationToken = {
+  trace(message: TemplateStringsArray, ...values: readonly unknown[]): void;
   /**
-   * Is `true` when the token has been cancelled, `false` otherwise.
+   * Log a trace message with properties.
+   *
+   * ```typescript
+   * logger.trace('A trace message with {value}.', { value });
+   * ```
+   *
+   * If the properties are expensive to compute, you can pass a callback that
+   * returns the properties:
+   *
+   * ```typescript
+   * logger.trace(
+   *   'A trace message with {value}.',
+   *   () => ({ value: expensiveComputation() })
+   * );
+   * ```
+   *
+   * @param message The message template.  Placeholders to be replaced with
+   *                `values` are indicated by keys in curly braces (e.g.,
+   *                `{value}`).
+   * @param properties The values to replace placeholders with.  For lazy
+   *                   evaluation, this can be a callback that returns the
+   *                   properties.
+   * @since 0.12.0
    */
-  readonly isCancellationRequested: boolean;
-};
-declare module 'ts-graphviz' {
-  namespace GraphAttributeKey {
-    interface $values extends $keywords<'likec4_viewId'> {}
-  }
-  namespace ClusterSubgraphAttributeKey {
-    interface $values extends $keywords<'likec4_type' | 'likec4_path' | 'likec4_id' | 'likec4_level' | 'likec4_depth'> {}
-  }
-  namespace NodeAttributeKey {
-    interface $values extends $keywords<'likec4_type' | 'likec4_path' | 'likec4_id' | 'likec4_project' | 'likec4_level'> {}
-  }
-  namespace EdgeAttributeKey {
-    interface $values extends $keywords<'likec4_id' | 'likec4_project'> {}
-  }
-  namespace Attribute {
-    interface $keys extends $keywords<'likec4_viewId' | 'likec4_type' | 'likec4_path' | 'likec4_id' | 'likec4_project' | 'likec4_level' | 'likec4_depth'> {}
-    interface $types {
-      likec4_viewId: string;
-      likec4_type: 'folder' | 'file' | 'view';
-      likec4_path: string;
-      likec4_id: string;
-      likec4_project: string;
-      likec4_level: number;
-      likec4_depth: number;
-    }
-  }
-}
-type DotSource = Tagged<string, 'DotSource'>; //#endregion
-//#region src/graphviz/types-dot.d.ts
-type GvNodeName = Tagged<string, 'GvNodeName'>;
-type GvId = Tagged<number, 'GvId'>;
-type Point = [x: number, y: number];
-interface GraphvizJson {
-  name: GvNodeName;
-  directed: boolean;
-  strict: boolean;
-  _draw_: GraphvizJson.Draw[];
-  bb: string;
-  compound: string;
-  fontname: string;
-  fontsize: string;
-  label: string;
-  nodesep: string;
-  outputorder: string;
-  rankdir: string;
-  ranksep: string;
-  splines: string;
-  xdotversion: string;
-  _subgraph_cnt: number;
-  objects?: GraphvizJson.GvObject[];
-  edges?: GraphvizJson.Edge[];
-}
-declare namespace GraphvizJson {
-  interface Draw {
-    op: string;
-    grad: string;
-    color: string;
-    points: Point[];
-  }
-  interface Draw2 {
-    op: string;
-    grad: string;
-    color: string;
-    points: Point[];
-  }
-  namespace DrawOps {
-    type Style = {
-      op: 'S';
-      style: string;
-    };
-    type BSpline = {
-      op: 'b' | 'B';
-      points: Point[];
-    };
-    type Color = {
-      op: 'c';
-      grad: string;
-      color: string;
-    };
-    type Polygon = {
-      op: 'p' | 'P';
-      points: Point[];
-    };
-  }
-  type DrawOp = DrawOps.Style | DrawOps.BSpline | DrawOps.Color | DrawOps.Polygon;
-  type LabelDrawOps = {
-    op: 'F';
-    size: number;
-    face: string;
-  } | {
-    op: 'c';
-    color: string;
-  } | {
-    op: 't';
-    fontchar: number;
-  } | {
-    op: 'T';
-    pt: Point;
-    align: 'l' | 'r' | 'c';
-    width: number;
-    text: string;
-  };
-  type GvObject = GvNodeObject | GvSubgraph;
-  interface GvSubgraph {
-    bb: string;
-    label?: string;
-    compound: 'true';
-    _ldraw_?: LabelDrawOps[];
-    likec4_type?: 'folder' | 'file';
-    likec4_path?: string;
-    likec4_id?: Fqn$1;
-    likec4_level?: number;
-    likec4_depth?: number;
-    _gvid: GvId;
-    subgraphs?: GvId[];
-    nodes?: GvId[];
-    edges?: GvId[];
-  }
-  interface GvNodeObject {
-    _draw_: Draw[];
-    _ldraw_?: LabelDrawOps[];
-    likec4_type?: 'folder' | 'file' | 'view';
-    likec4_path?: string;
-    likec4_id?: Fqn$1;
-    likec4_level?: number;
-    _gvid: GvId;
-    height: string;
-    pos: string;
-    shape: 'rect';
-    width: string;
-    label?: string;
-  }
-  interface Draw3 {
-    op: string;
-    grad: string;
-    color: string;
-    points: Point[];
-  }
-  interface Hdraw {
-    op: string;
-    style: string;
-    grad: string;
-    color: string;
-    points: Point[];
-  }
-  interface Edge {
-    _gvid: GvId;
-    tail: GvId;
-    head: GvId;
-    dir?: 'forward' | 'back' | 'both' | 'none';
-    _draw_: DrawOp[];
-    _hdraw_?: DrawOp[];
-    _tdraw_?: DrawOp[];
-    _ldraw_?: LabelDrawOps[];
-    _tldraw_?: LabelDrawOps[];
-    _hldraw_?: LabelDrawOps[];
-    fontname: string;
-    fontsize: string;
-    likec4_id?: EdgeId$1;
-    label: string;
-    lp: string;
-    nojustify?: 'true' | 'false';
-    pos?: string;
-  }
-} //#endregion
-//#region src/graphviz/GraphvizLayoter.d.ts
-interface GraphvizPort extends Disposable {
-  get name(): string;
-  get concurrency(): number;
-  unflatten(dot: DotSource): Promise<DotSource>;
-  acyclic(dot: DotSource): Promise<DotSource>;
-  layoutJson(dot: DotSource): Promise<string>;
-  svg(dot: DotSource): Promise<string>;
-  dispose(): void;
-}
-type LayoutTaskParams<A extends aux$1.Any = aux$1.Any> = {
-  view: ComputedView<A>;
-  styles: LikeC4Styles$1;
-};
-type LayoutResult<A extends aux$1.Any = aux$1.Any> = {
-  dot: DotSource;
-  diagram: DiagramView<A>;
-};
-declare class GraphvizLayouter implements Disposable {
-  private graphviz;
-  constructor(graphviz?: GraphvizPort);
-  dispose(): void;
-  [Symbol.dispose](): void;
-  get graphvizPort(): GraphvizPort;
-  changePort(graphviz: GraphvizPort): void;
+  trace(message: string, properties?: Record<string, unknown> | (() => Record<string, unknown>)): void;
   /**
-   * Generates DOT source for the given view and styles.
-   * If `hints` are provided, they will be used to influence the layout (e.g. by specifying node/edge order).
-   * This method does not perform unflattening or any other post-processing on the DOT output, so it may be used for debugging or to generate DOT for external processing.
+   * Log a trace message with properties computed asynchronously.
+   *
+   * Use this when the properties require async operations to compute:
+   *
+   * ```typescript
+   * await logger.trace(
+   *   'A trace message with {value}.',
+   *   async () => ({ value: await fetchValue() })
+   * );
+   * ```
+   *
+   * @param message The message template.  Placeholders to be replaced with
+   *                `values` are indicated by keys in curly braces (e.g.,
+   *                `{value}`).
+   * @param properties An async callback that returns the properties.
+   * @returns A promise that resolves when the log is written.
+   * @since 2.0.0
    */
-  printToDot(params: LayoutTaskParams, hints?: AILayoutHints): DotSource;
-  protected newScopedLogger(operation: string): any;
-  dotToJson(dot: DotSource): Promise<GraphvizJson>;
-  layout<A extends AnyAux>(params: LayoutTaskParams<A>): Promise<LayoutResult<A>>;
-  aiLayout<A extends AnyAux>({
-    view,
-    styles
-  }: LayoutTaskParams<A>, hints: AILayoutHints): Promise<LayoutResult<A>>;
-  svg<A extends AnyAux>(params: LayoutTaskParams<A>): Promise<{
-    svg: string;
-    dot: DotSource;
-  }>;
-  dot<A extends AnyAux>(params: LayoutTaskParams<A>): Promise<DotSource>;
-  layoutProjectsView(view: ComputedProjectsView): Promise<LayoutedProjectsView>;
-} //#endregion
-//#endregion
-//#region ../layouts/dist/index.d.mts
-//#region src/graphviz/QueueGraphvizLayoter.d.ts
-declare class QueueGraphvizLayoter extends GraphvizLayouter {
-  private queue;
-  private isProcessingBatch;
-  constructor(options?: {
-    graphviz?: GraphvizPort;
-    /**
-     * Concurrency limit.
-     * Minimum: `1`.
-     * @default 2
-     */
-    concurrency?: number;
-    /**
-     * Per-operation timeout in milliseconds. Operations fulfill once `timeout` elapses if they haven't already.
-     * @default 20_000
-     */
-    timeout?: number;
-    /**
-     * Whether or not a timeout is considered an exception.
-     * @default true
-     */
-    throwOnTimeout?: boolean;
-  });
-  private runInQueue;
-  changePort(graphvizPort: GraphvizPort): void;
-  layout<A extends AnyAux>(params: LayoutTaskParams<A>): Promise<LayoutResult<A>>;
-  layoutProjectsView(view: ComputedProjectsView): Promise<LayoutedProjectsView>;
-  batchLayout<A extends AnyAux>(params: {
-    batch: LayoutTaskParams<A>[];
-    cancelToken?: CancellationToken | undefined;
-    onSuccess?: (task: LayoutTaskParams<A>, result: LayoutResult<A>) => void;
-    onError?: (task: LayoutTaskParams<A>, error: unknown) => void;
-  }): Promise<LayoutResult<A>[]>;
+  trace(message: string, properties: () => Promise<Record<string, unknown>>): Promise<void>;
   /**
-   * Custom backpressure
-   * (basically allow same amount of tasks to be in queue as concurrency)
+   * Log a trace values with no message.  This is useful when you
+   * want to log properties without a message, e.g., when you want to log
+   * the context of a request or an operation.
+   *
+   * ```typescript
+   * logger.trace({ method: 'GET', url: '/api/v1/resource' });
+   * ```
+   *
+   * Note that this is a shorthand for:
+   *
+   * ```typescript
+   * logger.trace('{*}', { method: 'GET', url: '/api/v1/resource' });
+   * ```
+   *
+   * If the properties are expensive to compute, you cannot use this shorthand
+   * and should use the following syntax instead:
+   *
+   * ```typescript
+   * logger.trace('{*}', () => ({
+   *   method: expensiveMethod(),
+   *   url: expensiveUrl(),
+   * }));
+   * ```
+   *
+   * @param properties The values to log.  Note that this does not take
+   *                   a callback.
+   * @since 0.12.0
    */
-  private waitForQueueToShrink;
-  dispose(): void;
-} //#endregion
-//#region src/graphviz/wasm/GraphvizWasmAdapter.d.ts
-//#endregion
-//#region ../language-server/dist/_chunks/module.d.mts
-//#region src/documentation/documentation-provider.d.ts
-/**
- * Provides documentation for LikeC4 AST nodes, extending JSDoc parsing
- * with specialized formatting for deployment nodes, deployed instances, and elements.
- */
-declare class LikeC4DocumentationProvider extends JSDocDocumentationProvider {
-  private parser;
-  private locator;
+  trace(properties: Record<string, unknown>): void;
   /**
-   * Creates a new documentation provider.
-   * @param services - The LikeC4 language services.
+   * Lazily log a trace message.  Use this when the message values are expensive
+   * to compute and should only be computed if the message is actually logged.
+   *
+   * ```typescript
+   * logger.trace(l => l`A trace message with ${expensiveValue()}.`);
+   * ```
+   *
+   * @param callback A callback that returns the message template prefix.
+   * @throws {TypeError} If no log record was made inside the callback.
+   * @since 0.12.0
    */
-  constructor(services: LikeC4Services);
+  trace(callback: LogCallback): void;
   /**
-   * Returns documentation for the given AST node (deployment nodes, deployed instances, elements, or JSDoc fallback).
-   * @param node - The AST node to document.
-   * @returns Formatted documentation string, or undefined if none.
+   * Log a debug message.  Use this as a template string prefix.
+   *
+   * ```typescript
+   * logger.debug `A debug message with ${value}.`;
+   * ```
+   *
+   * @param message The message template strings array.
+   * @param values The message template values.
    */
-  getDocumentation(node: AstNode): string | undefined;
-} //#endregion
-//#region src/workspace/ProjectsManager.d.ts
-type NormalizedUri = Tagged<string, 'NormalizedUri'>;
-type DocOrUri = LangiumDocument | string | URI;
-/**
- * A tagged string that represents a project folder URI (with trailing slash).
- * Used in `startsWith` checks to determine if a document belongs to a project.
- */
-type ProjectFolder = Tagged<string, 'ProjectFolder'>;
-declare function ProjectFolder(folder: URI | string): ProjectFolder;
-interface Project {
-  id: ProjectId;
-  folderUri: URI;
-  config: LikeC4ProjectConfig;
-}
-interface ProjectData extends Project {
-  id: ProjectId;
-  folder: ProjectFolder;
-  config: LikeC4ProjectConfig;
-  configUri: URI;
-  folderUri: URI;
-  exclude?: {
-    (test: string): boolean;
-  };
+  debug(message: TemplateStringsArray, ...values: readonly unknown[]): void;
   /**
-   * Resolved include paths with both URI and folder string representations.
-   * These are additional directories that are part of this project.
+   * Log a debug message with properties.
+   *
+   * ```typescript
+   * logger.debug('A debug message with {value}.', { value });
+   * ```
+   *
+   * If the properties are expensive to compute, you can pass a callback that
+   * returns the properties:
+   *
+   * ```typescript
+   * logger.debug(
+   *   'A debug message with {value}.',
+   *   () => ({ value: expensiveComputation() })
+   * );
+   * ```
+   *
+   * @param message The message template.  Placeholders to be replaced with
+   *                `values` are indicated by keys in curly braces (e.g.,
+   *                `{value}`).
+   * @param properties The values to replace placeholders with.  For lazy
+   *                   evaluation, this can be a callback that returns the
+   *                   properties.
    */
-  includePaths?: NonEmptyArray$1<{
-    uri: URI;
-    folder: ProjectFolder;
-  }>;
+  debug(message: string, properties?: Record<string, unknown> | (() => Record<string, unknown>)): void;
   /**
-   * Normalized include configuration (paths, maxDepth, fileThreshold).
+   * Log a debug message with properties computed asynchronously.
+   *
+   * Use this when the properties require async operations to compute:
+   *
+   * ```typescript
+   * await logger.debug(
+   *   'A debug message with {value}.',
+   *   async () => ({ value: await fetchValue() })
+   * );
+   * ```
+   *
+   * @param message The message template.  Placeholders to be replaced with
+   *                `values` are indicated by keys in curly braces (e.g.,
+   *                `{value}`).
+   * @param properties An async callback that returns the properties.
+   * @returns A promise that resolves when the log is written.
+   * @since 2.0.0
    */
-  includeConfig: IncludeConfig;
-}
-type RegisterProjectOptions = {
-  config: LikeC4ProjectConfig | LikeC4ProjectConfigInput;
-} & ({
-  configUri: URI | string;
-} | {
-  folderUri: URI | string;
-});
-declare class ProjectsManager {
-  #private;
-  protected services: LikeC4SharedServices;
+  debug(message: string, properties: () => Promise<Record<string, unknown>>): Promise<void>;
   /**
-   * The global project ID used for all documents
-   * that are not part of a specific project.
+   * Log a debug values with no message.  This is useful when you
+   * want to log properties without a message, e.g., when you want to log
+   * the context of a request or an operation.
+   *
+   * ```typescript
+   * logger.debug({ method: 'GET', url: '/api/v1/resource' });
+   * ```
+   *
+   * Note that this is a shorthand for:
+   *
+   * ```typescript
+   * logger.debug('{*}', { method: 'GET', url: '/api/v1/resource' });
+   * ```
+   *
+   * If the properties are expensive to compute, you cannot use this shorthand
+   * and should use the following syntax instead:
+   *
+   * ```typescript
+   * logger.debug('{*}', () => ({
+   *   method: expensiveMethod(),
+   *   url: expensiveUrl(),
+   * }));
+   * ```
+   *
+   * @param properties The values to log.  Note that this does not take
+   *                   a callback.
+   * @since 0.11.0
    */
-  static readonly DefaultProjectId: ProjectId;
-  constructor(services: LikeC4SharedServices);
+  debug(properties: Record<string, unknown>): void;
   /**
-   * Checks if a document is excluded by workspace-level patterns.
-   * These patterns come from VS Code settings and take precedence over project-level excludes.
+   * Lazily log a debug message.  Use this when the message values are expensive
+   * to compute and should only be computed if the message is actually logged.
+   *
+   * ```typescript
+   * logger.debug(l => l`A debug message with ${expensiveValue()}.`);
+   * ```
+   *
+   * @param callback A callback that returns the message template prefix.
+   * @throws {TypeError} If no log record was made inside the callback.
    */
-  isExcludedByWorkspace(uri: NormalizedUri | URI): boolean;
+  debug(callback: LogCallback): void;
   /**
-   * Updates the workspace-level exclude patterns from VS Code settings.
-   * Called during initial server startup; dynamic changes restart the server.
+   * Log an informational message.  Use this as a template string prefix.
+   *
+   * ```typescript
+   * logger.info `An info message with ${value}.`;
+   * ```
+   *
+   * @param message The message template strings array.
+   * @param values The message template values.
    */
-  setWorkspaceExcludePatterns(patterns: string[] | undefined): void;
+  info(message: TemplateStringsArray, ...values: readonly unknown[]): void;
   /**
-   * Returns:
-   *  - configured default project ID if set
-   *  - the default project ID if there are no projects.
-   *  - the ID of the only project
-   *  - undefined if there are multiple projects.
+   * Log an informational message with properties.
+   *
+   * ```typescript
+   * logger.info('An info message with {value}.', { value });
+   * ```
+   *
+   * If the properties are expensive to compute, you can pass a callback that
+   * returns the properties:
+   *
+   * ```typescript
+   * logger.info(
+   *   'An info message with {value}.',
+   *   () => ({ value: expensiveComputation() })
+   * );
+   * ```
+   *
+   * @param message The message template.  Placeholders to be replaced with
+   *                `values` are indicated by keys in curly braces (e.g.,
+   *                `{value}`).
+   * @param properties The values to replace placeholders with.  For lazy
+   *                   evaluation, this can be a callback that returns the
+   *                   properties.
    */
-  get defaultProjectId(): ProjectId | undefined;
-  set defaultProjectId(id: string | ProjectId | undefined);
-  get default(): ProjectData;
-  get all(): NonEmptyReadonlyArray$1<ProjectId>;
-  getProject(arg: ProjectId | LangiumDocument): ProjectData;
+  info(message: string, properties?: Record<string, unknown> | (() => Record<string, unknown>)): void;
   /**
-   * Returns all projects that overlap with the specified folder (is parent or child)
+   * Log an informational message with properties computed asynchronously.
+   *
+   * Use this when the properties require async operations to compute:
+   *
+   * ```typescript
+   * await logger.info(
+   *   'An info message with {value}.',
+   *   async () => ({ value: await fetchValue() })
+   * );
+   * ```
+   *
+   * @param message The message template.  Placeholders to be replaced with
+   *                `values` are indicated by keys in curly braces (e.g.,
+   *                `{value}`).
+   * @param properties An async callback that returns the properties.
+   * @returns A promise that resolves when the log is written.
+   * @since 2.0.0
    */
-  findOverlaped(folder: URI | string): ReadonlyArray<ProjectData>;
+  info(message: string, properties: () => Promise<Record<string, unknown>>): Promise<void>;
   /**
-   * Validates and ensures the project ID.
-   * If no project ID is specified, returns default project ID
-   * If there are multiple projects and default project is not set, throws an error
+   * Log an informational values with no message.  This is useful when you
+   * want to log properties without a message, e.g., when you want to log
+   * the context of a request or an operation.
+   *
+   * ```typescript
+   * logger.info({ method: 'GET', url: '/api/v1/resource' });
+   * ```
+   *
+   * Note that this is a shorthand for:
+   *
+   * ```typescript
+   * logger.info('{*}', { method: 'GET', url: '/api/v1/resource' });
+   * ```
+   *
+   * If the properties are expensive to compute, you cannot use this shorthand
+   * and should use the following syntax instead:
+   *
+   * ```typescript
+   * logger.info('{*}', () => ({
+   *   method: expensiveMethod(),
+   *   url: expensiveUrl(),
+   * }));
+   * ```
+   *
+   * @param properties The values to log.  Note that this does not take
+   *                   a callback.
+   * @since 0.11.0
    */
-  ensureProjectId(projectId?: ProjectId | undefined): ProjectId;
+  info(properties: Record<string, unknown>): void;
   /**
-   * Validates and ensures the project data.
-   * If projectId is not specified, returns default project
+   * Lazily log an informational message.  Use this when the message values are
+   * expensive to compute and should only be computed if the message is actually
+   * logged.
    *
-   * If there are multiple projects and default project is not set, throws an error
+   * ```typescript
+   * logger.info(l => l`An info message with ${expensiveValue()}.`);
+   * ```
    *
-   * @see ensureProjectId - to validate project ID only
+   * @param callback A callback that returns the message template prefix.
+   * @throws {TypeError} If no log record was made inside the callback.
    */
-  ensureProject(projectId?: ProjectId | undefined): ProjectData;
-  hasMultipleProjects(): boolean;
+  info(callback: LogCallback): void;
   /**
-   * Checks if given document (or URI) must be excluded from processing.
+   * Log a warning.
+   *
+   * This overload is a shorthand for logging an {@link Error} instance as a
+   * structured property.
+   *
+   * ```typescript
+   * logger.warn(new Error("Oops"));
+   * ```
+   *
+   * Note that this uses `{error.message}` as the default message template.
+   * If you want to include the stack trace in text output, include `{error}`
+   * in the message template instead.
+   *
+   * @param error The error to log.
+   * @since 2.0.0
    */
-  isExcluded(document: DocOrUri): boolean;
+  warn(error: Error): void;
   /**
-   * Checks if given document (or URI) must be excluded in the context of the project.
+   * Log a warning with additional properties.
+   *
+   * This overload is a shorthand for logging an {@link Error} instance as a
+   * structured property while also adding extra properties.
+   *
+   * ```typescript
+   * logger.warn(new Error("Oops"), { requestId });
+   * ```
+   *
+   * @param error The error to log.
+   * @param properties Additional properties to log alongside the error.
+   * @since 2.1.0
    */
-  isExcluded(projectId: ProjectId, document: DocOrUri): boolean;
+  warn(error: Error, properties?: Record<string, unknown> | (() => Record<string, unknown>)): void;
   /**
-   * Checks if the specified document is included by the project:
-   * - if the document belongs to the project and is not excluded
-   * - if the document is included by the project
+   * Log a warning with additional properties computed asynchronously.
+   *
+   * @param error The error to log.
+   * @param properties An async callback that returns the properties.
+   * @returns A promise that resolves when the log is written.
+   * @since 2.1.0
    */
-  isIncluded(projectId: ProjectId, document: LangiumDocument | URI | string): boolean;
+  warn(error: Error, properties: () => Promise<Record<string, unknown>>): Promise<void>;
   /**
-   * Registers likec4 project by config file.
+   * Log a warning message with an {@link Error}.
+   *
+   * ```typescript
+   * logger.warn("Failed to do something", new Error("Oops"));
+   * ```
+   *
+   * @param message The message.
+   * @param error The error to log.
+   * @since 2.0.0
    */
-  registerConfigFile(configUri: URI, cancelToken?: CancellationToken$1): Promise<ProjectData>;
+  warn(message: string, error: Error): void;
   /**
-   * Registers (or reloads) likec4 project by config file or config object.
-   * If there is some project registered at same folder, it will be reloaded.
+   * Log a warning message.  Use this as a template string prefix.
+   *
+   * ```typescript
+   * logger.warn `A warning message with ${value}.`;
+   * ```
+   *
+   * @param message The message template strings array.
+   * @param values The message template values.
    */
-  registerProject(opts: RegisterProjectOptions, cancelToken?: CancellationToken$1): Promise<ProjectData>;
+  warn(message: TemplateStringsArray, ...values: readonly unknown[]): void;
   /**
-   * Determines which project the given document belongs to.
-   * If the document does not belong to any project, returns the default project ID.
+   * Log a warning message with properties.
+   *
+   * ```typescript
+   * logger.warn('A warning message with {value}.', { value });
+   * ```
+   *
+   * If the properties are expensive to compute, you can pass a callback that
+   * returns the properties:
+   *
+   * ```typescript
+   * logger.warn(
+   *   'A warning message with {value}.',
+   *   () => ({ value: expensiveComputation() })
+   * );
+   * ```
+   *
+   * @param message The message template.  Placeholders to be replaced with
+   *                `values` are indicated by keys in curly braces (e.g.,
+   *                `{value}`).
+   * @param properties The values to replace placeholders with.  For lazy
+   *                   evaluation, this can be a callback that returns the
+   *                   properties.
    */
-  ownerProjectId(document: LangiumDocument | URI | string): ProjectId;
+  warn(message: string, properties?: Record<string, unknown> | (() => Record<string, unknown>)): void;
   /**
-   * Returns path to the document relative to the project folder.
-   * If the document does not belong to any project, returns the document URI as string.
+   * Log a warning message with properties computed asynchronously.
+   *
+   * Use this when the properties require async operations to compute:
+   *
+   * ```typescript
+   * await logger.warn(
+   *   'A warning message with {value}.',
+   *   async () => ({ value: await fetchValue() })
+   * );
+   * ```
+   *
+   * @param message The message template.  Placeholders to be replaced with
+   *                `values` are indicated by keys in curly braces (e.g.,
+   *                `{value}`).
+   * @param properties An async callback that returns the properties.
+   * @returns A promise that resolves when the log is written.
+   * @since 2.0.0
    */
-  relativePath(document: LangiumDocument | URI | string): string;
+  warn(message: string, properties: () => Promise<Record<string, unknown>>): Promise<void>;
   /**
-   * Returns true if the manager is currently initializing or reloading projects.
-   * This is used to prevent duplicate reload operations.
+   * Log a warning values with no message.  This is useful when you
+   * want to log properties without a message, e.g., when you want to log
+   * the context of a request or an operation.
+   *
+   * ```typescript
+   * logger.warn({ method: 'GET', url: '/api/v1/resource' });
+   * ```
+   *
+   * Note that this is a shorthand for:
+   *
+   * ```typescript
+   * logger.warn('{*}', { method: 'GET', url: '/api/v1/resource' });
+   * ```
+   *
+   * If the properties are expensive to compute, you cannot use this shorthand
+   * and should use the following syntax instead:
+   *
+   * ```typescript
+   * logger.warn('{*}', () => ({
+   *   method: expensiveMethod(),
+   *   url: expensiveUrl(),
+   * }));
+   * ```
+   *
+   * @param properties The values to log.  Note that this does not take
+   *                   a callback.
+   * @since 0.11.0
    */
-  protected get isInitiatingOrReloading(): boolean;
-  reloadProjects(cancelToken?: CancellationToken$1): Promise<void>;
-  protected _reloadProjects(cancelToken?: CancellationToken$1): Promise<void>;
-  protected uniqueProjectId(name: string): ProjectId;
-  protected resetCaches(): void;
-  rebuildProject(projectId: ProjectId, cancelToken?: CancellationToken$1): Promise<void>;
+  warn(properties: Record<string, unknown>): void;
   /**
-   * Returns all include paths from all projects.
-   * Used by WorkspaceManager to scan additional directories for C4 files.
+   * Lazily log a warning message.  Use this when the message values are
+   * expensive to compute and should only be computed if the message is actually
+   * logged.
+   *
+   * ```typescript
+   * logger.warn(l => l`A warning message with ${expensiveValue()}.`);
+   * ```
+   *
+   * @param callback A callback that returns the message template prefix.
+   * @throws {TypeError} If no log record was made inside the callback.
    */
-  getAllIncludePaths(): Array<{
-    projectId: ProjectId;
-    includePath: URI;
-    includeConfig: IncludeConfig;
+  warn(callback: LogCallback): void;
+  /**
+   * Log a warning.
+   *
+   * This overload is a shorthand for logging an {@link Error} instance as a
+   * structured property.
+   *
+   * ```typescript
+   * logger.warning(new Error("Oops"));
+   * ```
+   *
+   * Note that this uses `{error.message}` as the default message template.
+   * If you want to include the stack trace in text output, include `{error}`
+   * in the message template instead.
+   *
+   * @param error The error to log.
+   * @since 2.0.0
+   */
+  warning(error: Error): void;
+  /**
+   * Log a warning with additional properties.
+   *
+   * This overload is a shorthand for logging an {@link Error} instance as a
+   * structured property while also adding extra properties.
+   *
+   * ```typescript
+   * logger.warning(new Error("Oops"), { requestId });
+   * ```
+   *
+   * @param error The error to log.
+   * @param properties Additional properties to log alongside the error.
+   * @since 2.1.0
+   */
+  warning(error: Error, properties?: Record<string, unknown> | (() => Record<string, unknown>)): void;
+  /**
+   * Log a warning with additional properties computed asynchronously.
+   *
+   * @param error The error to log.
+   * @param properties An async callback that returns the properties.
+   * @returns A promise that resolves when the log is written.
+   * @since 2.1.0
+   */
+  warning(error: Error, properties: () => Promise<Record<string, unknown>>): Promise<void>;
+  /**
+   * Log a warning message with an {@link Error}.
+   *
+   * ```typescript
+   * logger.warning("Failed to do something", new Error("Oops"));
+   * ```
+   *
+   * @param message The message.
+   * @param error The error to log.
+   * @since 2.0.0
+   */
+  warning(message: string, error: Error): void;
+  /**
+   * Log a warning message.  Use this as a template string prefix.
+   *
+   * ```typescript
+   * logger.warning `A warning message with ${value}.`;
+   * ```
+   *
+   * @param message The message template strings array.
+   * @param values The message template values.
+   * @since 0.12.0
+   */
+  warning(message: TemplateStringsArray, ...values: readonly unknown[]): void;
+  /**
+   * Log a warning message with properties.
+   *
+   * ```typescript
+   * logger.warning('A warning message with {value}.', { value });
+   * ```
+   *
+   * If the properties are expensive to compute, you can pass a callback that
+   * returns the properties:
+   *
+   * ```typescript
+   * logger.warning(
+   *   'A warning message with {value}.',
+   *   () => ({ value: expensiveComputation() })
+   * );
+   * ```
+   *
+   * @param message The message template.  Placeholders to be replaced with
+   *                `values` are indicated by keys in curly braces (e.g.,
+   *                `{value}`).
+   * @param properties The values to replace placeholders with.  For lazy
+   *                   evaluation, this can be a callback that returns the
+   *                   properties.
+   * @since 0.12.0
+   */
+  warning(message: string, properties?: Record<string, unknown> | (() => Record<string, unknown>)): void;
+  /**
+   * Log a warning message with properties computed asynchronously.
+   *
+   * Use this when the properties require async operations to compute:
+   *
+   * ```typescript
+   * await logger.warning(
+   *   'A warning message with {value}.',
+   *   async () => ({ value: await fetchValue() })
+   * );
+   * ```
+   *
+   * @param message The message template.  Placeholders to be replaced with
+   *                `values` are indicated by keys in curly braces (e.g.,
+   *                `{value}`).
+   * @param properties An async callback that returns the properties.
+   * @returns A promise that resolves when the log is written.
+   * @since 2.0.0
+   */
+  warning(message: string, properties: () => Promise<Record<string, unknown>>): Promise<void>;
+  /**
+   * Log a warning values with no message.  This is useful when you
+   * want to log properties without a message, e.g., when you want to log
+   * the context of a request or an operation.
+   *
+   * ```typescript
+   * logger.warning({ method: 'GET', url: '/api/v1/resource' });
+   * ```
+   *
+   * Note that this is a shorthand for:
+   *
+   * ```typescript
+   * logger.warning('{*}', { method: 'GET', url: '/api/v1/resource' });
+   * ```
+   *
+   * If the properties are expensive to compute, you cannot use this shorthand
+   * and should use the following syntax instead:
+   *
+   * ```typescript
+   * logger.warning('{*}', () => ({
+   *   method: expensiveMethod(),
+   *   url: expensiveUrl(),
+   * }));
+   * ```
+   *
+   * @param properties The values to log.  Note that this does not take
+   *                   a callback.
+   * @since 0.12.0
+   */
+  warning(properties: Record<string, unknown>): void;
+  /**
+   * Lazily log a warning message.  Use this when the message values are
+   * expensive to compute and should only be computed if the message is actually
+   * logged.
+   *
+   * ```typescript
+   * logger.warning(l => l`A warning message with ${expensiveValue()}.`);
+   * ```
+   *
+   * @param callback A callback that returns the message template prefix.
+   * @throws {TypeError} If no log record was made inside the callback.
+   * @since 0.12.0
+   */
+  warning(callback: LogCallback): void;
+  /**
+   * Log an error.
+   *
+   * This overload is a shorthand for logging an {@link Error} instance as a
+   * structured property.
+   *
+   * ```typescript
+   * logger.error(new Error("Oops"));
+   * ```
+   *
+   * Note that this uses `{error.message}` as the default message template.
+   * If you want to include the stack trace in text output, include `{error}`
+   * in the message template instead.
+   *
+   * @param error The error to log.
+   * @since 2.0.0
+   */
+  error(error: Error): void;
+  /**
+   * Log an error with additional properties.
+   *
+   * This overload is a shorthand for logging an {@link Error} instance as a
+   * structured property while also adding extra properties.
+   *
+   * ```typescript
+   * logger.error(new Error("Oops"), { requestId });
+   * ```
+   *
+   * If the properties are expensive to compute, you can pass a callback that
+   * returns the properties:
+   *
+   * ```typescript
+   * logger.error(
+   *   new Error("Oops"),
+   *   () => ({ requestId: expensiveLookup() })
+   * );
+   * ```
+   *
+   * @param error The error to log.
+   * @param properties Additional properties to log alongside the error.
+   * @since 2.1.0
+   */
+  error(error: Error, properties?: Record<string, unknown> | (() => Record<string, unknown>)): void;
+  /**
+   * Log an error with additional properties computed asynchronously.
+   *
+   * Use this when the properties require async operations to compute:
+   *
+   * ```typescript
+   * await logger.error(
+   *   new Error("Oops"),
+   *   async () => ({ requestId: await fetchRequestId() })
+   * );
+   * ```
+   *
+   * @param error The error to log.
+   * @param properties An async callback that returns the properties.
+   * @returns A promise that resolves when the log is written.
+   * @since 2.1.0
+   */
+  error(error: Error, properties: () => Promise<Record<string, unknown>>): Promise<void>;
+  /**
+   * Log an error message with an {@link Error}.
+   *
+   * ```typescript
+   * logger.error("Failed to do something", new Error("Oops"));
+   * ```
+   *
+   * @param message The message.
+   * @param error The error to log.
+   * @since 2.0.0
+   */
+  error(message: string, error: Error): void;
+  /**
+   * Log an error message.  Use this as a template string prefix.
+   *
+   * ```typescript
+   * logger.error `An error message with ${value}.`;
+   * ```
+   *
+   * @param message The message template strings array.
+   * @param values The message template values.
+   */
+  error(message: TemplateStringsArray, ...values: readonly unknown[]): void;
+  /**
+   * Log an error message with properties.
+   *
+   * ```typescript
+   * logger.warn('An error message with {value}.', { value });
+   * ```
+   *
+   * If the properties are expensive to compute, you can pass a callback that
+   * returns the properties:
+   *
+   * ```typescript
+   * logger.error(
+   *   'An error message with {value}.',
+   *   () => ({ value: expensiveComputation() })
+   * );
+   * ```
+   *
+   * @param message The message template.  Placeholders to be replaced with
+   *                `values` are indicated by keys in curly braces (e.g.,
+   *                `{value}`).
+   * @param properties The values to replace placeholders with.  For lazy
+   *                   evaluation, this can be a callback that returns the
+   *                   properties.
+   */
+  error(message: string, properties?: Record<string, unknown> | (() => Record<string, unknown>)): void;
+  /**
+   * Log an error message with properties computed asynchronously.
+   *
+   * Use this when the properties require async operations to compute:
+   *
+   * ```typescript
+   * await logger.error(
+   *   'An error message with {value}.',
+   *   async () => ({ value: await fetchValue() })
+   * );
+   * ```
+   *
+   * @param message The message template.  Placeholders to be replaced with
+   *                `values` are indicated by keys in curly braces (e.g.,
+   *                `{value}`).
+   * @param properties An async callback that returns the properties.
+   * @returns A promise that resolves when the log is written.
+   * @since 2.0.0
+   */
+  error(message: string, properties: () => Promise<Record<string, unknown>>): Promise<void>;
+  /**
+   * Log an error values with no message.  This is useful when you
+   * want to log properties without a message, e.g., when you want to log
+   * the context of a request or an operation.
+   *
+   * ```typescript
+   * logger.error({ method: 'GET', url: '/api/v1/resource' });
+   * ```
+   *
+   * Note that this is a shorthand for:
+   *
+   * ```typescript
+   * logger.error('{*}', { method: 'GET', url: '/api/v1/resource' });
+   * ```
+   *
+   * If the properties are expensive to compute, you cannot use this shorthand
+   * and should use the following syntax instead:
+   *
+   * ```typescript
+   * logger.error('{*}', () => ({
+   *   method: expensiveMethod(),
+   *   url: expensiveUrl(),
+   * }));
+   * ```
+   *
+   * @param properties The values to log.  Note that this does not take
+   *                   a callback.
+   * @since 0.11.0
+   */
+  error(properties: Record<string, unknown>): void;
+  /**
+   * Lazily log an error message.  Use this when the message values are
+   * expensive to compute and should only be computed if the message is actually
+   * logged.
+   *
+   * ```typescript
+   * logger.error(l => l`An error message with ${expensiveValue()}.`);
+   * ```
+   *
+   * @param callback A callback that returns the message template prefix.
+   * @throws {TypeError} If no log record was made inside the callback.
+   */
+  error(callback: LogCallback): void;
+  /**
+   * Log a fatal error.
+   *
+   * This overload is a shorthand for logging an {@link Error} instance as a
+   * structured property.
+   *
+   * ```typescript
+   * logger.fatal(new Error("Oops"));
+   * ```
+   *
+   * Note that this uses `{error.message}` as the default message template.
+   * If you want to include the stack trace in text output, include `{error}`
+   * in the message template instead.
+   *
+   * @param error The error to log.
+   * @since 2.0.0
+   */
+  fatal(error: Error): void;
+  /**
+   * Log a fatal error with additional properties.
+   *
+   * This overload is a shorthand for logging an {@link Error} instance as a
+   * structured property while also adding extra properties.
+   *
+   * ```typescript
+   * logger.fatal(new Error("Oops"), { requestId });
+   * ```
+   *
+   * @param error The error to log.
+   * @param properties Additional properties to log alongside the error.
+   * @since 2.1.0
+   */
+  fatal(error: Error, properties?: Record<string, unknown> | (() => Record<string, unknown>)): void;
+  /**
+   * Log a fatal error with additional properties computed asynchronously.
+   *
+   * @param error The error to log.
+   * @param properties An async callback that returns the properties.
+   * @returns A promise that resolves when the log is written.
+   * @since 2.1.0
+   */
+  fatal(error: Error, properties: () => Promise<Record<string, unknown>>): Promise<void>;
+  /**
+   * Log a fatal error message with an {@link Error}.
+   *
+   * ```typescript
+   * logger.fatal("Failed to do something", new Error("Oops"));
+   * ```
+   *
+   * @param message The message.
+   * @param error The error to log.
+   * @since 2.0.0
+   */
+  fatal(message: string, error: Error): void;
+  /**
+   * Log a fatal error message.  Use this as a template string prefix.
+   *
+   * ```typescript
+   * logger.fatal `A fatal error message with ${value}.`;
+   * ```
+   *
+   * @param message The message template strings array.
+   * @param values The message template values.
+   */
+  fatal(message: TemplateStringsArray, ...values: readonly unknown[]): void;
+  /**
+   * Log a fatal error message with properties.
+   *
+   * ```typescript
+   * logger.warn('A fatal error message with {value}.', { value });
+   * ```
+   *
+   * If the properties are expensive to compute, you can pass a callback that
+   * returns the properties:
+   *
+   * ```typescript
+   * logger.fatal(
+   *   'A fatal error message with {value}.',
+   *   () => ({ value: expensiveComputation() })
+   * );
+   * ```
+   *
+   * @param message The message template.  Placeholders to be replaced with
+   *                `values` are indicated by keys in curly braces (e.g.,
+   *                `{value}`).
+   * @param properties The values to replace placeholders with.  For lazy
+   *                   evaluation, this can be a callback that returns the
+   *                   properties.
+   */
+  fatal(message: string, properties?: Record<string, unknown> | (() => Record<string, unknown>)): void;
+  /**
+   * Log a fatal error message with properties computed asynchronously.
+   *
+   * Use this when the properties require async operations to compute:
+   *
+   * ```typescript
+   * await logger.fatal(
+   *   'A fatal error message with {value}.',
+   *   async () => ({ value: await fetchValue() })
+   * );
+   * ```
+   *
+   * @param message The message template.  Placeholders to be replaced with
+   *                `values` are indicated by keys in curly braces (e.g.,
+   *                `{value}`).
+   * @param properties An async callback that returns the properties.
+   * @returns A promise that resolves when the log is written.
+   * @since 2.0.0
+   */
+  fatal(message: string, properties: () => Promise<Record<string, unknown>>): Promise<void>;
+  /**
+   * Log a fatal error values with no message.  This is useful when you
+   * want to log properties without a message, e.g., when you want to log
+   * the context of a request or an operation.
+   *
+   * ```typescript
+   * logger.fatal({ method: 'GET', url: '/api/v1/resource' });
+   * ```
+   *
+   * Note that this is a shorthand for:
+   *
+   * ```typescript
+   * logger.fatal('{*}', { method: 'GET', url: '/api/v1/resource' });
+   * ```
+   *
+   * If the properties are expensive to compute, you cannot use this shorthand
+   * and should use the following syntax instead:
+   *
+   * ```typescript
+   * logger.fatal('{*}', () => ({
+   *   method: expensiveMethod(),
+   *   url: expensiveUrl(),
+   * }));
+   * ```
+   *
+   * @param properties The values to log.  Note that this does not take
+   *                   a callback.
+   * @since 0.11.0
+   */
+  fatal(properties: Record<string, unknown>): void;
+  /**
+   * Lazily log a fatal error message.  Use this when the message values are
+   * expensive to compute and should only be computed if the message is actually
+   * logged.
+   *
+   * ```typescript
+   * logger.fatal(l => l`A fatal error message with ${expensiveValue()}.`);
+   * ```
+   *
+   * @param callback A callback that returns the message template prefix.
+   * @throws {TypeError} If no log record was made inside the callback.
+   */
+  fatal(callback: LogCallback): void;
+  /**
+   * Emits a log record with custom fields while using this logger's
+   * category.
+   *
+   * This is a low-level API for integration scenarios where you need full
+   * control over the log record, particularly for preserving timestamps
+   * from external systems.
+   *
+   * ```typescript
+   * const logger = getLogger(["my-app", "integration"]);
+   *
+   * // Emit a log with a custom timestamp
+   * logger.emit({
+   *   timestamp: kafkaLog.originalTimestamp,
+   *   level: "info",
+   *   message: [kafkaLog.message],
+   *   rawMessage: kafkaLog.message,
+   *   properties: {
+   *     source: "kafka",
+   *     partition: kafkaLog.partition,
+   *     offset: kafkaLog.offset,
+   *   },
+   * });
+   * ```
+   *
+   * @param record Log record without category field (category comes from
+   *               the logger instance)
+   * @since 1.1.0
+   */
+  emit(record: Omit<LogRecord, "category">): void;
+  /**
+   * Check if a message of the given severity level would be processed by
+   * this logger.
+   *
+   * This is useful for conditionally executing expensive computations
+   * before logging, particularly for async operations where lazy
+   * evaluation callbacks cannot be used:
+   *
+   * ```typescript
+   * if (logger.isEnabledFor("debug")) {
+   *   const result = await expensiveAsync();
+   *   logger.debug("Result: {result}", { result });
+   * }
+   * ```
+   *
+   * @param level The log level to check.
+   * @returns `true` if a message of the given level would be logged,
+   *          `false` otherwise.
+   * @since 2.0.0
+   */
+  isEnabledFor(level: LogLevel): boolean;
+}
+/**
+ * A logging callback function.  It is used to defer the computation of a
+ * message template until it is actually logged.
+ * @param prefix The message template prefix.
+ * @returns The rendered message array.
+ */
+type LogCallback = (prefix: LogTemplatePrefix) => unknown[];
+/**
+ * A logging template prefix function.  It is used to log a message in
+ * a {@link LogCallback} function.
+ * @param message The message template strings array.
+ * @param values The message template values.
+ * @returns The rendered message array.
+ */
+type LogTemplatePrefix = (message: TemplateStringsArray, ...values: unknown[]) => unknown[];
+//#endregion
+//#region ../layouts/dist/chunks/types.d.mts
+/**
+ * invisible edge added by AI to enforce better layout
+ */
+interface AIEnforcementEdge {
+  source: NodeId;
+  target: NodeId;
+  weight?: number;
+  minlen?: number;
+}
+/**
+ * Complete set of AI-generated layout hints.
+ * This is the JSON schema the LLM must produce.
+ */
+interface AILayoutHints {
+  direction?: 'TB' | 'BT' | 'LR' | 'RL';
+  ranks: ReadonlyArray<{
+    rank: 'same' | 'source' | 'sink' | 'min' | 'max';
+    nodes: NonEmptyArray<NodeId>;
   }>;
+  edgeWeight: Record<EdgeId, number>;
+  edgeMinlen: Record<EdgeId, number>;
   /**
-   * Register a listener to be called when the projects configuration has changed.
-   * @returns A disposable that can be used to unregister the callback.
+   * These edges should be reversed in DOT
+   * Unique array of EdgeIds.
    */
-  onProjectsUpdate(callback: () => void): Disposable$1;
-  private getWorkspaceFolder;
-  private notifyListeners;
-  private updateIncludesExcludes;
-  private warnIfConfigOverride;
-} //#endregion
-//#region src/filesystem/types.d.ts
-interface FileNode extends FileSystemNode {
-  readonly isFile: true;
-  readonly isDirectory: false;
+  reverseRank?: NonEmptyReadonlyArray<EdgeId>;
+  /**
+   * These edges should be excluded, i.e. `constraint=false` in Graphviz, to allow more flexible layouts.
+   * Unique array of EdgeIds.
+   */
+  excludeFromRanking?: NonEmptyReadonlyArray<EdgeId>;
+  /**
+   * Suggested order of edges for DOT output, to influence edge routing.
+   */
+  edgeOrder?: NonEmptyReadonlyArray<EdgeId>;
+  /**
+   * Suggested order of nodes for DOT output, to influence node placement.
+   */
+  nodeOrder?: NonEmptyReadonlyArray<NodeId>;
+  /**
+   * Invisible edges added by AI to enforce better layout
+   */
+  invisibleEdges?: NonEmptyReadonlyArray<AIEnforcementEdge>;
+  /**
+   * LLM reasoning for debugging/display
+   */
+  reasoning: string;
 }
-interface FileSystemProvider$1 extends FileSystemProvider {
+//#endregion
+//#region ../language-server/dist/chunks/protocol.d.mts
+/**
+ * When server requests to open a likec4 preview panel
+ * (available only in the editor).
+ * (not the best place, but seems to be working)
+ */
+declare namespace DidRequestOpenViewNotification {
+  type Params = {
+    viewId: ViewId$1;
+    projectId: ProjectId$1;
+  };
+  const type: NotificationType<Params>;
+  type Type = typeof type;
+}
+/**
+ * Request to locate an element, relation, deployment or view.
+ * If LSP has multiple projects, the projectId is required.
+ */
+declare namespace Locate {
+  type Params =
   /**
-   * Scans the project files for the given URI.
-   * @returns The list of file system entries that are contained within the specified directory.
+   * Locate an element by its fqn
    */
-  scanProjectFiles(folderUri: URI): Promise<FileNode[]>;
+  {
+    element: Fqn$1;
+    projectId?: string | undefined;
+    property?: string;
+  } |
   /**
-   * Loads the project config from the given file.
-   * @returns The project config.
-   * @throws Error if the file does not exist or is not a valid project config.
+   * Locate a relation by its id
    */
-  loadProjectConfig(filepath: URI): Promise<LikeC4ProjectConfig>;
+  {
+    projectId?: string | undefined;
+    relation: RelationId;
+  } |
   /**
-   * Reads the directory and returns LikeC4 files.
-   *
-   * @param options.recursive If true, recursively reads the directory,
-   * @param options.maxDepth Maximum depth to traverse when recursive is true (default: Infinity)
+   * Locate a deployment by its fqn
    */
-  readDirectory(uri: URI, options?: {
-    recursive?: boolean;
-    maxDepth?: number;
-  }): Promise<FileNode[]>;
+  {
+    deployment: DeploymentFqn;
+    projectId?: string | undefined;
+    property?: string;
+  } |
   /**
-   * Finds all files in the given directory, matching the given filter.
+   * Locate a step in a dynamic view by its astPath
    */
-  scanDirectory(directory: URI, filter: (filepath: string, isDirectory: boolean) => boolean): Promise<FileNode[]>;
+  {
+    view: ViewId$1;
+    astPath: string;
+    projectId?: string | undefined;
+  } |
   /**
-   * Writes the content to the file system.
-   * Used by manual layouts.
+   * Locate a view by its id
    */
-  writeFile(uri: URI, content: string): Promise<void>;
+  {
+    view: ViewId$1;
+    projectId?: string | undefined;
+  };
+  type Res = Location | null;
+  const req: RequestType<Params, Res, void>;
+  type Req = typeof req;
+}
+/**
+ * Request to change the view
+ * If LSP has multiple projects, the projectId is required.
+ */
+declare namespace ChangeView {
+  type Params = {
+    viewId: ViewId$1;
+    change: ViewChange;
+    projectId?: string | undefined;
+  };
+  type Res = {
+    success: true;
+    location: Location | null;
+  } | {
+    success: false;
+    location?: Location | null;
+    error: string;
+  };
+  const req: RequestType<Params, Res, void>;
+  type Req = typeof req;
+}
+//#endregion
+//#region ../layouts/dist/chunks/GraphvizLayoter.d.mts
+//#region src/graphviz/types.d.ts
+/**
+ * Partially implements CancellationToken interface from vscode-jsonrpc
+ */
+type CancellationToken = {
   /**
-   * Deletes the file from the file system.
-   * Used by manual layouts.
-   * @return true if the file was deleted, false if the file did not exist.
+   * Is `true` when the token has been cancelled, `false` otherwise.
    */
-  deleteFile(uri: URI): Promise<boolean>;
+  readonly isCancellationRequested: boolean;
+};
+declare module 'ts-graphviz' {
+  namespace GraphAttributeKey {
+    interface $values extends $keywords<'likec4_viewId'> {}
+  }
+  namespace ClusterSubgraphAttributeKey {
+    interface $values extends $keywords<'likec4_type' | 'likec4_path' | 'likec4_id' | 'likec4_level' | 'likec4_depth'> {}
+  }
+  namespace NodeAttributeKey {
+    interface $values extends $keywords<'likec4_type' | 'likec4_path' | 'likec4_id' | 'likec4_project' | 'likec4_level'> {}
+  }
+  namespace EdgeAttributeKey {
+    interface $values extends $keywords<'likec4_id' | 'likec4_project'> {}
+  }
+  namespace Attribute {
+    interface $keys extends $keywords<'likec4_viewId' | 'likec4_type' | 'likec4_path' | 'likec4_id' | 'likec4_project' | 'likec4_level' | 'likec4_depth'> {}
+    interface $types {
+      likec4_viewId: string;
+      likec4_type: 'folder' | 'file' | 'view';
+      likec4_path: string;
+      likec4_id: string;
+      likec4_project: string;
+      likec4_level: number;
+      likec4_depth: number;
+    }
+  }
+}
+type DotSource = Tagged<string, 'DotSource'>;
+//#endregion
+//#region src/graphviz/types-dot.d.ts
+type GvNodeName = Tagged<string, 'GvNodeName'>;
+type GvId = Tagged<number, 'GvId'>;
+type Point = [x: number, y: number];
+interface GraphvizJson {
+  name: GvNodeName;
+  directed: boolean;
+  strict: boolean;
+  _draw_: GraphvizJson.Draw[];
+  bb: string;
+  compound: string;
+  fontname: string;
+  fontsize: string;
+  label: string;
+  nodesep: string;
+  outputorder: string;
+  rankdir: string;
+  ranksep: string;
+  splines: string;
+  xdotversion: string;
+  _subgraph_cnt: number;
+  objects?: GraphvizJson.GvObject[];
+  edges?: GraphvizJson.Edge[];
+}
+declare namespace GraphvizJson {
+  interface Draw {
+    op: string;
+    grad: string;
+    color: string;
+    points: Point[];
+  }
+  interface Draw2 {
+    op: string;
+    grad: string;
+    color: string;
+    points: Point[];
+  }
+  namespace DrawOps {
+    type Style = {
+      op: 'S';
+      style: string;
+    };
+    type BSpline = {
+      op: 'b' | 'B';
+      points: Point[];
+    };
+    type Color = {
+      op: 'c';
+      grad: string;
+      color: string;
+    };
+    type Polygon = {
+      op: 'p' | 'P';
+      points: Point[];
+    };
+  }
+  type DrawOp = DrawOps.Style | DrawOps.BSpline | DrawOps.Color | DrawOps.Polygon;
+  type LabelDrawOps = {
+    op: 'F';
+    size: number;
+    face: string;
+  } | {
+    op: 'c';
+    color: string;
+  } | {
+    op: 't';
+    fontchar: number;
+  } | {
+    op: 'T';
+    pt: Point;
+    align: 'l' | 'r' | 'c';
+    width: number;
+    text: string;
+  };
+  type GvObject = GvNodeObject | GvSubgraph;
+  interface GvSubgraph {
+    bb: string;
+    label?: string;
+    compound: 'true';
+    _ldraw_?: LabelDrawOps[];
+    likec4_type?: 'folder' | 'file';
+    likec4_path?: string;
+    likec4_id?: Fqn$1;
+    likec4_level?: number;
+    likec4_depth?: number;
+    _gvid: GvId;
+    subgraphs?: GvId[];
+    nodes?: GvId[];
+    edges?: GvId[];
+  }
+  interface GvNodeObject {
+    _draw_: Draw[];
+    _ldraw_?: LabelDrawOps[];
+    likec4_type?: 'folder' | 'file' | 'view';
+    likec4_path?: string;
+    likec4_id?: Fqn$1;
+    likec4_level?: number;
+    _gvid: GvId;
+    height: string;
+    pos: string;
+    shape: 'rect';
+    width: string;
+    label?: string;
+  }
+  interface Draw3 {
+    op: string;
+    grad: string;
+    color: string;
+    points: Point[];
+  }
+  interface Hdraw {
+    op: string;
+    style: string;
+    grad: string;
+    color: string;
+    points: Point[];
+  }
+  interface Edge {
+    _gvid: GvId;
+    tail: GvId;
+    head: GvId;
+    dir?: 'forward' | 'back' | 'both' | 'none';
+    _draw_: DrawOp[];
+    _hdraw_?: DrawOp[];
+    _tdraw_?: DrawOp[];
+    _ldraw_?: LabelDrawOps[];
+    _tldraw_?: LabelDrawOps[];
+    _hldraw_?: LabelDrawOps[];
+    fontname: string;
+    fontsize: string;
+    likec4_id?: EdgeId$1;
+    label: string;
+    lp: string;
+    nojustify?: 'true' | 'false';
+    pos?: string;
+  }
 }
-interface FileSystemWatcher extends AsyncDisposable {
-  /**
-   * Watches a folder for changes and triggers a reload of the documents and projects.
-   */
-  watch(folder: string): void;
+//#endregion
+//#region src/graphviz/GraphvizLayoter.d.ts
+interface GraphvizPort extends Disposable {
+  get name(): string;
+  get concurrency(): number;
+  unflatten(dot: DotSource): Promise<DotSource>;
+  acyclic(dot: DotSource): Promise<DotSource>;
+  layoutJson(dot: DotSource): Promise<string>;
+  svg(dot: DotSource): Promise<string>;
+  dispose(): void;
 }
-type ManualLayoutsSnapshot = {
-  hash: string;
-  views: Record<ViewId, LayoutedView>;
+type LayoutTaskParams<A extends aux$1.Any = aux$1.Any> = {
+  view: ComputedView<A>;
+  styles: LikeC4Styles$1;
 };
-type ManualLayoutUpdateEvent = {
-  updated: URI;
-  projectId: ProjectId;
-  viewId: ViewId;
-} | {
-  removed: URI;
-  projectId: ProjectId;
+type LayoutResult<A extends aux$1.Any = aux$1.Any> = {
+  dot: DotSource;
+  diagram: DiagramView<A>;
+};
+declare class GraphvizLayouter implements Disposable {
+  private graphviz;
+  constructor(graphviz?: GraphvizPort);
+  dispose(): void;
+  [Symbol.dispose](): void;
+  get graphvizPort(): GraphvizPort;
+  changePort(graphviz: GraphvizPort): void;
   /**
-   * Missing if triggered by FS event (file was deleted)
+   * Generates DOT source for the given view and styles.
+   * If `hints` are provided, they will be used to influence the layout (e.g. by specifying node/edge order).
+   * This method does not perform unflattening or any other post-processing on the DOT output, so it may be used for debugging or to generate DOT for external processing.
    */
-  viewId?: ViewId;
-};
-type ManualLayoutUpdateListener = (event: ManualLayoutUpdateEvent) => void;
-interface LikeC4ManualLayouts {
+  printToDot(params: LayoutTaskParams, hints?: AILayoutHints): DotSource;
+  protected newScopedLogger(operation: string): any;
+  dotToJson(dot: DotSource): Promise<GraphvizJson>;
+  layout<A extends AnyAux>(params: LayoutTaskParams<A>): Promise<LayoutResult<A>>;
+  aiLayout<A extends AnyAux>({ view, styles }: LayoutTaskParams<A>, hints: AILayoutHints): Promise<LayoutResult<A>>;
+  svg<A extends AnyAux>(params: LayoutTaskParams<A>): Promise<{
+    svg: string;
+    dot: DotSource;
+  }>;
+  dot<A extends AnyAux>(params: LayoutTaskParams<A>): Promise<DotSource>;
+  layoutProjectsView(view: ComputedProjectsView): Promise<LayoutedProjectsView>;
+}
+//#endregion
+//#region ../layouts/dist/index.d.mts
+//#region src/graphviz/QueueGraphvizLayoter.d.ts
+declare class QueueGraphvizLayoter extends GraphvizLayouter {
+  private queue;
+  private isProcessingBatch;
+  constructor(options?: {
+    graphviz?: GraphvizPort;
+    /**
+     * Concurrency limit.
+     * Minimum: `1`.
+     * @default 2
+     */
+    concurrency?: number;
+    /**
+     * Per-operation timeout in milliseconds. Operations fulfill once `timeout` elapses if they haven't already.
+     * @default 20_000
+     */
+    timeout?: number;
+    /**
+     * Whether or not a timeout is considered an exception.
+     * @default true
+     */
+    throwOnTimeout?: boolean;
+  });
+  private runInQueue;
+  changePort(graphvizPort: GraphvizPort): void;
+  layout<A extends AnyAux>(params: LayoutTaskParams<A>): Promise<LayoutResult<A>>;
+  layoutProjectsView(view: ComputedProjectsView): Promise<LayoutedProjectsView>;
+  batchLayout<A extends AnyAux>(params: {
+    batch: LayoutTaskParams<A>[];
+    cancelToken?: CancellationToken | undefined;
+    onSuccess?: (task: LayoutTaskParams<A>, result: LayoutResult<A>) => void;
+    onError?: (task: LayoutTaskParams<A>, error: unknown) => void;
+  }): Promise<LayoutResult<A>[]>;
   /**
-   * Reads a single layouted view from the file system by its URI.
-   * Used by the language server to get the current layout state.
+   * Custom backpressure
+   * (basically allow same amount of tasks to be in queue as concurrency)
    */
-  readSnapshot(uri: URI): Promise<LayoutedView | null>;
-  read(project: Project): Promise<ManualLayoutsSnapshot | null>;
-  write(project: Project, layouted: LayoutedView): Promise<Location>;
-  remove(project: Project, view: ViewId): Promise<Location | null>;
-  clearCaches(): void;
+  private waitForQueueToShrink;
+  dispose(): void;
+}
+//#endregion
+//#region ../language-server/dist/chunks/module.d.mts
+//#region src/documentation/documentation-provider.d.ts
+/**
+ * Provides documentation for LikeC4 AST nodes, extending JSDoc parsing
+ * with specialized formatting for deployment nodes, deployed instances, and elements.
+ */
+declare class LikeC4DocumentationProvider extends JSDocDocumentationProvider {
+  private parser;
+  private locator;
   /**
-   * Registers a listener for manual layout updates.
-   * The listener will be called when a manual layout is created, updated, or deleted.
+   * Creates a new documentation provider.
+   * @param services - The LikeC4 language services.
    */
-  onManualLayoutUpdate(listener: ManualLayoutUpdateListener): Disposable$1;
+  constructor(services: LikeC4Services);
   /**
-   * Handles file system updates for manual layouts.
-   * Used by the file system watcher to notify the manual layouts module of changes.
-   * @param event The file system event
+   * Returns documentation for the given AST node (deployment nodes, deployed instances, elements, or JSDoc fallback).
+   * @param node - The AST node to document.
+   * @returns Formatted documentation string, or undefined if none.
    */
-  handleFileSystemUpdate(event: {
-    update: URI;
-    delete?: never;
-  } | {
-    delete: URI;
-    update?: never;
-  }): Promise<void>;
-} //#endregion
-//#region src/filesystem/noop.d.ts
-//#endregion
-//#region src/formatting/LikeC4Formatter.d.ts
-type QuoteStyle = 'single' | 'double' | 'ignore' | 'auto';
-interface LikeC4FormatterOptions {
-  quoteStyle: QuoteStyle;
+  getDocumentation(node: AstNode): string | undefined;
 }
-type ExtendedFormattingCommandType = 'normalizeQuotes';
-interface ExtendedFormattingCommand {
-  type: ExtendedFormattingCommandType;
-  region: FormattingRegion;
+//#endregion
+//#region src/utils/disposable.d.ts
+declare abstract class ADisposable implements Disposable$1 {
+  protected toDispose: Disposable$1[];
+  protected isDisposed: boolean;
+  onDispose(...disposable: Disposable$1[]): void;
+  dispose(): void;
+  protected throwIfDisposed(): void;
 }
-declare class LikeC4Formatter extends AbstractFormatter {
-  protected options: LikeC4FormatterOptions;
-  extendedFormattingCommands: ExtendedFormattingCommand[];
-  constructor(services: LikeC4Services);
-  protected doDocumentFormat(document: LangiumDocument, options: FormattingOptions, range?: Range): TextEdit[];
-  protected format(node: AstNode): void;
-  protected formatTags(node: AstNode): void;
-  protected formatDeploymentRelation(node: AstNode): void;
-  protected formatExtendDeployment(node: AstNode): void;
-  protected formatRelation(node: AstNode): void;
-  protected removeIndentFromTopLevelStatements(node: AstNode): void;
-  protected indentContentInBraces(node: AstNode): void;
-  protected appendKeywordsWithSpace(node: AstNode): void;
-  protected formatView(node: AstNode): void;
-  protected formatLeafProperty(node: AstNode): void;
-  protected formatLinkProperty(node: AstNode): void;
-  protected formatNavigateToProperty(node: AstNode): void;
-  protected formatAutolayoutProperty(node: AstNode): void;
-  protected formatMetadataProperty(node: AstNode): void;
-  protected formatElementDeclaration(node: AstNode): void;
-  protected formatExtendElement(node: AstNode): void;
-  protected formatGlobals(node: AstNode): void;
-  protected formatImports(node: AstNode): void;
-  protected formatSpecificationRule(node: AstNode): void;
-  protected formatWithPredicate(node: AstNode): void;
-  protected formatDeploymentNodeDeclaration(node: AstNode): void;
-  protected formatDeployedInstance(node: AstNode): void;
-  protected formatViewRuleGlobalStyle(node: AstNode): void;
-  protected formatViewRuleGlobalPredicate(node: AstNode): void;
-  protected formatViewRuleGroup(node: AstNode): void;
-  protected formatViewRuleStyle(node: AstNode): void;
-  protected formatWhereExpression(node: AstNode): void;
-  protected formatWhereRelationExpression(node: AstNode): void;
-  protected formatWhereElementExpression(node: AstNode): void;
-  protected formatIncludeExcludeExpressions(node: AstNode): void;
-  protected formatRelationExpression(node: AstNode): void;
-  private findPredicateExpressionRoot;
-  private on;
-  private doExtendedFormatting;
-  protected normalizeQuotes(node: AstNode): void;
-  private quotesNormalizerFactory;
-  private escapeQuotesInternalQuotes;
-  private getAutoQuoteStyle;
-  private onConfigurationUpdate;
-} //#endregion
+//#endregion
 //#region src/generated/ast.d.ts
-type AnyProperty = DynamicViewProperty | ElementProperty | NavigateToProperty | NotationProperty | NotesProperty | RelationProperty | RelationshipStyleProperty | StringProperty | StyleProperty | ViewProperty;
+type AnyProperty = DynamicViewProperty | ElementProperty | NavigateToProperty | RelationProperty | RelationshipStyleProperty | StringProperty | StyleProperty | ViewProperty;
 declare const AnyProperty = "AnyProperty";
 type ArrowType = 'crow' | 'diamond' | 'dot' | 'none' | 'normal' | 'odiamond' | 'odot' | 'onormal' | 'open' | 'vee';
 type BorderStyleValue = 'none' | LineOptions;
@@ -766,13 +1589,13 @@ type DynamicViewProperty = DynamicViewDisplayVariantProperty | ViewProperty;
 declare const DynamicViewProperty = "DynamicViewProperty";
 type DynamicViewRule = DynamicViewGlobalPredicateRef | DynamicViewIncludePredicate | ViewRuleAutoLayout | ViewRuleStyleOrGlobalRef;
 declare const DynamicViewRule = "DynamicViewRule";
-type DynamicViewStep = DynamicStepChain | DynamicStepSingle;
-declare const DynamicViewStep = "DynamicViewStep";
 type ElementProperty = ElementStringProperty | ElementStyleProperty | IconProperty | LinkProperty | MetadataProperty;
 declare const ElementProperty = "ElementProperty";
 type ElementShape = 'browser' | 'bucket' | 'component' | 'cylinder' | 'document' | 'mobile' | 'person' | 'queue' | 'rectangle' | 'storage';
 type ExpressionV2 = FqnExprOrWith | RelationExprOrWith;
 declare const ExpressionV2 = "ExpressionV2";
+type ExtendElementOrRelation = ExtendElement | ExtendRelation;
+declare const ExtendElementOrRelation = "ExtendElementOrRelation";
 type ExtendElementProperty = LinkProperty | MetadataProperty;
 declare const ExtendElementProperty = "ExtendElementProperty";
 type ExtendRelationProperty = LinkProperty | MetadataProperty;
@@ -796,6 +1619,8 @@ type MetadataProperty = MetadataBody;
 declare const MetadataProperty = "MetadataProperty";
 type MetadataValue = MarkdownOrString | MetadataArray;
 declare const MetadataValue = "MetadataValue";
+type ModelElement = Element | ExtendElementOrRelation | Relation;
+declare const ModelElement = "ModelElement";
 type ModelReferenceable = Element | Imported;
 declare const ModelReferenceable = "ModelReferenceable";
 type Participant = 'source' | 'target';
@@ -815,11 +1640,17 @@ declare const RelationshipStyleProperty = "RelationshipStyleProperty";
 type SizeProperty = IconSizeProperty | PaddingSizeProperty | ShapeSizeProperty | TextSizeProperty;
 declare const SizeProperty = "SizeProperty";
 type SizeValue = 'large' | 'lg' | 'md' | 'medium' | 'sm' | 'small' | 'xl' | 'xlarge' | 'xs' | 'xsmall';
+type StepOrSeries = Step | StepSeries;
+declare const StepOrSeries = "StepOrSeries";
+type StepStatement = AltSteps | StepOrSeries | SubflowStep | TryStep;
+declare const StepStatement = "StepStatement";
 type StringProperty = ElementStringProperty | MetadataAttribute | NotationProperty | NotesProperty | RelationStringProperty | SpecificationElementStringProperty | SpecificationRelationshipStringProperty | ViewStringProperty;
 declare const StringProperty = "StringProperty";
 type StyleProperty = BorderProperty | ColorProperty | IconColorProperty | IconPositionProperty | IconProperty | IconSizeProperty | MultipleProperty | OpacityProperty | PaddingSizeProperty | ShapeProperty | ShapeSizeProperty | TextSizeProperty;
 declare const StyleProperty = "StyleProperty";
 type ThemeColor = 'amber' | 'blue' | 'gray' | 'green' | 'indigo' | 'muted' | 'primary' | 'red' | 'secondary' | 'sky' | 'slate';
+type TryStep = CatchBlock | FinallyBlock | TryBlock;
+declare const TryStep = "TryStep";
 type Uri = string;
 type ViewLayoutDirection = 'BottomTop' | 'LeftRight' | 'RightLeft' | 'TopBottom';
 type ViewProperty = LinkProperty | ViewStringProperty;
@@ -844,16 +1675,23 @@ type WhereRelationExpression = WhereBinaryExpression | WhereRelation | WhereRela
 declare const WhereRelationExpression = "WhereRelationExpression";
 type WhereTagEqual = WhereElementTag | WhereRelationParticipantTag | WhereRelationTag;
 declare const WhereTagEqual = "WhereTagEqual";
-interface AbstractDynamicStep extends AstNode {
-  readonly $container: DynamicStepChain | DynamicViewBody | DynamicViewParallelSteps;
-  readonly $type: 'AbstractDynamicStep' | 'DynamicStepChain' | 'DynamicStepSingle';
+interface AbstractStep extends AstNode {
+  readonly $container: DynamicViewBody | StepSeries | StepsBlock;
+  readonly $type: 'AbstractStep' | 'Step' | 'StepSeries';
   custom?: CustomRelationProperties;
   dotKind?: RelationKindDotRef;
   kind?: Reference<RelationshipKind>;
   target: ElementRef;
   title?: string;
 }
-declare const AbstractDynamicStep = "AbstractDynamicStep";
+declare const AbstractStep = "AbstractStep";
+interface AltSteps extends AstNode {
+  readonly $container: DynamicViewBody | StepsBlock;
+  readonly $type: 'AltSteps';
+  branches: Array<SubflowStep>;
+  title?: string;
+}
+declare const AltSteps = "AltSteps";
 interface ArrowProperty extends AstNode {
   readonly $container: CustomRelationProperties | RelationStyleProperty | SpecificationRelationshipKind;
   readonly $type: 'ArrowProperty';
@@ -868,6 +1706,14 @@ interface BorderProperty extends AstNode {
   value: BorderStyleValue;
 }
 declare const BorderProperty = "BorderProperty";
+interface CatchBlock extends AstNode {
+  readonly $container: DynamicViewBody | FinallyBlock | StepsBlock;
+  readonly $type: 'CatchBlock';
+  catch: StepsBlock;
+  title?: string;
+  try: TryBlock;
+}
+declare const CatchBlock = "CatchBlock";
 interface ColorProperty extends AstNode {
   readonly $container: CustomElementProperties | CustomRelationProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | RelationStyleProperty | SpecificationRelationshipKind | ViewRuleGroup | ViewRuleStyle;
   readonly $type: 'ColorProperty';
@@ -889,7 +1735,7 @@ interface CustomElementProperties extends AstNode {
 }
 declare const CustomElementProperties = "CustomElementProperties";
 interface CustomRelationProperties extends AstNode {
-  readonly $container: AbstractDynamicStep | RelationExprWith;
+  readonly $container: AbstractStep | RelationExprWith;
   readonly $type: 'CustomRelationProperties';
   props: Array<MultipleProperty | NotationProperty | NotesProperty | RelationNavigateToProperty | RelationStringProperty | RelationshipStyleProperty>;
 }
@@ -1005,7 +1851,7 @@ interface DynamicViewBody extends AstNode {
   readonly $type: 'DynamicViewBody';
   props: Array<DynamicViewProperty>;
   rules: Array<DynamicViewRule>;
-  steps: Array<DynamicViewParallelSteps | DynamicViewStep>;
+  steps: Array<StepStatement>;
   tags?: Tags;
 }
 declare const DynamicViewBody = "DynamicViewBody";
@@ -1027,13 +1873,7 @@ interface DynamicViewIncludePredicate extends AstNode {
   readonly $type: 'DynamicViewIncludePredicate';
   exprs: Expressions;
 }
-declare const DynamicViewIncludePredicate = "DynamicViewIncludePredicate";
-interface DynamicViewParallelSteps extends AstNode {
-  readonly $container: DynamicViewBody;
-  readonly $type: 'DynamicViewParallelSteps';
-  steps: Array<DynamicViewStep>;
-}
-declare const DynamicViewParallelSteps = "DynamicViewParallelSteps";
+declare const DynamicViewIncludePredicate = "DynamicViewIncludePredicate";
 interface DynamicViewRef extends AstNode {
   readonly $container: RelationNavigateToProperty;
   readonly $type: 'DynamicViewRef';
@@ -1071,7 +1911,7 @@ interface ElementKindExpression extends AstNode {
 }
 declare const ElementKindExpression = "ElementKindExpression";
 interface ElementRef extends AstNode {
-  readonly $container: AbstractDynamicStep | DeployedInstance | DynamicStepSingle | ElementView;
+  readonly $container: AbstractStep | DeployedInstance | ElementView | Step;
   readonly $type: 'ElementRef';
   modelElement: FqnRef$2;
 }
@@ -1175,6 +2015,14 @@ interface ExtendRelationBody extends AstNode {
   tags?: Tags;
 }
 declare const ExtendRelationBody = "ExtendRelationBody";
+interface FinallyBlock extends AstNode {
+  readonly $container: DynamicViewBody | StepsBlock;
+  readonly $type: 'FinallyBlock';
+  finally: StepsBlock;
+  title?: string;
+  tryCatch: CatchBlock | TryBlock;
+}
+declare const FinallyBlock = "FinallyBlock";
 interface FqnExpressions extends AstNode {
   readonly $container: DeploymentViewRuleStyle | FqnExpressions | GlobalStyle | ViewRuleRank | ViewRuleStyle;
   readonly $type: 'FqnExpressions';
@@ -1346,7 +2194,7 @@ interface LineProperty extends AstNode {
 }
 declare const LineProperty = "LineProperty";
 interface LinkProperty extends AstNode {
-  readonly $container: DeployedInstanceBody | DeploymentNodeBody | DeploymentRelationBody | DeploymentViewBody | DynamicViewBody | ElementBody | ElementViewBody | ExtendDeploymentBody | ExtendElementBody | ExtendRelationBody | RelationBody | SpecificationDeploymentNodeKind | SpecificationElementKind;
+  readonly $container: DeployedInstanceBody | DeploymentNodeBody | DeploymentRelationBody | DeploymentViewBody | DynamicViewBody | ElementBody | ElementViewBody | ExtendDeploymentBody | ExtendElementBody | ExtendRelationBody | RelationBody | SpecificationDeploymentNodeKind | SpecificationElementKind | SpecificationRelationshipKind;
   readonly $type: 'LinkProperty';
   key: 'link';
   title?: string;
@@ -1383,7 +2231,7 @@ declare const MetadataBody = "MetadataBody";
 interface Model extends AstNode {
   readonly $container: LikeC4Grammar;
   readonly $type: 'Model';
-  elements: Array<Element | ExtendElement | ExtendRelation | Relation>;
+  elements: Array<ModelElement>;
   name: 'model';
 }
 declare const Model = "Model";
@@ -1490,7 +2338,7 @@ interface RelationExprWith extends AstNode {
 }
 declare const RelationExprWith = "RelationExprWith";
 interface RelationKindDotRef extends AstNode {
-  readonly $container: AbstractDynamicStep | DeploymentRelation | ExtendRelation | OutgoingRelationExpr | Relation;
+  readonly $container: AbstractStep | DeploymentRelation | ExtendRelation | OutgoingRelationExpr | Relation;
   readonly $type: 'RelationKindDotRef';
   kind: Reference<RelationshipKind>;
 }
@@ -1579,13 +2427,14 @@ interface SpecificationRelationshipKind extends AstNode {
   readonly $container: SpecificationRule;
   readonly $type: 'SpecificationRelationshipKind';
   kind: RelationshipKind;
-  props: Array<MultipleProperty | RelationshipStyleProperty | SpecificationRelationshipStringProperty>;
+  props: Array<LinkProperty | MultipleProperty | RelationshipStyleProperty | SpecificationRelationshipStringProperty>;
+  tags?: Tags;
 }
 declare const SpecificationRelationshipKind = "SpecificationRelationshipKind";
 interface SpecificationRelationshipStringProperty extends AstNode {
   readonly $container: SpecificationRelationshipKind;
   readonly $type: 'SpecificationRelationshipStringProperty';
-  key: 'notation' | 'technology';
+  key: 'description' | 'notation' | 'technology' | 'title';
   value: MarkdownOrString;
 }
 declare const SpecificationRelationshipStringProperty = "SpecificationRelationshipStringProperty";
@@ -1607,6 +2456,12 @@ interface SpecificationTag extends AstNode {
   tag: Tag$1;
 }
 declare const SpecificationTag = "SpecificationTag";
+interface StepsBlock extends AstNode {
+  readonly $container: AltSteps | CatchBlock | DynamicViewBody | FinallyBlock | StepsBlock;
+  readonly $type: 'StepsBlock' | 'SubflowStep' | 'TryBlock';
+  steps: Array<StepStatement>;
+}
+declare const StepsBlock = "StepsBlock";
 interface StrictFqnElementRef extends AstNode {
   readonly $container: ExtendElement | StrictFqnElementRef;
   readonly $type: 'StrictFqnElementRef';
@@ -1634,7 +2489,7 @@ interface TagRef extends AstNode {
 }
 declare const TagRef = "TagRef";
 interface Tags extends AstNode {
-  readonly $container: DeployedInstanceBody | DeploymentNodeBody | DeploymentRelation | DeploymentRelationBody | DeploymentViewBody | DynamicViewBody | ElementBody | ElementViewBody | ExtendDeploymentBody | ExtendElementBody | ExtendRelationBody | Relation | RelationBody | SpecificationDeploymentNodeKind | SpecificationElementKind | Tags;
+  readonly $container: DeployedInstanceBody | DeploymentNodeBody | DeploymentRelation | DeploymentRelationBody | DeploymentViewBody | DynamicViewBody | ElementBody | ElementViewBody | ExtendDeploymentBody | ExtendElementBody | ExtendRelationBody | Relation | RelationBody | SpecificationDeploymentNodeKind | SpecificationElementKind | SpecificationRelationshipKind | Tags;
   readonly $type: 'Tags';
   prev?: Tags;
   values: Array<TagRef>;
@@ -1820,24 +2675,47 @@ interface WildcardExpression extends AstNode {
   isWildcard: boolean;
 }
 declare const WildcardExpression = "WildcardExpression";
-interface DynamicStepChain extends AbstractDynamicStep {
-  readonly $container: DynamicStepChain | DynamicViewBody | DynamicViewParallelSteps;
-  readonly $type: 'DynamicStepChain';
-  source: DynamicStepChain | DynamicStepSingle;
-}
-declare const DynamicStepChain = "DynamicStepChain";
-interface DynamicStepSingle extends AbstractDynamicStep {
-  readonly $container: DynamicStepChain | DynamicViewBody | DynamicViewParallelSteps;
-  readonly $type: 'DynamicStepSingle';
+/**
+ * A single step in a dynamic view flow
+ * source -> target
+ */
+interface Step extends AbstractStep {
+  readonly $container: DynamicViewBody | StepSeries | StepsBlock;
+  readonly $type: 'Step';
   isBackward: boolean;
   source: ElementRef;
 }
-declare const DynamicStepSingle = "DynamicStepSingle";
+declare const Step = "Step";
+/**
+ * A series of steps in a dynamic view flow
+ * source -> target1 -> target2 -> ...
+ */
+interface StepSeries extends AbstractStep {
+  readonly $container: DynamicViewBody | StepSeries | StepsBlock;
+  readonly $type: 'StepSeries';
+  source: Step | StepSeries;
+}
+declare const StepSeries = "StepSeries";
+interface SubflowStep extends StepsBlock {
+  readonly $container: AltSteps | DynamicViewBody | StepsBlock;
+  readonly $type: 'SubflowStep';
+  kind: 'break' | 'else' | 'if' | 'loop' | 'opt' | 'par' | 'parallel' | 'when';
+  title?: string;
+}
+declare const SubflowStep = "SubflowStep";
+interface TryBlock extends StepsBlock {
+  readonly $container: CatchBlock | DynamicViewBody | FinallyBlock | StepsBlock;
+  readonly $type: 'TryBlock';
+  title?: string;
+}
+declare const TryBlock = "TryBlock";
 type LikeC4AstType = {
-  AbstractDynamicStep: AbstractDynamicStep;
+  AbstractStep: AbstractStep;
+  AltSteps: AltSteps;
   AnyProperty: AnyProperty;
   ArrowProperty: ArrowProperty;
   BorderProperty: BorderProperty;
+  CatchBlock: CatchBlock;
   ColorLiteral: ColorLiteral$1;
   ColorProperty: ColorProperty;
   CustomColor: CustomColor;
@@ -1858,18 +2736,14 @@ type LikeC4AstType = {
   DeploymentViewRulePredicate: DeploymentViewRulePredicate;
   DeploymentViewRuleStyle: DeploymentViewRuleStyle;
   DirectedRelationExpr: DirectedRelationExpr;
-  DynamicStepChain: DynamicStepChain;
-  DynamicStepSingle: DynamicStepSingle;
   DynamicView: DynamicView;
   DynamicViewBody: DynamicViewBody;
   DynamicViewDisplayVariantProperty: DynamicViewDisplayVariantProperty;
   DynamicViewGlobalPredicateRef: DynamicViewGlobalPredicateRef;
   DynamicViewIncludePredicate: DynamicViewIncludePredicate;
-  DynamicViewParallelSteps: DynamicViewParallelSteps;
   DynamicViewProperty: DynamicViewProperty;
   DynamicViewRef: DynamicViewRef;
   DynamicViewRule: DynamicViewRule;
-  DynamicViewStep: DynamicViewStep;
   Element: Element;
   ElementBody: ElementBody;
   ElementKind: ElementKind;
@@ -1888,10 +2762,12 @@ type LikeC4AstType = {
   ExtendDeploymentBody: ExtendDeploymentBody;
   ExtendElement: ExtendElement;
   ExtendElementBody: ExtendElementBody;
+  ExtendElementOrRelation: ExtendElementOrRelation;
   ExtendElementProperty: ExtendElementProperty;
   ExtendRelation: ExtendRelation;
   ExtendRelationBody: ExtendRelationBody;
   ExtendRelationProperty: ExtendRelationProperty;
+  FinallyBlock: FinallyBlock;
   FqnExpr: FqnExpr$2;
   FqnExprOrWhere: FqnExprOrWhere;
   FqnExprOrWith: FqnExprOrWith;
@@ -1930,6 +2806,7 @@ type LikeC4AstType = {
   MetadataValue: MetadataValue;
   Model: Model;
   ModelDeployments: ModelDeployments;
+  ModelElement: ModelElement;
   ModelReferenceable: ModelReferenceable;
   ModelViews: ModelViews;
   MultipleProperty: MultipleProperty;
@@ -1966,14 +2843,22 @@ type LikeC4AstType = {
   SpecificationRelationshipStringProperty: SpecificationRelationshipStringProperty;
   SpecificationRule: SpecificationRule;
   SpecificationTag: SpecificationTag;
+  Step: Step;
+  StepOrSeries: StepOrSeries;
+  StepSeries: StepSeries;
+  StepStatement: StepStatement;
+  StepsBlock: StepsBlock;
   StrictFqnElementRef: StrictFqnElementRef;
   StrictFqnRef: StrictFqnRef;
   StringProperty: StringProperty;
   StyleProperty: StyleProperty;
+  SubflowStep: SubflowStep;
   Tag: Tag$1;
   TagRef: TagRef;
   Tags: Tags;
   TextSizeProperty: TextSizeProperty;
+  TryBlock: TryBlock;
+  TryStep: TryStep;
   ViewProperty: ViewProperty;
   ViewRef: ViewRef;
   ViewRule: ViewRule;
@@ -2008,7 +2893,8 @@ type LikeC4AstType = {
   WhereRelationTag: WhereRelationTag;
   WhereTagEqual: WhereTagEqual;
   WildcardExpression: WildcardExpression;
-}; //#endregion
+};
+//#endregion
 //#region src/validation/DocumentValidator.d.ts
 declare class LikeC4DocumentValidator extends DefaultDocumentValidator {
   protected services: LikeC4Services;
@@ -2017,7 +2903,8 @@ declare class LikeC4DocumentValidator extends DefaultDocumentValidator {
    * If the document is excluded, then we skip validation and return an empty array of diagnostics.
    */
   validateDocument(document: LangiumDocument, options?: ValidationOptions, cancelToken?: CancellationToken$1): Promise<Diagnostic[]>;
-} //#endregion
+}
+//#endregion
 //#region src/validation/index.d.ts
 declare const isValidatableAstNode: any;
 type ValidatableAstNode = GuardedBy<typeof isValidatableAstNode>;
@@ -2026,7 +2913,8 @@ declare function checksFromDiagnostics(doc: LikeC4LangiumDocument): {
   invalidNodes: WeakSet<WeakKey>;
 };
 type ChecksFromDiagnostics = ReturnType<typeof checksFromDiagnostics>;
-type IsValidFn = ChecksFromDiagnostics['isValid']; //#endregion
+type IsValidFn = ChecksFromDiagnostics['isValid'];
+//#endregion
 //#region src/ast.d.ts
 declare module 'langium' {
   interface LangiumDocument {
@@ -2077,15 +2965,7 @@ interface ParsedAstSpecification {
     color?: c4.ColorLiteral;
   }>;
   elements: Record<c4.ElementKind, c4.ElementSpecification>;
-  relationships: Record<c4.RelationshipKind, {
-    technology?: string;
-    notation?: string;
-    color?: c4.Color;
-    line?: c4.RelationshipLineType;
-    head?: c4.RelationshipArrowType;
-    tail?: c4.RelationshipArrowType;
-    multiple?: boolean;
-  }>;
+  relationships: Record<c4.RelationshipKind, c4.RelationshipSpecification>;
   colors: Record<c4.CustomColor, {
     color: c4.ColorLiteral;
   }>;
@@ -2166,54 +3046,365 @@ interface ParsedAstElementView {
   links: c4.NonEmptyArray<c4.Link> | null;
   rules: c4.ElementViewRule[];
 }
-interface ParsedAstDynamicView {
-  id: c4.ViewId;
-  astPath: string;
-  title: string | null;
-  description: c4.MarkdownOrString | null;
-  tags: c4.NonEmptyArray<c4.Tag> | null;
-  links: c4.NonEmptyArray<c4.Link> | null;
-  steps: c4.DynamicViewStep[];
-  rules: Array<c4.DynamicViewRule>;
-  variant: c4.DynamicViewDisplayVariant | undefined;
+interface ParsedAstDynamicView {
+  id: c4.ViewId;
+  astPath: string;
+  title: string | null;
+  description: c4.MarkdownOrString | null;
+  tags: c4.NonEmptyArray<c4.Tag> | null;
+  links: c4.NonEmptyArray<c4.Link> | null;
+  steps: c4.Step.Any[];
+  rules: Array<c4.DynamicViewRule>;
+  variant: c4.DynamicViewDisplayVariant | undefined;
+}
+interface ParsedAstDeploymentView {
+  id: c4.ViewId;
+  astPath: string;
+  title: string | null;
+  description: c4.MarkdownOrString | null;
+  tags: c4.NonEmptyArray<c4.Tag> | null;
+  links: c4.NonEmptyArray<c4.Link> | null;
+  rules: Array<c4.DeploymentViewRule>;
+}
+type ParsedAstView = ParsedAstElementView | ParsedAstDynamicView | ParsedAstDeploymentView;
+interface AstNodeDescriptionWithFqn extends AstNodeDescription {
+  likec4ProjectId: c4.ProjectId;
+  id: c4.Fqn;
+}
+type LikeC4AstNode = ValueOf<ConditionalPick<LikeC4AstType, AstNode>>;
+type LikeC4DocumentDiagnostic = Diagnostic & DiagnosticInfo<LikeC4AstNode>;
+interface LikeC4DocumentProps {
+  diagnostics?: Array<LikeC4DocumentDiagnostic>;
+  c4Specification?: ParsedAstSpecification;
+  c4Elements?: ParsedAstElement[];
+  c4ExtendElements?: ParsedAstExtend[];
+  c4ExtendDeployments?: ParsedAstExtend[];
+  c4ExtendRelations?: ParsedAstExtendRelation[];
+  c4Relations?: ParsedAstRelation[];
+  c4Globals?: ParsedAstGlobals;
+  c4Views?: ParsedAstView[];
+  c4Deployments?: ParsedAstDeployment[];
+  c4DeploymentRelations?: ParsedAstDeploymentRelation[];
+  c4Imports?: MultiMap<c4.ProjectId, c4.Fqn, Set<c4.Fqn>>;
+}
+type LikeC4GrammarDocument = Omit<LangiumDocument<LikeC4Grammar>, 'diagnostics'>;
+interface LikeC4LangiumDocument extends LikeC4GrammarDocument, LikeC4DocumentProps {
+  likec4ProjectId: c4.ProjectId;
+}
+interface ParsedLikeC4LangiumDocument extends LikeC4GrammarDocument, Required<LikeC4DocumentProps> {
+  likec4ProjectId: c4.ProjectId;
+}
+//#endregion
+//#region src/workspace/ProjectsManager.d.ts
+type NormalizedUri = Tagged<string, 'NormalizedUri'>;
+type DocOrUri = LangiumDocument | string | URI;
+/**
+ * A tagged string that represents a project folder URI (with trailing slash).
+ * Used in `startsWith` checks to determine if a document belongs to a project.
+ */
+type ProjectFolder = Tagged<string, 'ProjectFolder'>;
+declare function ProjectFolder(folder: URI | string): ProjectFolder;
+interface Project {
+  id: ProjectId;
+  folderUri: URI;
+  config: LikeC4ProjectConfig;
+}
+interface ProjectData extends Project {
+  id: ProjectId;
+  folder: ProjectFolder;
+  config: LikeC4ProjectConfig;
+  configUri: URI;
+  folderUri: URI;
+  exclude?: {
+    (test: string): boolean;
+  };
+  /**
+   * Resolved include paths with both URI and folder string representations.
+   * These are additional directories that are part of this project.
+   */
+  includePaths?: NonEmptyArray$1<{
+    uri: URI;
+    folder: ProjectFolder;
+  }>;
+  /**
+   * Normalized include configuration (paths, maxDepth, fileThreshold).
+   */
+  includeConfig: IncludeConfig;
+}
+type RegisterProjectOptions = {
+  config: LikeC4ProjectConfig | LikeC4ProjectConfigInput;
+} & ({
+  configUri: URI | string;
+} | {
+  folderUri: URI | string;
+});
+declare class ProjectsManager extends ADisposable {
+  #private;
+  protected services: LikeC4SharedServices;
+  /**
+   * The global project ID used for all documents
+   * that are not part of a specific project.
+   */
+  static readonly DefaultProjectId: ProjectId;
+  constructor(services: LikeC4SharedServices);
+  /**
+   * Checks if a document is excluded by workspace-level patterns.
+   * These patterns come from VS Code settings and take precedence over project-level excludes.
+   */
+  isExcludedByWorkspace(uri: NormalizedUri | URI): boolean;
+  /**
+   * Updates the workspace-level exclude patterns from VS Code settings.
+   * Called during initial server startup; dynamic changes restart the server.
+   */
+  setWorkspaceExcludePatterns(patterns: string[] | undefined): void;
+  /**
+   * Returns:
+   *  - configured default project ID if set
+   *  - the default project ID if there are no projects.
+   *  - the ID of the only project
+   *  - undefined if there are multiple projects.
+   */
+  get defaultProjectId(): ProjectId | undefined;
+  set defaultProjectId(id: string | ProjectId | undefined);
+  get default(): ProjectData;
+  get all(): NonEmptyReadonlyArray$1<ProjectId>;
+  getProject(arg: ProjectId | LangiumDocument): ProjectData;
+  /**
+   * Returns all projects that overlap with the specified folder (is parent or child)
+   */
+  findOverlaped(folder: URI | string): ReadonlyArray<ProjectData>;
+  /**
+   * Validates and ensures the project ID.
+   * If no project ID is specified, returns default project ID
+   * If there are multiple projects and default project is not set, throws an error
+   */
+  ensureProjectId(projectId?: ProjectId | undefined): ProjectId;
+  /**
+   * Validates and ensures the project data.
+   * If projectId is not specified, returns default project
+   *
+   * If there are multiple projects and default project is not set, throws an error
+   *
+   * @see ensureProjectId - to validate project ID only
+   */
+  ensureProject(projectId?: ProjectId | undefined): ProjectData;
+  hasMultipleProjects(): boolean;
+  /**
+   * Checks if given document (or URI) must be excluded from processing.
+   */
+  isExcluded(document: DocOrUri): boolean;
+  /**
+   * Checks if given document (or URI) must be excluded in the context of the project.
+   */
+  isExcluded(projectId: ProjectId, document: DocOrUri): boolean;
+  /**
+   * Checks if the specified document is included by the project:
+   * - if the document belongs to the project and is not excluded
+   * - if the document is included by the project
+   */
+  isIncluded(projectId: ProjectId, document: LangiumDocument | URI | string): boolean;
+  /**
+   * Registers likec4 project by config file.
+   */
+  registerConfigFile(configUri: URI, cancelToken?: CancellationToken$1): Promise<ProjectData>;
+  /**
+   * Registers (or reloads) likec4 project by config file or config object.
+   * If there is some project registered at same folder, it will be reloaded.
+   */
+  registerProject(opts: RegisterProjectOptions, cancelToken?: CancellationToken$1): Promise<ProjectData>;
+  /**
+   * Determines which project the given document belongs to.
+   * If the document does not belong to any project, returns the default project ID.
+   */
+  ownerProjectId(document: LangiumDocument | URI | string): ProjectId;
+  protected findOwnerProject(uri: NormalizedUri): ProjectData | undefined;
+  /**
+   * Returns path to the document relative to the project folder.
+   * If the document does not belong to any project, returns the document URI as string.
+   */
+  relativePath(document: LangiumDocument | URI | string): string;
+  /**
+   * Returns true if the manager is currently initializing or reloading projects.
+   * This is used to prevent duplicate reload operations.
+   */
+  protected get isInitiatingOrReloading(): boolean;
+  reloadProjects(cancelToken?: CancellationToken$1): Promise<void>;
+  protected _reloadProjects(cancelToken?: CancellationToken$1): Promise<void>;
+  protected uniqueProjectId(name: string): ProjectId;
+  clearCaches(): void;
+  rebuildProject(projectId: ProjectId, cancelToken?: CancellationToken$1): Promise<void>;
+  /**
+   * Returns all include paths from all projects.
+   * Used by WorkspaceManager to scan additional directories for C4 files.
+   */
+  getAllIncludePaths(): Array<{
+    projectId: ProjectId;
+    includePath: URI;
+    includeConfig: IncludeConfig;
+  }>;
+  /**
+   * Register a listener to be called when the projects configuration has changed.
+   * @returns A disposable that can be used to unregister the callback.
+   */
+  onProjectsUpdate(callback: () => void): Disposable$1;
+  private getWorkspaceFolder;
+  private notifyListeners;
+  private updateIncludesExcludes;
+  private warnIfConfigOverride;
+}
+//#endregion
+//#region src/filesystem/types.d.ts
+interface FileNode extends FileSystemNode {
+  readonly isFile: true;
+  readonly isDirectory: false;
+}
+interface FileSystemProvider$1 extends FileSystemProvider {
+  /**
+   * Scans the project files for the given URI.
+   * @returns The list of file system entries that are contained within the specified directory.
+   */
+  scanProjectFiles(folderUri: URI): Promise<FileNode[]>;
+  /**
+   * Loads the project config from the given file.
+   * @returns The project config.
+   * @throws Error if the file does not exist or is not a valid project config.
+   */
+  loadProjectConfig(filepath: URI): Promise<LikeC4ProjectConfig>;
+  /**
+   * Reads the directory and returns LikeC4 files.
+   *
+   * @param options.recursive If true, recursively reads the directory,
+   * @param options.maxDepth Maximum depth to traverse when recursive is true (default: Infinity)
+   */
+  readDirectory(uri: URI, options?: {
+    recursive?: boolean;
+    maxDepth?: number;
+  }): Promise<FileNode[]>;
+  /**
+   * Finds all files in the given directory, matching the given filter.
+   */
+  scanDirectory(directory: URI, filter: (filepath: string, isDirectory: boolean) => boolean): Promise<FileNode[]>;
+  /**
+   * Writes the content to the file system.
+   * Used by manual layouts.
+   */
+  writeFile(uri: URI, content: string): Promise<void>;
+  /**
+   * Deletes the file from the file system.
+   * Used by manual layouts.
+   * @return true if the file was deleted, false if the file did not exist.
+   */
+  deleteFile(uri: URI): Promise<boolean>;
+}
+interface FileSystemWatcher extends AsyncDisposable {
+  /**
+   * Watches a folder for changes and triggers a reload of the documents and projects.
+   */
+  watch(folder: string): void;
 }
-interface ParsedAstDeploymentView {
-  id: c4.ViewId;
-  astPath: string;
-  title: string | null;
-  description: c4.MarkdownOrString | null;
-  tags: c4.NonEmptyArray<c4.Tag> | null;
-  links: c4.NonEmptyArray<c4.Link> | null;
-  rules: Array<c4.DeploymentViewRule>;
+type ManualLayoutsSnapshot = {
+  hash: string;
+  views: Record<ViewId, LayoutedView>;
+};
+type ManualLayoutUpdateEvent = {
+  updated: URI;
+  projectId: ProjectId;
+  viewId: ViewId;
+} | {
+  removed: URI;
+  projectId: ProjectId;
+  /**
+   * Missing if triggered by FS event (file was deleted)
+   */
+  viewId?: ViewId;
+};
+type ManualLayoutUpdateListener = (event: ManualLayoutUpdateEvent) => void;
+interface LikeC4ManualLayouts extends Disposable$1 {
+  /**
+   * Reads a single layouted view from the file system by its URI.
+   * Used by the language server to get the current layout state.
+   */
+  readSnapshot(uri: URI): Promise<LayoutedView | null>;
+  read(project: Project): Promise<ManualLayoutsSnapshot | null>;
+  write(project: Project, layouted: LayoutedView): Promise<Location>;
+  remove(project: Project, view: ViewId): Promise<Location | null>;
+  clearCaches(): void;
+  /**
+   * Registers a listener for manual layout updates.
+   * The listener will be called when a manual layout is created, updated, or deleted.
+   */
+  onManualLayoutUpdate(listener: ManualLayoutUpdateListener): Disposable$1;
+  /**
+   * Handles file system updates for manual layouts.
+   * Used by the file system watcher to notify the manual layouts module of changes.
+   * @param event The file system event
+   */
+  handleFileSystemUpdate(event: {
+    update: URI;
+    delete?: never;
+  } | {
+    delete: URI;
+    update?: never;
+  }): Promise<void>;
 }
-type ParsedAstView = ParsedAstElementView | ParsedAstDynamicView | ParsedAstDeploymentView;
-interface AstNodeDescriptionWithFqn extends AstNodeDescription {
-  likec4ProjectId: c4.ProjectId;
-  id: c4.Fqn;
+//#endregion
+//#region src/formatting/LikeC4Formatter.d.ts
+type QuoteStyle = 'single' | 'double' | 'ignore' | 'auto';
+interface LikeC4FormatterOptions {
+  quoteStyle: QuoteStyle;
 }
-type LikeC4AstNode = ValueOf<ConditionalPick<LikeC4AstType, AstNode>>;
-type LikeC4DocumentDiagnostic = Diagnostic & DiagnosticInfo<LikeC4AstNode>;
-interface LikeC4DocumentProps {
-  diagnostics?: Array<LikeC4DocumentDiagnostic>;
-  c4Specification?: ParsedAstSpecification;
-  c4Elements?: ParsedAstElement[];
-  c4ExtendElements?: ParsedAstExtend[];
-  c4ExtendDeployments?: ParsedAstExtend[];
-  c4ExtendRelations?: ParsedAstExtendRelation[];
-  c4Relations?: ParsedAstRelation[];
-  c4Globals?: ParsedAstGlobals;
-  c4Views?: ParsedAstView[];
-  c4Deployments?: ParsedAstDeployment[];
-  c4DeploymentRelations?: ParsedAstDeploymentRelation[];
-  c4Imports?: MultiMap<c4.ProjectId, c4.Fqn, Set<c4.Fqn>>;
+type ExtendedFormattingCommandType = 'normalizeQuotes';
+interface ExtendedFormattingCommand {
+  type: ExtendedFormattingCommandType;
+  region: FormattingRegion;
 }
-type LikeC4GrammarDocument = Omit<LangiumDocument<LikeC4Grammar>, 'diagnostics'>;
-interface LikeC4LangiumDocument extends LikeC4GrammarDocument, LikeC4DocumentProps {
-  likec4ProjectId: c4.ProjectId;
+declare class LikeC4Formatter extends AbstractFormatter {
+  protected options: LikeC4FormatterOptions;
+  extendedFormattingCommands: ExtendedFormattingCommand[];
+  constructor(services: LikeC4Services);
+  protected doDocumentFormat(document: LangiumDocument, options: FormattingOptions, range?: Range): TextEdit[];
+  protected format(node: AstNode): void;
+  protected formatTags(node: AstNode): void;
+  protected formatDeploymentRelation(node: AstNode): void;
+  protected formatExtendDeployment(node: AstNode): void;
+  protected formatRelation(node: AstNode): void;
+  protected removeIndentFromTopLevelStatements(node: AstNode): void;
+  protected indentContentInBraces(node: AstNode): void;
+  protected appendKeywordsWithSpace(node: AstNode): void;
+  protected formatView(node: AstNode): void;
+  protected formatLeafProperty(node: AstNode): void;
+  protected formatLinkProperty(node: AstNode): void;
+  protected formatNavigateToProperty(node: AstNode): void;
+  protected formatAutolayoutProperty(node: AstNode): void;
+  protected formatMetadataProperty(node: AstNode): void;
+  protected formatElementDeclaration(node: AstNode): void;
+  protected formatExtendElement(node: AstNode): void;
+  protected formatGlobals(node: AstNode): void;
+  protected formatImports(node: AstNode): void;
+  protected formatSpecificationRule(node: AstNode): void;
+  protected formatWithPredicate(node: AstNode): void;
+  protected formatDeploymentNodeDeclaration(node: AstNode): void;
+  protected formatDeployedInstance(node: AstNode): void;
+  protected formatViewRuleGlobalStyle(node: AstNode): void;
+  protected formatViewRuleGlobalPredicate(node: AstNode): void;
+  protected formatViewRuleGroup(node: AstNode): void;
+  protected formatViewRuleStyle(node: AstNode): void;
+  protected formatWhereExpression(node: AstNode): void;
+  protected formatWhereRelationExpression(node: AstNode): void;
+  protected formatWhereElementExpression(node: AstNode): void;
+  protected formatIncludeExcludeExpressions(node: AstNode): void;
+  protected formatRelationExpression(node: AstNode): void;
+  protected formatSteps(node: AstNode): void;
+  private findPredicateExpressionRoot;
+  private on;
+  private doExtendedFormatting;
+  protected normalizeQuotes(node: AstNode): void;
+  private quotesNormalizerFactory;
+  private escapeQuotesInternalQuotes;
+  private getAutoQuoteStyle;
+  private onConfigurationUpdate;
 }
-interface ParsedLikeC4LangiumDocument extends LikeC4GrammarDocument, Required<LikeC4DocumentProps> {
-  likec4ProjectId: c4.ProjectId;
-} //#endregion
+//#endregion
 //#region src/references/name-provider.d.ts
 declare class LikeC4NameProvider extends DefaultNameProvider {
   protected services: LikeC4Services;
@@ -2221,7 +3412,8 @@ declare class LikeC4NameProvider extends DefaultNameProvider {
   getNameStrict(node: AstNode): string;
   getName(node: AstNode): string | undefined;
   getNameNode(node: AstNode): CstNode | undefined;
-} //#endregion
+}
+//#endregion
 //#region src/references/scope-computation.d.ts
 type ElementsContainer = Model | ElementBody | ExtendElementBody;
 type DeploymentsContainer = ModelDeployments | DeploymentNodeBody | ExtendDeploymentBody | DeployedInstanceBody;
@@ -2237,14 +3429,16 @@ declare class LikeC4ScopeComputation extends DefaultScopeComputation {
   computeLocalScopes(document: LikeC4LangiumDocument, _cancelToken?: CancellationToken$1): Promise<PrecomputedScopes>;
   protected processContainer(container: ElementsContainer, scopes: PrecomputedScopes, document: LikeC4LangiumDocument): AstNodeDescription[];
   protected processDeployments(container: DeploymentsContainer, scopes: PrecomputedScopes, document: LikeC4LangiumDocument): AstNodeDescription[];
-} //#endregion
+}
+//#endregion
 //#region src/workspace/IndexManager.d.ts
 declare class IndexManager extends DefaultIndexManager {
   protected services: LikeC4SharedServices;
   constructor(services: LikeC4SharedServices);
   updateContent(document: LangiumDocument, cancelToken?: CancellationToken$1): Promise<void>;
   projectElements(projectId: ProjectId$1, nodeType?: string, uris?: Set<string>): Stream<AstNodeDescription>;
-} //#endregion
+}
+//#endregion
 //#region src/workspace/LangiumDocuments.d.ts
 declare class LangiumDocuments extends DefaultLangiumDocuments {
   protected services: LikeC4SharedServices;
@@ -2270,15 +3464,16 @@ declare class LangiumDocuments extends DefaultLangiumDocuments {
    * Returns the URIs
    */
   resetProjectIds(): URI[];
-} //#endregion
+}
+//#endregion
 //#region src/workspace/WorkspaceManager.d.ts
 declare class LikeC4WorkspaceManager extends DefaultWorkspaceManager {
   #private;
   private services;
-  protected readonly documentFactory: LangiumDocumentFactory;
   protected readonly fileSystemProvider: FileSystemProvider$1;
   initialBuildOptions: BuildOptions;
   constructor(services: LikeC4SharedServices);
+  protected get documentFactory(): LangiumDocumentFactory;
   /**
    * Whether the workspace is ready, use {@link ready} promise to wait for it
    */
@@ -2288,20 +3483,11 @@ declare class LikeC4WorkspaceManager extends DefaultWorkspaceManager {
    */
   protected performStartup(folders: WorkspaceFolder[]): Promise<LangiumDocument[]>;
   /**
-   * Load all additional documents that shall be visible in the context of the given workspace
-   * folders and add them to the collector. This can be used to include built-in libraries of
-   * your language, which can be either loaded from provided files or constructed in memory.
-   */
-  protected loadAdditionalDocuments(folders: WorkspaceFolder[], collector: (document: LangiumDocument) => void): Promise<void>;
-  /**
-   * Traverse the file system folder identified by the given URI and its subfolders. All
-   * contained files that match the file extensions are added to the collector.
+   * Scans all include paths (from all projects) and returns found likec4 files
    */
-  protected traverseFolder(workspaceFolder: WorkspaceFolder, folderPath: URI, selector: FileSelector, collector: (document: LangiumDocument) => void): Promise<void>;
-  /**
-   * Determine whether the given folder entry shall be included while indexing the workspace.
-   */
-  protected includeEntry(_: WorkspaceFolder, entry: FileSystemNode, selector: FileSelector): boolean;
+  protected scanProjectIncludePaths(): Promise<FileSystemNode[]>;
+  protected loadDocuments(files: FileSystemNode[]): Promise<LangiumDocument[]>;
+  protected saveAddDocument(document: LangiumDocument): void;
   workspace(): WorkspaceFolder | null;
   rebuildAll(cancelToken?: CancellationToken$1): Promise<void>;
   get workspaceUri(): URI;
@@ -2319,26 +3505,21 @@ declare class LikeC4WorkspaceManager extends DefaultWorkspaceManager {
    * Uses a timeout fallback for third-party IDEs that may not support workspace/configuration.
    */
   private readExcludeConfig;
-} //#endregion
+}
+//#endregion
 //#region src/references/scope-provider.d.ts
 declare class LikeC4ScopeProvider extends DefaultScopeProvider {
-  protected deploymentsIndex: DeploymentsIndex;
-  protected fqnIndex: FqnIndex;
+  protected services: LikeC4Services;
   protected readonly indexManager: IndexManager;
   constructor(services: LikeC4Services);
+  protected get fqnIndex(): FqnIndex;
+  protected get deploymentsIndex(): DeploymentsIndex;
   getScope(context: ReferenceInfo): Scope;
   protected genUniqueDescedants(element: Element | DeploymentNode | undefined): Generator<AstNodeDescriptionWithFqn, void, any>;
-  protected genScopeExtendElement({
-    element
-  }: ExtendElement): Generator<AstNodeDescription>;
-  protected genScopeElementView({
-    viewOf,
-    extends: ext
-  }: ElementView): Generator<AstNodeDescription>;
+  protected genScopeExtendElement({ element }: ExtendElement): Generator<AstNodeDescription>;
+  protected genScopeElementView({ viewOf, extends: ext }: ElementView): Generator<AstNodeDescription>;
   protected getScopeForStrictFqnRef(projectId: ProjectId$1, container: StrictFqnRef, context: ReferenceInfo): Scope;
-  protected genScopeExtendDeployment({
-    deploymentNode
-  }: ExtendDeployment): Generator<AstNodeDescription>;
+  protected genScopeExtendDeployment({ deploymentNode }: ExtendDeployment): Generator<AstNodeDescription>;
   protected streamForFqnRef(projectId: ProjectId$1, container: FqnRef$2, context: ReferenceInfo): Stream<AstNodeDescription>;
   protected genScopeForParentlessFqnRef(projectId: ProjectId$1, container: FqnRef$2, context: ReferenceInfo): Generator<AstNodeDescription>;
   /**
@@ -2361,15 +3542,8 @@ declare class LikeC4ScopeProvider extends DefaultScopeProvider {
    * Create a global scope filtered for the given reference type.
    */
   protected getGlobalScope(referenceType: string, context: ReferenceInfo): Scope;
-} //#endregion
-//#region src/utils/disposable.d.ts
-declare abstract class ADisposable implements Disposable$1 {
-  protected toDispose: Disposable$1[];
-  protected isDisposed: boolean;
-  onDispose(...disposable: Disposable$1[]): void;
-  dispose(): void;
-  protected throwIfDisposed(): void;
-} //#endregion
+}
+//#endregion
 //#region src/model/fqn-index.d.ts
 declare class FqnIndex<AstNd = Element> extends ADisposable {
   protected services: LikeC4Services;
@@ -2412,23 +3586,21 @@ declare class DocumentFqnIndex {
   /**
    * direct children of elements
    */
-
   _children: MultiMap<Fqn, AstNodeDescriptionWithFqn>,
   /**
    * All descendants of an element (unique by name)
    */
-
   _descendants: MultiMap<Fqn, AstNodeDescriptionWithFqn>,
   /**
    * All elements by FQN
    */
-
   _byfqn: MultiMap<Fqn, AstNodeDescriptionWithFqn>, projectId: ProjectId);
   rootElements(): readonly AstNodeDescriptionWithFqn[];
   byFqn(fqn: Fqn): readonly AstNodeDescriptionWithFqn[];
   children(parent: Fqn): readonly AstNodeDescriptionWithFqn[];
   descendants(nodeName: Fqn): readonly AstNodeDescriptionWithFqn[];
-} //#endregion
+}
+//#endregion
 //#region src/model/deployments-index.d.ts
 declare class DeploymentsIndex extends FqnIndex<DeploymentElement> {
   protected services: LikeC4Services;
@@ -2436,7 +3608,8 @@ declare class DeploymentsIndex extends FqnIndex<DeploymentElement> {
   protected logger: any;
   constructor(services: LikeC4Services);
   protected createDocumentIndex(document: LikeC4LangiumDocument): DocumentFqnIndex;
-} //#endregion
+}
+//#endregion
 //#region src/model/builder/MergedSpecification.d.ts
 /**
  * The `MergedSpecification` class is responsible for merging multiple parsed
@@ -2457,30 +3630,11 @@ declare class MergedSpecification {
   /**
    * Converts a parsed model into a C4 model element.
    */
-  toModelElement: ({
-    tags,
-    links,
-    style,
-    id,
-    kind,
-    title,
-    description,
-    technology,
-    summary,
-    metadata
-  }: ParsedAstElement) => c4.Element | null;
+  toModelElement: ({ tags, links, style, id, kind, title, description, technology, summary, metadata }: ParsedAstElement) => c4.Element | null;
   /**
    * Converts a parsed model into a C4 model relation.
    */
-  toModelRelation: ({
-    astPath: _astPath,
-    source,
-    target,
-    kind,
-    links,
-    id,
-    ...model
-  }: ParsedAstRelation) => c4.Relationship | null;
+  toModelRelation: ({ astPath: _astPath, source, target, kind, links, id, title, tags, ...model }: ParsedAstRelation) => c4.Relationship | null;
   /**
    * Converts a parsed deployment model into a C4 deployment model
    */
@@ -2488,22 +3642,15 @@ declare class MergedSpecification {
   /**
    * Converts a parsed deployment relation into a C4 deployment relation.
    */
-  toDeploymentRelation: ({
-    astPath: _astPath,
-    source,
-    target,
-    kind,
-    links,
-    id,
-    ...model
-  }: ParsedAstDeploymentRelation) => c4.DeploymentRelationship | null;
-} //#endregion
+  toDeploymentRelation: ({ astPath: _astPath, source, target, kind, links, id, tags, ...model }: ParsedAstDeploymentRelation) => c4.DeploymentRelationship | null;
+}
+//#endregion
 //#region src/model/last-seen-artifacts.d.ts
 /**
  * Provides access to "last seen artifacts" for a given project,
  * (Results of the last successful parsing)
  */
-declare class LastSeenArtifacts {
+declare class LastSeenArtifacts extends ADisposable {
   #private;
   constructor(services: LikeC4Services);
   /**
@@ -2536,7 +3683,8 @@ declare class LastSeenArtifacts {
    * @returns LikeC4Model.Computed or undefined.
    */
   model(projectId: c4.ProjectId): LikeC4Model.Computed | undefined;
-} //#endregion
+}
+//#endregion
 //#region src/model/model-builder.d.ts
 type ModelParsedListener = (projectId: ProjectId$1, docs: URI[]) => void;
 interface LikeC4ModelBuilder extends Disposable$1 {
@@ -2545,7 +3693,8 @@ interface LikeC4ModelBuilder extends Disposable$1 {
   computeModel(projectId?: ProjectId$1 | undefined, cancelToken?: CancellationToken$1): Promise<LikeC4Model<UnknownComputed>>;
   onModelParsed(callback: ModelParsedListener): Disposable$1;
   clearCache(): void;
-} //#endregion
+}
+//#endregion
 //#region src/model/model-locator.d.ts
 /** Result of locating a view: document, view AST, and view block node. */
 type ViewLocateResult = {
@@ -2614,7 +3763,8 @@ declare class LikeC4ModelLocator {
     astPath: string;
     projectId?: c4.ProjectId | undefined;
   }): Location | null;
-} //#endregion
+}
+//#endregion
 //#region src/views/LikeC4Views.d.ts
 type GraphvizOut = {
   readonly dot: string;
@@ -2635,10 +3785,11 @@ type LayoutViewParams = {
    */
   layoutType?: LayoutType | undefined;
   projectId?: ProjectId$1 | undefined;
-  cancelToken?: CancellationToken$1 | undefined; /** Optional AI-generated layout hints */
+  cancelToken?: CancellationToken$1 | undefined;
+  /** Optional AI-generated layout hints */
   layoutHints?: AILayoutHints | undefined;
 };
-interface LikeC4Views {
+interface LikeC4Views extends Disposable$1 {
   readonly layouter: GraphvizLayouter;
   /**
    * Returns computed views (i.e. views with predicates computed)
@@ -2687,8 +3838,7 @@ interface LikeC4Views {
    * @param projectId - project id, if not specified - uses the default project
    */
   adhocView(predicates: AdhocViewPredicate[], projectId?: ProjectId$1 | undefined): Promise<LayoutedView$1>;
-} //#endregion
-//#region src/views/index.d.ts
+}
 //#endregion
 //#region src/model/parser/Base.d.ts
 type ParserLevel = 'base' | 'model' | 'deployment' | 'fqnref' | 'relation' | 'views' | 'globals' | 'imports' | 'specification';
@@ -2704,7 +3854,7 @@ declare class BaseParser {
   constructor(services: LikeC4Services, doc: ParsedLikeC4LangiumDocument, project: Project);
   logError(error: unknown, astNode?: AstNode | Reference<AstNode>, level?: ParserLevel): void;
   tryParse<N extends AstNode, T>(level: ParserLevel, node: N | undefined, fn: (node: NoInfer<N>) => T | undefined): T | undefined;
-  tryMap<N extends AstNode, T>(level: ParserLevel, iterable: ReadonlyArray<N>, fn: (node: N) => T | undefined): T[];
+  tryMap<N extends AstNode, T>(level: ParserLevel, iterable: ReadonlyArray<N>, fn: (node: N, index: number) => T | undefined): T[];
   resolveFqn(node: FqnReferenceable): c4.Fqn;
   getAstNodePath(node: AstNode): string;
   getMetadata(metadataAstNode: MetadataProperty | undefined): {
@@ -2747,7 +3897,8 @@ declare class BaseParser {
     description?: c4.MarkdownOrString;
     technology?: string;
   };
-} //#endregion
+}
+//#endregion
 //#region src/model/model-parser.d.ts
 declare const DocumentParserFromMixins: {
   new (...args: any[]): {
@@ -2769,13 +3920,17 @@ declare const DocumentParserFromMixins: {
     parseDynamicElementView(astNode: DynamicView, additionalStyles: any[]): ParsedAstDynamicView;
     parseDynamicViewRule(astRule: DynamicViewRule): ProjectId$1;
     parseDynamicViewIncludePredicate(astRule: DynamicViewIncludePredicate): ProjectId$1;
-    parseDynamicParallelSteps(node: DynamicViewParallelSteps): ProjectId$1;
-    parseDynamicStep(node: DynamicViewStep): ProjectId$1 | ProjectId$1;
-    recursiveParseDynamicStepChain(node: DynamicStepChain, callstack?: Array<[source: ProjectId$1, target: ProjectId$1]>): ProjectId$1[];
-    parseDynamicStepSingle(node: DynamicStepSingle): ProjectId$1;
-    parseAbstractDynamicStep(astnode: AbstractDynamicStep): type_fest0.Writable<type_fest0.Except<ProjectId$1, "source", {
+    parseSteps(nodes: StepStatement[]): ProjectId$1[];
+    parseStepStatement(node: StepStatement): ProjectId$1;
+    parseStepSeries(node: StepSeries): ProjectId$1;
+    recursiveParseStepSeries(node: StepSeries, callstack?: Array<[source: ProjectId$1, target: ProjectId$1]>): ProjectId$1[];
+    parseStep(node: Step): ProjectId$1;
+    parseAbstractDynamicStep(astnode: AbstractStep): import("type-fest").Writable<import("type-fest").Except<ProjectId$1, "source", {
       requireExactProps: true;
     }>>;
+    parseSubflowStep(node: SubflowStep): ProjectId$1 | ProjectId$1 | ProjectId$1 | ProjectId$1;
+    parseTryStep(node: TryStep): ProjectId$1;
+    parseAltSteps(node: AltSteps): ProjectId$1;
     parsePredicate(astNode: ExpressionV2): ProjectId$1;
     parseElementPredicate(astNode: FqnExprOrWith): ProjectId$1;
     parseElementPredicateOrWhere(astNode: FqnExprOrWhere): ProjectId$1;
@@ -2798,7 +3953,7 @@ declare const DocumentParserFromMixins: {
     parseFqnExpressions(astNode: FqnExpressions): ProjectId$1[];
     parseRelationExprOrWith(astNode: RelationExprOrWith): ProjectId$1;
     parseRelationExprWith(astNode: RelationExprWith): ProjectId$1;
-    parseCustomRelationProperties(custom: CustomRelationProperties | undefined): type_fest0.Except<ProjectId$1["customRelation"], "expr">;
+    parseCustomRelationProperties(custom: CustomRelationProperties | undefined): import("type-fest").Except<ProjectId$1["customRelation"], "expr">;
     parseRelationExprOrWhere(astNode: RelationExprOrWhere): ProjectId$1;
     parseRelationExprWhere(astNode: RelationExprWhere): ProjectId$1;
     parseRelationExpr(astNode: RelationExpr$1): ProjectId$1;
@@ -2812,7 +3967,7 @@ declare const DocumentParserFromMixins: {
     readonly project: Project;
     logError(error: unknown, astNode?: AstNode | Reference<AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
     tryParse<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", node: N | undefined, fn: (node: NoInfer<N>) => T | undefined): T | undefined;
-    tryMap<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N) => T | undefined): T[];
+    tryMap<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N, index: number) => T | undefined): T[];
     resolveFqn(node: FqnReferenceable): ProjectId$1;
     getAstNodePath(node: AstNode): string;
     getMetadata(metadataAstNode: MetadataProperty | undefined): {
@@ -2874,13 +4029,17 @@ declare const DocumentParserFromMixins: {
     parseDynamicElementView(astNode: DynamicView, additionalStyles: any[]): ParsedAstDynamicView;
     parseDynamicViewRule(astRule: DynamicViewRule): ProjectId$1;
     parseDynamicViewIncludePredicate(astRule: DynamicViewIncludePredicate): ProjectId$1;
-    parseDynamicParallelSteps(node: DynamicViewParallelSteps): ProjectId$1;
-    parseDynamicStep(node: DynamicViewStep): ProjectId$1 | ProjectId$1;
-    recursiveParseDynamicStepChain(node: DynamicStepChain, callstack?: Array<[source: ProjectId$1, target: ProjectId$1]>): ProjectId$1[];
-    parseDynamicStepSingle(node: DynamicStepSingle): ProjectId$1;
-    parseAbstractDynamicStep(astnode: AbstractDynamicStep): type_fest0.Writable<type_fest0.Except<ProjectId$1, "source", {
+    parseSteps(nodes: StepStatement[]): ProjectId$1[];
+    parseStepStatement(node: StepStatement): ProjectId$1;
+    parseStepSeries(node: StepSeries): ProjectId$1;
+    recursiveParseStepSeries(node: StepSeries, callstack?: Array<[source: ProjectId$1, target: ProjectId$1]>): ProjectId$1[];
+    parseStep(node: Step): ProjectId$1;
+    parseAbstractDynamicStep(astnode: AbstractStep): import("type-fest").Writable<import("type-fest").Except<ProjectId$1, "source", {
       requireExactProps: true;
     }>>;
+    parseSubflowStep(node: SubflowStep): ProjectId$1 | ProjectId$1 | ProjectId$1 | ProjectId$1;
+    parseTryStep(node: TryStep): ProjectId$1;
+    parseAltSteps(node: AltSteps): ProjectId$1;
     parsePredicate(astNode: ExpressionV2): ProjectId$1;
     parseElementPredicate(astNode: FqnExprOrWith): ProjectId$1;
     parseElementPredicateOrWhere(astNode: FqnExprOrWhere): ProjectId$1;
@@ -2903,7 +4062,7 @@ declare const DocumentParserFromMixins: {
     parseFqnExpressions(astNode: FqnExpressions): ProjectId$1[];
     parseRelationExprOrWith(astNode: RelationExprOrWith): ProjectId$1;
     parseRelationExprWith(astNode: RelationExprWith): ProjectId$1;
-    parseCustomRelationProperties(custom: CustomRelationProperties | undefined): type_fest0.Except<ProjectId$1["customRelation"], "expr">;
+    parseCustomRelationProperties(custom: CustomRelationProperties | undefined): import("type-fest").Except<ProjectId$1["customRelation"], "expr">;
     parseRelationExprOrWhere(astNode: RelationExprOrWhere): ProjectId$1;
     parseRelationExprWhere(astNode: RelationExprWhere): ProjectId$1;
     parseRelationExpr(astNode: RelationExpr$1): ProjectId$1;
@@ -2917,7 +4076,7 @@ declare const DocumentParserFromMixins: {
     readonly project: Project;
     logError(error: unknown, astNode?: AstNode | Reference<AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
     tryParse<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", node: N | undefined, fn: (node: NoInfer<N>) => T | undefined): T | undefined;
-    tryMap<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N) => T | undefined): T[];
+    tryMap<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N, index: number) => T | undefined): T[];
     resolveFqn(node: FqnReferenceable): ProjectId$1;
     getAstNodePath(node: AstNode): string;
     getMetadata(metadataAstNode: MetadataProperty | undefined): {
@@ -2977,7 +4136,7 @@ declare const DocumentParserFromMixins: {
     readonly project: Project;
     logError(error: unknown, astNode?: AstNode | Reference<AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
     tryParse<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", node: N | undefined, fn: (node: NoInfer<N>) => T | undefined): T | undefined;
-    tryMap<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N) => T | undefined): T[];
+    tryMap<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N, index: number) => T | undefined): T[];
     resolveFqn(node: FqnReferenceable): ProjectId$1;
     getAstNodePath(node: AstNode): string;
     getMetadata(metadataAstNode: MetadataProperty | undefined): {
@@ -3038,7 +4197,7 @@ declare const DocumentParserFromMixins: {
     parseFqnExpressions(astNode: FqnExpressions): ProjectId$1[];
     parseRelationExprOrWith(astNode: RelationExprOrWith): ProjectId$1;
     parseRelationExprWith(astNode: RelationExprWith): ProjectId$1;
-    parseCustomRelationProperties(custom: CustomRelationProperties | undefined): type_fest0.Except<ProjectId$1["customRelation"], "expr">;
+    parseCustomRelationProperties(custom: CustomRelationProperties | undefined): import("type-fest").Except<ProjectId$1["customRelation"], "expr">;
     parseRelationExprOrWhere(astNode: RelationExprOrWhere): ProjectId$1;
     parseRelationExprWhere(astNode: RelationExprWhere): ProjectId$1;
     parseRelationExpr(astNode: RelationExpr$1): ProjectId$1;
@@ -3052,7 +4211,7 @@ declare const DocumentParserFromMixins: {
     readonly project: Project;
     logError(error: unknown, astNode?: AstNode | Reference<AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
     tryParse<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", node: N | undefined, fn: (node: NoInfer<N>) => T | undefined): T | undefined;
-    tryMap<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N) => T | undefined): T[];
+    tryMap<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N, index: number) => T | undefined): T[];
     resolveFqn(node: FqnReferenceable): ProjectId$1;
     getAstNodePath(node: AstNode): string;
     getMetadata(metadataAstNode: MetadataProperty | undefined): {
@@ -3106,7 +4265,7 @@ declare const DocumentParserFromMixins: {
     parseFqnExpressions(astNode: FqnExpressions): ProjectId$1[];
     parseRelationExprOrWith(astNode: RelationExprOrWith): ProjectId$1;
     parseRelationExprWith(astNode: RelationExprWith): ProjectId$1;
-    parseCustomRelationProperties(custom: CustomRelationProperties | undefined): type_fest0.Except<ProjectId$1["customRelation"], "expr">;
+    parseCustomRelationProperties(custom: CustomRelationProperties | undefined): import("type-fest").Except<ProjectId$1["customRelation"], "expr">;
     parseRelationExprOrWhere(astNode: RelationExprOrWhere): ProjectId$1;
     parseRelationExprWhere(astNode: RelationExprWhere): ProjectId$1;
     parseRelationExpr(astNode: RelationExpr$1): ProjectId$1;
@@ -3120,7 +4279,7 @@ declare const DocumentParserFromMixins: {
     readonly project: Project;
     logError(error: unknown, astNode?: AstNode | Reference<AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
     tryParse<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", node: N | undefined, fn: (node: NoInfer<N>) => T | undefined): T | undefined;
-    tryMap<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N) => T | undefined): T[];
+    tryMap<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N, index: number) => T | undefined): T[];
     resolveFqn(node: FqnReferenceable): ProjectId$1;
     getAstNodePath(node: AstNode): string;
     getMetadata(metadataAstNode: MetadataProperty | undefined): {
@@ -3182,7 +4341,7 @@ declare const DocumentParserFromMixins: {
     parseFqnExpressions(astNode: FqnExpressions): ProjectId$1[];
     parseRelationExprOrWith(astNode: RelationExprOrWith): ProjectId$1;
     parseRelationExprWith(astNode: RelationExprWith): ProjectId$1;
-    parseCustomRelationProperties(custom: CustomRelationProperties | undefined): type_fest0.Except<ProjectId$1["customRelation"], "expr">;
+    parseCustomRelationProperties(custom: CustomRelationProperties | undefined): import("type-fest").Except<ProjectId$1["customRelation"], "expr">;
     parseRelationExprOrWhere(astNode: RelationExprOrWhere): ProjectId$1;
     parseRelationExprWhere(astNode: RelationExprWhere): ProjectId$1;
     parseRelationExpr(astNode: RelationExpr$1): ProjectId$1;
@@ -3196,7 +4355,7 @@ declare const DocumentParserFromMixins: {
     readonly project: Project;
     logError(error: unknown, astNode?: AstNode | Reference<AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
     tryParse<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", node: N | undefined, fn: (node: NoInfer<N>) => T | undefined): T | undefined;
-    tryMap<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N) => T | undefined): T[];
+    tryMap<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N, index: number) => T | undefined): T[];
     resolveFqn(node: FqnReferenceable): ProjectId$1;
     getAstNodePath(node: AstNode): string;
     getMetadata(metadataAstNode: MetadataProperty | undefined): {
@@ -3252,7 +4411,7 @@ declare const DocumentParserFromMixins: {
     parseFqnExpressions(astNode: FqnExpressions): ProjectId$1[];
     parseRelationExprOrWith(astNode: RelationExprOrWith): ProjectId$1;
     parseRelationExprWith(astNode: RelationExprWith): ProjectId$1;
-    parseCustomRelationProperties(custom: CustomRelationProperties | undefined): type_fest0.Except<ProjectId$1["customRelation"], "expr">;
+    parseCustomRelationProperties(custom: CustomRelationProperties | undefined): import("type-fest").Except<ProjectId$1["customRelation"], "expr">;
     parseRelationExprOrWhere(astNode: RelationExprOrWhere): ProjectId$1;
     parseRelationExprWhere(astNode: RelationExprWhere): ProjectId$1;
     parseRelationExpr(astNode: RelationExpr$1): ProjectId$1;
@@ -3266,7 +4425,7 @@ declare const DocumentParserFromMixins: {
     readonly project: Project;
     logError(error: unknown, astNode?: AstNode | Reference<AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
     tryParse<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", node: N | undefined, fn: (node: NoInfer<N>) => T | undefined): T | undefined;
-    tryMap<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N) => T | undefined): T[];
+    tryMap<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N, index: number) => T | undefined): T[];
     resolveFqn(node: FqnReferenceable): ProjectId$1;
     getAstNodePath(node: AstNode): string;
     getMetadata(metadataAstNode: MetadataProperty | undefined): {
@@ -3314,7 +4473,7 @@ declare const DocumentParserFromMixins: {
     readonly project: Project;
     logError(error: unknown, astNode?: AstNode | Reference<AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
     tryParse<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", node: N | undefined, fn: (node: NoInfer<N>) => T | undefined): T | undefined;
-    tryMap<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N) => T | undefined): T[];
+    tryMap<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N, index: number) => T | undefined): T[];
     resolveFqn(node: FqnReferenceable): ProjectId$1;
     getAstNodePath(node: AstNode): string;
     getMetadata(metadataAstNode: MetadataProperty | undefined): {
@@ -3364,7 +4523,7 @@ declare const DocumentParserFromMixins: {
     parseFqnExpressions(astNode: FqnExpressions): ProjectId$1[];
     parseRelationExprOrWith(astNode: RelationExprOrWith): ProjectId$1;
     parseRelationExprWith(astNode: RelationExprWith): ProjectId$1;
-    parseCustomRelationProperties(custom: CustomRelationProperties | undefined): type_fest0.Except<ProjectId$1["customRelation"], "expr">;
+    parseCustomRelationProperties(custom: CustomRelationProperties | undefined): import("type-fest").Except<ProjectId$1["customRelation"], "expr">;
     parseRelationExprOrWhere(astNode: RelationExprOrWhere): ProjectId$1;
     parseRelationExprWhere(astNode: RelationExprWhere): ProjectId$1;
     parseRelationExpr(astNode: RelationExpr$1): ProjectId$1;
@@ -3378,7 +4537,7 @@ declare const DocumentParserFromMixins: {
     readonly project: Project;
     logError(error: unknown, astNode?: AstNode | Reference<AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
     tryParse<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", node: N | undefined, fn: (node: NoInfer<N>) => T | undefined): T | undefined;
-    tryMap<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N) => T | undefined): T[];
+    tryMap<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N, index: number) => T | undefined): T[];
     resolveFqn(node: FqnReferenceable): ProjectId$1;
     getAstNodePath(node: AstNode): string;
     getMetadata(metadataAstNode: MetadataProperty | undefined): {
@@ -3417,7 +4576,7 @@ declare const DocumentParserFromMixins: {
   };
 } & typeof BaseParser;
 declare class DocumentParser extends DocumentParserFromMixins {}
-declare class LikeC4ModelParser {
+declare class LikeC4ModelParser extends ADisposable {
   private services;
   protected cachedParsers: any;
   constructor(services: LikeC4Services);
@@ -3425,21 +4584,20 @@ declare class LikeC4ModelParser {
   parse(doc: LangiumDocument): ParsedLikeC4LangiumDocument;
   forDocument(doc: LangiumDocument): DocumentParser;
   private createParser;
-} //#endregion
+}
+//#endregion
 //#region src/model/parser/ValueConverter.d.ts
 declare class LikeC4ValueConverter extends DefaultValueConverter {
   protected runConverter(rule: any, input: string, cstNode: CstNode): ValueType;
-} //#endregion
+}
+//#endregion
 //#region src/model-change/ModelChanges.d.ts
 declare class LikeC4ModelChanges {
   private services;
   private locator;
   constructor(services: LikeC4Services);
   applyChange(changeView: ChangeView.Params): Promise<ChangeView.Res>;
-  protected convertToTextEdit({
-    lookup,
-    change
-  }: {
+  protected convertToTextEdit({ lookup, change }: {
     lookup: ViewLocateResult;
     change: Exclude<ViewChange, ViewChange.SaveViewSnapshot | ViewChange.ResetManualLayout | ViewChange.ChangeProperty>;
   }): {
@@ -3447,7 +4605,8 @@ declare class LikeC4ModelChanges {
     edits: TextEdit[];
   };
   protected applyTextEdits(doc: ParsedLikeC4LangiumDocument, edits: TextEdit[]): Promise<boolean>;
-} //#endregion
+}
+//#endregion
 //#region src/LikeC4LanguageServices.d.ts
 interface LikeC4LanguageServices {
   readonly views: LikeC4Views;
@@ -3548,13 +4707,15 @@ interface FormatOptions {
   insertFinalNewline?: boolean;
   /** Trim all newlines after the final newline at the end of the file. */
   trimFinalNewlines?: boolean;
-} //#endregion
+}
+//#endregion
 //#region src/lsp/CodeLensProvider.d.ts
 declare class LikeC4CodeLensProvider implements CodeLensProvider {
   private services;
   constructor(services: LikeC4Services);
   provideCodeLens(doc: LangiumDocument, _params: CodeLensParams, cancelToken?: CancellationToken$1): Promise<CodeLens[] | undefined>;
-} //#endregion
+}
+//#endregion
 //#region src/lsp/CompletionProvider.d.ts
 declare class LikeC4CompletionProvider extends DefaultCompletionProvider {
   protected services: LikeC4Services;
@@ -3565,14 +4726,16 @@ declare class LikeC4CompletionProvider extends DefaultCompletionProvider {
   protected completionFor(context: CompletionContext, next: NextFeature, acceptor: CompletionAcceptor): MaybePromise<void>;
   protected completionForKeyword(context: CompletionContext, keyword: Keyword, acceptor: CompletionAcceptor): MaybePromise<void>;
   protected completionForImportedProject(context: CompletionContext, acceptor: CompletionAcceptor): void;
-} //#endregion
+}
+//#endregion
 //#region src/lsp/DocumentHighlightProvider.d.ts
 declare class LikeC4DocumentHighlightProvider extends DefaultDocumentHighlightProvider {
   /**
    * Override this method to determine the highlight kind of the given reference.
    */
   protected createDocumentHighlight(reference: ReferenceDescription): DocumentHighlight;
-} //#endregion
+}
+//#endregion
 //#region src/lsp/DocumentLinkProvider.d.ts
 declare class LikeC4DocumentLinkProvider implements DocumentLinkProvider {
   private services;
@@ -3580,7 +4743,8 @@ declare class LikeC4DocumentLinkProvider implements DocumentLinkProvider {
   getDocumentLinks(doc: LangiumDocument, _params: DocumentLinkParams, _cancelToken?: CancellationToken$1): Promise<DocumentLink[]>;
   resolveLink(doc: LangiumDocument, link: string): string;
   relativeLink(doc: LangiumDocument, link: string): string | null;
-} //#endregion
+}
+//#endregion
 //#region src/lsp/DocumentSymbolProvider.d.ts
 declare class LikeC4DocumentSymbolProvider implements DocumentSymbolProvider {
   private services;
@@ -3594,7 +4758,7 @@ declare class LikeC4DocumentSymbolProvider implements DocumentSymbolProvider {
   protected getSpecSymbol(astSpec: SpecificationRule): DocumentSymbol[];
   protected getModelSymbol(astModel: Model): DocumentSymbol[];
   protected getDeploymentModelSymbol(astModel: ModelDeployments): DocumentSymbol[];
-  protected getElementsSymbol(el: Element | Relation | ExtendElement, parentFqn?: string): DocumentSymbol[];
+  protected getElementsSymbol(el: Element | Relation | ExtendElement, _parentFqn?: string): DocumentSymbol[];
   protected getExtendElementSymbol(astElement: ExtendElement): DocumentSymbol[];
   protected getElementSymbol(astElement: Element): DocumentSymbol[];
   protected getModelViewsSymbol(astViews: ModelViews): DocumentSymbol[];
@@ -3606,7 +4770,8 @@ declare class LikeC4DocumentSymbolProvider implements DocumentSymbolProvider {
   protected getDeploymentNodeSymbol(astElement: DeploymentNode): DocumentSymbol[];
   protected getDeployedInstanceSymbol(astElement: DeployedInstance): DocumentSymbol[];
   protected symbolKind(node: AstNode): SymbolKind;
-} //#endregion
+}
+//#endregion
 //#region src/lsp/HoverProvider.d.ts
 /**
  * Provides hover content for LikeC4 AST nodes (elements, tags, relations, etc.)
@@ -3644,7 +4809,8 @@ declare class LikeC4HoverProvider extends AstNodeHoverProvider {
    * @returns Hover information with markdown content showing instance details.
    */
   protected getDeployedInstanceHover(node: DeployedInstance): MaybePromise<Hover | undefined>;
-} //#endregion
+}
+//#endregion
 //#region src/lsp/CodeActionProvider.d.ts
 type CommandOrCodeAction = Command | CodeAction;
 declare class LikeC4CodeActionProvider implements CodeActionProvider {
@@ -3655,7 +4821,8 @@ declare class LikeC4CodeActionProvider implements CodeActionProvider {
    * @throws `ResponseError` if an error is detected that should be sent as response to the client
    */
   getCodeActions(_document: LangiumDocument, _params: CodeActionParams): CommandOrCodeAction[] | undefined;
-} //#endregion
+}
+//#endregion
 //#region src/lsp/SemanticTokenProvider.d.ts
 declare class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
   protected services: LikeC4Services;
@@ -3666,14 +4833,16 @@ declare class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider
   private highlightNameAndKind;
   private highlightView;
   private mark;
-} //#endregion
+}
+//#endregion
 //#region src/Rpc.d.ts
 declare class Rpc extends ADisposable {
   private services;
   constructor(services: LikeC4Services);
   init: () => void;
   openView(params: DidRequestOpenViewNotification.Params): Promise<void>;
-} //#endregion
+}
+//#endregion
 //#region src/shared/NodeKindProvider.d.ts
 declare class NodeKindProvider$1 implements NodeKindProvider {
   private services;
@@ -3686,9 +4855,11 @@ declare class NodeKindProvider$1 implements NodeKindProvider {
    * Returns a `CompletionItemKind` as used by the `CompletionProvider`.
    */
   getCompletionItemKind(node: AstNode | AstNodeDescription): CompletionItemKind;
-} //#endregion
+}
+//#endregion
 //#region src/shared/WorkspaceSymbolProvider.d.ts
-declare class WorkspaceSymbolProvider extends DefaultWorkspaceSymbolProvider {} //#endregion
+declare class WorkspaceSymbolProvider extends DefaultWorkspaceSymbolProvider {}
+//#endregion
 //#region src/module.d.ts
 interface LikeC4AddedSharedServices {
   lsp: {
@@ -3754,7 +4925,7 @@ interface LikeC4AddedServices {
 }
 type LikeC4Services = LangiumServices & LikeC4AddedServices;
 //#endregion
-//#region ../language-services/dist/_chunks/options.d.mts
+//#region ../language-services/dist/chunks/options.d.mts
 //#region src/common/LikeC4.d.ts
 interface LikeC4Langium {
   shared: LikeC4SharedServices;
@@ -3767,15 +4938,15 @@ declare class LikeC4 {
   /**
    * File system path to the workspace root
    */
-  get workspace(): any;
+  get workspace(): string;
   /**
    * URI of the workspace root
    */
-  get workspaceURI(): any;
+  get workspaceURI(): URI;
   /**
    * URL of the workspace root
    */
-  get workspaceURL(): any;
+  get workspaceURL(): URL;
   get languageServices(): LikeC4LanguageServices;
   get projectsManager(): ProjectsManager;
   get viewsService(): LikeC4Views;
@@ -3803,6 +4974,104 @@ declare class LikeC4 {
    * Not ready for rendering, but enough to traverse
    */
   computedModel(project?: string | undefined): Promise<LikeC4Model.Computed>;
+  /**
+   * Returns the parsed model — elements, relations, views, deployments, globals
+   * and imports as parsed from DSL, BEFORE view computation or layout.
+   *
+   * Use this when you need to inspect the raw parsed shape, or as input to
+   * {@link toBuilder} for programmatic enrichment.
+   */
+  parsedModel(project?: string | undefined): Promise<LikeC4Model.Parsed>;
+  /**
+   * Returns a {@link Builder} seeded with the parsed model of the given project.
+   *
+   * This unblocks programmatic enrichment — you can chain `.model(...)`,
+   * `.deployment(...)` and `.views(...)` on the returned builder to add new
+   * elements, relations and views on top of what was loaded from DSL.
+   *
+   * The builder is `editable` by default: re-declaring an element that already
+   * exists (same FQN, same kind) edits it in place rather than throwing — which
+   * is what you usually want when patching a loaded model. Pass `'strict'` to
+   * get the strict builder where duplicate FQNs always throw (see
+   * {@link BuilderMode}).
+   *
+   * Type-safety note: the returned builder is `Builder<AnyTypes>` — element
+   * kinds, FQNs, view ids and tags are only known at runtime. See
+   * {@link Builder.fromParsed} for details.
+   *
+   * @example
+   * ```ts
+   * const likec4 = await LikeC4.fromWorkspace('/path/to/workspace')
+   * const enriched = (await likec4.toBuilder())
+   *   .model(({ system, component }, _) =>
+   *     _(system('monitoring').with(component('grafana'))),
+   *   )
+   *   .toLikeC4Model()
+   *
+   * // Strict builder — re-declaring an existing FQN throws:
+   * const strict = await likec4.toBuilder('strict')
+   * ```
+   */
+  toBuilder(mode?: BuilderMode, project?: string | undefined): Promise<Builder<AnyTypes>>;
+  /**
+   * Like {@link toBuilder}, but validates the given `specification` against the
+   * loaded model and returns a **typed** builder.
+   *
+   * Use this when your code authors the model with the same specification as the
+   * DSL: pass that spec and get a `Builder<Types.FromSpecification<Spec>>` with
+   * autocomplete on element / deployment / relationship kinds, tags and metadata
+   * keys — replacing the unchecked `as unknown as Builder<...>` cast.
+   *
+   * Validation is **subset-based**: every kind / tag / metadata key you declare
+   * must exist in the loaded model (otherwise the produced types would lie and we
+   * throw). The loaded model may contain *extra* kinds you didn't declare — you
+   * simply won't get typed helpers for them.
+   *
+   * Like {@link toBuilder}, the builder is `editable` by default — pass
+   * `mode: 'strict'` for the throw-on-duplicate builder.
+   *
+   * Note: existing FQNs and view ids from the loaded model are still NOT part of
+   * the static type set (only kinds/tags/metadata keys are) — see
+   * {@link Builder.fromParsed}.
+   *
+   * @example
+   * ```ts
+   * const specification = {
+   *   elements: ['actor', 'system', 'component'],
+   *   tags: ['external'],
+   * } as const
+   *
+   * const builder = await likec4.toTypedBuilder({ specification })
+   * const enriched = builder
+   *   .model(({ system, component }, _) =>
+   *     _(system('monitoring').with(component('grafana'))),
+   *   )
+   *   .toLikeC4Model()
+   * ```
+   */
+  toTypedBuilder<const Spec extends BuilderSpecification>(options: {
+    /** The specification your code expects — validated against the loaded model. */
+    specification: Spec;
+    /** Duplicate handling, defaults to `'editable'` (see {@link toBuilder}). */
+    mode?: BuilderMode;
+    /** Project name to seed from (for multi-project workspaces). */
+    project?: string;
+  }): Promise<Builder<Types.FromSpecification<Spec>>>;
+  /**
+   * Renders the parsed model of the given project back to LikeC4 DSL source.
+   *
+   * The output is a single, formatted `.c4` string containing the specification,
+   * model, deployment and views blocks. This round-trip is intentionally LOSSY:
+   * comments, source positions and original formatting are not preserved.
+   *
+   * Useful for "load + patch + emit" workflows where the source of truth is
+   * external (e.g. a service catalogue or Terraform state) and DSL files are
+   * regenerated wholesale.
+   *
+   * To write the output to disk, use the `writeDSL` helper from
+   * `@likec4/language-services/node`.
+   */
+  toDSL(project?: string | undefined): Promise<string>;
   projects(): NonEmptyArray<ProjectId>;
   /**
    * Same as {@link computedModel()}, but also applies layout
@@ -3834,9 +5103,11 @@ declare class LikeC4 {
    */
   documentCount(): number;
   /**
-   * @returns a function to dispose the listener
+   * Subscribe to model updates
+   * @param listener Function called when the model is updated - receives the project ID that was updated
+   * @returns A function to dispose the listener
    */
-  onModelUpdate(listener: () => void): () => void;
+  onModelUpdate(listener: (projectId: ProjectId) => void): () => void;
   /**
    * Formats documents and returns a map of document URI → formatted source text.
    *
@@ -3870,7 +5141,36 @@ interface LikeC4FormatOptions {
   insertFinalNewline?: boolean;
   /** Trim all newlines after the final newline at the end of the file. */
   trimFinalNewlines?: boolean;
-} //#endregion
-//#region src/common/options.d.ts
+}
+//#endregion
+//#region ../language-services/dist/node/index.d.mts
+/**
+ * Options for {@link writeDSL}.
+ */
+interface WriteDSLOptions {
+  /** Project to render (when the workspace has multiple). Defaults to the only one. */
+  project?: string;
+  /** Output filename. Default: `model.c4`. */
+  fileName?: string;
+}
+/**
+ * Renders the parsed model back to LikeC4 DSL source and writes it to disk.
+ *
+ * The output is a single, formatted `.c4` file. This round-trip is intentionally
+ * LOSSY: comments, source positions and original formatting are not preserved.
+ *
+ * @param likec4 - A LikeC4 instance (typically from `fromWorkspace`).
+ * @param targetDir - Directory to write the output file into. Must already exist.
+ * @param options - {@link WriteDSLOptions}
+ * @returns The full path of the written file.
+ *
+ * @example
+ * ```ts
+ * const likec4 = await LikeC4.fromWorkspace('/path/to/workspace')
+ * const out = await writeDSL(likec4, '/tmp/generated')
+ * console.log(`Wrote DSL to ${out}`)
+ * ```
+ */
+declare function writeDSL(likec4: LikeC4, targetDir: string, options?: WriteDSLOptions): Promise<string>;
 //#endregion
-export { LikeC4LanguageServices as n, LikeC4 as t };
+export { LikeC4LanguageServices as i, writeDSL as n, LikeC4 as r, WriteDSLOptions as t };