@likec4/language-server 1.44.0 → 1.46.0

package/dist/views/LikeC4ManualLayouts.d.ts

@@ -1,4 +1,5 @@
-import type { LayoutedView, ViewId } from '@likec4/core';
+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';
@@ -19,10 +20,23 @@ export interface LikeC4ManualLayoutsModuleContext {
 export declare const WithLikeC4ManualLayouts: LikeC4ManualLayoutsModuleContext;
 export declare class DefaultLikeC4ManualLayouts implements LikeC4ManualLayouts {
     private services;
-    private manualLayouts;
+    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

@@ -1,10 +1,9 @@
-import { getOrCreate } from '@likec4/core/utils';
 import JSON5 from 'json5';
-import { UriUtils } from 'langium';
+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 logger = rootLogger.getChild('manual-layouts');
+const layoutsLogger = rootLogger.getChild('manual-layouts');
 /**
  * @todo sync with vscode extension watchers
  *       (search for ".likec4.snap" references)
@@ -19,14 +18,17 @@ function getManualLayoutsOutDir(project) {
 export const WithLikeC4ManualLayouts = {
     manualLayouts: (services) => new DefaultLikeC4ManualLayouts(services),
 };
+const RELATIVE_PATH_PREFIX = 'file://./';
 export class DefaultLikeC4ManualLayouts {
     services;
-    manualLayouts = new WeakMap();
+    cache;
     constructor(services) {
         this.services = services;
+        this.cache = new WorkspaceCache(services.shared, DocumentState.Validated);
     }
     async read(project) {
-        return await getOrCreate(this.manualLayouts, project.folderUri, async (_) => {
+        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 = [];
@@ -39,8 +41,10 @@ export class DefaultLikeC4ManualLayouts {
                     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({
-                                ...JSON5.parse(content),
+                                ...resolved,
                                 _layout: 'manual',
                             });
                         }
@@ -63,6 +67,7 @@ export class DefaultLikeC4ManualLayouts {
         });
     }
     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)
@@ -70,7 +75,9 @@ export class DefaultLikeC4ManualLayouts {
             const { manualLayout: _, ...rest } = layouted;
             layouted = rest;
         }
-        const content = JSON5.stringify(layouted, {
+        const content = JSON5.stringify(
+        // Normalize icon paths before writing
+        this.normalizeIconPathsForWrite(layouted, project.folderUri), {
             space: 2,
             quote: '\'',
         });
@@ -81,23 +88,29 @@ export class DefaultLikeC4ManualLayouts {
         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);
+            await fs.writeFile(file, content + '\n');
         }
         catch (err) {
             logger.warn(`Failed to write snapshot ${layouted.id} to ${file.fsPath}`, { err });
         }
-        const projectCaches = await this.read(project);
-        if (projectCaches) {
-            logger.debug `update snapshot cache of ${layouted.id} in project ${project.id}`;
-            projectCaches[layouted.id] = layouted;
-        }
-        else {
-            this.manualLayouts.delete(project.folderUri);
+        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}`;
@@ -115,18 +128,82 @@ export class DefaultLikeC4ManualLayouts {
         catch (err) {
             logger.warn(`Failed to delete snapshot ${view} from ${file.fsPath}`, { err });
         }
-        const projectCaches = await this.read(project);
-        if (projectCaches) {
-            logger.debug `clean cache of ${view} in project ${project.id}`;
-            delete projectCaches[view];
-        }
-        else {
-            this.manualLayouts.delete(project.folderUri);
+        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.manualLayouts = new WeakMap();
+        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/LikeC4Views.d.ts

@@ -1,4 +1,4 @@
-import type { ComputedView, DiagramView, LayoutedView, 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';
@@ -11,6 +11,18 @@ type GraphvizSvgOut = {
     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,14 +30,18 @@ export interface LikeC4Views {
      */
     computedViews(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<ComputedView[]>;
     /**
-     * Returns all layouted views (without manual layout)
+     * Layouts all views (ignoring any manual snapshots)
      */
     layoutAllViews(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<GraphvizOut[]>;
     /**
-     * Layouts a view (from sources, i.e. without manual layout)
+     * 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.
      * If diagram has manual layout, it will be used.
@@ -55,7 +71,7 @@ export declare class DefaultLikeC4Views implements LikeC4Views {
     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>;
+    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>>;
     /**
@@ -63,6 +79,11 @@ export declare class DefaultLikeC4Views implements LikeC4Views {
      */
     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

@@ -1,8 +1,8 @@
-import { applyLayoutDriftReasons, applyManualLayout } from '@likec4/core/model';
+import { _layout, applyManualLayout, calcDriftsFromSnapshot } from '@likec4/core';
 import { GraphvizLayouter } from '@likec4/layouts';
 import { loggable } from '@likec4/log';
 import { interruptAndCheck } from 'langium';
-import { unique, values } from 'remeda';
+import { isTruthy, values } from 'remeda';
 import { logger as rootLogger, logWarnError } from '../logger';
 import { performanceMark } from '../utils';
 const viewsLogger = rootLogger.getChild('views');
@@ -78,47 +78,48 @@ export class DefaultLikeC4Views {
         const likeC4Model = await this.ModelBuilder.computeModel(projectId, cancelToken);
         return await this._layoutAllViews(likeC4Model, cancelToken);
     }
-    async layoutView(viewId, projectId, 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 project = this.services.shared.workspace.ProjectsManager.getProject(projectId);
-            const manualLayouts = await this.services.likec4.ManualLayouts.read(project);
-            const snapshot = manualLayouts?.[viewId];
+            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: {
-                        ...snapshot,
-                        _layout: 'manual',
-                        drifts: snapshot.drifts
-                            ? unique([
-                                ...snapshot.drifts,
-                                'not-exists',
-                            ])
-                            : ['not-exists'],
-                    },
+                    diagram: diagram,
                     dot: '# manual layout',
                 };
             }
             return null;
         }
-        let cached = this.cache.get(view);
-        if (cached) {
-            logger.debug `layout ${viewId} from cache`;
-            return await Promise.resolve().then(() => cached);
-        }
         try {
             const m0 = performanceMark();
-            const result = await this.layouter.layout({
+            const out = this.cache.get(view) ?? await this.layouter.layout({
                 view,
                 styles: model.$styles,
             });
-            logger.debug(`layout {viewId} ready in ${m0.pretty}`, { viewId });
-            return this.viewSucceed(view, model, result);
+            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);
@@ -131,11 +132,8 @@ export class DefaultLikeC4Views {
         const likeC4Model = await this.ModelBuilder.computeModel(projectId, cancelToken);
         const layouted = await this._layoutAllViews(likeC4Model, cancelToken);
         return layouted.map(({ diagram }) => {
-            const manualLayout = likeC4Model.$data.manualLayouts?.[diagram.id];
-            if (manualLayout) {
-                return applyManualLayout(diagram, manualLayout);
-            }
-            return diagram;
+            // Apply manual layout if any
+            return this.withLayoutType(diagram, likeC4Model, 'manual');
         });
     }
     async viewsAsGraphvizOut(projectId, cancelToken) {
@@ -181,18 +179,36 @@ export class DefaultLikeC4Views {
     }
     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}`;
-        const snapshot = likec4model.$data.manualLayouts?.[view.id];
-        if (snapshot) {
-            result.diagram = applyLayoutDriftReasons(result.diagram, snapshot);
-        }
         this.viewsWithReportedErrors.delete(key);
         this.cache.set(view, result);
         return result;

package/dist/workspace/AstNodeDescriptionProvider.js

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

package/dist/workspace/IndexManager.js

@@ -8,7 +8,7 @@ export class IndexManager extends DefaultIndexManager {
     async updateContent(document, cancelToken) {
         const projects = this.services.workspace.ProjectsManager;
         // Ensure the document is assigned to a project
-        document.likec4ProjectId = projects.belongsTo(document.uri);
+        document.likec4ProjectId = projects.belongsTo(document);
         await super.updateContent(document, cancelToken);
     }
     projectElements(projectId, nodeType, uris) {

package/dist/workspace/LangiumDocuments.d.ts

@@ -1,5 +1,5 @@
 import type { NonEmptyArray, ProjectId } from '@likec4/core';
-import type { LangiumDocument, Stream } from 'langium';
+import type { LangiumDocument, Stream, URI } from 'langium';
 import { DefaultLangiumDocuments } from 'langium';
 import { type LikeC4LangiumDocument } from '../ast';
 import type { LikeC4SharedServices } from '../module';
@@ -8,11 +8,12 @@ export declare class LangiumDocuments extends DefaultLangiumDocuments {
     protected compare: (a: string | undefined, b: string | undefined) => number;
     constructor(services: LikeC4SharedServices);
     addDocument(document: LangiumDocument): void;
+    getDocument(uri: URI): LikeC4LangiumDocument | undefined;
+    get all(): Stream<LikeC4LangiumDocument>;
     /**
      * Returns all user documents, excluding built-in documents.
      */
     get allExcludingBuiltin(): Stream<LikeC4LangiumDocument>;
     projectDocuments(projectId: ProjectId): Stream<LikeC4LangiumDocument>;
     groupedByProject(): Record<ProjectId, NonEmptyArray<LikeC4LangiumDocument>>;
-    resetProjectIds(): void;
 }

package/dist/workspace/LangiumDocuments.js

@@ -1,13 +1,17 @@
 import { compareNaturalHierarchically } from '@likec4/core/utils';
-import { DefaultLangiumDocuments } from 'langium';
+import { DefaultLangiumDocuments, stream } from 'langium';
 import { groupBy, prop } from 'remeda';
 import { isLikeC4LangiumDocument } from '../ast';
+import { LikeC4LanguageMetaData } from '../generated/module';
 import { isLikeC4Builtin } from '../likec4lib';
 /**
  * Compare function for document paths to ensure consistent order
  */
 const compare = compareNaturalHierarchically('/', true);
 const ensureOrder = (a, b) => compare(a.uri.path, b.uri.path);
+const exclude = (doc) => {
+    return doc.textDocument.languageId !== LikeC4LanguageMetaData.languageId || isLikeC4Builtin(doc.uri);
+};
 export class LangiumDocuments extends DefaultLangiumDocuments {
     services;
     compare = compareNaturalHierarchically('/', true);
@@ -27,17 +31,36 @@ export class LangiumDocuments extends DefaultLangiumDocuments {
             this.documentMap.set(doc.uri.toString(), doc);
         }
     }
+    getDocument(uri) {
+        const doc = super.getDocument(uri);
+        if (doc && !exclude(doc)) {
+            doc.likec4ProjectId ??= this.services.workspace.ProjectsManager.belongsTo(doc);
+        }
+        if (doc && !isLikeC4LangiumDocument(doc)) {
+            throw new Error(`Document ${doc.uri.path} is not a LikeC4 document`);
+        }
+        return doc;
+    }
+    get all() {
+        return stream(this.documentMap.values())
+            .filter((doc) => {
+            if (doc.textDocument.languageId === LikeC4LanguageMetaData.languageId) {
+                if (!isLikeC4Builtin(doc.uri)) {
+                    doc.likec4ProjectId ??= this.services.workspace.ProjectsManager.belongsTo(doc);
+                }
+                return true;
+            }
+            return false;
+        });
+    }
     /**
      * Returns all user documents, excluding built-in documents.
      */
     get allExcludingBuiltin() {
         const projects = this.services.workspace.ProjectsManager;
         return super.all.filter((doc) => {
-            if (!isLikeC4LangiumDocument(doc) || isLikeC4Builtin(doc.uri)) {
-                return false;
-            }
-            doc.likec4ProjectId = projects.belongsTo(doc.uri);
-            return !projects.isExcluded(doc);
+            // Exclude built-in and non-LikeC4 documents, and also documents excluded by ProjectsManager
+            return !exclude(doc) && !projects.isExcluded(doc);
         });
     }
     projectDocuments(projectId) {
@@ -46,13 +69,4 @@ export class LangiumDocuments extends DefaultLangiumDocuments {
     groupedByProject() {
         return groupBy(this.allExcludingBuiltin.toArray(), prop('likec4ProjectId'));
     }
-    resetProjectIds() {
-        const projects = this.services.workspace.ProjectsManager;
-        this.all.forEach(doc => {
-            if (!isLikeC4LangiumDocument(doc) || isLikeC4Builtin(doc.uri)) {
-                return;
-            }
-            doc.likec4ProjectId = projects.belongsTo(doc);
-        });
-    }
 }

package/dist/workspace/ProjectsManager.d.ts

@@ -1,6 +1,6 @@
-import { type LikeC4ProjectConfig, type LikeC4ProjectConfigInput } from '@likec4/config';
+import { type IncludeConfig, type LikeC4ProjectConfig, type LikeC4ProjectConfigInput } from '@likec4/config';
 import type { NonEmptyReadonlyArray } from '@likec4/core';
-import type { scalar } from '@likec4/core/types';
+import type { ProjectId, scalar } from '@likec4/core/types';
 import { type Cancellation, type LangiumDocument, URI, WorkspaceCache } from 'langium';
 import type { Tagged } from 'type-fest';
 import type { LikeC4SharedServices } from '../module';
@@ -16,11 +16,27 @@ interface ProjectData {
     folder: ProjectFolder;
     folderUri: URI;
     exclude?: (path: string) => boolean;
+    /**
+     * Resolved include paths with both URI and folder string representations.
+     * These are additional directories that are part of this project.
+     */
+    includePaths?: Array<{
+        uri: URI;
+        folder: ProjectFolder;
+    }>;
+    /**
+     * Normalized include configuration (paths, maxDepth, fileThreshold).
+     */
+    includeConfig: IncludeConfig;
 }
 export interface Project {
     id: scalar.ProjectId;
     folderUri: URI;
     config: LikeC4ProjectConfig;
+    /**
+     * Resolved include paths as URIs (if configured).
+     */
+    includePaths?: URI[];
 }
 export declare class ProjectsManager {
     #private;
@@ -29,7 +45,7 @@ export declare class ProjectsManager {
      * The global project ID used for all documents
      * that are not part of a specific project.
      */
-    static readonly DefaultProjectId: scalar.ProjectId<string>;
+    static readonly DefaultProjectId: ProjectId<string>;
     constructor(services: LikeC4SharedServices);
     /**
      * Returns:
@@ -40,6 +56,7 @@ export declare class ProjectsManager {
      */
     get defaultProjectId(): scalar.ProjectId | undefined;
     set defaultProjectId(id: string | scalar.ProjectId | undefined);
+    get default(): ProjectData;
     get all(): NonEmptyReadonlyArray<scalar.ProjectId>;
     getProject(arg: scalar.ProjectId | LangiumDocument): Project;
     /**
@@ -64,31 +81,43 @@ export declare class ProjectsManager {
      */
     isConfigFile(entry: URI): boolean;
     /**
-     * Checks if the provided file system entry is a valid project config file.
-     *
-     * @param entry The file system entry to check
+     * Registers likec4 project by config file.
      */
-    registerConfigFile(configFile: URI): Promise<ProjectData | undefined>;
+    registerConfigFile(configFile: URI): 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: URI | {
-        config: LikeC4ProjectConfigInput;
+    registerProject(opts: {
+        config: LikeC4ProjectConfig | LikeC4ProjectConfigInput;
         folderUri: URI | string;
     }): 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.
+     * Determines which project the given document belongs to.
+     * If the document does not belong to any project, returns the default project ID.
      */
-    private _registerProject;
     belongsTo(document: LangiumDocument | URI | string): scalar.ProjectId;
     reloadProjects(): Promise<void>;
     protected _reloadProjects(): Promise<void>;
     protected uniqueProjectId(name: string): scalar.ProjectId;
-    protected resetProjectIds(): void;
-    protected rebuidDocuments(cancelToken?: Cancellation.CancellationToken): Promise<void>;
-    protected findProjectForDocument(documentUri: string): Pick<ProjectData, "id" | "exclude" | "config">;
-    protected get mappingsToProject(): WorkspaceCache<string, Pick<ProjectData, 'id' | 'config' | 'exclude'>>;
+    protected reset(): void;
+    rebuidProject(projectId: ProjectId, cancelToken?: Cancellation.CancellationToken): Promise<void>;
+    protected findProjectForDocument(documentUri: string): ProjectData;
+    protected get mappingsToProject(): WorkspaceCache<string, ProjectData>;
+    /**
+     * The mapping between documents and projects they belong to.
+     * Lazy-created due to initialization order of the LanguageServer
+     */
+    protected get documentBelongsTo(): WorkspaceCache<LangiumDocument, ProjectData>;
+    /**
+     * Returns all include paths from all projects.
+     * Used by WorkspaceManager to scan additional directories for C4 files.
+     */
+    getAllIncludePaths(): Array<{
+        projectId: scalar.ProjectId;
+        includePath: URI;
+        includeConfig: IncludeConfig;
+    }>;
+    private getWorkspaceFolder;
 }
 export {};