@likec4/language-server 1.45.0 → 1.46.0

package/dist/model/parser/GlobalsParser.d.ts

@@ -15,6 +15,7 @@ export declare function GlobalsParser<TBase extends WithViewsParser>(B: TBase):
         parseViewRuleGlobalPredicateRef(astRule: ast.ViewRuleGlobalPredicateRef | ast.DynamicViewGlobalPredicateRef): c4.ViewRuleGlobalPredicateRef;
         parseViewRuleStyleOrGlobalRef(astRule: ast.ViewRuleStyleOrGlobalRef): c4.ViewRuleGlobalStyle | c4.ElementViewRuleStyle<c4.aux.Any>;
         parseViewRuleGroup(astNode: ast.ViewRuleGroup): c4.ElementViewRuleGroup;
+        parseViewRuleRank(astRule: ast.ViewRuleRank): c4.ElementViewRuleRank;
         parseViewRuleStyle(astRule: ast.ViewRuleStyle | ast.GlobalStyle): c4.ElementViewRuleStyle;
         parseViewRuleGlobalStyle(astRule: ast.ViewRuleGlobalStyle): c4.ViewRuleGlobalStyle;
         parseDynamicElementView(astNode: ast.DynamicView, additionalStyles: (c4.ViewRuleGlobalStyle | c4.ElementViewRuleStyle<c4.aux.Any>)[]): import("../../ast").ParsedAstDynamicView;

package/dist/model/parser/ModelParser.d.ts

@@ -1,6 +1,6 @@
 import type * as c4 from '@likec4/core';
 import { FqnRef } from '@likec4/core/types';
-import { type ParsedAstElement, type ParsedAstExtend, type ParsedAstRelation, ast } from '../../ast';
+import { type ParsedAstElement, type ParsedAstExtend, type ParsedAstExtendRelation, type ParsedAstRelation, ast } from '../../ast';
 import type { WithExpressionV2 } from './FqnRefParser';
 export type WithModel = ReturnType<typeof ModelParser>;
 export declare function ModelParser<TBase extends WithExpressionV2>(B: TBase): {
@@ -8,6 +8,7 @@ export declare function ModelParser<TBase extends WithExpressionV2>(B: TBase): {
         parseModel(): void;
         parseElement(astNode: ast.Element): ParsedAstElement;
         parseExtendElement(astNode: ast.ExtendElement): ParsedAstExtend | null;
+        parseExtendRelation(astNode: ast.ExtendRelation): ParsedAstExtendRelation | null;
         _resolveRelationSource(node: ast.Relation): FqnRef.ModelRef | FqnRef.ImportRef;
         parseRelation(astNode: ast.Relation): ParsedAstRelation;
         parseFqnRef(astNode: ast.FqnRef): c4.FqnRef;

package/dist/model/parser/ModelParser.js

@@ -1,3 +1,9 @@
+// SPDX-License-Identifier: MIT
+//
+// Copyright (c) 2023-2025 Denis Davydkov
+// Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+// Portions of this file have been modified by NVIDIA CORPORATION & AFFILIATES.
 import { invariant, isNonEmptyArray, LinkedList, nonexhaustive, nonNullable } from '@likec4/core';
 import { exact, FqnRef } from '@likec4/core/types';
 import { loggable } from '@likec4/log';
@@ -15,7 +21,12 @@ function* streamModel(doc) {
             relations.push(el);
             continue;
         }
-        if (el.body && el.body.elements && el.body.elements.length > 0) {
+        // Skip ExtendRelation as it doesn't have child elements
+        if (ast.isExtendRelation(el)) {
+            yield el;
+            continue;
+        }
+        if (el.body && 'elements' in el.body && el.body.elements && el.body.elements.length > 0) {
             for (const child of el.body.elements) {
                 traverseStack.push(child);
             }
@@ -48,6 +59,13 @@ export function ModelParser(B) {
                         }
                         continue;
                     }
+                    if (ast.isExtendRelation(el)) {
+                        const parsed = this.parseExtendRelation(el);
+                        if (parsed) {
+                            doc.c4ExtendRelations.push(parsed);
+                        }
+                        continue;
+                    }
                     nonexhaustive(el);
                 }
                 catch (e) {
@@ -107,6 +125,32 @@ export function ModelParser(B) {
                 links: isNonEmptyArray(links) ? links : null,
             });
         }
+        parseExtendRelation(astNode) {
+            const source = this.parseFqnRef(astNode.source);
+            const target = this.parseFqnRef(astNode.target);
+            invariant(FqnRef.isModelRef(source) || FqnRef.isImportRef(source), 'Source must be a model reference');
+            invariant(FqnRef.isModelRef(target) || FqnRef.isImportRef(target), 'Target must be a model reference');
+            const tags = this.parseTags(astNode.body);
+            const metadata = this.getMetadata(astNode.body?.props.find(ast.isMetadataProperty));
+            const astPath = this.getAstNodePath(astNode);
+            const links = this.parseLinks(astNode.body) ?? [];
+            if (!tags && isEmpty(metadata ?? {}) && isEmpty(links)) {
+                return null;
+            }
+            // Generate a stable relation ID based on source, target, kind, and title
+            // This allows extends to match specific relations between elements
+            const kind = (astNode.kind ?? astNode.dotKind?.kind)?.ref?.name;
+            // Normalize title the same way as parseRelation does
+            const { title = '' } = this.parseBaseProps({}, { title: astNode.title });
+            const id = stringHash('extend-relation', FqnRef.flatten(source), FqnRef.flatten(target), kind ?? 'default', title);
+            return exact({
+                id,
+                astPath,
+                metadata,
+                tags,
+                links: isNonEmptyArray(links) ? links : null,
+            });
+        }
         _resolveRelationSource(node) {
             if (isDefined(node.source)) {
                 const source = this.parseFqnRef(node.source);

package/dist/model/parser/ViewsParser.d.ts

@@ -14,6 +14,7 @@ export declare function ViewsParser<TBase extends WithPredicates & WithDeploymen
         parseViewRuleGlobalPredicateRef(astRule: ast.ViewRuleGlobalPredicateRef | ast.DynamicViewGlobalPredicateRef): c4.ViewRuleGlobalPredicateRef;
         parseViewRuleStyleOrGlobalRef(astRule: ast.ViewRuleStyleOrGlobalRef): ViewRuleStyleOrGlobalRef;
         parseViewRuleGroup(astNode: ast.ViewRuleGroup): c4.ElementViewRuleGroup;
+        parseViewRuleRank(astRule: ast.ViewRuleRank): c4.ElementViewRuleRank;
         parseViewRuleStyle(astRule: ast.ViewRuleStyle | ast.GlobalStyle): c4.ElementViewRuleStyle;
         parseViewRuleGlobalStyle(astRule: ast.ViewRuleGlobalStyle): c4.ViewRuleGlobalStyle;
         parseDynamicElementView(astNode: ast.DynamicView, additionalStyles: ViewRuleStyleOrGlobalRef[]): ParsedAstDynamicView;

package/dist/model/parser/ViewsParser.js

@@ -9,6 +9,7 @@ import { elementRef } from '../../utils/elementRef';
 import { parseViewManualLayout } from '../../view-utils/manual-layout';
 import { removeIndent, toSingleLine } from './Base';
 const logger = mainLogger.getChild('ViewsParser');
+const rankLogger = logger.getChild('rank');
 export function ViewsParser(B) {
     return class ViewsParser extends B {
         parseViews() {
@@ -128,6 +129,9 @@ export function ViewsParser(B) {
             if (ast.isViewRuleGroup(astRule)) {
                 return this.parseViewRuleGroup(astRule);
             }
+            if (ast.isViewRuleRank(astRule)) {
+                return this.parseViewRuleRank(astRule);
+            }
             nonexhaustive(astRule);
         }
         parseViewRulePredicate(astNode) {
@@ -192,6 +196,15 @@ export function ViewsParser(B) {
                 ...this.parseStyleProps(astNode.props),
             };
         }
+        parseViewRuleRank(astRule) {
+            const targets = this.parseFqnExpressions(astRule.targets).filter((e) => c4.ModelExpression.isFqnExpr(e));
+            const rank = astRule.value ?? 'same';
+            rankLogger.debug `Parsed rank constraint ${rank} with ${targets.length} target(s)`;
+            return {
+                rank,
+                targets,
+            };
+        }
         parseViewRuleStyle(astRule) {
             const targets = this.parseFqnExpressions(astRule.targets).filter((e) => c4.ModelExpression.isFqnExpr(e));
             const style = this.parseStyleProps(astRule.props.filter(ast.isStyleProperty));

package/dist/model-change/ModelChanges.js

@@ -15,7 +15,6 @@ export class LikeC4ModelChanges {
     }
     async applyChange(changeView) {
         const lspConnection = this.services.shared.lsp.Connection;
-        invariant(lspConnection, 'LSP Connection not available');
         let result = null;
         try {
             await this.services.shared.workspace.WorkspaceLock.write(async () => {
@@ -32,7 +31,7 @@ export class LikeC4ModelChanges {
                 };
                 // TODO refactor to use separate methods for save/reset operations
                 if (change.op === 'save-view-snapshot') {
-                    invariant(viewId === change.layout.id, 'View ID does not match');
+                    invariant(viewId === change.layout.id, 'View ID does not match, expected ' + viewId + ', got ' + change.layout.id);
                     // If there is an existing manual layout v1
                     if (lookup.view.manualLayout) {
                         // We clean it up
@@ -62,6 +61,7 @@ export class LikeC4ModelChanges {
                     };
                     return;
                 }
+                invariant(lspConnection, 'This change only supported in IDE (running as Extension)');
                 const { edits, modifiedRange } = this.convertToTextEdit({
                     lookup,
                     change,
@@ -91,13 +91,16 @@ export class LikeC4ModelChanges {
             });
         }
         catch (err) {
-            const error = loggable(wrapError(err, `Failed to apply change ${changeView.change.op} ${changeView.viewId}:\n`));
+            const error = loggable(wrapError(err, `Failed to apply change ${changeView.change.op} ${changeView.viewId}`));
             logger.error(error);
             result = {
                 success: false,
                 error,
             };
         }
+        finally {
+            this.services.likec4.ModelBuilder.clearCache();
+        }
         return result ?? {
             success: false,
             error: 'Unknown error applying model change',

package/dist/validation/index.d.ts

@@ -4,7 +4,7 @@ import type { LikeC4Services } from '../module';
 export { LikeC4DocumentValidator } from './DocumentValidator';
 type Guard<N extends AstNode> = (n: AstNode) => n is N;
 type Guarded<G> = G extends Guard<infer N> ? N : never;
-declare const isValidatableAstNode: (n: AstNode) => n is ast.DynamicViewDisplayVariantProperty | ast.LinkProperty | ast.ViewStringProperty | ast.ElementStringProperty | ast.ElementStyleProperty | ast.IconProperty | ast.MetadataBody | ast.RelationStringProperty | ast.MetadataAttribute | ast.NotationProperty | ast.NotesProperty | ast.SpecificationElementStringProperty | ast.SpecificationRelationshipStringProperty | ast.HexColor | ast.RGBAColor | ast.DeployedInstance | ast.DeploymentNode | ast.DeploymentViewRulePredicate | ast.DeploymentViewRuleStyle | ast.ViewRuleAutoLayout | ast.DynamicViewGlobalPredicateRef | ast.DynamicViewIncludePredicate | ast.ViewRuleGlobalStyle | ast.ViewRuleStyle | ast.DynamicStepChain | ast.DynamicStepSingle | ast.ElementKindExpression | ast.ElementTagExpression | ast.FqnRefExpr | ast.WildcardExpression | ast.FqnExprWhere | ast.FqnExprWith | ast.DirectedRelationExpr | ast.InOutRelationExpr | ast.IncomingRelationExpr | ast.OutgoingRelationExpr | ast.RelationExprWhere | ast.RelationExprWith | ast.Element | ast.ExtendDeployment | ast.ExtendElement | ast.Imported | ast.DeploymentView | ast.DynamicView | ast.ElementView | ast.ArrowProperty | ast.ColorProperty | ast.LineProperty | ast.PaddingSizeProperty | ast.ShapeSizeProperty | ast.TextSizeProperty | ast.BorderProperty | ast.MultipleProperty | ast.OpacityProperty | ast.ShapeProperty | ast.ViewRuleGlobalPredicateRef | ast.ViewRuleGroup | ast.ViewRulePredicate | ast.DynamicViewParallelSteps | ast.SpecificationRelationshipKind | ast.SpecificationRule | ast.ElementRef | ast.DeploymentRelation | ast.Relation | ast.GlobalDynamicPredicateGroup | ast.Globals | ast.GlobalPredicateGroup | ast.GlobalStyle | ast.SpecificationDeploymentNodeKind | ast.SpecificationElementKind | ast.GlobalStyleGroup | ast.SpecificationColor | ast.NavigateToProperty | ast.Tags | ast.ImportsFromPoject | ast.SpecificationTag;
+declare const isValidatableAstNode: (n: AstNode) => n is ast.DynamicViewDisplayVariantProperty | ast.LinkProperty | ast.ViewStringProperty | ast.ElementStringProperty | ast.ElementStyleProperty | ast.IconProperty | ast.MetadataBody | ast.RelationStringProperty | ast.MetadataAttribute | ast.NotationProperty | ast.NotesProperty | ast.SpecificationElementStringProperty | ast.SpecificationRelationshipStringProperty | ast.HexColor | ast.RGBAColor | ast.DeployedInstance | ast.DeploymentNode | ast.DeploymentViewRulePredicate | ast.DeploymentViewRuleStyle | ast.ViewRuleAutoLayout | ast.DynamicViewGlobalPredicateRef | ast.DynamicViewIncludePredicate | ast.ViewRuleGlobalStyle | ast.ViewRuleStyle | ast.DynamicStepChain | ast.DynamicStepSingle | ast.ElementKindExpression | ast.ElementTagExpression | ast.FqnRefExpr | ast.WildcardExpression | ast.FqnExprWhere | ast.FqnExprWith | ast.DirectedRelationExpr | ast.InOutRelationExpr | ast.IncomingRelationExpr | ast.OutgoingRelationExpr | ast.RelationExprWhere | ast.RelationExprWith | ast.Element | ast.ExtendDeployment | ast.ExtendElement | ast.Imported | ast.DeploymentView | ast.DynamicView | ast.ElementView | ast.ArrowProperty | ast.ColorProperty | ast.LineProperty | ast.PaddingSizeProperty | ast.ShapeSizeProperty | ast.TextSizeProperty | ast.BorderProperty | ast.MultipleProperty | ast.OpacityProperty | ast.ShapeProperty | ast.ViewRuleGlobalPredicateRef | ast.ViewRuleGroup | ast.ViewRulePredicate | ast.ViewRuleRank | ast.DynamicViewParallelSteps | ast.SpecificationRelationshipKind | ast.SpecificationRule | ast.ElementRef | ast.DeploymentRelation | ast.Relation | ast.GlobalDynamicPredicateGroup | ast.Globals | ast.GlobalPredicateGroup | ast.GlobalStyle | ast.SpecificationDeploymentNodeKind | ast.SpecificationElementKind | ast.GlobalStyleGroup | ast.SpecificationColor | ast.NavigateToProperty | ast.Tags | ast.ExtendRelation | ast.ImportsFromPoject | ast.SpecificationTag;
 type ValidatableAstNode = Guarded<typeof isValidatableAstNode>;
 export declare function checksFromDiagnostics(doc: LikeC4LangiumDocument): {
     isValid: (n: ValidatableAstNode) => boolean;

package/dist/validation/index.js

@@ -1,3 +1,9 @@
+// SPDX-License-Identifier: MIT
+//
+// Copyright (c) 2023-2025 Denis Davydkov
+// Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+// Portions of this file have been modified by NVIDIA CORPORATION & AFFILIATES.
 import { onNextTick } from '@likec4/core/utils';
 import { loggable } from '@likec4/log';
 import { DocumentState } from 'langium';
@@ -11,9 +17,10 @@ import { checkElement } from './element';
 import { checkElementRef } from './element-ref';
 import { checkImportsFromPoject } from './imports';
 import { colorLiteralRuleChecks, iconPropertyRuleChecks, notesPropertyRuleChecks, opacityPropertyRuleChecks, } from './property-checks';
-import { checkRelationBody, relationChecks } from './relation';
+import { checkRelationBody, extendRelationChecks, relationChecks } from './relation';
 import { checkDeploymentNodeKind, checkElementKind, checkGlobalPredicate, checkGlobals, checkGlobalStyleId, checkModel, checkRelationshipKind, checkSpecificationRule, checkTag, } from './specification';
 import { viewChecks } from './view';
+import { viewRuleRankChecks } from './view-checks';
 import { checkFqnExprWith, checkFqnRefExpr, checkIncomingRelationExpr, checkOutgoingRelationExpr, checkRelationExpr, checkRelationExprWith, } from './view-predicates';
 export { LikeC4DocumentValidator } from './DocumentValidator';
 function validatableAstNodeGuards(predicates) {
@@ -60,6 +67,7 @@ const isValidatableAstNode = validatableAstNodeGuards([
     ast.isElementRef,
     ast.isExtendElement,
     ast.isExtendDeployment,
+    ast.isExtendRelation,
     ast.isSpecificationElementKind,
     ast.isSpecificationRelationshipKind,
     ast.isSpecificationDeploymentNodeKind,
@@ -108,6 +116,7 @@ export function registerValidationChecks(services) {
         DeploymentNode: deploymentNodeChecks(services),
         DeploymentRelation: deploymentRelationChecks(services),
         ExtendDeployment: extendDeploymentChecks(services),
+        ExtendRelation: extendRelationChecks(services),
         FqnRefExpr: checkFqnRefExpr(services),
         RelationExpr: checkRelationExpr(services),
         NotesProperty: notesPropertyRuleChecks(services),
@@ -137,6 +146,7 @@ export function registerValidationChecks(services) {
         // Imported: checkImported(services),
         ColorLiteral: colorLiteralRuleChecks(services),
         DynamicViewDisplayVariantProperty: dynamicViewDisplayVariant(services),
+        ViewRuleRank: viewRuleRankChecks(services),
     });
     const connection = services.shared.lsp.Connection;
     if (connection) {

package/dist/validation/relation.d.ts

@@ -3,3 +3,4 @@ import { ast } from '../ast';
 import type { LikeC4Services } from '../module';
 export declare const relationChecks: (services: LikeC4Services) => ValidationCheck<ast.Relation>;
 export declare const checkRelationBody: (_services: LikeC4Services) => ValidationCheck<ast.RelationBody>;
+export declare const extendRelationChecks: (services: LikeC4Services) => ValidationCheck<ast.ExtendRelation>;

package/dist/validation/relation.js

@@ -1,8 +1,29 @@
+// SPDX-License-Identifier: MIT
+//
+// Copyright (c) 2023-2025 Denis Davydkov
+// Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+// Portions of this file have been modified by NVIDIA CORPORATION & AFFILIATES.
 import { FqnRef, isSameHierarchy } from '@likec4/core';
 import { AstUtils } from 'langium';
-import { ast } from '../ast';
+import { ast, isParsedLikeC4LangiumDocument } from '../ast';
 import { safeCall } from '../utils';
+import { stringHash } from '../utils/stringHash';
 import { tryOrLog } from './_shared';
+// Cache of relation match keys to avoid recomputing for every extend validation
+let cachedRelationKeys = null;
+let cachedDocsFingerprint = null;
+const computeDocsFingerprint = (docs) => {
+    return docs
+        .map(doc => {
+        const relationHashes = (doc.c4Relations ?? [])
+            .map(rel => stringHash('extend-relation', FqnRef.flatten(rel.source), FqnRef.flatten(rel.target), rel.kind ?? 'default', rel.title ?? ''))
+            .sort()
+            .join(',');
+        return `${doc.uri.toString()}:${relationHashes}`;
+    })
+        .join('|');
+};
 export const relationChecks = (services) => {
     const modelParser = services.likec4.ModelParser;
     return tryOrLog((el, accept) => {
@@ -53,3 +74,68 @@ export const checkRelationBody = (_services) => {
         }
     });
 };
+export const extendRelationChecks = (services) => {
+    const modelParser = services.likec4.ModelParser;
+    return tryOrLog((el, accept) => {
+        const parser = modelParser.forDocument(AstUtils.getDocument(el));
+        const source = safeCall(() => parser.parseFqnRef(el.source));
+        if (!source) {
+            accept('error', 'Source not resolved', {
+                node: el,
+                property: 'source',
+            });
+            return;
+        }
+        const target = safeCall(() => parser.parseFqnRef(el.target));
+        if (!target) {
+            accept('error', 'Target not resolved', {
+                node: el,
+                property: 'target',
+            });
+            return;
+        }
+        if (!FqnRef.isModelRef(source) && !FqnRef.isImportRef(source)) {
+            accept('error', 'Source must reference a model element', {
+                node: el,
+                property: 'source',
+            });
+            return;
+        }
+        if (!FqnRef.isModelRef(target) && !FqnRef.isImportRef(target)) {
+            accept('error', 'Target must reference a model element', {
+                node: el,
+                property: 'target',
+            });
+            return;
+        }
+        // Warn if this extend does not match any relation in the workspace
+        // Build a match key identical to buildModel.ts
+        const kind = (el.kind ?? el.dotKind?.kind)?.ref?.name ?? 'default';
+        // Normalize title using the same parser helper
+        const { title = '' } = parser.parseBaseProps({}, { title: el.title });
+        const extendKey = stringHash('extend-relation', FqnRef.flatten(source), FqnRef.flatten(target), kind, title);
+        // Build (or reuse) a Set of all relation match keys across the workspace.
+        // This avoids O(E x D x R) scans on large workspaces.
+        const docs = services.shared.workspace.LangiumDocuments.all
+            .toArray()
+            .filter(isParsedLikeC4LangiumDocument);
+        const fingerprint = computeDocsFingerprint(docs);
+        if (fingerprint !== cachedDocsFingerprint) {
+            const keys = new Set();
+            for (const d of docs) {
+                for (const rel of d.c4Relations ?? []) {
+                    const key = stringHash('extend-relation', FqnRef.flatten(rel.source), FqnRef.flatten(rel.target), rel.kind ?? 'default', rel.title ?? '');
+                    keys.add(key);
+                }
+            }
+            cachedRelationKeys = keys;
+            cachedDocsFingerprint = fingerprint;
+        }
+        const hasMatch = cachedRelationKeys?.has(extendKey) ?? false;
+        if (!hasMatch) {
+            accept('warning', 'This extend does not match any relation (by source, kind, target, title)', {
+                node: el,
+            });
+        }
+    });
+};

package/dist/validation/view-checks.d.ts

@@ -0,0 +1,4 @@
+import type { ValidationCheck } from 'langium';
+import { ast } from '../ast';
+import type { LikeC4Services } from '../module';
+export declare const viewRuleRankChecks: (_services: LikeC4Services) => ValidationCheck<ast.ViewRuleRank>;

package/dist/validation/view-checks.js

@@ -0,0 +1,46 @@
+import { ast } from '../ast';
+import { tryOrLog } from './_shared';
+// Helper to collect FqnExpr values from FqnExpressions linked list
+function collectFqnExprs(exprs) {
+    const result = [];
+    let iter = exprs;
+    while (iter) {
+        if (iter.value) {
+            result.push(iter.value);
+        }
+        iter = iter.prev;
+    }
+    return result.reverse();
+}
+export const viewRuleRankChecks = (_services) => {
+    return tryOrLog((el, accept) => {
+        const targetExprs = collectFqnExprs(el.targets);
+        if (targetExprs.length < 2 && el.value === 'same') {
+            accept('warning', 'Rank rule should have at least 2 targets', {
+                node: el,
+                property: 'targets',
+            });
+        }
+        // Filter to only FqnRefExpr for parent comparison
+        const fqnRefExprs = targetExprs.filter(ast.isFqnRefExpr);
+        const firstParent = fqnRefExprs[0]?.ref?.parent;
+        for (let i = 1; i < fqnRefExprs.length; i++) {
+            const target = fqnRefExprs[i];
+            if (el.value === 'same' && !areSame(firstParent, target?.ref?.parent)) {
+                accept('error', 'All targets must have the same parent rank same', {
+                    node: el,
+                    property: 'targets',
+                });
+            }
+        }
+    });
+};
+function areSame(a, b) {
+    if (!a && !b)
+        return true;
+    if (!a || !b)
+        return false;
+    if (a.value.ref !== b.value.ref)
+        return false;
+    return areSame(a.parent, b.parent);
+}

package/dist/views/LikeC4ManualLayouts.js

@@ -75,9 +75,9 @@ export class DefaultLikeC4ManualLayouts {
             const { manualLayout: _, ...rest } = layouted;
             layouted = rest;
         }
+        const content = JSON5.stringify(
         // Normalize icon paths before writing
-        layouted = this.normalizeIconPathsForWrite(layouted, project.folderUri);
-        const content = JSON5.stringify(layouted, {
+        this.normalizeIconPathsForWrite(layouted, project.folderUri), {
             space: 2,
             quote: '\'',
         });

package/dist/views/LikeC4Views.js

@@ -1,8 +1,8 @@
-import { _layout, applyManualLayout, calcDriftsFromSnapshot, invariant } from '@likec4/core';
+import { _layout, applyManualLayout, calcDriftsFromSnapshot } from '@likec4/core';
 import { GraphvizLayouter } from '@likec4/layouts';
 import { loggable } from '@likec4/log';
 import { interruptAndCheck } from 'langium';
-import { isTruthy, 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');

package/dist/workspace/ProjectsManager.d.ts

@@ -1,4 +1,4 @@
-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 { ProjectId, scalar } from '@likec4/core/types';
 import { type Cancellation, type LangiumDocument, URI, WorkspaceCache } from 'langium';
@@ -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;
@@ -93,6 +109,15 @@ export declare class ProjectsManager {
      * 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 {};