likec4 1.56.0 → 1.58.0

package/dist/chunks/index2.d.mts

@@ -1,17 +1,1209 @@
 import { i as __name } from "./rolldown-runtime.mjs";
 import { a as LikeC4ProjectConfig, i as IncludeConfig, o as LikeC4ProjectConfigInput } from "./index.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 { t as $keywords } from "./libs/ts-graphviz.mjs";
+import { t as $keywords } from "./libs/@ts-graphviz/common.mjs";
+import { LikeC4Styles } from "@likec4/core/styles";
+import { EdgeId, Fqn, GuardedBy, LayoutedView, NodeId, NonEmptyArray, NonEmptyReadonlyArray, ProjectId, ViewId } from "@likec4/core/types";
 import * as c4 from "@likec4/core";
-import { AnyAux, ComputedView, DeploymentFqn, DiagramView, EdgeId, Fqn, LayoutType, LayoutedView, LikeC4Styles, NonEmptyArray, NonEmptyReadonlyArray, ProjectId, RelationId, Tag, UnknownComputed, UnknownLayouted, UnknownParsed, ViewChange, ViewId, aux } from "@likec4/core";
-import { LikeC4Styles as LikeC4Styles$1 } from "@likec4/core/styles";
-import { Fqn as Fqn$1, GuardedBy, LayoutedView as LayoutedView$1, ProjectId as ProjectId$1, ViewId as ViewId$1 } from "@likec4/core/types";
+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 ../../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"];
+/**
+ * The severity level of a {@link LogRecord}.
+ */
+type LogLevel = typeof logLevels[number];
+/**
+ * Lists all available log levels with the order of their severity.
+ * The `"trace"` level goes first, and the `"fatal"` level goes last.
+ * @returns A new copy of the array of log levels.
+ * @since 1.0.0
+ */
+//#endregion
+//#region ../../node_modules/.pnpm/@logtape+logtape@2.1.1/node_modules/@logtape/logtape/dist/record.d.ts
+//#region src/record.d.ts
+/**
+ * A log record.
+ */
+interface LogRecord {
+  /**
+   * The category of the logger that produced the log record.
+   */
+  readonly category: readonly string[];
+  /**
+   * The log level.
+   */
+  readonly level: LogLevel;
+  /**
+   * 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.
+   */
+  readonly message: readonly unknown[];
+  /**
+   * 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
+   */
+  readonly rawMessage: string | TemplateStringsArray;
+  /**
+   * The timestamp of the log record in milliseconds since the Unix epoch.
+   */
+  readonly timestamp: number;
+  /**
+   * The extra properties of the log record.
+   */
+  readonly properties: Record<string, unknown>;
+} //# sourceMappingURL=record.d.ts.map
+//#endregion
+//#endregion
+//#region ../../node_modules/.pnpm/@logtape+logtape@2.1.1/node_modules/@logtape/logtape/dist/logger.d.ts
+/**
+ * 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.
+ */
+interface Logger {
+  /**
+   * The category of the logger.  It is an array of strings.
+   */
+  readonly category: readonly string[];
+  /**
+   * The logger with the supercategory of the current logger.  If the current
+   * logger is the root logger, this is `null`.
+   */
+  readonly parent: Logger | null;
+  /**
+   * 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.
+   */
+  getChild(subcategory: string | readonly [string] | readonly [string, ...string[]]): Logger;
+  /**
+   * 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
+   */
+  with(properties: Record<string, unknown>): Logger;
+  /**
+   * 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
+   */
+  trace(message: TemplateStringsArray, ...values: readonly unknown[]): void;
+  /**
+   * 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
+   */
+  trace(message: string, properties?: Record<string, unknown> | (() => Record<string, unknown>)): void;
+  /**
+   * 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
+   */
+  trace(message: string, properties: () => Promise<Record<string, unknown>>): Promise<void>;
+  /**
+   * 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
+   */
+  trace(properties: Record<string, unknown>): void;
+  /**
+   * 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
+   */
+  trace(callback: LogCallback): void;
+  /**
+   * 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.
+   */
+  debug(message: TemplateStringsArray, ...values: readonly unknown[]): void;
+  /**
+   * 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.
+   */
+  debug(message: string, properties?: Record<string, unknown> | (() => Record<string, unknown>)): void;
+  /**
+   * 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
+   */
+  debug(message: string, properties: () => Promise<Record<string, unknown>>): Promise<void>;
+  /**
+   * 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
+   */
+  debug(properties: Record<string, unknown>): void;
+  /**
+   * 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.
+   */
+  debug(callback: LogCallback): void;
+  /**
+   * 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.
+   */
+  info(message: TemplateStringsArray, ...values: readonly unknown[]): void;
+  /**
+   * 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.
+   */
+  info(message: string, properties?: Record<string, unknown> | (() => Record<string, unknown>)): void;
+  /**
+   * 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
+   */
+  info(message: string, properties: () => Promise<Record<string, unknown>>): Promise<void>;
+  /**
+   * 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
+   */
+  info(properties: Record<string, unknown>): void;
+  /**
+   * 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.
+   *
+   * ```typescript
+   * logger.info(l => l`An info message with ${expensiveValue()}.`);
+   * ```
+   *
+   * @param callback A callback that returns the message template prefix.
+   * @throws {TypeError} If no log record was made inside the callback.
+   */
+  info(callback: LogCallback): void;
+  /**
+   * 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
+   */
+  warn(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.warn(new Error("Oops"), { requestId });
+   * ```
+   *
+   * @param error The error to log.
+   * @param properties Additional properties to log alongside the error.
+   * @since 2.1.0
+   */
+  warn(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
+   */
+  warn(error: Error, properties: () => Promise<Record<string, unknown>>): Promise<void>;
+  /**
+   * 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
+   */
+  warn(message: string, error: Error): void;
+  /**
+   * 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.
+   */
+  warn(message: TemplateStringsArray, ...values: readonly unknown[]): void;
+  /**
+   * 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.
+   */
+  warn(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.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
+   */
+  warn(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.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
+   */
+  warn(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.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.
+   */
+  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[];
+/**
+ * A function type for logging methods in the {@link Logger} interface.
+ * @since 1.0.0
+ */
+//#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>;
+  /**
+   * These edges should be reversed in DOT
+   * Unique array of EdgeIds.
+   */
+  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;
+} //#endregion
+//#endregion
 //#region ../language-server/dist/_chunks/protocol.d.mts
 /**
  * When server requests to open a likec4 preview panel
@@ -20,8 +1212,8 @@ import { ConditionalPick, MergeExclusive, Simplify, Tagged, ValueOf, Writable }
  */
 declare namespace DidRequestOpenViewNotification {
   type Params = {
-    viewId: ViewId;
-    projectId: ProjectId;
+    viewId: ViewId$1;
+    projectId: ProjectId$1;
   };
   const type: NotificationType<Params>;
   type Type = typeof type;
@@ -41,7 +1233,7 @@ declare namespace Locate {
    * Locate an element by its fqn
    */
   {
-    element: Fqn;
+    element: Fqn$1;
     projectId?: string | undefined;
     property?: string;
   }
@@ -64,7 +1256,7 @@ declare namespace Locate {
    * Locate a step in a dynamic view by its astPath
    */
   | {
-    view: ViewId;
+    view: ViewId$1;
     astPath: string;
     projectId?: string | undefined;
   }
@@ -72,7 +1264,7 @@ declare namespace Locate {
    * Locate a view by its id
    */
   | {
-    view: ViewId;
+    view: ViewId$1;
     projectId?: string | undefined;
   };
   type Res = Location | null;
@@ -85,7 +1277,7 @@ declare namespace Locate {
  */
 declare namespace ChangeView {
   type Params = {
-    viewId: ViewId;
+    viewId: ViewId$1;
     change: ViewChange;
     projectId?: string | undefined;
   };
@@ -224,7 +1416,7 @@ declare namespace GraphvizJson {
     _ldraw_?: LabelDrawOps[];
     likec4_type?: 'folder' | 'file';
     likec4_path?: string;
-    likec4_id?: Fqn;
+    likec4_id?: Fqn$1;
     likec4_level?: number;
     likec4_depth?: number;
     _gvid: GvId;
@@ -237,7 +1429,7 @@ declare namespace GraphvizJson {
     _ldraw_?: LabelDrawOps[];
     likec4_type?: 'folder' | 'file' | 'view';
     likec4_path?: string;
-    likec4_id?: Fqn;
+    likec4_id?: Fqn$1;
     likec4_level?: number;
     _gvid: GvId;
     height: string;
@@ -272,7 +1464,7 @@ declare namespace GraphvizJson {
     _hldraw_?: LabelDrawOps[];
     fontname: string;
     fontsize: string;
-    likec4_id?: EdgeId;
+    likec4_id?: EdgeId$1;
     label: string;
     lp: string;
     nojustify?: 'true' | 'false';
@@ -289,11 +1481,11 @@ interface GraphvizPort extends Disposable {
   svg(dot: DotSource): Promise<string>;
   dispose(): void;
 }
-type LayoutTaskParams<A extends aux.Any = aux.Any> = {
+type LayoutTaskParams<A extends aux$1.Any = aux$1.Any> = {
   view: ComputedView<A>;
-  styles: LikeC4Styles;
+  styles: LikeC4Styles$1;
 };
-type LayoutResult<A extends aux.Any = aux.Any> = {
+type LayoutResult<A extends aux$1.Any = aux$1.Any> = {
   dot: DotSource;
   diagram: DiagramView<A>;
 };
@@ -304,9 +1496,19 @@ declare class GraphvizLayouter implements Disposable {
   [Symbol.dispose](): void;
   get graphvizPort(): GraphvizPort;
   changePort(graphviz: GraphvizPort): void;
-  printToDot(params: LayoutTaskParams): DotSource;
+  /**
+   * 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.
+   */
+  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;
@@ -356,335 +1558,36 @@ declare class QueueGraphvizLayoter extends GraphvizLayouter {
   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;
-  /**
-   * Creates a new documentation provider.
-   * @param services - The LikeC4 language services.
-   */
-  constructor(services: LikeC4Services);
-  /**
-   * 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.
-   */
-  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$1;
-  folderUri: URI;
-  config: LikeC4ProjectConfig;
-}
-interface ProjectData extends Project {
-  id: ProjectId$1;
-  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<{
-    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 {
-  #private;
-  protected services: LikeC4SharedServices;
-  /**
-   * The global project ID used for all documents
-   * that are not part of a specific project.
-   */
-  static readonly DefaultProjectId: ProjectId$1;
-  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$1 | undefined;
-  set defaultProjectId(id: string | ProjectId$1 | undefined);
-  get default(): ProjectData;
-  get all(): NonEmptyReadonlyArray<ProjectId$1>;
-  getProject(arg: ProjectId$1 | 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$1 | undefined): ProjectId$1;
-  /**
-   * 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$1 | 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$1, 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$1, 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$1;
-  /**
-   * 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$1;
-  protected resetCaches(): void;
-  rebuildProject(projectId: ProjectId$1, 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$1;
-    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;
-}
-type ManualLayoutsSnapshot = {
-  hash: string;
-  views: Record<ViewId$1, LayoutedView$1>;
-};
-type ManualLayoutUpdateEvent = {
-  updated: URI;
-  projectId: ProjectId$1;
-  viewId: ViewId$1;
-} | {
-  removed: URI;
-  projectId: ProjectId$1;
-  /**
-   * Missing if triggered by FS event (file was deleted)
-   */
-  viewId?: ViewId$1;
-};
-type ManualLayoutUpdateListener = (event: ManualLayoutUpdateEvent) => void;
-interface LikeC4ManualLayouts {
-  /**
-   * 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$1 | null>;
-  read(project: Project): Promise<ManualLayoutsSnapshot | null>;
-  write(project: Project, layouted: LayoutedView$1): Promise<Location>;
-  remove(project: Project, view: ViewId$1): Promise<Location | null>;
-  clearCaches(): void;
+//#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;
   /**
-   * 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>;
+  getDocumentation(node: AstNode): string | undefined;
 } //#endregion
-//#region src/filesystem/noop.d.ts
-//#endregion
-//#region src/formatting/LikeC4Formatter.d.ts
-type QuoteStyle = 'single' | 'double' | 'ignore' | 'auto';
-interface LikeC4FormatterOptions {
-  quoteStyle: QuoteStyle;
-}
-type ExtendedFormattingCommandType = 'normalizeQuotes';
-interface ExtendedFormattingCommand {
-  type: ExtendedFormattingCommandType;
-  region: FormattingRegion;
-}
-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;
+//#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
 //#region src/generated/ast.d.ts
 type AnyProperty = DynamicViewProperty | ElementProperty | NavigateToProperty | NotationProperty | NotesProperty | RelationProperty | RelationshipStyleProperty | StringProperty | StyleProperty | ViewProperty;
@@ -698,7 +1601,7 @@ type DeploymentElement = DeployedInstance | DeploymentNode;
 declare const DeploymentElement = "DeploymentElement";
 type DeploymentNodeOrElementKind = DeploymentNodeKind | ElementKind;
 declare const DeploymentNodeOrElementKind = "DeploymentNodeOrElementKind";
-type DeploymentViewRule = DeploymentViewRulePredicate | DeploymentViewRuleStyle | ViewRuleAutoLayout;
+type DeploymentViewRule = DeploymentViewRulePredicate | DeploymentViewRuleStyle | ViewRuleAncestors | ViewRuleAutoLayout;
 declare const DeploymentViewRule = "DeploymentViewRule";
 type DynamicViewDisplayVariantValue = 'diagram' | 'sequence';
 type DynamicViewProperty = DynamicViewDisplayVariantProperty | ViewProperty;
@@ -830,7 +1733,7 @@ declare const CustomElementProperties = "CustomElementProperties";
 interface CustomRelationProperties extends AstNode {
   readonly $container: AbstractDynamicStep | RelationExprWith;
   readonly $type: 'CustomRelationProperties';
-  props: Array<NotationProperty | NotesProperty | RelationNavigateToProperty | RelationStringProperty | RelationshipStyleProperty>;
+  props: Array<MultipleProperty | NotationProperty | NotesProperty | RelationNavigateToProperty | RelationStringProperty | RelationshipStyleProperty>;
 }
 declare const CustomRelationProperties = "CustomRelationProperties";
 interface DeployedInstance extends AstNode {
@@ -968,9 +1871,9 @@ interface DynamicViewIncludePredicate extends AstNode {
 }
 declare const DynamicViewIncludePredicate = "DynamicViewIncludePredicate";
 interface DynamicViewParallelSteps extends AstNode {
-  readonly $container: DynamicViewBody;
+  readonly $container: DynamicViewBody | DynamicViewParallelSteps;
   readonly $type: 'DynamicViewParallelSteps';
-  steps: Array<DynamicViewStep>;
+  steps: Array<DynamicViewParallelSteps | DynamicViewStep>;
 }
 declare const DynamicViewParallelSteps = "DynamicViewParallelSteps";
 interface DynamicViewRef extends AstNode {
@@ -1309,7 +2212,7 @@ interface MetadataAttribute extends AstNode {
   readonly $container: MetadataBody;
   readonly $type: 'MetadataAttribute';
   boolValue: boolean;
-  key: string;
+  key: Id;
   value?: MetadataValue;
 }
 declare const MetadataAttribute = "MetadataAttribute";
@@ -1343,7 +2246,7 @@ interface ModelViews extends AstNode {
 }
 declare const ModelViews = "ModelViews";
 interface MultipleProperty extends AstNode {
-  readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
+  readonly $container: CustomElementProperties | CustomRelationProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | SpecificationRelationshipKind | ViewRuleStyle;
   readonly $type: 'MultipleProperty';
   key: 'multiple';
   value: boolean;
@@ -1518,7 +2421,7 @@ interface SpecificationRelationshipKind extends AstNode {
   readonly $container: SpecificationRule;
   readonly $type: 'SpecificationRelationshipKind';
   kind: RelationshipKind;
-  props: Array<RelationshipStyleProperty | SpecificationRelationshipStringProperty>;
+  props: Array<MultipleProperty | RelationshipStyleProperty | SpecificationRelationshipStringProperty>;
 }
 declare const SpecificationRelationshipKind = "SpecificationRelationshipKind";
 interface SpecificationRelationshipStringProperty extends AstNode {
@@ -1592,6 +2495,13 @@ interface ViewRef extends AstNode {
   view: Reference<LikeC4View>;
 }
 declare const ViewRef = "ViewRef";
+interface ViewRuleAncestors extends AstNode {
+  readonly $container: DeploymentViewBody;
+  readonly $type: 'ViewRuleAncestors';
+  key: 'includeAncestors';
+  value: boolean;
+}
+declare const ViewRuleAncestors = "ViewRuleAncestors";
 interface ViewRuleAutoLayout extends AstNode {
   readonly $container: DeploymentViewBody | DynamicViewBody | ElementViewBody;
   readonly $type: 'ViewRuleAutoLayout';
@@ -1909,6 +2819,7 @@ type LikeC4AstType = {
   ViewProperty: ViewProperty;
   ViewRef: ViewRef;
   ViewRule: ViewRule;
+  ViewRuleAncestors: ViewRuleAncestors;
   ViewRuleAutoLayout: ViewRuleAutoLayout;
   ViewRuleGlobalPredicateRef: ViewRuleGlobalPredicateRef;
   ViewRuleGlobalStyle: ViewRuleGlobalStyle;
@@ -2015,6 +2926,7 @@ interface ParsedAstSpecification {
     line?: c4.RelationshipLineType;
     head?: c4.RelationshipArrowType;
     tail?: c4.RelationshipArrowType;
+    multiple?: boolean;
   }>;
   colors: Record<c4.CustomColor, {
     color: c4.ColorLiteral;
@@ -2107,42 +3019,349 @@ interface ParsedAstDynamicView {
   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>;
+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;
+  /**
+   * 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;
+  protected resetCaches(): 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>;
 }
-type ParsedAstView = ParsedAstElementView | ParsedAstDynamicView | ParsedAstDeploymentView;
-interface AstNodeDescriptionWithFqn extends AstNodeDescription {
-  likec4ProjectId: c4.ProjectId;
-  id: c4.Fqn;
+interface FileSystemWatcher extends AsyncDisposable {
+  /**
+   * Watches a folder for changes and triggers a reload of the documents and projects.
+   */
+  watch(folder: string): void;
 }
-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 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>;
+} //#endregion
+//#region src/filesystem/noop.d.ts
+//#endregion
+//#region src/formatting/LikeC4Formatter.d.ts
+type QuoteStyle = 'single' | 'double' | 'ignore' | 'auto';
+interface LikeC4FormatterOptions {
+  quoteStyle: QuoteStyle;
 }
-type LikeC4GrammarDocument = Omit<LangiumDocument<LikeC4Grammar>, 'diagnostics'>;
-interface LikeC4LangiumDocument extends LikeC4GrammarDocument, LikeC4DocumentProps {
-  likec4ProjectId: c4.ProjectId;
+type ExtendedFormattingCommandType = 'normalizeQuotes';
+interface ExtendedFormattingCommand {
+  type: ExtendedFormattingCommandType;
+  region: FormattingRegion;
 }
-interface ParsedLikeC4LangiumDocument extends LikeC4GrammarDocument, Required<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;
+  private findPredicateExpressionRoot;
+  private on;
+  private doExtendedFormatting;
+  protected normalizeQuotes(node: AstNode): void;
+  private quotesNormalizerFactory;
+  private escapeQuotesInternalQuotes;
+  private getAutoQuoteStyle;
+  private onConfigurationUpdate;
 } //#endregion
 //#region src/references/name-provider.d.ts
 declare class LikeC4NameProvider extends DefaultNameProvider {
@@ -2173,7 +3392,7 @@ declare class IndexManager extends DefaultIndexManager {
   protected services: LikeC4SharedServices;
   constructor(services: LikeC4SharedServices);
   updateContent(document: LangiumDocument, cancelToken?: CancellationToken$1): Promise<void>;
-  projectElements(projectId: ProjectId, nodeType?: string, uris?: Set<string>): Stream<AstNodeDescription>;
+  projectElements(projectId: ProjectId$1, nodeType?: string, uris?: Set<string>): Stream<AstNodeDescription>;
 } //#endregion
 //#region src/workspace/LangiumDocuments.d.ts
 declare class LangiumDocuments extends DefaultLangiumDocuments {
@@ -2193,8 +3412,8 @@ declare class LangiumDocuments extends DefaultLangiumDocuments {
   /**
    * Returns all documents for a project, including both project documents and documents included by the project.
    */
-  projectDocuments(projectId: ProjectId): Stream<LikeC4LangiumDocument>;
-  groupedByProject(): Record<ProjectId, NonEmptyArray<LikeC4LangiumDocument>>;
+  projectDocuments(projectId: ProjectId$1): Stream<LikeC4LangiumDocument>;
+  groupedByProject(): Record<ProjectId$1, NonEmptyArray$1<LikeC4LangiumDocument>>;
   /**
    * Reset the project IDs of all documents.
    * Returns the URIs
@@ -2265,12 +3484,12 @@ declare class LikeC4ScopeProvider extends DefaultScopeProvider {
     viewOf,
     extends: ext
   }: ElementView): Generator<AstNodeDescription>;
-  protected getScopeForStrictFqnRef(projectId: ProjectId, container: StrictFqnRef, context: ReferenceInfo): Scope;
+  protected getScopeForStrictFqnRef(projectId: ProjectId$1, container: StrictFqnRef, context: ReferenceInfo): Scope;
   protected genScopeExtendDeployment({
     deploymentNode
   }: ExtendDeployment): Generator<AstNodeDescription>;
-  protected streamForFqnRef(projectId: ProjectId, container: FqnRef$2, context: ReferenceInfo): Stream<AstNodeDescription>;
-  protected genScopeForParentlessFqnRef(projectId: ProjectId, container: FqnRef$2, context: ReferenceInfo): 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>;
   /**
    * Computes the scope for a given reference context.
    *
@@ -2282,24 +3501,16 @@ declare class LikeC4ScopeProvider extends DefaultScopeProvider {
    * It then iterates through the container hierarchy, collecting relevant scopes based on the reference type and container type.
    * Finally, it combines the collected scopes with the global scope to produce the final scope.
    */
-  protected computeScope(projectId: ProjectId, context: ReferenceInfo, referenceType?: string): Generator<AstNodeDescription>;
+  protected computeScope(projectId: ProjectId$1, context: ReferenceInfo, referenceType?: string): Generator<AstNodeDescription>;
   /**
    * Create a global scope filtered for the given reference type.
    */
-  protected getProjectScope(projectId: ProjectId, referenceType: string, context: ReferenceInfo): Scope;
+  protected getProjectScope(projectId: ProjectId$1, referenceType: string, context: ReferenceInfo): Scope;
   /**
    * 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
 //#region src/model/fqn-index.d.ts
 declare class FqnIndex<AstNd = Element> extends ADisposable {
   protected services: LikeC4Services;
@@ -2311,15 +3522,15 @@ declare class FqnIndex<AstNd = Element> extends ADisposable {
   constructor(services: LikeC4Services);
   private documents;
   get(document: LikeC4LangiumDocument): DocumentFqnIndex;
-  resolve(reference: Referenceable): Fqn$1;
-  getFqn(el: AstNd): Fqn$1;
-  byFqn(projectId: ProjectId$1, fqn: Fqn$1): Stream<AstNodeDescriptionWithFqn>;
-  rootElements(projectId: ProjectId$1): Stream<AstNodeDescriptionWithFqn>;
-  directChildrenOf(projectId: ProjectId$1, parent: Fqn$1): Stream<AstNodeDescriptionWithFqn>;
+  resolve(reference: Referenceable): Fqn;
+  getFqn(el: AstNd): Fqn;
+  byFqn(projectId: ProjectId, fqn: Fqn): Stream<AstNodeDescriptionWithFqn>;
+  rootElements(projectId: ProjectId): Stream<AstNodeDescriptionWithFqn>;
+  directChildrenOf(projectId: ProjectId, parent: Fqn): Stream<AstNodeDescriptionWithFqn>;
   /**
    * Returns descedant elements with unique names in the scope
    */
-  uniqueDescedants(projectId: ProjectId$1, parent: Fqn$1): Stream<AstNodeDescriptionWithFqn>;
+  uniqueDescedants(projectId: ProjectId, parent: Fqn): Stream<AstNodeDescriptionWithFqn>;
   protected createDocumentIndex(document: LikeC4LangiumDocument): DocumentFqnIndex;
 }
 declare class DocumentFqnIndex {
@@ -2336,28 +3547,28 @@ declare class DocumentFqnIndex {
    * All elements by FQN
    */
   private _byfqn;
-  readonly projectId: ProjectId$1;
+  readonly projectId: ProjectId;
   static readonly EMPTY: DocumentFqnIndex;
   constructor(_rootElements: Array<AstNodeDescriptionWithFqn>,
   /**
    * direct children of elements
    */
 
-  _children: MultiMap<Fqn$1, AstNodeDescriptionWithFqn>,
+  _children: MultiMap<Fqn, AstNodeDescriptionWithFqn>,
   /**
    * All descendants of an element (unique by name)
    */
 
-  _descendants: MultiMap<Fqn$1, AstNodeDescriptionWithFqn>,
+  _descendants: MultiMap<Fqn, AstNodeDescriptionWithFqn>,
   /**
    * All elements by FQN
    */
 
-  _byfqn: MultiMap<Fqn$1, AstNodeDescriptionWithFqn>, projectId: ProjectId$1);
+  _byfqn: MultiMap<Fqn, AstNodeDescriptionWithFqn>, projectId: ProjectId);
   rootElements(): readonly AstNodeDescriptionWithFqn[];
-  byFqn(fqn: Fqn$1): readonly AstNodeDescriptionWithFqn[];
-  children(parent: Fqn$1): readonly AstNodeDescriptionWithFqn[];
-  descendants(nodeName: Fqn$1): readonly AstNodeDescriptionWithFqn[];
+  byFqn(fqn: Fqn): readonly AstNodeDescriptionWithFqn[];
+  children(parent: Fqn): readonly AstNodeDescriptionWithFqn[];
+  descendants(nodeName: Fqn): readonly AstNodeDescriptionWithFqn[];
 } //#endregion
 //#region src/model/deployments-index.d.ts
 declare class DeploymentsIndex extends FqnIndex<DeploymentElement> {
@@ -2433,7 +3644,7 @@ declare class MergedSpecification {
  * 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);
   /**
@@ -2459,7 +3670,7 @@ declare class LastSeenArtifacts {
    * @param projectId - Project id to look up.
    * @returns LikeC4Styles or undefined.
    */
-  styles(projectId: c4.ProjectId): LikeC4Styles$1 | undefined;
+  styles(projectId: c4.ProjectId): LikeC4Styles | undefined;
   /**
    * Returns the last seen computed model for the given project, if available.
    * @param projectId - Project id to look up.
@@ -2468,11 +3679,11 @@ declare class LastSeenArtifacts {
   model(projectId: c4.ProjectId): LikeC4Model.Computed | undefined;
 } //#endregion
 //#region src/model/model-builder.d.ts
-type ModelParsedListener = (projectId: ProjectId, docs: URI[]) => void;
+type ModelParsedListener = (projectId: ProjectId$1, docs: URI[]) => void;
 interface LikeC4ModelBuilder extends Disposable$1 {
-  parseModel(projectId?: ProjectId | undefined, cancelToken?: CancellationToken$1): Promise<LikeC4Model<UnknownParsed> | null>;
-  unsafeSyncComputeModel(projectId: ProjectId): LikeC4Model<UnknownComputed>;
-  computeModel(projectId?: ProjectId | undefined, cancelToken?: CancellationToken$1): Promise<LikeC4Model<UnknownComputed>>;
+  parseModel(projectId?: ProjectId$1 | undefined, cancelToken?: CancellationToken$1): Promise<LikeC4Model<UnknownParsed> | null>;
+  unsafeSyncComputeModel(projectId: ProjectId$1): LikeC4Model<UnknownComputed>;
+  computeModel(projectId?: ProjectId$1 | undefined, cancelToken?: CancellationToken$1): Promise<LikeC4Model<UnknownComputed>>;
   onModelParsed(callback: ModelParsedListener): Disposable$1;
   clearCache(): void;
 } //#endregion
@@ -2548,15 +3759,15 @@ declare class LikeC4ModelLocator {
 //#region src/views/LikeC4Views.d.ts
 type GraphvizOut = {
   readonly dot: string;
-  readonly diagram: LayoutedView;
+  readonly diagram: LayoutedView$1;
 };
 type GraphvizSvgOut = {
-  readonly id: ViewId;
+  readonly id: ViewId$1;
   readonly dot: string;
   readonly svg: string;
 };
 type LayoutViewParams = {
-  viewId: ViewId;
+  viewId: ViewId$1;
   /**
    * Type of layout to apply
    * - 'manual' - applies manual layout if any
@@ -2564,29 +3775,32 @@ type LayoutViewParams = {
    * - undefined - returns latest layout as is
    */
   layoutType?: LayoutType | undefined;
-  projectId?: ProjectId | undefined;
-  cancelToken?: CancellationToken$1 | undefined;
+  projectId?: ProjectId$1 | undefined;
+  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)
    *
    * @param projectId - project id, if not specified - uses the default project
    */
-  computedViews(projectId?: ProjectId | undefined, cancelToken?: CancellationToken$1): Promise<ComputedView[]>;
+  computedViews(projectId?: ProjectId$1 | undefined, cancelToken?: CancellationToken$1): Promise<ComputedView[]>;
   /**
    * Layouts all views (ignoring any manual snapshots)
    *
    * @param projectId - project id, if not specified - uses the default project
    */
-  layoutAllViews(projectId?: ProjectId | undefined, cancelToken?: CancellationToken$1): Promise<GraphvizOut[]>;
+  layoutAllViews(projectId?: ProjectId$1 | undefined, cancelToken?: CancellationToken$1): Promise<GraphvizOut[]>;
   /**
    * Layouts a view.
-   * If layoutType is 'manual' - applies manual layout if any.
-   * If layoutType is 'auto' - returns latest version with drifts from manual layout if any
+   * If `layoutType` is 'manual' - applies manual layout if any.
+   * If `layoutType` is 'auto' - returns latest version with drifts from manual layout if any
    * If not specified - returns latest layout as is
    *
+   * If `layoutHints` are provided, they will be used, ignoring any manual snapshots, and the resulting layout will not be cached (i.e. it will be computed on every call)
+   *
    * If view not found in model, but there is a snapshot - it will be returned (with empty DOT)
    */
   layoutView(params: LayoutViewParams): Promise<GraphvizOut | null>;
@@ -2595,25 +3809,25 @@ interface LikeC4Views {
    * If diagram has manual layout, it will be used.
    * @param projectId - project id, if not specified - uses the default project
    */
-  diagrams(projectId?: ProjectId | undefined, cancelToken?: CancellationToken$1): Promise<Array<DiagramView>>;
+  diagrams(projectId?: ProjectId$1 | undefined, cancelToken?: CancellationToken$1): Promise<Array<DiagramView>>;
   /**
    * Returns all layouted views as Graphviz output (i.e. views with layout computed)
    * @param projectId - project id, if not specified - uses the default project
    */
-  viewsAsGraphvizOut(projectId?: ProjectId | undefined, cancelToken?: CancellationToken$1): Promise<Array<GraphvizSvgOut>>;
+  viewsAsGraphvizOut(projectId?: ProjectId$1 | undefined, cancelToken?: CancellationToken$1): Promise<Array<GraphvizSvgOut>>;
   /**
    * Open view in the preview panel.
    * (works only if running as a vscode extension)
    *
    * @param projectId - project id, if not specified - uses the default project
    */
-  openView(viewId: ViewId, projectId?: ProjectId | undefined): Promise<void>;
+  openView(viewId: ViewId$1, projectId?: ProjectId$1 | undefined): Promise<void>;
   /**
    * Computes and layouts an adhoc view (not defined in the model)
    *
    * @param projectId - project id, if not specified - uses the default project
    */
-  adhocView(predicates: AdhocViewPredicate[], projectId?: ProjectId | undefined): Promise<LayoutedView>;
+  adhocView(predicates: AdhocViewPredicate[], projectId?: ProjectId$1 | undefined): Promise<LayoutedView$1>;
 } //#endregion
 //#region src/views/index.d.ts
 //#endregion
@@ -2679,58 +3893,58 @@ declare class BaseParser {
 declare const DocumentParserFromMixins: {
   new (...args: any[]): {
     parseGlobals(): void;
-    parseAndStoreGlobalPredicateGroupOrDynamic(astRule: GlobalPredicateGroup | GlobalDynamicPredicateGroup, id: ProjectId, c4Globals: ParsedAstGlobals): void;
-    parseGlobalPredicateGroup(astRule: GlobalPredicateGroup): ProjectId[];
-    parseGlobalDynamicPredicateGroup(astRule: GlobalDynamicPredicateGroup): ProjectId[];
-    parseGlobalStyleOrGroup(astRule: GlobalStyle | GlobalStyleGroup): ProjectId[];
+    parseAndStoreGlobalPredicateGroupOrDynamic(astRule: GlobalPredicateGroup | GlobalDynamicPredicateGroup, id: ProjectId$1, c4Globals: ParsedAstGlobals): void;
+    parseGlobalPredicateGroup(astRule: GlobalPredicateGroup): ProjectId$1[];
+    parseGlobalDynamicPredicateGroup(astRule: GlobalDynamicPredicateGroup): ProjectId$1[];
+    parseGlobalStyleOrGroup(astRule: GlobalStyle | GlobalStyleGroup): ProjectId$1[];
     parseViews(): void;
     parseElementView(astNode: ElementView, additionalStyles: any[]): ParsedAstElementView;
-    parseElementViewRule(astRule: ViewRule): ProjectId;
-    parseViewRulePredicate(astNode: ViewRulePredicate): ProjectId;
-    parseViewRuleGlobalPredicateRef(astRule: ViewRuleGlobalPredicateRef | DynamicViewGlobalPredicateRef): ProjectId;
+    parseElementViewRule(astRule: ViewRule): ProjectId$1;
+    parseViewRulePredicate(astNode: ViewRulePredicate): ProjectId$1;
+    parseViewRuleGlobalPredicateRef(astRule: ViewRuleGlobalPredicateRef | DynamicViewGlobalPredicateRef): ProjectId$1;
     parseViewRuleStyleOrGlobalRef(astRule: ViewRuleStyleOrGlobalRef): any;
-    parseViewRuleGroup(astNode: ViewRuleGroup): ProjectId;
-    parseViewRuleRank(astRule: ViewRuleRank): ProjectId;
-    parseViewRuleStyle(astRule: ViewRuleStyle | GlobalStyle): ProjectId;
-    parseViewRuleGlobalStyle(astRule: ViewRuleGlobalStyle): ProjectId;
+    parseViewRuleGroup(astNode: ViewRuleGroup): ProjectId$1;
+    parseViewRuleRank(astRule: ViewRuleRank): ProjectId$1;
+    parseViewRuleStyle(astRule: ViewRuleStyle | GlobalStyle): ProjectId$1;
+    parseViewRuleGlobalStyle(astRule: ViewRuleGlobalStyle): ProjectId$1;
     parseDynamicElementView(astNode: DynamicView, additionalStyles: any[]): ParsedAstDynamicView;
-    parseDynamicViewRule(astRule: DynamicViewRule): ProjectId;
-    parseDynamicViewIncludePredicate(astRule: DynamicViewIncludePredicate): ProjectId;
-    parseDynamicParallelSteps(node: DynamicViewParallelSteps): ProjectId;
-    parseDynamicStep(node: DynamicViewStep): ProjectId | ProjectId;
-    recursiveParseDynamicStepChain(node: DynamicStepChain, callstack?: Array<[source: ProjectId, target: ProjectId]>): ProjectId[];
-    parseDynamicStepSingle(node: DynamicStepSingle): ProjectId;
-    parseAbstractDynamicStep(astnode: AbstractDynamicStep): type_fest0.Writable<type_fest0.Except<ProjectId, "source", {
+    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", {
       requireExactProps: true;
     }>>;
-    parsePredicate(astNode: ExpressionV2): ProjectId;
-    parseElementPredicate(astNode: FqnExprOrWith): ProjectId;
-    parseElementPredicateOrWhere(astNode: FqnExprOrWhere): ProjectId;
-    parseElementExpression(astNode: FqnExpr$2): ProjectId;
-    parseElementPredicateWhere(astNode: FqnExprWhere): ProjectId;
-    parseElementPredicateWith(astNode: FqnExprWith): ProjectId;
-    parseRelationPredicate(astNode: RelationExprOrWith): ProjectId;
-    parseRelationPredicateOrWhere(astNode: RelationExprOrWhere): ProjectId;
-    parseRelationPredicateWhere(astNode: RelationExprWhere): ProjectId;
-    parseRelationPredicateWith(astNode: RelationExprWith): ProjectId;
-    parseRelationExpression(astNode: RelationExpr$1): ProjectId;
-    parseFqnRef(astNode: FqnRef$2): ProjectId;
-    parseExpressionV2(astNode: ExpressionV2): ProjectId;
-    parseFqnExprOrWith(astNode: FqnExprOrWith): ProjectId;
-    parseFqnExprWith(astNode: FqnExprWith): ProjectId;
-    parseFqnExprOrWhere(astNode: FqnExprOrWhere): ProjectId;
-    parseFqnExprWhere(astNode: FqnExprWhere): ProjectId;
-    parseFqnExpr(astNode: FqnExpr$2): ProjectId;
-    parseFqnRefExpr(astNode: FqnRefExpr): ProjectId;
-    parseFqnExpressions(astNode: FqnExpressions): ProjectId[];
-    parseRelationExprOrWith(astNode: RelationExprOrWith): ProjectId;
-    parseRelationExprWith(astNode: RelationExprWith): ProjectId;
-    parseCustomRelationProperties(custom: CustomRelationProperties | undefined): type_fest0.Except<ProjectId["customRelation"], "expr">;
-    parseRelationExprOrWhere(astNode: RelationExprOrWhere): ProjectId;
-    parseRelationExprWhere(astNode: RelationExprWhere): ProjectId;
-    parseRelationExpr(astNode: RelationExpr$1): ProjectId;
-    parseInlineKindCondition(astNode: OutgoingRelationExpr): ProjectId | null;
-    wrapInWhere(expr: ProjectId, condition: ProjectId | null): ProjectId;
+    parsePredicate(astNode: ExpressionV2): ProjectId$1;
+    parseElementPredicate(astNode: FqnExprOrWith): ProjectId$1;
+    parseElementPredicateOrWhere(astNode: FqnExprOrWhere): ProjectId$1;
+    parseElementExpression(astNode: FqnExpr$2): ProjectId$1;
+    parseElementPredicateWhere(astNode: FqnExprWhere): ProjectId$1;
+    parseElementPredicateWith(astNode: FqnExprWith): ProjectId$1;
+    parseRelationPredicate(astNode: RelationExprOrWith): ProjectId$1;
+    parseRelationPredicateOrWhere(astNode: RelationExprOrWhere): ProjectId$1;
+    parseRelationPredicateWhere(astNode: RelationExprWhere): ProjectId$1;
+    parseRelationPredicateWith(astNode: RelationExprWith): ProjectId$1;
+    parseRelationExpression(astNode: RelationExpr$1): ProjectId$1;
+    parseFqnRef(astNode: FqnRef$2): ProjectId$1;
+    parseExpressionV2(astNode: ExpressionV2): ProjectId$1;
+    parseFqnExprOrWith(astNode: FqnExprOrWith): ProjectId$1;
+    parseFqnExprWith(astNode: FqnExprWith): ProjectId$1;
+    parseFqnExprOrWhere(astNode: FqnExprOrWhere): ProjectId$1;
+    parseFqnExprWhere(astNode: FqnExprWhere): ProjectId$1;
+    parseFqnExpr(astNode: FqnExpr$2): ProjectId$1;
+    parseFqnRefExpr(astNode: FqnRefExpr): ProjectId$1;
+    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">;
+    parseRelationExprOrWhere(astNode: RelationExprOrWhere): ProjectId$1;
+    parseRelationExprWhere(astNode: RelationExprWhere): ProjectId$1;
+    parseRelationExpr(astNode: RelationExpr$1): ProjectId$1;
+    parseInlineKindCondition(astNode: OutgoingRelationExpr): ProjectId$1 | null;
+    wrapInWhere(expr: ProjectId$1, condition: ProjectId$1 | null): ProjectId$1;
     isValid: IsValidFn;
     docUri: string;
     docPathInProject: string;
@@ -2740,23 +3954,23 @@ declare const DocumentParserFromMixins: {
     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[];
-    resolveFqn(node: FqnReferenceable): ProjectId;
+    resolveFqn(node: FqnReferenceable): ProjectId$1;
     getAstNodePath(node: AstNode): string;
     getMetadata(metadataAstNode: MetadataProperty | undefined): {
       [key: string]: string | string[];
     } | undefined;
-    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId | undefined;
+    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId$1 | undefined;
     convertTags<E extends {
       tags?: Tags;
     }>(withTags?: E | undefined): any;
     parseTags<E extends {
       tags?: Tags;
-    }>(withTags?: E): ProjectId<ProjectId> | null;
-    convertLinks(source?: LinkProperty["$container"]): ProjectId<ProjectId> | undefined;
-    parseLinks(source?: LinkProperty["$container"]): ProjectId<ProjectId> | undefined;
-    parseIconProperty(prop: IconProperty | undefined): ProjectId | undefined;
+    }>(withTags?: E): ProjectId$1<ProjectId$1> | null;
+    convertLinks(source?: LinkProperty["$container"]): ProjectId$1<ProjectId$1> | undefined;
+    parseLinks(source?: LinkProperty["$container"]): ProjectId$1<ProjectId$1> | undefined;
+    parseIconProperty(prop: IconProperty | undefined): ProjectId$1 | undefined;
     parseImageAlias(value: string): string | undefined;
-    parseColorLiteral(astNode: ColorLiteral$1): ProjectId | undefined;
+    parseColorLiteral(astNode: ColorLiteral$1): ProjectId$1 | undefined;
     parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
     parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
     parseBaseProps(props: {
@@ -2771,71 +3985,71 @@ declare const DocumentParserFromMixins: {
       technology?: string | undefined;
     }): {
       title?: string;
-      summary?: ProjectId;
-      description?: ProjectId;
+      summary?: ProjectId$1;
+      description?: ProjectId$1;
       technology?: string;
     };
     parseDeploymentView(astNode: DeploymentView): ParsedAstDeploymentView;
-    parseDeploymentViewRule(astRule: DeploymentViewRule): ProjectId;
-    parseDeploymentViewRulePredicate(astRule: DeploymentViewRulePredicate): ProjectId;
-    parseDeploymentViewRuleStyle(astRule: DeploymentViewRuleStyle): ProjectId;
+    parseDeploymentViewRule(astRule: DeploymentViewRule): ProjectId$1;
+    parseDeploymentViewRulePredicate(astRule: DeploymentViewRulePredicate): ProjectId$1;
+    parseDeploymentViewRuleStyle(astRule: DeploymentViewRuleStyle): ProjectId$1;
     parseDeployment(): void;
     parseDeploymentNode(astNode: DeploymentNode): ParsedAstDeployment.Node;
     parseDeployedInstance(astNode: DeployedInstance): ParsedAstDeployment.Instance;
     parseExtendDeployment(astNode: ExtendDeployment): ParsedAstExtend | null;
-    _resolveDeploymentRelationSource(node: DeploymentRelation): ProjectId;
+    _resolveDeploymentRelationSource(node: DeploymentRelation): ProjectId$1;
     parseDeploymentRelation(astNode: DeploymentRelation): ParsedAstDeploymentRelation;
   };
 } & {
   new (...args: any[]): {
     parseViews(): void;
     parseElementView(astNode: ElementView, additionalStyles: any[]): ParsedAstElementView;
-    parseElementViewRule(astRule: ViewRule): ProjectId;
-    parseViewRulePredicate(astNode: ViewRulePredicate): ProjectId;
-    parseViewRuleGlobalPredicateRef(astRule: ViewRuleGlobalPredicateRef | DynamicViewGlobalPredicateRef): ProjectId;
+    parseElementViewRule(astRule: ViewRule): ProjectId$1;
+    parseViewRulePredicate(astNode: ViewRulePredicate): ProjectId$1;
+    parseViewRuleGlobalPredicateRef(astRule: ViewRuleGlobalPredicateRef | DynamicViewGlobalPredicateRef): ProjectId$1;
     parseViewRuleStyleOrGlobalRef(astRule: ViewRuleStyleOrGlobalRef): any;
-    parseViewRuleGroup(astNode: ViewRuleGroup): ProjectId;
-    parseViewRuleRank(astRule: ViewRuleRank): ProjectId;
-    parseViewRuleStyle(astRule: ViewRuleStyle | GlobalStyle): ProjectId;
-    parseViewRuleGlobalStyle(astRule: ViewRuleGlobalStyle): ProjectId;
+    parseViewRuleGroup(astNode: ViewRuleGroup): ProjectId$1;
+    parseViewRuleRank(astRule: ViewRuleRank): ProjectId$1;
+    parseViewRuleStyle(astRule: ViewRuleStyle | GlobalStyle): ProjectId$1;
+    parseViewRuleGlobalStyle(astRule: ViewRuleGlobalStyle): ProjectId$1;
     parseDynamicElementView(astNode: DynamicView, additionalStyles: any[]): ParsedAstDynamicView;
-    parseDynamicViewRule(astRule: DynamicViewRule): ProjectId;
-    parseDynamicViewIncludePredicate(astRule: DynamicViewIncludePredicate): ProjectId;
-    parseDynamicParallelSteps(node: DynamicViewParallelSteps): ProjectId;
-    parseDynamicStep(node: DynamicViewStep): ProjectId | ProjectId;
-    recursiveParseDynamicStepChain(node: DynamicStepChain, callstack?: Array<[source: ProjectId, target: ProjectId]>): ProjectId[];
-    parseDynamicStepSingle(node: DynamicStepSingle): ProjectId;
-    parseAbstractDynamicStep(astnode: AbstractDynamicStep): type_fest0.Writable<type_fest0.Except<ProjectId, "source", {
+    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", {
       requireExactProps: true;
     }>>;
-    parsePredicate(astNode: ExpressionV2): ProjectId;
-    parseElementPredicate(astNode: FqnExprOrWith): ProjectId;
-    parseElementPredicateOrWhere(astNode: FqnExprOrWhere): ProjectId;
-    parseElementExpression(astNode: FqnExpr$2): ProjectId;
-    parseElementPredicateWhere(astNode: FqnExprWhere): ProjectId;
-    parseElementPredicateWith(astNode: FqnExprWith): ProjectId;
-    parseRelationPredicate(astNode: RelationExprOrWith): ProjectId;
-    parseRelationPredicateOrWhere(astNode: RelationExprOrWhere): ProjectId;
-    parseRelationPredicateWhere(astNode: RelationExprWhere): ProjectId;
-    parseRelationPredicateWith(astNode: RelationExprWith): ProjectId;
-    parseRelationExpression(astNode: RelationExpr$1): ProjectId;
-    parseFqnRef(astNode: FqnRef$2): ProjectId;
-    parseExpressionV2(astNode: ExpressionV2): ProjectId;
-    parseFqnExprOrWith(astNode: FqnExprOrWith): ProjectId;
-    parseFqnExprWith(astNode: FqnExprWith): ProjectId;
-    parseFqnExprOrWhere(astNode: FqnExprOrWhere): ProjectId;
-    parseFqnExprWhere(astNode: FqnExprWhere): ProjectId;
-    parseFqnExpr(astNode: FqnExpr$2): ProjectId;
-    parseFqnRefExpr(astNode: FqnRefExpr): ProjectId;
-    parseFqnExpressions(astNode: FqnExpressions): ProjectId[];
-    parseRelationExprOrWith(astNode: RelationExprOrWith): ProjectId;
-    parseRelationExprWith(astNode: RelationExprWith): ProjectId;
-    parseCustomRelationProperties(custom: CustomRelationProperties | undefined): type_fest0.Except<ProjectId["customRelation"], "expr">;
-    parseRelationExprOrWhere(astNode: RelationExprOrWhere): ProjectId;
-    parseRelationExprWhere(astNode: RelationExprWhere): ProjectId;
-    parseRelationExpr(astNode: RelationExpr$1): ProjectId;
-    parseInlineKindCondition(astNode: OutgoingRelationExpr): ProjectId | null;
-    wrapInWhere(expr: ProjectId, condition: ProjectId | null): ProjectId;
+    parsePredicate(astNode: ExpressionV2): ProjectId$1;
+    parseElementPredicate(astNode: FqnExprOrWith): ProjectId$1;
+    parseElementPredicateOrWhere(astNode: FqnExprOrWhere): ProjectId$1;
+    parseElementExpression(astNode: FqnExpr$2): ProjectId$1;
+    parseElementPredicateWhere(astNode: FqnExprWhere): ProjectId$1;
+    parseElementPredicateWith(astNode: FqnExprWith): ProjectId$1;
+    parseRelationPredicate(astNode: RelationExprOrWith): ProjectId$1;
+    parseRelationPredicateOrWhere(astNode: RelationExprOrWhere): ProjectId$1;
+    parseRelationPredicateWhere(astNode: RelationExprWhere): ProjectId$1;
+    parseRelationPredicateWith(astNode: RelationExprWith): ProjectId$1;
+    parseRelationExpression(astNode: RelationExpr$1): ProjectId$1;
+    parseFqnRef(astNode: FqnRef$2): ProjectId$1;
+    parseExpressionV2(astNode: ExpressionV2): ProjectId$1;
+    parseFqnExprOrWith(astNode: FqnExprOrWith): ProjectId$1;
+    parseFqnExprWith(astNode: FqnExprWith): ProjectId$1;
+    parseFqnExprOrWhere(astNode: FqnExprOrWhere): ProjectId$1;
+    parseFqnExprWhere(astNode: FqnExprWhere): ProjectId$1;
+    parseFqnExpr(astNode: FqnExpr$2): ProjectId$1;
+    parseFqnRefExpr(astNode: FqnRefExpr): ProjectId$1;
+    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">;
+    parseRelationExprOrWhere(astNode: RelationExprOrWhere): ProjectId$1;
+    parseRelationExprWhere(astNode: RelationExprWhere): ProjectId$1;
+    parseRelationExpr(astNode: RelationExpr$1): ProjectId$1;
+    parseInlineKindCondition(astNode: OutgoingRelationExpr): ProjectId$1 | null;
+    wrapInWhere(expr: ProjectId$1, condition: ProjectId$1 | null): ProjectId$1;
     isValid: IsValidFn;
     docUri: string;
     docPathInProject: string;
@@ -2845,23 +4059,23 @@ declare const DocumentParserFromMixins: {
     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[];
-    resolveFqn(node: FqnReferenceable): ProjectId;
+    resolveFqn(node: FqnReferenceable): ProjectId$1;
     getAstNodePath(node: AstNode): string;
     getMetadata(metadataAstNode: MetadataProperty | undefined): {
       [key: string]: string | string[];
     } | undefined;
-    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId | undefined;
+    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId$1 | undefined;
     convertTags<E extends {
       tags?: Tags;
     }>(withTags?: E | undefined): any;
     parseTags<E extends {
       tags?: Tags;
-    }>(withTags?: E): ProjectId<ProjectId> | null;
-    convertLinks(source?: LinkProperty["$container"]): ProjectId<ProjectId> | undefined;
-    parseLinks(source?: LinkProperty["$container"]): ProjectId<ProjectId> | undefined;
-    parseIconProperty(prop: IconProperty | undefined): ProjectId | undefined;
+    }>(withTags?: E): ProjectId$1<ProjectId$1> | null;
+    convertLinks(source?: LinkProperty["$container"]): ProjectId$1<ProjectId$1> | undefined;
+    parseLinks(source?: LinkProperty["$container"]): ProjectId$1<ProjectId$1> | undefined;
+    parseIconProperty(prop: IconProperty | undefined): ProjectId$1 | undefined;
     parseImageAlias(value: string): string | undefined;
-    parseColorLiteral(astNode: ColorLiteral$1): ProjectId | undefined;
+    parseColorLiteral(astNode: ColorLiteral$1): ProjectId$1 | undefined;
     parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
     parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
     parseBaseProps(props: {
@@ -2876,19 +4090,19 @@ declare const DocumentParserFromMixins: {
       technology?: string | undefined;
     }): {
       title?: string;
-      summary?: ProjectId;
-      description?: ProjectId;
+      summary?: ProjectId$1;
+      description?: ProjectId$1;
       technology?: string;
     };
     parseDeploymentView(astNode: DeploymentView): ParsedAstDeploymentView;
-    parseDeploymentViewRule(astRule: DeploymentViewRule): ProjectId;
-    parseDeploymentViewRulePredicate(astRule: DeploymentViewRulePredicate): ProjectId;
-    parseDeploymentViewRuleStyle(astRule: DeploymentViewRuleStyle): ProjectId;
+    parseDeploymentViewRule(astRule: DeploymentViewRule): ProjectId$1;
+    parseDeploymentViewRulePredicate(astRule: DeploymentViewRulePredicate): ProjectId$1;
+    parseDeploymentViewRuleStyle(astRule: DeploymentViewRuleStyle): ProjectId$1;
     parseDeployment(): void;
     parseDeploymentNode(astNode: DeploymentNode): ParsedAstDeployment.Node;
     parseDeployedInstance(astNode: DeployedInstance): ParsedAstDeployment.Instance;
     parseExtendDeployment(astNode: ExtendDeployment): ParsedAstExtend | null;
-    _resolveDeploymentRelationSource(node: DeploymentRelation): ProjectId;
+    _resolveDeploymentRelationSource(node: DeploymentRelation): ProjectId$1;
     parseDeploymentRelation(astNode: DeploymentRelation): ParsedAstDeploymentRelation;
   };
 } & {
@@ -2905,23 +4119,23 @@ declare const DocumentParserFromMixins: {
     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[];
-    resolveFqn(node: FqnReferenceable): ProjectId;
+    resolveFqn(node: FqnReferenceable): ProjectId$1;
     getAstNodePath(node: AstNode): string;
     getMetadata(metadataAstNode: MetadataProperty | undefined): {
       [key: string]: string | string[];
     } | undefined;
-    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId | undefined;
+    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId$1 | undefined;
     convertTags<E extends {
       tags?: Tags;
     }>(withTags?: E | undefined): any;
     parseTags<E extends {
       tags?: Tags;
-    }>(withTags?: E): ProjectId<ProjectId> | null;
-    convertLinks(source?: LinkProperty["$container"]): ProjectId<ProjectId> | undefined;
-    parseLinks(source?: LinkProperty["$container"]): ProjectId<ProjectId> | undefined;
-    parseIconProperty(prop: IconProperty | undefined): ProjectId | undefined;
+    }>(withTags?: E): ProjectId$1<ProjectId$1> | null;
+    convertLinks(source?: LinkProperty["$container"]): ProjectId$1<ProjectId$1> | undefined;
+    parseLinks(source?: LinkProperty["$container"]): ProjectId$1<ProjectId$1> | undefined;
+    parseIconProperty(prop: IconProperty | undefined): ProjectId$1 | undefined;
     parseImageAlias(value: string): string | undefined;
-    parseColorLiteral(astNode: ColorLiteral$1): ProjectId | undefined;
+    parseColorLiteral(astNode: ColorLiteral$1): ProjectId$1 | undefined;
     parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
     parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
     parseBaseProps(props: {
@@ -2936,41 +4150,41 @@ declare const DocumentParserFromMixins: {
       technology?: string | undefined;
     }): {
       title?: string;
-      summary?: ProjectId;
-      description?: ProjectId;
+      summary?: ProjectId$1;
+      description?: ProjectId$1;
       technology?: string;
     };
   };
 } & {
   new (...args: any[]): {
-    parsePredicate(astNode: ExpressionV2): ProjectId;
-    parseElementPredicate(astNode: FqnExprOrWith): ProjectId;
-    parseElementPredicateOrWhere(astNode: FqnExprOrWhere): ProjectId;
-    parseElementExpression(astNode: FqnExpr$2): ProjectId;
-    parseElementPredicateWhere(astNode: FqnExprWhere): ProjectId;
-    parseElementPredicateWith(astNode: FqnExprWith): ProjectId;
-    parseRelationPredicate(astNode: RelationExprOrWith): ProjectId;
-    parseRelationPredicateOrWhere(astNode: RelationExprOrWhere): ProjectId;
-    parseRelationPredicateWhere(astNode: RelationExprWhere): ProjectId;
-    parseRelationPredicateWith(astNode: RelationExprWith): ProjectId;
-    parseRelationExpression(astNode: RelationExpr$1): ProjectId;
-    parseFqnRef(astNode: FqnRef$2): ProjectId;
-    parseExpressionV2(astNode: ExpressionV2): ProjectId;
-    parseFqnExprOrWith(astNode: FqnExprOrWith): ProjectId;
-    parseFqnExprWith(astNode: FqnExprWith): ProjectId;
-    parseFqnExprOrWhere(astNode: FqnExprOrWhere): ProjectId;
-    parseFqnExprWhere(astNode: FqnExprWhere): ProjectId;
-    parseFqnExpr(astNode: FqnExpr$2): ProjectId;
-    parseFqnRefExpr(astNode: FqnRefExpr): ProjectId;
-    parseFqnExpressions(astNode: FqnExpressions): ProjectId[];
-    parseRelationExprOrWith(astNode: RelationExprOrWith): ProjectId;
-    parseRelationExprWith(astNode: RelationExprWith): ProjectId;
-    parseCustomRelationProperties(custom: CustomRelationProperties | undefined): type_fest0.Except<ProjectId["customRelation"], "expr">;
-    parseRelationExprOrWhere(astNode: RelationExprOrWhere): ProjectId;
-    parseRelationExprWhere(astNode: RelationExprWhere): ProjectId;
-    parseRelationExpr(astNode: RelationExpr$1): ProjectId;
-    parseInlineKindCondition(astNode: OutgoingRelationExpr): ProjectId | null;
-    wrapInWhere(expr: ProjectId, condition: ProjectId | null): ProjectId;
+    parsePredicate(astNode: ExpressionV2): ProjectId$1;
+    parseElementPredicate(astNode: FqnExprOrWith): ProjectId$1;
+    parseElementPredicateOrWhere(astNode: FqnExprOrWhere): ProjectId$1;
+    parseElementExpression(astNode: FqnExpr$2): ProjectId$1;
+    parseElementPredicateWhere(astNode: FqnExprWhere): ProjectId$1;
+    parseElementPredicateWith(astNode: FqnExprWith): ProjectId$1;
+    parseRelationPredicate(astNode: RelationExprOrWith): ProjectId$1;
+    parseRelationPredicateOrWhere(astNode: RelationExprOrWhere): ProjectId$1;
+    parseRelationPredicateWhere(astNode: RelationExprWhere): ProjectId$1;
+    parseRelationPredicateWith(astNode: RelationExprWith): ProjectId$1;
+    parseRelationExpression(astNode: RelationExpr$1): ProjectId$1;
+    parseFqnRef(astNode: FqnRef$2): ProjectId$1;
+    parseExpressionV2(astNode: ExpressionV2): ProjectId$1;
+    parseFqnExprOrWith(astNode: FqnExprOrWith): ProjectId$1;
+    parseFqnExprWith(astNode: FqnExprWith): ProjectId$1;
+    parseFqnExprOrWhere(astNode: FqnExprOrWhere): ProjectId$1;
+    parseFqnExprWhere(astNode: FqnExprWhere): ProjectId$1;
+    parseFqnExpr(astNode: FqnExpr$2): ProjectId$1;
+    parseFqnRefExpr(astNode: FqnRefExpr): ProjectId$1;
+    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">;
+    parseRelationExprOrWhere(astNode: RelationExprOrWhere): ProjectId$1;
+    parseRelationExprWhere(astNode: RelationExprWhere): ProjectId$1;
+    parseRelationExpr(astNode: RelationExpr$1): ProjectId$1;
+    parseInlineKindCondition(astNode: OutgoingRelationExpr): ProjectId$1 | null;
+    wrapInWhere(expr: ProjectId$1, condition: ProjectId$1 | null): ProjectId$1;
     isValid: IsValidFn;
     docUri: string;
     docPathInProject: string;
@@ -2980,23 +4194,23 @@ declare const DocumentParserFromMixins: {
     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[];
-    resolveFqn(node: FqnReferenceable): ProjectId;
+    resolveFqn(node: FqnReferenceable): ProjectId$1;
     getAstNodePath(node: AstNode): string;
     getMetadata(metadataAstNode: MetadataProperty | undefined): {
       [key: string]: string | string[];
     } | undefined;
-    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId | undefined;
+    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId$1 | undefined;
     convertTags<E extends {
       tags?: Tags;
     }>(withTags?: E | undefined): any;
     parseTags<E extends {
       tags?: Tags;
-    }>(withTags?: E): ProjectId<ProjectId> | null;
-    convertLinks(source?: LinkProperty["$container"]): ProjectId<ProjectId> | undefined;
-    parseLinks(source?: LinkProperty["$container"]): ProjectId<ProjectId> | undefined;
-    parseIconProperty(prop: IconProperty | undefined): ProjectId | undefined;
+    }>(withTags?: E): ProjectId$1<ProjectId$1> | null;
+    convertLinks(source?: LinkProperty["$container"]): ProjectId$1<ProjectId$1> | undefined;
+    parseLinks(source?: LinkProperty["$container"]): ProjectId$1<ProjectId$1> | undefined;
+    parseIconProperty(prop: IconProperty | undefined): ProjectId$1 | undefined;
     parseImageAlias(value: string): string | undefined;
-    parseColorLiteral(astNode: ColorLiteral$1): ProjectId | undefined;
+    parseColorLiteral(astNode: ColorLiteral$1): ProjectId$1 | undefined;
     parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
     parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
     parseBaseProps(props: {
@@ -3011,34 +4225,34 @@ declare const DocumentParserFromMixins: {
       technology?: string | undefined;
     }): {
       title?: string;
-      summary?: ProjectId;
-      description?: ProjectId;
+      summary?: ProjectId$1;
+      description?: ProjectId$1;
       technology?: string;
     };
   };
 } & {
   new (...args: any[]): {
     parseDeploymentView(astNode: DeploymentView): ParsedAstDeploymentView;
-    parseDeploymentViewRule(astRule: DeploymentViewRule): ProjectId;
-    parseDeploymentViewRulePredicate(astRule: DeploymentViewRulePredicate): ProjectId;
-    parseDeploymentViewRuleStyle(astRule: DeploymentViewRuleStyle): ProjectId;
-    parseFqnRef(astNode: FqnRef$2): ProjectId;
-    parseExpressionV2(astNode: ExpressionV2): ProjectId;
-    parseFqnExprOrWith(astNode: FqnExprOrWith): ProjectId;
-    parseFqnExprWith(astNode: FqnExprWith): ProjectId;
-    parseFqnExprOrWhere(astNode: FqnExprOrWhere): ProjectId;
-    parseFqnExprWhere(astNode: FqnExprWhere): ProjectId;
-    parseFqnExpr(astNode: FqnExpr$2): ProjectId;
-    parseFqnRefExpr(astNode: FqnRefExpr): ProjectId;
-    parseFqnExpressions(astNode: FqnExpressions): ProjectId[];
-    parseRelationExprOrWith(astNode: RelationExprOrWith): ProjectId;
-    parseRelationExprWith(astNode: RelationExprWith): ProjectId;
-    parseCustomRelationProperties(custom: CustomRelationProperties | undefined): type_fest0.Except<ProjectId["customRelation"], "expr">;
-    parseRelationExprOrWhere(astNode: RelationExprOrWhere): ProjectId;
-    parseRelationExprWhere(astNode: RelationExprWhere): ProjectId;
-    parseRelationExpr(astNode: RelationExpr$1): ProjectId;
-    parseInlineKindCondition(astNode: OutgoingRelationExpr): ProjectId | null;
-    wrapInWhere(expr: ProjectId, condition: ProjectId | null): ProjectId;
+    parseDeploymentViewRule(astRule: DeploymentViewRule): ProjectId$1;
+    parseDeploymentViewRulePredicate(astRule: DeploymentViewRulePredicate): ProjectId$1;
+    parseDeploymentViewRuleStyle(astRule: DeploymentViewRuleStyle): ProjectId$1;
+    parseFqnRef(astNode: FqnRef$2): ProjectId$1;
+    parseExpressionV2(astNode: ExpressionV2): ProjectId$1;
+    parseFqnExprOrWith(astNode: FqnExprOrWith): ProjectId$1;
+    parseFqnExprWith(astNode: FqnExprWith): ProjectId$1;
+    parseFqnExprOrWhere(astNode: FqnExprOrWhere): ProjectId$1;
+    parseFqnExprWhere(astNode: FqnExprWhere): ProjectId$1;
+    parseFqnExpr(astNode: FqnExpr$2): ProjectId$1;
+    parseFqnRefExpr(astNode: FqnRefExpr): ProjectId$1;
+    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">;
+    parseRelationExprOrWhere(astNode: RelationExprOrWhere): ProjectId$1;
+    parseRelationExprWhere(astNode: RelationExprWhere): ProjectId$1;
+    parseRelationExpr(astNode: RelationExpr$1): ProjectId$1;
+    parseInlineKindCondition(astNode: OutgoingRelationExpr): ProjectId$1 | null;
+    wrapInWhere(expr: ProjectId$1, condition: ProjectId$1 | null): ProjectId$1;
     isValid: IsValidFn;
     docUri: string;
     docPathInProject: string;
@@ -3048,23 +4262,23 @@ declare const DocumentParserFromMixins: {
     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[];
-    resolveFqn(node: FqnReferenceable): ProjectId;
+    resolveFqn(node: FqnReferenceable): ProjectId$1;
     getAstNodePath(node: AstNode): string;
     getMetadata(metadataAstNode: MetadataProperty | undefined): {
       [key: string]: string | string[];
     } | undefined;
-    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId | undefined;
+    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId$1 | undefined;
     convertTags<E extends {
       tags?: Tags;
     }>(withTags?: E | undefined): any;
     parseTags<E extends {
       tags?: Tags;
-    }>(withTags?: E): ProjectId<ProjectId> | null;
-    convertLinks(source?: LinkProperty["$container"]): ProjectId<ProjectId> | undefined;
-    parseLinks(source?: LinkProperty["$container"]): ProjectId<ProjectId> | undefined;
-    parseIconProperty(prop: IconProperty | undefined): ProjectId | undefined;
+    }>(withTags?: E): ProjectId$1<ProjectId$1> | null;
+    convertLinks(source?: LinkProperty["$container"]): ProjectId$1<ProjectId$1> | undefined;
+    parseLinks(source?: LinkProperty["$container"]): ProjectId$1<ProjectId$1> | undefined;
+    parseIconProperty(prop: IconProperty | undefined): ProjectId$1 | undefined;
     parseImageAlias(value: string): string | undefined;
-    parseColorLiteral(astNode: ColorLiteral$1): ProjectId | undefined;
+    parseColorLiteral(astNode: ColorLiteral$1): ProjectId$1 | undefined;
     parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
     parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
     parseBaseProps(props: {
@@ -3079,15 +4293,15 @@ declare const DocumentParserFromMixins: {
       technology?: string | undefined;
     }): {
       title?: string;
-      summary?: ProjectId;
-      description?: ProjectId;
+      summary?: ProjectId$1;
+      description?: ProjectId$1;
       technology?: string;
     };
     parseDeployment(): void;
     parseDeploymentNode(astNode: DeploymentNode): ParsedAstDeployment.Node;
     parseDeployedInstance(astNode: DeployedInstance): ParsedAstDeployment.Instance;
     parseExtendDeployment(astNode: ExtendDeployment): ParsedAstExtend | null;
-    _resolveDeploymentRelationSource(node: DeploymentRelation): ProjectId;
+    _resolveDeploymentRelationSource(node: DeploymentRelation): ProjectId$1;
     parseDeploymentRelation(astNode: DeploymentRelation): ParsedAstDeploymentRelation;
   };
 } & {
@@ -3096,25 +4310,25 @@ declare const DocumentParserFromMixins: {
     parseDeploymentNode(astNode: DeploymentNode): ParsedAstDeployment.Node;
     parseDeployedInstance(astNode: DeployedInstance): ParsedAstDeployment.Instance;
     parseExtendDeployment(astNode: ExtendDeployment): ParsedAstExtend | null;
-    _resolveDeploymentRelationSource(node: DeploymentRelation): ProjectId;
+    _resolveDeploymentRelationSource(node: DeploymentRelation): ProjectId$1;
     parseDeploymentRelation(astNode: DeploymentRelation): ParsedAstDeploymentRelation;
-    parseFqnRef(astNode: FqnRef$2): ProjectId;
-    parseExpressionV2(astNode: ExpressionV2): ProjectId;
-    parseFqnExprOrWith(astNode: FqnExprOrWith): ProjectId;
-    parseFqnExprWith(astNode: FqnExprWith): ProjectId;
-    parseFqnExprOrWhere(astNode: FqnExprOrWhere): ProjectId;
-    parseFqnExprWhere(astNode: FqnExprWhere): ProjectId;
-    parseFqnExpr(astNode: FqnExpr$2): ProjectId;
-    parseFqnRefExpr(astNode: FqnRefExpr): ProjectId;
-    parseFqnExpressions(astNode: FqnExpressions): ProjectId[];
-    parseRelationExprOrWith(astNode: RelationExprOrWith): ProjectId;
-    parseRelationExprWith(astNode: RelationExprWith): ProjectId;
-    parseCustomRelationProperties(custom: CustomRelationProperties | undefined): type_fest0.Except<ProjectId["customRelation"], "expr">;
-    parseRelationExprOrWhere(astNode: RelationExprOrWhere): ProjectId;
-    parseRelationExprWhere(astNode: RelationExprWhere): ProjectId;
-    parseRelationExpr(astNode: RelationExpr$1): ProjectId;
-    parseInlineKindCondition(astNode: OutgoingRelationExpr): ProjectId | null;
-    wrapInWhere(expr: ProjectId, condition: ProjectId | null): ProjectId;
+    parseFqnRef(astNode: FqnRef$2): ProjectId$1;
+    parseExpressionV2(astNode: ExpressionV2): ProjectId$1;
+    parseFqnExprOrWith(astNode: FqnExprOrWith): ProjectId$1;
+    parseFqnExprWith(astNode: FqnExprWith): ProjectId$1;
+    parseFqnExprOrWhere(astNode: FqnExprOrWhere): ProjectId$1;
+    parseFqnExprWhere(astNode: FqnExprWhere): ProjectId$1;
+    parseFqnExpr(astNode: FqnExpr$2): ProjectId$1;
+    parseFqnRefExpr(astNode: FqnRefExpr): ProjectId$1;
+    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">;
+    parseRelationExprOrWhere(astNode: RelationExprOrWhere): ProjectId$1;
+    parseRelationExprWhere(astNode: RelationExprWhere): ProjectId$1;
+    parseRelationExpr(astNode: RelationExpr$1): ProjectId$1;
+    parseInlineKindCondition(astNode: OutgoingRelationExpr): ProjectId$1 | null;
+    wrapInWhere(expr: ProjectId$1, condition: ProjectId$1 | null): ProjectId$1;
     isValid: IsValidFn;
     docUri: string;
     docPathInProject: string;
@@ -3124,23 +4338,23 @@ declare const DocumentParserFromMixins: {
     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[];
-    resolveFqn(node: FqnReferenceable): ProjectId;
+    resolveFqn(node: FqnReferenceable): ProjectId$1;
     getAstNodePath(node: AstNode): string;
     getMetadata(metadataAstNode: MetadataProperty | undefined): {
       [key: string]: string | string[];
     } | undefined;
-    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId | undefined;
+    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId$1 | undefined;
     convertTags<E extends {
       tags?: Tags;
     }>(withTags?: E | undefined): any;
     parseTags<E extends {
       tags?: Tags;
-    }>(withTags?: E): ProjectId<ProjectId> | null;
-    convertLinks(source?: LinkProperty["$container"]): ProjectId<ProjectId> | undefined;
-    parseLinks(source?: LinkProperty["$container"]): ProjectId<ProjectId> | undefined;
-    parseIconProperty(prop: IconProperty | undefined): ProjectId | undefined;
+    }>(withTags?: E): ProjectId$1<ProjectId$1> | null;
+    convertLinks(source?: LinkProperty["$container"]): ProjectId$1<ProjectId$1> | undefined;
+    parseLinks(source?: LinkProperty["$container"]): ProjectId$1<ProjectId$1> | undefined;
+    parseIconProperty(prop: IconProperty | undefined): ProjectId$1 | undefined;
     parseImageAlias(value: string): string | undefined;
-    parseColorLiteral(astNode: ColorLiteral$1): ProjectId | undefined;
+    parseColorLiteral(astNode: ColorLiteral$1): ProjectId$1 | undefined;
     parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
     parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
     parseBaseProps(props: {
@@ -3155,8 +4369,8 @@ declare const DocumentParserFromMixins: {
       technology?: string | undefined;
     }): {
       title?: string;
-      summary?: ProjectId;
-      description?: ProjectId;
+      summary?: ProjectId$1;
+      description?: ProjectId$1;
       technology?: string;
     };
   };
@@ -3166,25 +4380,25 @@ declare const DocumentParserFromMixins: {
     parseElement(astNode: Element): ParsedAstElement;
     parseExtendElement(astNode: ExtendElement): ParsedAstExtend | null;
     parseExtendRelation(astNode: ExtendRelation): ParsedAstExtendRelation | null;
-    _resolveRelationSource(node: Relation): ProjectId | ProjectId;
+    _resolveRelationSource(node: Relation): ProjectId$1 | ProjectId$1;
     parseRelation(astNode: Relation): ParsedAstRelation;
-    parseFqnRef(astNode: FqnRef$2): ProjectId;
-    parseExpressionV2(astNode: ExpressionV2): ProjectId;
-    parseFqnExprOrWith(astNode: FqnExprOrWith): ProjectId;
-    parseFqnExprWith(astNode: FqnExprWith): ProjectId;
-    parseFqnExprOrWhere(astNode: FqnExprOrWhere): ProjectId;
-    parseFqnExprWhere(astNode: FqnExprWhere): ProjectId;
-    parseFqnExpr(astNode: FqnExpr$2): ProjectId;
-    parseFqnRefExpr(astNode: FqnRefExpr): ProjectId;
-    parseFqnExpressions(astNode: FqnExpressions): ProjectId[];
-    parseRelationExprOrWith(astNode: RelationExprOrWith): ProjectId;
-    parseRelationExprWith(astNode: RelationExprWith): ProjectId;
-    parseCustomRelationProperties(custom: CustomRelationProperties | undefined): type_fest0.Except<ProjectId["customRelation"], "expr">;
-    parseRelationExprOrWhere(astNode: RelationExprOrWhere): ProjectId;
-    parseRelationExprWhere(astNode: RelationExprWhere): ProjectId;
-    parseRelationExpr(astNode: RelationExpr$1): ProjectId;
-    parseInlineKindCondition(astNode: OutgoingRelationExpr): ProjectId | null;
-    wrapInWhere(expr: ProjectId, condition: ProjectId | null): ProjectId;
+    parseFqnRef(astNode: FqnRef$2): ProjectId$1;
+    parseExpressionV2(astNode: ExpressionV2): ProjectId$1;
+    parseFqnExprOrWith(astNode: FqnExprOrWith): ProjectId$1;
+    parseFqnExprWith(astNode: FqnExprWith): ProjectId$1;
+    parseFqnExprOrWhere(astNode: FqnExprOrWhere): ProjectId$1;
+    parseFqnExprWhere(astNode: FqnExprWhere): ProjectId$1;
+    parseFqnExpr(astNode: FqnExpr$2): ProjectId$1;
+    parseFqnRefExpr(astNode: FqnRefExpr): ProjectId$1;
+    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">;
+    parseRelationExprOrWhere(astNode: RelationExprOrWhere): ProjectId$1;
+    parseRelationExprWhere(astNode: RelationExprWhere): ProjectId$1;
+    parseRelationExpr(astNode: RelationExpr$1): ProjectId$1;
+    parseInlineKindCondition(astNode: OutgoingRelationExpr): ProjectId$1 | null;
+    wrapInWhere(expr: ProjectId$1, condition: ProjectId$1 | null): ProjectId$1;
     isValid: IsValidFn;
     docUri: string;
     docPathInProject: string;
@@ -3194,23 +4408,23 @@ declare const DocumentParserFromMixins: {
     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[];
-    resolveFqn(node: FqnReferenceable): ProjectId;
+    resolveFqn(node: FqnReferenceable): ProjectId$1;
     getAstNodePath(node: AstNode): string;
     getMetadata(metadataAstNode: MetadataProperty | undefined): {
       [key: string]: string | string[];
     } | undefined;
-    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId | undefined;
+    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId$1 | undefined;
     convertTags<E extends {
       tags?: Tags;
     }>(withTags?: E | undefined): any;
     parseTags<E extends {
       tags?: Tags;
-    }>(withTags?: E): ProjectId<ProjectId> | null;
-    convertLinks(source?: LinkProperty["$container"]): ProjectId<ProjectId> | undefined;
-    parseLinks(source?: LinkProperty["$container"]): ProjectId<ProjectId> | undefined;
-    parseIconProperty(prop: IconProperty | undefined): ProjectId | undefined;
+    }>(withTags?: E): ProjectId$1<ProjectId$1> | null;
+    convertLinks(source?: LinkProperty["$container"]): ProjectId$1<ProjectId$1> | undefined;
+    parseLinks(source?: LinkProperty["$container"]): ProjectId$1<ProjectId$1> | undefined;
+    parseIconProperty(prop: IconProperty | undefined): ProjectId$1 | undefined;
     parseImageAlias(value: string): string | undefined;
-    parseColorLiteral(astNode: ColorLiteral$1): ProjectId | undefined;
+    parseColorLiteral(astNode: ColorLiteral$1): ProjectId$1 | undefined;
     parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
     parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
     parseBaseProps(props: {
@@ -3225,8 +4439,8 @@ declare const DocumentParserFromMixins: {
       technology?: string | undefined;
     }): {
       title?: string;
-      summary?: ProjectId;
-      description?: ProjectId;
+      summary?: ProjectId$1;
+      description?: ProjectId$1;
       technology?: string;
     };
   };
@@ -3242,23 +4456,23 @@ declare const DocumentParserFromMixins: {
     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[];
-    resolveFqn(node: FqnReferenceable): ProjectId;
+    resolveFqn(node: FqnReferenceable): ProjectId$1;
     getAstNodePath(node: AstNode): string;
     getMetadata(metadataAstNode: MetadataProperty | undefined): {
       [key: string]: string | string[];
     } | undefined;
-    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId | undefined;
+    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId$1 | undefined;
     convertTags<E extends {
       tags?: Tags;
     }>(withTags?: E | undefined): any;
     parseTags<E extends {
       tags?: Tags;
-    }>(withTags?: E): ProjectId<ProjectId> | null;
-    convertLinks(source?: LinkProperty["$container"]): ProjectId<ProjectId> | undefined;
-    parseLinks(source?: LinkProperty["$container"]): ProjectId<ProjectId> | undefined;
-    parseIconProperty(prop: IconProperty | undefined): ProjectId | undefined;
+    }>(withTags?: E): ProjectId$1<ProjectId$1> | null;
+    convertLinks(source?: LinkProperty["$container"]): ProjectId$1<ProjectId$1> | undefined;
+    parseLinks(source?: LinkProperty["$container"]): ProjectId$1<ProjectId$1> | undefined;
+    parseIconProperty(prop: IconProperty | undefined): ProjectId$1 | undefined;
     parseImageAlias(value: string): string | undefined;
-    parseColorLiteral(astNode: ColorLiteral$1): ProjectId | undefined;
+    parseColorLiteral(astNode: ColorLiteral$1): ProjectId$1 | undefined;
     parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
     parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
     parseBaseProps(props: {
@@ -3273,30 +4487,30 @@ declare const DocumentParserFromMixins: {
       technology?: string | undefined;
     }): {
       title?: string;
-      summary?: ProjectId;
-      description?: ProjectId;
+      summary?: ProjectId$1;
+      description?: ProjectId$1;
       technology?: string;
     };
   };
 } & {
   new (...args: any[]): {
-    parseFqnRef(astNode: FqnRef$2): ProjectId;
-    parseExpressionV2(astNode: ExpressionV2): ProjectId;
-    parseFqnExprOrWith(astNode: FqnExprOrWith): ProjectId;
-    parseFqnExprWith(astNode: FqnExprWith): ProjectId;
-    parseFqnExprOrWhere(astNode: FqnExprOrWhere): ProjectId;
-    parseFqnExprWhere(astNode: FqnExprWhere): ProjectId;
-    parseFqnExpr(astNode: FqnExpr$2): ProjectId;
-    parseFqnRefExpr(astNode: FqnRefExpr): ProjectId;
-    parseFqnExpressions(astNode: FqnExpressions): ProjectId[];
-    parseRelationExprOrWith(astNode: RelationExprOrWith): ProjectId;
-    parseRelationExprWith(astNode: RelationExprWith): ProjectId;
-    parseCustomRelationProperties(custom: CustomRelationProperties | undefined): type_fest0.Except<ProjectId["customRelation"], "expr">;
-    parseRelationExprOrWhere(astNode: RelationExprOrWhere): ProjectId;
-    parseRelationExprWhere(astNode: RelationExprWhere): ProjectId;
-    parseRelationExpr(astNode: RelationExpr$1): ProjectId;
-    parseInlineKindCondition(astNode: OutgoingRelationExpr): ProjectId | null;
-    wrapInWhere(expr: ProjectId, condition: ProjectId | null): ProjectId;
+    parseFqnRef(astNode: FqnRef$2): ProjectId$1;
+    parseExpressionV2(astNode: ExpressionV2): ProjectId$1;
+    parseFqnExprOrWith(astNode: FqnExprOrWith): ProjectId$1;
+    parseFqnExprWith(astNode: FqnExprWith): ProjectId$1;
+    parseFqnExprOrWhere(astNode: FqnExprOrWhere): ProjectId$1;
+    parseFqnExprWhere(astNode: FqnExprWhere): ProjectId$1;
+    parseFqnExpr(astNode: FqnExpr$2): ProjectId$1;
+    parseFqnRefExpr(astNode: FqnRefExpr): ProjectId$1;
+    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">;
+    parseRelationExprOrWhere(astNode: RelationExprOrWhere): ProjectId$1;
+    parseRelationExprWhere(astNode: RelationExprWhere): ProjectId$1;
+    parseRelationExpr(astNode: RelationExpr$1): ProjectId$1;
+    parseInlineKindCondition(astNode: OutgoingRelationExpr): ProjectId$1 | null;
+    wrapInWhere(expr: ProjectId$1, condition: ProjectId$1 | null): ProjectId$1;
     isValid: IsValidFn;
     docUri: string;
     docPathInProject: string;
@@ -3306,23 +4520,23 @@ declare const DocumentParserFromMixins: {
     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[];
-    resolveFqn(node: FqnReferenceable): ProjectId;
+    resolveFqn(node: FqnReferenceable): ProjectId$1;
     getAstNodePath(node: AstNode): string;
     getMetadata(metadataAstNode: MetadataProperty | undefined): {
       [key: string]: string | string[];
     } | undefined;
-    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId | undefined;
+    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId$1 | undefined;
     convertTags<E extends {
       tags?: Tags;
     }>(withTags?: E | undefined): any;
     parseTags<E extends {
       tags?: Tags;
-    }>(withTags?: E): ProjectId<ProjectId> | null;
-    convertLinks(source?: LinkProperty["$container"]): ProjectId<ProjectId> | undefined;
-    parseLinks(source?: LinkProperty["$container"]): ProjectId<ProjectId> | undefined;
-    parseIconProperty(prop: IconProperty | undefined): ProjectId | undefined;
+    }>(withTags?: E): ProjectId$1<ProjectId$1> | null;
+    convertLinks(source?: LinkProperty["$container"]): ProjectId$1<ProjectId$1> | undefined;
+    parseLinks(source?: LinkProperty["$container"]): ProjectId$1<ProjectId$1> | undefined;
+    parseIconProperty(prop: IconProperty | undefined): ProjectId$1 | undefined;
     parseImageAlias(value: string): string | undefined;
-    parseColorLiteral(astNode: ColorLiteral$1): ProjectId | undefined;
+    parseColorLiteral(astNode: ColorLiteral$1): ProjectId$1 | undefined;
     parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
     parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
     parseBaseProps(props: {
@@ -3337,18 +4551,18 @@ declare const DocumentParserFromMixins: {
       technology?: string | undefined;
     }): {
       title?: string;
-      summary?: ProjectId;
-      description?: ProjectId;
+      summary?: ProjectId$1;
+      description?: ProjectId$1;
       technology?: string;
     };
   };
 } & typeof BaseParser;
 declare class DocumentParser extends DocumentParserFromMixins {}
-declare class LikeC4ModelParser {
+declare class LikeC4ModelParser extends ADisposable {
   private services;
   protected cachedParsers: any;
   constructor(services: LikeC4Services);
-  documents(projectId: ProjectId): Stream<ParsedLikeC4LangiumDocument>;
+  documents(projectId: ProjectId$1): Stream<ParsedLikeC4LangiumDocument>;
   parse(doc: LangiumDocument): ParsedLikeC4LangiumDocument;
   forDocument(doc: LangiumDocument): DocumentParser;
   private createParser;
@@ -3368,7 +4582,7 @@ declare class LikeC4ModelChanges {
     change
   }: {
     lookup: ViewLocateResult;
-    change: Exclude<ViewChange, ViewChange.SaveViewSnapshot | ViewChange.ResetManualLayout>;
+    change: Exclude<ViewChange, ViewChange.SaveViewSnapshot | ViewChange.ResetManualLayout | ViewChange.ChangeProperty>;
   }): {
     modifiedRange: Range;
     edits: TextEdit[];
@@ -3386,8 +4600,8 @@ interface LikeC4LanguageServices {
   /**
    * Returns all projects with relevant documents
    */
-  projects(): NonEmptyArray<{
-    id: ProjectId;
+  projects(): NonEmptyArray$1<{
+    id: ProjectId$1;
     folder: URI;
     title: string;
     documents: ReadonlyArray<URI>;
@@ -3396,8 +4610,8 @@ interface LikeC4LanguageServices {
   /**
    * Returns project by ID, returns default project if no ID is specified
    */
-  project(projectId?: ProjectId): {
-    id: ProjectId;
+  project(projectId?: ProjectId$1): {
+    id: ProjectId$1;
     folder: URI;
     title: string;
     documents: ReadonlyArray<URI>;
@@ -3414,21 +4628,21 @@ interface LikeC4LanguageServices {
    *
    * If no {@link project} is specified, returns for default project
    */
-  computedModel(project?: ProjectId | undefined, cancelToken?: CancellationToken$1): Promise<LikeC4Model<UnknownComputed>>;
+  computedModel(project?: ProjectId$1 | undefined, cancelToken?: CancellationToken$1): Promise<LikeC4Model<UnknownComputed>>;
   /**
    * Returns {@link LikeC4Model} of the specified project, with layouted views {@link LayoutedView}
    * Ready for rendering. Applies manual layouts if available.
    *
    * If no {@link project} is specified, returns for default project
    */
-  layoutedModel(project?: ProjectId | undefined, cancelToken?: CancellationToken$1): Promise<LikeC4Model<UnknownLayouted>>;
+  layoutedModel(project?: ProjectId$1 | undefined, cancelToken?: CancellationToken$1): Promise<LikeC4Model<UnknownLayouted>>;
   /**
    * Returns diagrams (i.e. layouted views {@link LayoutedView}) for the specified project
    * Applies manual layouts if available.
    *
    * If no {@link project} is specified, returns diagrams for default project
    */
-  diagrams(project?: ProjectId | undefined, cancelToken?: CancellationToken$1): Promise<LayoutedView[]>;
+  diagrams(project?: ProjectId$1 | undefined, cancelToken?: CancellationToken$1): Promise<LayoutedView$1[]>;
   getErrors(): Array<{
     message: string;
     line: number;
@@ -3462,7 +4676,7 @@ interface LikeC4LanguageServices {
  */
 interface FormatOptions {
   /** Include all documents from these projects. */
-  projectIds?: ReadonlyArray<ProjectId>;
+  projectIds?: ReadonlyArray<ProjectId$1>;
   /** Include these specific documents (by URI string). */
   documentUris?: ReadonlyArray<string>;
   /** Size of a tab in spaces (default: 2). */
@@ -3521,7 +4735,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): 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[];
@@ -3558,7 +4772,7 @@ declare class LikeC4HoverProvider extends AstNodeHoverProvider {
    * @param projectId - The project identifier for constructing view links.
    * @returns Markdown string with model details, or undefined if no details available.
    */
-  protected getElementModelHover(model: ElementModel, projectId: ProjectId): string | undefined;
+  protected getElementModelHover(model: ElementModel, projectId: ProjectId$1): string | undefined;
   /**
    * Builds hover content for a deployment node (id, title, kind, summary).
    * @param node - The deployment node AST node to generate hover content for.
@@ -3681,4 +4895,125 @@ interface LikeC4AddedServices {
 }
 type LikeC4Services = LangiumServices & LikeC4AddedServices;
 //#endregion
-export { LikeC4Views as a, LikeC4SharedServices as i, LikeC4ModelBuilder as n, ProjectsManager as o, LikeC4Services as r, LikeC4LanguageServices as t };
+//#region ../language-services/dist/_chunks/options.d.mts
+//#region src/common/LikeC4.d.ts
+interface LikeC4Langium {
+  shared: LikeC4SharedServices;
+  likec4: LikeC4Services;
+}
+declare class LikeC4 {
+  protected readonly langium: LikeC4Langium;
+  protected readonly logger: Logger;
+  constructor(langium: LikeC4Langium, logger?: Logger);
+  /**
+   * File system path to the workspace root
+   */
+  get workspace(): string;
+  /**
+   * URI of the workspace root
+   */
+  get workspaceURI(): URI;
+  /**
+   * URL of the workspace root
+   */
+  get workspaceURL(): URL;
+  get languageServices(): LikeC4LanguageServices;
+  get projectsManager(): ProjectsManager;
+  get viewsService(): LikeC4Views;
+  get modelBuilder(): LikeC4ModelBuilder;
+  private get LangiumDocuments();
+  ensureSingleProject(): void;
+  /**
+   * Diagram is a computed view, layouted using Graphviz
+   * If diagram has manual layout, it will be used.
+   * Used in React components
+   */
+  diagrams(project?: string | undefined): Promise<LayoutedView[]>;
+  /**
+   * Builds LikeC4Model from all documents
+   * Only computes view predicates {@link ComputedView} - i.e. no layout
+   * Not ready for rendering, but enough to traverse
+   *
+   * Sync version does not read manual layouts
+   * Use {@link computedModel} for a version that includes manual layouts
+   */
+  syncComputedModel(project?: string | undefined): LikeC4Model.Computed;
+  /**
+   * Builds LikeC4Model from all documents
+   * Only computes view predicates {@link ComputedView} - i.e. no layout
+   * Not ready for rendering, but enough to traverse
+   */
+  computedModel(project?: string | undefined): Promise<LikeC4Model.Computed>;
+  projects(): NonEmptyArray<ProjectId>;
+  /**
+   * Same as {@link computedModel()}, but also applies layout
+   * Ready for rendering
+   */
+  layoutedModel(project?: string | undefined): Promise<LikeC4Model.Layouted>;
+  getErrors(): Array<{
+    message: string;
+    line: number;
+    range: {
+      start: {
+        line: number;
+        character: number;
+      };
+      end: {
+        line: number;
+        character: number;
+      };
+    };
+    sourceFsPath: string;
+  }>;
+  hasErrors(): boolean;
+  /**
+   * @returns true if there are errors
+   */
+  printErrors(): boolean;
+  /**
+   * Returns the number of parsed documents in the workspace
+   */
+  documentCount(): number;
+  /**
+   * 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: (projectId: ProjectId) => void): () => void;
+  /**
+   * Formats documents and returns a map of document URI → formatted source text.
+   *
+   * Target selection uses union semantics:
+   * - Omit both `projects` and `documentUris` to format **all** documents.
+   * - Provide `projects` to include all documents from those projects.
+   * - Provide `documentUris` to include specific documents.
+   * - Provide both to format the **union** (deduplicated).
+   */
+  format(options?: LikeC4FormatOptions): Promise<Map<string, string>>;
+  dispose(): Promise<void>;
+  [Symbol.asyncDispose](): Promise<void>;
+}
+/**
+ * Options for {@link LikeC4.format}.
+ *
+ * Same as {@link FormatOptions} but uses project name strings instead of {@link ProjectId}.
+ */
+interface LikeC4FormatOptions {
+  /** Include all documents from these projects (by name). */
+  projects?: ReadonlyArray<string>;
+  /** Include these specific documents (by URI string). */
+  documentUris?: ReadonlyArray<string>;
+  /** Size of a tab in spaces (default: 2). */
+  tabSize?: number;
+  /** Prefer spaces over tabs (default: true). */
+  insertSpaces?: boolean;
+  /** Trim trailing whitespace on a line. */
+  trimTrailingWhitespace?: boolean;
+  /** Insert a newline character at the end of the file if one does not exist. */
+  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
+export { LikeC4LanguageServices as n, LikeC4 as t };