@likec4/language-server 1.42.1 → 1.44.0

package/browser/package.json

@@ -1,4 +1,4 @@
 {
   "types": "../dist/browser.d.ts",
-  "module": "../dist/browser.mjs"
+  "module": "../dist/browser.js"
 }

package/browser-worker/package.json

@@ -1,4 +1,4 @@
 {
   "types": "../dist/browser-worker.d.ts",
-  "module": "../dist/browser-worker.mjs"
+  "module": "../dist/browser-worker.js"
 }

package/dist/LikeC4LanguageServices.d.ts

@@ -1,12 +1,13 @@
 import type { LikeC4ProjectConfig } from '@likec4/config';
-import { type DiagramView, type NonEmptyArray, type ProjectId } from '@likec4/core';
+import { type DiagramView, type NonEmptyArray, type ProjectId, type UnknownComputed, type UnknownLayouted } from '@likec4/core';
 import { LikeC4Model } from '@likec4/core/model';
-import { type LangiumDocument, URI } from 'langium';
-import { type Range } from 'vscode-languageserver-types';
+import { URI } from 'langium';
+import type { CancellationToken } from 'vscode-jsonrpc';
+import type { Range } from 'vscode-languageserver-types';
 import type { LikeC4ModelBuilder } from './model';
 import type { LikeC4Services } from './module';
 import type { Locate } from './protocol';
-import type { LikeC4Views } from './views/likec4-views';
+import type { LikeC4Views } from './views/LikeC4Views';
 import { ProjectsManager } from './workspace';
 export interface LikeC4LanguageServices {
     readonly views: LikeC4Views;
@@ -38,9 +39,9 @@ export interface LikeC4LanguageServices {
      * Returns diagrams (i.e. views with layout computed) for the specified project
      * If no project is specified, returns diagrams for default project
      */
-    diagrams(project?: ProjectId | undefined): Promise<DiagramView[]>;
-    computedModel(project?: ProjectId | undefined): Promise<LikeC4Model.Computed>;
-    layoutedModel(project?: ProjectId | undefined): Promise<LikeC4Model.Layouted>;
+    diagrams(project?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<DiagramView[]>;
+    computedModel(project?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<LikeC4Model<UnknownComputed>>;
+    layoutedModel(project?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<LikeC4Model<UnknownLayouted>>;
     getErrors(): Array<{
         message: string;
         line: number;
@@ -59,10 +60,6 @@ export interface LikeC4LanguageServices {
      * Returns the location of the specified element, relation, view or deployment element
      */
     locate(params: Locate.Params): Locate.Res;
-    /**
-     * Checks if the specified document should be excluded from processing.
-     */
-    isExcluded(doc: LangiumDocument): boolean;
     dispose(): Promise<void>;
 }
 /**
@@ -91,20 +88,20 @@ export declare class DefaultLikeC4LanguageServices implements LikeC4LanguageServ
     };
     /**
      * Diagram is a computed view, layouted using Graphviz
-     * Used in React components
+     * If diagram has manual layout, it will be used.
      */
-    diagrams(): Promise<DiagramView[]>;
+    diagrams(project?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<DiagramView[]>;
     /**
      * 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?: ProjectId | undefined): Promise<LikeC4Model.Computed>;
+    computedModel(project?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<LikeC4Model<UnknownComputed>>;
     /**
      * Same as {@link computedModel()}, but also applies layout
      * Ready for rendering
      */
-    layoutedModel(project?: ProjectId | undefined): Promise<LikeC4Model.Layouted>;
+    layoutedModel(project?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<LikeC4Model<UnknownLayouted>>;
     getErrors(): Array<{
         message: string;
         line: number;
@@ -119,9 +116,5 @@ export declare class DefaultLikeC4LanguageServices implements LikeC4LanguageServ
         removed?: string;
     }): Promise<boolean>;
     locate(params: Locate.Params): Locate.Res;
-    /**
-     * Checks if the specified document should be excluded from processing.
-     */
-    isExcluded(doc: LangiumDocument): boolean;
     dispose(): Promise<void>;
 }

package/dist/LikeC4LanguageServices.js

@@ -0,0 +1,182 @@
+import { nonexhaustive, } from '@likec4/core';
+import { LikeC4Model } from '@likec4/core/model';
+import { loggable } from '@likec4/log';
+import { URI } from 'langium';
+import { entries, hasAtLeast, indexBy, map, pipe, prop } from 'remeda';
+import { DiagnosticSeverity } from 'vscode-languageserver-types';
+import { isLikeC4LangiumDocument } from './ast';
+import { logger as mainLogger, logWarnError } from './logger';
+import { ProjectsManager } from './workspace';
+const logger = mainLogger.getChild('LanguageServices');
+/**
+ * Public Language Services
+ */
+export class DefaultLikeC4LanguageServices {
+    services;
+    builder;
+    projectsManager;
+    constructor(services) {
+        this.services = services;
+        this.builder = services.likec4.ModelBuilder;
+        this.projectsManager = services.shared.workspace.ProjectsManager;
+    }
+    get views() {
+        return this.services.likec4.Views;
+    }
+    get workspaceUri() {
+        return this.services.shared.workspace.WorkspaceManager.workspaceUri;
+    }
+    projects() {
+        const projectsManager = this.services.shared.workspace.ProjectsManager;
+        const projectsWithDocs = pipe(this.services.shared.workspace.LangiumDocuments.groupedByProject(), entries(), map(([projectId, docs]) => {
+            const id = projectId;
+            const { folderUri, config } = projectsManager.getProject(id);
+            return {
+                id,
+                folder: folderUri,
+                title: config.title ?? config.name,
+                documents: map(docs, prop('uri')),
+                config,
+            };
+        }));
+        // if there are multiple projects and default project is set, ensure it is first
+        if (hasAtLeast(projectsWithDocs, 2) && projectsManager.defaultProjectId) {
+            const idx = projectsWithDocs.findIndex(p => p.id === projectsManager.defaultProjectId);
+            if (idx > 0) {
+                const [defaultProject] = projectsWithDocs.splice(idx, 1);
+                return [defaultProject, ...projectsWithDocs];
+            }
+            return projectsWithDocs;
+        }
+        if (hasAtLeast(projectsWithDocs, 1)) {
+            return projectsWithDocs;
+        }
+        const { folderUri, config } = projectsManager.getProject(ProjectsManager.DefaultProjectId);
+        const documents = map(this.services.shared.workspace.LangiumDocuments.projectDocuments(ProjectsManager.DefaultProjectId).toArray(), prop('uri'));
+        return [{
+                id: ProjectsManager.DefaultProjectId,
+                folder: folderUri,
+                title: config.title ?? config.name,
+                documents,
+                config,
+            }];
+    }
+    project(projectId) {
+        projectId = this.projectsManager.ensureProjectId(projectId);
+        const projectsManager = this.services.shared.workspace.ProjectsManager;
+        const { folderUri, config } = projectsManager.getProject(projectId);
+        const documents = map(this.services.shared.workspace.LangiumDocuments.projectDocuments(projectId).toArray(), prop('uri'));
+        return {
+            id: projectId,
+            folder: folderUri,
+            title: config.title ?? config.name,
+            documents,
+            config,
+        };
+    }
+    /**
+     * Diagram is a computed view, layouted using Graphviz
+     * If diagram has manual layout, it will be used.
+     */
+    async diagrams(project, cancelToken) {
+        const projectId = this.projectsManager.ensureProjectId(project);
+        return await this.views.diagrams(projectId, cancelToken);
+    }
+    /**
+     * Builds LikeC4Model from all documents
+     * Only computes view predicates {@link ComputedView} - i.e. no layout
+     * Not ready for rendering, but enough to traverse
+     */
+    async computedModel(project, cancelToken) {
+        const projectId = this.projectsManager.ensureProjectId(project);
+        return await this.builder.computeModel(projectId, cancelToken);
+    }
+    /**
+     * Same as {@link computedModel()}, but also applies layout
+     * Ready for rendering
+     */
+    async layoutedModel(project, cancelToken) {
+        const projectId = this.projectsManager.ensureProjectId(project);
+        const model = await this.builder.computeModel(projectId, cancelToken);
+        if (!model) {
+            throw new Error('Failed to parse model');
+        }
+        const layouted = await this.views.layoutAllViews(projectId, cancelToken);
+        return LikeC4Model.create({
+            ...model.$data,
+            _stage: 'layouted',
+            views: pipe(layouted, map(prop('diagram')), indexBy(prop('id'))),
+        });
+    }
+    getErrors() {
+        const docs = this.services.shared.workspace.LangiumDocuments.allExcludingBuiltin.toArray();
+        return docs.flatMap(doc => {
+            return (doc.diagnostics ?? [])
+                .filter(d => d.severity === DiagnosticSeverity.Error)
+                .map(({ message, range }) => ({
+                message,
+                line: range.start.line,
+                range,
+                sourceFsPath: doc.uri.fsPath,
+            }));
+        });
+    }
+    /**
+     * TODO Replace with watcher
+     */
+    async notifyUpdate({ changed, removed }) {
+        if (!changed && !removed) {
+            return false;
+        }
+        const _changed = changed ? URI.file(changed) : undefined;
+        const _removed = removed ? URI.file(removed) : undefined;
+        const pm = this.services.shared.workspace.ProjectsManager;
+        if ((_changed && pm.isConfigFile(_changed)) || (_removed && pm.isConfigFile(_removed))) {
+            await pm.reloadProjects();
+            return true;
+        }
+        const mutex = this.services.shared.workspace.WorkspaceLock;
+        try {
+            let completed = false;
+            await mutex.write(async (token) => {
+                await this.services.shared.workspace.DocumentBuilder.update(_changed ? [_changed] : [], _removed ? [_removed] : [], token);
+                // we come here if only the update was successful, did not throw and not cancelled
+                completed = !token.isCancellationRequested;
+            });
+            return completed;
+        }
+        catch (e) {
+            logger.error(loggable(e));
+            return false;
+        }
+    }
+    locate(params) {
+        switch (true) {
+            case 'element' in params:
+                return this.services.likec4.ModelLocator.locateElement(params.element, params.projectId);
+            case 'relation' in params:
+                return this.services.likec4.ModelLocator.locateRelation(params.relation, params.projectId);
+            case 'view' in params:
+                return this.services.likec4.ModelLocator.locateView(params.view, params.projectId);
+            case 'deployment' in params:
+                return this.services.likec4.ModelLocator.locateDeploymentElement(params.deployment, params.projectId);
+            default:
+                nonexhaustive(params);
+        }
+    }
+    async dispose() {
+        try {
+            logger.debug('disposing LikeC4LanguageServices');
+            await this.services.shared.workspace.FileSystemWatcher.dispose();
+            if (this.services.mcp.Server.isStarted) {
+                await this.services.mcp.Server.stop();
+            }
+            this.services.Rpc.dispose();
+            this.services.likec4.ModelBuilder.dispose();
+            logger.debug('LikeC4LanguageServices disposed');
+        }
+        catch (e) {
+            logger.error(loggable(e));
+        }
+    }
+}

package/dist/Rpc.js

@@ -0,0 +1,245 @@
+import { filter, flatMap, funnel, indexBy, keys, map, mapValues, pipe, sort } from 'remeda';
+import { logger as rootLogger } from './logger';
+import { serializableLikeC4ProjectConfig } from '@likec4/config';
+import { invariant, nonexhaustive, } from '@likec4/core';
+import { LikeC4Model } from '@likec4/core/model';
+import { Disposable, interruptAndCheck, URI, UriUtils } from 'langium';
+import { DiagnosticSeverity } from 'vscode-languageserver-protocol';
+import { BuildDocuments, ChangeView, DidChangeModelNotification, DidRequestOpenViewNotification, FetchComputedModel, FetchLayoutedModel, FetchProjects, FetchTelemetryMetrics, FetchViewsFromAllProjects, GetDocumentTags, LayoutView, Locate, RegisterProject, ReloadProjects, ValidateLayout, } from './protocol';
+import { ADisposable } from './utils';
+const logger = rootLogger.getChild('rpc');
+export class Rpc extends ADisposable {
+    services;
+    constructor(services) {
+        super();
+        this.services = services;
+    }
+    init() {
+        const connection = this.services.shared.lsp.Connection;
+        if (!connection) {
+            logger.info(`[ServerRpc] no connection, not initializing`);
+            return;
+        }
+        logger.info(`[ServerRpc] init`);
+        const likec4Services = this.services.likec4;
+        const projects = this.services.shared.workspace.ProjectsManager;
+        const LangiumDocuments = this.services.shared.workspace.LangiumDocuments;
+        const DocumentBuilder = this.services.shared.workspace.DocumentBuilder;
+        const notifyModelParsed = funnel(() => {
+            logger.debug `sendNotification ${'onDidChangeModel'}`;
+            connection.sendNotification(DidChangeModelNotification.type, '').catch(error => {
+                logger.warn(`[ServerRpc] error sending onDidChangeModel:`, { error });
+                return;
+            });
+        }, {
+            triggerAt: 'end',
+            minQuietPeriodMs: 150,
+            maxBurstDurationMs: 500,
+            minGapMs: 300,
+        });
+        let isFirstBuild = true;
+        this.onDispose(likec4Services.ModelBuilder.onModelParsed(() => notifyModelParsed.call()), connection.onRequest(FetchComputedModel.req, async ({ projectId, cleanCaches }, cancelToken) => {
+            logger.debug `received request ${'fetchComputedModel'} for project ${projectId}`;
+            if (cleanCaches) {
+                const docs = projectId
+                    ? LangiumDocuments.projectDocuments(projectId)
+                    : LangiumDocuments.allExcludingBuiltin;
+                const uris = docs.toArray().map(d => d.uri);
+                await DocumentBuilder.update(uris, [], cancelToken);
+            }
+            const likec4model = await likec4Services.ModelBuilder.computeModel(projectId, cancelToken);
+            if (likec4model !== LikeC4Model.EMPTY) {
+                return { model: likec4model.$model };
+            }
+            return { model: null };
+        }), connection.onRequest(FetchLayoutedModel.req, async ({ projectId }, cancelToken) => {
+            logger.debug `received request ${'fetchLayoutedModel'} for project ${projectId}`;
+            const model = await likec4Services.LanguageServices.layoutedModel(projectId);
+            if (model === null) {
+                return { model: null };
+            }
+            const diagrams = await likec4Services.Views.diagrams(projectId, cancelToken);
+            return {
+                model: {
+                    ...model.$data,
+                    _stage: 'layouted',
+                    views: indexBy(diagrams, d => d.id),
+                },
+            };
+        }), connection.onRequest(LayoutView.req, async ({ viewId, projectId }, cancelToken) => {
+            logger.debug `received request ${'layoutView'} for ${viewId} from project ${projectId}`;
+            const result = await likec4Services.Views.layoutView(viewId, projectId, cancelToken);
+            return { result };
+        }), connection.onRequest(ValidateLayout.Req, async ({ projectId }, cancelToken) => {
+            logger.debug `received request ${'validateLayout'} for project ${projectId}`;
+            const layouts = await likec4Services.Views.layoutAllViews(projectId, cancelToken);
+            const result = reportLayoutDrift(layouts.map(l => l.diagram));
+            return { result };
+        }), connection.onRequest(FetchProjects.req, async (_cancelToken) => {
+            logger.debug `received request ${'FetchProjects'}`;
+            const docsByProject = LangiumDocuments.groupedByProject();
+            return {
+                projects: mapValues(docsByProject, (docs, projectId) => {
+                    const { folderUri, config, } = projects.getProject(projectId);
+                    return {
+                        folder: folderUri.toString(),
+                        config: serializableLikeC4ProjectConfig(config),
+                        docs: map(docs, d => d.uri.toString()),
+                    };
+                }),
+            };
+        }), connection.onRequest(ReloadProjects.req, async () => {
+            logger.debug `received request ${'ReloadProjects'}`;
+            likec4Services.ManualLayouts.clearCaches();
+            await projects.reloadProjects();
+            return;
+        }), connection.onRequest(RegisterProject.req, async (params) => {
+            logger.debug `received request ${'RegisterProject'}`;
+            const project = await projects.registerProject(params);
+            return { id: project.id };
+        }), connection.onRequest(FetchViewsFromAllProjects.req, async (cancelToken) => {
+            logger.debug `received request ${'FetchViewsFromAllProjects'}`;
+            const promises = projects.all.map(async (projectId) => {
+                const computedViews = await likec4Services.Views.computedViews(projectId, cancelToken);
+                return pipe(computedViews, map(v => ({
+                    id: v.id,
+                    title: v.title ?? v.id,
+                    projectId,
+                })), sort((a, b) => {
+                    if (a.id === 'index') {
+                        return -1;
+                    }
+                    if (b.id === 'index') {
+                        return 1;
+                    }
+                    return a.title.localeCompare(b.title);
+                }));
+            });
+            const results = await Promise.allSettled(promises);
+            await interruptAndCheck(cancelToken);
+            return {
+                views: pipe(results, filter(r => r.status === 'fulfilled'), flatMap(r => r.value)),
+            };
+        }), connection.onRequest(BuildDocuments.Req, async ({ docs }, cancelToken) => {
+            const changed = docs.map(d => URI.parse(d));
+            const notChanged = (uri) => changed.every(c => !UriUtils.equals(c, uri));
+            const deleted = LangiumDocuments.allExcludingBuiltin
+                .toArray()
+                .filter(d => notChanged(d.uri))
+                .map(d => d.uri);
+            logger.debug(`[ServerRpc] received request to build:
+  changed (total ${changed.length}):${docs.map(d => '\n    - ' + d).join('')}
+  deleted (total ${deleted.length}):${deleted.map(d => '\n    - ' + d.toString()).join('\n')}`);
+            if (!isFirstBuild && (changed.length + deleted.length) > 0) {
+                await Promise.allSettled([...changed, ...deleted].map(async (d) => {
+                    const uri = d.toString();
+                    logger.debug(`clear diagnostics for ${uri}`);
+                    try {
+                        await connection.sendDiagnostics({
+                            uri,
+                            diagnostics: [],
+                        });
+                    }
+                    catch (e) {
+                        // Ignore
+                        logger.warn(`error clearing diagnostics for ${uri}: ${e}`);
+                    }
+                }));
+            }
+            isFirstBuild = false;
+            await interruptAndCheck(cancelToken);
+            await DocumentBuilder.update(changed, deleted, cancelToken);
+        }), connection.onRequest(Locate.Req, params => {
+            logger.debug `received request ${'locate'}, ${params}`;
+            switch (true) {
+                case 'element' in params:
+                    return likec4Services.ModelLocator.locateElement(params.element, params.projectId);
+                case 'relation' in params:
+                    return likec4Services.ModelLocator.locateRelation(params.relation, params.projectId);
+                case 'astPath' in params:
+                    return likec4Services.ModelLocator.locateDynamicViewStep({
+                        view: params.view,
+                        astPath: params.astPath,
+                        projectId: params.projectId,
+                    });
+                case 'view' in params:
+                    return likec4Services.ModelLocator.locateView(params.view, params.projectId);
+                case 'deployment' in params:
+                    return likec4Services.ModelLocator.locateDeploymentElement(params.deployment, params.projectId);
+                default:
+                    nonexhaustive(params);
+            }
+        }), connection.onRequest(ChangeView.Req, async (request, _cancelToken) => {
+            logger.debug `received request ${'changeView'} of ${request.viewId} from project ${request.projectId}`;
+            return await likec4Services.ModelChanges.applyChange(request);
+        }), connection.onRequest(FetchTelemetryMetrics.req, async (cancelToken) => {
+            const projectsIds = [...projects.all];
+            const promises = projectsIds.map(async (projectId) => {
+                const model = await likec4Services.ModelBuilder.computeModel(projectId, cancelToken);
+                if (model === LikeC4Model.EMPTY) {
+                    return Promise.reject(new Error(`Model is empty`));
+                }
+                return {
+                    elementKinds: keys(model.specification.elements).length,
+                    deploymentKinds: keys(model.specification.deployments).length,
+                    relationshipKinds: keys(model.specification.relationships).length,
+                    tags: keys(model.specification.tags).length,
+                    customColors: keys(model.specification.customColors ?? {}).length,
+                    elements: keys(model.$data.elements).length,
+                    deploymentNodes: [...model.deployment.nodes()].length,
+                    relationships: keys(model.$data.relations).length,
+                    views: keys(model.$data.views).length,
+                    projects: 1,
+                };
+            });
+            const results = await Promise.allSettled(promises);
+            await interruptAndCheck(cancelToken);
+            const values = results.filter(r => r.status === 'fulfilled').map(r => r.value);
+            const metrics = values.length > 0
+                ? values.reduce((acc, r) => ({
+                    elementKinds: acc.elementKinds + r.elementKinds,
+                    deploymentKinds: acc.deploymentKinds + r.deploymentKinds,
+                    relationshipKinds: acc.relationshipKinds + r.relationshipKinds,
+                    tags: acc.tags + r.tags,
+                    customColors: acc.customColors + r.customColors,
+                    elements: acc.elements + r.elements,
+                    deploymentNodes: acc.deploymentNodes + r.deploymentNodes,
+                    relationships: acc.relationships + r.relationships,
+                    views: acc.views + r.views,
+                    projects: acc.projects + 1,
+                }))
+                : null;
+            return {
+                metrics,
+            };
+        }), connection.onRequest(GetDocumentTags.req, async ({ documentUri }, cancelToken) => {
+            const tags = await likec4Services.ModelLocator.locateDocumentTags(URI.parse(documentUri), cancelToken);
+            return {
+                tags,
+            };
+        }), Disposable.create(() => {
+            notifyModelParsed.cancel();
+        }));
+        function reportLayoutDrift(diagrams) {
+            return pipe(diagrams, filter(d => !!d.hasLayoutDrift), map(d => {
+                const loc = likec4Services.ModelLocator.locateView(d.id);
+                invariant(loc, `View ${d.id} not found`);
+                return {
+                    uri: loc.uri,
+                    viewId: d.id,
+                    severity: DiagnosticSeverity.Warning,
+                    message: `Layout drift detected for view '${d.id}'`,
+                    range: loc.range,
+                };
+            }));
+        }
+    }
+    async openView(params) {
+        const lspConnection = this.services.shared.lsp.Connection;
+        if (!lspConnection) {
+            logger.warn('No LSP connection');
+            return;
+        }
+        await lspConnection.sendNotification(DidRequestOpenViewNotification.type, params);
+    }
+}

package/dist/ast.d.ts

@@ -78,16 +78,16 @@ export interface ParsedAstElement {
     links?: c4.NonEmptyArray<c4.Link>;
     style: ParsedElementStyle;
     metadata?: {
-        [key: string]: string;
+        [key: string]: string | string[];
     };
 }
 export interface ParsedAstExtend {
     id: c4.Fqn;
     astPath: string;
-    tags: c4.NonEmptyArray<c4.Tag> | null;
-    links: c4.NonEmptyArray<c4.Link> | null;
+    tags?: c4.NonEmptyArray<c4.Tag> | null;
+    links?: c4.NonEmptyArray<c4.Link> | null;
     metadata?: {
-        [key: string]: string;
+        [key: string]: string | string[];
     };
 }
 export interface ParsedAstRelation {
@@ -107,7 +107,7 @@ export interface ParsedAstRelation {
     links?: c4.NonEmptyArray<c4.Link>;
     navigateTo?: c4.ViewId;
     metadata?: {
-        [key: string]: string;
+        [key: string]: string | string[];
     };
 }
 export type ParsedAstDeployment = Simplify<MergeExclusive<ParsedAstDeployment.Node, ParsedAstDeployment.Instance>>;
@@ -122,6 +122,7 @@ export type ParsedAstDeploymentRelation = c4.DeploymentRelationship & {
 };
 export type ParsedAstGlobals = Writable<c4.ModelGlobals>;
 export interface ParsedAstElementView {
+    [c4._type]: 'element';
     id: c4.ViewId;
     viewOf?: c4.Fqn;
     extends?: c4.ViewId;
@@ -134,6 +135,7 @@ export interface ParsedAstElementView {
     manualLayout?: c4.ViewManualLayout;
 }
 export interface ParsedAstDynamicView {
+    [c4._type]: 'dynamic';
     id: c4.ViewId;
     astPath: string;
     title: string | null;
@@ -146,6 +148,7 @@ export interface ParsedAstDynamicView {
     manualLayout?: c4.ViewManualLayout;
 }
 export interface ParsedAstDeploymentView {
+    [c4._type]: 'deployment';
     id: c4.ViewId;
     astPath: string;
     title: string | null;
@@ -153,6 +156,7 @@ export interface ParsedAstDeploymentView {
     tags: c4.NonEmptyArray<c4.Tag> | null;
     links: c4.NonEmptyArray<c4.Link> | null;
     rules: Array<c4.DeploymentViewRule>;
+    manualLayout?: c4.ViewManualLayout;
 }
 export type ParsedAstView = ParsedAstElementView | ParsedAstDynamicView | ParsedAstDeploymentView;
 export declare const ViewOps: {
@@ -161,7 +165,7 @@ export declare const ViewOps: {
 };
 export declare const ElementOps: {
     writeId(node: ast.Element | ast.DeploymentElement, id: c4.Fqn | null): ast.DeploymentElement | ast.Element;
-    readId(node: ast.Element | ast.DeploymentElement): any;
+    readId(node: ast.Element | ast.DeploymentElement): c4.Fqn<string> | undefined;
 };
 export interface AstNodeDescriptionWithFqn extends AstNodeDescription {
     likec4ProjectId: c4.ProjectId;