@likec4/language-server 1.47.0 → 1.48.0

package/dist/_chunks/LikeC4LanguageServices.mjs

@@ -0,0 +1,725 @@
+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 };