@likec4/language-server 1.43.0 → 1.45.0

package/dist/views/ConfigurableLayouter.js

@@ -0,0 +1,51 @@
+import { GraphvizWasmAdapter, QueueGraphvizLayoter } from '@likec4/layouts';
+import { GraphvizBinaryAdapter } from '@likec4/layouts/graphviz/binary';
+import { isEmpty } from 'remeda';
+import which from 'which';
+import { logger } from '../logger';
+function graphvizBinPath() {
+    try {
+        return which.sync('dot');
+    }
+    catch (error) {
+        logger.error('Error checking for native Graphviz:', { error });
+        return null;
+    }
+}
+export const ConfigurableLayouter = {
+    likec4: {
+        Layouter(services) {
+            logger.debug('Creating ConfigurableLayouter');
+            const layouter = new QueueGraphvizLayoter();
+            services.shared.workspace.ConfigurationProvider.onConfigurationSectionUpdate((update) => {
+                logger.debug('Configuration update: {update}', { update });
+                if (update.section !== services.LanguageMetaData.languageId) {
+                    logger.debug(`Ignoring configuration update as it is not for ${services.LanguageMetaData.languageId}`);
+                    return;
+                }
+                try {
+                    const { mode, path } = update.configuration.graphviz ?? {
+                        mode: 'wasm',
+                        path: '',
+                    };
+                    if (mode !== 'wasm') {
+                        let binaryPath = isEmpty(path) ? graphvizBinPath() : path;
+                        if (!isEmpty(binaryPath)) {
+                            layouter.changePort(new GraphvizBinaryAdapter(binaryPath));
+                            logger.info `use graphviz binary: ${binaryPath}`;
+                            return;
+                        }
+                        logger.warn(`No Graphviz binaries found on PATH, use graphviz wasm`);
+                        services.shared.lsp.Connection?.window.showWarningMessage('No Graphviz binaries found on PATH, set path to binaries in settings.');
+                    }
+                    layouter.changePort(new GraphvizWasmAdapter());
+                    logger.info('use graphviz wasm');
+                }
+                catch (error) {
+                    logger.error('Failed to update configuration', { error });
+                }
+            });
+            return layouter;
+        },
+    },
+};

package/dist/views/LikeC4ManualLayouts.d.ts

@@ -0,0 +1,42 @@
+import type { LayoutedView, ProjectId, ViewId } from '@likec4/core';
+import { URI, WorkspaceCache } from 'langium';
+import { type Location } from 'vscode-languageserver-types';
+import type { LikeC4Services } from '../module';
+import type { Project } from '../workspace/ProjectsManager';
+/**
+ * @todo sync with vscode extension watchers
+ *       (search for ".likec4.snap" references)
+ */
+export declare const isManualLayoutFile: (path: string) => boolean;
+export interface LikeC4ManualLayouts {
+    read(project: Project): Promise<Record<ViewId, LayoutedView> | null>;
+    write(project: Project, layouted: LayoutedView): Promise<Location>;
+    remove(project: Project, view: ViewId): Promise<Location | null>;
+    clearCaches(): void;
+}
+export interface LikeC4ManualLayoutsModuleContext {
+    manualLayouts: (services: LikeC4Services) => LikeC4ManualLayouts;
+}
+export declare const WithLikeC4ManualLayouts: LikeC4ManualLayoutsModuleContext;
+export declare class DefaultLikeC4ManualLayouts implements LikeC4ManualLayouts {
+    private services;
+    protected cache: WorkspaceCache<ProjectId, Promise<Record<ViewId, LayoutedView> | null>>;
+    constructor(services: LikeC4Services);
+    read(project: Project): Promise<Record<ViewId, LayoutedView> | null>;
+    write(project: Project, layouted: LayoutedView): Promise<Location>;
+    remove(project: Project, view: ViewId): Promise<Location | null>;
+    clearCaches(): void;
+    /**
+     * When we save snapshot - it may contain fullpath to icons on the machine it was created,
+     * that is wrong when opened on another.
+     *
+     * Prepares a snapshot for writing by converting absolute icon paths to relative paths.
+     * Absolute paths starting with 'file://' are converted to relative paths prefixed with 'file://./'
+     */
+    protected normalizeIconPathsForWrite(layouted: LayoutedView, projectUri: URI): LayoutedView;
+    /**
+     * Postprocesses a snapshot after reading by converting relative icon paths back to absolute paths.
+     * Relative paths prefixed with 'file://./' are converted to absolute paths based on project folder.
+     */
+    protected resolveIconPathsAfterRead(layouted: LayoutedView, projectUri: URI): LayoutedView;
+}

package/dist/views/LikeC4ManualLayouts.js

@@ -0,0 +1,209 @@
+import JSON5 from 'json5';
+import { DocumentState, URI, UriUtils, WorkspaceCache } from 'langium';
+import { indexBy, prop } from 'remeda';
+import { Position, Range, } from 'vscode-languageserver-types';
+import { logger as rootLogger } from '../logger';
+const layoutsLogger = rootLogger.getChild('manual-layouts');
+/**
+ * @todo sync with vscode extension watchers
+ *       (search for ".likec4.snap" references)
+ */
+export const isManualLayoutFile = (path) => path.endsWith('.likec4.snap');
+function fileName(view) {
+    return `${view}.likec4.snap`;
+}
+function getManualLayoutsOutDir(project) {
+    return UriUtils.resolvePath(project.folderUri, project.config.manualLayouts?.outDir ?? '.likec4');
+}
+export const WithLikeC4ManualLayouts = {
+    manualLayouts: (services) => new DefaultLikeC4ManualLayouts(services),
+};
+const RELATIVE_PATH_PREFIX = 'file://./';
+export class DefaultLikeC4ManualLayouts {
+    services;
+    cache;
+    constructor(services) {
+        this.services = services;
+        this.cache = new WorkspaceCache(services.shared, DocumentState.Validated);
+    }
+    async read(project) {
+        return await this.cache.get(project.id, async () => {
+            const logger = layoutsLogger.getChild(project.id);
+            const fs = this.services.shared.workspace.FileSystemProvider;
+            const outDir = getManualLayoutsOutDir(project);
+            const manualLayouts = [];
+            try {
+                const files = await fs.scanDirectory(outDir, isManualLayoutFile);
+                if (files.length === 0) {
+                    return null;
+                }
+                for (const file of files) {
+                    if (file.isFile) {
+                        try {
+                            const content = await fs.readFile(file.uri);
+                            const parsed = JSON5.parse(content);
+                            const resolved = this.resolveIconPathsAfterRead(parsed, project.folderUri);
+                            manualLayouts.push({
+                                ...resolved,
+                                _layout: 'manual',
+                            });
+                        }
+                        catch (err) {
+                            logger.warn(`Failed to read view snapshot ${file.uri.fsPath}`, { err });
+                        }
+                    }
+                }
+                if (manualLayouts.length) {
+                    logger.debug `read manual layouts for ${project.id}, found ${manualLayouts.length}`;
+                }
+            }
+            catch (err) {
+                logger.warn(`Failed to read manual layouts for ${project.folderUri.fsPath}`, { err });
+            }
+            if (manualLayouts.length === 0) {
+                return null;
+            }
+            return indexBy(manualLayouts, prop('id'));
+        });
+    }
+    async write(project, layouted) {
+        const logger = layoutsLogger.getChild(project.id);
+        const outDir = getManualLayoutsOutDir(project);
+        const file = UriUtils.joinPath(outDir, fileName(layouted.id));
+        // Ensure the manualLayout field is omitted (may exist in migration)
+        if ('manualLayout' in layouted) {
+            const { manualLayout: _, ...rest } = layouted;
+            layouted = rest;
+        }
+        // Normalize icon paths before writing
+        layouted = this.normalizeIconPathsForWrite(layouted, project.folderUri);
+        const content = JSON5.stringify(layouted, {
+            space: 2,
+            quote: '\'',
+        });
+        const location = {
+            uri: file.toString(),
+            range: Range.create(Position.create(0, 0), Position.create(content.split('\n').length - 1, 1)),
+        };
+        logger.debug `write snapshot of ${layouted.id} in project ${project.id} to ${file.fsPath}`;
+        const fs = this.services.shared.workspace.FileSystemProvider;
+        try {
+            await fs.writeFile(file, content + '\n');
+        }
+        catch (err) {
+            logger.warn(`Failed to write snapshot ${layouted.id} to ${file.fsPath}`, { err });
+        }
+        const projectCachesPromise = this.cache.get(project.id);
+        if (projectCachesPromise) {
+            const projectCaches = await projectCachesPromise;
+            if (projectCaches) {
+                logger.debug `update snapshot cache of ${layouted.id} in project ${project.id}`;
+                projectCaches[layouted.id] = layouted;
+            }
+            else {
+                logger.debug `clean cache of project ${project.id}`;
+                // Cache was null, remove it entirely
+                this.cache.delete(project.id);
+            }
+        }
+        this.services.likec4.ModelBuilder.clearCache();
+        return location;
+    }
+    async remove(project, view) {
+        const logger = layoutsLogger.getChild(project.id);
+        const outDir = getManualLayoutsOutDir(project);
+        const file = UriUtils.joinPath(outDir, fileName(view));
+        logger.debug `delete snapshot of ${view} in project ${project.id}. File: ${file.fsPath}`;
+        const location = {
+            uri: file.toString(),
+            range: Range.create(0, 0, 0, 0),
+        };
+        try {
+            const fs = this.services.shared.workspace.FileSystemProvider;
+            if (!(await fs.deleteFile(file))) {
+                logger.warn `Snapshot ${view} did not exist at ${file.fsPath}`;
+                return null;
+            }
+        }
+        catch (err) {
+            logger.warn(`Failed to delete snapshot ${view} from ${file.fsPath}`, { err });
+        }
+        const projectCachesPromise = this.cache.get(project.id);
+        if (projectCachesPromise) {
+            const projectCaches = await projectCachesPromise;
+            if (projectCaches) {
+                logger.debug `clean cached view ${view} in project ${project.id}`;
+                delete projectCaches[view];
+            }
+            else {
+                logger.debug `reset empty cache of project ${project.id}`;
+                // Cache was null, remove it entirely
+                this.cache.delete(project.id);
+            }
+        }
+        this.services.likec4.ModelBuilder.clearCache();
+        return location;
+    }
+    clearCaches() {
+        this.cache.clear();
+    }
+    /**
+     * When we save snapshot - it may contain fullpath to icons on the machine it was created,
+     * that is wrong when opened on another.
+     *
+     * Prepares a snapshot for writing by converting absolute icon paths to relative paths.
+     * Absolute paths starting with 'file://' are converted to relative paths prefixed with 'file://./'
+     */
+    normalizeIconPathsForWrite(layouted, projectUri) {
+        const nodes = layouted.nodes.map((node) => {
+            if (!node.icon || typeof node.icon !== 'string') {
+                return node;
+            }
+            // Check if icon is an absolute file path
+            if (node.icon.startsWith('file://')) {
+                const iconUri = URI.parse(node.icon);
+                // Get relative path from project folder to icon
+                const relativePath = UriUtils.relative(projectUri, iconUri);
+                // If icon is outside of project folder - leave it as is,
+                // to avoid security issues on reading snapshots on another machine
+                if (relativePath.startsWith('..')) {
+                    return node;
+                }
+                return {
+                    ...node,
+                    icon: `${RELATIVE_PATH_PREFIX}${relativePath}`,
+                };
+            }
+            return node;
+        });
+        return {
+            ...layouted,
+            nodes: nodes,
+        };
+    }
+    /**
+     * Postprocesses a snapshot after reading by converting relative icon paths back to absolute paths.
+     * Relative paths prefixed with 'file://./' are converted to absolute paths based on project folder.
+     */
+    resolveIconPathsAfterRead(layouted, projectUri) {
+        const nodes = layouted.nodes.map((node) => {
+            if (!node.icon || typeof node.icon !== 'string') {
+                return node;
+            }
+            // Check if icon is a relative file path
+            if (node.icon.startsWith(RELATIVE_PATH_PREFIX)) {
+                const relativePath = node.icon.substring(RELATIVE_PATH_PREFIX.length);
+                const absoluteUri = UriUtils.joinPath(projectUri, relativePath);
+                return {
+                    ...node,
+                    icon: absoluteUri.toString(),
+                };
+            }
+            return node;
+        });
+        return {
+            ...layouted,
+            nodes: nodes,
+        };
+    }
+}

package/dist/views/{likec4-views.d.ts → LikeC4Views.d.ts}

@@ -1,16 +1,28 @@
-import type { ComputedView, DiagramView, ProjectId, ViewId } from '@likec4/core';
+import type { ComputedView, DiagramView, LayoutedView, LayoutType, ProjectId, ViewId } from '@likec4/core';
 import { type QueueGraphvizLayoter, GraphvizLayouter } from '@likec4/layouts';
 import type { CancellationToken } from 'vscode-languageserver';
 import type { LikeC4Services } from '../module';
 export type GraphvizOut = {
     readonly dot: string;
-    readonly diagram: DiagramView;
+    readonly diagram: LayoutedView;
 };
 type GraphvizSvgOut = {
     readonly id: ViewId;
     readonly dot: string;
     readonly svg: string;
 };
+type LayoutViewParams = {
+    viewId: ViewId;
+    /**
+     * Type of layout to apply
+     * - 'manual' - applies manual layout if any
+     * - 'auto' - returns latest version with drifts from manual layout if any
+     * - undefined - returns latest layout as is
+     */
+    layoutType?: LayoutType | undefined;
+    projectId?: ProjectId | undefined;
+    cancelToken?: CancellationToken | undefined;
+};
 export interface LikeC4Views {
     readonly layouter: GraphvizLayouter;
     /**
@@ -18,17 +30,21 @@ export interface LikeC4Views {
      */
     computedViews(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<ComputedView[]>;
     /**
-     * Returns all layouted views (i.e. views with layout computed)
-     * Result includes dot and diagram
+     * Layouts all views (ignoring any manual snapshots)
      */
     layoutAllViews(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<GraphvizOut[]>;
     /**
-     * Returns layouted view (i.e. view with layout computed)
-     * Result includes dot and diagram
+     * 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 not specified - returns latest layout as is
+     *
+     * If view not found in model, but there is a snapshot - it will be returned (with empty DOT)
      */
-    layoutView(viewId: ViewId, projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<GraphvizOut | null>;
+    layoutView(params: LayoutViewParams): Promise<GraphvizOut | null>;
     /**
-     * Returns diagrams (i.e. views with layout computed)
+     * Returns diagrams.
+     * If diagram has manual layout, it will be used.
      */
     diagrams(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<Array<DiagramView>>;
     /**
@@ -53,15 +69,21 @@ export declare class DefaultLikeC4Views implements LikeC4Views {
     constructor(services: LikeC4Services);
     get layouter(): QueueGraphvizLayoter;
     computedViews(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<ComputedView[]>;
+    private _layoutAllViews;
     layoutAllViews(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<GraphvizOut[]>;
-    layoutView(viewId: ViewId, projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<GraphvizOut | null>;
-    diagrams(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<Array<DiagramView>>;
+    layoutView({ viewId, layoutType, projectId, cancelToken, }: LayoutViewParams): Promise<GraphvizOut | null>;
+    diagrams(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<Array<LayoutedView>>;
     viewsAsGraphvizOut(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<Array<GraphvizSvgOut>>;
     /**
      * Open a view in the preview panel.
      */
     openView(viewId: ViewId, projectId: ProjectId): Promise<void>;
     private reportViewError;
+    /**
+     * Applies manual layout or calculates drifts from snapshot
+     * if layoutType is specified
+     */
+    private withLayoutType;
     private viewSucceed;
 }
 export {};

package/dist/views/LikeC4Views.js

@@ -0,0 +1,216 @@
+import { _layout, applyManualLayout, calcDriftsFromSnapshot, invariant } from '@likec4/core';
+import { GraphvizLayouter } from '@likec4/layouts';
+import { loggable } from '@likec4/log';
+import { interruptAndCheck } from 'langium';
+import { isTruthy, unique, values } from 'remeda';
+import { logger as rootLogger, logWarnError } from '../logger';
+import { performanceMark } from '../utils';
+const viewsLogger = rootLogger.getChild('views');
+export class DefaultLikeC4Views {
+    services;
+    cache = new WeakMap();
+    /**
+     * Set of viewIds with reported errors
+     * value is `${projectId}-${viewId}`
+     */
+    viewsWithReportedErrors = new Set();
+    ModelBuilder;
+    constructor(services) {
+        this.services = services;
+        this.ModelBuilder = services.likec4.ModelBuilder;
+    }
+    get layouter() {
+        return this.services.likec4.Layouter;
+    }
+    async computedViews(projectId, cancelToken) {
+        const likeC4Model = await this.ModelBuilder.computeModel(projectId, cancelToken);
+        return values(likeC4Model.$data.views);
+    }
+    async _layoutAllViews(likeC4Model, cancelToken) {
+        const views = values(likeC4Model.$data.views);
+        if (views.length === 0) {
+            return [];
+        }
+        const m0 = performanceMark();
+        const projectId = likeC4Model.project.id;
+        const logger = viewsLogger.getChild(projectId);
+        logger.debug `layoutAll: ${views.length} views`;
+        const tasks = [];
+        const styles = likeC4Model.$styles;
+        const results = [];
+        //
+        for (const view of views) {
+            let cached = this.cache.get(view);
+            if (cached) {
+                logger.debug `layout ${view.id} from cache`;
+                results.push(cached);
+                continue;
+            }
+            tasks.push({
+                view,
+                styles,
+            });
+        }
+        if (tasks.length > 0) {
+            await this.layouter.batchLayout({
+                batch: tasks,
+                cancelToken,
+                onSuccess: (task, result) => {
+                    results.push(this.viewSucceed(task.view, likeC4Model, result));
+                },
+                onError: (task, error) => {
+                    logger.warn(`Fail layout view ${task.view.id}`, { error });
+                },
+            });
+        }
+        if (cancelToken && cancelToken.isCancellationRequested) {
+            await interruptAndCheck(cancelToken);
+        }
+        if (results.length !== views.length) {
+            logger.warn `layouted ${results.length} of ${views.length} views in ${m0.pretty}`;
+        }
+        else if (results.length > 0) {
+            logger.debug `layouted all ${results.length} views in ${m0.pretty}`;
+        }
+        return results;
+    }
+    async layoutAllViews(projectId, cancelToken) {
+        const likeC4Model = await this.ModelBuilder.computeModel(projectId, cancelToken);
+        return await this._layoutAllViews(likeC4Model, cancelToken);
+    }
+    async layoutView({ viewId, layoutType, projectId, cancelToken, }) {
+        const model = await this.ModelBuilder.computeModel(projectId, cancelToken);
+        const view = model.findView(viewId)?.$view;
+        projectId = model.project.id;
+        const logger = viewsLogger.getChild(projectId);
+        if (!view) {
+            logger.warn `layoutView ${viewId} not found`;
+            const snapshot = model.findManualLayout(viewId);
+            if (snapshot) {
+                logger.debug `found manual layout for ${viewId}`;
+                let diagram = { ...snapshot };
+                diagram.drifts = [
+                    'not-exists',
+                ];
+                diagram._layout = 'manual';
+                return {
+                    diagram: diagram,
+                    dot: '# manual layout',
+                };
+            }
+            return null;
+        }
+        try {
+            const m0 = performanceMark();
+            const out = this.cache.get(view) ?? await this.layouter.layout({
+                view,
+                styles: model.$styles,
+            });
+            if (this.cache.has(view)) {
+                logger.debug `layout ${viewId} from cache`;
+            }
+            else {
+                this.viewSucceed(view, model, out);
+                logger.debug(`layout {viewId} in ${m0.pretty}`, { viewId });
+            }
+            if (isTruthy(layoutType)) {
+                return {
+                    dot: out.dot,
+                    diagram: this.withLayoutType(out.diagram, model, layoutType),
+                };
+            }
+            return out;
+        }
+        catch (e) {
+            const errMessage = loggable(e);
+            logger.warn(errMessage);
+            this.reportViewError(view, projectId, errMessage);
+            return Promise.reject(e);
+        }
+    }
+    async diagrams(projectId, cancelToken) {
+        const likeC4Model = await this.ModelBuilder.computeModel(projectId, cancelToken);
+        const layouted = await this._layoutAllViews(likeC4Model, cancelToken);
+        return layouted.map(({ diagram }) => {
+            // Apply manual layout if any
+            return this.withLayoutType(diagram, likeC4Model, 'manual');
+        });
+    }
+    async viewsAsGraphvizOut(projectId, cancelToken) {
+        const KEY = 'All-LayoutedViews-DotWithSvg';
+        const cache = this.services.shared.workspace.Cache;
+        if (cache.has(KEY)) {
+            return await Promise.resolve(cache.get(KEY));
+        }
+        const likeC4Model = await this.ModelBuilder.computeModel(projectId, cancelToken);
+        const views = values(likeC4Model.$data.views);
+        if (views.length === 0) {
+            return [];
+        }
+        const tasks = views.map(async (view) => {
+            const { dot, svg } = await this.layouter.svg({
+                view,
+                styles: likeC4Model.$styles,
+            });
+            return {
+                id: view.id,
+                dot,
+                svg,
+            };
+        });
+        const succeed = [];
+        const settledResult = await Promise.allSettled(tasks);
+        for (const result of settledResult) {
+            if (result.status === 'fulfilled') {
+                succeed.push(result.value);
+            }
+            else {
+                logWarnError(result.reason);
+            }
+        }
+        cache.set(KEY, succeed);
+        return succeed;
+    }
+    /**
+     * Open a view in the preview panel.
+     */
+    async openView(viewId, projectId) {
+        await this.services.Rpc.openView({ viewId, projectId });
+    }
+    reportViewError(view, projectId, error) {
+        const key = `${projectId}-${view.id}`;
+        this.cache.delete(view);
+        if (!this.viewsWithReportedErrors.has(key)) {
+            this.services.shared.lsp.Connection?.window.showErrorMessage(`LikeC4: ${error}`);
+            this.viewsWithReportedErrors.add(key);
+        }
+    }
+    /**
+     * Applies manual layout or calculates drifts from snapshot
+     * if layoutType is specified
+     */
+    withLayoutType(layouted, likec4model, layoutType) {
+        if (!layoutType) {
+            return layouted;
+        }
+        const snapshot = likec4model.findManualLayout(layouted.id);
+        if (!snapshot) {
+            return layouted;
+        }
+        if (layoutType === 'manual') {
+            if (layouted[_layout] === 'manual') {
+                viewsLogger.error(`View ${layouted.id} already has manual layout, this should not happen`);
+                return layouted;
+            }
+            return applyManualLayout(layouted, snapshot);
+        }
+        return calcDriftsFromSnapshot(layouted, snapshot);
+    }
+    viewSucceed(view, likec4model, result) {
+        const projectId = likec4model.project.id;
+        const key = `${projectId}-${view.id}`;
+        this.viewsWithReportedErrors.delete(key);
+        this.cache.set(view, result);
+        return result;
+    }
+}

package/dist/views/index.d.ts

@@ -1 +1,4 @@
-export { DefaultLikeC4Views, type LikeC4Views } from './likec4-views';
+import type { LikeC4ManualLayouts, LikeC4ManualLayoutsModuleContext } from './LikeC4ManualLayouts';
+export { DefaultLikeC4Views, type LikeC4Views } from './LikeC4Views';
+export type { LikeC4ManualLayouts, LikeC4ManualLayoutsModuleContext };
+export declare const NoopLikeC4ManualLayouts: LikeC4ManualLayoutsModuleContext;

package/dist/views/index.js

@@ -0,0 +1,11 @@
+export { DefaultLikeC4Views } from './LikeC4Views';
+export const NoopLikeC4ManualLayouts = {
+    manualLayouts: () => {
+        return {
+            read: () => Promise.resolve(null),
+            write: () => Promise.reject(new Error('NoopLikeC4ManualLayouts: write operation is not supported')),
+            remove: () => Promise.resolve(null),
+            clearCaches: () => { },
+        };
+    },
+};

package/dist/workspace/AstNodeDescriptionProvider.js

@@ -0,0 +1,18 @@
+import { AstUtils, DefaultAstNodeDescriptionProvider, } from 'langium';
+import { isLikeC4Builtin } from '../likec4lib';
+export class AstNodeDescriptionProvider extends DefaultAstNodeDescriptionProvider {
+    services;
+    constructor(services) {
+        super(services);
+        this.services = services;
+    }
+    createDescription(node, name, document) {
+        document ??= AstUtils.getDocument(node);
+        const description = super.createDescription(node, name, document);
+        if (!isLikeC4Builtin(document.uri)) {
+            document.likec4ProjectId ??= this.services.shared.workspace.ProjectsManager.belongsTo(document);
+            description.likec4ProjectId = document.likec4ProjectId;
+        }
+        return description;
+    }
+}

package/dist/workspace/IndexManager.js

@@ -0,0 +1,21 @@
+import { DefaultIndexManager, stream } from 'langium';
+export class IndexManager extends DefaultIndexManager {
+    services;
+    constructor(services) {
+        super(services);
+        this.services = services;
+    }
+    async updateContent(document, cancelToken) {
+        const projects = this.services.workspace.ProjectsManager;
+        // Ensure the document is assigned to a project
+        document.likec4ProjectId = projects.belongsTo(document);
+        await super.updateContent(document, cancelToken);
+    }
+    projectElements(projectId, nodeType, uris) {
+        const projects = this.services.workspace.ProjectsManager;
+        let documentUris = stream(this.symbolIndex.keys());
+        return documentUris
+            .filter(uri => projects.belongsTo(uri) === projectId && (!uris || uris.has(uri)))
+            .flatMap(uri => this.getFileDescriptions(uri, nodeType));
+    }
+}