@likec4/language-server 1.10.1 → 1.11.0

package/dist/shared/{language-server.BFBeyvV8.mjs → language-server.CCOotWDz.mjs}

@@ -1,8 +1,8 @@
 import { AbstractAstReflection, loadGrammarFromJson, DocumentState, AstUtils, GrammarUtils, MultiMap, CstUtils, stream, StreamImpl, DONE_RESULT, interruptAndCheck, Disposable, DefaultScopeComputation, DefaultScopeProvider, EMPTY_STREAM, StreamScope, MapScope, EMPTY_SCOPE, URI, UriUtils, isAstNode, DefaultWorkspaceManager, WorkspaceCache, inject, EmptyFileSystem } from 'langium';
 import { DefaultCompletionProvider, DefaultDocumentHighlightProvider, AstNodeHoverProvider, AbstractSemanticTokenProvider, DefaultWorkspaceSymbolProvider, Formatting, AbstractFormatter, createDefaultModule, createDefaultSharedModule } from 'langium/lsp';
 import { rootLogger, LogLevels, logger as logger$1 } from '@likec4/log';
+import { isError, isNullish, isDefined, clamp, isTruthy, pipe, map, filter, isEmpty, find, values, first, last, unique, hasAtLeast, mapToObj, groupBy, forEach, prop, mapValues, flatMap, reduce, sort, reverse, indexBy, isNumber, isNonNullish, findLast, entries, debounce } from 'remeda';
 import { nonexhaustive, DefaultRelationshipColor, DefaultLineStyle, DefaultArrowType, AsFqn, parentFqn, nameFromFqn, isComputedElementView, isExtendsElementView, invariant, compareNatural, isElementView as isElementView$1, isScopedElementView, computeColorValues, sortByFqnHierarchically, compareRelations, isOrOperator, isNonEmptyArray, isAndOperator, isAncestor, hasAtLeast as hasAtLeast$1, isSameHierarchy } from '@likec4/core';
-import { isNullish, isDefined, clamp, isTruthy, pipe, map, filter, isEmpty, find, values, first, last, unique, hasAtLeast, mapToObj, groupBy, forEach, prop, mapValues, flatMap, reduce, sort, reverse, indexBy, isNumber, isNonNullish, findLast, entries, debounce } from 'remeda';
 import { DiagnosticSeverity, SymbolKind, SemanticTokenTypes, SemanticTokenModifiers, TextEdit, CompletionItemKind } from 'vscode-languageserver-types';
 import indentString from 'indent-string';
 import { decode, encode } from '@msgpack/msgpack';
@@ -18,95 +18,6 @@ import { hasProtocol, hasLeadingSlash, isRelative, withoutLeadingSlash, withoutB
 import { Graph } from '@dagrejs/graphlib';
 import { DocumentHighlight, DocumentHighlightKind } from 'vscode-languageserver';
 
-const logger = rootLogger.withTag("lsp");
-function logError(err) {
-  logger.error(err);
-}
-function logWarnError(err) {
-  if (err instanceof Error) {
-    logger.warn(err.stack ?? err.message);
-    return;
-  }
-  logger.warn(err);
-}
-function setLogLevel(level) {
-  logger.level = LogLevels[level];
-}
-function logErrorToTelemetry(connection) {
-  const reporter = {
-    log: ({ level, ...logObj }, ctx) => {
-      if (level !== LogLevels.error && level !== LogLevels.fatal) {
-        return;
-      }
-      const tag = logObj.tag || "";
-      const parts = logObj.args.map((arg) => {
-        if (arg && typeof arg.stack === "string") {
-          return arg.message + "\n" + arg.stack;
-        }
-        if (typeof arg === "string") {
-          return arg;
-        }
-        return String(arg);
-      });
-      if (tag) {
-        parts.unshift(`[${tag}]`);
-      }
-      const message = parts.join(" ");
-      connection.telemetry.logEvent({ eventName: "error", error: message });
-    }
-  };
-  rootLogger.addReporter(reporter);
-  logger.setReporters(rootLogger.options.reporters);
-}
-function logToLspConnection(connection) {
-  const reporter = {
-    log: ({ level, ...logObj }, ctx) => {
-      const tag = logObj.tag || "";
-      const parts = logObj.args.map((arg) => {
-        if (arg && typeof arg.stack === "string") {
-          return arg.message + "\n" + arg.stack;
-        }
-        if (typeof arg === "string") {
-          return arg;
-        }
-        return String(arg);
-      });
-      if (tag) {
-        parts.unshift(`[${tag}]`);
-      }
-      const message = parts.join(" ");
-      switch (true) {
-        case level >= LogLevels.trace: {
-          connection.tracer.log(message);
-          break;
-        }
-        case level >= LogLevels.debug: {
-          connection.console.debug(message);
-          break;
-        }
-        case level >= LogLevels.info: {
-          connection.console.info(message);
-          break;
-        }
-        case level >= LogLevels.log: {
-          connection.console.log(message);
-          break;
-        }
-        case level >= LogLevels.warn: {
-          connection.console.warn(message);
-          break;
-        }
-        case level >= LogLevels.fatal: {
-          connection.console.error(message);
-          break;
-        }
-      }
-    }
-  };
-  rootLogger.addReporter(reporter);
-  logger.setReporters(rootLogger.options.reporters);
-}
-
 const DynamicViewRule = "DynamicViewRule";
 function isDynamicViewRule(item) {
   return reflection.isInstance(item, DynamicViewRule);
@@ -1488,6 +1399,94 @@ const LikeC4GeneratedModule = {
   }
 };
 
+const logger = rootLogger.withTag("lsp");
+function logError(err) {
+  logger.error(err);
+}
+function logWarnError(err) {
+  if (err instanceof Error) {
+    logger.warn(err.stack ?? err.message);
+    return;
+  }
+  logger.warn(err);
+}
+function setLogLevel(level) {
+  logger.level = LogLevels[level];
+}
+function logErrorToTelemetry(connection) {
+  const reporter = {
+    log: ({ level, ...logObj }, ctx) => {
+      if (level !== LogLevels.error && level !== LogLevels.fatal) {
+        return;
+      }
+      const tag = logObj.tag || "";
+      const parts = logObj.args.map((arg) => {
+        if (isError(arg)) {
+          return arg.stack ?? arg.message;
+        }
+        if (typeof arg === "string") {
+          return arg;
+        }
+        return "" + arg;
+      });
+      if (tag) {
+        parts.unshift(`[${tag}]`);
+      }
+      const message = parts.join(" ");
+      connection.telemetry.logEvent({ eventName: "error", error: message });
+    }
+  };
+  rootLogger.addReporter(reporter);
+  logger.setReporters(rootLogger.options.reporters);
+}
+function logToLspConnection(connection) {
+  const reporter = {
+    log: ({ level, ...logObj }, ctx) => {
+      const tag = logObj.tag || "";
+      const parts = logObj.args.map((arg) => {
+        if (isError(arg)) {
+          return arg.stack ?? arg.message;
+        }
+        if (typeof arg === "string") {
+          return arg;
+        }
+        return "" + arg;
+      });
+      if (tag) {
+        parts.unshift(`[${tag}]`);
+      }
+      const message = parts.join(" ");
+      switch (true) {
+        case level >= LogLevels.debug: {
+          connection.console.debug(message);
+          break;
+        }
+        // case level >= LogLevels.info: {
+        //   connection.console.info(message)
+        //   break
+        // }
+        case level >= LogLevels.log: {
+          connection.console.info(message);
+          break;
+        }
+        case level >= LogLevels.warn: {
+          connection.console.warn(message);
+          break;
+        }
+        case level >= LogLevels.fatal: {
+          connection.console.error(message);
+          break;
+        }
+        default: {
+          connection.console.log(message);
+        }
+      }
+    }
+  };
+  rootLogger.setReporters([reporter]);
+  logger.setReporters(rootLogger.options.reporters);
+}
+
 function elementRef(node) {
   return node.el.ref;
 }
@@ -1609,7 +1608,7 @@ function checksFromDiagnostics(doc) {
   };
 }
 function* streamModel(doc, isValid) {
-  const traverseStack = doc.parseResult.value.models.flatMap((m) => isValid(m) ? m.elements : []);
+  const traverseStack = doc.parseResult.value.models.flatMap((m) => m.elements);
   const relations = [];
   let el;
   while (el = traverseStack.shift()) {
@@ -2540,8 +2539,6 @@ class FqnIndex {
   }
 }
 
-const printDocs = (docs) => docs.map((d) => "  - " + d.uri.toString(true)).join("\n");
-
 function assignNavigateTo(views) {
   const allElementViews = /* @__PURE__ */ new Map();
   for (const v of views) {
@@ -2935,8 +2932,7 @@ class LikeC4ModelBuilder {
       async (docs, _cancelToken) => {
         let parsed = [];
         try {
-          logger.debug(`[ModelBuilder] onValidated (${docs.length} docs)
-${printDocs(docs)}`);
+          logger.debug(`[ModelBuilder] onValidated (${docs.length} docs)`);
           for (const doc of parser.parse(docs)) {
             parsed.push(doc.uri);
           }
@@ -2966,8 +2962,7 @@ ${printDocs(docs)}`);
         logger.debug("[ModelBuilder] No documents to build model from");
         return null;
       }
-      logger.debug(`[ModelBuilder] buildModel from ${docs.length} docs:
-${printDocs(docs)}`);
+      logger.debug(`[ModelBuilder] onValidated (${docs.length} docs)`);
       return buildModel(this.services, docs);
     });
   }
@@ -3024,14 +3019,14 @@ ${printDocs(docs)}`);
     if (cache.has(CACHE_KEY_COMPUTED_MODEL)) {
       return cache.get(CACHE_KEY_COMPUTED_MODEL);
     }
-    const model = await this.buildModel(cancelToken);
-    if (!model) {
-      return null;
-    }
     return await this.services.shared.workspace.WorkspaceLock.read(async () => {
       if (cancelToken) {
         await interruptAndCheck(cancelToken);
       }
+      const model = this.unsafeSyncBuildModel();
+      if (!model) {
+        return null;
+      }
       return this.unsafeSyncBuildComputedModel(model);
     });
   }
@@ -3041,17 +3036,17 @@ ${printDocs(docs)}`);
     if (cache.has(cacheKey)) {
       return cache.get(cacheKey);
     }
-    const model = await this.buildModel(cancelToken);
-    const view = model?.views[viewId];
-    if (!view) {
-      logger.warn(`[ModelBuilder] Cannot find view ${viewId}`);
-      return null;
-    }
     return await this.services.shared.workspace.WorkspaceLock.read(async () => {
       if (cancelToken) {
         await interruptAndCheck(cancelToken);
       }
       return cache.get(cacheKey, () => {
+        const model = this.unsafeSyncBuildModel();
+        const view = model?.views[viewId];
+        if (!view) {
+          logger.warn(`[ModelBuilder] Cannot find view ${viewId}`);
+          return null;
+        }
         const index = new LikeC4ModelGraph(model);
         const result = isElementView$1(view) ? computeView(view, index) : computeDynamicView(view, index);
         if (!result.isSuccess) {
@@ -4737,14 +4732,16 @@ class Rpc {
     const LangiumDocuments = this.services.shared.workspace.LangiumDocuments;
     const DocumentBuilder = this.services.shared.workspace.DocumentBuilder;
     const notifyModelParsed = debounce(
-      () => void connection.sendNotification(onDidChangeModel, "").catch((e) => {
-        logger.error(`[ServerRpc] error sending onDidChangeModel: ${e}`);
-        return Promise.resolve();
-      }),
+      () => {
+        connection.sendNotification(onDidChangeModel, "").catch((e) => {
+          logger.error(`[ServerRpc] error sending onDidChangeModel: ${e}`);
+          return Promise.resolve();
+        });
+      },
       {
         timing: "both",
-        waitMs: 350,
-        maxWaitMs: 1e3
+        waitMs: 300,
+        maxWaitMs: 600
       }
     );
     let isFirstBuild = true;
@@ -4753,7 +4750,10 @@ class Rpc {
         notifyModelParsed.cancel();
       }),
       modelBuilder.onModelParsed(() => notifyModelParsed.call()),
-      connection.onRequest(fetchComputedModel, async (cancelToken) => {
+      connection.onRequest(fetchComputedModel, async ({ cleanCaches }, cancelToken) => {
+        if (cleanCaches) {
+          this.services.WorkspaceCache.clear();
+        }
         const model = await modelBuilder.buildComputedModel(cancelToken);
         return { model };
       }),
@@ -4929,8 +4929,8 @@ class LikeC4WorkspaceManager extends DefaultWorkspaceManager {
    * your language, which can be either loaded from provided files or constructed in memory.
    */
   async loadAdditionalDocuments(folders, collector) {
-    await super.loadAdditionalDocuments(folders, collector);
     collector(this.documentFactory.fromString(LibIcons, URI$1.parse(Uri)));
+    await super.loadAdditionalDocuments(folders, collector);
   }
   workspace() {
     if (this.folders && hasAtLeast$1(this.folders, 1)) {
@@ -5735,4 +5735,4 @@ function _merge(target, source) {
   return target;
 }
 
-export { LikeC4Module as L, createLanguageServices as a, createCustomLanguageServices as c, setLogLevel as s };
+export { LikeC4Module as L, createCustomLanguageServices as a, createLanguageServices as c, logger as l, setLogLevel as s };

package/dist/shared/{language-server.CnVuAxDh.d.ts → language-server.Cyw-bCtc.d.ts}

@@ -1,12 +1,41 @@
+import { LangiumDocument, ReferenceDescription, MaybePromise, AstNode, Reference, MultiMap, AstNodeDescription, DiagnosticInfo, LangiumDocuments, Stream, Cancellation, Disposable, URI, DefaultScopeComputation, PrecomputedScopes, DefaultScopeProvider, ReferenceInfo, Scope, DefaultWorkspaceManager, WorkspaceCache, Module } from 'langium';
+import { CodeLensProvider, DefaultCompletionProvider, DefaultDocumentHighlightProvider, DocumentLinkProvider, DocumentSymbolProvider, NodeKindProvider as NodeKindProvider$1, AstNodeHoverProvider, AbstractSemanticTokenProvider, SemanticTokenAcceptor, LangiumSharedServices, DefaultWorkspaceSymbolProvider, LangiumServices, PartialLangiumServices, DefaultSharedModuleContext } from 'langium/lsp';
+import { CodeLensParams, CancellationToken, CodeLens, DocumentHighlight, DocumentLinkParams, DocumentLink, WorkspaceFolder } from 'vscode-languageserver';
+import { Diagnostic, DocumentSymbol, SymbolKind, Hover, Location, Range, TextEdit, CompletionItemKind } from 'vscode-languageserver-types';
 import * as c4 from '@likec4/core';
 import { Fqn, ViewID } from '@likec4/core';
-import { AstNode, Reference, LangiumDocument, MultiMap, AstNodeDescription, DiagnosticInfo, ReferenceDescription, MaybePromise, DefaultScopeComputation, PrecomputedScopes, DefaultScopeProvider, ReferenceInfo, Scope, Disposable, DefaultWorkspaceManager, WorkspaceCache, Module, LangiumDocuments, Stream, Cancellation, URI as URI$1 } from 'langium';
 import { SetRequired, ValueOf, ConditionalPick } from 'type-fest';
-import { Diagnostic, DocumentSymbol, SymbolKind, Hover, Location, Range, TextEdit, CompletionItemKind } from 'vscode-languageserver-types';
-import { CodeLensProvider, DefaultCompletionProvider, DefaultDocumentHighlightProvider, DocumentLinkProvider, DocumentSymbolProvider, NodeKindProvider as NodeKindProvider$1, AstNodeHoverProvider, AbstractSemanticTokenProvider, SemanticTokenAcceptor, LangiumSharedServices, DefaultWorkspaceSymbolProvider, LangiumServices, PartialLangiumServices, DefaultSharedModuleContext } from 'langium/lsp';
-import { CodeLensParams, CancellationToken, CodeLens, DocumentHighlight, DocumentLinkParams, DocumentLink, WorkspaceFolder } from 'vscode-languageserver';
 import { ChangeViewRequestParams } from '../protocol.js';
-import { URI } from 'vscode-uri';
+import { URI as URI$1 } from 'vscode-uri';
+import * as _likec4_log from '@likec4/log';
+import { LogLevels } from '@likec4/log';
+
+declare class LikeC4CodeLensProvider implements CodeLensProvider {
+    private services;
+    constructor(services: LikeC4Services);
+    provideCodeLens(doc: LangiumDocument, _params: CodeLensParams, cancelToken?: CancellationToken): Promise<CodeLens[] | undefined>;
+}
+
+declare class LikeC4CompletionProvider extends DefaultCompletionProvider {
+    readonly completionOptions: {
+        triggerCharacters: string[];
+    };
+}
+
+declare class LikeC4DocumentHighlightProvider extends DefaultDocumentHighlightProvider {
+    /**
+     * Override this method to determine the highlight kind of the given reference.
+     */
+    protected createDocumentHighlight(reference: ReferenceDescription): DocumentHighlight;
+}
+
+declare class LikeC4DocumentLinkProvider implements DocumentLinkProvider {
+    private services;
+    constructor(services: LikeC4Services);
+    getDocumentLinks(doc: LangiumDocument, _params: DocumentLinkParams): MaybePromise<DocumentLink[]>;
+    resolveLink(doc: LangiumDocument, link: string): string;
+    relativeLink(doc: LangiumDocument, link: string): string | null;
+}
 
 /******************************************************************************
  * This file was generated by langium-cli 3.2.0.
@@ -931,33 +960,6 @@ declare function checksFromDiagnostics(doc: LikeC4LangiumDocument): {
 };
 type ChecksFromDiagnostics = ReturnType<typeof checksFromDiagnostics>;
 
-declare class LikeC4CodeLensProvider implements CodeLensProvider {
-    private services;
-    constructor(services: LikeC4Services);
-    provideCodeLens(doc: LangiumDocument, _params: CodeLensParams, cancelToken?: CancellationToken): Promise<CodeLens[] | undefined>;
-}
-
-declare class LikeC4CompletionProvider extends DefaultCompletionProvider {
-    readonly completionOptions: {
-        triggerCharacters: string[];
-    };
-}
-
-declare class LikeC4DocumentHighlightProvider extends DefaultDocumentHighlightProvider {
-    /**
-     * Override this method to determine the highlight kind of the given reference.
-     */
-    protected createDocumentHighlight(reference: ReferenceDescription): DocumentHighlight;
-}
-
-declare class LikeC4DocumentLinkProvider implements DocumentLinkProvider {
-    private services;
-    constructor(services: LikeC4Services);
-    getDocumentLinks(doc: LangiumDocument, _params: DocumentLinkParams): MaybePromise<DocumentLink[]>;
-    resolveLink(doc: LangiumDocument, link: string): string;
-    relativeLink(doc: LangiumDocument, link: string): string | null;
-}
-
 declare class LikeC4DocumentSymbolProvider implements DocumentSymbolProvider {
     private services;
     protected readonly nodeKindProvider: NodeKindProvider$1;
@@ -989,6 +991,111 @@ declare class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider
     private highlightView;
 }
 
+declare function computeDocumentFqn(document: LikeC4LangiumDocument, services: LikeC4Services): void;
+
+interface FqnIndexEntry {
+    fqn: Fqn;
+    name: string;
+    el: Element;
+    doc: FqnIndexedDocument;
+    path: string;
+}
+declare class FqnIndex {
+    private services;
+    protected langiumDocuments: LangiumDocuments;
+    constructor(services: LikeC4Services);
+    get documents(): Stream<FqnIndexedDocument>;
+    private entries;
+    getFqn(el: Element): Fqn | null;
+    byFqn(fqn: Fqn): Stream<AstNodeDescription>;
+    directChildrenOf(parent: Fqn): Stream<AstNodeDescription>;
+    /**
+     * Returns descedant elements with unique names in the scope
+     */
+    uniqueDescedants(parent: Fqn): Stream<AstNodeDescription>;
+}
+
+type ModelParsedListener$1 = (docs: URI[]) => void;
+declare class LikeC4ModelBuilder {
+    private services;
+    private langiumDocuments;
+    private listeners;
+    constructor(services: LikeC4Services);
+    /**
+     * WARNING:
+     * This method is internal and should to be called only when all documents are known to be parsed.
+     * Otherwise, the model may be incomplete.
+     */
+    unsafeSyncBuildModel(): c4.ParsedLikeC4Model | null;
+    buildModel(cancelToken?: Cancellation.CancellationToken): Promise<c4.ParsedLikeC4Model | null>;
+    private previousViews;
+    /**
+     * WARNING:
+     * This method is internal and should to be called only when all documents are known to be parsed.
+     * Otherwise, the model may be incomplete.
+     */
+    unsafeSyncBuildComputedModel(model: c4.ParsedLikeC4Model): c4.ComputedLikeC4Model;
+    buildComputedModel(cancelToken?: Cancellation.CancellationToken): Promise<c4.ComputedLikeC4Model | null>;
+    computeView(viewId: ViewID, cancelToken?: Cancellation.CancellationToken): Promise<c4.ComputedView | null>;
+    onModelParsed(callback: ModelParsedListener$1): Disposable;
+    private documents;
+    private notifyListeners;
+}
+
+declare class LikeC4ModelLocator {
+    private services;
+    private fqnIndex;
+    private langiumDocuments;
+    constructor(services: LikeC4Services);
+    private documents;
+    getParsedElement(astNode: Element): ParsedAstElement | null;
+    locateElement(fqn: c4.Fqn, _prop?: string): Location | null;
+    locateRelation(relationId: c4.RelationID): Location | null;
+    locateViewAst(viewId: c4.ViewID): {
+        doc: ParsedLikeC4LangiumDocument;
+        view: ParsedAstView;
+        viewAst: LikeC4View;
+    };
+    locateView(viewId: c4.ViewID): Location | null;
+}
+
+type ModelParsedListener = () => void;
+type IsValidFn = ChecksFromDiagnostics['isValid'];
+declare class LikeC4ModelParser {
+    private services;
+    private fqnIndex;
+    constructor(services: LikeC4Services);
+    parse(doc: LangiumDocument | LangiumDocument[]): ParsedLikeC4LangiumDocument[];
+    protected parseLikeC4Document(_doc: FqnIndexedDocument): ParsedLikeC4LangiumDocument;
+    private parseSpecification;
+    private parseModel;
+    private parseElement;
+    private parseRelation;
+    private parseViews;
+    private parseViewRulePredicate;
+    private parsePredicate;
+    private parseElementExpressionsIterator;
+    private parseElementPredicate;
+    private parseElementExpr;
+    private parseElementPredicateWith;
+    private parseElementPredicateWhere;
+    private parseRelationPredicate;
+    private parseRelationPredicateWhere;
+    private parseRelationPredicateWith;
+    private parseRelationExpr;
+    private parseViewRule;
+    private parseViewManualLaout;
+    private parseDynamicParallelSteps;
+    private parseDynamicStep;
+    private parseElementView;
+    private parseDynamicElementView;
+    protected resolveFqn(node: Element | ExtendElement): c4.Fqn;
+    private getAstNodePath;
+    private getMetadata;
+    private convertTags;
+    private convertLinks;
+}
+
 declare class LikeC4ModelChanges {
     private services;
     private locator;
@@ -1059,7 +1166,7 @@ declare class LikeC4WorkspaceManager extends DefaultWorkspaceManager {
      */
     protected loadAdditionalDocuments(folders: WorkspaceFolder[], collector: (document: LangiumDocument) => void): Promise<void>;
     workspace(): WorkspaceFolder;
-    get workspaceUri(): URI;
+    get workspaceUri(): URI$1;
     get workspaceURL(): URL;
 }
 
@@ -1117,107 +1224,7 @@ declare function createLanguageServices(context?: LanguageServicesContext): {
     likec4: LikeC4Services;
 };
 
-interface FqnIndexEntry {
-    fqn: Fqn;
-    name: string;
-    el: Element;
-    doc: FqnIndexedDocument;
-    path: string;
-}
-declare class FqnIndex {
-    private services;
-    protected langiumDocuments: LangiumDocuments;
-    constructor(services: LikeC4Services);
-    get documents(): Stream<FqnIndexedDocument>;
-    private entries;
-    getFqn(el: Element): Fqn | null;
-    byFqn(fqn: Fqn): Stream<AstNodeDescription>;
-    directChildrenOf(parent: Fqn): Stream<AstNodeDescription>;
-    /**
-     * Returns descedant elements with unique names in the scope
-     */
-    uniqueDescedants(parent: Fqn): Stream<AstNodeDescription>;
-}
-
-type ModelParsedListener$1 = (docs: URI$1[]) => void;
-declare class LikeC4ModelBuilder {
-    private services;
-    private langiumDocuments;
-    private listeners;
-    constructor(services: LikeC4Services);
-    /**
-     * WARNING:
-     * This method is internal and should to be called only when all documents are known to be parsed.
-     * Otherwise, the model may be incomplete.
-     */
-    unsafeSyncBuildModel(): c4.ParsedLikeC4Model | null;
-    buildModel(cancelToken?: Cancellation.CancellationToken): Promise<c4.ParsedLikeC4Model | null>;
-    private previousViews;
-    /**
-     * WARNING:
-     * This method is internal and should to be called only when all documents are known to be parsed.
-     * Otherwise, the model may be incomplete.
-     */
-    unsafeSyncBuildComputedModel(model: c4.ParsedLikeC4Model): c4.ComputedLikeC4Model;
-    buildComputedModel(cancelToken?: Cancellation.CancellationToken): Promise<c4.ComputedLikeC4Model | null>;
-    computeView(viewId: ViewID, cancelToken?: Cancellation.CancellationToken): Promise<c4.ComputedView | null>;
-    onModelParsed(callback: ModelParsedListener$1): Disposable;
-    private documents;
-    private notifyListeners;
-}
-
-declare class LikeC4ModelLocator {
-    private services;
-    private fqnIndex;
-    private langiumDocuments;
-    constructor(services: LikeC4Services);
-    private documents;
-    getParsedElement(astNode: Element): ParsedAstElement | null;
-    locateElement(fqn: c4.Fqn, _prop?: string): Location | null;
-    locateRelation(relationId: c4.RelationID): Location | null;
-    locateViewAst(viewId: c4.ViewID): {
-        doc: ParsedLikeC4LangiumDocument;
-        view: ParsedAstView;
-        viewAst: LikeC4View;
-    };
-    locateView(viewId: c4.ViewID): Location | null;
-}
-
-type ModelParsedListener = () => void;
-type IsValidFn = ChecksFromDiagnostics['isValid'];
-declare class LikeC4ModelParser {
-    private services;
-    private fqnIndex;
-    constructor(services: LikeC4Services);
-    parse(doc: LangiumDocument | LangiumDocument[]): ParsedLikeC4LangiumDocument[];
-    protected parseLikeC4Document(_doc: FqnIndexedDocument): ParsedLikeC4LangiumDocument;
-    private parseSpecification;
-    private parseModel;
-    private parseElement;
-    private parseRelation;
-    private parseViews;
-    private parseViewRulePredicate;
-    private parsePredicate;
-    private parseElementExpressionsIterator;
-    private parseElementPredicate;
-    private parseElementExpr;
-    private parseElementPredicateWith;
-    private parseElementPredicateWhere;
-    private parseRelationPredicate;
-    private parseRelationPredicateWhere;
-    private parseRelationPredicateWith;
-    private parseRelationExpr;
-    private parseViewRule;
-    private parseViewManualLaout;
-    private parseDynamicParallelSteps;
-    private parseDynamicStep;
-    private parseElementView;
-    private parseDynamicElementView;
-    protected resolveFqn(node: Element | ExtendElement): c4.Fqn;
-    private getAstNodePath;
-    private getMetadata;
-    private convertTags;
-    private convertLinks;
-}
+declare const logger: _likec4_log.ConsolaInstance;
+declare function setLogLevel(level: keyof typeof LogLevels): void;
 
-export { type FqnIndexEntry as F, type IsValidFn as I, type LikeC4LangiumDocument as L, type ModelParsedListener as M, type LikeC4Services as a, createLanguageServices as b, createCustomLanguageServices as c, LikeC4Module as d, FqnIndex as e, LikeC4ModelBuilder as f, LikeC4ModelLocator as g, LikeC4ModelParser as h, type LikeC4SharedServices as i, type LikeC4AddedServices as j, type LanguageServicesContext as k, createSharedServices as l };
+export { type FqnIndexEntry as F, type IsValidFn as I, type LikeC4SharedServices as L, type ModelParsedListener as M, type LikeC4Services as a, createLanguageServices as b, createCustomLanguageServices as c, LikeC4Module as d, computeDocumentFqn as e, FqnIndex as f, LikeC4ModelBuilder as g, LikeC4ModelLocator as h, LikeC4ModelParser as i, type LikeC4AddedServices as j, type LanguageServicesContext as k, createSharedServices as l, logger as m, setLogLevel as s };