@likec4/language-server 1.58.0 → 1.59.0

package/dist/browser/index.d.mts

@@ -1,5 +1,5 @@
-import { B as LikeC4ManualLayoutsModuleContext, C as ViewLocateResult, D as LangiumDocuments, E as LikeC4WorkspaceManager, F as FileSystemModuleContext, H as Project, I as FileSystemProvider, L as FileSystemWatcher, M as NoFileSystemWatcher, N as NoLikeC4ManualLayouts, R as FileSystemWatcherModuleContext, S as LikeC4ModelLocator, T as FqnIndex, U as ProjectData, W as ProjectsManager, _ as LikeC4ViewsModuleContext, b as LayoutViewParams, d as LikeC4LanguageServices, f as DocumentParser, j as NoFileSystem, n as LikeC4AddedServices, o as LikeC4SharedServices, p as LikeC4ModelParser, r as LikeC4Services, s as createLanguageServices, t as LanguageServicesContext, u as FormatOptions, w as LikeC4ModelBuilder, x as LikeC4Views, y as WithWasmGraphviz, z as LikeC4ManualLayouts } from "../_chunks/module.mjs";
-
+import { t as __name } from "../chunks/rolldown-runtime.mjs";
+import { B as LikeC4ManualLayoutsModuleContext, C as ViewLocateResult, D as LangiumDocuments, E as LikeC4WorkspaceManager, F as FileSystemModuleContext, H as Project, I as FileSystemProvider, L as FileSystemWatcher, M as NoFileSystemWatcher, N as NoLikeC4ManualLayouts, R as FileSystemWatcherModuleContext, S as LikeC4ModelLocator, T as FqnIndex, U as ProjectData, W as ProjectsManager, _ as LikeC4ViewsModuleContext, b as LayoutViewParams, d as LikeC4LanguageServices, f as DocumentParser, j as NoFileSystem, n as LikeC4AddedServices, o as LikeC4SharedServices, p as LikeC4ModelParser, r as LikeC4Services, s as createLanguageServices, t as LanguageServicesContext, u as FormatOptions, w as LikeC4ModelBuilder, x as LikeC4Views, y as WithWasmGraphviz, z as LikeC4ManualLayouts } from "../chunks/module.mjs";
 //#region src/browser/index.d.ts
 /**
  * Starts the LikeC4 language server in the browser, connected via the given port (e.g. a worker).
@@ -11,4 +11,4 @@ declare function startLanguageServer(port: MessagePort | DedicatedWorkerGlobalSc
   likec4: LikeC4Services;
 };
 //#endregion
-export { DocumentParser, FileSystemModuleContext, FileSystemProvider, FileSystemWatcher, FileSystemWatcherModuleContext, FormatOptions, FqnIndex, LangiumDocuments, LanguageServicesContext, LayoutViewParams, LikeC4AddedServices, LikeC4LanguageServices, LikeC4ManualLayouts, LikeC4ManualLayoutsModuleContext, LikeC4ModelBuilder, LikeC4ModelLocator, LikeC4ModelParser, LikeC4Services, LikeC4SharedServices, LikeC4Views, LikeC4ViewsModuleContext, LikeC4WorkspaceManager, NoFileSystem, NoFileSystemWatcher, NoLikeC4ManualLayouts, Project, ProjectData, ProjectsManager, ViewLocateResult, WithWasmGraphviz, createLanguageServices, startLanguageServer };
+export { type DocumentParser, type FileSystemModuleContext, type FileSystemProvider, type FileSystemWatcher, type FileSystemWatcherModuleContext, type FormatOptions, type FqnIndex, type LangiumDocuments, type LanguageServicesContext, type LayoutViewParams, type LikeC4AddedServices, type LikeC4LanguageServices, type LikeC4ManualLayouts, type LikeC4ManualLayoutsModuleContext, type LikeC4ModelBuilder, type LikeC4ModelLocator, type LikeC4ModelParser, type LikeC4Services, type LikeC4SharedServices, type LikeC4Views, type LikeC4ViewsModuleContext, type LikeC4WorkspaceManager, NoFileSystem, NoFileSystemWatcher, NoLikeC4ManualLayouts, type Project, type ProjectData, type ProjectsManager, type ViewLocateResult, type WithWasmGraphviz, createLanguageServices, startLanguageServer };

package/dist/browser/index.mjs

@@ -1 +1,32 @@
-import{ai as e,oi as t,si as n}from"../_chunks/utils.mjs";import{t as r}from"../_chunks/module.mjs";import"../_chunks/common-exports.mjs";import{configureLogger as i,getConsoleSink as a,getTextFormatter as o}from"@likec4/log";import{startLanguageServer as s}from"langium/lsp";import{BrowserMessageReader as c,BrowserMessageWriter as l,createConnection as u}from"vscode-languageserver/browser";function startLanguageServer(e){let t=u(new c(e),new l(e));i({sinks:{console:a({formatter:o({format:({level:e,category:t,message:n})=>`${e} ${t} ${n}`})})},loggers:[{category:`likec4`,sinks:[`console`],lowestLevel:`debug`}]});let n=r({connection:t});return s(n.shared),n}export{e as NoFileSystem,t as NoFileSystemWatcher,n as NoLikeC4ManualLayouts,r as createLanguageServices,startLanguageServer};
+import { t as __name } from "../chunks/rolldown-runtime.mjs";
+import { Lr as NoFileSystem, Rr as NoFileSystemWatcher, zr as NoLikeC4ManualLayouts } from "../chunks/utils.mjs";
+import { t as createLanguageServices } from "../chunks/module.mjs";
+import { configureLogger, getConsoleSink, getTextFormatter } from "@likec4/log";
+import { startLanguageServer as startLanguageServer$1 } from "langium/lsp";
+import { BrowserMessageReader, BrowserMessageWriter, createConnection } from "vscode-languageserver/browser.js";
+
+//#region src/browser/index.ts
+/**
+* Starts the LikeC4 language server in the browser, connected via the given port (e.g. a worker).
+* @param port - MessagePort or DedicatedWorkerGlobalScope for LSP communication.
+* @returns Shared and LikeC4-specific services after the connection is initialized.
+*/
+function startLanguageServer(port) {
+	const connection = createConnection(new BrowserMessageReader(port), new BrowserMessageWriter(port));
+	configureLogger({
+		sinks: { console: getConsoleSink({ formatter: getTextFormatter({ format: ({ level, category, message }) => {
+			return `${level} ${category} ${message}`;
+		} }) }) },
+		loggers: [{
+			category: "likec4",
+			sinks: ["console"],
+			lowestLevel: "debug"
+		}]
+	});
+	const services = createLanguageServices({ connection });
+	startLanguageServer$1(services.shared);
+	return services;
+}
+
+//#endregion
+export { NoFileSystem, NoFileSystemWatcher, NoLikeC4ManualLayouts, createLanguageServices, startLanguageServer };

package/dist/browser/worker.mjs

@@ -1 +1,40 @@
-import{startLanguageServer as e}from"./index.mjs";function errToString(e){switch(!0){case e instanceof Error:return e.message;case typeof e==`object`&&!!e:try{return JSON.stringify(e)}catch{return`[unserializable value]`}case typeof e==`string`:return e;case e==null:return``;case typeof e==`number`||typeof e==`boolean`:return String(e);case typeof e==`symbol`:return e.toString();default:return`unknown`}}const log=(e,t)=>{let n=t==null?e:`${e} ${errToString(t)}`;try{console.error(`[LikeC4 LSP worker]`,n)}catch{}};self.onerror=e=>(log(`Uncaught error`,e.message??e.error),!1),self.onunhandledrejection=e=>{log(`Unhandled rejection`,e.reason)};try{e(self)}catch(e){throw log(`Failed to start language server`,e),e}
+import { t as __name } from "../chunks/rolldown-runtime.mjs";
+import { startLanguageServer } from "./index.mjs";
+
+//#region src/browser/worker.ts
+function errToString(err) {
+	switch (true) {
+		case err instanceof Error: return err.message;
+		case typeof err === "object" && err !== null: try {
+			return JSON.stringify(err);
+		} catch {
+			return "[unserializable value]";
+		}
+		case typeof err === "string": return err;
+		case err === null || err === void 0: return "";
+		case typeof err === "number" || typeof err === "boolean": return String(err);
+		case typeof err === "symbol": return err.toString();
+		default: return "unknown";
+	}
+}
+const log = (msg, err) => {
+	const line = err === void 0 || err === null ? msg : `${msg} ${errToString(err)}`;
+	try {
+		console.error("[LikeC4 LSP worker]", line);
+	} catch {}
+};
+self.onerror = (event) => {
+	log("Uncaught error", event.message ?? event.error);
+	return false;
+};
+self.onunhandledrejection = (event) => {
+	log("Unhandled rejection", event.reason);
+};
+try {
+	startLanguageServer(self);
+} catch (err) {
+	log("Failed to start language server", err);
+	throw err;
+}
+
+//#endregion

package/dist/chunks/LikeC4FileSystem.mjs

@@ -0,0 +1,537 @@
+import { t as __name } from "./rolldown-runtime.mjs";
+import { t as LibIcons } from "./icons.mjs";
+import { isLikeC4Builtin } from "../likec4lib.mjs";
+import { Fr as compareByUri, Hr as logger$1, Ir as compareByUriDeepFirst, Pr as ADisposable, Rr as NoFileSystemWatcher, a as LikeC4LanguageMetaData, n as safeCall } from "./utils.mjs";
+import { compareNaturalHierarchically, onNextTick, stringHash } from "@likec4/core/utils";
+import { isLikeC4Config, loadConfig } from "@likec4/config/node";
+import { fdir } from "fdir";
+import { Disposable, SimpleCache, URI, UriUtils } from "langium";
+import { NodeFileSystemProvider } from "langium/node";
+import { mkdirSync, statSync } from "node:fs";
+import { unlink, writeFile } from "node:fs/promises";
+import { basename, dirname } from "node:path";
+import { indexBy, prop } from "remeda";
+import { exact } from "@likec4/core";
+import chokidar from "chokidar";
+import PQueue from "p-queue";
+import JSON5 from "json5";
+import pLimit from "p-limit";
+import { Position, Range } from "vscode-languageserver-types";
+
+//#region src/filesystem/LikeC4ManualLayouts.ts
+const layoutsLogger = logger$1.getChild("manual-layouts");
+const extension = ".likec4.snap";
+/**
+* @todo sync with vscode extension watchers
+*       (search for ".likec4.snap" references)
+*/
+const isManualLayoutFile = (path) => path !== extension && path.endsWith(extension);
+function fileName(view) {
+	return `${view}${extension}`;
+}
+function viewIdFromURI(uri) {
+	const fileName = UriUtils.basename(uri);
+	if (!isManualLayoutFile(fileName)) return null;
+	return fileName.slice(0, -12);
+}
+function getManualLayoutsOutDir(project) {
+	return UriUtils.resolvePath(project.folderUri, project.config.manualLayouts?.outDir ?? ".likec4");
+}
+const WithLikeC4ManualLayouts = { manualLayouts: (services) => new DefaultLikeC4ManualLayouts(services) };
+const RELATIVE_PATH_PREFIX = "file://./";
+var DefaultLikeC4ManualLayouts = class extends ADisposable {
+	services;
+	cache;
+	listeners = [];
+	#limit = pLimit(1);
+	constructor(services) {
+		super();
+		this.services = services;
+		this.cache = new SimpleCache();
+		this.onDispose(Disposable.create(() => {
+			this.listeners.length = 0;
+			this.cache.clear();
+		}));
+		onNextTick(() => {
+			this.onDispose(services.workspace.ProjectsManager.onProjectsUpdate(() => {
+				this.clearCaches();
+			}));
+		});
+	}
+	async handleFileSystemUpdate(event) {
+		const uri = event.update ?? event.delete;
+		let viewId = viewIdFromURI(uri) ?? void 0;
+		const projectId = this.services.workspace.ProjectsManager.ownerProjectId(uri);
+		this.cache.delete(projectId);
+		if ("delete" in event) {
+			this.triggerUpdate(exact({
+				removed: uri,
+				projectId,
+				viewId
+			}));
+			return;
+		}
+		const project = this.services.workspace.ProjectsManager.getProject(projectId);
+		if (!viewId) {
+			const snapshot = await this.readSnapshot(uri, project);
+			if (snapshot) viewId = snapshot.id;
+			else {
+				layoutsLogger.error(`Snapshot ${uri.fsPath} does not exist or is invalid`);
+				viewId = "index";
+			}
+		}
+		this.triggerUpdate({
+			updated: uri,
+			projectId,
+			viewId
+		});
+	}
+	onManualLayoutUpdate(listener) {
+		this.listeners.push(listener);
+		return { dispose: () => {
+			const index = this.listeners.indexOf(listener);
+			if (index !== -1) this.listeners.splice(index, 1);
+		} };
+	}
+	async readManualLayouts(project) {
+		const logger = layoutsLogger.getChild(project.id);
+		const fs = this.services.workspace.FileSystemProvider;
+		const outDir = getManualLayoutsOutDir(project);
+		const manualLayouts = [];
+		let hash = `${outDir.toString()}`;
+		try {
+			const files = await fs.scanDirectory(outDir, isManualLayoutFile);
+			if (files.length === 0) return null;
+			files.sort((a, b) => a.uri.path.localeCompare(b.uri.path));
+			for (const file of files) try {
+				const content = await fs.readFile(file.uri);
+				const parsed = JSON5.parse(content);
+				hash = stringHash(hash + file.uri.toString() + content);
+				const resolved = this.resolveIconPathsAfterRead(parsed, project.folderUri);
+				manualLayouts.push({
+					...resolved,
+					_layout: "manual"
+				});
+			} catch (err) {
+				logger.warn(`Failed to read view snapshot ${file.uri.fsPath}`, { err });
+			}
+			if (manualLayouts.length) logger.trace`read manual layouts for ${project.id}, found ${manualLayouts.length}`;
+		} catch (err) {
+			logger.warn(`Failed to read manual layouts for ${project.folderUri.fsPath}`, { err });
+		}
+		if (manualLayouts.length === 0) return null;
+		const views = indexBy(manualLayouts, prop("id"));
+		return {
+			hash,
+			views
+		};
+	}
+	async readSnapshot(uri, project) {
+		const fs = this.services.workspace.FileSystemProvider;
+		try {
+			const content = await fs.readFile(uri);
+			const parsed = JSON5.parse(content);
+			if (!project) {
+				const projectId = this.services.workspace.ProjectsManager.ownerProjectId(uri);
+				project = this.services.workspace.ProjectsManager.getProject(projectId);
+			}
+			return {
+				...this.resolveIconPathsAfterRead(parsed, project.folderUri),
+				_layout: "manual"
+			};
+		} catch (err) {
+			layoutsLogger.warn(`Failed to read view snapshot ${uri.fsPath}`, { err });
+			return null;
+		}
+	}
+	async read(project) {
+		return await this.#limit(async () => {
+			const cached = this.cache.get(project.id);
+			if (cached !== void 0) {
+				layoutsLogger.trace`cache hit project ${project.id}`;
+				return cached;
+			}
+			const result = await this.readManualLayouts(project);
+			this.cache.set(project.id, result);
+			return result;
+		});
+	}
+	async write(project, layouted) {
+		this.cache.delete(project.id);
+		const logger = layoutsLogger.getChild(project.id);
+		const outDir = getManualLayoutsOutDir(project);
+		const file = UriUtils.joinPath(outDir, fileName(layouted.id));
+		if ("manualLayout" in layouted) {
+			const { manualLayout: _, ...rest } = layouted;
+			layouted = rest;
+		}
+		const content = JSON5.stringify(this.normalizeIconPathsForWrite(layouted, project.folderUri), {
+			space: 2,
+			quote: "'"
+		});
+		const location = {
+			uri: file.toString(),
+			range: Range.create(Position.create(0, 0), Position.create(content.split("\n").length - 1, 1))
+		};
+		logger.debug`write snapshot of ${layouted.id} in project ${project.id} to ${file.fsPath}`;
+		const fs = this.services.workspace.FileSystemProvider;
+		try {
+			await fs.writeFile(file, content + "\n");
+			this.triggerUpdate({
+				updated: file,
+				projectId: project.id,
+				viewId: layouted.id
+			});
+		} catch (err) {
+			logger.warn(`Failed to write snapshot ${layouted.id} to ${file.fsPath}`, { err });
+		}
+		return location;
+	}
+	async remove(project, view) {
+		this.cache.delete(project.id);
+		const logger = layoutsLogger.getChild(project.id);
+		const outDir = getManualLayoutsOutDir(project);
+		const file = UriUtils.joinPath(outDir, fileName(view));
+		logger.debug`delete snapshot of ${view} in project ${project.id}. File: ${file.fsPath}`;
+		const location = {
+			uri: file.toString(),
+			range: Range.create(0, 0, 0, 0)
+		};
+		try {
+			if (!await this.services.workspace.FileSystemProvider.deleteFile(file)) {
+				logger.warn`Snapshot ${view} did not exist at ${file.fsPath}`;
+				return null;
+			}
+			this.triggerUpdate({
+				removed: file,
+				projectId: project.id,
+				viewId: view
+			});
+		} catch (err) {
+			logger.warn(`Failed to delete snapshot ${view} from ${file.fsPath}`, { err });
+		}
+		return location;
+	}
+	clearCaches() {
+		layoutsLogger.trace`clear caches`;
+		this.cache.clear();
+	}
+	triggerUpdate(event) {
+		const listeners = [...this.listeners];
+		for (const listener of listeners) safeCall(() => listener(event));
+	}
+	/**
+	* When we save snapshot - it may contain fullpath to icons on the machine it was created,
+	* that is wrong when opened on another.
+	*
+	* Prepares a snapshot for writing by converting absolute icon paths to relative paths.
+	* Absolute paths starting with 'file://' are converted to relative paths prefixed with 'file://./'
+	*/
+	normalizeIconPathsForWrite(layouted, projectUri) {
+		const nodes = layouted.nodes.map((node) => {
+			if (!node.icon || typeof node.icon !== "string") return node;
+			if (node.icon.startsWith("file://")) {
+				const iconUri = URI.parse(node.icon);
+				const relativePath = UriUtils.relative(projectUri, iconUri);
+				if (relativePath.startsWith("..")) return node;
+				return {
+					...node,
+					icon: `${RELATIVE_PATH_PREFIX}${relativePath}`
+				};
+			}
+			return node;
+		});
+		return {
+			...layouted,
+			nodes
+		};
+	}
+	/**
+	* Postprocesses a snapshot after reading by converting relative icon paths back to absolute paths.
+	* Relative paths prefixed with 'file://./' are converted to absolute paths based on project folder.
+	*/
+	resolveIconPathsAfterRead(layouted, projectUri) {
+		const nodes = layouted.nodes.map((node) => {
+			if (!node.icon || typeof node.icon !== "string") return node;
+			if (node.icon.startsWith(RELATIVE_PATH_PREFIX)) {
+				const relativePath = node.icon.substring(9);
+				const absoluteUri = UriUtils.joinPath(projectUri, relativePath);
+				return {
+					...node,
+					icon: absoluteUri.toString()
+				};
+			}
+			return node;
+		});
+		return {
+			...layouted,
+			nodes
+		};
+	}
+};
+
+//#endregion
+//#region src/filesystem/utils.ts
+function hasLikeC4Ext(path) {
+	return LikeC4LanguageMetaData.fileExtensions.some((ext) => path !== ext && path.endsWith(ext));
+}
+const nodeModulesOrRepo = [
+	"node_modules",
+	".git",
+	".svn",
+	".yarn",
+	".pnpm"
+];
+/**
+* Check if the given directory name is a node_modules or repository directory
+*/
+function isNodeModulesOrRepo(basename) {
+	return nodeModulesOrRepo.includes(basename);
+}
+function insideNodeModulesOrRepo(path) {
+	for (const dir of nodeModulesOrRepo) if (path.includes(dir)) return true;
+	return false;
+}
+
+//#endregion
+//#region src/filesystem/ChokidarWatcher.ts
+const logger = logger$1.getChild("chokidar");
+const WithChokidarWatcher = { fileSystemWatcher: (services) => new ChokidarFileSystemWatcher(services) };
+const isAnyLikeC4File = (path) => {
+	const filename = basename(path);
+	return hasLikeC4Ext(filename) || isLikeC4Config(filename) || isManualLayoutFile(filename);
+};
+/**
+* A no-op file system watcher.
+*/
+var ChokidarFileSystemWatcher = class {
+	services;
+	watcher;
+	queue = new PQueue({
+		concurrency: 1,
+		timeout: 5e3
+	});
+	constructor(services) {
+		this.services = services;
+		logger.trace`ChokidarFileSystemWatcher created`;
+	}
+	watch(folder) {
+		if (this.watcher) {
+			logger.debug`add watching folder: ${folder}`;
+			this.watcher.add(folder);
+			return;
+		}
+		this.watcher = this.createWatcher(folder);
+	}
+	async dispose() {
+		if (this.watcher) {
+			const watcher = this.watcher;
+			this.watcher = void 0;
+			try {
+				await watcher.close();
+			} catch {}
+		}
+	}
+	createWatcher(folder) {
+		logger.debug`create watcher for folder: ${folder}`;
+		let watcher = chokidar.watch(folder, {
+			ignored: [
+				(path) => insideNodeModulesOrRepo(path),
+				(path, stats) => !!stats && stats.isFile() && !isAnyLikeC4File(path),
+				(path) => this.services.workspace.ProjectsManager.isExcluded(URI.file(path))
+			],
+			followSymlinks: true,
+			ignoreInitial: true
+		});
+		const onAddOrChange = (path, stats) => {
+			if (stats?.isDirectory()) return;
+			this.enqueueFileOp("addOrChange: " + path, async () => {
+				await this.onAddOrChange(path);
+			});
+		};
+		const onRemove = (path, stats) => {
+			if (stats?.isDirectory()) return;
+			this.enqueueFileOp("remove: " + path, async () => {
+				await this.onRemove(path);
+			});
+		};
+		watcher.on("add", onAddOrChange).on("change", onAddOrChange).on("unlink", onRemove).on("unlinkDir", (path) => {
+			this.enqueueFileOp("removeDir: " + path, async () => {
+				await this.onRemoveDir(path);
+			});
+		});
+		return watcher;
+	}
+	enqueueFileOp(fileop, fn) {
+		this.queue.add(async () => {
+			try {
+				await fn();
+			} catch (error) {
+				logger.warn(`Failed on {fileop}`, {
+					fileop,
+					error
+				});
+			}
+		}).catch((error) => {
+			logger.error(`Error on {fileop}`, {
+				fileop,
+				error
+			});
+		});
+	}
+	async onAddOrChange(path) {
+		const workspace = this.services.workspace;
+		const filename = basename(path);
+		const uri = URI.file(path);
+		switch (true) {
+			case isLikeC4Config(filename):
+				logger.debug`project config changed: ${path}`;
+				workspace.ManualLayouts.clearCaches();
+				await workspace.ProjectsManager.registerConfigFile(uri);
+				break;
+			case isManualLayoutFile(filename):
+				logger.debug`manual layout file changed: ${path}`;
+				await workspace.ManualLayouts.handleFileSystemUpdate({ update: uri });
+				break;
+			case hasLikeC4Ext(filename):
+				logger.debug`file changed: ${path}`;
+				await workspace.DocumentBuilder.update([uri], []);
+				break;
+			default: logger.warn`Unknown file change: ${path}`;
+		}
+	}
+	async onRemove(path) {
+		const workspace = this.services.workspace;
+		const filename = basename(path);
+		const uri = URI.file(path);
+		switch (true) {
+			case isLikeC4Config(filename):
+				logger.debug`project file removed: ${path}`;
+				workspace.ManualLayouts.clearCaches();
+				await workspace.ProjectsManager.reloadProjects();
+				break;
+			case hasLikeC4Ext(filename):
+				logger.debug`file removed: ${path}`;
+				await workspace.DocumentBuilder.update([], [uri]);
+				break;
+			case isManualLayoutFile(filename):
+				logger.debug`manual layout file removed: ${path}`;
+				await workspace.ManualLayouts.handleFileSystemUpdate({ delete: uri });
+				break;
+			default: logger.warn`Unknown file removal: ${path}`;
+		}
+	}
+	async onRemoveDir(path) {
+		logger.debug`directory removed: ${path}`;
+		const workspace = this.services.workspace;
+		if (workspace.ProjectsManager.findOverlaped(path).length > 0) {
+			workspace.ManualLayouts.clearCaches();
+			await workspace.ProjectsManager.reloadProjects();
+		}
+	}
+};
+
+//#endregion
+//#region src/filesystem/LikeC4FileSystem.ts
+function isLikeC4ConfigFile(path, isDirectory = false) {
+	return !isDirectory && isLikeC4Config(basename(path));
+}
+function isLikeC4File(path, isDirectory = false) {
+	return !isDirectory && hasLikeC4Ext(basename(path));
+}
+const WithFileSystem = (enableWatcher = false) => ({
+	fileSystemProvider: () => new SymLinkTraversingFileSystemProvider(),
+	...enableWatcher ? WithChokidarWatcher : NoFileSystemWatcher
+});
+/**
+* A file system provider that follows symbolic links.
+* @see https://github.com/likec4/likec4/pull/1213
+*/
+var SymLinkTraversingFileSystemProvider = class extends NodeFileSystemProvider {
+	#logger = logger$1.getChild("filesystem");
+	async readFile(uri) {
+		if (isLikeC4Builtin(uri)) return Promise.resolve(LibIcons);
+		try {
+			return await super.readFile(uri);
+		} catch (error) {
+			this.#logger.warn(`Failed to read file ${uri.fsPath}`, { error });
+			return "";
+		}
+	}
+	async readDirectory(folderPath, opts) {
+		const recursive = opts?.recursive ?? true;
+		const maxDepth = opts?.maxDepth ?? Infinity;
+		const entries = [];
+		try {
+			let crawler = new fdir().withSymlinks({ resolvePaths: false }).exclude(isNodeModulesOrRepo).withFullPaths().filter(isLikeC4File);
+			if (!recursive) crawler = crawler.withMaxDepth(1);
+			else if (maxDepth !== Infinity) crawler = crawler.withMaxDepth(maxDepth);
+			const crawled = await crawler.crawl(folderPath.fsPath).withPromise();
+			for (const path of crawled) entries.push({
+				isFile: true,
+				isDirectory: false,
+				uri: URI.file(path)
+			});
+			return entries.sort(compareByUri);
+		} catch (error) {
+			this.#logger.warn(`Failed to read directory ${folderPath.fsPath}`, { error });
+			return [];
+		}
+	}
+	async scanProjectFiles(folderUri) {
+		const files = await this.scanDirectory(folderUri, isLikeC4ConfigFile);
+		if (files.length <= 1) return files;
+		return files.sort(compareByUriDeepFirst);
+	}
+	async scanDirectory(directory, filter) {
+		const entries = [];
+		try {
+			const crawled = await new fdir().withSymlinks({ resolvePaths: false }).exclude(isNodeModulesOrRepo).withFullPaths().filter(filter).crawl(directory.fsPath).withPromise();
+			for (const path of crawled) entries.push({
+				isFile: true,
+				isDirectory: false,
+				uri: URI.file(path)
+			});
+		} catch (error) {
+			this.#logger.warn(`Failed to scan directory {path}`, {
+				path: directory.fsPath,
+				error
+			});
+		}
+		return entries;
+	}
+	async loadProjectConfig(filepath) {
+		return await loadConfig(filepath);
+	}
+	async writeFile(uri, content) {
+		const dir = dirname(uri.fsPath);
+		const exists = statSync(dir, { throwIfNoEntry: false });
+		if (exists?.isFile()) throw new Error(`Cannot create directory ${dir} because a file with the same name exists.`);
+		if (!exists) {
+			this.#logger.debug("creating directory {path}", { path: dir });
+			mkdirSync(dir, { recursive: true });
+		}
+		this.#logger.debug("writing file {path}", { path: uri.fsPath });
+		return await writeFile(uri.fsPath, content, { encoding: "utf-8" });
+	}
+	async deleteFile(uri) {
+		try {
+			const path = uri.fsPath;
+			const exists = statSync(path, { throwIfNoEntry: false });
+			if (exists?.isFile() || exists?.isSymbolicLink()) {
+				await unlink(path);
+				this.#logger.debug("deleted file {path}", { path });
+				return true;
+			} else {
+				this.#logger.warn("deleteFile failed: {path} does not exist, or is not a file", { path });
+				return false;
+			}
+		} catch (error) {
+			this.#logger.warn(`Failed to delete file ${uri.fsPath}`, { error });
+		}
+		return false;
+	}
+};
+
+//#endregion
+export { WithChokidarWatcher as n, WithLikeC4ManualLayouts as r, WithFileSystem as t };

package/dist/{_chunks → chunks}/icons.d.mts

@@ -1,3 +1,4 @@
+import { t as __name } from "./rolldown-runtime.mjs";
 //#region src/generated-lib/icons.d.ts
 declare const groupedIcons: {
   readonly aws: readonly ["activate", "alexa-for-business", "amplify", "apache-mxnet-on-aws", "api-gateway", "app-config", "app-flow", "app-mesh", "app-runner", "app-stream", "app-sync", "application-auto-scaling", "application-composer", "application-cost-profiler", "application-discovery-service", "application-migration-service", "artifact", "athena", "audit-manager", "augmented-ai-a2i", "aurora", "auto-scaling", "backint-agent", "backup", "batch", "billing-conductor", "bottlerocket", "braket", "budgets", "certificate-manager", "chatbot", "chime-sdk", "chime-voice-connector", "chime", "clean-rooms", "client-vpn", "cloud-control-api", "cloud-development-kit", "cloud-directory", "cloud-formation", "cloud-front", "cloud-hsm", "cloud-map", "cloud-search", "cloud-shell", "cloud-trail", "cloud-wan", "cloud-watch", "cloud9", "code-artifact", "code-build", "code-catalyst", "code-commit", "code-deploy", "code-guru", "code-pipeline", "code-star", "code-whisperer", "cognito", "command-line-interface", "comprehend-medical", "comprehend", "compute-optimizer", "config", "connect", "console-mobile-application", "control-tower", "corretto", "cost-and-usage-report", "cost-explorer", "data-exchange", "data-pipeline", "data-sync", "data-zone", "database-migration-service", "deep-composer", "deep-learning-amis", "deep-learning-containers", "deep-lens", "deep-racer", "detective", "dev-ops-guru", "device-farm", "direct-connect", "directory-service", "distro-for-open-telemetry", "document-db", "dynamo-db", "ec2-auto-scaling", "ec2-image-builder", "ec2", "ecs-anywhere", "efs", "eks-anywhere", "eks-cloud", "eks-distro", "elasti-cache", "elastic-beanstalk", "elastic-block-store", "elastic-container-registry", "elastic-container-service", "elastic-disaster-recovery", "elastic-fabric-adapter", "elastic-inference", "elastic-kubernetes-service", "elastic-load-balancing", "elastic-transcoder", "elemental-appliances-software", "elemental-conductor", "elemental-delta", "elemental-link", "elemental-live", "elemental-media-connect", "elemental-media-convert", "elemental-media-live", "elemental-media-package", "elemental-media-store", "elemental-media-tailor", "elemental-server", "emr", "event-bridge", "express-workflows", "fargate", "fault-injection-simulator", "file-cache", "fin-space", "firewall-manager", "forecast", "fraud-detector", "free-rtos", "fsx-for-lustre", "fsx-for-net-app-ontap", "fsx-for-open-zfs", "fsx-for-wfs", "fsx", "game-kit", "game-lift", "game-sparks", "genomics-cli", "global-accelerator", "glue-data-brew", "glue-elastic-views", "glue", "ground-station", "guard-duty", "health-lake", "honeycode", "iam-identity-center", "identity-and-access-management", "inspector", "interactive-video-service", "io-t-1-click", "io-t-analytics", "io-t-button", "io-t-core", "io-t-device-defender", "io-t-device-management", "io-t-edu-kit", "io-t-events", "io-t-express-link", "io-t-fleet-wise", "io-t-greengrass", "io-t-robo-runner", "io-t-site-wise", "io-t-things-graph", "io-t-twin-maker", "iq", "kendra", "key-management-service", "keyspaces", "kinesis-data-analytics", "kinesis-data-streams", "kinesis-firehose", "kinesis-video-streams", "kinesis", "lake-formation", "lambda", "launch-wizard", "lex", "license-manager", "lightsail", "local-zones", "location-service", "lookout-for-equipment", "lookout-for-metrics", "lookout-for-vision", "lumberyard", "macie", "mainframe-modernization", "managed-blockchain", "managed-grafana", "managed-service-for-prometheus", "managed-services", "managed-streaming-for-apache-kafka", "managed-workflows-for-apache-airflow", "management-console", "marketplace-dark", "marketplace-light", "memory-db-for-redis", "migration-evaluator", "migration-hub", "monitron", "mq", "neptune", "network-firewall", "neuron", "nice-dcv", "nice-engin-frame", "nimble-studio", "nitro-enclaves", "omics", "open-3d-engine", "open-search-service", "ops-works", "organizations", "outposts-family", "outposts-rack", "outposts-servers", "panorama", "parallel-cluster", "personal-health-dashboard", "personalize", "pinpoint-apis", "pinpoint", "polly", "private-5g", "private-certificate-authority", "private-link", "professional-services", "proton", "quantum-ledger-database", "quick-sight", "rds-on-vmware", "rds", "re-post", "red-hat-open-shift-service-on-aws", "redshift", "rekognition", "reserved-instance-reporting", "resilience-hub", "resource-access-manager", "resource-explorer", "robo-maker", "route-53", "s3-on-outposts", "sage-maker-ground-truth", "sage-maker-studio-lab", "sage-maker", "savings-plans", "secrets-manager", "security-hub", "security-lake", "server-migration-service", "serverless-application-repository", "service-catalog", "service-management-connector", "shield", "signer", "sim-space-weaver", "simple-email-service", "simple-notification-service", "simple-queue-service", "simple-storage-service-glacier", "simple-storage-service", "site-to-site-vpn", "snowball-edge", "snowball", "snowcone", "snowmobile", "step-functions", "storage-gateway", "sumerian", "supply-chain", "support", "systems-manager", "tensor-flow-on-aws", "textract", "thinkbox-deadline", "thinkbox-frost", "thinkbox-krakatoa", "thinkbox-sequoia", "thinkbox-stoke", "thinkbox-xmesh", "timestream", "tools-and-sdks", "torch-serve", "training-certification", "transcribe", "transfer-family", "transit-gateway", "translate", "trusted-advisor", "verified-access", "verified-permissions", "virtual-private-cloud", "vmware-cloud-on-aws", "vpc-lattice", "waf", "wavelength", "well-architected-tool", "wickr", "work-docs-sdk", "work-docs", "work-link", "work-mail", "work-spaces-family", "x-ray"];