@likec4/language-server 1.27.3 → 1.28.1

package/dist/model-change/changeElementStyle.js

@@ -15,15 +15,15 @@ const asViewStyleRule = (target, style, indent = 0) => {
   ];
 };
 const isMatchingViewRule = (fqn, index) => (rule) => {
-  if (!ast.isViewRuleStyle(rule)) {
+  if (!ast.isViewRuleStyle(rule) && !ast.isDeploymentViewRuleStyle(rule)) {
     return false;
   }
-  const target = rule.target.value;
-  if (!target || isTruthy(rule.target.prev) || !ast.isElementRef(target)) {
+  const target = rule.targets.value;
+  if (!target || isTruthy(rule.targets.prev) || target.$type !== "FqnRefExpr" || isTruthy(target.selector)) {
     return false;
   }
-  const ref = target.el.ref;
-  const _fqn = ref ? index.getFqn(ref) : null;
+  const ref = target.ref?.value?.ref;
+  const _fqn = ref ? index.resolve(ref) : null;
   return _fqn === fqn;
 };
 export function changeElementStyle(services, {
@@ -39,7 +39,10 @@ export function changeElementStyle(services, {
   invariant(insertPos, "insertPos is not defined");
   const indent = viewCstNode.range.start.character + 2;
   const fqnIndex = services.likec4.FqnIndex;
-  const styleRules = filter(viewAst.body.rules, ast.isViewRuleStyle);
+  const styleRules = filter(
+    viewAst.body.rules,
+    (r) => ast.isViewRuleStyle(r) || ast.isDeploymentViewRuleStyle(r)
+  );
   const viewOf = view.__ === "element" ? view.viewOf : null;
   const existing = [];
   const insert = [];

package/dist/references/name-provider.js

@@ -16,8 +16,11 @@ export class LikeC4NameProvider extends DefaultNameProvider {
     if (isNamed(node)) {
       return node.name;
     }
+    if (ast.isImported(node)) {
+      return node.imported.$refText;
+    }
     if (ast.isDeployedInstance(node)) {
-      return node.element.el.$refText;
+      return node.target.modelElement.value.$refText;
     }
     return void 0;
   }
@@ -25,8 +28,11 @@ export class LikeC4NameProvider extends DefaultNameProvider {
     if (isNamed(node)) {
       return super.getNameNode(node);
     }
+    if (ast.isImported(node)) {
+      return node.imported.$refNode;
+    }
     if (ast.isDeployedInstance(node)) {
-      return node.element.el.$refNode;
+      return node.target.modelElement.value.$refNode;
     }
     return void 0;
   }

package/dist/references/scope-computation.d.ts

@@ -3,7 +3,7 @@ import type { CancellationToken } from 'vscode-languageserver';
 import { type LikeC4LangiumDocument, ast } from '../ast';
 import type { LikeC4Services } from '../module';
 type ElementsContainer = ast.Model | ast.ElementBody | ast.ExtendElementBody;
-type DeploymentsContainer = ast.ModelDeployments | ast.DeploymentNodeBody | ast.ExtendDeploymentBody;
+type DeploymentsContainer = ast.ModelDeployments | ast.DeploymentNodeBody | ast.ExtendDeploymentBody | ast.DeployedInstanceBody;
 export declare class LikeC4ScopeComputation extends DefaultScopeComputation {
     constructor(services: LikeC4Services);
     computeExports(document: LikeC4LangiumDocument, _cancelToken?: CancellationToken): Promise<AstNodeDescription[]>;

package/dist/references/scope-computation.js

@@ -21,7 +21,15 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
   async computeExports(document, _cancelToken) {
     const docExports = [];
     try {
-      const { specifications, models, views, globals, likec4lib, deployments } = document.parseResult.value;
+      const {
+        specifications,
+        models,
+        views,
+        globals,
+        likec4lib,
+        deployments,
+        imports
+      } = document.parseResult.value;
       this.exportLibrary(likec4lib, docExports, document);
       this.exportSpecification(specifications, docExports, document);
       this.exportModel(models, docExports, document);
@@ -193,6 +201,19 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
           logWarnError(e);
         }
       }
+      for (const imports of root.imports.flatMap((i) => i.imports)) {
+        try {
+          let imported = imports;
+          while (imported) {
+            descendants.push(
+              this.descriptions.createDescription(imported, imported.imported.$refText, document)
+            );
+            imported = imported.prev;
+          }
+        } catch (e) {
+          logWarnError(e);
+        }
+      }
       uniqueDescriptions(descendants).forEach((desc) => {
         scopes.add(root, desc);
       });
@@ -212,6 +233,10 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
           localScope.add(el.name, this.descriptions.createDescription(el, el.name, document));
         }
         subcontainer = el.body;
+        if (subcontainer) {
+          scopes.add(subcontainer, this.descriptions.createDescription(el, "this", document));
+          scopes.add(subcontainer, this.descriptions.createDescription(el, "it", document));
+        }
       } else if (ast.isExtendElement(el)) {
         subcontainer = el.body;
       }
@@ -248,17 +273,22 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
       if (ast.isDeploymentRelation(el)) {
         continue;
       }
+      let subcontainer = el.body;
       if (!ast.isExtendDeployment(el)) {
         let name = this.nameProvider.getName(el);
         if (isTruthy(name)) {
           const desc = this.descriptions.createDescription(el, name, document);
           localScope.add(name, desc);
         }
+        if (subcontainer) {
+          scopes.add(subcontainer, this.descriptions.createDescription(el, "this", document));
+          scopes.add(subcontainer, this.descriptions.createDescription(el, "it", document));
+        }
       }
-      if (!ast.isDeployedInstance(el) && el.body) {
+      if (subcontainer) {
         try {
           descedants.push(
-            ...this.processDeployments(el.body, scopes, document)
+            ...this.processDeployments(subcontainer, scopes, document)
           );
         } catch (e) {
           logWarnError(e);

package/dist/references/scope-provider.d.ts

@@ -1,6 +1,6 @@
 import { type ProjectId } from '@likec4/core';
 import { type AstNodeDescription, type ReferenceInfo, type Scope, type Stream, DefaultScopeProvider } from 'langium';
-import { ast } from '../ast';
+import { type AstNodeDescriptionWithFqn, ast } from '../ast';
 import type { DeploymentsIndex, FqnIndex } from '../model';
 import type { LikeC4Services } from '../module';
 import type { IndexManager } from '../workspace';
@@ -10,14 +10,13 @@ export declare class LikeC4ScopeProvider extends DefaultScopeProvider {
     protected readonly indexManager: IndexManager;
     constructor(services: LikeC4Services);
     getScope(context: ReferenceInfo): Scope;
-    protected genUniqueDescedants(of: () => ast.Element | ast.DeploymentNode | undefined): Generator<Stream<import("../ast").AstNodeDescriptionWithFqn>, void, any>;
-    protected streamScopeElementRef(ref: ast.ElementRef): Stream<AstNodeDescription>;
-    protected streamScopeExtendElement({ element }: ast.ExtendElement): Stream<AstNodeDescription>;
-    protected streamScopeElementView({ viewOf, extends: ext }: ast.ElementView): Stream<AstNodeDescription>;
+    protected genUniqueDescedants(of: () => ast.Element | ast.DeploymentNode | undefined): Generator<Stream<AstNodeDescriptionWithFqn>, void, any>;
+    protected genScopeExtendElement({ element }: ast.ExtendElement): Generator<AstNodeDescription>;
+    protected genScopeElementView({ viewOf, extends: ext }: ast.ElementView): Generator<AstNodeDescription>;
     protected getScopeForStrictFqnRef(projectId: ProjectId, container: ast.StrictFqnRef, context: ReferenceInfo): any;
-    protected streamScopeExtendDeployment({ deploymentNode }: ast.ExtendDeployment): Stream<AstNodeDescription>;
+    protected genScopeExtendDeployment({ deploymentNode }: ast.ExtendDeployment): Generator<AstNodeDescription>;
     protected streamForFqnRef(projectId: ProjectId, container: ast.FqnRef, context: ReferenceInfo): Stream<AstNodeDescription>;
-    protected genScopeForFqnRef(projectId: ProjectId, container: ast.FqnRef, context: ReferenceInfo): Generator<any, void, any>;
+    protected genScopeForParentlessFqnRef(projectId: ProjectId, container: ast.FqnRef, context: ReferenceInfo): Generator<AstNodeDescription>;
     /**
      * Computes the scope for a given reference context.
      *
@@ -29,7 +28,7 @@ export declare class LikeC4ScopeProvider extends DefaultScopeProvider {
      * It then iterates through the container hierarchy, collecting relevant scopes based on the reference type and container type.
      * Finally, it combines the collected scopes with the global scope to produce the final scope.
      */
-    protected computeScope(projectId: ProjectId, context: ReferenceInfo, referenceType?: any): Generator<any, void, any>;
+    protected computeScope(projectId: ProjectId, context: ReferenceInfo, referenceType?: any): Generator<AstNodeDescription>;
     /**
      * Create a global scope filtered for the given reference type.
      */

package/dist/references/scope-provider.js

@@ -10,7 +10,7 @@ import {
   StreamImpl,
   StreamScope
 } from "langium";
-import { ast } from "../ast.js";
+import { ast, isFqnRefInsideGlobals, isFqnRefInsideModel } from "../ast.js";
 import { logWarnError } from "../logger.js";
 import { projectIdFrom } from "../utils/index.js";
 import { elementRef, readStrictFqn } from "../utils/elementRef.js";
@@ -40,6 +40,10 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
         if (referenceType !== ast.Element) {
           return this.getProjectScope(projectId, referenceType, context);
         }
+        if (ast.isImported(container)) {
+          const projectId2 = projectIdFrom(container);
+          return new StreamScope(this.fqnIndex.rootElements(projectId2));
+        }
         if (ast.isStrictFqnElementRef(container) && context.property === "el") {
           const parent = container.parent;
           if (!parent) {
@@ -47,22 +51,6 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
           }
           return new StreamScope(this.fqnIndex.directChildrenOf(projectId, readStrictFqn(parent)));
         }
-        if (ast.isElementRef(container) && context.property === "el") {
-          const parent = container.parent;
-          if (parent) {
-            return new StreamScope(this.streamScopeElementRef(parent));
-          }
-          if (context.reference.$refText === "this" || context.reference.$refText === "it") {
-            const closestElement = AstUtils.getContainerOfType(container, ast.isElement);
-            if (closestElement) {
-              return new MapScope([
-                this.descriptions.createDescription(closestElement, context.reference.$refText)
-              ]);
-            } else {
-              return EMPTY_SCOPE;
-            }
-          }
-        }
         return new StreamScope(stream(this.computeScope(projectId, context)));
       } catch (e) {
         logWarnError(e);
@@ -90,23 +78,26 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
       yield* this.deploymentsIndex.uniqueDescedants(projectId, fqn);
     }
   }
-  streamScopeElementRef(ref) {
-    return stream(this.genUniqueDescedants(() => ref.el.ref));
-  }
-  streamScopeExtendElement({ element }) {
-    return stream([element.el.$nodeDescription]).nonNullable().concat(this.genUniqueDescedants(() => elementRef(element)));
+  *genScopeExtendElement({ element }) {
+    if (element.el.$nodeDescription) {
+      yield element.el.$nodeDescription;
+    }
+    yield* this.genUniqueDescedants(() => elementRef(element));
   }
-  streamScopeElementView({ viewOf, extends: ext }) {
+  *genScopeElementView({ viewOf, extends: ext }) {
     if (viewOf) {
-      return stream([viewOf.el.$nodeDescription]).nonNullable().concat(this.genUniqueDescedants(() => elementRef(viewOf)));
+      if (viewOf.modelElement.value.$nodeDescription) {
+        yield viewOf.modelElement.value.$nodeDescription;
+      }
+      yield* this.genUniqueDescedants(() => elementRef(viewOf));
+      return;
     }
     if (ext) {
-      return stream([ext]).flatMap((v) => {
-        const view = v.view.ref;
-        return view ? this.streamScopeElementView(view) : EMPTY_STREAM;
-      });
+      const view = ext.view.ref;
+      if (view) {
+        yield* this.genScopeElementView(view);
+      }
     }
-    return EMPTY_STREAM;
   }
   getScopeForStrictFqnRef(projectId, container, context) {
     const parent = container.parent;
@@ -117,37 +108,64 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
       this.deploymentsIndex.directChildrenOf(projectId, readStrictFqn(parent)).filter((desc) => this.reflection.isSubtype(desc.type, ast.DeploymentNode))
     );
   }
-  streamScopeExtendDeployment({ deploymentNode }) {
-    return stream([deploymentNode.value.$nodeDescription]).nonNullable().concat(this.genUniqueDescedants(() => {
+  *genScopeExtendDeployment({ deploymentNode }) {
+    if (deploymentNode.value.$nodeDescription) {
+      yield deploymentNode.value.$nodeDescription;
+    }
+    yield* this.genUniqueDescedants(() => {
       const target = deploymentNode.value.ref;
       return target && ast.isDeploymentNode(target) ? target : void 0;
-    }));
+    });
   }
   streamForFqnRef(projectId, container, context) {
     const parent = container.parent;
     if (!parent) {
-      return stream(this.genScopeForFqnRef(projectId, container, context));
+      return stream(this.genScopeForParentlessFqnRef(projectId, container, context));
     }
     const parentRef = parent.value.ref;
     if (!parentRef) {
       return EMPTY_STREAM;
     }
+    if (ast.isImported(parentRef)) {
+      return stream(this.genUniqueDescedants(() => {
+        return parentRef.imported.ref;
+      }));
+    }
     if (ast.isDeploymentNode(parentRef)) {
       return stream(this.genUniqueDescedants(() => parentRef));
     }
     if (ast.isDeployedInstance(parentRef)) {
-      return stream(this.streamScopeElementRef(parentRef.element));
+      return stream(this.genUniqueDescedants(() => {
+        const target = parentRef.target.modelElement.value.ref;
+        if (ast.isImported(target)) {
+          return target.imported.ref;
+        }
+        return ast.isElement(target) ? target : void 0;
+      }));
     }
     if (ast.isElement(parentRef)) {
       return stream(this.genUniqueDescedants(() => parentRef));
     }
     return nonexhaustive(parentRef);
   }
-  *genScopeForFqnRef(projectId, container, context) {
-    yield* this.computeScope(projectId, context, ast.DeploymentNode);
-    yield* this.computeScope(projectId, context, ast.DeployedInstance);
-    if (AstUtils.hasContainerOfType(container, ast.isDeploymentView)) {
+  *genScopeForParentlessFqnRef(projectId, container, context) {
+    if (AstUtils.hasContainerOfType(container, ast.isElementRef) || isFqnRefInsideModel(container)) {
       yield* this.computeScope(projectId, context, ast.Element);
+    } else if (isFqnRefInsideGlobals(container)) {
+      yield* this.computeScope(projectId, context, ast.Element);
+      yield* this.computeScope(projectId, context, ast.DeploymentNode);
+      yield* this.computeScope(projectId, context, ast.DeployedInstance);
+    } else {
+      yield* this.computeScope(projectId, context, ast.DeploymentNode);
+      yield* this.computeScope(projectId, context, ast.DeployedInstance);
+      if (AstUtils.hasContainerOfType(container, ast.isDeploymentViewBody)) {
+        yield* this.computeScope(projectId, context, ast.Element);
+      }
+    }
+    const doc = getDocument(container);
+    const precomputed = doc.precomputedScopes;
+    if (precomputed) {
+      yield* precomputed.values().filter((nd) => this.reflection.isSubtype(nd.type, ast.Imported));
     }
   }
   /**
@@ -178,13 +196,13 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
         yield* elements;
       }
       if (isDeploymentReference && ast.isExtendDeploymentBody(container)) {
-        yield* this.streamScopeExtendDeployment(container.$container);
+        yield* this.genScopeExtendDeployment(container.$container);
       }
       if (isElementReference && ast.isExtendElementBody(container)) {
-        yield* this.streamScopeExtendElement(container.$container);
+        yield* this.genScopeExtendElement(container.$container);
       }
       if (isElementReference && ast.isElementViewBody(container)) {
-        yield* this.streamScopeElementView(container.$container);
+        yield* this.genScopeElementView(container.$container);
       }
       container = container.$container;
     }

package/dist/shared/NodeKindProvider.js

@@ -17,7 +17,8 @@ export class NodeKindProvider {
         ast.Element,
         ast.ExtendElement,
         ast.DeploymentNode,
-        ast.DeployedInstance
+        ast.DeployedInstance,
+        ast.Imported
       ):
         return SymbolKind.Constructor;
       case hasType(
@@ -67,7 +68,8 @@ export class NodeKindProvider {
         ast.Element,
         ast.DeploymentNode,
         ast.DeployedInstance,
-        ast.ExtendElement
+        ast.ExtendElement,
+        ast.Imported
       ):
         return CompletionItemKind.Constructor;
       case hasType(

package/dist/test/testServices.d.ts

@@ -20,7 +20,9 @@ export declare function createTestServices(workspace?: string): {
     format: (input: string | LikeC4LangiumDocument, uri?: string) => Promise<any>;
 };
 export declare function createMultiProjectTestServices<const Projects extends Record<string, Record<string, string>>>(data: Projects): Promise<{
+    services: any;
     projects: { readonly [K in keyof Projects]: { readonly [L in keyof Projects[K]]: LikeC4LangiumDocument; }; };
+    projectsManager: any;
     /**
      * Add document outside of projects
      */

package/dist/test/testServices.js

@@ -141,7 +141,8 @@ export async function createMultiProjectTestServices(data) {
     const folderUri = UriUtils.joinPath(URI.parse(workspace), "src", name);
     services.shared.workspace.ProjectsManager.registerProject({
       config: {
-        name
+        name,
+        exclude: ["node_modules"]
       },
       folderUri
     });
@@ -164,7 +165,9 @@ export async function createMultiProjectTestServices(data) {
     return model.$model;
   }
   return {
+    services,
     projects,
+    projectsManager: services.shared.workspace.ProjectsManager,
     /**
      * Add document outside of projects
      */

package/dist/utils/elementRef.d.ts

@@ -1,5 +1,5 @@
 import type * as c4 from '@likec4/core';
-import type { ast } from '../ast';
+import { ast } from '../ast';
 /**
  * Returns referenced AST Element
  */

package/dist/utils/elementRef.js

@@ -1,5 +1,10 @@
+import { ast } from "../ast.js";
 export function elementRef(node) {
-  return node.el.ref;
+  let el = ast.isStrictFqnElementRef(node) ? node.el.ref : node.modelElement.value.ref;
+  if (el?.$type === "Imported") {
+    el = el.imported.ref;
+  }
+  return el?.$type === "Element" ? el : void 0;
 }
 export function readStrictFqn(node) {
   const name = [node.$type === "StrictFqnRef" ? node.value.$refText : node.el.$refText];

package/dist/utils/fqnRef.d.ts

@@ -1,6 +1,9 @@
 import { ast } from '../ast';
+export declare function referenceableParent(node: ast.FqnRef): ast.Referenceable | null;
 export declare function instanceRef(deploymentRef: ast.FqnRef): ast.DeployedInstance | null;
 export declare function deploymentNodeRef(deploymentRef: ast.FqnRef): ast.DeploymentNode | null;
+export declare function importsRef(node: ast.FqnRef): ast.Imported | null;
+export declare function isImportsRef(node: ast.FqnRef): boolean;
 export declare function isReferenceToLogicalModel(node: ast.FqnRef): boolean;
 /**
  * Returns true if node references deployment model

package/dist/utils/fqnRef.js

@@ -1,6 +1,12 @@
 import { AstUtils } from "langium";
 import { isNullish } from "remeda";
 import { ast } from "../ast.js";
+export function referenceableParent(node) {
+  while (node.parent) {
+    node = node.parent;
+  }
+  return node.value.ref ?? null;
+}
 export function instanceRef(deploymentRef) {
   let referenceable;
   while (referenceable = deploymentRef.value?.ref) {
@@ -25,11 +31,16 @@ export function deploymentNodeRef(deploymentRef) {
   const artifact = instanceRef(deploymentRef);
   return artifact ? AstUtils.getContainerOfType(artifact, ast.isDeploymentNode) ?? null : null;
 }
+export function importsRef(node) {
+  const referenceable = referenceableParent(node);
+  return referenceable?.$type === "Imported" ? referenceable : null;
+}
+export function isImportsRef(node) {
+  return !!importsRef(node);
+}
 export function isReferenceToLogicalModel(node) {
-  while (node.parent) {
-    node = node.parent;
-  }
-  return ast.isElement(node.value.ref);
+  const referenceable = referenceableParent(node);
+  return referenceable?.$type === "Element";
 }
 export function isReferenceToDeploymentModel(node) {
   let referenceable;

package/dist/utils/index.d.ts

@@ -3,3 +3,4 @@ export * from './elementRef';
 export * from './fqnRef';
 export * from './projectId';
 export * from './stringHash';
+export declare function safeCall<T>(fn: () => T): T | undefined;

package/dist/utils/index.js

@@ -1,5 +1,14 @@
+import { logger } from "../logger.js";
 export * from "./disposable.js";
 export * from "./elementRef.js";
 export * from "./fqnRef.js";
 export * from "./projectId.js";
 export * from "./stringHash.js";
+export function safeCall(fn) {
+  try {
+    return fn();
+  } catch (e) {
+    logger.debug(`Safe call failed`, { error: e });
+    return void 0;
+  }
+}

package/dist/utils/projectId.d.ts

@@ -1,3 +1,4 @@
 import { type ProjectId } from '@likec4/core';
 import { type AstNode, type LangiumDocument } from 'langium';
-export declare function projectIdFrom(value: AstNode | LangiumDocument): ProjectId;
+import { ast } from '../ast';
+export declare function projectIdFrom(value: AstNode | LangiumDocument | ast.ImportsFromPoject | ast.Imported): ProjectId;

package/dist/utils/projectId.js

@@ -1,6 +1,16 @@
-import { nonNullable } from "@likec4/core";
+import { invariant, nonNullable } from "@likec4/core";
 import { AstUtils, isAstNode } from "langium";
+import { ast } from "../ast.js";
 export function projectIdFrom(value) {
+  if (ast.isImported(value)) {
+    while (value.$type === "Imported" && value.$container) {
+      value = value.$container;
+    }
+    invariant(ast.isImportsFromPoject(value));
+  }
+  if (ast.isImportsFromPoject(value)) {
+    return value.project;
+  }
   const doc = isAstNode(value) ? AstUtils.getDocument(value) : value;
   return nonNullable(doc.likec4ProjectId, () => `Invalid state, document ${doc.uri} has no project ID assigned`);
 }

package/dist/validation/_shared.js

@@ -1,5 +1,5 @@
 import { isPromise } from "remeda";
-import { logWarnError } from "../logger.js";
+import { logger } from "../logger.js";
 export const RESERVED_WORDS = [
   "this",
   "it",
@@ -19,7 +19,7 @@ export function tryOrLog(fn) {
     } catch (e) {
       const message = e instanceof Error ? e.message : String(e);
       accept("error", `Validation failed: ${message}`, { node });
-      logWarnError(e);
+      logger.debug(`Validation failed: ${message}`, { error: e });
     }
   };
 }

package/dist/validation/deployment-checks.js

@@ -73,15 +73,6 @@ export const deployedInstanceChecks = (services) => {
 export const deploymentRelationChecks = (services) => {
   const ModelParser = services.likec4.ModelParser;
   return tryOrLog((el, accept) => {
-    const source = el.source?.value?.ref;
-    if (!source) {
-      let sourceCstText = el.source?.$cstNode?.text ?? "";
-      accept("error", `DeploymentRelation source '${sourceCstText}' not resolved`, {
-        node: el,
-        property: "source"
-      });
-      return;
-    }
     const target = el.target?.value?.ref;
     if (!target) {
       let targetCstText = el.target?.$cstNode?.text ?? "";
@@ -93,7 +84,23 @@ export const deploymentRelationChecks = (services) => {
     }
     const doc = getDocument(el);
     const parser = ModelParser.forDocument(doc);
-    const sourceFqnRef = parser.parseFqnRef(el.source);
+    let sourceFqnRef;
+    try {
+      sourceFqnRef = parser._resolveDeploymentRelationSource(el);
+    } catch (e) {
+      accept("error", "DeploymentRelation source not resolved", {
+        node: el,
+        property: "source"
+      });
+      return;
+    }
+    if (FqnRef.isImportRef(sourceFqnRef)) {
+      accept("error", "DeploymentRelation cannot refer imported model (not implemented yet)", {
+        node: el,
+        property: "source"
+      });
+      return;
+    }
     if (FqnRef.isModelRef(sourceFqnRef)) {
       accept("error", "DeploymentRelation must refer deployment element", {
         node: el,
@@ -102,6 +109,13 @@ export const deploymentRelationChecks = (services) => {
       return;
     }
     const targetFqnRef = parser.parseFqnRef(el.target);
+    if (FqnRef.isImportRef(targetFqnRef)) {
+      accept("error", "DeploymentRelation cannot refer imported model (not implemented yet)", {
+        node: el,
+        property: "target"
+      });
+      return;
+    }
     if (FqnRef.isModelRef(targetFqnRef)) {
       accept("error", "DeploymentRelation must refer deployment element", {
         node: el,

package/dist/validation/element-ref.d.ts

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

package/dist/validation/element-ref.js

@@ -0,0 +1,12 @@
+import { isReferenceToDeploymentModel } from "../utils/index.js";
+import { tryOrLog } from "./_shared.js";
+export const checkElementRef = (services) => {
+  return tryOrLog((el, accept) => {
+    if (isReferenceToDeploymentModel(el.modelElement)) {
+      accept("error", "Only model elements allowed here", {
+        node: el,
+        property: "modelElement"
+      });
+    }
+  });
+};

package/dist/validation/element.d.ts

@@ -1,4 +1,4 @@
 import { type ValidationCheck } from 'langium';
 import type { ast } from '../ast';
 import type { LikeC4Services } from '../module';
-export declare const elementChecks: (services: LikeC4Services) => ValidationCheck<ast.Element>;
+export declare const checkElement: (services: LikeC4Services) => ValidationCheck<ast.Element>;

package/dist/validation/element.js

@@ -2,7 +2,7 @@ import { AstUtils } from "langium";
 import { projectIdFrom } from "../utils/index.js";
 import { RESERVED_WORDS, tryOrLog } from "./_shared.js";
 const { getDocument } = AstUtils;
-export const elementChecks = (services) => {
+export const checkElement = (services) => {
   const fqnIndex = services.likec4.FqnIndex;
   const locator = services.workspace.AstNodeLocator;
   return tryOrLog((el, accept) => {

package/dist/validation/imports.d.ts

@@ -0,0 +1,5 @@
+import { type ValidationCheck } from 'langium';
+import type { ast } from '../ast';
+import type { LikeC4Services } from '../module';
+export declare const checkImportsFromPoject: (services: LikeC4Services) => ValidationCheck<ast.ImportsFromPoject>;
+export declare const checkImported: (services: LikeC4Services) => ValidationCheck<ast.Imported>;