@likec4/language-server 1.19.0 → 1.19.2

package/dist/index.d.ts

@@ -4,6 +4,7 @@ export { logger as lspLogger, setLogLevel } from './logger';
 export type { DocumentParser, LikeC4ModelBuilder, LikeC4ModelLocator, LikeC4ModelParser } from './model';
 export { createCustomLanguageServices, createLanguageServices, LikeC4Module } from './module';
 export type { LikeC4Services, LikeC4SharedServices } from './module';
+export type { LikeC4Views } from './views';
 export { LikeC4FileSystem };
 export declare function startLanguageServer(): {
     shared: LikeC4SharedServices;

package/dist/index.js

@@ -1,13 +1,14 @@
 import { startLanguageServer as startLanguim } from "langium/lsp";
 import { createConnection, ProposedFeatures } from "vscode-languageserver/node";
 import { LikeC4FileSystem } from "./LikeC4FileSystem.js";
-import { createLanguageServices } from "./module.js";
+import { createCustomLanguageServices } from "./module.js";
+import { ConfigurableLayouter } from "./views/configurable-layouter.js";
 export { logger as lspLogger, setLogLevel } from "./logger.js";
 export { createCustomLanguageServices, createLanguageServices, LikeC4Module } from "./module.js";
 export { LikeC4FileSystem };
 export function startLanguageServer() {
   const connection = createConnection(ProposedFeatures.all);
-  const services = createLanguageServices({ connection, ...LikeC4FileSystem });
+  const services = createCustomLanguageServices({ connection, ...LikeC4FileSystem }, ConfigurableLayouter);
   startLanguim(services.shared);
   return services;
 }

package/dist/like-c4.langium

@@ -620,10 +620,13 @@ DeploymentViewRulePredicateExpression:
 ;
 
 ExpressionV2:
-  RelationExpr |
+  RelationPredicateOrWhereV2 |
   FqnExpr
 ;
 
+RelationPredicateOrWhereV2:
+  RelationExpr ({infer RelationPredicateWhereV2.subject=current} 'where' where=WhereRelationExpression?)?
+;
 
 FqnExpr:
   {infer WildcardExpression} isWildcard?='*' |

package/dist/lsp/DocumentSymbolProvider.d.ts

@@ -1,16 +1,22 @@
 import { type AstNode, type MaybePromise } from 'langium';
 import type { DocumentSymbolProvider, NodeKindProvider } from 'langium/lsp';
 import { type DocumentSymbol, SymbolKind } from 'vscode-languageserver-types';
-import { ast, type LikeC4LangiumDocument } from '../ast';
+import { type LikeC4LangiumDocument, ast } from '../ast';
+import type { LikeC4ModelLocator, LikeC4ModelParser } from '../model';
 import type { LikeC4Services } from '../module';
+import type { LikeC4NameProvider } from '../references';
 export declare class LikeC4DocumentSymbolProvider implements DocumentSymbolProvider {
     private services;
     protected readonly nodeKindProvider: NodeKindProvider;
+    protected readonly nameProvider: LikeC4NameProvider;
+    protected readonly parser: LikeC4ModelParser;
+    protected readonly locator: LikeC4ModelLocator;
     constructor(services: LikeC4Services);
-    getSymbols({ parseResult: { value: { specifications, models, views, likec4lib } } }: LikeC4LangiumDocument): MaybePromise<DocumentSymbol[]>;
+    getSymbols({ parseResult: { value: { specifications, models, deployments, views, likec4lib }, }, }: LikeC4LangiumDocument): MaybePromise<DocumentSymbol[]>;
     protected getLikec4LibSymbol(astLib: ast.LikeC4Lib): DocumentSymbol[];
     protected getSpecSymbol(astSpec: ast.SpecificationRule): DocumentSymbol[];
     protected getModelSymbol(astModel: ast.Model): DocumentSymbol[];
+    protected getDeploymentModelSymbol(astModel: ast.ModelDeployments): DocumentSymbol[];
     protected getElementsSymbol(el: ast.Element | ast.Relation | ast.ExtendElement): DocumentSymbol[];
     protected getExtendElementSymbol(astElement: ast.ExtendElement): DocumentSymbol[];
     protected getElementSymbol(astElement: ast.Element): DocumentSymbol[];
@@ -19,5 +25,8 @@ export declare class LikeC4DocumentSymbolProvider implements DocumentSymbolProvi
     protected getTagSymbol(astTag: ast.SpecificationTag): DocumentSymbol | null;
     protected getLibIconSymbol(astTag: ast.LibIcon): DocumentSymbol | null;
     protected getViewSymbol(astView: ast.LikeC4View): DocumentSymbol[];
+    protected getDeploymentElementSymbol(el: ast.DeploymentElement | ast.DeploymentRelation): DocumentSymbol[];
+    protected getDeploymentNodeSymbol(astElement: ast.DeploymentNode): DocumentSymbol[];
+    protected getDeployedInstanceSymbol(astElement: ast.DeployedInstance): DocumentSymbol[];
     protected symbolKind(node: AstNode): SymbolKind;
 }

package/dist/lsp/DocumentSymbolProvider.js

@@ -1,31 +1,38 @@
 import { nonexhaustive } from "@likec4/core";
-import { GrammarUtils } from "langium";
+import { AstUtils, GrammarUtils } from "langium";
 import { filter, isEmpty, isTruthy, map, pipe } from "remeda";
 import { SymbolKind } from "vscode-languageserver-types";
 import { ast } from "../ast.js";
-import { logError } from "../logger.js";
+import { logWarnError } from "../logger.js";
 import { getFqnElementRef } from "../utils/elementRef.js";
 export class LikeC4DocumentSymbolProvider {
   constructor(services) {
     this.services = services;
     this.nodeKindProvider = services.shared.lsp.NodeKindProvider;
+    this.parser = services.likec4.ModelParser;
+    this.locator = services.likec4.ModelLocator;
+    this.nameProvider = services.references.NameProvider;
   }
   nodeKindProvider;
+  nameProvider;
+  parser;
+  locator;
   getSymbols({
     parseResult: {
-      value: { specifications, models, views, likec4lib }
+      value: { specifications, models, deployments, views, likec4lib }
     }
   }) {
     return [
       ...likec4lib.map((l) => () => this.getLikec4LibSymbol(l)),
       ...specifications.map((s) => () => this.getSpecSymbol(s)),
       ...models.map((s) => () => this.getModelSymbol(s)),
+      ...deployments.map((s) => () => this.getDeploymentModelSymbol(s)),
       ...views.map((s) => () => this.getModelViewsSymbol(s))
     ].flatMap((fn) => {
       try {
         return fn() ?? [];
       } catch (e) {
-        logError(e);
+        logWarnError(e);
         return [];
       }
     });
@@ -61,7 +68,7 @@ export class LikeC4DocumentSymbolProvider {
             return this.getTagSymbol(nd);
           }
         } catch (e) {
-          logError(e);
+          logWarnError(e);
           return null;
         }
         nonexhaustive(nd);
@@ -94,6 +101,21 @@ export class LikeC4DocumentSymbolProvider {
       }
     ];
   }
+  getDeploymentModelSymbol(astModel) {
+    const cstModel = astModel.$cstNode;
+    if (!cstModel) return [];
+    const nameNode = GrammarUtils.findNodeForProperty(cstModel, "name");
+    if (!nameNode) return [];
+    return [
+      {
+        kind: this.symbolKind(astModel),
+        name: astModel.name,
+        range: cstModel.range,
+        selectionRange: nameNode.range,
+        children: astModel.elements.flatMap((e) => this.getDeploymentElementSymbol(e))
+      }
+    ];
+  }
   getElementsSymbol(el) {
     try {
       if (ast.isExtendElement(el)) {
@@ -103,7 +125,7 @@ export class LikeC4DocumentSymbolProvider {
         return this.getElementSymbol(el);
       }
     } catch (e) {
-      logError(e);
+      logWarnError(e);
     }
     return [];
   }
@@ -196,6 +218,56 @@ export class LikeC4DocumentSymbolProvider {
       }
     ];
   }
+  getDeploymentElementSymbol(el) {
+    try {
+      if (ast.isDeploymentNode(el)) {
+        return this.getDeploymentNodeSymbol(el);
+      }
+      if (ast.isDeployedInstance(el)) {
+        return this.getDeployedInstanceSymbol(el);
+      }
+    } catch (e) {
+      logWarnError(e);
+    }
+    return [];
+  }
+  getDeploymentNodeSymbol(astElement) {
+    const cst = astElement.$cstNode;
+    const nameNode = this.nameProvider.getNameNode(astElement);
+    if (!nameNode || !cst) return [];
+    const name = this.nameProvider.getNameStrict(astElement);
+    const kind = astElement.kind.$refText;
+    const detail = kind;
+    return [
+      {
+        kind: this.symbolKind(astElement),
+        name,
+        range: cst.range,
+        selectionRange: nameNode.range,
+        detail,
+        children: astElement.body?.elements.flatMap((e) => this.getDeploymentElementSymbol(e)) ?? []
+      }
+    ];
+  }
+  getDeployedInstanceSymbol(astElement) {
+    const cst = astElement.$cstNode;
+    const nameNode = this.nameProvider.getNameNode(astElement);
+    if (!nameNode || !cst) return [];
+    const doc = AstUtils.getDocument(astElement);
+    const instance = this.parser.forDocument(doc).parseDeployedInstance(astElement);
+    const name = this.nameProvider.getNameStrict(astElement);
+    const detail = "instance of " + instance.element;
+    return [
+      {
+        kind: this.symbolKind(astElement),
+        name,
+        range: cst.range,
+        selectionRange: nameNode.range,
+        detail,
+        children: []
+      }
+    ];
+  }
   symbolKind(node) {
     return this.nodeKindProvider.getSymbolKind(node);
   }

package/dist/model/fqn-computation.js

@@ -1,4 +1,4 @@
-import { AsFqn, nonexhaustive } from "@likec4/core";
+import { AsFqn, LinkedList, nonexhaustive } from "@likec4/core";
 import { AstUtils, CstUtils, GrammarUtils, MultiMap } from "langium";
 import { isDefined, isEmpty } from "remeda";
 import { ast, ElementOps } from "../ast.js";
@@ -29,7 +29,7 @@ export function computeDocumentFqn(document, services) {
     return;
   }
   const locator = services.workspace.AstNodeLocator;
-  const traverseStack = elements.map((el) => [el, null]);
+  const traverseStack = LinkedList.from(elements.map((el) => [el, null]));
   let pair;
   while (pair = traverseStack.shift()) {
     try {

package/dist/model/model-builder.js

@@ -33,7 +33,7 @@ import {
   values
 } from "remeda";
 import { isParsedLikeC4LangiumDocument } from "../ast.js";
-import { logError, logger, logWarnError } from "../logger.js";
+import { logger, logWarnError } from "../logger.js";
 import { assignNavigateTo, resolveRelativePaths } from "../view-utils/index.js";
 function buildModel(services, docs) {
   const c4Specification = {
@@ -542,7 +542,7 @@ export class LikeC4ModelBuilder {
         }
         const result = LikeC4Model.makeCompute(model)(view);
         if (!result.isSuccess) {
-          logError(result.error);
+          logWarnError(result.error);
           return null;
         }
         let computedView = result.view;
@@ -588,7 +588,7 @@ export class LikeC4ModelBuilder {
       try {
         listener(docs);
       } catch (e) {
-        logError(e);
+        logWarnError(e);
       }
     }
   }

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

@@ -60,6 +60,7 @@ declare const DocumentParserFromMixins: {
         parseFqnExpr(astNode: import("../generated/ast").FqnExpr): invariant;
         parseFqnRefExpr(astNode: import("../generated/ast").FqnRefExpr): invariant;
         parseFqnExpressions(astNode: import("../generated/ast").FqnExpressions): invariant[];
+        parseRelationWhereExpr(astNode: import("../generated/ast").RelationPredicateWhereV2): invariant;
         parseRelationExpr(astNode: import("../generated/ast").RelationExpr): invariant;
         parseDeployment(): void;
         parseDeploymentNode(astNode: import("../generated/ast").DeploymentNode): import("../ast").ParsedAstDeployment.Node;
@@ -117,6 +118,7 @@ declare const DocumentParserFromMixins: {
         parseFqnExpr(astNode: import("../generated/ast").FqnExpr): invariant;
         parseFqnRefExpr(astNode: import("../generated/ast").FqnRefExpr): invariant;
         parseFqnExpressions(astNode: import("../generated/ast").FqnExpressions): invariant[];
+        parseRelationWhereExpr(astNode: import("../generated/ast").RelationPredicateWhereV2): invariant;
         parseRelationExpr(astNode: import("../generated/ast").RelationExpr): invariant;
         parseDeployment(): void;
         parseDeploymentNode(astNode: import("../generated/ast").DeploymentNode): import("../ast").ParsedAstDeployment.Node;
@@ -183,6 +185,7 @@ declare const DocumentParserFromMixins: {
         parseFqnExpr(astNode: import("../generated/ast").FqnExpr): invariant;
         parseFqnRefExpr(astNode: import("../generated/ast").FqnRefExpr): invariant;
         parseFqnExpressions(astNode: import("../generated/ast").FqnExpressions): invariant[];
+        parseRelationWhereExpr(astNode: import("../generated/ast").RelationPredicateWhereV2): invariant;
         parseRelationExpr(astNode: import("../generated/ast").RelationExpr): invariant;
         isValid: import("../validation").IsValidFn;
         readonly services: LikeC4Services;
@@ -215,6 +218,7 @@ declare const DocumentParserFromMixins: {
         parseFqnExpr(astNode: import("../generated/ast").FqnExpr): invariant;
         parseFqnRefExpr(astNode: import("../generated/ast").FqnRefExpr): invariant;
         parseFqnExpressions(astNode: import("../generated/ast").FqnExpressions): invariant[];
+        parseRelationWhereExpr(astNode: import("../generated/ast").RelationPredicateWhereV2): invariant;
         parseRelationExpr(astNode: import("../generated/ast").RelationExpr): invariant;
         isValid: import("../validation").IsValidFn;
         readonly services: LikeC4Services;
@@ -261,6 +265,7 @@ declare const DocumentParserFromMixins: {
         parseFqnExpr(astNode: import("../generated/ast").FqnExpr): invariant;
         parseFqnRefExpr(astNode: import("../generated/ast").FqnRefExpr): invariant;
         parseFqnExpressions(astNode: import("../generated/ast").FqnExpressions): invariant[];
+        parseRelationWhereExpr(astNode: import("../generated/ast").RelationPredicateWhereV2): invariant;
         parseRelationExpr(astNode: import("../generated/ast").RelationExpr): invariant;
         isValid: import("../validation").IsValidFn;
         readonly services: LikeC4Services;

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

@@ -12,6 +12,7 @@ export declare function DeploymentModelParser<TBase extends WithExpressionV2>(B:
         parseFqnExpr(astNode: ast.FqnExpr): c4.FqnExpr;
         parseFqnRefExpr(astNode: ast.FqnRefExpr): c4.FqnExpr.NonWildcard;
         parseFqnExpressions(astNode: ast.FqnExpressions): c4.FqnExpr[];
+        parseRelationWhereExpr(astNode: ast.RelationPredicateWhereV2): c4.RelationExpr;
         parseRelationExpr(astNode: ast.RelationExpr): c4.RelationExpr;
         isValid: import("../../validation").IsValidFn;
         readonly services: import("../..").LikeC4Services;

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

@@ -1,5 +1,5 @@
 import type * as c4 from '@likec4/core';
-import { ast, type ParsedAstDeploymentView } from '../../ast';
+import { type ParsedAstDeploymentView, ast } from '../../ast';
 import type { WithDeploymentModel } from './DeploymentModelParser';
 import type { WithExpressionV2 } from './FqnRefParser';
 export type WithDeploymentView = ReturnType<typeof DeploymentViewParser>;
@@ -13,6 +13,7 @@ export declare function DeploymentViewParser<TBase extends WithExpressionV2 & Wi
         parseFqnExpr(astNode: ast.FqnExpr): c4.FqnExpr;
         parseFqnRefExpr(astNode: ast.FqnRefExpr): c4.FqnExpr.NonWildcard;
         parseFqnExpressions(astNode: ast.FqnExpressions): c4.FqnExpr[];
+        parseRelationWhereExpr(astNode: ast.RelationPredicateWhereV2): c4.RelationExpr;
         parseRelationExpr(astNode: ast.RelationExpr): c4.RelationExpr;
         isValid: import("../../validation").IsValidFn;
         readonly services: import("../..").LikeC4Services;

package/dist/model/parser/DeploymentViewParser.js

@@ -70,6 +70,9 @@ export function DeploymentViewParser(B) {
               case ast.isRelationExpr(expr):
                 exprs.unshift(this.parseRelationExpr(expr));
                 break;
+              case ast.isRelationPredicateWhereV2(expr):
+                exprs.unshift(this.parseRelationWhereExpr(expr));
+                break;
               default:
                 nonexhaustive(expr);
             }

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

@@ -8,6 +8,7 @@ export declare function ExpressionV2Parser<TBase extends Base>(B: TBase): {
         parseFqnExpr(astNode: ast.FqnExpr): c4.FqnExpr;
         parseFqnRefExpr(astNode: ast.FqnRefExpr): c4.FqnExpr.NonWildcard;
         parseFqnExpressions(astNode: ast.FqnExpressions): c4.FqnExpr[];
+        parseRelationWhereExpr(astNode: ast.RelationPredicateWhereV2): c4.RelationExpr;
         parseRelationExpr(astNode: ast.RelationExpr): c4.RelationExpr;
         isValid: import("../../validation").IsValidFn;
         readonly services: import("../..").LikeC4Services;

package/dist/model/parser/FqnRefParser.js

@@ -3,6 +3,7 @@ import { isNonNullish } from "remeda";
 import { ast } from "../../ast.js";
 import { logWarnError } from "../../logger.js";
 import { instanceRef } from "../../utils/fqnRef.js";
+import { parseWhereClause } from "../model-parser-where.js";
 export function ExpressionV2Parser(B) {
   return class ExpressionV2Parser extends B {
     parseFqnRef(astNode) {
@@ -79,7 +80,19 @@ export function ExpressionV2Parser(B) {
       }
       return exprs.reverse();
     }
+    parseRelationWhereExpr(astNode) {
+      return {
+        where: {
+          expr: this.parseRelationExpr(astNode.subject),
+          condition: astNode.where ? parseWhereClause(astNode.where) : {
+            kind: { neq: "--always-true--" }
+          }
+        }
+      };
+    }
     parseRelationExpr(astNode) {
+      if (ast.isRelationPredicateWhere(astNode)) {
+      }
       if (ast.isDirectedRelationExpr(astNode)) {
         return {
           source: this.parseFqnExpr(astNode.source.from),

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

@@ -57,6 +57,7 @@ export declare function GlobalsParser<TBase extends WithViewsParser>(B: TBase):
         parseFqnExpr(astNode: ast.FqnExpr): c4.FqnExpr;
         parseFqnRefExpr(astNode: ast.FqnRefExpr): c4.FqnExpr.NonWildcard;
         parseFqnExpressions(astNode: ast.FqnExpressions): c4.FqnExpr[];
+        parseRelationWhereExpr(astNode: ast.RelationPredicateWhereV2): c4.RelationExpr;
         parseRelationExpr(astNode: ast.RelationExpr): c4.RelationExpr;
         parseDeployment(): void;
         parseDeploymentNode(astNode: ast.DeploymentNode): import("../../ast").ParsedAstDeployment.Node;

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

@@ -55,6 +55,7 @@ export declare function ViewsParser<TBase extends WithPredicates & WithDeploymen
         parseFqnExpr(astNode: ast.FqnExpr): c4.FqnExpr;
         parseFqnRefExpr(astNode: ast.FqnRefExpr): c4.FqnExpr.NonWildcard;
         parseFqnExpressions(astNode: ast.FqnExpressions): c4.FqnExpr[];
+        parseRelationWhereExpr(astNode: ast.RelationPredicateWhereV2): c4.RelationExpr;
         parseRelationExpr(astNode: ast.RelationExpr): c4.RelationExpr;
         parseDeployment(): void;
         parseDeploymentNode(astNode: ast.DeploymentNode): import("../../ast").ParsedAstDeployment.Node;

package/dist/module.d.ts

@@ -1,11 +1,14 @@
+import { GraphvizLayouter } from '@likec4/layouts';
 import { type Module, DocumentCache, WorkspaceCache } from 'langium';
 import { type DefaultSharedModuleContext, type LangiumServices, type LangiumSharedServices, type PartialLangiumServices } from 'langium/lsp';
+import { LikeC4DocumentationProvider } from './documentation';
 import { LikeC4CodeLensProvider, LikeC4CompletionProvider, LikeC4DocumentHighlightProvider, LikeC4DocumentLinkProvider, LikeC4DocumentSymbolProvider, LikeC4HoverProvider, LikeC4SemanticTokenProvider } from './lsp';
 import { DeploymentsIndex, FqnIndex, LikeC4ModelBuilder, LikeC4ModelLocator, LikeC4ModelParser } from './model';
 import { LikeC4ModelChanges } from './model-change/ModelChanges';
 import { LikeC4NameProvider, LikeC4ScopeComputation, LikeC4ScopeProvider } from './references';
 import { Rpc } from './Rpc';
 import { LikeC4WorkspaceManager, NodeKindProvider, WorkspaceSymbolProvider } from './shared';
+import { LikeC4Views } from './views';
 interface LikeC4AddedSharedServices {
     lsp: {
         NodeKindProvider: NodeKindProvider;
@@ -20,10 +23,15 @@ export type LikeC4SharedServices = LangiumSharedServices & LikeC4AddedSharedServ
  * Declaration of custom services - add your own service classes here.
  */
 export interface LikeC4AddedServices {
+    documentation: {
+        DocumentationProvider: LikeC4DocumentationProvider;
+    };
     WorkspaceCache: WorkspaceCache<string, any>;
     DocumentCache: DocumentCache<string, any>;
     Rpc: Rpc;
     likec4: {
+        Views: LikeC4Views;
+        Layouter: GraphvizLayouter;
         DeploymentsIndex: DeploymentsIndex;
         FqnIndex: FqnIndex;
         ModelParser: LikeC4ModelParser;
@@ -50,7 +58,7 @@ export interface LikeC4AddedServices {
 export type LikeC4Services = LangiumServices & LikeC4AddedServices;
 export declare const LikeC4Module: Module<LikeC4Services, PartialLangiumServices & LikeC4AddedServices>;
 export type LanguageServicesContext = Partial<DefaultSharedModuleContext>;
-export declare function createCustomLanguageServices<I1, I2, I3, I extends I1 & I2 & I3 & LikeC4Services>(context: LanguageServicesContext, module: Module<I, I1>, module2?: Module<I, I2>, module3?: Module<I, I3>): {
+export declare function createCustomLanguageServices<I1, I2, I3, I extends I1 & I2 & I3 & LikeC4Services>(context: LanguageServicesContext, module?: Module<I, I1>, module2?: Module<I, I2>, module3?: Module<I, I3>): {
     shared: LikeC4SharedServices;
     likec4: I;
 };

package/dist/module.js

@@ -1,11 +1,21 @@
-import { DocumentCache, EmptyFileSystem, inject, WorkspaceCache } from "langium";
+import { GraphvizLayouter, GraphvizWasmAdapter } from "@likec4/layouts";
+import {
+  DocumentCache,
+  EmptyFileSystem,
+  inject,
+  WorkspaceCache
+} from "langium";
 import {
   createDefaultModule,
   createDefaultSharedModule
 } from "langium/lsp";
+import { LikeC4DocumentationProvider } from "./documentation/index.js";
 import { LikeC4Formatter } from "./formatting/LikeC4Formatter.js";
-import { LikeC4GeneratedModule, LikeC4GeneratedSharedModule } from "./generated/module.js";
-import { logToLspConnection } from "./logger.js";
+import {
+  LikeC4GeneratedModule,
+  LikeC4GeneratedSharedModule
+} from "./generated/module.js";
+import { logger, logToLspConnection } from "./logger.js";
 import {
   LikeC4CodeLensProvider,
   LikeC4CompletionProvider,
@@ -15,12 +25,27 @@ import {
   LikeC4HoverProvider,
   LikeC4SemanticTokenProvider
 } from "./lsp/index.js";
-import { DeploymentsIndex, FqnIndex, LikeC4ModelBuilder, LikeC4ModelLocator, LikeC4ModelParser } from "./model/index.js";
+import {
+  DeploymentsIndex,
+  FqnIndex,
+  LikeC4ModelBuilder,
+  LikeC4ModelLocator,
+  LikeC4ModelParser
+} from "./model/index.js";
 import { LikeC4ModelChanges } from "./model-change/ModelChanges.js";
-import { LikeC4NameProvider, LikeC4ScopeComputation, LikeC4ScopeProvider } from "./references/index.js";
+import {
+  LikeC4NameProvider,
+  LikeC4ScopeComputation,
+  LikeC4ScopeProvider
+} from "./references/index.js";
 import { Rpc } from "./Rpc.js";
-import { LikeC4WorkspaceManager, NodeKindProvider, WorkspaceSymbolProvider } from "./shared/index.js";
+import {
+  LikeC4WorkspaceManager,
+  NodeKindProvider,
+  WorkspaceSymbolProvider
+} from "./shared/index.js";
 import { registerValidationChecks } from "./validation/index.js";
+import { LikeC4Views } from "./views/index.js";
 const LikeC4SharedModule = {
   lsp: {
     NodeKindProvider: (services) => new NodeKindProvider(services),
@@ -34,10 +59,18 @@ function bind(Type) {
   return (services) => new Type(services);
 }
 export const LikeC4Module = {
+  documentation: {
+    DocumentationProvider: bind(LikeC4DocumentationProvider)
+  },
   WorkspaceCache: (services) => new WorkspaceCache(services.shared),
   DocumentCache: (services) => new DocumentCache(services.shared),
   Rpc: bind(Rpc),
   likec4: {
+    Layouter: (_services) => {
+      logger.debug("Creating GraphvizLayouter with GraphvizWasmAdapter");
+      return new GraphvizLayouter(new GraphvizWasmAdapter());
+    },
+    Views: bind(LikeC4Views),
     DeploymentsIndex: bind(DeploymentsIndex),
     ModelChanges: bind(LikeC4ModelChanges),
     FqnIndex: bind(FqnIndex),
@@ -98,10 +131,16 @@ export function createSharedServices(context = {}) {
 }
 export function createLanguageServices(context = {}) {
   const shared = createSharedServices(context);
-  const likec4 = inject(createDefaultModule({ shared }), LikeC4GeneratedModule, LikeC4Module);
+  const likec4 = inject(
+    createDefaultModule({ shared }),
+    LikeC4GeneratedModule,
+    LikeC4Module
+  );
   shared.ServiceRegistry.register(likec4);
   registerValidationChecks(likec4);
-  if (context.connection) {
+  if (!context.connection) {
+    shared.workspace.ConfigurationProvider.initialized({});
+  } else {
     likec4.Rpc.init();
   }
   return { shared, likec4 };

package/dist/protocol.d.ts

@@ -1,4 +1,4 @@
-import type { ComputedLikeC4Model, ComputedView, Fqn, ParsedLikeC4Model, RelationId, ViewChange, ViewId } from '@likec4/core';
+import type { ComputedLikeC4Model, ComputedView, DiagramView, Fqn, ParsedLikeC4Model, RelationId, ViewChange, ViewId } from '@likec4/core';
 import { NotificationType, RequestType, RequestType0 } from 'vscode-jsonrpc';
 import type { DocumentUri, Location } from 'vscode-languageserver-types';
 export declare const onDidChangeModel: NotificationType<string>;
@@ -19,11 +19,29 @@ export declare const computeView: RequestType<{
     view: ComputedView | null;
 }, void>;
 export type ComputeViewRequest = typeof computeView;
+/**
+ * Request to layout a view.
+ */
+export declare const layoutView: RequestType<{
+    viewId: ViewId;
+}, {
+    result: {
+        dot: string;
+        diagram: DiagramView;
+    } | null;
+}, void>;
+export type LayoutViewRequest = typeof layoutView;
+/**
+ * Request to build documents.
+ */
 export interface BuildDocumentsParams {
     docs: DocumentUri[];
 }
 export declare const buildDocuments: RequestType<BuildDocumentsParams, void, void>;
 export type BuildDocumentsRequest = typeof buildDocuments;
+/**
+ * Request to locate an element, relation, deployment or view.
+ */
 export type LocateParams = {
     element: Fqn;
     property?: string;

package/dist/protocol.js

@@ -9,6 +9,7 @@ export const fetchComputedModel = new RequestType(
 export const computeView = new RequestType(
   "likec4/computeView"
 );
+export const layoutView = new RequestType("likec4/layout-view");
 export const buildDocuments = new RequestType("likec4/build");
 export const locate = new RequestType("likec4/locate");
 export const changeView = new RequestType("likec4/change-view");

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

@@ -1,6 +1,6 @@
-import { type AstNodeDescription, DefaultScopeComputation, type PrecomputedScopes } from 'langium';
+import { type AstNodeDescription, type PrecomputedScopes, DefaultScopeComputation } from 'langium';
 import type { CancellationToken } from 'vscode-languageserver';
-import { ast, type LikeC4LangiumDocument } from '../ast';
+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;

package/dist/references/scope-computation.js

@@ -5,7 +5,7 @@ import {
 } from "langium";
 import { entries, filter, flatMap, forEachObj, groupBy, isNullish, isTruthy, pipe } from "remeda";
 import { ast } from "../ast.js";
-import { logError, logWarnError } from "../logger.js";
+import { logWarnError } from "../logger.js";
 function uniqueDescriptions(descs) {
   return pipe(
     descs,
@@ -29,7 +29,7 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
       this.exportGlobals(globals, docExports, document);
       this.exportDeployments(deployments, docExports, document);
     } catch (e) {
-      logError(e);
+      logWarnError(e);
     }
     return docExports;
   }
@@ -44,7 +44,7 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
           docExports.push(this.descriptions.createDescription(viewAst, viewAst.name, document));
         }
       } catch (e) {
-        logError(e);
+        logWarnError(e);
       }
     }
   }
@@ -59,7 +59,7 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
           docExports.push(this.descriptions.createDescription(id, id.name, document));
         }
       } catch (e) {
-        logError(e);
+        logWarnError(e);
       }
     }
     for (const globalStyleAst of globals.flatMap((g) => g.styles)) {
@@ -69,7 +69,7 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
           docExports.push(this.descriptions.createDescription(id, id.name, document));
         }
       } catch (e) {
-        logError(e);
+        logWarnError(e);
       }
     }
   }
@@ -83,7 +83,7 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
           docExports.push(this.descriptions.createDescription(elAst, elAst.name, document));
         }
       } catch (e) {
-        logError(e);
+        logWarnError(e);
       }
     }
   }
@@ -96,7 +96,7 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
         docExports.push(this.descriptions.createDescription(iconAst, iconAst.name, document));
       }
     } catch (e) {
-      logError(e);
+      logWarnError(e);
     }
   }
   exportSpecification(specifications, docExports, document) {
@@ -151,7 +151,7 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
             nonexhaustive(spec);
         }
       } catch (e) {
-        logError(e);
+        logWarnError(e);
       }
     }
   }
@@ -181,7 +181,7 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
             ...this.processContainer(model, scopes, document)
           );
         } catch (e) {
-          logError(e);
+          logWarnError(e);
         }
       }
       for (const deployment of root.deployments) {