@likec4/language-server 1.36.1 → 1.38.0

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

@@ -30,7 +30,7 @@ export declare function DeploymentViewParser<TBase extends WithExpressionV2 & Wi
         readonly doc: import("../../ast").ParsedLikeC4LangiumDocument;
         get project(): {
             id: c4.ProjectId;
-            folder: c4;
+            folderUri: c4;
             config: Readonly<import("../../config").ProjectConfig>;
         };
         resolveFqn(node: ast.FqnReferenceable): c4.Fqn;

package/dist/model/parser/DeploymentViewParser.js

@@ -5,7 +5,7 @@ import { ast, parseMarkdownAsString, toAutoLayout, ViewOps } from "../../ast.js"
 import { logWarnError } from "../../logger.js";
 import { stringHash } from "../../utils/index.js";
 import { parseViewManualLayout } from "../../view-utils/manual-layout.js";
-import { removeIndent } from "./Base.js";
+import { removeIndent, toSingleLine } from "./Base.js";
 export function DeploymentViewParser(B) {
   return class DeploymentViewParser extends B {
     parseDeploymentView(astNode) {
@@ -39,7 +39,7 @@ export function DeploymentViewParser(B) {
         [c4._type]: "deployment",
         id,
         astPath,
-        title,
+        title: toSingleLine(title) ?? null,
         description,
         tags,
         links: isNonEmptyArray(links) ? links : null,

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

@@ -25,7 +25,7 @@ export declare function ExpressionV2Parser<TBase extends Base>(B: TBase): {
         readonly doc: import("../../ast").ParsedLikeC4LangiumDocument;
         get project(): {
             id: c4.ProjectId;
-            folder: c4;
+            folderUri: c4;
             config: Readonly<import("../../config").ProjectConfig>;
         };
         resolveFqn(node: ast.FqnReferenceable): c4.Fqn;

package/dist/model/parser/FqnRefParser.js

@@ -88,7 +88,14 @@ export function ExpressionV2Parser(B) {
           }
           if (ast.isElementStringProperty(prop)) {
             if (isDefined(prop.value)) {
-              acc.custom[prop.key] = removeIndent(parseMarkdownAsString(prop.value)) || "";
+              if (prop.key === "description") {
+                const parsed = this.parseMarkdownOrString(prop.value);
+                if (parsed) {
+                  acc.custom["description"] = parsed;
+                }
+              } else {
+                acc.custom[prop.key] = removeIndent(parseMarkdownAsString(prop.value)) || "";
+              }
             }
             return acc;
           }

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

@@ -54,7 +54,7 @@ export declare function GlobalsParser<TBase extends WithViewsParser>(B: TBase):
         readonly doc: import("../../ast").ParsedLikeC4LangiumDocument;
         get project(): {
             id: c4.ProjectId;
-            folder: c4;
+            folderUri: c4;
             config: Readonly<import("../../config").ProjectConfig>;
         };
         resolveFqn(node: ast.FqnReferenceable): c4.Fqn;

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

@@ -9,7 +9,7 @@ export declare function ImportsParser<TBase extends Base>(B: TBase): {
         readonly doc: import("../../ast").ParsedLikeC4LangiumDocument;
         get project(): {
             id: ProjectId;
-            folder: ProjectId;
+            folderUri: ProjectId;
             config: Readonly<import("../../config").ProjectConfig>;
         };
         resolveFqn(node: ast.FqnReferenceable): ProjectId;

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

@@ -31,7 +31,7 @@ export declare function ModelParser<TBase extends WithExpressionV2>(B: TBase): {
         readonly doc: import("../../ast").ParsedLikeC4LangiumDocument;
         get project(): {
             id: c4.ProjectId;
-            folder: c4;
+            folderUri: c4;
             config: Readonly<import("../../config").ProjectConfig>;
         };
         resolveFqn(node: ast.FqnReferenceable): c4.Fqn;

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

@@ -36,7 +36,7 @@ export declare function PredicatesParser<TBase extends WithExpressionV2>(B: TBas
         readonly doc: import("../../ast").ParsedLikeC4LangiumDocument;
         get project(): {
             id: c4.ProjectId;
-            folder: c4;
+            folderUri: c4;
             config: Readonly<import("../../config").ProjectConfig>;
         };
         resolveFqn(node: ast.FqnReferenceable): c4.Fqn;

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

@@ -15,7 +15,7 @@ export declare function SpecificationParser<TBase extends Base>(B: TBase): {
         readonly doc: import("../../ast").ParsedLikeC4LangiumDocument;
         get project(): {
             id: c4.ProjectId;
-            folder: c4;
+            folderUri: c4;
             config: Readonly<import("../../config").ProjectConfig>;
         };
         resolveFqn(node: ast.FqnReferenceable): c4.Fqn;

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

@@ -52,7 +52,7 @@ export declare function ViewsParser<TBase extends WithPredicates & WithDeploymen
         readonly doc: import("../../ast").ParsedLikeC4LangiumDocument;
         get project(): {
             id: c4.ProjectId;
-            folder: c4;
+            folderUri: c4;
             config: Readonly<import("../../config").ProjectConfig>;
         };
         resolveFqn(node: ast.FqnReferenceable): c4.Fqn;

package/dist/model/parser/ViewsParser.js

@@ -26,7 +26,7 @@ export function ViewsParser(B) {
             return [];
           }
         });
-        const folder = viewBlock.folder && !isEmpty(viewBlock.folder.trim()) ? viewBlock.folder : null;
+        const folder = viewBlock.folder && !isEmpty(viewBlock.folder.trim()) ? toSingleLine(viewBlock.folder) : null;
         for (const view of viewBlock.views) {
           try {
             if (!isValid(view)) {
@@ -93,7 +93,7 @@ export function ViewsParser(B) {
         [c4._type]: "element",
         id,
         astPath,
-        title,
+        title: toSingleLine(title) ?? null,
         description,
         tags,
         links: isNonEmptyArray(links) ? links : null,
@@ -245,7 +245,7 @@ export function ViewsParser(B) {
         [c4._type]: "dynamic",
         id,
         astPath,
-        title,
+        title: toSingleLine(title) ?? null,
         description,
         tags,
         links: isNonEmptyArray(links) ? links : null,

package/dist/module.d.ts

@@ -2,16 +2,20 @@ import { QueueGraphvizLayoter } from '@likec4/layouts';
 import { type Module, WorkspaceCache } from 'langium';
 import { type DefaultSharedModuleContext, type LangiumServices, type LangiumSharedServices, type PartialLangiumServices } from 'langium/lsp';
 import { LikeC4DocumentationProvider } from './documentation';
+import { type FileSystemModuleContext, type FileSystemProvider, type FileSystemWatcher } from './filesystem';
 import { type LikeC4LanguageServices } from './LikeC4LanguageServices';
 import { LikeC4CodeLensProvider, LikeC4CompletionProvider, LikeC4DocumentHighlightProvider, LikeC4DocumentLinkProvider, LikeC4DocumentSymbolProvider, LikeC4HoverProvider, LikeC4SemanticTokenProvider } from './lsp';
-import { type LikeC4MCPServer, type LikeC4MCPServerFactory } from './mcp/interfaces';
+import { type LikeC4MCPServer, type LikeC4MCPServerModuleContext } from './mcp/interfaces';
+import { LikeC4MCPServerFactory } from './mcp/MCPServerFactory';
 import { type LikeC4ModelBuilder, DeploymentsIndex, FqnIndex, LikeC4ModelLocator, LikeC4ModelParser, LikeC4ValueConverter } from './model';
 import { LikeC4ModelChanges } from './model-change/ModelChanges';
 import { LikeC4NameProvider, LikeC4ScopeComputation, LikeC4ScopeProvider } from './references';
 import { Rpc } from './Rpc';
 import { NodeKindProvider, WorkspaceSymbolProvider } from './shared';
+import { LikeC4DocumentValidator } from './validation';
 import { type LikeC4Views } from './views';
 import { IndexManager, LangiumDocuments, LikeC4WorkspaceManager, ProjectsManager } from './workspace';
+export type LanguageServicesContext = Omit<DefaultSharedModuleContext, 'fileSystemProvider'> & FileSystemModuleContext & LikeC4MCPServerModuleContext;
 interface LikeC4AddedSharedServices {
     lsp: {
         NodeKindProvider: NodeKindProvider;
@@ -22,6 +26,8 @@ interface LikeC4AddedSharedServices {
         IndexManager: IndexManager;
         LangiumDocuments: LangiumDocuments;
         WorkspaceManager: LikeC4WorkspaceManager;
+        FileSystemProvider: FileSystemProvider;
+        FileSystemWatcher: FileSystemWatcher;
     };
 }
 export type LikeC4SharedServices = LangiumSharedServices & LikeC4AddedSharedServices;
@@ -33,6 +39,9 @@ export interface LikeC4AddedServices {
         DocumentationProvider: LikeC4DocumentationProvider;
     };
     ValidatedWorkspaceCache: WorkspaceCache<string, any>;
+    validation: {
+        DocumentValidator: LikeC4DocumentValidator;
+    };
     Rpc: Rpc;
     mcp: {
         Server: LikeC4MCPServer;
@@ -69,15 +78,10 @@ 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 const createLikeC4Module: (context: LikeC4MCPServerModuleContext) => Module<LikeC4Services, PartialLangiumServices & LikeC4AddedServices>;
+export declare function createLanguageServices<I1, I2, I3, I extends I1 & I2 & I3 & LikeC4Services>(context: Partial<LanguageServicesContext>, module?: Module<I, I1>, module2?: Module<I, I2>, module3?: Module<I, I3>): {
     shared: LikeC4SharedServices;
     likec4: I;
 };
-export declare function createSharedServices(context?: LanguageServicesContext): LikeC4SharedServices;
-export declare function createLanguageServices(context?: LanguageServicesContext): {
-    shared: LikeC4SharedServices;
-    likec4: LikeC4Services;
-};
+export declare function createSharedServices(context?: Partial<LanguageServicesContext>): LikeC4SharedServices;
 export {};

package/dist/module.js

@@ -1,7 +1,6 @@
 import { GraphvizWasmAdapter, QueueGraphvizLayoter } from "@likec4/layouts";
 import {
   DocumentState,
-  EmptyFileSystem,
   inject,
   WorkspaceCache
 } from "langium";
@@ -10,6 +9,9 @@ import {
   createDefaultSharedModule
 } from "langium/lsp";
 import { LikeC4DocumentationProvider } from "./documentation/index.js";
+import {
+  NoopFileSystem
+} from "./filesystem/index.js";
 import { LikeC4Formatter } from "./formatting/LikeC4Formatter.js";
 import {
   LikeC4GeneratedModule,
@@ -25,7 +27,10 @@ import {
   LikeC4HoverProvider,
   LikeC4SemanticTokenProvider
 } from "./lsp/index.js";
-import { NoopLikeC4MCPServer, NoopLikeC4MCPServerFactory } from "./mcp/NoopLikeC4MCPServer.js";
+import {
+  NoMCPServer
+} from "./mcp/interfaces.js";
+import { LikeC4MCPServerFactory } from "./mcp/MCPServerFactory.js";
 import {
   DefaultLikeC4ModelBuilder,
   DeploymentsIndex,
@@ -45,7 +50,7 @@ import {
   NodeKindProvider,
   WorkspaceSymbolProvider
 } from "./shared/index.js";
-import { registerValidationChecks } from "./validation/index.js";
+import { LikeC4DocumentValidator, registerValidationChecks } from "./validation/index.js";
 import { DefaultLikeC4Views } from "./views/index.js";
 import {
   AstNodeDescriptionProvider,
@@ -54,7 +59,7 @@ import {
   LikeC4WorkspaceManager,
   ProjectsManager
 } from "./workspace/index.js";
-const LikeC4SharedModule = {
+const createLikeC4SharedModule = (context) => ({
   lsp: {
     NodeKindProvider: (services) => new NodeKindProvider(services),
     WorkspaceSymbolProvider: (services) => new WorkspaceSymbolProvider(services)
@@ -63,21 +68,26 @@ const LikeC4SharedModule = {
     IndexManager: (services) => new IndexManager(services),
     LangiumDocuments: (services) => new LangiumDocuments(services),
     ProjectsManager: (services) => new ProjectsManager(services),
-    WorkspaceManager: (services) => new LikeC4WorkspaceManager(services)
+    WorkspaceManager: (services) => new LikeC4WorkspaceManager(services),
+    FileSystemProvider: (services) => context.fileSystemProvider(services),
+    FileSystemWatcher: (services) => context.fileSystemWatcher(services)
   }
-};
+});
 function bind(Type) {
   return (services) => new Type(services);
 }
-export const LikeC4Module = {
+export const createLikeC4Module = (context) => ({
   documentation: {
     DocumentationProvider: bind(LikeC4DocumentationProvider)
   },
+  validation: {
+    DocumentValidator: bind(LikeC4DocumentValidator)
+  },
   ValidatedWorkspaceCache: (services) => new WorkspaceCache(services.shared, DocumentState.Validated),
   Rpc: bind(Rpc),
   mcp: {
-    Server: bind(NoopLikeC4MCPServer),
-    ServerFactory: bind(NoopLikeC4MCPServerFactory)
+    Server: (services) => context.mcpServer(services),
+    ServerFactory: bind(LikeC4MCPServerFactory)
   },
   likec4: {
     LanguageServices: bind(DefaultLikeC4LanguageServices),
@@ -116,13 +126,16 @@ export const LikeC4Module = {
   parser: {
     ValueConverter: bind(LikeC4ValueConverter)
   }
-};
-export function createCustomLanguageServices(context, module, module2, module3) {
+});
+export function createLanguageServices(context, module, module2, module3) {
   const shared = createSharedServices(context);
   const modules = [
     createDefaultModule({ shared }),
     LikeC4GeneratedModule,
-    LikeC4Module,
+    createLikeC4Module({
+      ...NoMCPServer,
+      ...context
+    }),
     module,
     module2,
     module3
@@ -139,30 +152,15 @@ export function createCustomLanguageServices(context, module, module2, module3)
 }
 export function createSharedServices(context = {}) {
   const moduleContext = {
-    ...EmptyFileSystem,
+    ...NoMCPServer,
+    ...NoopFileSystem,
     ...context
   };
   return inject(
     createDefaultSharedModule(moduleContext),
     LikeC4GeneratedSharedModule,
-    LikeC4SharedModule
-  );
-}
-export function createLanguageServices(context = {}) {
-  const shared = createSharedServices(context);
-  const likec4 = inject(
-    createDefaultModule({ shared }),
-    LikeC4GeneratedModule,
-    LikeC4Module
+    createLikeC4SharedModule(moduleContext)
   );
-  shared.ServiceRegistry.register(likec4);
-  registerValidationChecks(likec4);
-  if (!context.connection) {
-    shared.workspace.ConfigurationProvider.initialized({});
-  } else {
-    likec4.Rpc.init();
-  }
-  return { shared, likec4 };
 }
 function _merge(target, source) {
   if (source) {

package/dist/protocol.d.ts

@@ -1,6 +1,7 @@
 import type { ComputedLikeC4ModelData, ComputedView, DeploymentFqn, DiagramView, Fqn, LayoutedLikeC4ModelData, NonEmptyArray, ProjectId, RelationId, ViewChange, ViewId } from '@likec4/core';
-import { NotificationType, RequestType, RequestType0 } from 'vscode-languageserver';
-import type { DiagnosticSeverity, DocumentUri, Location, Position, Range } from 'vscode-languageserver-types';
+import { NotificationType, RequestType, RequestType0 } from 'vscode-jsonrpc';
+import type { DiagnosticSeverity, DocumentUri, Location, Position, Range, URI } from 'vscode-languageserver-types';
+import type { ProjectConfig } from './config';
 export declare namespace DidChangeModelNotification {
     const type: NotificationType<string>;
     type Type = typeof type;
@@ -121,13 +122,26 @@ export declare namespace ValidateLayout {
     type Req = typeof Req;
 }
 /**
- * Request to build documents.
+ * Request to reload projects.
+ */
+export declare namespace ReloadProjects {
+    type Params = never;
+    type Res = void;
+    const req: RequestType0<void, void>;
+    type Req = typeof req;
+}
+/**
+ * Fetch all non-empty projects.
  */
 export declare namespace FetchProjects {
     type Params = never;
     type Res = {
         projects: {
-            [projectId: ProjectId]: NonEmptyArray<DocumentUri>;
+            [projectId: ProjectId]: {
+                folder: URI;
+                config: ProjectConfig;
+                docs: NonEmptyArray<DocumentUri>;
+            };
         };
     };
     const req: RequestType0<Res, void>;

package/dist/protocol.js

@@ -1,4 +1,4 @@
-import { NotificationType, RequestType, RequestType0 } from "vscode-languageserver";
+import { NotificationType, RequestType, RequestType0 } from "vscode-jsonrpc";
 export var DidChangeModelNotification;
 ((DidChangeModelNotification2) => {
   DidChangeModelNotification2.type = new NotificationType("likec4/onDidChangeModel");
@@ -31,6 +31,10 @@ export var ValidateLayout;
 ((ValidateLayout2) => {
   ValidateLayout2.Req = new RequestType("likec4/validate-layout");
 })(ValidateLayout || (ValidateLayout = {}));
+export var ReloadProjects;
+((ReloadProjects2) => {
+  ReloadProjects2.req = new RequestType0("likec4/reload-projects");
+})(ReloadProjects || (ReloadProjects = {}));
 export var FetchProjects;
 ((FetchProjects2) => {
   FetchProjects2.req = new RequestType0("likec4/fetch-projects");

package/dist/test/testServices.d.ts

@@ -1,4 +1,6 @@
 import type { ComputedLikeC4ModelData } from '@likec4/core';
+import type { LiteralUnion } from 'type-fest';
+import { URI } from 'vscode-uri';
 import type { LikeC4LangiumDocument } from '../ast';
 export declare function createTestServices(workspace?: string): {
     services: any;
@@ -38,6 +40,7 @@ export declare function createMultiProjectTestServices<const Projects extends Re
     services: any;
     projects: { readonly [K in keyof Projects]: { readonly [L in keyof Projects[K]]: LikeC4LangiumDocument; }; };
     projectsManager: any;
+    addDocument: (uri: string | URI, input: string) => Promise<LikeC4LangiumDocument>;
     /**
      * Add document outside of projects
      */
@@ -47,8 +50,8 @@ export declare function createMultiProjectTestServices<const Projects extends Re
         errors: any;
         warnings: any;
     }>;
-    buildModel: (projectId: keyof Projects) => Promise<ComputedLikeC4ModelData>;
-    buildLikeC4Model: (projectId: keyof Projects) => Promise<any>;
+    buildModel: (projectId: LiteralUnion<keyof Projects, string>) => Promise<ComputedLikeC4ModelData>;
+    buildLikeC4Model: (projectId: LiteralUnion<keyof Projects, string>) => Promise<any>;
 }>;
 export type TestServices = ReturnType<typeof createTestServices>;
 export type TestParseFn = TestServices['validate'];

package/dist/test/testServices.js

@@ -1,12 +1,13 @@
-import { DocumentState, EmptyFileSystem, TextDocument, UriUtils } from "langium";
+import { DocumentState, TextDocument, UriUtils } from "langium";
 import * as assert from "node:assert";
 import { entries } from "remeda";
 import stripIndent from "strip-indent";
 import { DiagnosticSeverity } from "vscode-languageserver-types";
 import { URI, Utils } from "vscode-uri";
+import { NoopFileSystem } from "../filesystem/index.js";
 import { createLanguageServices } from "../module.js";
 export function createTestServices(workspace = "file:///test/workspace") {
-  const services = createLanguageServices(EmptyFileSystem).likec4;
+  const services = createLanguageServices(NoopFileSystem).likec4;
   const metaData = services.LanguageMetaData;
   const langiumDocuments = services.shared.workspace.LangiumDocuments;
   const documentBuilder = services.shared.workspace.DocumentBuilder;
@@ -165,12 +166,15 @@ export async function createMultiProjectTestServices(data) {
   }
   async function buildModel(projectId) {
     const model = await buildLikeC4Model(projectId);
-    return model.$model;
+    return model.$data;
   }
   return {
     services,
     projects,
     projectsManager: services.shared.workspace.ProjectsManager,
+    addDocument: async (uri, input) => {
+      return await addDocument(input, uri.toString());
+    },
     /**
      * Add document outside of projects
      */

package/dist/validation/DocumentValidator.d.ts

@@ -0,0 +1,11 @@
+import { type LangiumDocument, type ValidationOptions, Cancellation, DefaultDocumentValidator } from 'langium';
+import type { Diagnostic } from 'vscode-languageserver-types';
+import type { LikeC4Services } from '../module';
+export declare class LikeC4DocumentValidator extends DefaultDocumentValidator {
+    protected services: LikeC4Services;
+    constructor(services: LikeC4Services);
+    /**
+     * If the document is excluded, then we skip validation and return an empty array of diagnostics.
+     */
+    validateDocument(document: LangiumDocument, options?: ValidationOptions, cancelToken?: Cancellation.CancellationToken): Promise<Diagnostic[]>;
+}

package/dist/validation/DocumentValidator.js

@@ -0,0 +1,16 @@
+import { DefaultDocumentValidator } from "langium";
+export class LikeC4DocumentValidator extends DefaultDocumentValidator {
+  constructor(services) {
+    super(services);
+    this.services = services;
+  }
+  /**
+   * If the document is excluded, then we skip validation and return an empty array of diagnostics.
+   */
+  async validateDocument(document, options, cancelToken) {
+    if (this.services.shared.workspace.ProjectsManager.checkIfExcluded(document)) {
+      return [];
+    }
+    return await super.validateDocument(document, options, cancelToken);
+  }
+}

package/dist/validation/index.d.ts

@@ -1,6 +1,7 @@
 import { type AstNode } from 'langium';
 import { type LikeC4LangiumDocument, ast } from '../ast';
 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.DynamicViewGlobalPredicateRef | ast.DynamicViewIncludePredicate | ast.ViewRuleGlobalStyle | ast.ViewRuleStyle | ast.ElementStringProperty | ast.ElementStyleProperty | ast.IconProperty | ast.LinkProperty | 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.ViewStringProperty | 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;
@@ -12,4 +13,3 @@ export declare function checksFromDiagnostics(doc: LikeC4LangiumDocument): {
 export type ChecksFromDiagnostics = ReturnType<typeof checksFromDiagnostics>;
 export type IsValidFn = ChecksFromDiagnostics['isValid'];
 export declare function registerValidationChecks(services: LikeC4Services): void;
-export {};

package/dist/validation/index.js

@@ -40,6 +40,7 @@ import {
   checkRelationExpr,
   checkRelationExprWith
 } from "./view-predicates/index.js";
+export { LikeC4DocumentValidator } from "./DocumentValidator.js";
 function validatableAstNodeGuards(predicates) {
   return (n) => predicates.some((p) => p(n));
 }

package/dist/workspace/LangiumDocuments.d.ts

@@ -11,4 +11,5 @@ export declare class LangiumDocuments extends DefaultLangiumDocuments {
     get allExcludingBuiltin(): Stream<LikeC4LangiumDocument>;
     projectDocuments(projectId: ProjectId): Stream<LikeC4LangiumDocument>;
     groupedByProject(): Record<ProjectId, NonEmptyArray<LikeC4LangiumDocument>>;
+    resetProjectIds(): void;
 }

package/dist/workspace/LangiumDocuments.js

@@ -13,7 +13,7 @@ export class LangiumDocuments extends DefaultLangiumDocuments {
   get allExcludingBuiltin() {
     const projects = this.services.workspace.ProjectsManager;
     return super.all.filter((doc) => {
-      if (!isLikeC4LangiumDocument(doc) || isLikeC4Builtin(doc.uri)) {
+      if (!isLikeC4LangiumDocument(doc) || isLikeC4Builtin(doc.uri) || projects.checkIfExcluded(doc)) {
         return false;
       }
       doc.likec4ProjectId = projects.belongsTo(doc.uri);
@@ -26,4 +26,13 @@ export class LangiumDocuments extends DefaultLangiumDocuments {
   groupedByProject() {
     return groupBy(this.allExcludingBuiltin.toArray(), prop("likec4ProjectId"));
   }
+  resetProjectIds() {
+    const projects = this.services.workspace.ProjectsManager;
+    this.all.forEach((doc) => {
+      if (!isLikeC4LangiumDocument(doc) || isLikeC4Builtin(doc.uri)) {
+        return;
+      }
+      doc.likec4ProjectId = projects.belongsTo(doc);
+    });
+  }
 }

package/dist/workspace/ProjectsManager.d.ts

@@ -1,14 +1,27 @@
 import type { NonEmptyReadonlyArray, ProjectId } from '@likec4/core';
-import { type FileSystemNode, type LangiumDocument, URI, WorkspaceCache } from 'langium';
-import picomatch from 'picomatch/posix';
+import { type Cancellation, type FileSystemNode, type LangiumDocument, URI, WorkspaceCache } from 'langium';
+import picomatch from 'picomatch';
+import type { Tagged } from 'type-fest';
 import { ProjectConfig } from '../config';
 import type { LikeC4SharedServices } from '../module';
-interface Project {
+/**
+ * A tagged string that represents a project folder.
+ * Always has trailing slash.
+ */
+export type ProjectFolder = Tagged<string, 'ProjectFolder'>;
+export declare function ProjectFolder(folder: URI | string): ProjectFolder;
+interface ProjectData {
     id: ProjectId;
     config: ProjectConfig;
-    folder: string;
+    folder: ProjectFolder;
+    folderUri: URI;
     exclude?: picomatch.Matcher;
 }
+export interface Project {
+    id: ProjectId;
+    folderUri: URI;
+    config: ProjectConfig;
+}
 export declare class ProjectsManager {
     protected services: LikeC4SharedServices;
     /**
@@ -27,7 +40,9 @@ export declare class ProjectsManager {
      * This ensures that the most specific project is used for a document.
      */
     private _projects;
+    private excludedDocuments;
     private defaultGlobalProject;
+    private reloadProjectsLimiter;
     constructor(services: LikeC4SharedServices);
     /**
      * Returns:
@@ -37,29 +52,32 @@ export declare class ProjectsManager {
      */
     get defaultProjectId(): ProjectId | undefined;
     get all(): NonEmptyReadonlyArray<ProjectId>;
-    getProject(arg: ProjectId | LangiumDocument): {
-        id: ProjectId;
-        folder: URI;
-        config: Readonly<ProjectConfig>;
-    };
+    getProject(arg: ProjectId | LangiumDocument): Project;
     ensureProjectId(projectId?: ProjectId | undefined): ProjectId;
     hasMultipleProjects(): boolean;
-    checkIfExcluded(documentUri: URI): boolean;
-    isConfigFile(entry: FileSystemNode): boolean;
+    checkIfExcluded(document: LangiumDocument | URI | string): boolean;
+    /**
+     * Checks if it is a config file and it is not excluded by default exclude pattern
+     *
+     * @param entry The file system entry to check
+     */
+    isConfigFile(entry: URI): boolean;
     /**
      * Checks if the provided file system entry is a valid project config file.
      *
      * @param entry The file system entry to check
      */
-    loadConfigFile(entry: FileSystemNode): Promise<Project | undefined>;
-    registerProject(configFile: URI): Promise<Project>;
+    loadConfigFile(entry: FileSystemNode): Promise<ProjectData | undefined>;
+    registerProject(configFile: URI): Promise<ProjectData>;
     registerProject(opts: {
         config: ProjectConfig;
         folderUri: URI | string;
-    }): Promise<Project>;
+    }): Promise<ProjectData>;
     belongsTo(document: LangiumDocument | URI | string): ProjectId;
-    protected findProjectForDocument(documentUri: string): Omit<Project, 'folder'>;
-    private _mappingsToProject;
-    protected get mappingsToProject(): WorkspaceCache<string, Omit<Project, 'folder'>>;
+    reloadProjects(token?: Cancellation.CancellationToken): Promise<void>;
+    protected uniqueProjectId(name: string): ProjectId;
+    protected resetProjectIds(): void;
+    protected findProjectForDocument(documentUri: string): any;
+    protected get mappingsToProject(): WorkspaceCache<string, Pick<ProjectData, 'id' | 'config' | 'exclude'>>;
 }
 export {};