@likec4/language-server 1.48.0 → 1.49.0

package/dist/_chunks/LikeC4LanguageServices.mjs

@@ -1,725 +0,0 @@
-import { r as __toESM } from "./rolldown-runtime.mjs";
-import { r as isLikeC4Builtin } from "./likec4lib.mjs";
-import { C as t$5, F as t$2, M as n, N as t$4, P as t, _ as e$1, i as t$3, o as e, u as t$1 } from "./libs/remeda.mjs";
-import { t as deepEqual } from "./libs/fast-equals.mjs";
-import { t as require_picomatch } from "./libs/picomatch.mjs";
-import { a as joinRelativeURL, c as withTrailingSlash, d as withoutProtocol, f as withoutTrailingSlash, i as isRelative, o as joinURL, s as parseFilename, t as cleanDoubleSlashes } from "./libs/ufo.mjs";
-import { errorFromLogRecord, getMessageOnlyFormatter, getTextFormatter, loggable, logger, wrapError } from "@likec4/log";
-import { Disposable, OperationCancelled, URI, WorkspaceCache, isOperationCancelled } from "langium";
-import { BiMap, DefaultMap, compareNaturalHierarchically, invariant, memoizeProp, nonNullable, nonexhaustive } from "@likec4/core/utils";
-import { DiagnosticSeverity } from "vscode-languageserver-types";
-import { isLikeC4Config, normalizeIncludeConfig, validateProjectConfig } from "@likec4/config";
-import { LikeC4Model } from "@likec4/core/model";
-import { nonexhaustive as nonexhaustive$1 } from "@likec4/core";
-import { computeProjectsView } from "@likec4/core/compute-view";
-
-//#region src/logger.ts
-const logger$3 = logger.getChild("server");
-/**
-* Logs an error as warning (not critical)
-*/
-function logWarnError(err) {
-	logger$3.warn(loggable(err));
-}
-function getLspConnectionSink(connection, props) {
-	const format = props?.formatter ?? getTextFormatter({ format: ({ category, message }) => {
-		return `${category} ${message}`;
-	} });
-	return (logObj) => {
-		try {
-			switch (logObj.level) {
-				case "trace":
-				case "debug":
-					connection.console.debug(format(logObj));
-					break;
-				case "info":
-					connection.console.info(format(logObj));
-					break;
-				case "warning":
-					connection.console.warn(format(logObj));
-					break;
-				case "error":
-				case "fatal":
-					connection.console.error(format(logObj));
-					break;
-				default: nonexhaustive(logObj.level);
-			}
-		} catch (e) {
-			console.error("Error while logging to LSP connection:", e);
-		}
-	};
-}
-function getTelemetrySink(connection) {
-	const messageOnly = getMessageOnlyFormatter();
-	return (logObj) => {
-		try {
-			switch (logObj.level) {
-				case "error":
-				case "fatal": {
-					const err = errorFromLogRecord(logObj);
-					if (err) connection.telemetry.logEvent({
-						eventName: "error",
-						message: `${err.name}: ${err.message}`,
-						category: logObj.category.join("."),
-						...err.stack && { stack: err.stack }
-					});
-					else connection.telemetry.logEvent({
-						eventName: "error",
-						message: messageOnly(logObj),
-						category: logObj.category.join(".")
-					});
-					break;
-				}
-			}
-		} catch (e) {
-			console.error("Error while logging to LSP connection:", e);
-		}
-	};
-}
-
-//#endregion
-//#region src/workspace/ProjectsManager.ts
-var import_picomatch = /* @__PURE__ */ __toESM(require_picomatch(), 1);
-const logger$2 = logger$3.getChild("ProjectsManager");
-function normalizeUri(uri) {
-	if (URI.isUri(uri)) return uri.toString();
-	else if (typeof uri === "string") return uri.startsWith("file://") ? uri : URI.file(uri).toString();
-	else return uri.uri.toString();
-}
-/**
-* Compare function to ensure consistent order
-*/
-const compare = compareNaturalHierarchically("/", true);
-const compareUri = (a, b) => compare(withoutTrailingSlash(a.path), withoutTrailingSlash(b.path));
-/**
-* Returns a predicate that checks if the given path is included in the project folder.
-*/
-function isParentFolderFor(uri) {
-	const path = normalizeUri(uri);
-	return (p) => path.startsWith(p.folder);
-}
-function ProjectFolder(folder) {
-	folder = normalizeUri(folder);
-	return withTrailingSlash(folder);
-}
-const DefaultProject = {
-	id: "default",
-	config: {
-		name: "default",
-		exclude: ["**/node_modules/**"]
-	},
-	exclude: (0, import_picomatch.default)("**/node_modules/**", { dot: true }),
-	includeConfig: {
-		paths: [],
-		maxDepth: 3,
-		fileThreshold: 30
-	}
-};
-var ProjectsManager = class ProjectsManager {
-	/**
-	* The global project ID used for all documents
-	* that are not part of a specific project.
-	*/
-	static DefaultProjectId = DefaultProject.id;
-	#updateListeners = [];
-	/**
-	* Configured default project ID.
-	* (it is used in CLI and Vite plugin)
-	*/
-	#defaultProjectId = void 0;
-	/**
-	* Cached default project.
-	*/
-	#defaultProject = void 0;
-	/**
-	* The mapping between project config files and project IDs.
-	*/
-	#projectIdToFolder = new BiMap();
-	/**
-	* Registered projects.
-	* Sorted descending by the number of segments in the folder path.
-	* This ensures that the most specific project is used for a document.
-	*/
-	#projects = [];
-	/**
-	* This is a cached lookup for performance.
-	*/
-	#lookupById = new DefaultMap((id) => {
-		if (id === ProjectsManager.DefaultProjectId) {
-			const folder = ProjectFolder(this.getWorkspaceFolder());
-			return {
-				id,
-				config: DefaultProject.config,
-				folder,
-				folderUri: URI.parse(folder),
-				exclude: DefaultProject.exclude,
-				includeConfig: DefaultProject.includeConfig
-			};
-		}
-		return nonNullable(this.#projects.find((p) => p.id === id), `Project ${id} not found`);
-	});
-	#excludedDocuments = /* @__PURE__ */ new WeakMap();
-	constructor(services) {
-		this.services = services;
-		logger$2.debug`created`;
-	}
-	/**
-	* Returns:
-	*  - configured default project ID if set
-	*  - the default project ID if there are no projects.
-	*  - the ID of the only project
-	*  - undefined if there are multiple projects.
-	*/
-	get defaultProjectId() {
-		if (this.#defaultProjectId) return this.#defaultProjectId;
-		if (this.#projects.length > 1) return;
-		return this.#projects[0]?.id ?? ProjectsManager.DefaultProjectId;
-	}
-	set defaultProjectId(id) {
-		if (id === this.#defaultProjectId) return;
-		this.#defaultProject = void 0;
-		if (!id || id === ProjectsManager.DefaultProjectId) {
-			logger$2.debug`reset default project ID`;
-			this.#defaultProjectId = void 0;
-			return;
-		}
-		invariant(this.#projects.find((p) => p.id === id), `Project "${id}" not found`);
-		logger$2.debug`set default project ID to ${id}`;
-		this.#defaultProjectId = id;
-	}
-	get default() {
-		if (!this.#defaultProject) {
-			const id = this.defaultProjectId ?? ProjectsManager.DefaultProjectId;
-			this.#defaultProject = this.#lookupById.get(id);
-		}
-		return this.#defaultProject;
-	}
-	get all() {
-		if (t(this.#projects, 1)) {
-			const ids = [...t$1(this.#projects, e("id")), DefaultProject.id];
-			if (this.#defaultProjectId) {
-				const idx = ids.findIndex((p) => p === this.#defaultProjectId);
-				if (idx > 0) {
-					const [defaultProject] = ids.splice(idx, 1);
-					return [defaultProject, ...ids];
-				}
-			}
-			return ids;
-		}
-		return [DefaultProject.id];
-	}
-	getProject(arg) {
-		const id = typeof arg === "string" ? arg : arg.likec4ProjectId || this.belongsTo(arg);
-		const project = this.#lookupById.get(id);
-		return {
-			id,
-			folderUri: project.folderUri,
-			config: project.config,
-			...project.includePaths && { includePaths: t$1(project.includePaths, e("uri")) }
-		};
-	}
-	/**
-	* Returns all projects that include the specified folder, or inside the folder.
-	*/
-	findAllProjectsByFolder(folder) {
-		const projectFolder = ProjectFolder(folder);
-		const isInsideOrIncludes = (p) => p.folder.startsWith(projectFolder) || projectFolder.startsWith(p.folder);
-		return this.#projects.filter(isInsideOrIncludes);
-	}
-	/**
-	* Validates and ensures the project ID.
-	* If no project ID is specified, returns default project ID
-	* If there are multiple projects and default project is not set, throws an error
-	*/
-	ensureProjectId(projectId) {
-		if (projectId === ProjectsManager.DefaultProjectId) return this.defaultProjectId ?? ProjectsManager.DefaultProjectId;
-		if (projectId) {
-			invariant(this.#projectIdToFolder.has(projectId), `Project ID ${projectId} is not registered`);
-			return projectId;
-		}
-		return nonNullable(this.defaultProjectId, () => `Specify exact project, known: [${[...this.#projectIdToFolder.keys()].join(", ")}]`);
-	}
-	/**
-	* Validates and ensures the project.
-	*/
-	ensureProject(projectId) {
-		projectId = this.ensureProjectId(projectId);
-		return this.getProject(projectId);
-	}
-	hasMultipleProjects() {
-		return this.#projects.length > 1;
-	}
-	/**
-	* Checks if the specified document should be excluded from processing.
-	*/
-	isExcluded(document) {
-		if (typeof document === "string" || URI.isUri(document)) {
-			let docUriAsString = normalizeUri(document);
-			const project = this.findProjectForDocument(docUriAsString);
-			if (!project.exclude) return false;
-			const input = withoutProtocol(docUriAsString);
-			return project.exclude(input);
-		}
-		let isExcluded = this.#excludedDocuments.get(document);
-		if (isExcluded === void 0) {
-			isExcluded = this.isExcluded(document.uri);
-			this.#excludedDocuments.set(document, isExcluded);
-		}
-		return isExcluded;
-	}
-	/**
-	* Checks if the specified document is included by the project:
-	* - if the document belongs to the project and is not excluded
-	* - if the document is included by the project
-	*/
-	isIncluded(projectId, document) {
-		if (typeof document !== "string" && !URI.isUri(document)) return this.isIncluded(projectId, document.uri);
-		if (this.belongsTo(document) === projectId) return !this.isExcluded(document);
-		let includePaths = this.#lookupById.get(projectId)?.includePaths;
-		if (!includePaths) return false;
-		return includePaths.some(isParentFolderFor(document));
-	}
-	/**
-	* Checks if it is a config file and it is not excluded by default exclude pattern
-	*
-	* @param entry The file system entry to check
-	*/
-	isConfigFile(entry) {
-		const filename = parseFilename(entry.toString(), { strict: false })?.toLowerCase();
-		const isConfigFile = !!filename && isLikeC4Config(filename);
-		if (isConfigFile) {
-			if (DefaultProject.exclude(entry.path)) {
-				logger$2.debug`exclude config file ${entry.path}`;
-				return false;
-			}
-		}
-		return isConfigFile;
-	}
-	/**
-	* Registers likec4 project by config file.
-	*/
-	async registerConfigFile(configFile, cancelToken) {
-		if (DefaultProject.exclude(configFile.path)) throw new Error(`Path to ${configFile.fsPath} is excluded by: ${DefaultProject.config.exclude.join(", ")}`);
-		if (!this.isConfigFile(configFile)) throw new Error(`${configFile.fsPath} is not a valid LikeC4 config filename.`);
-		try {
-			const config = await this.services.workspace.FileSystemProvider.loadProjectConfig(configFile);
-			const path = joinRelativeURL(configFile.path, "..");
-			const folderUri = configFile.with({ path });
-			return await this.registerProject({
-				config,
-				folderUri
-			}, cancelToken);
-		} catch (error) {
-			if (!isOperationCancelled(error)) {
-				this.services.lsp.Connection?.window.showErrorMessage(`LikeC4: Failed to register project at ${configFile.fsPath}`);
-				throw wrapError(error, `Failed to register project config ${configFile.fsPath}:\n`);
-			}
-			return Promise.reject(error);
-		}
-	}
-	/**
-	* Registers (or reloads) likec4 project by config file or config object.
-	* If there is some project registered at same folder, it will be reloaded.
-	*/
-	async registerProject(opts, cancelToken) {
-		const config = validateProjectConfig(opts.config);
-		const folder = ProjectFolder(opts.folderUri);
-		let project = this.#projects.find((p) => p.folder === folder);
-		if (project && deepEqual(project.config, config)) return project;
-		let mustReset = false;
-		let id;
-		if (!project) {
-			if (this.#projectIdToFolder.has(config.name)) logger$2.warn`Project "${config.name}" already exists, generating unique ID`;
-			id = this.uniqueProjectId(config.name);
-			const includeConfig = normalizeIncludeConfig(config.include);
-			project = {
-				id,
-				config,
-				folder,
-				folderUri: URI.parse(folder),
-				includeConfig
-			};
-			mustReset = this.#projects.some((p) => p.folder.startsWith(folder) || folder.startsWith(p.folder));
-			this.#projects = t$2([...this.#projects, project], t$3((a, b) => compareUri(a.folderUri, b.folderUri)));
-			logger$2.info`register project ${project.id} folder: ${folder}`;
-		} else {
-			mustReset = true;
-			if (project.config.name !== config.name) {
-				this.#projectIdToFolder.delete(project.id);
-				logger$2.info`unregister project ${project.id} folder: ${folder}`;
-				id = this.uniqueProjectId(config.name);
-				project.id = id;
-				logger$2.info`re-register project ${project.id} folder: ${folder}`;
-			} else {
-				id = project.id;
-				logger$2.info`update project ${project.id} on config change`;
-			}
-			project.config = config;
-			const includeConfig = normalizeIncludeConfig(config.include);
-			project.includeConfig = includeConfig;
-		}
-		if (e$1(config.exclude)) project.exclude = DefaultProject.exclude;
-		else if (t(config.exclude, 1)) {
-			const patterns = t$1(config.exclude, (p) => {
-				if (!isRelative(p) && !p.startsWith("**")) p = joinURL("**", p);
-				return cleanDoubleSlashes(joinRelativeURL(project.folderUri.path, p));
-			});
-			project.exclude = (0, import_picomatch.default)(patterns, {
-				contains: true,
-				dot: true
-			});
-		}
-		if (project.includeConfig.paths && t(project.includeConfig.paths, 1)) {
-			project.includePaths = t$1(project.includeConfig.paths, (includePath) => {
-				const resolvedPath = joinRelativeURL(project.folderUri.path, includePath);
-				const uri = project.folderUri.with({ path: resolvedPath });
-				return {
-					uri,
-					folder: ProjectFolder(uri)
-				};
-			});
-			logger$2.debug`project ${project.id} include paths: ${project.includePaths.map((p) => p.uri.fsPath).join(", ")}`;
-			for (const includePath of project.includePaths) for (const otherProject of this.#projects) {
-				if (otherProject.id === project.id) continue;
-				if (includePath.folder.startsWith(otherProject.folder) || otherProject.folder.startsWith(includePath.folder)) {
-					mustReset = true;
-					logger$2.warn("Project \"{projectId}\" include path \"{includePath}\" overlaps with project \"{otherProjectId}\" folder. Files in overlapping areas will only belong to one project.", {
-						projectId: project.id,
-						includePath: includePath.folder,
-						otherProjectId: otherProject.id
-					});
-				}
-				if (otherProject.includePaths) {
-					for (const otherIncludePath of otherProject.includePaths) if (includePath.folder.startsWith(otherIncludePath.folder) || otherIncludePath.folder.startsWith(includePath.folder)) {
-						mustReset = true;
-						logger$2.warn("Project \"{projectId}\" include path \"{includePath}\" overlaps with project \"{otherProjectId}\" include path \"{otherIncludePath}\". Files in overlapping areas will only belong to one project.", {
-							projectId: project.id,
-							includePath: includePath.folder,
-							otherProjectId: otherProject.id,
-							otherIncludePath: otherIncludePath.folder
-						});
-					}
-				}
-			}
-		} else delete project.includePaths;
-		this.#defaultProject = void 0;
-		this.#projectIdToFolder.set(project.id, folder);
-		this.#lookupById.clear();
-		if (this.#activeReload) return project;
-		if (mustReset) await this.rebuidProject(project.id, cancelToken).catch((error) => {
-			if (isOperationCancelled(error)) return Promise.reject(error);
-			logger$2.warn("Failed to rebuild project {projectId} after config change", {
-				projectId: project.id,
-				error
-			});
-			return Promise.resolve();
-		});
-		this.notifyListeners();
-		return project;
-	}
-	/**
-	* Determines which project the given document belongs to.
-	* If the document does not belong to any project, returns the default project ID.
-	*/
-	belongsTo(document) {
-		if (URI.isUri(document) || typeof document === "string") {
-			const documentUri = normalizeUri(document);
-			return this.findProjectForDocument(documentUri).id;
-		}
-		return this.documentBelongsTo.get(document, () => {
-			return this.findProjectForDocument(normalizeUri(document.uri));
-		}).id;
-	}
-	#activeReload = null;
-	async reloadProjects(cancelToken) {
-		if (this.#activeReload) {
-			logger$2.debug`reload projects is already in progress, waiting`;
-			return await this.#activeReload.catch(() => {});
-		}
-		logger$2.debug`schedule reload projects`;
-		this.#activeReload = Promise.resolve().then(() => this._reloadProjects(cancelToken)).catch((error) => {
-			if (!isOperationCancelled(error)) logger$2.warn("Failed to reload projects", { error });
-			return Promise.reject(error);
-		}).finally(() => {
-			this.#activeReload = null;
-			this.notifyListeners();
-		});
-		return await this.#activeReload;
-	}
-	async _reloadProjects(cancelToken) {
-		const folders = this.services.workspace.WorkspaceManager.workspaceFolders;
-		if (!folders) {
-			logger$2.warn("No workspace folders found");
-			return;
-		}
-		logger$2.debug`start reload projects`;
-		const configFiles = [];
-		for (const folder of folders) try {
-			logger$2.debug`scan projects in folder ${folder.uri}`;
-			const files = await this.services.workspace.FileSystemProvider.scanProjectFiles(URI.parse(folder.uri));
-			for (const file of files) if (file.isFile && this.isConfigFile(file.uri)) {
-				logger$2.debug`found config ${file.uri.fsPath}`;
-				configFiles.push(file.uri);
-			}
-		} catch (error) {
-			logger$2.error("Failed to scanProjectFiles, {folder}", {
-				folder: folder.uri,
-				error
-			});
-		}
-		if (configFiles.length === 0 && this.#projects.length !== 0) logger$2.warning("No config files found, but some projects were registered before");
-		configFiles.sort(compareUri);
-		this.#projects = [];
-		this.#projectIdToFolder.clear();
-		this.#lookupById.clear();
-		for (const uri of configFiles) {
-			if (cancelToken?.isCancellationRequested) break;
-			await this.registerConfigFile(uri, cancelToken).catch((error) => {
-				if (!isOperationCancelled(error)) logger$2.warn(loggable(error));
-			});
-		}
-		this.reset();
-		if (cancelToken?.isCancellationRequested) throw OperationCancelled;
-		await this.services.workspace.WorkspaceManager.rebuildAll(cancelToken);
-	}
-	uniqueProjectId(name) {
-		let id = name;
-		let i = 1;
-		while (this.#projectIdToFolder.has(id)) id = `${name}-${i++}`;
-		return id;
-	}
-	reset() {
-		logger$2.debug("reset");
-		this.#defaultProject = void 0;
-		if (this.#defaultProjectId && !this.#projectIdToFolder.has(this.#defaultProjectId)) this.#defaultProjectId = void 0;
-		this.services.workspace.LangiumDocuments.resetProjectIds();
-		this.documentBelongsTo.clear();
-		this.mappingsToProject.clear();
-		this.#lookupById.clear();
-		this.#excludedDocuments = /* @__PURE__ */ new WeakMap();
-	}
-	async rebuidProject(projectId, cancelToken) {
-		this.#defaultProject = void 0;
-		const project = this.#projects.find((p) => p.id === projectId) ?? this.default;
-		if (project.id !== projectId) logger$2.warn`Project ${projectId} not found, rebuilding default project ${project.id}`;
-		const log = logger$2.getChild(project.id);
-		const folder = project.folder;
-		const includePaths = project.includePaths;
-		const allDocs = this.services.workspace.LangiumDocuments.allKnownDocuments.filter((doc) => !isLikeC4Builtin(doc.uri)).toArray();
-		if (allDocs.length === 0) return;
-		const docs = t$2(allDocs, n((doc) => {
-			if (project.exclude?.(doc.uri.path)) return false;
-			const docUriStr = normalizeUri(doc.uri);
-			if (docUriStr.startsWith(folder)) return true;
-			if (includePaths && includePaths.some(isParentFolderFor(docUriStr))) return true;
-			const docdir = withTrailingSlash(joinRelativeURL(docUriStr, ".."));
-			return docdir.startsWith(folder) || folder.startsWith(docdir);
-		}), t$1((d) => d.uri));
-		if (docs.length === 0) {
-			log.debug("no documents in project, skipping rebuild");
-			return;
-		}
-		log.info("rebuild project documents: {docs}", { docs: docs.length });
-		this.reset();
-		await this.services.workspace.DocumentBuilder.update(docs, [], cancelToken).catch((error) => {
-			log.warn("Failed to rebuild project", { error });
-		});
-	}
-	findProjectForDocument(documentUri) {
-		return this.mappingsToProject.get(documentUri, () => {
-			const hasThisDoc = isParentFolderFor(documentUri);
-			const project = this.#projects.find(hasThisDoc);
-			if (project) return project;
-			return this.#projects.find(({ includePaths }) => {
-				return !!includePaths && includePaths.some(hasThisDoc);
-			}) ?? this.default;
-		});
-	}
-	get mappingsToProject() {
-		return memoizeProp(this, "_mappingsToProject", () => new WorkspaceCache(this.services));
-	}
-	/**
-	* The mapping between documents and projects they belong to.
-	* Lazy-created due to initialization order of the LanguageServer
-	*/
-	get documentBelongsTo() {
-		return memoizeProp(this, "_documentBelongsTo", () => new WorkspaceCache(this.services));
-	}
-	/**
-	* Returns all include paths from all projects.
-	* Used by WorkspaceManager to scan additional directories for C4 files.
-	*/
-	getAllIncludePaths() {
-		const result = [];
-		for (const project of this.#projects) if (project.includePaths) for (const includePath of project.includePaths) result.push({
-			projectId: project.id,
-			includePath: includePath.uri,
-			includeConfig: project.includeConfig
-		});
-		return result;
-	}
-	/**
-	* Register a listener to be called when the projects configuration has changed.
-	* @returns A disposable that can be used to unregister the callback.
-	*/
-	onProjectsUpdate(callback) {
-		this.#updateListeners.push(callback);
-		return Disposable.create(() => {
-			const index = this.#updateListeners.indexOf(callback);
-			if (index >= 0) this.#updateListeners.splice(index, 1);
-		});
-	}
-	getWorkspaceFolder() {
-		try {
-			return this.services.workspace.WorkspaceManager.workspaceUri;
-		} catch (error) {
-			logger$2.warn("Failed to get workspace URI, using default folder", { error });
-			return URI.file("/");
-		}
-	}
-	notifyListeners() {
-		for (const listener of this.#updateListeners) try {
-			listener();
-		} catch (e) {
-			logger$2.warn(loggable(e));
-		}
-	}
-};
-
-//#endregion
-//#region src/LikeC4LanguageServices.ts
-const logger$1 = logger$3.getChild("LanguageServices");
-/**
-* Public Language Services
-*/
-var DefaultLikeC4LanguageServices = class {
-	builder;
-	editor;
-	projectsManager;
-	constructor(services) {
-		this.services = services;
-		this.builder = services.likec4.ModelBuilder;
-		this.projectsManager = services.shared.workspace.ProjectsManager;
-		this.editor = services.likec4.ModelChanges;
-	}
-	get views() {
-		return this.services.likec4.Views;
-	}
-	get workspaceUri() {
-		return this.services.shared.workspace.WorkspaceManager.workspaceUri;
-	}
-	projects() {
-		const projectsManager = this.services.shared.workspace.ProjectsManager;
-		const projectsWithDocs = t$2(this.services.shared.workspace.LangiumDocuments.groupedByProject(), t$4(), t$1(([projectId, docs]) => {
-			const id = projectId;
-			const { folderUri, config } = projectsManager.getProject(id);
-			return {
-				id,
-				folder: folderUri,
-				title: config.title ?? config.name,
-				documents: t$1(docs, e("uri")),
-				config
-			};
-		}));
-		if (t(projectsWithDocs, 2) && projectsManager.defaultProjectId) {
-			const idx = projectsWithDocs.findIndex((p) => p.id === projectsManager.defaultProjectId);
-			if (idx > 0) {
-				const [defaultProject] = projectsWithDocs.splice(idx, 1);
-				return [defaultProject, ...projectsWithDocs];
-			}
-			return projectsWithDocs;
-		}
-		if (t(projectsWithDocs, 1)) return projectsWithDocs;
-		const { folderUri, config } = projectsManager.getProject(ProjectsManager.DefaultProjectId);
-		const documents = t$1(this.services.shared.workspace.LangiumDocuments.projectDocuments(ProjectsManager.DefaultProjectId).toArray(), e("uri"));
-		return [{
-			id: ProjectsManager.DefaultProjectId,
-			folder: folderUri,
-			title: config.title ?? config.name,
-			documents,
-			config
-		}];
-	}
-	project(projectId) {
-		projectId = this.projectsManager.ensureProjectId(projectId);
-		const { folderUri, config } = this.services.shared.workspace.ProjectsManager.getProject(projectId);
-		const documents = t$1(this.services.shared.workspace.LangiumDocuments.projectDocuments(projectId).toArray(), e("uri"));
-		return {
-			id: projectId,
-			folder: folderUri,
-			title: config.title ?? config.name,
-			documents,
-			config
-		};
-	}
-	async diagrams(project, cancelToken) {
-		const projectId = this.projectsManager.ensureProjectId(project);
-		return await this.views.diagrams(projectId, cancelToken);
-	}
-	async computedModel(project, cancelToken) {
-		const projectId = this.projectsManager.ensureProjectId(project);
-		return await this.builder.computeModel(projectId, cancelToken);
-	}
-	async layoutedModel(project, cancelToken) {
-		const projectId = this.projectsManager.ensureProjectId(project);
-		const model = await this.builder.computeModel(projectId, cancelToken);
-		if (!model) throw new Error("Failed to compute model, empty project?");
-		const layouted = await this.views.layoutAllViews(projectId, cancelToken);
-		return LikeC4Model.create({
-			...model.$data,
-			_stage: "layouted",
-			views: t$2(layouted, t$1(e("diagram")), t$5(e("id")))
-		});
-	}
-	async projectsOverview(cancelToken) {
-		const allProjects = this.services.shared.workspace.ProjectsManager.all;
-		const models = [];
-		for (const project of allProjects) {
-			const model = await this.builder.computeModel(project, cancelToken);
-			if (cancelToken?.isCancellationRequested) throw new Error("Operation cancelled");
-			if (model === LikeC4Model.EMPTY) {
-				logger$1.debug(`Project ${project} is empty, skipping`);
-				continue;
-			}
-			models.push(model);
-		}
-		if (!t(models, 1)) throw new Error("No models found");
-		const projectsView = computeProjectsView(models);
-		return await this.views.layouter.layoutProjectsView(projectsView);
-	}
-	getErrors() {
-		return this.services.shared.workspace.LangiumDocuments.allExcludingBuiltin.toArray().flatMap((doc) => {
-			return (doc.diagnostics ?? []).filter((d) => d.severity === DiagnosticSeverity.Error).map(({ message, range }) => ({
-				message,
-				line: range.start.line,
-				range,
-				sourceFsPath: doc.uri.fsPath
-			}));
-		});
-	}
-	locate(params) {
-		switch (true) {
-			case "element" in params: return this.services.likec4.ModelLocator.locateElement(params.element, params.projectId);
-			case "relation" in params: return this.services.likec4.ModelLocator.locateRelation(params.relation, params.projectId);
-			case "view" in params: return this.services.likec4.ModelLocator.locateView(params.view, params.projectId);
-			case "deployment" in params: return this.services.likec4.ModelLocator.locateDeploymentElement(params.deployment, params.projectId);
-			default: nonexhaustive$1(params);
-		}
-	}
-	async dispose() {
-		try {
-			logger$1.debug("disposing LikeC4LanguageServices");
-			await this.services.shared.workspace.FileSystemWatcher.dispose();
-			if (this.services.mcp.Server.isStarted) await this.services.mcp.Server.stop();
-			this.services.Rpc.dispose();
-			this.services.likec4.ModelBuilder.dispose();
-		} catch (e) {
-			logger$1.error(loggable(e));
-		} finally {
-			logger$1.debug("LikeC4LanguageServices disposed");
-		}
-	}
-};
-
-//#endregion
-export { logWarnError as a, getTelemetrySink as i, ProjectsManager as n, logger$3 as o, getLspConnectionSink as r, DefaultLikeC4LanguageServices as t };