@likec4/language-server 0.6.2 → 0.6.3

package/dist/module.js

@@ -0,0 +1,65 @@
+import { createDefaultModule, createDefaultSharedModule, EmptyFileSystem, inject } from 'langium';
+import { LikeC4GeneratedModule, LikeC4GeneratedSharedModule } from './generated/module';
+import { LikeC4DocumentSymbolProvider, LikeC4HoverProvider, LikeC4SemanticTokenProvider } from './lsp';
+import { FqnIndex, LikeC4ModelBuilder, LikeC4ModelLocator } from './model';
+import { LikeC4ScopeComputation, LikeC4ScopeProvider } from './references';
+import { registerProtocolHandlers } from './registerProtocolHandlers';
+import { LikeC4CodeLensProvider, LikeC4WorkspaceManager } from './shared';
+import { registerValidationChecks } from './validation';
+function bind(Type) {
+    return (services) => new Type(services);
+}
+export const LikeC4Module = {
+    likec4: {
+        FqnIndex: bind(FqnIndex),
+        ModelBuilder: bind(LikeC4ModelBuilder),
+        ModelLocator: bind(LikeC4ModelLocator)
+        // Model: bind(LikeC4Model),
+        // Model: bind(LikeC4Model),
+        // SpecIndex: bind(LikeC4SpecIndex),
+        // Validator: bind(LikeC4Validator)
+    },
+    lsp: {
+        DocumentSymbolProvider: bind(LikeC4DocumentSymbolProvider),
+        SemanticTokenProvider: bind(LikeC4SemanticTokenProvider),
+        HoverProvider: bind(LikeC4HoverProvider)
+    },
+    //
+    //   // Formatter: bind(LikeC4Formatter),
+    //
+    // },
+    references: {
+        ScopeComputation: bind(LikeC4ScopeComputation),
+        ScopeProvider: bind(LikeC4ScopeProvider)
+    }
+};
+const LikeC4SharedModule = {
+    ...LikeC4GeneratedSharedModule,
+    workspace: {
+        WorkspaceManager: services => new LikeC4WorkspaceManager(services)
+    },
+    lsp: {
+        CodeLensProvider: services => new LikeC4CodeLensProvider(services)
+    }
+};
+export function createLanguageServices(context) {
+    // const connection = context.connection
+    // if (connection) {
+    //   logger.log = connection.console.log.bind(connection.console)
+    //   logger.info = connection.console.info.bind(connection.console)
+    //   logger.warn = connection.console.warn.bind(connection.console)
+    //   logger.error = connection.console.error.bind(connection.console)
+    //   logger.debug = connection.tracer.log.bind(connection.tracer)
+    //   logger.trace = connection.tracer.log.bind(connection.tracer)
+    // }
+    const moduleContext = {
+        ...EmptyFileSystem,
+        ...context
+    };
+    const shared = inject(createDefaultSharedModule(moduleContext), LikeC4SharedModule);
+    const likec4 = inject(createDefaultModule({ shared }), LikeC4GeneratedModule, LikeC4Module);
+    shared.ServiceRegistry.register(likec4);
+    registerValidationChecks(likec4);
+    registerProtocolHandlers(likec4);
+    return { shared, likec4 };
+}

package/dist/references/index.d.ts

@@ -0,0 +1,2 @@
+export * from './scope-computation';
+export * from './scope-provider';

package/dist/references/index.js

@@ -0,0 +1,2 @@
+export * from './scope-computation';
+export * from './scope-provider';

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

@@ -0,0 +1,10 @@
+import { DefaultScopeComputation, MultiMap, type AstNodeDescription, type PrecomputedScopes } from 'langium';
+import type { CancellationToken } from 'vscode-languageserver-protocol';
+import { ast, type LikeC4LangiumDocument } from '../ast';
+type ElementsContainer = ast.Model | ast.ElementBody | ast.ExtendElementBody;
+export declare class LikeC4ScopeComputation extends DefaultScopeComputation {
+    computeExports(document: LikeC4LangiumDocument, _cancelToken: CancellationToken): Promise<AstNodeDescription[]>;
+    computeLocalScopes(document: LikeC4LangiumDocument, _cancelToken: CancellationToken): Promise<PrecomputedScopes>;
+    protected processContainer(container: ElementsContainer, scopes: PrecomputedScopes, document: LikeC4LangiumDocument): MultiMap<string, AstNodeDescription>;
+}
+export {};

package/dist/references/scope-computation.js

@@ -0,0 +1,76 @@
+import { DefaultScopeComputation, MultiMap } from 'langium';
+import { ast } from '../ast';
+export class LikeC4ScopeComputation extends DefaultScopeComputation {
+    // constructor(services: LikeC4Services) {
+    //   super(services)
+    // }
+    computeExports(document, _cancelToken) {
+        const { specification, model, views } = document.parseResult.value;
+        const docExports = [];
+        if (specification) {
+            for (const { kind } of specification.elementKinds) {
+                docExports.push(this.descriptions.createDescription(kind, kind.name, document));
+            }
+            for (const { tag } of specification.tags) {
+                docExports.push(this.descriptions.createDescription(tag, tag.name, document));
+                docExports.push(this.descriptions.createDescription(tag, '#' + tag.name, document));
+            }
+        }
+        if (model) {
+            for (const elAst of model.elements) {
+                if (ast.isElement(elAst)) {
+                    docExports.push(this.descriptions.createDescription(elAst, elAst.name, document));
+                }
+            }
+        }
+        if (views) {
+            for (const viewAst of views.views) {
+                if ('name' in viewAst) {
+                    docExports.push(this.descriptions.createDescription(viewAst, viewAst.name, document));
+                }
+            }
+        }
+        return Promise.resolve(docExports);
+    }
+    async computeLocalScopes(document, _cancelToken) {
+        const root = document.parseResult.value;
+        const scopes = new MultiMap();
+        if (root.model) {
+            const nested = this.processContainer(root.model, scopes, document);
+            scopes.addAll(root, nested.values());
+        }
+        return Promise.resolve(scopes);
+    }
+    processContainer(container, scopes, document) {
+        const localScope = new MultiMap();
+        const nestedScopes = new MultiMap();
+        for (const el of container.elements) {
+            if (ast.isRelation(el)) {
+                continue;
+            }
+            let subcontainer;
+            if (ast.isElement(el)) {
+                localScope.add(el.name, this.descriptions.createDescription(el, el.name, document));
+                subcontainer = el.body;
+            }
+            else if (ast.isExtendElement(el)) {
+                subcontainer = el.body;
+            }
+            if (subcontainer && subcontainer.elements.length > 0) {
+                const nested = this.processContainer(subcontainer, scopes, document);
+                for (const [nestedName, desc] of nested) {
+                    nestedScopes.add(nestedName, desc);
+                }
+            }
+        }
+        for (const [name, descriptions] of nestedScopes.entriesGroupedByKey()) {
+            // If name is unique for current scope
+            if (!localScope.has(name) && descriptions.length === 1) {
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                localScope.add(name, descriptions[0]);
+            }
+        }
+        scopes.addAll(container, localScope.values());
+        return localScope;
+    }
+}

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

@@ -0,0 +1,15 @@
+import type { AstNode } from 'langium';
+import { DefaultScopeProvider, type ReferenceInfo, type Scope } from 'langium';
+import type { LikeC4Services } from '../module';
+export declare class LikeC4ScopeProvider extends DefaultScopeProvider {
+    private fqnIndex;
+    constructor(services: LikeC4Services);
+    private scopeElementRef;
+    private scopeElementView;
+    getScope(context: ReferenceInfo): Scope;
+    protected computeScope(node: AstNode, referenceType: string): Scope;
+    /**
+     * Create a global scope filtered for the given reference type.
+     */
+    protected getGlobalScope(referenceType: string): Scope;
+}

package/dist/references/scope-provider.js

@@ -0,0 +1,110 @@
+import { DONE_RESULT, DefaultScopeProvider, EMPTY_SCOPE, StreamImpl, StreamScope, getDocument, stream, EMPTY_STREAM } from 'langium';
+import { ast } from '../ast';
+import { elementRef, isElementRefHead, parentStrictElementRef, strictElementRefFqn } from '../elementRef';
+export class LikeC4ScopeProvider extends DefaultScopeProvider {
+    fqnIndex;
+    constructor(services) {
+        super(services);
+        this.fqnIndex = services.likec4.FqnIndex;
+    }
+    scopeElementRef(ref) {
+        const parentNode = ref.$container;
+        if (!ast.isElementRef(parentNode)) {
+            throw new Error('Expected be inside ElementRef');
+        }
+        return new StreamImpl(() => {
+            const parent = parentNode.el.ref;
+            const fqn = parent && this.fqnIndex.get(parent);
+            if (fqn) {
+                return this.fqnIndex.uniqueDescedants(fqn).iterator();
+            }
+            return null;
+        }, iterator => {
+            if (iterator) {
+                return iterator.next();
+            }
+            return DONE_RESULT;
+        });
+    }
+    scopeElementView({ viewOf }) {
+        if (!viewOf) {
+            return EMPTY_STREAM;
+        }
+        return new StreamImpl(() => {
+            const target = elementRef(viewOf);
+            const fqn = target && this.fqnIndex.get(target);
+            if (fqn) {
+                return this.fqnIndex.uniqueDescedants(fqn).iterator();
+            }
+            return null;
+        }, iterator => {
+            if (iterator) {
+                return iterator.next();
+            }
+            return DONE_RESULT;
+        });
+    }
+    getScope(context) {
+        try {
+            const referenceType = this.reflection.getReferenceType(context);
+            const node = context.container;
+            // const path = this.services.workspace.AstNodeLocator.getAstNodePath(node)
+            if (referenceType === ast.Element) {
+                if (ast.isStrictElementRef(node)) {
+                    if (isElementRefHead(node)) {
+                        return this.getGlobalScope(referenceType);
+                    }
+                    const parent = parentStrictElementRef(node);
+                    return new StreamScope(this.fqnIndex.directChildrenOf(parent));
+                }
+                if (ast.isElementRef(node) && !isElementRefHead(node)) {
+                    return new StreamScope(this.scopeElementRef(node));
+                }
+            }
+            return this.computeScope(node, referenceType);
+        }
+        catch (e) {
+            console.error(e);
+            // logger.error(e)
+            return EMPTY_SCOPE;
+        }
+    }
+    computeScope(node, referenceType) {
+        const scopes = [];
+        const doc = getDocument(node);
+        const precomputed = doc.precomputedScopes;
+        const byReferenceType = (desc) => this.reflection.isSubtype(desc.type, referenceType);
+        if (precomputed) {
+            const elements = precomputed.get(node).filter(byReferenceType);
+            if (elements.length > 0) {
+                scopes.push(stream(elements));
+            }
+            let container = node.$container;
+            while (container) {
+                const elements = precomputed.get(container).filter(byReferenceType);
+                if (elements.length > 0) {
+                    scopes.push(stream(elements));
+                }
+                if (referenceType === ast.Element) {
+                    if (ast.isExtendElementBody(container)) {
+                        const extendsOf = strictElementRefFqn(container.$container.element);
+                        scopes.push(this.fqnIndex.uniqueDescedants(extendsOf));
+                    }
+                    if (ast.isViewRule(container)) {
+                        scopes.push(this.scopeElementView(container.$container));
+                    }
+                }
+                container = container.$container;
+            }
+        }
+        return scopes.reduceRight((outerScope, elements) => {
+            return this.createScope(elements, outerScope);
+        }, this.getGlobalScope(referenceType));
+    }
+    /**
+     * Create a global scope filtered for the given reference type.
+     */
+    getGlobalScope(referenceType) {
+        return new StreamScope(this.indexManager.allElements(referenceType));
+    }
+}

package/dist/registerProtocolHandlers.d.ts

@@ -0,0 +1,2 @@
+import type { LikeC4Services } from './module';
+export declare function registerProtocolHandlers(services: LikeC4Services): void;

package/dist/registerProtocolHandlers.js

@@ -0,0 +1,64 @@
+import { logger } from './logger';
+import { buildDocuments, fetchLikeC4Model, locateElement, locateRelation, locateView } from '@likec4/language-protocol';
+export function registerProtocolHandlers(services) {
+    const connection = services.shared.lsp.Connection;
+    if (!connection) {
+        return;
+    }
+    const modelBuilder = services.likec4.ModelBuilder;
+    const modelLocator = services.likec4.ModelLocator;
+    const LangiumDocuments = services.shared.workspace.LangiumDocuments;
+    connection.onRequest(fetchLikeC4Model, async (_cancelToken) => {
+        let model;
+        try {
+            model = modelBuilder.buildModel() ?? null;
+        }
+        catch (e) {
+            model = null;
+            logger.error(e);
+        }
+        return Promise.resolve({
+            model: model ?? null
+        });
+    });
+    connection.onRequest(buildDocuments, async (docs, cancelToken) => {
+        const changed = [];
+        for (const d of docs) {
+            const uri = d;
+            if (LangiumDocuments.hasDocument(uri)) {
+                changed.push(uri);
+            }
+            else {
+                logger.error(`LangiumDocuments does not have document: ${uri.toString()}`);
+            }
+        }
+        logger.debug(`Received request to rebuild: [
+      ${changed.map(d => d.toString()).join('\n      ')}
+    ]`);
+        await services.shared.workspace.DocumentBuilder.update(changed, [], cancelToken);
+    });
+    connection.onRequest(locateElement, async ({ element, property }, _cancelToken) => {
+        try {
+            return Promise.resolve(modelLocator.locateElement(element, property ?? 'name'));
+        }
+        catch (e) {
+            return Promise.reject(e);
+        }
+    });
+    connection.onRequest(locateRelation, ({ id }, _cancelToken) => {
+        try {
+            return Promise.resolve(modelLocator.locateRelation(id));
+        }
+        catch (e) {
+            return Promise.reject(e);
+        }
+    });
+    connection.onRequest(locateView, ({ id }, _cancelToken) => {
+        try {
+            return Promise.resolve(modelLocator.locateView(id));
+        }
+        catch (e) {
+            return Promise.reject(e);
+        }
+    });
+}

package/dist/shared/CodeLensProvider.d.ts

@@ -0,0 +1,8 @@
+import type { LangiumDocument, LangiumSharedServices, MaybePromise } from 'langium';
+import type { CodeLensProvider } from 'langium/lib/lsp/code-lens-provider';
+import type { CancellationToken, CodeLens, CodeLensParams } from 'vscode-languageserver-protocol';
+export declare class LikeC4CodeLensProvider implements CodeLensProvider {
+    private services;
+    constructor(services: LangiumSharedServices);
+    provideCodeLens(doc: LangiumDocument, _params: CodeLensParams, _cancelToken?: CancellationToken): MaybePromise<CodeLens[] | undefined>;
+}

package/dist/shared/CodeLensProvider.js

@@ -0,0 +1,35 @@
+import { ElementViewOps, isParsedLikeC4LangiumDocument } from '../ast';
+export class LikeC4CodeLensProvider {
+    services;
+    constructor(services) {
+        this.services = services;
+        //
+    }
+    provideCodeLens(doc, _params, _cancelToken) {
+        if (!isParsedLikeC4LangiumDocument(doc)) {
+            return;
+        }
+        return doc.parseResult.value.views?.views.flatMap(ast => {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const viewId = ElementViewOps.readId(ast);
+            const range = ast.$cstNode?.range;
+            if (!range || !viewId) {
+                return [];
+            }
+            return {
+                range: {
+                    start: range.start,
+                    end: {
+                        line: range.start.line,
+                        character: range.start.character + 4
+                    }
+                },
+                command: {
+                    command: 'likec4.open-preview',
+                    arguments: [viewId],
+                    title: 'open preview'
+                }
+            };
+        });
+    }
+}

package/dist/shared/WorkspaceManager.d.ts

@@ -0,0 +1,13 @@
+import type { LangiumDocument, LangiumDocumentFactory, LangiumSharedServices } from 'langium';
+import { DefaultWorkspaceManager } from 'langium';
+import type { WorkspaceFolder } from 'vscode-languageserver-protocol';
+export declare class LikeC4WorkspaceManager extends DefaultWorkspaceManager {
+    protected readonly documentFactory: LangiumDocumentFactory;
+    constructor(services: LangiumSharedServices);
+    /**
+     * Load all additional documents that shall be visible in the context of the given workspace
+     * folders and add them to the collector. This can be used to include built-in libraries of
+     * your language, which can be either loaded from provided files or constructed in memory.
+     */
+    protected loadAdditionalDocuments(folders: WorkspaceFolder[], collector: (document: LangiumDocument) => void): Promise<void>;
+}

package/dist/shared/WorkspaceManager.js

@@ -0,0 +1,19 @@
+import { DefaultWorkspaceManager } from 'langium';
+import { URI } from 'vscode-uri';
+import * as builtin from '../builtin';
+export class LikeC4WorkspaceManager extends DefaultWorkspaceManager {
+    documentFactory;
+    constructor(services) {
+        super(services);
+        this.documentFactory = services.workspace.LangiumDocumentFactory;
+    }
+    /**
+     * Load all additional documents that shall be visible in the context of the given workspace
+     * folders and add them to the collector. This can be used to include built-in libraries of
+     * your language, which can be either loaded from provided files or constructed in memory.
+     */
+    loadAdditionalDocuments(folders, collector) {
+        collector(this.documentFactory.fromString(builtin.specification.document, URI.parse(builtin.specification.uri)));
+        return Promise.resolve();
+    }
+}

package/dist/shared/index.d.ts

@@ -0,0 +1,2 @@
+export * from './CodeLensProvider';
+export * from './WorkspaceManager';

package/dist/shared/index.js

@@ -0,0 +1,2 @@
+export * from './CodeLensProvider';
+export * from './WorkspaceManager';

package/dist/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function failExpectedNever(arg: never): never;
+export declare function ignoreNeverInRuntime(arg: never): void;

package/dist/utils.js

@@ -0,0 +1,7 @@
+export function failExpectedNever(arg) {
+    throw new Error(`Unexpected value: ${JSON.stringify(arg)}`);
+}
+export function ignoreNeverInRuntime(arg) {
+    console.warn(`Unexpected and ignored value: ${JSON.stringify(arg)}`);
+    // throw new Error(`Unexpected value: ${arg}`);
+}

package/dist/validation/element.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import type { ValidationCheck } from 'langium';
+import type { ast } from '../ast';
+import type { LikeC4Services } from '../module';
+export declare const elementChecks: (services: LikeC4Services) => ValidationCheck<ast.Element>;

package/dist/validation/element.js

@@ -0,0 +1,20 @@
+export const elementChecks = (services) => {
+    const fqnIndex = services.likec4.FqnIndex;
+    return (el, accept) => {
+        const fqn = fqnIndex.get(el);
+        if (!fqn) {
+            accept('error', 'Not indexed', {
+                node: el,
+                property: 'name'
+            });
+            return;
+        }
+        const withSameFqn = fqnIndex.byFqn(fqn);
+        if (withSameFqn.length > 1) {
+            accept('error', `Duplicate element name ${el.name !== fqn ? el.name + ' (' + fqn + ')' : el.name}`, {
+                node: el,
+                property: 'name'
+            });
+        }
+    };
+};

package/dist/validation/index.d.ts

@@ -0,0 +1,2 @@
+import type { LikeC4Services } from '../module';
+export declare function registerValidationChecks(services: LikeC4Services): void;

package/dist/validation/index.js

@@ -0,0 +1,22 @@
+import { elementChecks } from './element';
+import { relationChecks } from './relation';
+import { elementKindChecks, tagChecks } from './specification';
+import { viewChecks } from './view';
+export function registerValidationChecks(services) {
+    const registry = services.validation.ValidationRegistry;
+    // const checks: ValidationChecks = {
+    // Element: validator.checkElementNameDuplicates,
+    // Tag: validator.checkTagDuplicates,
+    // ElementKind: elementKindChecks(services),
+    // ElementStyleProperty: validator.checkElementStyleProperty,
+    // View: validator.checkViewNameDuplicates,
+    // ColorStyleProperty: validator.checkColorStyleProperty,
+    // }
+    registry.register({
+        ElementView: viewChecks(services),
+        Element: elementChecks(services),
+        ElementKind: elementKindChecks(services),
+        Relation: relationChecks(services),
+        Tag: tagChecks(services)
+    });
+}

package/dist/validation/relation.d.ts

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

package/dist/validation/relation.js

@@ -0,0 +1,53 @@
+import { resolveRelationPoints } from '../ast';
+import { isSameHierarchy } from '@likec4/core/utils';
+export const relationChecks = (services) => {
+    const fqnIndex = services.likec4.FqnIndex;
+    return (el, accept) => {
+        try {
+            const coupling = resolveRelationPoints(el);
+            const target = fqnIndex.get(coupling.target);
+            if (!target) {
+                return accept('error', 'Invalid target', {
+                    node: el,
+                    property: 'target'
+                });
+            }
+            const source = fqnIndex.get(coupling.source);
+            if (!source) {
+                return accept('error', 'Invalid source', {
+                    node: el
+                });
+            }
+            if (isSameHierarchy(source, target)) {
+                return accept('error', 'Invalid relation (same hierarchy)', {
+                    node: el
+                });
+            }
+        }
+        catch (e) {
+            if (e instanceof Error) {
+                return accept('error', e.message, {
+                    node: el
+                });
+            }
+            accept('error', 'Invalid relation', {
+                node: el
+            });
+        }
+        // const fqn = fqnIndex.get(el)
+        // if (!fqn) {
+        //   accept('error', 'Not indexed', {
+        //     node: el,
+        //     property: 'name',
+        //   })
+        //   return
+        // }
+        // const withSameFqn = fqnIndex.byFqn(fqn)
+        // if (withSameFqn.length > 1) {
+        //   accept('error', `Duplicate element name ${el.name !== fqn ? el.name +' (' + fqn + ')' : el.name}`, {
+        //     node: el,
+        //     property: 'name',
+        //   })
+        // }
+    };
+};

package/dist/validation/specification.d.ts

@@ -0,0 +1,5 @@
+import type { ValidationCheck } from 'langium';
+import { ast } from '../ast';
+import type { LikeC4Services } from '../module';
+export declare const elementKindChecks: (services: LikeC4Services) => ValidationCheck<ast.ElementKind>;
+export declare const tagChecks: (services: LikeC4Services) => ValidationCheck<ast.Tag>;

package/dist/validation/specification.js

@@ -0,0 +1,33 @@
+import { ast } from '../ast';
+export const elementKindChecks = (services) => {
+    const index = services.shared.workspace.IndexManager;
+    return (node, accept) => {
+        const sameKinds = index
+            .allElements(ast.ElementKind)
+            .filter(n => n.name === node.name)
+            .limit(2)
+            .count();
+        if (sameKinds > 1) {
+            accept('error', `Duplicate element kind '${node.name}'`, {
+                node: node,
+                property: 'name'
+            });
+        }
+    };
+};
+export const tagChecks = (services) => {
+    const index = services.shared.workspace.IndexManager;
+    return (node, accept) => {
+        const sameKinds = index
+            .allElements(ast.Tag)
+            .filter(n => n.name === node.name)
+            .limit(2)
+            .count();
+        if (sameKinds > 1) {
+            accept('error', `Duplicate tag '${node.name}'`, {
+                node: node,
+                property: 'name'
+            });
+        }
+    };
+};

package/dist/validation/view.d.ts

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

package/dist/validation/view.js

@@ -0,0 +1,20 @@
+import { ast } from '../ast';
+export const viewChecks = (services) => {
+    const index = services.shared.workspace.IndexManager;
+    return (el, accept) => {
+        if (!el.name) {
+            return;
+        }
+        const anotherViews = index
+            .allElements(ast.View)
+            .filter(n => n.name === el.name)
+            .limit(2)
+            .count();
+        if (anotherViews > 1) {
+            accept('error', `Duplicate view '${el.name}'`, {
+                node: el,
+                property: 'name'
+            });
+        }
+    };
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@likec4/language-server",
   "description": "LikeC4 Language Server",
-  "version": "0.6.2",
+  "version": "0.6.3",
   "license": "MIT",
   "type": "module",
   "bugs": "https://github.com/likec4/likec4/issues",
@@ -66,8 +66,8 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@likec4/core": "0.6.2",
-    "@likec4/language-protocol": "0.6.2",
+    "@likec4/core": "0.6.3",
+    "@likec4/language-protocol": "0.6.3",
     "@mobily/ts-belt": "^3.13.1",
     "nanoid": "^4.0.2",
     "object-hash": "^3.0.0",