@likec4/language-server 1.44.0 → 1.46.0

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/SpecificationParser.js

@@ -55,6 +55,10 @@ export function SpecificationParser(B) {
                     const tag = tagSpec.tag.name;
                     const astPath = this.getAstNodePath(tagSpec.tag);
                     const color = tagSpec.color && this.parseColorLiteral(tagSpec.color);
+                    if (tag in c4Specification.tags) {
+                        logger.warn(`Tag {tag} is already defined, skipping duplicate`, { tag });
+                        continue;
+                    }
                     if (isTruthy(tag)) {
                         c4Specification.tags[tag] = {
                             astPath,

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() {
@@ -63,7 +64,9 @@ export function ViewsParser(B) {
                 const viewOfEl = elementRef(astNode.viewOf);
                 const _viewOf = viewOfEl && this.resolveFqn(viewOfEl);
                 if (!_viewOf) {
-                    logger.warn('viewOf is not resolved: ' + astNode.$cstNode?.text);
+                    const viewId = astNode.name ?? 'unnamed';
+                    const msg = astNode.viewOf.$cstNode?.text ?? '<unknown>';
+                    logger.warn(`viewOf {viewId} not resolved {msg}`, { msg, viewId });
                 }
                 else {
                     viewOf = _viewOf;
@@ -126,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) {
@@ -190,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.d.ts

@@ -1,5 +1,5 @@
 import { type ViewChange } from '@likec4/core';
-import { Location, Range, TextEdit } from 'vscode-languageserver-types';
+import { Range, TextEdit } from 'vscode-languageserver-types';
 import type { ViewLocateResult } from '../model';
 import type { LikeC4Services } from '../module';
 import type { ChangeView } from '../protocol';
@@ -7,7 +7,7 @@ export declare class LikeC4ModelChanges {
     private services;
     private locator;
     constructor(services: LikeC4Services);
-    applyChange(changeView: ChangeView.Params): Promise<Location | null>;
+    applyChange(changeView: ChangeView.Params): Promise<ChangeView.Res>;
     protected convertToTextEdit({ lookup, change }: {
         lookup: ViewLocateResult;
         change: Exclude<ViewChange, ViewChange.SaveViewSnapshot | ViewChange.ResetManualLayout>;

package/dist/model-change/ModelChanges.js

@@ -1,5 +1,6 @@
 import { invariant, nonexhaustive } from '@likec4/core';
-import { Location, Range, TextEdit } from 'vscode-languageserver-types';
+import { loggable, wrapError } from '@likec4/log';
+import { Range, TextEdit } from 'vscode-languageserver-types';
 import { logger as mainLogger } from '../logger';
 import { changeElementStyle } from './changeElementStyle';
 import { changeViewLayout } from './changeViewLayout';
@@ -14,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 () => {
@@ -23,7 +23,7 @@ export class LikeC4ModelChanges {
                 logger.debug `Applying model change ${change.op} to view ${viewId} in project ${project.id}`;
                 const lookup = this.locator.locateViewAst(viewId, project.id);
                 if (!lookup) {
-                    throw new Error(`LikeC4ModelChanges: view not found: ${viewId}`);
+                    throw new Error(`View ${viewId} not found in project ${project.id}`);
                 }
                 const textDocument = {
                     uri: lookup.doc.textDocument.uri,
@@ -31,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
@@ -39,13 +39,29 @@ export class LikeC4ModelChanges {
                             logger.warn(`Failed to remove manual layout v1 for view ${viewId} in project ${project.id}`, { err });
                         });
                     }
-                    result = await this.services.likec4.ManualLayouts.write(project, change.layout);
+                    const location = await this.services.likec4.ManualLayouts.write(project, change.layout);
+                    result = {
+                        success: true,
+                        location,
+                    };
                     return;
                 }
                 if (change.op === 'reset-manual-layout') {
-                    result = await this.services.likec4.ManualLayouts.remove(project, viewId);
+                    // If there is an existing manual layout v1
+                    if (lookup.view.manualLayout) {
+                        // We clean it up
+                        await removeManualLayoutV1(this.services, { lookup }).catch(err => {
+                            logger.warn(`Failed to remove manual layout v1 for view ${viewId} in project ${project.id}`, { err });
+                        });
+                    }
+                    const location = await this.services.likec4.ManualLayouts.remove(project, viewId);
+                    result = {
+                        success: true,
+                        location,
+                    };
                     return;
                 }
+                invariant(lspConnection, 'This change only supported in IDE (running as Extension)');
                 const { edits, modifiedRange } = this.convertToTextEdit({
                     lookup,
                     change,
@@ -66,15 +82,29 @@ export class LikeC4ModelChanges {
                     return;
                 }
                 result = {
-                    uri: textDocument.uri,
-                    range: modifiedRange,
+                    success: true,
+                    location: {
+                        uri: textDocument.uri,
+                        range: modifiedRange,
+                    },
                 };
             });
         }
-        catch (error) {
-            logger.error(`Failed to apply change ${changeView.change.op} ${changeView.viewId}`, { error });
+        catch (err) {
+            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;
+        return result ?? {
+            success: false,
+            error: 'Unknown error applying model change',
+        };
     }
     convertToTextEdit({ lookup, change }) {
         switch (change.op) {

package/dist/protocol.d.ts

@@ -6,6 +6,18 @@ export declare namespace DidChangeModelNotification {
     const type: NotificationType<string>;
     type Type = typeof type;
 }
+/**
+ * When the snapshot of a manual layout changes
+ * Send by the editor to the language server
+ */
+export declare namespace DidChangeSnapshotNotification {
+    type Params = {
+        snapshotUri: DocumentUri;
+    };
+    const Method: "likec4/onDidChangeSnapshot";
+    const type: NotificationType<Params>;
+    type Type = typeof type;
+}
 /**
  * When server requests to open a likec4 preview panel
  * (available only in the editor).
@@ -72,6 +84,7 @@ export declare namespace LayoutView {
     type Params = {
         viewId: ViewId;
         projectId?: string | undefined;
+        layoutType?: 'auto' | 'manual' | undefined;
     };
     type Res = {
         result: {
@@ -102,8 +115,8 @@ export declare namespace ValidateLayout {
             };
         }[] | null;
     };
-    const Req: RequestType<Params, Res, void>;
-    type Req = typeof Req;
+    const req: RequestType<Params, Res, void>;
+    type Req = typeof req;
 }
 /**
  * Request to reload projects.
@@ -123,7 +136,10 @@ export declare namespace FetchProjects {
         projects: {
             [projectId: ProjectId]: {
                 folder: URI;
-                config: LikeC4ProjectJsonConfig;
+                config: {
+                    name: string;
+                    title?: string | undefined;
+                };
                 docs: NonEmptyArray<DocumentUri>;
             };
         };
@@ -152,8 +168,8 @@ export declare namespace BuildDocuments {
     type Params = {
         docs: DocumentUri[];
     };
-    const Req: RequestType<Params, void, void>;
-    type Req = typeof Req;
+    const req: RequestType<Params, void, void>;
+    type Req = typeof req;
 }
 /**
  * Request to locate an element, relation, deployment or view.
@@ -200,8 +216,8 @@ export declare namespace Locate {
         projectId?: string | undefined;
     };
     type Res = Location | null;
-    const Req: RequestType<Params, Res, void>;
-    type Req = typeof Req;
+    const req: RequestType<Params, Res, void>;
+    type Req = typeof req;
 }
 /**
  * Request to change the view
@@ -213,9 +229,16 @@ export declare namespace ChangeView {
         change: ViewChange;
         projectId?: string | undefined;
     };
-    type Res = Location | null;
-    const Req: RequestType<Params, Res, void>;
-    type Req = typeof Req;
+    type Res = {
+        success: true;
+        location: Location | null;
+    } | {
+        success: false;
+        location?: Location | null;
+        error: string;
+    };
+    const req: RequestType<Params, Res, void>;
+    type Req = typeof req;
 }
 /**
  * Request to fetch telemetry metrics

package/dist/protocol.js

@@ -3,6 +3,15 @@ export var DidChangeModelNotification;
 (function (DidChangeModelNotification) {
     DidChangeModelNotification.type = new NotificationType('likec4/onDidChangeModel');
 })(DidChangeModelNotification || (DidChangeModelNotification = {}));
+/**
+ * When the snapshot of a manual layout changes
+ * Send by the editor to the language server
+ */
+export var DidChangeSnapshotNotification;
+(function (DidChangeSnapshotNotification) {
+    DidChangeSnapshotNotification.Method = 'likec4/onDidChangeSnapshot';
+    DidChangeSnapshotNotification.type = new NotificationType(DidChangeSnapshotNotification.Method);
+})(DidChangeSnapshotNotification || (DidChangeSnapshotNotification = {}));
 /**
  * When server requests to open a likec4 preview panel
  * (available only in the editor).
@@ -51,7 +60,7 @@ export var LayoutView;
  */
 export var ValidateLayout;
 (function (ValidateLayout) {
-    ValidateLayout.Req = new RequestType('likec4/validate-layout');
+    ValidateLayout.req = new RequestType('likec4/validate-layout');
 })(ValidateLayout || (ValidateLayout = {}));
 /**
  * Request to reload projects.
@@ -79,7 +88,7 @@ export var RegisterProject;
  */
 export var BuildDocuments;
 (function (BuildDocuments) {
-    BuildDocuments.Req = new RequestType('likec4/build');
+    BuildDocuments.req = new RequestType('likec4/build');
 })(BuildDocuments || (BuildDocuments = {}));
 /**
  * Request to locate an element, relation, deployment or view.
@@ -87,7 +96,7 @@ export var BuildDocuments;
  */
 export var Locate;
 (function (Locate) {
-    Locate.Req = new RequestType('likec4/locate');
+    Locate.req = new RequestType('likec4/locate');
 })(Locate || (Locate = {}));
 // #endregion
 /**
@@ -96,7 +105,7 @@ export var Locate;
  */
 export var ChangeView;
 (function (ChangeView) {
-    ChangeView.Req = new RequestType('likec4/change-view');
+    ChangeView.req = new RequestType('likec4/change-view');
 })(ChangeView || (ChangeView = {}));
 /**
  * Request to fetch telemetry metrics

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/view-utils/manual-layout.js

@@ -14,10 +14,9 @@ function pack({ nodes, edges, ...rest }) {
             b: [x, y, width, height],
             c: isCompound,
         })),
-        edges: mapValues(edges, ({ points, controlPoints, labelBBox, dotpos, ...e }) => ({
+        edges: mapValues(edges, ({ points, controlPoints, labelBBox, ...e }) => ({
             ...!!controlPoints && { cp: controlPoints },
             ...!!labelBBox && { l: labelBBox },
-            ...!!dotpos && { dp: dotpos },
             ...e,
             p: points,
         })),
@@ -36,10 +35,9 @@ function unpack({ nodes, edges, autoLayout, ...rest }) {
             isCompound: c,
             ...n,
         })),
-        edges: mapValues(edges, ({ p, cp, l, dp, ...e }) => ({
+        edges: mapValues(edges, ({ p, cp, l, ...e }) => ({
             ...!!cp && { controlPoints: cp },
             ...!!l && { labelBBox: l },
-            ...!!dp && { dotpos: dp },
             ...e,
             points: p,
         })),