@likec4/language-server 1.18.0 → 1.19.0

package/src/validation/deployment-checks.ts

@@ -1,5 +1,5 @@
-import { nonNullable } from '@likec4/core'
-import { AstUtils, type ValidationCheck } from 'langium'
+import { FqnRef, isSameHierarchy, nonNullable } from '@likec4/core'
+import { type ValidationCheck, AstUtils } from 'langium'
 import { ast } from '../ast'
 import type { LikeC4Services } from '../module'
 import type { LikeC4NameProvider } from '../references'
@@ -14,7 +14,7 @@ export const deploymentNodeChecks = (services: LikeC4Services): ValidationCheck<
     const nodeName = Names.getName(el)
     if (!nodeName) {
       accept('error', 'DeploymentNode must be named', {
-        node: el
+        node: el,
       })
       return
     }
@@ -23,10 +23,10 @@ export const deploymentNodeChecks = (services: LikeC4Services): ValidationCheck<
     if (RESERVED_WORDS.includes(nodeName)) {
       accept('error', `Reserved word: ${nodeName}`, {
         node: el,
-        range
+        range,
       })
     }
-    const fqnName = DeploymentsIndex.getFqnName(el)
+    const fqnName = DeploymentsIndex.getFqn(el)
 
     const withSameName = DeploymentsIndex.byFqn(fqnName).limit(2).toArray()
     if (withSameName.length > 1) {
@@ -35,8 +35,8 @@ export const deploymentNodeChecks = (services: LikeC4Services): ValidationCheck<
         `Duplicate node name "${fqnName}"`,
         {
           node: el,
-          range
-        }
+          range,
+        },
       )
     }
   })
@@ -50,7 +50,7 @@ export const deployedInstanceChecks = (services: LikeC4Services): ValidationChec
     const artifactName = Names.getName(el)
     if (!artifactName) {
       accept('error', 'Deployed instance must be named, unique inside node', {
-        node: el
+        node: el,
       })
       return
     }
@@ -59,10 +59,11 @@ export const deployedInstanceChecks = (services: LikeC4Services): ValidationChec
     if (RESERVED_WORDS.includes(artifactName)) {
       accept('error', `Reserved word: ${artifactName}`, {
         node: el,
-        range
+        range,
       })
     }
-    const fqnName = DeploymentsIndex.getFqnName(el)
+
+    const fqnName = DeploymentsIndex.getFqn(el)
 
     const withSameName = DeploymentsIndex.byFqn(fqnName).limit(2).toArray()
     if (withSameName.length > 1) {
@@ -71,74 +72,60 @@ export const deployedInstanceChecks = (services: LikeC4Services): ValidationChec
         `Duplicate instance name "${fqnName}"`,
         {
           node: el,
-          range
-        }
+          range,
+        },
       )
     }
   })
 }
 
 export const deploymentRelationChecks = (services: LikeC4Services): ValidationCheck<ast.DeploymentRelation> => {
-  // const DeploymentsIndex = services.likec4.DeploymentsIndex
-  // const Names = services.references.NameProvider as LikeC4NameProvider
-  // const Locator = services.workspace.AstNodeLocator
-  // const fqnIndex = services.likec4.FqnIndex
+  const ModelParser = services.likec4.ModelParser
   return tryOrLog((el, accept) => {
     const source = el.source?.value?.ref
-    const target = el.target?.value?.ref
-
-    if (!source || !target) {
+    if (!source) {
+      let sourceCstText = el.source?.$cstNode?.text ?? ''
+      accept('error', `DeploymentRelation source '${sourceCstText}' not resolved`, {
+        node: el,
+        property: 'source',
+      })
       return
     }
-
-    if (
-      ast.isElement(source) && ast.isDeploymentNode(target) || ast.isElement(target) && ast.isDeploymentNode(source)
-    ) {
-      const range = el.target.$cstNode?.range ?? el.source.$cstNode?.range
-      accept('error', 'Relations between deployment nodes and instance internals are not supported', {
+    const target = el.target?.value?.ref
+    if (!target) {
+      let targetCstText = el.target?.$cstNode?.text ?? ''
+      accept('error', `DeploymentRelation target '${targetCstText}' not resolved`, {
         node: el,
-        ...range && { range }
+        property: 'target',
       })
+      return
     }
 
-    // const sourceEl = ast.isDeployedInstance(source)
-    //   ? elementRef(source.element)
-    //   : source
-    // const targetEl = ast.isDeployedInstance(target)
-    //   ? elementRef(target.element)
-    //   : target
-
-    // if (!sourceEl || !targetEl) {
-    //   return
-    // }
+    const doc = getDocument(el)
+    const parser = ModelParser.forDocument(doc)
 
-    // const sourceFqn = ast.isElement(sourceEl) ? fqnIndex.getFqn(sourceEl) : DeploymentsIndex.getFqnName(sourceEl) as Fqn
-    // if (!sourceFqn) {
-    //   accept('error', 'Source not resolved', {
-    //     node: el,
-    //     property: 'source'
-    //   })
-    // }
-
-    // const targetFqn = ast.isElement(targetEl) ? fqnIndex.getFqn(targetEl) : DeploymentsIndex.getFqnName(targetEl) as Fqn
-    // if (!targetFqn) {
-    //   accept('error', 'Target not resolved', {
-    //     node: el,
-    //     property: 'target'
-    //   })
-    // }
+    const sourceFqnRef = parser.parseFqnRef(el.source)
+    if (FqnRef.isModelRef(sourceFqnRef)) {
+      accept('error', 'DeploymentRelation must refer deployment element', {
+        node: el,
+        property: 'source',
+      })
+      return
+    }
 
-    // if (!!sourceFqn && sourceFqn === targetFqn) {
-    //   accept('error', 'Self-relation is not allowed', {
-    //     node: el
-    //   })
-    //   return
-    // }
+    const targetFqnRef = parser.parseFqnRef(el.target)
+    if (FqnRef.isModelRef(targetFqnRef)) {
+      accept('error', 'DeploymentRelation must refer deployment element', {
+        node: el,
+        property: 'target',
+      })
+      return
+    }
 
-    // if (sourceFqn && targetFqn && isSameHierarchy(sourceFqn, targetFqn)) {
-    //   accept('error', 'Invalid parent-child relationship', {
-    //     node: el
-    //   })
-    // }
+    if (isSameHierarchy(sourceFqnRef.deployment, targetFqnRef.deployment)) {
+      accept('error', 'Invalid parent-child relationship', {
+        node: el,
+      })
+    }
   })
 }

package/src/validation/index.ts

@@ -1,4 +1,7 @@
-import { type ast } from '../ast'
+import type { AstNode } from 'langium'
+import { isNullish } from 'remeda'
+import { DiagnosticSeverity } from 'vscode-languageserver-types'
+import { type LikeC4AstNode, type LikeC4LangiumDocument, ast } from '../ast'
 import { logger } from '../logger'
 import type { LikeC4Services } from '../module'
 import { deployedInstanceChecks, deploymentNodeChecks, deploymentRelationChecks } from './deployment-checks'
@@ -15,27 +18,115 @@ import {
   modelRuleChecks,
   relationshipChecks,
   specificationRuleChecks,
-  tagChecks
+  tagChecks,
 } from './specification'
 import { viewChecks } from './view'
 import {
-  deploymentRefExpressionChecks,
   elementPredicateWithChecks,
   expandElementExprChecks,
+  fqnRefExprChecks,
   incomingExpressionChecks,
   outgoingExpressionChecks,
-  relationPredicateWithChecks
+  relationExprChecks,
+  relationPredicateWithChecks,
 } from './view-predicates'
 
+type Guard<N extends AstNode> = (n: AstNode) => n is N
+type Guarded<G> = G extends Guard<infer N> ? N : never
+
+function validatableAstNodeGuards<const Predicates extends Guard<AstNode>[]>(
+  predicates: Predicates,
+) {
+  return (n: AstNode): n is Guarded<Predicates[number]> => predicates.some(p => p(n))
+}
+const isValidatableAstNode = validatableAstNodeGuards([
+  ast.isGlobals,
+  ast.isGlobalPredicateGroup,
+  ast.isGlobalDynamicPredicateGroup,
+  ast.isGlobalStyle,
+  ast.isGlobalStyleGroup,
+  ast.isDynamicViewPredicateIterator,
+  ast.isElementPredicateWith,
+  ast.isRelationPredicateWith,
+  ast.isElementExpression,
+  ast.isRelationExpression,
+  ast.isDynamicViewParallelSteps,
+  ast.isDynamicViewStep,
+  ast.isDeploymentViewRule,
+  ast.isDeploymentViewRulePredicate,
+  ast.isExpressionV2,
+  ast.isRelationExpr,
+  ast.isFqnRefExpr,
+  ast.isViewProperty,
+  ast.isStyleProperty,
+  ast.isPredicate,
+  ast.isTags,
+  ast.isViewRule,
+  ast.isDynamicViewRule,
+  ast.isLikeC4View,
+  ast.isViewRuleStyleOrGlobalRef,
+  ast.isDeployedInstance,
+  ast.isDeploymentNode,
+  ast.isDeploymentRelation,
+  ast.isRelationshipStyleProperty,
+  ast.isMetadataProperty,
+  ast.isRelation,
+  ast.isElementProperty,
+  ast.isStringProperty,
+  ast.isNavigateToProperty,
+  ast.isElement,
+  ast.isExtendElement,
+  ast.isSpecificationElementKind,
+  ast.isSpecificationRelationshipKind,
+  ast.isSpecificationDeploymentNodeKind,
+  ast.isSpecificationTag,
+  ast.isSpecificationColor,
+  ast.isSpecificationRule,
+])
+type ValidatableAstNode = Guarded<typeof isValidatableAstNode>
+
+const findInvalidContainer = (node: LikeC4AstNode): ValidatableAstNode | undefined => {
+  let nd = node as LikeC4AstNode['$container']
+  while (nd && !ast.isLikeC4Grammar(nd)) {
+    if (isValidatableAstNode(nd)) {
+      return nd
+    }
+    nd = nd.$container
+  }
+  return undefined
+}
+
+export function checksFromDiagnostics(doc: LikeC4LangiumDocument) {
+  const errors = doc.diagnostics?.filter(d => d.severity === DiagnosticSeverity.Error) ?? []
+  const invalidNodes = new WeakSet()
+  for (const { node } of errors) {
+    if (isNullish(node) || invalidNodes.has(node)) {
+      continue
+    }
+    invalidNodes.add(node)
+    const container = findInvalidContainer(node)
+    if (container) {
+      invalidNodes.add(container)
+    }
+  }
+  const isValid = (n: ValidatableAstNode) => !invalidNodes.has(n)
+  return {
+    isValid,
+    invalidNodes,
+  }
+}
+export type ChecksFromDiagnostics = ReturnType<typeof checksFromDiagnostics>
+export type IsValidFn = ChecksFromDiagnostics['isValid']
+
 export function registerValidationChecks(services: LikeC4Services) {
-  logger.info('registerValidationChecks')
+  logger.debug('registerValidationChecks')
   const registry = services.validation.ValidationRegistry
   registry.register<ast.LikeC4AstType>({
     DeployedInstance: deployedInstanceChecks(services),
     DeploymentNode: deploymentNodeChecks(services),
     DeploymentRelation: deploymentRelationChecks(services),
-    DeploymentRefExpression: deploymentRefExpressionChecks(services),
-    // DeploymentRelationExpression: deploymentRelationExpressionChecks(services),
+    FqnRefExpr: fqnRefExprChecks(services),
+    RelationExpr: relationExprChecks(services),
     NotesProperty: notesPropertyRuleChecks(services),
     OpacityProperty: opacityPropertyRuleChecks(services),
     IconProperty: iconPropertyRuleChecks(services),
@@ -58,7 +149,7 @@ export function registerValidationChecks(services: LikeC4Services) {
     ExpandElementExpression: expandElementExprChecks(services),
     RelationshipKind: relationshipChecks(services),
     IncomingRelationExpression: incomingExpressionChecks(services),
-    OutgoingRelationExpression: outgoingExpressionChecks(services)
+    OutgoingRelationExpression: outgoingExpressionChecks(services),
   })
   const connection = services.shared.lsp.Connection
   if (connection) {
@@ -68,7 +159,7 @@ export function registerValidationChecks(services: LikeC4Services) {
         logger.debug(`clear diagnostics for deleted ${uri.path}`)
         void connection.sendDiagnostics({
           uri: uri.toString(),
-          diagnostics: []
+          diagnostics: [],
         })
       }
     })

package/src/validation/view-predicates/expression-v2.ts

@@ -0,0 +1,101 @@
+import { FqnExpr, FqnRef } from '@likec4/core'
+import { AstUtils, type ValidationCheck } from 'langium'
+import { isNonNullish, isNullish } from 'remeda'
+import { ast } from '../../ast'
+import type { LikeC4Services } from '../../module'
+import { tryOrLog } from '../_shared'
+
+export const relationExprChecks = (services: LikeC4Services): ValidationCheck<ast.RelationExpr> => {
+  const ModelParser = services.likec4.ModelParser
+  return tryOrLog((node, accept) => {
+    if (node.$container.$type !== 'DeploymentViewRulePredicateExpression') {
+      // skip validation for this node, validated by container
+      return
+    }
+
+    const predicate = AstUtils.getContainerOfType(node, ast.isDeploymentViewRulePredicate)
+    if (!predicate || predicate.isInclude !== true) {
+      // no restriction for exclude predicate
+      return
+    }
+
+    const doc = AstUtils.getDocument(node)
+    const parser = ModelParser.forDocument(doc)
+
+    const ModelRefOnlyExclude = 'Model reference is allowed in exclude predicate only'
+
+    if (ast.isDirectedRelationExpr(node)) {
+      if (FqnExpr.isModelRef(parser.parseFqnExpr(node.source.from))) {
+        accept('error', ModelRefOnlyExclude, {
+          node: node.source,
+          property: 'from'
+        })
+      }
+
+      if (FqnExpr.isModelRef(parser.parseFqnExpr(node.target))) {
+        accept('error', ModelRefOnlyExclude, {
+          node,
+          property: 'target'
+        })
+      }
+      return
+    }
+
+    let expr: ast.FqnExpr
+    if (ast.isIncomingRelationExpr(node)) {
+      expr = node.to
+    } else if (ast.isOutgoingRelationExpr(node)) {
+      expr = node.from
+    } else {
+      expr = node.inout.to
+    }
+    if (FqnExpr.isModelRef(parser.parseFqnExpr(expr))) {
+      accept('error', ModelRefOnlyExclude, {
+        node
+      })
+      return
+    }
+  })
+}
+
+export const fqnRefExprChecks = (services: LikeC4Services): ValidationCheck<ast.FqnRefExpr> => {
+  const ModelParser = services.likec4.ModelParser
+  // const DeploymentsIndex = services.likec4.DeploymentsIndex
+  // const Names = services.references.NameProvider as LikeC4NameProvider
+  // const Locator = services.workspace.AstNodeLocator
+  // const fqnIndex = services.likec4.FqnIndex
+  return tryOrLog((node, accept) => {
+    const referenceTo = node.ref.value.ref
+    if (isNullish(referenceTo)) {
+      accept('error', 'Invalid empty reference', {
+        node
+      })
+      return
+    }
+    const doc = AstUtils.getDocument(node)
+    const expr = ModelParser.forDocument(doc).parseFqnRefExpr(node)
+
+    // This expression is part of element predicate
+    if (node.$container.$type === 'DeploymentViewRulePredicateExpression') {
+      if (FqnExpr.isModelRef(expr)) {
+        accept('error', 'Deployment view predicate must reference deployment model', {
+          node
+        })
+        return
+      }
+      if (FqnExpr.isDeploymentRef(expr) && FqnRef.isInsideInstanceRef(expr.ref)) {
+        accept('error', 'Must reference deployment nodes or instances, but not internals', {
+          node
+        })
+        return
+      }
+    }
+
+    if (!ast.isDeploymentNode(referenceTo) && isNonNullish(node.selector)) {
+      accept('warning', `Selector '${node.selector}' applies to deployment nodes only, ignored here`, {
+        node,
+        property: 'selector'
+      })
+    }
+  })
+}

package/src/validation/view-predicates/index.ts

@@ -1,6 +1,6 @@
-export * from './deployments'
 export * from './element-with'
 export * from './expanded-element'
+export * from './expression-v2'
 export * from './incoming'
 export * from './outgoing'
 export * from './relation-with'

package/src/view-utils/assignNavigateTo.ts

@@ -1,4 +1,4 @@
-import { ComputedNode, ComputedView, type Fqn, isElementView, type ViewId } from '@likec4/core'
+import { ComputedNode, ComputedView, type Fqn, type ViewId } from '@likec4/core'
 import { find, isNullish } from 'remeda'
 
 export function assignNavigateTo<R extends Iterable<ComputedView>>(views: R): R {

package/src/view-utils/manual-layout.ts

@@ -1,7 +1,13 @@
+import type * as c4 from '@likec4/core'
 import { isAutoLayoutDirection, type ViewManualLayout } from '@likec4/core'
 import { decode, encode } from '@msgpack/msgpack'
 import { fromBase64, toBase64 } from '@smithy/util-base64'
+import { AstUtils, CstUtils } from 'langium'
 import { mapValues } from 'remeda'
+import type { ast } from '../ast'
+import { logger } from '../logger'
+
+const { getDocument } = AstUtils
 
 function pack({
   nodes,
@@ -89,3 +95,22 @@ export function deserializeFromComment(comment: string): ViewManualLayout {
   const decodedb64 = fromBase64(b64)
   return unpack(decode(decodedb64) as any) as ViewManualLayout
 }
+
+export function parseViewManualLayout(node: ast.LikeC4View): c4.ViewManualLayout | undefined {
+  const commentNode = CstUtils.findCommentNode(node.$cstNode, ['BLOCK_COMMENT'])
+  if (!commentNode || !hasManualLayout(commentNode.text)) {
+    return undefined
+  }
+  try {
+    return deserializeFromComment(commentNode.text)
+  } catch (e) {
+    const doc = getDocument(node)
+    logger.warn(e)
+    logger.warn(
+      `Ignoring manual layout of "${node.name ?? 'unnamed'}" at ${doc.uri.fsPath}:${
+        1 + (commentNode.range.start.line || 0)
+      }`
+    )
+    return undefined
+  }
+}

package/dist/browser.cjs

@@ -1,25 +0,0 @@
-'use strict';
-
-const lsp = require('langium/lsp');
-const browser = require('vscode-languageserver/browser');
-const module$1 = require('./shared/language-server.CO_nmHiL.cjs');
-
-function startLanguageServer() {
-  const messageReader = new browser.BrowserMessageReader(self);
-  const messageWriter = new browser.BrowserMessageWriter(self);
-  const connection = browser.createConnection(messageReader, messageWriter);
-  const services = module$1.createLanguageServices({ connection });
-  lsp.startLanguageServer(services.shared);
-  return {
-    ...services,
-    connection,
-    messageReader,
-    messageWriter
-  };
-}
-
-exports.LikeC4Module = module$1.LikeC4Module;
-exports.createCustomLanguageServices = module$1.createCustomLanguageServices;
-exports.createLanguageServices = module$1.createLanguageServices;
-exports.setLogLevel = module$1.setLogLevel;
-exports.startLanguageServer = startLanguageServer;

package/dist/browser.d.cts

@@ -1,23 +0,0 @@
-import { L as LikeC4SharedServices, a as LikeC4Services } from './shared/language-server.Da6ey08o.cjs';
-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.Da6ey08o.cjs';
-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.cjs';
-import 'vscode-jsonrpc';
-import 'vscode-uri';
-import '@likec4/log';
-
-declare function startLanguageServer(): {
-    connection: vscode_languageserver.Connection;
-    messageReader: BrowserMessageReader;
-    messageWriter: BrowserMessageWriter;
-    shared: LikeC4SharedServices;
-    likec4: LikeC4Services;
-};
-
-export { LikeC4Services, LikeC4SharedServices, startLanguageServer };

package/dist/browser.d.mts

@@ -1,23 +0,0 @@
-import { L as LikeC4SharedServices, a as LikeC4Services } from './shared/language-server.Dj4iDjtB.mjs';
-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.Dj4iDjtB.mjs';
-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.mjs';
-import 'vscode-jsonrpc';
-import 'vscode-uri';
-import '@likec4/log';
-
-declare function startLanguageServer(): {
-    connection: vscode_languageserver.Connection;
-    messageReader: BrowserMessageReader;
-    messageWriter: BrowserMessageWriter;
-    shared: LikeC4SharedServices;
-    likec4: LikeC4Services;
-};
-
-export { LikeC4Services, LikeC4SharedServices, startLanguageServer };

package/dist/browser.mjs

@@ -1,20 +0,0 @@
-import { startLanguageServer as startLanguageServer$1 } from 'langium/lsp';
-import { BrowserMessageReader, BrowserMessageWriter, createConnection } from 'vscode-languageserver/browser';
-import { c as createLanguageServices } from './shared/language-server.oO_9JoAG.mjs';
-export { L as LikeC4Module, a as createCustomLanguageServices, s as setLogLevel } from './shared/language-server.oO_9JoAG.mjs';
-
-function startLanguageServer() {
-  const messageReader = new BrowserMessageReader(self);
-  const messageWriter = new BrowserMessageWriter(self);
-  const connection = createConnection(messageReader, messageWriter);
-  const services = createLanguageServices({ connection });
-  startLanguageServer$1(services.shared);
-  return {
-    ...services,
-    connection,
-    messageReader,
-    messageWriter
-  };
-}
-
-export { createLanguageServices, startLanguageServer };

package/dist/index.cjs

@@ -1,53 +0,0 @@
-'use strict';
-
-const lsp = require('langium/lsp');
-const node$1 = require('vscode-languageserver/node');
-const langium = require('langium');
-const node = require('langium/node');
-const node_fs = require('node:fs');
-const promises = require('node:fs/promises');
-const node_path = require('node:path');
-const module$1 = require('./shared/language-server.CO_nmHiL.cjs');
-
-const LikeC4FileSystem = {
-  fileSystemProvider: () => new SymLinkTraversingFileSystemProvider()
-};
-class SymLinkTraversingFileSystemProvider extends node.NodeFileSystemProvider {
-  async readDirectory(folderPath) {
-    const dirents = await promises.readdir(folderPath.fsPath, { withFileTypes: true });
-    return dirents.map((dirent) => this.followUri(langium.UriUtils.joinPath(folderPath, dirent.name)));
-  }
-  followUri(uri) {
-    const directoryPath = node_path.dirname(uri.fsPath);
-    const stat = node_fs.lstatSync(uri.fsPath);
-    if (stat.isSymbolicLink()) {
-      const resolved_link = node_fs.readlinkSync(uri.fsPath);
-      const linked_path = node_path.resolve(directoryPath, resolved_link);
-      return this.followUri(langium.URI.file(linked_path));
-    } else {
-      return {
-        isFile: stat.isFile(),
-        isDirectory: stat.isDirectory(),
-        uri
-      };
-    }
-  }
-}
-
-function startLanguageServer() {
-  const connection = node$1.createConnection(node$1.ProposedFeatures.all);
-  const services = module$1.createLanguageServices({ connection, ...LikeC4FileSystem });
-  lsp.startLanguageServer(services.shared);
-  return {
-    ...services,
-    connection
-  };
-}
-
-exports.LikeC4Module = module$1.LikeC4Module;
-exports.createCustomLanguageServices = module$1.createCustomLanguageServices;
-exports.createLanguageServices = module$1.createLanguageServices;
-exports.lspLogger = module$1.logger;
-exports.setLogLevel = module$1.setLogLevel;
-exports.LikeC4FileSystem = LikeC4FileSystem;
-exports.startLanguageServer = startLanguageServer;

package/dist/index.d.cts

@@ -1,34 +0,0 @@
-import { L as LikeC4SharedServices, a as LikeC4Services } from './shared/language-server.Da6ey08o.cjs';
-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, n as lspLogger, s as setLogLevel } from './shared/language-server.Da6ey08o.cjs';
-import * as vscode_languageserver_lib_common_inlineCompletion_proposed from 'vscode-languageserver/lib/common/inlineCompletion.proposed';
-import * as vscode_languageserver from 'vscode-languageserver';
-import { URI, FileSystemNode } from 'langium';
-import { NodeFileSystemProvider } from 'langium/node';
-import 'langium/lsp';
-import 'vscode-languageserver-types';
-import '@likec4/core';
-import 'type-fest';
-import './protocol.cjs';
-import 'vscode-jsonrpc';
-import 'vscode-uri';
-import '@likec4/log';
-
-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[]>;
-    followUri(uri: URI): FileSystemNode;
-}
-
-declare function startLanguageServer(): {
-    connection: vscode_languageserver._Connection<vscode_languageserver._, vscode_languageserver._, vscode_languageserver._, vscode_languageserver._, vscode_languageserver._, vscode_languageserver._, vscode_languageserver_lib_common_inlineCompletion_proposed.InlineCompletionFeatureShape, vscode_languageserver._>;
-    shared: LikeC4SharedServices;
-    likec4: LikeC4Services;
-};
-
-export { LikeC4FileSystem, LikeC4Services, LikeC4SharedServices, startLanguageServer };