@likec4/language-server 1.47.0 → 1.49.0

package/dist/filesystem/index.d.mts

@@ -0,0 +1,2 @@
+import { B as NoFileSystem, G as FileSystemProvider, H as NoLikeC4ManualLayouts, J as LikeC4ManualLayouts, K as FileSystemWatcher, L as WithLikeC4ManualLayouts, R as WithChokidarWatcher, U as FileNode, V as NoFileSystemWatcher, W as FileSystemModuleContext, X as ManualLayoutsSnapshot, Y as LikeC4ManualLayoutsModuleContext, q as FileSystemWatcherModuleContext, z as WithFileSystem } from "../_chunks/index.mjs";
+export { type FileNode, type FileSystemModuleContext, type FileSystemProvider, type FileSystemWatcher, type FileSystemWatcherModuleContext, type LikeC4ManualLayouts, type LikeC4ManualLayoutsModuleContext, type ManualLayoutsSnapshot, NoFileSystem, NoFileSystemWatcher, NoLikeC4ManualLayouts, WithChokidarWatcher, WithFileSystem, WithLikeC4ManualLayouts };

package/dist/filesystem/index.mjs

@@ -0,0 +1 @@
+import{Cr as NoFileSystem,Tr as NoLikeC4ManualLayouts,wr as NoFileSystemWatcher}from"../_chunks/utils.mjs";import"../_chunks/libs/eventemitter3.mjs";import{n as WithChokidarWatcher,r as WithLikeC4ManualLayouts,t as WithFileSystem}from"../_chunks/LikeC4FileSystem.mjs";export{NoFileSystem,NoFileSystemWatcher,NoLikeC4ManualLayouts,WithChokidarWatcher,WithFileSystem,WithLikeC4ManualLayouts};

package/dist/index.d.mts

@@ -0,0 +1,39 @@
+import { $ as ProjectsManager, B as NoFileSystem, D as LikeC4WorkspaceManager, G as FileSystemProvider, H as NoLikeC4ManualLayouts, J as LikeC4ManualLayouts, K as FileSystemWatcher, L as WithLikeC4ManualLayouts, O as LangiumDocuments, Q as ProjectData, S as LikeC4ModelBuilder, T as FqnIndex, V as NoFileSystemWatcher, W as FileSystemModuleContext, Y as LikeC4ManualLayoutsModuleContext, Z as Project, _ as LikeC4Views, b as LikeC4ModelLocator, f as LikeC4LanguageServices, g as LikeC4ModelParser, h as DocumentParser, q as FileSystemWatcherModuleContext, v as WithMCPServer, x as ViewLocateResult, y as NoMCPServer, z as WithFileSystem } from "./_chunks/index.mjs";
+import "./mcp/index.mjs";
+import { LanguageServicesContext, LikeC4AddedServices, LikeC4Services, LikeC4SharedServices, createLanguageServices } from "./module.mjs";
+import { Connection } from "vscode-languageserver";
+
+//#region src/index.d.ts
+type StartLanguageServerOptions = {
+  /**
+   * The Language Server Protocol connection to use.
+   */
+  connection?: Connection;
+  /**
+   * Whether to enable the file system watcher.
+   * @default true
+   */
+  enableWatcher?: boolean;
+  /**
+   * @default true
+   */
+  enableTelemetry?: boolean;
+  /**
+   * Whether to enable the MCP server.
+   * @default 'sse'
+   */
+  enableMCP?: false | 'stdio' | 'sse' | {
+    port: number;
+  };
+  /**
+   * Whether to enable manual layouts, stored in json5 files.
+   * @default true
+   */
+  enableManualLayouts?: boolean;
+};
+declare function startLanguageServer(options?: StartLanguageServerOptions): {
+  shared: LikeC4SharedServices;
+  likec4: LikeC4Services;
+};
+//#endregion
+export { DocumentParser, FileSystemModuleContext, FileSystemProvider, FileSystemWatcher, FileSystemWatcherModuleContext, FqnIndex, LangiumDocuments, LanguageServicesContext, LikeC4AddedServices, LikeC4LanguageServices, LikeC4ManualLayouts, LikeC4ManualLayoutsModuleContext, LikeC4ModelBuilder, LikeC4ModelLocator, LikeC4ModelParser, LikeC4Services, LikeC4SharedServices, LikeC4Views, LikeC4WorkspaceManager, NoFileSystem, NoFileSystemWatcher, NoLikeC4ManualLayouts, NoMCPServer, Project, ProjectData, ProjectsManager, ViewLocateResult, WithFileSystem, WithLikeC4ManualLayouts, WithMCPServer, createLanguageServices, startLanguageServer };

package/dist/index.mjs

@@ -0,0 +1 @@
+import{Cr as NoFileSystem,Tr as NoLikeC4ManualLayouts,wr as NoFileSystemWatcher}from"./_chunks/utils.mjs";import{i as logger$1,n as getTelemetrySink}from"./_chunks/logger.mjs";import"./_chunks/libs/eventemitter3.mjs";import{r as WithLikeC4ManualLayouts,t as WithFileSystem}from"./_chunks/LikeC4FileSystem.mjs";import{n as NoMCPServer}from"./_chunks/ProjectsManager.mjs";import{createLanguageServices}from"./module.mjs";import{t as WithMCPServer}from"./_chunks/WithMCPServer.mjs";import{t as ConfigurableLayouter}from"./_chunks/ConfigurableLayouter.mjs";import{configureLogger,getConsoleSink,getConsoleStderrSink,getTextFormatter}from"@likec4/log";import{startLanguageServer as startLanguageServer$1}from"langium/lsp";import{defu}from"defu";import{isDevelopment}from"std-env";function startLanguageServer(e){let t=e?.connection,n=defu(e,{enableWatcher:!0,enableMCP:`sse`,enableTelemetry:!!t,enableManualLayouts:!0}),r=!!t&&n.enableTelemetry&&!isDevelopment;configureLogger({sinks:{console:n.enableMCP===`stdio`||t?getConsoleStderrSink({formatter:getTextFormatter()}):getConsoleSink({formatter:getTextFormatter()}),...r&&{telemetry:getTelemetrySink(t)}},loggers:[{category:[`likec4`],sinks:[`console`,...r?[`telemetry`]:[]],lowestLevel:isDevelopment?`trace`:`debug`}]}),t?logger$1.info(`Starting LikeC4 language server`):logger$1.warn(`Starting LikeC4 language server (headless - no LSP connection)`);let i=createLanguageServices({...t&&{connection:t},...WithFileSystem(n.enableWatcher),...!!n.enableMCP&&WithMCPServer(n.enableMCP),...n.enableManualLayouts&&WithLikeC4ManualLayouts},t?{likec4:{...ConfigurableLayouter.likec4}}:void 0);return startLanguageServer$1(i.shared),i}export{NoFileSystem,NoFileSystemWatcher,NoLikeC4ManualLayouts,NoMCPServer,WithFileSystem,WithLikeC4ManualLayouts,WithMCPServer,createLanguageServices,startLanguageServer};

package/dist/likec4lib.d.mts

@@ -0,0 +1,16 @@
+import { URI } from "vscode-uri";
+
+//#region src/generated-lib/icons.d.ts
+declare const LibIcons: string;
+//#endregion
+//#region src/likec4lib.d.ts
+declare const Scheme = "likec4builtin";
+declare const Uri: "likec4builtin:///likec4/lib/icons.c4";
+declare function isLikeC4Builtin(uri: URI | {
+  uri: URI;
+}): boolean;
+declare function isNotLikeC4Builtin(uri: URI | {
+  uri: URI;
+}): boolean;
+//#endregion
+export { LibIcons as Content, Scheme, Uri, isLikeC4Builtin, isNotLikeC4Builtin };

package/dist/likec4lib.mjs

@@ -0,0 +1 @@
+import{t as LibIcons}from"./_chunks/icons.mjs";const Scheme=`likec4builtin`,Uri=`${Scheme}:///likec4/lib/icons.c4`;function isLikeC4Builtin(e){return(`uri`in e?e.uri:e).scheme===Scheme}function isNotLikeC4Builtin(e){return!isLikeC4Builtin(e)}export{LibIcons as Content,Scheme,Uri,isLikeC4Builtin,isNotLikeC4Builtin};

package/dist/mcp/index.d.mts

@@ -0,0 +1,2 @@
+import { F as LikeC4MCPServerModuleContext, N as LikeC4MCPServer, P as LikeC4MCPServerFactory, v as WithMCPServer, y as NoMCPServer } from "../_chunks/index.mjs";
+export { type LikeC4MCPServer, type LikeC4MCPServerFactory, type LikeC4MCPServerModuleContext, NoMCPServer, WithMCPServer };

package/dist/mcp/index.mjs

@@ -0,0 +1 @@
+import{n as NoMCPServer}from"../_chunks/ProjectsManager.mjs";import{t as WithMCPServer}from"../_chunks/WithMCPServer.mjs";export{NoMCPServer,WithMCPServer};

package/dist/module.d.mts

@@ -0,0 +1,126 @@
+import { $ as ProjectsManager, A as LikeC4ScopeComputation, B as NoFileSystem, C as LastSeenArtifacts, D as LikeC4WorkspaceManager, E as LikeC4ScopeProvider, F as LikeC4MCPServerModuleContext, G as FileSystemProvider$1, H as NoLikeC4ManualLayouts, I as LikeC4Formatter, J as LikeC4ManualLayouts, K as FileSystemWatcher, M as LikeC4DocumentValidator, N as LikeC4MCPServer, O as LangiumDocuments, P as LikeC4MCPServerFactory, S as LikeC4ModelBuilder, T as FqnIndex, W as FileSystemModuleContext, Y as LikeC4ManualLayoutsModuleContext, _ as LikeC4Views, a as LikeC4CodeActionProvider, b as LikeC4ModelLocator, c as LikeC4DocumentLinkProvider, d as LikeC4CodeLensProvider, et as LikeC4DocumentationProvider, f as LikeC4LanguageServices, g as LikeC4ModelParser, i as LikeC4SemanticTokenProvider, j as LikeC4NameProvider, k as IndexManager, l as LikeC4DocumentHighlightProvider, m as LikeC4ValueConverter, n as NodeKindProvider$1, o as LikeC4HoverProvider, p as LikeC4ModelChanges, r as Rpc, s as LikeC4DocumentSymbolProvider, t as WorkspaceSymbolProvider, u as LikeC4CompletionProvider, w as DeploymentsIndex, y as NoMCPServer } from "./_chunks/index.mjs";
+import "./filesystem/index.mjs";
+import { Module, WorkspaceCache } from "langium";
+import { DefaultSharedModuleContext, LangiumServices, LangiumSharedServices, PartialLangiumServices } from "langium/lsp";
+import { QueueGraphvizLayoter } from "@likec4/layouts";
+
+//#region src/module.d.ts
+type LanguageServicesContext = Omit<DefaultSharedModuleContext, 'fileSystemProvider'> & FileSystemModuleContext & LikeC4MCPServerModuleContext & LikeC4ManualLayoutsModuleContext;
+interface LikeC4AddedSharedServices {
+  lsp: {
+    NodeKindProvider: NodeKindProvider$1;
+    WorkspaceSymbolProvider: WorkspaceSymbolProvider;
+  };
+  workspace: {
+    Cache: WorkspaceCache<string, any>;
+    ProjectsManager: ProjectsManager;
+    IndexManager: IndexManager;
+    LangiumDocuments: LangiumDocuments;
+    WorkspaceManager: LikeC4WorkspaceManager;
+    FileSystemProvider: FileSystemProvider$1;
+    FileSystemWatcher: FileSystemWatcher;
+    ManualLayouts: LikeC4ManualLayouts;
+  };
+}
+type LikeC4SharedServices = LangiumSharedServices & LikeC4AddedSharedServices;
+/**
+ * Declaration of custom services - add your own service classes here.
+ */
+interface LikeC4AddedServices {
+  documentation: {
+    DocumentationProvider: LikeC4DocumentationProvider;
+  };
+  validation: {
+    DocumentValidator: LikeC4DocumentValidator;
+  };
+  Rpc: Rpc;
+  mcp: {
+    Server: LikeC4MCPServer;
+    ServerFactory: LikeC4MCPServerFactory;
+  };
+  likec4: {
+    LanguageServices: LikeC4LanguageServices;
+    Views: LikeC4Views;
+    Layouter: QueueGraphvizLayoter;
+    DeploymentsIndex: DeploymentsIndex;
+    FqnIndex: FqnIndex;
+    ModelParser: LikeC4ModelParser;
+    ModelBuilder: LikeC4ModelBuilder;
+    ModelLocator: LikeC4ModelLocator;
+    ModelChanges: LikeC4ModelChanges;
+    LastSeen: LastSeenArtifacts;
+  };
+  lsp: {
+    CompletionProvider: LikeC4CompletionProvider;
+    DocumentHighlightProvider: LikeC4DocumentHighlightProvider;
+    DocumentSymbolProvider: LikeC4DocumentSymbolProvider;
+    SemanticTokenProvider: LikeC4SemanticTokenProvider;
+    HoverProvider: LikeC4HoverProvider;
+    CodeLensProvider: LikeC4CodeLensProvider;
+    DocumentLinkProvider: LikeC4DocumentLinkProvider;
+    Formatter: LikeC4Formatter;
+    CodeActionProvider: LikeC4CodeActionProvider;
+  };
+  references: {
+    NameProvider: LikeC4NameProvider;
+    ScopeComputation: LikeC4ScopeComputation;
+    ScopeProvider: LikeC4ScopeProvider;
+  };
+  shared?: LikeC4SharedServices;
+  parser: {
+    ValueConverter: LikeC4ValueConverter;
+  };
+}
+type LikeC4Services = LangiumServices & LikeC4AddedServices;
+/**
+ * Most probably you don't need to use this function directly.
+ * Use {@link createLanguageServices} instead.
+ * @internal
+ */
+declare function createLikeC4Module(context: LikeC4MCPServerModuleContext): Module<LikeC4Services, PartialLangiumServices & LikeC4AddedServices>;
+/**
+ * Create and initialize likec4 language services with the given context
+ * @example
+ * ```ts
+ * const { shared, likec4 } = createLanguageServices({
+ *   ...WithFileSystem(enableWatcher = true),
+ *   ...WithLikeC4ManualLayouts(),
+ *   ...NoMcpServer(),
+ * });
+ * ```
+ *
+ * It is possible to extend/override the context with additional modules
+ * See Langium documentation for more details (or at the CliContext in packages/likec4/src/language/module.ts).
+ */
+declare function createLanguageServices(): {
+  shared: LikeC4SharedServices;
+  likec4: LikeC4Services;
+};
+declare function createLanguageServices(context: Partial<LanguageServicesContext>): {
+  shared: LikeC4SharedServices;
+  likec4: LikeC4Services;
+};
+declare function createLanguageServices(context: Partial<LanguageServicesContext>): {
+  shared: LikeC4SharedServices;
+  likec4: LikeC4Services;
+};
+declare function createLanguageServices<I1, I extends I1 & LikeC4Services>(context: Partial<LanguageServicesContext>, module: Module<I, I1> | undefined): {
+  shared: LikeC4SharedServices;
+  likec4: I;
+};
+declare function createLanguageServices<I1, I2, I extends I1 & I2 & LikeC4Services>(context: Partial<LanguageServicesContext>, module: Module<I, I1>, module2: Module<I, I2>): {
+  shared: LikeC4SharedServices;
+  likec4: I;
+};
+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;
+};
+/**
+ * Most probably you don't need to use this function directly.
+ * Use {@link createLanguageServices} instead.
+ * @internal
+ */
+declare function createSharedServices(context?: Partial<LanguageServicesContext>): LikeC4SharedServices;
+//#endregion
+export { LanguageServicesContext, LikeC4AddedServices, LikeC4Services, LikeC4SharedServices, NoFileSystem, NoLikeC4ManualLayouts, NoMCPServer, createLanguageServices, createLikeC4Module, createSharedServices };

package/dist/module.mjs

@@ -0,0 +1 @@
+import{Cr as NoFileSystem,Tr as NoLikeC4ManualLayouts,a as LikeC4GeneratedSharedModule,i as LikeC4GeneratedModule}from"./_chunks/utils.mjs";import{A as AstNodeDescriptionProvider,C as LikeC4DocumentHighlightProvider,D as LikeC4WorkspaceManager,E as DefaultLikeC4LanguageServices,M as LikeC4DocumentationProvider,O as LangiumDocuments,S as LikeC4DocumentLinkProvider,T as LikeC4CodeLensProvider,_ as FqnIndex,a as LikeC4ScopeProvider,b as LikeC4HoverProvider,c as LikeC4ModelChanges,d as registerValidationChecks,f as LikeC4DocumentValidator,g as DeploymentsIndex,h as LastSeenArtifacts,i as Rpc,j as LikeC4Formatter,k as IndexManager,l as LikeC4ValueConverter,m as DefaultLikeC4ModelBuilder,n as WorkspaceSymbolProvider,o as LikeC4ScopeComputation,p as LikeC4ModelLocator,r as NodeKindProvider$1,s as LikeC4NameProvider,t as DefaultLikeC4Views,u as LikeC4ModelParser,v as LikeC4SemanticTokenProvider,w as LikeC4CompletionProvider,x as LikeC4DocumentSymbolProvider,y as LikeC4CodeActionProvider}from"./_chunks/LikeC4Views.mjs";import{n as NoMCPServer,t as ProjectsManager}from"./_chunks/ProjectsManager.mjs";import{DocumentState,WorkspaceCache,inject}from"langium";import{onNextTick}from"@likec4/core/utils";import{createDefaultModule,createDefaultSharedModule}from"langium/lsp";import{GraphvizWasmAdapter,QueueGraphvizLayoter}from"@likec4/layouts";function createLikeC4SharedModule(e){return{lsp:{NodeKindProvider:e=>new NodeKindProvider$1(e),WorkspaceSymbolProvider:e=>new WorkspaceSymbolProvider(e)},workspace:{Cache:e=>new WorkspaceCache(e,DocumentState.Validated),IndexManager:e=>new IndexManager(e),LangiumDocuments:e=>new LangiumDocuments(e),ProjectsManager:e=>new ProjectsManager(e),WorkspaceManager:e=>new LikeC4WorkspaceManager(e),FileSystemProvider:()=>e.fileSystemProvider(),FileSystemWatcher:t=>e.fileSystemWatcher(t),ManualLayouts:t=>e.manualLayouts(t)}}}function bind(e){return t=>new e(t)}function createLikeC4Module(e){return{documentation:{DocumentationProvider:bind(LikeC4DocumentationProvider)},validation:{DocumentValidator:bind(LikeC4DocumentValidator)},Rpc:bind(Rpc),mcp:{Server:t=>e.mcpServer(t),ServerFactory:t=>e.mcpServerFactory(t)},likec4:{LanguageServices:bind(DefaultLikeC4LanguageServices),Layouter:e=>new QueueGraphvizLayoter({graphviz:new GraphvizWasmAdapter}),Views:bind(DefaultLikeC4Views),DeploymentsIndex:bind(DeploymentsIndex),ModelChanges:bind(LikeC4ModelChanges),FqnIndex:bind(FqnIndex),ModelParser:bind(LikeC4ModelParser),ModelBuilder:bind(DefaultLikeC4ModelBuilder),ModelLocator:bind(LikeC4ModelLocator),LastSeen:bind(LastSeenArtifacts)},lsp:{CompletionProvider:bind(LikeC4CompletionProvider),DocumentHighlightProvider:bind(LikeC4DocumentHighlightProvider),DocumentSymbolProvider:bind(LikeC4DocumentSymbolProvider),SemanticTokenProvider:bind(LikeC4SemanticTokenProvider),HoverProvider:bind(LikeC4HoverProvider),CodeLensProvider:bind(LikeC4CodeLensProvider),DocumentLinkProvider:bind(LikeC4DocumentLinkProvider),Formatter:bind(LikeC4Formatter),CodeActionProvider:bind(LikeC4CodeActionProvider)},workspace:{AstNodeDescriptionProvider:bind(AstNodeDescriptionProvider)},references:{NameProvider:bind(LikeC4NameProvider),ScopeComputation:bind(LikeC4ScopeComputation),ScopeProvider:bind(LikeC4ScopeProvider)},parser:{ValueConverter:bind(LikeC4ValueConverter)}}}function createLanguageServices(n={},i,a,o){let s=createSharedServices(n),c=inject([createDefaultModule({shared:s}),LikeC4GeneratedModule,createLikeC4Module({...NoMCPServer,...NoFileSystem,...NoLikeC4ManualLayouts,...n}),i,a,o].reduce(_merge,{}));return s.ServiceRegistry.register(c),registerValidationChecks(c),n.connection?onNextTick(()=>c.Rpc.init()):s.workspace.ConfigurationProvider.initialized({}),{shared:s,likec4:c}}function createSharedServices(r={}){let i={...NoMCPServer,...NoFileSystem,...NoLikeC4ManualLayouts,...r};return inject(createDefaultSharedModule(i),LikeC4GeneratedSharedModule,createLikeC4SharedModule(i))}function _merge(e,t){if(t){for(let[n,r]of Object.entries(t))if(r!==void 0){let t=e[n];t!==null&&r!==null&&typeof t==`object`&&typeof r==`object`?e[n]=_merge(t,r):e[n]=r}}return e}export{NoFileSystem,NoLikeC4ManualLayouts,NoMCPServer,createLanguageServices,createLikeC4Module,createSharedServices};

package/dist/protocol.d.mts

@@ -0,0 +1,315 @@
+import { DiagnosticSeverity, DocumentUri, Location, Position, Range, URI } from "vscode-languageserver-types";
+import { ColorLiteral, ComputedLikeC4ModelData, DeploymentFqn, DiagramView, Fqn, LayoutedLikeC4ModelData, LayoutedProjectsView, NonEmptyArray, ProjectId, RelationId, ViewChange, ViewId } from "@likec4/core";
+import { LikeC4ProjectJsonConfig } from "@likec4/config";
+import { NotificationType, NotificationType0, RequestType, RequestType0 } from "vscode-jsonrpc";
+
+//#region src/protocol.d.ts
+declare namespace DidChangeModelNotification {
+  const type: NotificationType<string>;
+  type Type = typeof type;
+}
+/**
+ * Triggered by the language server when projects changed
+ * (number of projects changed, names changed, etc)
+ */
+declare namespace DidChangeProjectsNotification {
+  const type: NotificationType0;
+  type Type = typeof type;
+}
+/**
+ * When the snapshot of a manual layout changes
+ * Send by the editor to the language server
+ */
+declare namespace DidChangeSnapshotNotification {
+  type Params = {
+    snapshotUri: DocumentUri;
+  };
+  const Method: "likec4/onDidChangeSnapshot";
+  const type: NotificationType<Params>;
+  type Type = typeof type;
+}
+/**
+ * When server requests to open a likec4 preview panel
+ * (available only in the editor).
+ * (not the best place, but seems to be working)
+ */
+declare namespace DidRequestOpenViewNotification {
+  type Params = {
+    viewId: ViewId;
+    projectId: ProjectId;
+  };
+  const type: NotificationType<Params>;
+  type Type = typeof type;
+}
+/**
+ * Request to fetch the computed model data
+ * If LSP has multiple projects, the projectId is required.
+ * otherwise throws an error.
+ */
+declare namespace FetchComputedModel {
+  type Params = {
+    projectId?: string | undefined;
+    cleanCaches?: boolean | undefined;
+  };
+  type Res = {
+    model: ComputedLikeC4ModelData | null;
+  };
+  const req: RequestType<Params, Res, void>;
+  type Req = typeof req;
+}
+/**
+ * Request to fetch all views of all projects
+ */
+declare namespace FetchViewsFromAllProjects {
+  type Res = {
+    views: Array<{
+      id: ViewId;
+      title: string;
+      projectId: ProjectId;
+    }>;
+  };
+  const req: RequestType0<Res, void>;
+  type Req = typeof req;
+}
+/**
+ * Request to fetch the layouted model data
+ * If LSP has multiple projects, the projectId is required.
+ * otherwise throws an error.
+ */
+declare namespace FetchLayoutedModel {
+  type Params = {
+    projectId?: string | undefined;
+  };
+  type Res = {
+    model: LayoutedLikeC4ModelData | null;
+  };
+  const req: RequestType<Params, Res, void>;
+  type Req = typeof req;
+}
+/**
+ * Request to layout a view.
+ * If LSP has multiple projects, the projectId is required.
+ */
+declare namespace LayoutView {
+  type Params = {
+    viewId: ViewId;
+    projectId?: string | undefined;
+    layoutType?: 'auto' | 'manual' | undefined;
+  };
+  type Res = {
+    result: {
+      dot: string;
+      diagram: DiagramView;
+    } | null;
+  };
+  const req: RequestType<Params, Res, void>;
+  type Req = typeof req;
+}
+/**
+ * Request to validate all views
+ * If projects ID is provided, it will validate only the views of that project.
+ */
+declare namespace ValidateLayout {
+  type Params = {
+    projectId?: string;
+  };
+  type Res = {
+    result: {
+      uri: string;
+      viewId: ViewId;
+      message: string;
+      severity: DiagnosticSeverity;
+      range: {
+        start: Position;
+        end: Position;
+      };
+    }[] | null;
+  };
+  const req: RequestType<Params, Res, void>;
+  type Req = typeof req;
+}
+/**
+ * Request to reload projects.
+ */
+declare namespace ReloadProjects {
+  type Params = never;
+  type Res = void;
+  const req: RequestType0<void, void>;
+  type Req = typeof req;
+}
+/**
+ * Fetch all non-empty projects.
+ */
+declare namespace FetchProjects {
+  type Params = never;
+  type Res = {
+    projects: {
+      [projectId: ProjectId]: {
+        folder: URI;
+        config: {
+          name: string;
+          title?: string | undefined;
+        };
+        docs: NonEmptyArray<DocumentUri>;
+      };
+    };
+  };
+  const req: RequestType0<Res, void>;
+  type Req = typeof req;
+}
+/**
+ * Request from the client to register a project.
+ */
+declare namespace RegisterProject {
+  type Params = {
+    folderUri: URI;
+    config: LikeC4ProjectJsonConfig;
+    configUri?: never;
+  } | {
+    configUri: URI;
+    folderUri?: never;
+    config?: never;
+  };
+  type Res = {
+    id: ProjectId;
+  };
+  const req: RequestType<Params, Res, void>;
+  type Req = typeof req;
+}
+/**
+ * Request to build documents.
+ */
+declare namespace BuildDocuments {
+  type Params = {
+    docs: DocumentUri[];
+  };
+  const req: RequestType<Params, void, void>;
+  type Req = typeof req;
+}
+/**
+ * Request to locate an element, relation, deployment or view.
+ * If LSP has multiple projects, the projectId is required.
+ */
+declare namespace Locate {
+  type Params =
+  /**
+   * Locate an element by its fqn
+   */
+  {
+    element: Fqn;
+    projectId?: string | undefined;
+    property?: string;
+  }
+  /**
+   * Locate a relation by its id
+   */
+  | {
+    projectId?: string | undefined;
+    relation: RelationId;
+  }
+  /**
+   * Locate a deployment by its fqn
+   */
+  | {
+    deployment: DeploymentFqn;
+    projectId?: string | undefined;
+    property?: string;
+  }
+  /**
+   * Locate a step in a dynamic view by its astPath
+   */
+  | {
+    view: ViewId;
+    astPath: string;
+    projectId?: string | undefined;
+  }
+  /**
+   * Locate a view by its id
+   */
+  | {
+    view: ViewId;
+    projectId?: string | undefined;
+  };
+  type Res = Location | null;
+  const req: RequestType<Params, Res, void>;
+  type Req = typeof req;
+}
+/**
+ * Request to change the view
+ * If LSP has multiple projects, the projectId is required.
+ */
+declare namespace ChangeView {
+  type Params = {
+    viewId: ViewId;
+    change: ViewChange;
+    projectId?: string | undefined;
+  };
+  type Res = {
+    success: true;
+    location: Location | null;
+  } | {
+    success: false;
+    location?: Location | null;
+    error: string;
+  };
+  const req: RequestType<Params, Res, void>;
+  type Req = typeof req;
+}
+/**
+ * Request to fetch telemetry metrics
+ */
+declare namespace FetchTelemetryMetrics {
+  type Res = {
+    metrics: null | {
+      elementKinds: number;
+      deploymentKinds: number;
+      relationshipKinds: number;
+      tags: number;
+      customColors: number;
+      elements: number;
+      deploymentNodes: number;
+      relationships: number;
+      views: number;
+      projects: number;
+    };
+  };
+  const req: RequestType0<Res, void>;
+  type Req = typeof req;
+}
+/**
+ * Request to fetch all tags of a document
+ */
+declare namespace GetDocumentTags {
+  type Params = {
+    documentUri: DocumentUri;
+  };
+  type Res = {
+    /**
+     * Project ID this document belongs to (if any)
+     */
+    projectId: ProjectId;
+    /**
+     * Used tags in the document
+     */
+    tags: Array<{
+      name: string;
+      range: Range;
+      color: ColorLiteral;
+      isSpecification?: boolean;
+    }>;
+  };
+  const req: RequestType<Params, Res, void>;
+  type Req = typeof req;
+}
+/**
+ * Request to fetch projects overview diagram
+ */
+declare namespace FetchProjectsOverview {
+  type Res = {
+    projectsView: LayoutedProjectsView | null;
+  };
+  const req: RequestType0<Res, void>;
+  type Req = typeof req;
+}
+//#endregion
+export { BuildDocuments, ChangeView, DidChangeModelNotification, DidChangeProjectsNotification, DidChangeSnapshotNotification, DidRequestOpenViewNotification, FetchComputedModel, FetchLayoutedModel, FetchProjects, FetchProjectsOverview, FetchTelemetryMetrics, FetchViewsFromAllProjects, GetDocumentTags, LayoutView, Locate, RegisterProject, ReloadProjects, ValidateLayout };

package/dist/protocol.mjs

@@ -0,0 +1 @@
+import{NotificationType,NotificationType0,RequestType,RequestType0}from"vscode-jsonrpc";let DidChangeModelNotification;(function(t){t.type=new NotificationType(`likec4/onDidChangeModel`)})(DidChangeModelNotification||={});let DidChangeProjectsNotification;(function(e){e.type=new NotificationType0(`likec4/onDidChangeProjects`)})(DidChangeProjectsNotification||={});let DidChangeSnapshotNotification;(function(t){t.type=new NotificationType(t.Method=`likec4/onDidChangeSnapshot`)})(DidChangeSnapshotNotification||={});let DidRequestOpenViewNotification;(function(t){t.type=new NotificationType(`likec4/onRequestOpenView`)})(DidRequestOpenViewNotification||={});let FetchComputedModel;(function(e){e.req=new RequestType(`likec4/fetchComputedModel`)})(FetchComputedModel||={});let FetchViewsFromAllProjects;(function(e){e.req=new RequestType0(`likec4/fetchViewsFromAllProjects`)})(FetchViewsFromAllProjects||={});let FetchLayoutedModel;(function(e){e.req=new RequestType(`likec4/fetchLayoutedModel`)})(FetchLayoutedModel||={});let LayoutView;(function(e){e.req=new RequestType(`likec4/layout-view`)})(LayoutView||={});let ValidateLayout;(function(e){e.req=new RequestType(`likec4/validate-layout`)})(ValidateLayout||={});let ReloadProjects;(function(e){e.req=new RequestType0(`likec4/reload-projects`)})(ReloadProjects||={});let FetchProjects;(function(e){e.req=new RequestType0(`likec4/fetch-projects`)})(FetchProjects||={});let RegisterProject;(function(e){e.req=new RequestType(`likec4/register-project`)})(RegisterProject||={});let BuildDocuments;(function(e){e.req=new RequestType(`likec4/build`)})(BuildDocuments||={});let Locate;(function(e){e.req=new RequestType(`likec4/locate`)})(Locate||={});let ChangeView;(function(e){e.req=new RequestType(`likec4/change-view`)})(ChangeView||={});let FetchTelemetryMetrics;(function(e){e.req=new RequestType0(`likec4/metrics`)})(FetchTelemetryMetrics||={});let GetDocumentTags;(function(e){e.req=new RequestType(`likec4/document-tags`)})(GetDocumentTags||={});let FetchProjectsOverview;(function(e){e.req=new RequestType0(`likec4/fetch-projects-overview`)})(FetchProjectsOverview||={});export{BuildDocuments,ChangeView,DidChangeModelNotification,DidChangeProjectsNotification,DidChangeSnapshotNotification,DidRequestOpenViewNotification,FetchComputedModel,FetchLayoutedModel,FetchProjects,FetchProjectsOverview,FetchTelemetryMetrics,FetchViewsFromAllProjects,GetDocumentTags,LayoutView,Locate,RegisterProject,ReloadProjects,ValidateLayout};

package/filesystem/package.json

@@ -0,0 +1,4 @@
+{
+  "types": "../dist/filesystem/index.d.mts",
+  "module": "../dist/filesystem/index.mjs"
+}

package/likec4lib/package.json

@@ -1,4 +1,4 @@
 {
-  "types": "../dist/likec4lib.d.ts",
-  "module": "../dist/likec4lib.js"
+  "types": "../dist/likec4lib.d.mts",
+  "module": "../dist/likec4lib.mjs"
 }

package/mcp/package.json

@@ -0,0 +1,4 @@
+{
+  "types": "../dist/mcp/index.d.mts",
+  "module": "../dist/mcp/index.mjs"
+}

package/module/package.json

@@ -0,0 +1,4 @@
+{
+  "types": "../dist/module.d.mts",
+  "module": "../dist/module.mjs"
+}