@likec4/language-server 1.18.0 → 1.19.0

package/dist/LikeC4FileSystem.d.ts

@@ -0,0 +1,13 @@
+import { type FileSystemNode, URI } from 'langium';
+import { NodeFileSystemProvider } from 'langium/node';
+export declare const LikeC4FileSystem: {
+    fileSystemProvider: () => SymLinkTraversingFileSystemProvider;
+};
+/**
+ * A file system provider that follows symbolic links.
+ * @see https://github.com/likec4/likec4/pull/1213
+ */
+declare class SymLinkTraversingFileSystemProvider extends NodeFileSystemProvider {
+    readDirectory(folderPath: URI): Promise<FileSystemNode[]>;
+}
+export {};

package/dist/LikeC4FileSystem.js

@@ -0,0 +1,27 @@
+import { fdir } from "fdir";
+import { URI } from "langium";
+import { NodeFileSystemProvider } from "langium/node";
+import { stat } from "node:fs/promises";
+import { logger } from "./logger.js";
+export const LikeC4FileSystem = {
+  fileSystemProvider: () => new SymLinkTraversingFileSystemProvider()
+};
+class SymLinkTraversingFileSystemProvider extends NodeFileSystemProvider {
+  async readDirectory(folderPath) {
+    const crawled = await new fdir().withSymlinks().withFullPaths().crawl(folderPath.fsPath).withPromise();
+    const entries = [];
+    for (const path of crawled) {
+      try {
+        const stats = await stat(path);
+        entries.push({
+          isFile: stats.isFile(),
+          isDirectory: stats.isDirectory(),
+          uri: URI.file(path)
+        });
+      } catch (error) {
+        logger.error(error);
+      }
+    }
+    return entries;
+  }
+}

package/dist/Rpc.d.ts

@@ -0,0 +1,9 @@
+import type { LikeC4Services } from './module';
+import { Disposable } from 'langium';
+export declare class Rpc implements Disposable {
+    private services;
+    private disposables;
+    constructor(services: LikeC4Services);
+    init(): void;
+    dispose(): void;
+}

package/dist/Rpc.js

@@ -0,0 +1,126 @@
+import { debounce } from "remeda";
+import { logError, logger } from "./logger.js";
+import { nonexhaustive } from "@likec4/core";
+import { Disposable, interruptAndCheck, URI, UriUtils } from "langium";
+import { isLikeC4LangiumDocument } from "./ast.js";
+import { Scheme } from "./likec4lib.js";
+import {
+  buildDocuments,
+  changeView,
+  computeView,
+  fetchComputedModel,
+  fetchModel,
+  locate,
+  onDidChangeModel
+} from "./protocol.js";
+export class Rpc {
+  constructor(services) {
+    this.services = services;
+  }
+  disposables = [];
+  init() {
+    const modelBuilder = this.services.likec4.ModelBuilder;
+    const modelLocator = this.services.likec4.ModelLocator;
+    const modelEditor = this.services.likec4.ModelChanges;
+    const connection = this.services.shared.lsp.Connection;
+    if (!connection) {
+      logger.info(`[ServerRpc] no connection, not initializing`);
+      return;
+    }
+    logger.info(`[ServerRpc] init`);
+    const LangiumDocuments = this.services.shared.workspace.LangiumDocuments;
+    const DocumentBuilder = this.services.shared.workspace.DocumentBuilder;
+    const notifyModelParsed = debounce(
+      () => {
+        connection.sendNotification(onDidChangeModel, "").catch((e) => {
+          logger.error(`[ServerRpc] error sending onDidChangeModel: ${e}`);
+          return Promise.resolve();
+        });
+      },
+      {
+        timing: "trailing",
+        waitMs: 300,
+        maxWaitMs: 1e3
+      }
+    );
+    let isFirstBuild = true;
+    this.disposables.push(
+      Disposable.create(() => {
+        notifyModelParsed.cancel();
+      }),
+      modelBuilder.onModelParsed(() => notifyModelParsed.call()),
+      connection.onRequest(fetchComputedModel, async ({ cleanCaches }, cancelToken) => {
+        if (cleanCaches) {
+          this.services.WorkspaceCache.clear();
+        }
+        const model = await modelBuilder.buildComputedModel(cancelToken);
+        return { model };
+      }),
+      connection.onRequest(fetchModel, async (cancelToken) => {
+        const model = await modelBuilder.buildModel(cancelToken);
+        return { model };
+      }),
+      connection.onRequest(computeView, async ({ viewId }, cancelToken) => {
+        const view = await modelBuilder.computeView(viewId, cancelToken);
+        return { view };
+      }),
+      connection.onRequest(buildDocuments, async ({ docs }, cancelToken) => {
+        const changed = docs.map((d) => URI.parse(d));
+        const notChanged = (uri) => changed.every((c) => !UriUtils.equals(c, uri));
+        const deleted = LangiumDocuments.all.filter((d) => isLikeC4LangiumDocument(d) && notChanged(d.uri) && d.uri.scheme !== Scheme).map((d) => d.uri).toArray();
+        logger.debug(
+          `[ServerRpc] received request to build:
+  changed (total ${changed.length}):${docs.map((d) => "\n    - " + d).join("")}
+  deleted (total ${deleted.length}):${deleted.map((d) => "\n    - " + d.toString()).join("\n")}`
+        );
+        if (!isFirstBuild && changed.length + deleted.length > 0) {
+          await Promise.allSettled(
+            [...changed, ...deleted].map(async (d) => {
+              const uri = d.toString();
+              logger.debug(`clear diagnostics for ${uri}`);
+              try {
+                await connection.sendDiagnostics({
+                  uri,
+                  diagnostics: []
+                });
+              } catch (e) {
+                logger.warn(`error clearing diagnostics for ${uri}: ${e}`);
+              }
+            })
+          );
+          await interruptAndCheck(cancelToken);
+        }
+        isFirstBuild = false;
+        await DocumentBuilder.update(changed, deleted, cancelToken);
+      }),
+      connection.onRequest(locate, (params) => {
+        if ("element" in params) {
+          return modelLocator.locateElement(params.element, params.property ?? "name");
+        }
+        if ("relation" in params) {
+          return modelLocator.locateRelation(params.relation);
+        }
+        if ("view" in params) {
+          return modelLocator.locateView(params.view);
+        }
+        if ("deployment" in params) {
+          return modelLocator.locateDeploymentElement(params.deployment, params.property ?? "name");
+        }
+        nonexhaustive(params);
+      }),
+      connection.onRequest(changeView, async (request, _cancelToken) => {
+        return await modelEditor.applyChange(request);
+      })
+    );
+  }
+  dispose() {
+    let item;
+    while (item = this.disposables.pop()) {
+      try {
+        item.dispose();
+      } catch (e) {
+        logError(e);
+      }
+    }
+  }
+}

package/dist/ast.d.ts

@@ -0,0 +1,200 @@
+import type * as c4 from '@likec4/core';
+import type { AstNode, AstNodeDescription, DiagnosticInfo, LangiumDocument, MultiMap } from 'langium';
+import type { ConditionalPick, SetRequired, ValueOf, Writable } from 'type-fest';
+import type { Diagnostic } from 'vscode-languageserver-types';
+import type { LikeC4Grammar } from './generated/ast';
+import * as ast from './generated/ast';
+import type { IsValidFn } from './validation';
+export { ast };
+declare const idattr: unique symbol;
+declare module './generated/ast' {
+    interface Element {
+        [idattr]?: c4.Fqn | undefined;
+    }
+    interface ElementView {
+        [idattr]?: c4.ViewId | undefined;
+    }
+    interface DynamicView {
+        [idattr]?: c4.ViewId | undefined;
+    }
+    interface DeploymentView {
+        [idattr]?: c4.ViewId | undefined;
+    }
+    interface DeploymentNode {
+        [idattr]?: c4.Fqn | undefined;
+    }
+    interface DeployedInstance {
+        [idattr]?: c4.Fqn | undefined;
+    }
+}
+type ParsedElementStyle = {
+    shape?: c4.ElementShape;
+    icon?: c4.IconUrl;
+    color?: c4.Color;
+    border?: c4.BorderStyle;
+    opacity?: number;
+};
+export interface ParsedAstSpecification {
+    tags: Set<c4.Tag>;
+    elements: Record<c4.ElementKind, {
+        technology?: string;
+        notation?: string;
+        style: ParsedElementStyle;
+    }>;
+    relationships: Record<c4.RelationshipKind, {
+        technology?: string;
+        notation?: string;
+        color?: c4.Color;
+        line?: c4.RelationshipLineType;
+        head?: c4.RelationshipArrowType;
+        tail?: c4.RelationshipArrowType;
+    }>;
+    colors: Record<c4.CustomColor, {
+        color: c4.HexColorLiteral;
+    }>;
+    deployments: Record<c4.DeploymentNodeKind, c4.DeploymentNodeKindSpecification>;
+}
+export interface ParsedAstElement {
+    id: c4.Fqn;
+    astPath: string;
+    kind: c4.ElementKind;
+    title: string;
+    description?: string;
+    technology?: string;
+    tags?: c4.NonEmptyArray<c4.Tag>;
+    links?: c4.NonEmptyArray<ParsedLink>;
+    style: ParsedElementStyle;
+    metadata?: {
+        [key: string]: string;
+    };
+}
+export interface ParsedAstRelation {
+    id: c4.RelationId;
+    astPath: string;
+    source: c4.Fqn;
+    target: c4.Fqn;
+    kind?: c4.RelationshipKind;
+    tags?: c4.NonEmptyArray<c4.Tag>;
+    title: string;
+    description?: string;
+    technology?: string;
+    color?: c4.Color;
+    line?: c4.RelationshipLineType;
+    head?: c4.RelationshipArrowType;
+    tail?: c4.RelationshipArrowType;
+    links?: c4.NonEmptyArray<ParsedLink>;
+    navigateTo?: c4.ViewId;
+    metadata?: {
+        [key: string]: string;
+    };
+}
+export type ParsedAstDeployment = c4.DeploymentElement;
+export declare namespace ParsedAstDeployment {
+    type Node = c4.DeploymentNode;
+    type Instance = c4.DeployedInstance;
+}
+export type ParsedAstDeploymentRelation = c4.DeploymentRelation & {
+    astPath: string;
+};
+export type ParsedAstGlobals = Writable<c4.ModelGlobals>;
+export interface ParsedAstElementView {
+    __: 'element';
+    id: c4.ViewId;
+    viewOf?: c4.Fqn;
+    extends?: c4.ViewId;
+    astPath: string;
+    title: string | null;
+    description: string | null;
+    tags: c4.NonEmptyArray<c4.Tag> | null;
+    links: c4.NonEmptyArray<ParsedLink> | null;
+    rules: c4.ViewRule[];
+    manualLayout?: c4.ViewManualLayout;
+}
+export interface ParsedAstDynamicView {
+    __: 'dynamic';
+    id: c4.ViewId;
+    astPath: string;
+    title: string | null;
+    description: string | null;
+    tags: c4.NonEmptyArray<c4.Tag> | null;
+    links: c4.NonEmptyArray<ParsedLink> | null;
+    steps: c4.DynamicViewStepOrParallel[];
+    rules: Array<c4.DynamicViewRule>;
+    manualLayout?: c4.ViewManualLayout;
+}
+export interface ParsedAstDeploymentView {
+    __: 'deployment';
+    id: c4.ViewId;
+    astPath: string;
+    title: string | null;
+    description: string | null;
+    tags: c4.NonEmptyArray<c4.Tag> | null;
+    links: c4.NonEmptyArray<ParsedLink> | null;
+    rules: Array<c4.DeploymentViewRule>;
+}
+export type ParsedAstView = ParsedAstElementView | ParsedAstDynamicView | ParsedAstDeploymentView;
+export declare const ViewOps: {
+    writeId<T extends ast.LikeC4View>(node: T, id: c4.ViewId): T;
+    readId(node: ast.LikeC4View): c4.ViewId | undefined;
+};
+export interface ParsedLink {
+    title?: string;
+    url: string;
+}
+export declare const ElementOps: {
+    writeId(node: ast.Element | ast.DeploymentElement, id: c4.Fqn | null): ast.DeploymentElement | ast.Element;
+    readId(node: ast.Element | ast.DeploymentElement): any;
+};
+export interface DocFqnIndexAstNodeDescription extends AstNodeDescription {
+    fqn: c4.Fqn;
+}
+export interface DeploymentAstNodeDescription extends AstNodeDescription {
+    fqn: string;
+}
+export type LikeC4AstNode = ValueOf<ConditionalPick<ast.LikeC4AstType, AstNode>>;
+type LikeC4DocumentDiagnostic = Diagnostic & DiagnosticInfo<LikeC4AstNode>;
+export interface LikeC4DocumentProps {
+    diagnostics?: Array<LikeC4DocumentDiagnostic>;
+    c4Specification?: ParsedAstSpecification;
+    c4Elements?: ParsedAstElement[];
+    c4Relations?: ParsedAstRelation[];
+    c4Globals?: ParsedAstGlobals;
+    c4Views?: ParsedAstView[];
+    c4Deployments?: ParsedAstDeployment[];
+    c4DeploymentRelations?: ParsedAstDeploymentRelation[];
+    c4fqnIndex?: MultiMap<c4.Fqn, DocFqnIndexAstNodeDescription>;
+}
+type LikeC4GrammarDocument = Omit<LangiumDocument<LikeC4Grammar>, 'diagnostics'>;
+export interface LikeC4LangiumDocument extends LikeC4GrammarDocument, LikeC4DocumentProps {
+}
+export interface FqnIndexedDocument extends SetRequired<LikeC4LangiumDocument, 'c4fqnIndex'> {
+}
+export interface ParsedLikeC4LangiumDocument extends LikeC4GrammarDocument, Required<LikeC4DocumentProps> {
+}
+export declare function isLikeC4LangiumDocument(doc: LangiumDocument): doc is LikeC4LangiumDocument;
+export declare function isFqnIndexedDocument(doc: LangiumDocument): doc is FqnIndexedDocument;
+export declare function isParsedLikeC4LangiumDocument(doc: LangiumDocument): doc is ParsedLikeC4LangiumDocument;
+export declare function streamModel(doc: LikeC4LangiumDocument): Generator<any, void, unknown>;
+export declare function streamDeploymentModel(doc: LikeC4LangiumDocument): Generator<any, void, unknown>;
+export declare function resolveRelationPoints(node: ast.Relation): {
+    source: ast.Element;
+    target: ast.Element;
+};
+export declare function parseAstOpacityProperty({ value }: ast.OpacityProperty): number;
+export declare function toElementStyle(props: Array<ast.StyleProperty> | undefined, isValid: IsValidFn): ParsedElementStyle;
+export declare function toRelationshipStyle(props: ast.RelationshipStyleProperty[] | undefined, isValid: IsValidFn): {
+    color?: c4.Color;
+    line?: c4.RelationshipLineType;
+    head?: c4.RelationshipArrowType;
+    tail?: c4.RelationshipArrowType;
+};
+export declare function toRelationshipStyleExcludeDefaults(props: ast.SpecificationRelationshipKind['props'] | undefined, isValid: IsValidFn): {
+    tail?: any;
+    head?: any;
+    line?: any;
+    color?: any;
+};
+export declare function toColor(astNode: ast.ColorProperty): c4.Color | undefined;
+export declare function toAutoLayout(rule: ast.ViewRuleAutoLayout): c4.ViewRuleAutoLayout;
+export declare function toAstViewLayoutDirection(c4: c4.ViewRuleAutoLayout['direction']): ast.ViewLayoutDirection;
+export declare function elementExpressionFromPredicate(predicate: ast.ElementPredicate): ast.ElementExpression;

package/dist/ast.js

@@ -0,0 +1,276 @@
+import { DefaultArrowType, DefaultLineStyle, DefaultRelationshipColor, LinkedList, nonexhaustive } from "@likec4/core";
+import { DocumentState } from "langium";
+import { clamp, isDefined, isNullish, isTruthy } from "remeda";
+import * as ast from "./generated/ast.js";
+import { LikeC4LanguageMetaData } from "./generated/module.js";
+import { elementRef } from "./utils/elementRef.js";
+export { ast };
+const idattr = Symbol.for("idattr");
+export const ViewOps = {
+  writeId(node, id) {
+    node[idattr] = id;
+    return node;
+  },
+  readId(node) {
+    return node[idattr];
+  }
+};
+export const ElementOps = {
+  writeId(node, id) {
+    if (isNullish(id)) {
+      node[idattr] = void 0;
+    } else {
+      node[idattr] = id;
+    }
+    return node;
+  },
+  readId(node) {
+    return node[idattr];
+  }
+};
+export function isLikeC4LangiumDocument(doc) {
+  return doc.textDocument.languageId === LikeC4LanguageMetaData.languageId;
+}
+export function isFqnIndexedDocument(doc) {
+  return isLikeC4LangiumDocument(doc) && doc.state >= DocumentState.IndexedContent && !!doc.c4fqnIndex;
+}
+export function isParsedLikeC4LangiumDocument(doc) {
+  return isLikeC4LangiumDocument(doc) && doc.state == DocumentState.Validated && !!doc.c4Specification && !!doc.c4Elements && !!doc.c4Relations && !!doc.c4Views && !!doc.c4fqnIndex && !!doc.c4Deployments && !!doc.c4DeploymentRelations;
+}
+export function* streamModel(doc) {
+  const traverseStack = LinkedList.from(doc.parseResult.value.models.flatMap((m) => m.elements));
+  const relations = [];
+  let el;
+  while (el = traverseStack.shift()) {
+    if (ast.isRelation(el)) {
+      relations.push(el);
+      continue;
+    }
+    if (ast.isExtendElement(el)) {
+      if (el.body && el.body.elements.length > 0) {
+        for (const child of el.body.elements) {
+          traverseStack.push(child);
+        }
+      }
+      continue;
+    }
+    if (el.body && el.body.elements.length > 0) {
+      for (const child of el.body.elements) {
+        traverseStack.push(child);
+      }
+    }
+    yield el;
+  }
+  yield* relations;
+  return;
+}
+export function* streamDeploymentModel(doc) {
+  const traverseStack = LinkedList.from(
+    doc.parseResult.value.deployments.flatMap((m) => m.elements)
+  );
+  const relations = [];
+  let el;
+  while (el = traverseStack.shift()) {
+    if (ast.isDeploymentRelation(el)) {
+      relations.push(el);
+      continue;
+    }
+    if (ast.isDeploymentNode(el) && el.body && el.body.elements.length > 0) {
+      for (const child of el.body.elements) {
+        traverseStack.push(child);
+      }
+    }
+    yield el;
+  }
+  yield* relations;
+  return;
+}
+export function resolveRelationPoints(node) {
+  const target = elementRef(node.target);
+  if (!target) {
+    throw new Error("RelationRefError: Invalid reference to target");
+  }
+  if (isDefined(node.source)) {
+    const source = elementRef(node.source);
+    if (!source) {
+      throw new Error("RelationRefError: Invalid reference to source");
+    }
+    return {
+      source,
+      target
+    };
+  }
+  if (!ast.isElementBody(node.$container)) {
+    throw new Error("RelationRefError: Invalid container for sourceless relation");
+  }
+  return {
+    source: node.$container.$container,
+    target
+  };
+}
+export function parseAstOpacityProperty({ value }) {
+  const opacity = parseFloat(value);
+  return isNaN(opacity) ? 100 : clamp(opacity, { min: 0, max: 100 });
+}
+export function toElementStyle(props, isValid) {
+  const result = {};
+  if (!props || props.length === 0) {
+    return result;
+  }
+  for (const prop of props) {
+    if (!isValid(prop)) {
+      continue;
+    }
+    switch (true) {
+      case ast.isBorderProperty(prop): {
+        if (isTruthy(prop.value)) {
+          result.border = prop.value;
+        }
+        break;
+      }
+      case ast.isColorProperty(prop): {
+        const color = toColor(prop);
+        if (isTruthy(color)) {
+          result.color = color;
+        }
+        break;
+      }
+      case ast.isShapeProperty(prop): {
+        if (isTruthy(prop.value)) {
+          result.shape = prop.value;
+        }
+        break;
+      }
+      case ast.isIconProperty(prop): {
+        const icon = prop.libicon?.ref?.name ?? prop.value;
+        if (isTruthy(icon)) {
+          result.icon = icon;
+        }
+        break;
+      }
+      case ast.isOpacityProperty(prop): {
+        result.opacity = parseAstOpacityProperty(prop);
+        break;
+      }
+      default:
+        nonexhaustive(prop);
+    }
+  }
+  return result;
+}
+export function toRelationshipStyle(props, isValid) {
+  const result = {};
+  if (!props || props.length === 0) {
+    return result;
+  }
+  for (const prop of props) {
+    if (!isValid(prop)) {
+      continue;
+    }
+    switch (true) {
+      case ast.isColorProperty(prop): {
+        const color = toColor(prop);
+        if (isTruthy(color)) {
+          result.color = color;
+        }
+        break;
+      }
+      case ast.isLineProperty(prop): {
+        result.line = prop.value;
+        break;
+      }
+      case ast.isArrowProperty(prop): {
+        switch (prop.key) {
+          case "head": {
+            result.head = prop.value;
+            break;
+          }
+          case "tail": {
+            result.tail = prop.value;
+            break;
+          }
+          default: {
+            nonexhaustive(prop);
+          }
+        }
+        break;
+      }
+      default: {
+        nonexhaustive(prop);
+      }
+    }
+  }
+  return result;
+}
+export function toRelationshipStyleExcludeDefaults(props, isValid) {
+  const { color, line, head, tail } = toRelationshipStyle(props?.filter(ast.isRelationshipStyleProperty), isValid);
+  return {
+    ...color && color !== DefaultRelationshipColor ? { color } : {},
+    ...line && line !== DefaultLineStyle ? { line } : {},
+    ...head && head !== DefaultArrowType ? { head } : {},
+    ...tail ? { tail } : {}
+  };
+}
+export function toColor(astNode) {
+  return astNode?.themeColor ?? astNode?.customColor?.$refText;
+}
+export function toAutoLayout(rule) {
+  const rankSep = rule.rankSep;
+  const nodeSep = rule.nodeSep;
+  let direction;
+  switch (rule.direction) {
+    case "TopBottom": {
+      direction = "TB";
+      break;
+    }
+    case "BottomTop": {
+      direction = "BT";
+      break;
+    }
+    case "LeftRight": {
+      direction = "LR";
+      break;
+    }
+    case "RightLeft": {
+      direction = "RL";
+      break;
+    }
+    default:
+      nonexhaustive(rule.direction);
+  }
+  return {
+    direction,
+    ...nodeSep && { nodeSep },
+    ...rankSep && { rankSep }
+  };
+}
+export function toAstViewLayoutDirection(c4) {
+  switch (c4) {
+    case "TB": {
+      return "TopBottom";
+    }
+    case "BT": {
+      return "BottomTop";
+    }
+    case "LR": {
+      return "LeftRight";
+    }
+    case "RL": {
+      return "RightLeft";
+    }
+    default:
+      nonexhaustive(c4);
+  }
+}
+export function elementExpressionFromPredicate(predicate) {
+  if (ast.isElementExpression(predicate)) {
+    return predicate;
+  }
+  if (ast.isElementPredicateWhere(predicate)) {
+    return predicate.subject;
+  }
+  if (ast.isElementPredicateWith(predicate)) {
+    return elementExpressionFromPredicate(predicate.subject);
+  }
+  nonexhaustive(predicate);
+}

package/dist/browser.d.ts

@@ -1,23 +1,9 @@
-import { L as LikeC4SharedServices, a as LikeC4Services } from './shared/language-server.De7S3e5Z.js';
-export { D as DeploymentsIndex, e as DocumentDeploymentsIndex, g as FqnIndex, F as FqnIndexEntry, I as IsValidFn, l as LanguageServicesContext, k as LikeC4AddedServices, h as LikeC4ModelBuilder, i as LikeC4ModelLocator, j as LikeC4ModelParser, d as LikeC4Module, M as ModelParsedListener, f as computeDocumentFqn, c as createCustomLanguageServices, b as createLanguageServices, m as createSharedServices, s as setLogLevel } from './shared/language-server.De7S3e5Z.js';
-import * as vscode_languageserver from 'vscode-languageserver';
-import { BrowserMessageReader, BrowserMessageWriter } from 'vscode-languageserver/browser';
-import 'langium';
-import 'langium/lsp';
-import 'vscode-languageserver-types';
-import '@likec4/core';
-import 'type-fest';
-import './protocol.js';
-import 'vscode-jsonrpc';
-import 'vscode-uri';
-import '@likec4/log';
-
-declare function startLanguageServer(): {
-    connection: vscode_languageserver.Connection;
-    messageReader: BrowserMessageReader;
-    messageWriter: BrowserMessageWriter;
+import { type LikeC4Services, type LikeC4SharedServices } from './module';
+export { logger as lspLogger, setLogLevel } from './logger';
+export type { DocumentParser, LikeC4ModelBuilder, LikeC4ModelLocator, LikeC4ModelParser } from './model';
+export { createCustomLanguageServices, createLanguageServices, LikeC4Module } from './module';
+export type { LikeC4Services, LikeC4SharedServices } from './module';
+export declare function startLanguageServer(): {
     shared: LikeC4SharedServices;
     likec4: LikeC4Services;
 };
-
-export { LikeC4Services, LikeC4SharedServices, startLanguageServer };

package/dist/browser.js

@@ -0,0 +1,13 @@
+import { startLanguageServer as startLanguim } from "langium/lsp";
+import { BrowserMessageReader, BrowserMessageWriter, createConnection } from "vscode-languageserver/browser";
+import { createLanguageServices } from "./module.js";
+export { logger as lspLogger, setLogLevel } from "./logger.js";
+export { createCustomLanguageServices, createLanguageServices, LikeC4Module } from "./module.js";
+export function startLanguageServer() {
+  const messageReader = new BrowserMessageReader(self);
+  const messageWriter = new BrowserMessageWriter(self);
+  const connection = createConnection(messageReader, messageWriter);
+  const services = createLanguageServices({ connection });
+  startLanguim(services.shared);
+  return services;
+}