@likec4/language-server 1.41.0 → 1.42.1

package/dist/references/scope-computation.mjs

@@ -27,8 +27,7 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
         views,
         globals,
         likec4lib,
-        deployments,
-        imports
+        deployments
       } = document.parseResult.value;
       this.exportLibrary(likec4lib, docExports, document);
       this.exportSpecification(specifications, docExports, document);
@@ -205,7 +204,7 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
           let imported = imports;
           while (imported) {
             descendants.push(
-              this.descriptions.createDescription(imported, imported.imported.$refText, document)
+              this.descriptions.createDescription(imported, imported.imported.$refText)
             );
             imported = imported.prev;
           }

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 { type AstNodeDescriptionWithFqn, ast } from '../ast';
+import { ast } from '../ast';
 import type { DeploymentsIndex, FqnIndex } from '../model';
 import type { LikeC4Services } from '../module';
 import type { IndexManager } from '../workspace';
@@ -10,7 +10,7 @@ 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<AstNodeDescriptionWithFqn>, void, any>;
+    protected genUniqueDescedants(of: () => ast.Element | ast.DeploymentNode | undefined): Generator<Stream<import("../ast").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;

package/dist/references/scope-provider.mjs

@@ -2,12 +2,10 @@ import { nonexhaustive } from "@likec4/core";
 import {
   AstUtils,
   DefaultScopeProvider,
-  DONE_RESULT,
   EMPTY_SCOPE,
   EMPTY_STREAM,
   MapScope,
   stream,
-  StreamImpl,
   StreamScope
 } from "langium";
 import { ast, isFqnRefInsideGlobals, isFqnRefInsideModel } from "../ast.mjs";
@@ -81,6 +79,14 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
   *genScopeExtendElement({ element }) {
     if (element.el.$nodeDescription) {
       yield element.el.$nodeDescription;
+      yield {
+        ...element.el.$nodeDescription,
+        name: "this"
+      };
+      yield {
+        ...element.el.$nodeDescription,
+        name: "it"
+      };
     }
     yield* this.genUniqueDescedants(() => elementRef(element));
   }
@@ -231,16 +237,3 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
     return this.getProjectScope(projectId, referenceType, context);
   }
 }
-function lazyStream(fn) {
-  return new StreamImpl(
-    () => {
-      return fn().iterator();
-    },
-    (iterator) => {
-      if (iterator) {
-        return iterator.next();
-      }
-      return DONE_RESULT;
-    }
-  );
-}

package/dist/test/testServices.d.ts

@@ -1,5 +1,6 @@
 import type { LikeC4ProjectJsonConfig } from '@likec4/config';
 import type { ComputedLikeC4ModelData } from '@likec4/core';
+import { type LangiumDocument } from 'langium';
 import type { LiteralUnion } from 'type-fest';
 import { URI } from 'vscode-uri';
 import type { LikeC4LangiumDocument } from '../ast';
@@ -9,6 +10,7 @@ export declare function createTestServices(options?: {
 }): {
     services: any;
     addDocument: (input: string, uri?: string) => Promise<LikeC4LangiumDocument>;
+    removeDocument: (doc: LangiumDocument | URI) => Promise<void>;
     parse: (input: string, uri?: string) => Promise<LikeC4LangiumDocument>;
     validate: (input: string | LikeC4LangiumDocument, uri?: string) => Promise<{
         document: LikeC4LangiumDocument;

package/dist/test/testServices.mjs

@@ -63,18 +63,18 @@ export function createTestServices(options) {
     langiumDocuments.addDocument(document);
     return document;
   };
+  const removeDocument = async (doc) => {
+    const uri = doc instanceof URI ? doc : doc.uri;
+    await documentBuilder.update([], [uri]);
+  };
   const parse = async (input, uri) => {
     const document = await addDocument(input, uri);
-    await services.shared.workspace.WorkspaceLock.write(async (_cancelToken) => {
-      await documentBuilder.build([document], { validation: false });
-    });
+    await documentBuilder.build([document], { validation: false });
     return document;
   };
   const validate = async (input, uri) => {
     const document = typeof input === "string" ? await addDocument(input, uri) : input;
-    await services.shared.workspace.WorkspaceLock.write(async (_cancelToken) => {
-      await documentBuilder.build([document], { validation: true });
-    });
+    await documentBuilder.build([document], { validation: true });
     const diagnostics = document.diagnostics ?? [];
     const warnings = diagnostics.flatMap((d) => d.severity === DiagnosticSeverity.Warning ? d.message : []);
     const errors = diagnostics.flatMap((d) => d.severity === DiagnosticSeverity.Error ? d.message : []);
@@ -86,10 +86,8 @@ export function createTestServices(options) {
     };
   };
   const format = async (input, uri) => {
-    const document = typeof input === "string" ? await parse(input, uri) : input;
-    await services.shared.workspace.WorkspaceLock.write(async (_cancelToken) => {
-      await documentBuilder.build([document], { validation: true });
-    });
+    const document = typeof input === "string" ? await parse(stripIndent(input), uri) : input;
+    await documentBuilder.build([document], { validation: true });
     const edits = await formatter?.formatDocument(
       document,
       {
@@ -137,6 +135,7 @@ export function createTestServices(options) {
   return {
     services,
     addDocument,
+    removeDocument,
     parse,
     validate,
     validateAll,
@@ -156,7 +155,7 @@ export async function createMultiProjectTestServices(data) {
   const projects = {};
   for (const [name, files] of entries(data)) {
     const folderUri = UriUtils.joinPath(URI.parse(workspace), "src", name);
-    services.shared.workspace.ProjectsManager.registerProject({
+    await services.shared.workspace.ProjectsManager.registerProject({
       config: {
         name,
         exclude: ["node_modules"]

package/dist/utils/disposable.mjs

@@ -1,4 +1,4 @@
-import { logError } from "../logger.mjs";
+import { logWarnError } from "../logger.mjs";
 export class ADisposable {
   toDispose = [];
   isDisposed = false;
@@ -13,7 +13,7 @@ export class ADisposable {
       try {
         item.dispose();
       } catch (e) {
-        logError(e);
+        logWarnError(e);
       }
     }
   }

package/dist/utils/index.mjs

@@ -16,7 +16,7 @@ export function safeCall(fn) {
 export function performanceNow() {
   try {
     return performance.now();
-  } catch (e) {
+  } catch {
     return Date.now();
   }
 }

package/dist/validation/_shared.d.ts

@@ -1,3 +1,3 @@
-import { type AstNode, type ValidationCheck } from 'langium';
+import type { AstNode, ValidationCheck } from 'langium';
 export declare const RESERVED_WORDS: string[];
 export declare function tryOrLog<T extends AstNode>(fn: ValidationCheck<T>): ValidationCheck<T>;

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

@@ -4,4 +4,4 @@ import type { LikeC4Services } from '../module';
 export declare const deploymentNodeChecks: (services: LikeC4Services) => ValidationCheck<ast.DeploymentNode>;
 export declare const deployedInstanceChecks: (services: LikeC4Services) => ValidationCheck<ast.DeployedInstance>;
 export declare const deploymentRelationChecks: (services: LikeC4Services) => ValidationCheck<ast.DeploymentRelation>;
-export declare const extendDeploymentChecks: (services: LikeC4Services) => ValidationCheck<ast.ExtendDeployment>;
+export declare const extendDeploymentChecks: (_services: LikeC4Services) => ValidationCheck<ast.ExtendDeployment>;

package/dist/validation/deployment-checks.mjs

@@ -1,6 +1,8 @@
 import { FqnRef, isSameHierarchy, nonNullable } from "@likec4/core";
+import { loggable } from "@likec4/log";
 import { AstUtils } from "langium";
 import { ast } from "../ast.mjs";
+import { logger } from "../logger.mjs";
 import { projectIdFrom } from "../utils/index.mjs";
 import { RESERVED_WORDS, tryOrLog } from "./_shared.mjs";
 const { getDocument } = AstUtils;
@@ -88,6 +90,7 @@ export const deploymentRelationChecks = (services) => {
     try {
       sourceFqnRef = parser._resolveDeploymentRelationSource(el);
     } catch (e) {
+      logger.warn(loggable(e));
       accept("error", "DeploymentRelation source not resolved", {
         node: el,
         property: "source"
@@ -130,7 +133,7 @@ export const deploymentRelationChecks = (services) => {
     }
   });
 };
-export const extendDeploymentChecks = (services) => {
+export const extendDeploymentChecks = (_services) => {
   return tryOrLog((el, accept) => {
     const target = el.deploymentNode.value.ref;
     if (!target || !ast.isDeploymentNode(target)) {

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

@@ -1,5 +1,6 @@
 import { type ValidationCheck } from 'langium';
 import { ast } from '../ast';
 import type { LikeC4Services } from '../module';
-export declare const dynamicViewStep: (services: LikeC4Services) => ValidationCheck<ast.DynamicViewStep>;
-export declare const dynamicViewDisplayVariant: (services: LikeC4Services) => ValidationCheck<ast.DynamicViewDisplayVariantProperty>;
+export declare const dynamicViewStepSingle: (services: LikeC4Services) => ValidationCheck<ast.DynamicStepSingle>;
+export declare const dynamicViewStepChain: (services: LikeC4Services) => ValidationCheck<ast.DynamicStepChain>;
+export declare const dynamicViewDisplayVariant: (_services: LikeC4Services) => ValidationCheck<ast.DynamicViewDisplayVariantProperty>;

package/dist/validation/dynamic-view.mjs

@@ -4,7 +4,7 @@ import { isEmpty } from "remeda";
 import { ast } from "../ast.mjs";
 import { elementRef } from "../utils/elementRef.mjs";
 import { tryOrLog } from "./_shared.mjs";
-export const dynamicViewStep = (services) => {
+export const dynamicViewStepSingle = (services) => {
   const fqnIndex = services.likec4.FqnIndex;
   return tryOrLog((el, accept) => {
     const sourceEl = elementRef(el.source);
@@ -30,7 +30,26 @@ export const dynamicViewStep = (services) => {
     }
   });
 };
-export const dynamicViewDisplayVariant = (services) => {
+export const dynamicViewStepChain = (services) => {
+  const fqnIndex = services.likec4.FqnIndex;
+  return tryOrLog((el, accept) => {
+    const source = el.source;
+    if (ast.isDynamicStepSingle(source) && source.isBackward) {
+      accept("error", "Invalid chain after backward step", {
+        node: el
+      });
+    }
+    const targetEl = elementRef(el.target);
+    const target = targetEl && fqnIndex.getFqn(targetEl);
+    if (!target) {
+      accept("error", "Target not found (not parsed/indexed yet)", {
+        node: el,
+        property: "target"
+      });
+    }
+  });
+};
+export const dynamicViewDisplayVariant = (_services) => {
   return tryOrLog((prop, accept) => {
     if (isEmpty(prop.value) || prop.value !== "diagram" && prop.value !== "sequence") {
       accept("error", 'Invalid display variant: "diagram" or "sequence" are allowed', {

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

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

package/dist/validation/element-ref.mjs

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

package/dist/validation/imports.d.ts

@@ -2,4 +2,3 @@ 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>;

package/dist/validation/imports.mjs

@@ -23,8 +23,3 @@ export const checkImportsFromPoject = (services) => {
     }
   });
 };
-export const checkImported = (services) => {
-  const fqnIndex = services.likec4.FqnIndex;
-  return tryOrLog((el, accept) => {
-  });
-};

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.HexColor | ast.RGBAColor | ast.DeployedInstance | ast.DeploymentNode | ast.DeploymentViewRulePredicate | ast.DeploymentViewRuleStyle | ast.ViewRuleAutoLayout | ast.DynamicViewDisplayVariantProperty | ast.LinkProperty | ast.ViewStringProperty | ast.DynamicViewGlobalPredicateRef | ast.DynamicViewIncludePredicate | ast.ViewRuleGlobalStyle | ast.ViewRuleStyle | ast.ElementStringProperty | ast.ElementStyleProperty | ast.IconProperty | ast.MetadataBody | 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.RelationStringProperty | ast.ArrowProperty | ast.ColorProperty | ast.LineProperty | ast.PaddingSizeProperty | ast.ShapeSizeProperty | ast.TextSizeProperty | ast.MetadataAttribute | ast.NotationProperty | ast.NotesProperty | ast.SpecificationElementStringProperty | ast.SpecificationRelationshipStringProperty | ast.BorderProperty | ast.MultipleProperty | ast.OpacityProperty | ast.ShapeProperty | ast.ViewRuleGlobalPredicateRef | ast.ViewRuleGroup | ast.ViewRulePredicate | ast.SpecificationRelationshipKind | ast.GlobalStyle | ast.SpecificationColor | ast.NavigateToProperty | ast.DynamicViewStep | ast.ElementRef | ast.DeploymentRelation | ast.Tags | ast.SpecificationDeploymentNodeKind | ast.DynamicViewParallelSteps | ast.GlobalDynamicPredicateGroup | ast.Relation | ast.SpecificationElementKind | ast.Globals | ast.GlobalPredicateGroup | ast.GlobalStyleGroup | ast.SpecificationTag | ast.ImportsFromPoject | ast.SpecificationRule;
+declare const isValidatableAstNode: (n: AstNode) => n is ast.HexColor | ast.RGBAColor | ast.DeployedInstance | ast.DeploymentNode | ast.DeploymentViewRulePredicate | ast.DeploymentViewRuleStyle | ast.ViewRuleAutoLayout | ast.DynamicViewDisplayVariantProperty | ast.LinkProperty | ast.ViewStringProperty | ast.DynamicViewGlobalPredicateRef | ast.DynamicViewIncludePredicate | ast.ViewRuleGlobalStyle | ast.ViewRuleStyle | ast.DynamicStepChain | ast.DynamicStepSingle | ast.ElementStringProperty | ast.ElementStyleProperty | ast.IconProperty | ast.MetadataBody | 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.RelationStringProperty | ast.ArrowProperty | ast.ColorProperty | ast.LineProperty | ast.PaddingSizeProperty | ast.ShapeSizeProperty | ast.TextSizeProperty | ast.MetadataAttribute | ast.NotationProperty | ast.NotesProperty | ast.SpecificationElementStringProperty | ast.SpecificationRelationshipStringProperty | ast.BorderProperty | ast.MultipleProperty | ast.OpacityProperty | ast.ShapeProperty | ast.ViewRuleGlobalPredicateRef | ast.ViewRuleGroup | ast.ViewRulePredicate | ast.DynamicViewParallelSteps | ast.ElementRef | ast.SpecificationRelationshipKind | ast.GlobalStyle | ast.SpecificationColor | ast.NavigateToProperty | ast.DeploymentRelation | ast.Tags | ast.SpecificationDeploymentNodeKind | ast.GlobalDynamicPredicateGroup | ast.Relation | ast.SpecificationElementKind | ast.Globals | ast.GlobalPredicateGroup | ast.GlobalStyleGroup | ast.SpecificationTag | ast.ImportsFromPoject | ast.SpecificationRule;
 type ValidatableAstNode = Guarded<typeof isValidatableAstNode>;
 export declare function checksFromDiagnostics(doc: LikeC4LangiumDocument): {
     isValid: (n: ValidatableAstNode) => boolean;

package/dist/validation/index.mjs

@@ -1,3 +1,5 @@
+import { onNextTick } from "@likec4/core/utils";
+import { loggable } from "@likec4/log";
 import { DocumentState } from "langium";
 import { isNullish } from "remeda";
 import { DiagnosticSeverity } from "vscode-languageserver-types";
@@ -9,10 +11,10 @@ import {
   deploymentRelationChecks,
   extendDeploymentChecks
 } from "./deployment-checks.mjs";
-import { dynamicViewDisplayVariant, dynamicViewStep } from "./dynamic-view.mjs";
+import { dynamicViewDisplayVariant, dynamicViewStepChain, dynamicViewStepSingle } from "./dynamic-view.mjs";
 import { checkElement } from "./element.mjs";
 import { checkElementRef } from "./element-ref.mjs";
-import { checkImported, checkImportsFromPoject } from "./imports.mjs";
+import { checkImportsFromPoject } from "./imports.mjs";
 import {
   colorLiteralRuleChecks,
   iconPropertyRuleChecks,
@@ -57,7 +59,8 @@ const isValidatableAstNode = validatableAstNodeGuards([
   ast.isFqnExpr,
   ast.isRelationExpr,
   ast.isDynamicViewParallelSteps,
-  ast.isDynamicViewStep,
+  ast.isDynamicStepChain,
+  ast.isDynamicStepSingle,
   ast.isDeploymentViewRule,
   ast.isDeploymentViewRulePredicate,
   ast.isExpressionV2,
@@ -141,7 +144,8 @@ export function registerValidationChecks(services) {
     GlobalPredicateGroup: checkGlobalPredicate(services),
     GlobalDynamicPredicateGroup: checkGlobalPredicate(services),
     GlobalStyleId: checkGlobalStyleId(services),
-    DynamicViewStep: dynamicViewStep(services),
+    DynamicStepSingle: dynamicViewStepSingle(services),
+    DynamicStepChain: dynamicViewStepChain(services),
     LikeC4View: viewChecks(services),
     Element: checkElement(services),
     ElementRef: checkElementRef(services),
@@ -155,20 +159,22 @@ export function registerValidationChecks(services) {
     IncomingRelationExpr: checkIncomingRelationExpr(services),
     OutgoingRelationExpr: checkOutgoingRelationExpr(services),
     ImportsFromPoject: checkImportsFromPoject(services),
-    Imported: checkImported(services),
+    // Imported: checkImported(services),
     ColorLiteral: colorLiteralRuleChecks(services),
     DynamicViewDisplayVariantProperty: dynamicViewDisplayVariant(services)
   });
   const connection = services.shared.lsp.Connection;
   if (connection) {
-    services.shared.workspace.DocumentBuilder.onUpdate((_, deleted) => {
-      for (const uri of deleted) {
-        logger.debug(`clear diagnostics for deleted ${uri.path}`);
-        void connection.sendDiagnostics({
-          uri: uri.toString(),
-          diagnostics: []
-        });
-      }
+    onNextTick(() => {
+      services.shared.workspace.DocumentBuilder.onUpdate((_, deleted) => {
+        for (const uri of deleted) {
+          logger.debug(`clear diagnostics for deleted ${uri.path}`);
+          connection.sendDiagnostics({
+            uri: uri.toString(),
+            diagnostics: []
+          }).catch((e) => logger.error(loggable(e)));
+        }
+      });
     });
   }
 }

package/dist/validation/view-predicates/relation-with.d.ts

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

package/dist/validation/view.d.ts

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

package/dist/view-utils/index.d.ts

@@ -1,2 +1 @@
 export * from './assignNavigateTo';
-export * from './resolve-relative-paths';

package/dist/view-utils/index.mjs

@@ -1,2 +1 @@
 export * from "./assignNavigateTo.mjs";
-export * from "./resolve-relative-paths.mjs";

package/dist/views/likec4-views.d.ts

@@ -44,6 +44,10 @@ export interface LikeC4Views {
 export declare class DefaultLikeC4Views implements LikeC4Views {
     private services;
     private cache;
+    /**
+     * Set of viewIds with reported errors
+     * value is `${projectId}-${viewId}`
+     */
     private viewsWithReportedErrors;
     private ModelBuilder;
     constructor(services: LikeC4Services);
@@ -57,5 +61,7 @@ export declare class DefaultLikeC4Views implements LikeC4Views {
      * Open a view in the preview panel.
      */
     openView(viewId: ViewId, projectId: ProjectId): Promise<void>;
+    private reportViewError;
+    private viewSucceed;
 }
 export {};

package/dist/views/likec4-views.mjs

@@ -1,6 +1,6 @@
 import { loggable } from "@likec4/log";
 import { values } from "remeda";
-import { logError, logger as rootLogger, logWarnError } from "../logger.mjs";
+import { logger as rootLogger, logWarnError } from "../logger.mjs";
 import { performanceMark } from "../utils/index.mjs";
 const viewsLogger = rootLogger.getChild("views");
 export class DefaultLikeC4Views {
@@ -9,6 +9,10 @@ export class DefaultLikeC4Views {
     this.ModelBuilder = services.likec4.ModelBuilder;
   }
   cache = /* @__PURE__ */ new WeakMap();
+  /**
+   * Set of viewIds with reported errors
+   * value is `${projectId}-${viewId}`
+   */
   viewsWithReportedErrors = /* @__PURE__ */ new Set();
   ModelBuilder;
   get layouter() {
@@ -25,10 +29,11 @@ export class DefaultLikeC4Views {
       return [];
     }
     const m0 = performanceMark();
-    const logger = projectId ? viewsLogger.getChild(projectId) : viewsLogger;
+    projectId ??= likeC4Model.project.id;
+    const logger = viewsLogger.getChild(projectId);
     logger.debug`layoutAll: ${views.length} views`;
     const tasks = [];
-    const specification = likeC4Model.$data.specification;
+    const styles = likeC4Model.$styles;
     const results = [];
     for (const view of views) {
       let cached = this.cache.get(view);
@@ -39,15 +44,14 @@ export class DefaultLikeC4Views {
       }
       tasks.push({
         view,
-        specification
+        styles
       });
     }
     if (tasks.length > 0) {
       await this.layouter.batchLayout({
         batch: tasks,
         onSuccess: (task, result) => {
-          this.viewsWithReportedErrors.delete(task.view.id);
-          this.cache.set(task.view, result);
+          this.viewSucceed(task.view, projectId, result);
           results.push(result);
         },
         onError: (task, error) => {
@@ -65,7 +69,8 @@ export class DefaultLikeC4Views {
   async layoutView(viewId, projectId, cancelToken) {
     const model = await this.ModelBuilder.buildLikeC4Model(projectId, cancelToken);
     const view = model.findView(viewId)?.$view;
-    const logger = projectId ? viewsLogger.getChild(projectId) : viewsLogger;
+    projectId ??= model.project.id;
+    const logger = viewsLogger.getChild(projectId);
     if (!view) {
       logger.warn`layoutView ${viewId} not found`;
       return null;
@@ -73,25 +78,21 @@ export class DefaultLikeC4Views {
     let cached = this.cache.get(view);
     if (cached) {
       logger.debug`layout ${viewId} from cache`;
-      return await Promise.resolve(cached);
+      return await Promise.resolve().then(() => cached);
     }
     try {
       const m0 = performanceMark();
       const result = await this.layouter.layout({
         view,
-        specification: model.$data.specification
+        styles: model.$styles
       });
-      this.viewsWithReportedErrors.delete(viewId);
-      this.cache.set(view, result);
+      this.viewSucceed(view, projectId, result);
       logger.debug(`layout {viewId} ready in ${m0.pretty}`, { viewId });
       return result;
     } catch (e) {
-      if (!this.viewsWithReportedErrors.has(viewId)) {
-        const errMessage = loggable(e);
-        this.services.shared.lsp.Connection?.window.showErrorMessage(`LikeC4: ${errMessage}`);
-        this.viewsWithReportedErrors.add(viewId);
-        logError(e);
-      }
+      const errMessage = loggable(e);
+      logger.warn(errMessage);
+      this.reportViewError(view, projectId, errMessage);
       return Promise.reject(e);
     }
   }
@@ -113,7 +114,7 @@ export class DefaultLikeC4Views {
     const tasks = views.map(async (view) => {
       const { dot, svg } = await this.layouter.svg({
         view,
-        specification: likeC4Model.$data.specification
+        styles: likeC4Model.$styles
       });
       return {
         id: view.id,
@@ -139,6 +140,18 @@ export class DefaultLikeC4Views {
   async openView(viewId, projectId) {
     await this.services.Rpc.openView({ viewId, projectId });
   }
+  reportViewError(view, projectId, error) {
+    const key = `${projectId}-${view.id}`;
+    if (!this.viewsWithReportedErrors.has(key)) {
+      this.services.shared.lsp.Connection?.window.showErrorMessage(`LikeC4: ${error}`);
+      this.viewsWithReportedErrors.add(key);
+    }
+  }
+  viewSucceed(view, projectId, result) {
+    const key = `${projectId}-${view.id}`;
+    this.viewsWithReportedErrors.delete(key);
+    this.cache.set(view, result);
+  }
   // async overviewGraph(): Promise<OverviewGraph> {
   //   const KEY = 'OverviewGraph'
   //   const cache = this.services.ValidatedWorkspaceCache as WorkspaceCache<string, OverviewGraph>

package/dist/workspace/ProjectsManager.d.ts

@@ -1,6 +1,7 @@
-import { type LikeC4ProjectConfig } from '@likec4/config';
-import type { NonEmptyReadonlyArray, ProjectId } from '@likec4/core';
-import { type Cancellation, type FileSystemNode, type LangiumDocument, URI, WorkspaceCache } from 'langium';
+import { type LikeC4ProjectConfig, type LikeC4ProjectConfigInput } from '@likec4/config';
+import type { NonEmptyReadonlyArray } from '@likec4/core';
+import type { scalar } from '@likec4/core/types';
+import { type Cancellation, type LangiumDocument, URI, WorkspaceCache } from 'langium';
 import type { Tagged } from 'type-fest';
 import type { LikeC4SharedServices } from '../module';
 /**
@@ -10,14 +11,14 @@ import type { LikeC4SharedServices } from '../module';
 export type ProjectFolder = Tagged<string, 'ProjectFolder'>;
 export declare function ProjectFolder(folder: URI | string): ProjectFolder;
 interface ProjectData {
-    id: ProjectId;
+    id: scalar.ProjectId;
     config: LikeC4ProjectConfig;
     folder: ProjectFolder;
     folderUri: URI;
     exclude?: (path: string) => boolean;
 }
 export interface Project {
-    id: ProjectId;
+    id: scalar.ProjectId;
     folderUri: URI;
     config: LikeC4ProjectConfig;
 }
@@ -28,21 +29,7 @@ export declare class ProjectsManager {
      * The global project ID used for all documents
      * that are not part of a specific project.
      */
-    static readonly DefaultProjectId: ProjectId;
-    private static DefaultProject;
-    /**
-     * The mapping between project config files and project IDs.
-     */
-    private projectIdToFolder;
-    /**
-     * Registered projects.
-     * Sorted descending by the number of segments in the folder path.
-     * This ensures that the most specific project is used for a document.
-     */
-    private _projects;
-    private excludedDocuments;
-    private get defaultGlobalProject();
-    private reloadProjectsLimiter;
+    static readonly DefaultProjectId: scalar.ProjectId;
     constructor(services: LikeC4SharedServices);
     /**
      * Returns:
@@ -51,16 +38,16 @@ export declare class ProjectsManager {
      *  - the ID of the only project
      *  - undefined if there are multiple projects.
      */
-    get defaultProjectId(): ProjectId | undefined;
-    set defaultProjectId(id: ProjectId | undefined);
-    get all(): NonEmptyReadonlyArray<ProjectId>;
-    getProject(arg: ProjectId | LangiumDocument): Project;
+    get defaultProjectId(): scalar.ProjectId | undefined;
+    set defaultProjectId(id: string | scalar.ProjectId | undefined);
+    get all(): NonEmptyReadonlyArray<scalar.ProjectId>;
+    getProject(arg: scalar.ProjectId | LangiumDocument): Project;
     /**
      * Validates and ensures the project ID.
      * If no project ID is specified, returns default project ID
      * If there are multiple projects and default project is not set, throws an error
      */
-    ensureProjectId(projectId?: ProjectId | undefined): ProjectId;
+    ensureProjectId(projectId?: scalar.ProjectId | undefined): scalar.ProjectId;
     hasMultipleProjects(): boolean;
     /**
      * Checks if the specified document should be excluded from processing.
@@ -77,20 +64,25 @@ export declare class ProjectsManager {
      *
      * @param entry The file system entry to check
      */
-    loadConfigFile(entry: FileSystemNode): Promise<ProjectData | undefined>;
+    registerConfigFile(configFile: URI): Promise<ProjectData | undefined>;
     /**
      * Registers (or reloads) likec4 project by config file or config object.
      * If there is some project registered at same folder, it will be reloaded.
      */
     registerProject(opts: URI | {
-        config: LikeC4ProjectConfig;
+        config: LikeC4ProjectConfigInput;
         folderUri: URI | string;
     }): Promise<ProjectData>;
-    belongsTo(document: LangiumDocument | URI | string): ProjectId;
-    reloadProjects(token?: Cancellation.CancellationToken): Promise<void>;
-    protected uniqueProjectId(name: string): ProjectId;
+    /**
+     * Registers (or reloads) likec4 project by config file or config object.
+     * If there is some project registered at same folder, it will be reloaded.
+     */
+    private _registerProject;
+    belongsTo(document: LangiumDocument | URI | string): scalar.ProjectId;
+    reloadProjects(): Promise<void>;
+    protected uniqueProjectId(name: string): scalar.ProjectId;
     protected resetProjectIds(): void;
-    protected rebuidDocuments(): Promise<void>;
+    protected rebuidDocuments(cancelToken?: Cancellation.CancellationToken): Promise<void>;
     protected findProjectForDocument(documentUri: string): any;
     protected get mappingsToProject(): WorkspaceCache<string, Pick<ProjectData, 'id' | 'config' | 'exclude'>>;
 }