@likec4/language-services 1.48.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023-2026 Denis Davydkov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,147 @@
+# @likec4/language-services
+
+This package provides initialization of language services from given workspace directory, or in-memory from sources.
+
+It is designed to be browser-compatible and bundled within the main [`likec4`](https://www.npmjs.com/package/likec4) package.
+
+> [!WARNING]
+> **This package is intended for internal use within other LikeC4 packages.**
+>
+> Please use the main [`likec4`](https://www.npmjs.com/package/likec4) package instead.
+
+## Features
+
+- **Browser and Node.js Support** - Dual runtime compatibility with separate entry points
+- **Source Parsing** - Parse LikeC4 DSL from strings or workspace directories
+- **Model Building** - Build and validate architecture models from parsed sources
+- **View Computation** - Compute views with predicates and element filtering
+- **Layout Engine** - Graphviz-based automatic layout for diagrams
+- **Multi-project Support** - Handle multiple LikeC4 projects in a workspace
+
+## Installation
+
+```bash
+npm install @likec4/language-services
+# or
+pnpm add @likec4/language-services
+```
+
+## Usage
+
+### Browser Environment
+
+```typescript
+import { fromSource, fromSources } from '@likec4/language-services/browser'
+
+// From a single source string
+const likec4 = await fromSource(`
+  model {
+    customer = person 'Customer'
+    system = softwareSystem 'System'
+
+    customer -> system 'uses'
+  }
+`)
+
+// From multiple source files
+const likec4 = await fromSources({
+  'model.c4': 'model { ... }',
+  'views.c4': 'views { ... }',
+  /**
+   * Optional, but allows to inject project config
+   * with theme customization
+   */
+  'likec4.config.json': '{ "name": "project-name" }',
+})
+
+// Get computed model
+const model = await likec4.computedModel()
+
+// Get layouted diagrams
+const diagrams = await likec4.diagrams()
+```
+
+### Node.js Environment
+
+```typescript
+import { fromWorkdir, fromWorkspace } from '@likec4/language-services/node'
+
+// From a workspace directory
+const likec4 = await fromWorkspace('./architecture')
+
+// From current working directory
+const likec4 = await fromWorkdir()
+
+// Get layouted model
+const model = await likec4.layoutedModel()
+
+// Get all projects
+const projects = likec4.projects()
+```
+
+> [!NOTE]
+> There is a separate entry point for node.js environment without MCP support: `@likec4/language-services/node/without-mcp`
+>
+> Useful to reduce bundle size
+
+## API
+
+### Factory Functions
+
+#### Browser
+
+- `fromSource(source: string): Promise<LikeC4>` - Create from a single source string
+- `fromSources(sources: Record<string, string>): Promise<LikeC4>` - Create from multiple source files
+
+> [!NOTE]
+> `fromSource` and `fromSources` are available in both browser and node.js environments.
+
+#### Node.js
+
+- `fromWorkspace(path: string, options?: FromWorkspaceOptions): Promise<LikeC4>` - Create from a workspace directory
+- `fromWorkdir(options?: FromWorkspaceOptions): Promise<LikeC4>` - Create from current working directory
+- `fromSources(sources: Record<string, string>, options?: InitOptions): Promise<LikeC4>` - Create from multiple source files
+- `fromSource(source: string, options?: InitOptions): Promise<LikeC4>` - Create from a single source string
+
+### LikeC4 Class
+
+- `computedModel(project?: ProjectId): Promise<LikeC4Model.Computed>` - Build model with computed views (no layout)
+- `layoutedModel(project?: ProjectId): Promise<LikeC4Model.Layouted>` - Build model with layout applied
+- `diagrams(project?: ProjectId): Promise<LayoutedView[]>` - Get all layouted diagrams
+- `projects(): NonEmptyArray<ProjectId>` - Get all project IDs
+- `validate(): Promise<ValidationResult>` - Validate all documents
+- `export(format: ExportFormat): Promise<string>` - Export to various formats
+
+## Runtime Compatibility
+
+The package provides conditional exports for browser and Node.js environments:
+
+- **Browser**: Uses in-memory workspace, no filesystem access
+- **Node.js**: Full filesystem support, workspace scanning, and file watching
+
+The appropriate version is automatically selected based on your environment.
+
+## Getting help
+
+We are always happy to help you get started:
+
+- [Join Discord community](https://discord.gg/86ZSpjKAdA) – it is the easiest way to get help
+- [GitHub Discussions](https://github.com/likec4/likec4/discussions) – ask anything about the project or give feedback
+
+## Contributors
+
+<a href="https://github.com/likec4/likec4/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=likec4/likec4" />
+</a>
+
+[Become a contributor](../../CONTRIBUTING.md)
+
+## Support development
+
+LikeC4 is a MIT-licensed open source project with its ongoing development made possible entirely by your support.\
+If you like the project, please consider contributing financially to help grow and improve it.\
+You can support us via [OpenCollective](https://opencollective.com/likec4) or [GitHub Sponsors](https://github.com/sponsors/likec4).
+
+## License
+
+This project is released under the [MIT License](LICENSE)

package/browser/package.json

@@ -0,0 +1,4 @@
+{
+  "types": "../dist/browser/index.d.mts",
+  "module": "../dist/browser/index.mjs"
+}

package/dist/_chunks/createFromSources.mjs

@@ -0,0 +1,172 @@
+import { loggable, rootLogger } from "@likec4/log";
+import defu from "defu";
+import { extname } from "pathe";
+import k from "tinyrainbow";
+import { LikeC4ProjectConfigOps, isLikeC4JsonConfig } from "@likec4/config";
+import { URI, UriUtils } from "langium";
+import { entries, map, partition, pipe, prop } from "remeda";
+import { DiagnosticSeverity } from "vscode-languageserver-types";
+var LikeC4 = class {
+	langium;
+	logger;
+	constructor(langium, logger = rootLogger) {
+		this.langium = langium;
+		this.logger = logger;
+	}
+	get workspace() {
+		return this.langium.shared.workspace.WorkspaceManager.workspaceUri.fsPath;
+	}
+	get workspaceURI() {
+		return this.langium.shared.workspace.WorkspaceManager.workspaceUri;
+	}
+	get workspaceURL() {
+		return this.langium.shared.workspace.WorkspaceManager.workspaceURL;
+	}
+	get languageServices() {
+		return this.langium.likec4.likec4.LanguageServices;
+	}
+	get projectsManager() {
+		return this.langium.shared.workspace.ProjectsManager;
+	}
+	get viewsService() {
+		return this.langium.likec4.likec4.Views;
+	}
+	get modelBuilder() {
+		return this.langium.likec4.likec4.ModelBuilder;
+	}
+	get LangiumDocuments() {
+		return this.langium.shared.workspace.LangiumDocuments;
+	}
+	ensureSingleProject() {
+		const projects = this.languageServices.projects();
+		if (projects.length > 1) {
+			this.logger.error(`Multiple projects found:
+${projects.map((p) => `  - ${p.folder.fsPath}`).join("\n")}
+
+Please specify a project folder`);
+			throw new Error(`Multiple projects found`);
+		}
+	}
+	async diagrams(project) {
+		const projectId = this.projectsManager.ensureProjectId(project);
+		return await this.viewsService.diagrams(projectId);
+	}
+	syncComputedModel(project) {
+		const projectId = this.projectsManager.ensureProjectId(project);
+		return this.modelBuilder.unsafeSyncComputeModel(projectId);
+	}
+	async computedModel(project) {
+		const projectId = this.projectsManager.ensureProjectId(project);
+		return await this.modelBuilder.computeModel(projectId);
+	}
+	projects() {
+		return map(this.languageServices.projects(), prop("id"));
+	}
+	async layoutedModel(project) {
+		const projectId = this.projectsManager.ensureProjectId(project);
+		return await this.languageServices.layoutedModel(projectId);
+	}
+	getErrors() {
+		return this.LangiumDocuments.all.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
+			}));
+		});
+	}
+	hasErrors() {
+		return this.LangiumDocuments.all.some((doc) => {
+			return doc.diagnostics?.some((d) => d.severity === DiagnosticSeverity.Error) ?? false;
+		});
+	}
+	printErrors() {
+		let hasErrors = false;
+		for (const doc of this.LangiumDocuments.all) {
+			const errors = doc.diagnostics?.filter((e) => e.severity === 1);
+			if (errors && errors.length > 0) {
+				hasErrors = true;
+				const messages = errors.flatMap((validationError) => {
+					const line = validationError.range.start.line;
+					const messages = validationError.message.split("\n");
+					if (messages.length > 10) {
+						messages.length = 10;
+						messages.push("...");
+					}
+					return messages.map((message, i) => {
+						if (i === 0) return "    " + k.dim(`Line ${line}: `) + k.red(message);
+						return " ".repeat(10) + k.red(message);
+					});
+				}).join("\n");
+				this.logger.error(`Invalid ${doc.uri.fsPath}\n${messages}`);
+			}
+		}
+		return hasErrors;
+	}
+	onModelUpdate(listener) {
+		const sib = this.modelBuilder.onModelParsed(() => listener());
+		return () => {
+			sib.dispose();
+		};
+	}
+	async dispose() {
+		await this.languageServices.dispose();
+	}
+	async [Symbol.asyncDispose]() {
+		await this.dispose();
+	}
+};
+const validationErrorsToError = (likec4) => /* @__PURE__ */ new Error(`Invalid model:\n${likec4.getErrors().map((e) => `  ${e.sourceFsPath}:${e.line} ${e.message.slice(0, 200)}`).join("\n")}`);
+async function handleInitOptions(langium, logger = rootLogger, options) {
+	const likec4 = new LikeC4(langium, logger);
+	const opts = defu(options, {
+		printErrors: true,
+		throwIfInvalid: false
+	});
+	if (opts.throwIfInvalid === true && likec4.hasErrors()) {
+		await likec4.dispose();
+		return Promise.reject(validationErrorsToError(likec4));
+	}
+	if (opts.printErrors !== false && likec4.hasErrors()) likec4.printErrors();
+	return likec4;
+}
+async function createFromSources(langium, logger, sources, initOptions) {
+	const uri = URI.from({
+		scheme: "virtual",
+		path: "/workspace"
+	});
+	const workspace = {
+		name: "virtual",
+		uri: uri.toString()
+	};
+	const WorkspaceManager = langium.shared.workspace.WorkspaceManager;
+	WorkspaceManager.initialize({
+		capabilities: {},
+		processId: null,
+		rootUri: workspace.uri,
+		workspaceFolders: [workspace]
+	});
+	await WorkspaceManager.initializeWorkspace([workspace]);
+	const fileExtensions = langium.shared.ServiceRegistry.all.flatMap((e) => e.LanguageMetaData.fileExtensions);
+	const [configs, docentries] = partition(entries(sources), ([path]) => isLikeC4JsonConfig(path));
+	for (const [path, content] of configs) {
+		const configUri = UriUtils.joinPath(uri, path);
+		try {
+			await langium.shared.workspace.ProjectsManager.registerProject({
+				configUri,
+				config: LikeC4ProjectConfigOps.parse(content)
+			});
+		} catch (error) {
+			logger.error(loggable(error));
+		}
+	}
+	const docs = pipe(docentries, map(([path, content]) => {
+		if (!fileExtensions.includes(extname(path))) path += ".c4";
+		const docuri = UriUtils.joinPath(uri, path);
+		return langium.shared.workspace.LangiumDocuments.createDocument(docuri, content);
+	}));
+	await langium.shared.workspace.DocumentBuilder.build(docs, { validation: true });
+	return handleInitOptions(langium, logger, initOptions);
+}
+export { handleInitOptions as n, LikeC4 as r, createFromSources as t };

package/dist/_chunks/options.d.mts

@@ -0,0 +1,133 @@
+import { Logger } from "@likec4/log";
+import * as vscode_uri0 from "vscode-uri";
+import { LikeC4Model } from "@likec4/core/model";
+import { LayoutedView, NonEmptyArray, ProjectId } from "@likec4/core/types";
+import { LikeC4LanguageServices, LikeC4ModelBuilder, LikeC4Services, LikeC4SharedServices, LikeC4Views, ProjectsManager } from "@likec4/language-server";
+
+//#region src/common/LikeC4.d.ts
+interface LikeC4Langium {
+  shared: LikeC4SharedServices;
+  likec4: LikeC4Services;
+}
+declare class LikeC4 {
+  protected readonly langium: LikeC4Langium;
+  protected readonly logger: Logger;
+  constructor(langium: LikeC4Langium, logger?: Logger);
+  /**
+   * File system path to the workspace root
+   */
+  get workspace(): string;
+  /**
+   * URI of the workspace root
+   */
+  get workspaceURI(): vscode_uri0.URI;
+  /**
+   * URL of the workspace root
+   */
+  get workspaceURL(): URL;
+  get languageServices(): LikeC4LanguageServices;
+  get projectsManager(): ProjectsManager;
+  get viewsService(): LikeC4Views;
+  get modelBuilder(): LikeC4ModelBuilder;
+  private get LangiumDocuments();
+  ensureSingleProject(): void;
+  /**
+   * Diagram is a computed view, layouted using Graphviz
+   * If diagram has manual layout, it will be used.
+   * Used in React components
+   */
+  diagrams(project?: string | undefined): Promise<LayoutedView[]>;
+  /**
+   * Builds LikeC4Model from all documents
+   * Only computes view predicates {@link ComputedView} - i.e. no layout
+   * Not ready for rendering, but enough to traverse
+   *
+   * Sync version does not read manual layouts
+   * Use {@link computedModel} for a version that includes manual layouts
+   */
+  syncComputedModel(project?: string | undefined): LikeC4Model.Computed;
+  /**
+   * Builds LikeC4Model from all documents
+   * Only computes view predicates {@link ComputedView} - i.e. no layout
+   * Not ready for rendering, but enough to traverse
+   */
+  computedModel(project?: string | undefined): Promise<LikeC4Model.Computed>;
+  projects(): NonEmptyArray<ProjectId>;
+  /**
+   * Same as {@link computedModel()}, but also applies layout
+   * Ready for rendering
+   */
+  layoutedModel(project?: string | undefined): Promise<LikeC4Model.Layouted>;
+  getErrors(): Array<{
+    message: string;
+    line: number;
+    range: {
+      start: {
+        line: number;
+        character: number;
+      };
+      end: {
+        line: number;
+        character: number;
+      };
+    };
+    sourceFsPath: string;
+  }>;
+  hasErrors(): boolean;
+  /**
+   * @returns true if there are errors
+   */
+  printErrors(): boolean;
+  /**
+   * @returns a function to dispose the listener
+   */
+  onModelUpdate(listener: () => void): () => void;
+  dispose(): Promise<void>;
+  [Symbol.asyncDispose](): Promise<void>;
+}
+//#endregion
+//#region src/common/options.d.ts
+type InitOptions = {
+  /**
+   * By default, if LikeC4 model is invalid, errors are printed to the console.
+   * Disable this behavior by setting this option to false.
+   *
+   * @default true
+   */
+  printErrors?: boolean;
+  /**
+   * If true, initialization will return rejected promise with the LikeC4 instance.
+   * Use `likec4.getErrors()` to get the errors.
+   * @default false
+   */
+  throwIfInvalid?: boolean;
+  /**
+   * Whether to use the `dot` binary for layouting or the WebAssembly version.
+   * @default 'wasm'
+   */
+  graphviz?: 'wasm' | 'binary';
+  /**
+   * Whether to start MCP server
+   *
+   * if port is specified, starts HTTP Streamable MCP server
+   *
+   * @default false
+   */
+  mcp?: false | 'stdio' | {
+    port: number;
+  };
+};
+type FromWorkspaceOptions = InitOptions & {
+  /**
+   * Whether to read and use manual layouts from the workspace.
+   * @default true
+   */
+  manualLayouts?: boolean;
+  /**
+   * Whether to watch for changes in the workspace.
+   * @default false
+   */
+  watch?: boolean;
+};
+//#endregion
+export { LikeC4Langium as i, InitOptions as n, LikeC4 as r, FromWorkspaceOptions as t };

package/dist/browser/index.d.mts

@@ -0,0 +1,41 @@
+import { n as InitOptions, r as LikeC4, t as FromWorkspaceOptions } from "../_chunks/options.mjs";
+
+//#region src/browser/index.d.ts
+/**
+ * Create a LikeC4 instance from a workspace directory
+ * @param _workspace - The workspace directory path
+ * @param options - Optional configuration options
+ * @returns A Promise that resolves to a LikeC4 instance
+ */
+declare function fromWorkspace(_workspace: string, _options?: FromWorkspaceOptions): Promise<LikeC4>;
+/**
+ * Create a LikeC4 instance from the current working directory
+ * @param options - Optional configuration options
+ * @returns A Promise that resolves to a LikeC4 instance
+ */
+declare function fromWorkdir(_options?: FromWorkspaceOptions): Promise<LikeC4>;
+/**
+ * Create a LikeC4 instance from a record of source files
+ *
+ * @example
+ * ```ts
+ * const likec4 = await fromSources({
+ *   'likec4.config.json': '...', // optional, stringified LikeC4Config
+ *   'model.c4': 'model { ... }',
+ *   'path/views.c4': 'views { ... }',
+ * })
+ * ```
+ *
+ * @param sources - A record of file paths to source content
+ * @returns A Promise that resolves to a LikeC4 instance
+ */
+declare function fromSources(sources: Record<string, string>): Promise<LikeC4>;
+/**
+ * Create a LikeC4 instance from a single source string
+ * @param source - The LikeC4 source code
+
+ * @returns A Promise that resolves to a LikeC4 instance
+ */
+declare function fromSource(source: string): Promise<LikeC4>;
+//#endregion
+export { type FromWorkspaceOptions, type InitOptions, type LikeC4, fromSource, fromSources, fromWorkdir, fromWorkspace };

package/dist/browser/index.mjs

@@ -0,0 +1,27 @@
+import { t as createFromSources } from "../_chunks/createFromSources.mjs";
+import { configureLogger, getConsoleSink, getTextFormatter, rootLogger } from "@likec4/log";
+import { createLanguageServices } from "@likec4/language-server/browser";
+async function fromWorkspace(_workspace, _options) {
+	throw new Error(`fromWorkspace is not yet implemented in the browser environment. use fromSources`);
+}
+async function fromWorkdir(_options) {
+	throw new Error(`fromWorkdir is not yet implemented in the browser environment, use fromSources`);
+}
+async function fromSources(sources) {
+	configureLogger({
+		sinks: { console: getConsoleSink({ formatter: getTextFormatter({ format: ({ level, category, message }) => {
+			return `${level} ${category} ${message}`;
+		} }) }) },
+		loggers: [{
+			category: "likec4",
+			sinks: ["console"],
+			lowestLevel: "debug"
+		}]
+	});
+	const logger = rootLogger.getChild("lang");
+	return await createFromSources(createLanguageServices(), logger, sources, {});
+}
+async function fromSource(source) {
+	return fromSources({ "source.c4": source });
+}
+export { fromSource, fromSources, fromWorkdir, fromWorkspace };

package/dist/node/index.d.mts

@@ -0,0 +1,44 @@
+import { i as LikeC4Langium, n as InitOptions, r as LikeC4, t as FromWorkspaceOptions } from "../_chunks/options.mjs";
+
+//#region src/node/index.d.ts
+/**
+ * Create a LikeC4 instance from a workspace directory
+ * The instance is cached in globalThis to avoid creating multiple instances for the same workspace
+ *
+ * @param path - The workspace directory path
+ * @param options - Optional configuration options
+ * @returns A Promise that resolves to a LikeC4 instance
+ */
+declare function fromWorkspace(path: string, options?: FromWorkspaceOptions): Promise<LikeC4>;
+/**
+ * Create a LikeC4 instance from the current working directory
+ * @param options - Optional configuration options
+ * @returns A Promise that resolves to a LikeC4 instance
+ */
+declare function fromWorkdir(options?: FromWorkspaceOptions): Promise<LikeC4>;
+/**
+ * Create a LikeC4 instance from a record of source files
+ *
+ * @example
+ * ```ts
+ * const likec4 = await fromSources({
+ *   'likec4.config.json': '...', // optional, stringified LikeC4Config
+ *   'model.c4': 'model { ... }',
+ *   'path/views.c4': 'views { ... }',
+ * })
+ * ```
+ *
+ * @param sources - A record of file paths to source content
+ * @param options - Optional configuration options
+ * @returns A Promise that resolves to a LikeC4 instance
+ */
+declare function fromSources(sources: Record<string, string>, options?: InitOptions): Promise<LikeC4>;
+/**
+ * Create a LikeC4 instance from a single source string
+ * @param source - The LikeC4 source code
+ * @param options - Optional configuration options
+ * @returns A Promise that resolves to a LikeC4 instance
+ */
+declare function fromSource(source: string, options?: InitOptions): Promise<LikeC4>;
+//#endregion
+export { type FromWorkspaceOptions, type InitOptions, LikeC4, type LikeC4Langium, fromSource, fromSources, fromWorkdir, fromWorkspace };

package/dist/node/index.mjs

@@ -0,0 +1,98 @@
+import { n as handleInitOptions, r as LikeC4, t as createFromSources } from "../_chunks/createFromSources.mjs";
+import { memoizeProp } from "@likec4/core";
+import { configureLogger, getConsoleStderrSink, loggable, rootLogger } from "@likec4/log";
+import defu from "defu";
+import { basename, resolve } from "pathe";
+import k from "tinyrainbow";
+import { pathToFileURL } from "url";
+import { WithFileSystem, WithLikeC4ManualLayouts } from "@likec4/language-server/filesystem";
+import { WithMCPServer } from "@likec4/language-server/mcp";
+import { NoFileSystem, NoLikeC4ManualLayouts, createLanguageServices } from "@likec4/language-server/module";
+import { GraphvizWasmAdapter, QueueGraphvizLayoter } from "@likec4/layouts";
+import { GraphvizBinaryAdapter } from "@likec4/layouts/graphviz/binary";
+function createLanguageServices$1(opts) {
+	const logger = rootLogger.getChild("lang");
+	const options = defu(opts, {
+		useFileSystem: true,
+		manualLayouts: true,
+		watch: false,
+		graphviz: "wasm",
+		mcp: false
+	});
+	if (options.mcp === "stdio") configureLogger({
+		reset: true,
+		sinks: { console: getConsoleStderrSink() },
+		loggers: [{
+			category: "likec4",
+			sinks: ["console"],
+			lowestLevel: "warning"
+		}]
+	});
+	const useDotBin = options.graphviz === "binary";
+	logger.info(`${k.dim("layout")} ${useDotBin ? "binary" : "wasm"}`);
+	const langium = createLanguageServices({
+		...options.useFileSystem ? {
+			...WithFileSystem(options.watch),
+			...options.manualLayouts ? WithLikeC4ManualLayouts : NoLikeC4ManualLayouts
+		} : {
+			...NoFileSystem,
+			...NoLikeC4ManualLayouts
+		},
+		...options.mcp ? WithMCPServer(options.mcp === "stdio" ? "stdio" : options.mcp) : {}
+	}, { likec4: { Layouter: () => new QueueGraphvizLayoter({ graphviz: useDotBin ? new GraphvizBinaryAdapter() : new GraphvizWasmAdapter() }) } });
+	if (typeof options.mcp === "object" && options.mcp.port) langium.likec4.mcp.Server.start(options.mcp.port).catch((e) => {
+		logger.error(loggable(e));
+	});
+	if (options.mcp === "stdio") langium.likec4.mcp.Server.start().catch((e) => {
+		logger.error(loggable(e));
+	});
+	return langium;
+}
+async function fromWorkspace(path, options) {
+	const workspacePath = resolve(path);
+	return memoizeProp(globalThis, "likec4:" + workspacePath, async () => {
+		const logger = rootLogger.getChild("lang");
+		const langium = createLanguageServices$1(defu(options, {
+			useFileSystem: true,
+			manualLayouts: true,
+			watch: false,
+			mcp: false
+		}));
+		const workspace = {
+			name: basename(workspacePath),
+			uri: pathToFileURL(workspacePath).toString()
+		};
+		const WorkspaceManager = langium.shared.workspace.WorkspaceManager;
+		logger.info(`${k.dim("workspace:")} ${workspacePath}`);
+		WorkspaceManager.initialize({
+			capabilities: {},
+			processId: null,
+			rootUri: null,
+			workspaceFolders: [workspace]
+		});
+		await WorkspaceManager.initializeWorkspace([workspace]);
+		const userDocuments = langium.shared.workspace.LangiumDocuments.userDocuments.toArray();
+		if (userDocuments.length === 0) {
+			logger.error(`no LikeC4 sources found`);
+			if (options?.throwIfInvalid) throw new Error(`no LikeC4 sources found`);
+		}
+		logger.info(`${k.dim("workspace:")} found ${userDocuments.length} source files`);
+		return handleInitOptions(langium, rootLogger, options);
+	});
+}
+async function fromWorkdir(options) {
+	return fromWorkspace(".", options);
+}
+async function fromSources(sources, options) {
+	const logger = rootLogger.getChild("lang");
+	return await createFromSources(createLanguageServices$1(defu(options, {
+		useFileSystem: false,
+		watch: false,
+		manualLayouts: false,
+		mcp: false
+	})), logger, sources, options);
+}
+async function fromSource(source, options) {
+	return fromSources({ "source.c4": source }, options);
+}
+export { LikeC4, fromSource, fromSources, fromWorkdir, fromWorkspace };

package/dist/node/without-mcp/index.d.mts

@@ -0,0 +1,44 @@
+import { i as LikeC4Langium, n as InitOptions, r as LikeC4, t as FromWorkspaceOptions } from "../../_chunks/options.mjs";
+
+//#region src/node/without-mcp/index.d.ts
+/**
+ * Create a LikeC4 instance from a workspace directory
+ * The instance is cached in globalThis to avoid creating multiple instances for the same workspace
+ *
+ * @param path - The workspace directory path
+ * @param options - Optional configuration options
+ * @returns A Promise that resolves to a LikeC4 instance
+ */
+declare function fromWorkspace(path: string, options?: FromWorkspaceOptions): Promise<LikeC4>;
+/**
+ * Create a LikeC4 instance from the current working directory
+ * @param options - Optional configuration options
+ * @returns A Promise that resolves to a LikeC4 instance
+ */
+declare function fromWorkdir(options?: FromWorkspaceOptions): Promise<LikeC4>;
+/**
+ * Create a LikeC4 instance from a record of source files
+ *
+ * @example
+ * ```ts
+ * const likec4 = await fromSources({
+ *   'likec4.config.json': '...', // optional, stringified LikeC4Config
+ *   'model.c4': 'model { ... }',
+ *   'path/views.c4': 'views { ... }',
+ * })
+ * ```
+ *
+ * @param sources - A record of file paths to source content
+ * @param options - Optional configuration options
+ * @returns A Promise that resolves to a LikeC4 instance
+ */
+declare function fromSources(sources: Record<string, string>, options?: InitOptions): Promise<LikeC4>;
+/**
+ * Create a LikeC4 instance from a single source string
+ * @param source - The LikeC4 source code
+ * @param options - Optional configuration options
+ * @returns A Promise that resolves to a LikeC4 instance
+ */
+declare function fromSource(source: string, options?: InitOptions): Promise<LikeC4>;
+//#endregion
+export { type FromWorkspaceOptions, type InitOptions, LikeC4, type LikeC4Langium, fromSource, fromSources, fromWorkdir, fromWorkspace };

package/dist/node/without-mcp/index.mjs

@@ -0,0 +1,77 @@
+import { n as handleInitOptions, r as LikeC4, t as createFromSources } from "../../_chunks/createFromSources.mjs";
+import { memoizeProp } from "@likec4/core";
+import { rootLogger } from "@likec4/log";
+import defu from "defu";
+import { basename, resolve } from "pathe";
+import k from "tinyrainbow";
+import { pathToFileURL } from "url";
+import { WithFileSystem, WithLikeC4ManualLayouts } from "@likec4/language-server/filesystem";
+import { NoFileSystem, NoLikeC4ManualLayouts, createLanguageServices } from "@likec4/language-server/module";
+import { GraphvizWasmAdapter, QueueGraphvizLayoter } from "@likec4/layouts";
+import { GraphvizBinaryAdapter } from "@likec4/layouts/graphviz/binary";
+function createLanguageServices$1(opts) {
+	const logger = rootLogger.getChild("lang");
+	const options = defu(opts, {
+		useFileSystem: true,
+		manualLayouts: true,
+		watch: false,
+		graphviz: "wasm"
+	});
+	const useDotBin = options.graphviz === "binary";
+	logger.info(`${k.dim("layout")} ${useDotBin ? "binary" : "wasm"}`);
+	return createLanguageServices({ ...options.useFileSystem ? {
+		...WithFileSystem(options.watch),
+		...options.manualLayouts ? WithLikeC4ManualLayouts : NoLikeC4ManualLayouts
+	} : {
+		...NoFileSystem,
+		...NoLikeC4ManualLayouts
+	} }, { likec4: { Layouter: () => new QueueGraphvizLayoter({ graphviz: useDotBin ? new GraphvizBinaryAdapter() : new GraphvizWasmAdapter() }) } });
+}
+async function fromWorkspace(path, options) {
+	const workspacePath = resolve(path);
+	return memoizeProp(globalThis, "likec4:" + workspacePath, async () => {
+		const logger = rootLogger.getChild("lang");
+		const mergedOptions = defu(options, {
+			useFileSystem: true,
+			manualLayouts: true,
+			watch: false
+		});
+		if (mergedOptions.mcp) throw new Error("MCP server is not supported in this build");
+		const langium = createLanguageServices$1(mergedOptions);
+		const workspace = {
+			name: basename(workspacePath),
+			uri: pathToFileURL(workspacePath).toString()
+		};
+		const WorkspaceManager = langium.shared.workspace.WorkspaceManager;
+		logger.info(`${k.dim("workspace:")} ${workspacePath}`);
+		WorkspaceManager.initialize({
+			capabilities: {},
+			processId: null,
+			rootUri: null,
+			workspaceFolders: [workspace]
+		});
+		await WorkspaceManager.initializeWorkspace([workspace]);
+		const userDocuments = langium.shared.workspace.LangiumDocuments.userDocuments.toArray();
+		if (userDocuments.length === 0) {
+			logger.error(`no LikeC4 sources found`);
+			throw new Error(`no LikeC4 sources found`);
+		}
+		logger.info(`${k.dim("workspace:")} found ${userDocuments.length} source files`);
+		return handleInitOptions(langium, rootLogger, options);
+	});
+}
+async function fromWorkdir(options) {
+	return fromWorkspace(".", options);
+}
+async function fromSources(sources, options) {
+	const logger = rootLogger.getChild("lang");
+	return await createFromSources(createLanguageServices$1(defu(options, {
+		useFileSystem: false,
+		watch: false,
+		manualLayouts: false
+	})), logger, sources, options);
+}
+async function fromSource(source, options) {
+	return fromSources({ "source.c4": source }, options);
+}
+export { LikeC4, fromSource, fromSources, fromWorkdir, fromWorkspace };

package/node/package.json

@@ -0,0 +1,4 @@
+{
+  "types": "../dist/node/index.d.mts",
+  "module": "../dist/node/index.mjs"
+}

package/node/without-mcp/package.json

@@ -0,0 +1,4 @@
+{
+  "types": "../../dist/node/without-mcp/index.d.mts",
+  "module": "../../dist/node/without-mcp/index.mjs"
+}

package/package.json

@@ -0,0 +1,113 @@
+{
+  "name": "@likec4/language-services",
+  "description": "LikeC4 Language Services",
+  "version": "1.48.0",
+  "license": "MIT",
+  "bugs": "https://github.com/likec4/likec4/issues",
+  "homepage": "https://likec4.dev",
+  "author": "Denis Davydkov <denis@davydkov.com>",
+  "files": [
+    "dist",
+    "**/package.json",
+    "!**/__mocks__/",
+    "!**/__tests__/",
+    "!**/*.spec.*",
+    "!**/*.map"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/likec4/likec4.git",
+    "directory": "packages/language-services"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "browser": {
+        "sources": "./src/browser/index.ts",
+        "default": {
+          "types": "./dist/browser/index.d.mts",
+          "import": "./dist/browser/index.mjs",
+          "default": "./dist/browser/index.mjs"
+        }
+      },
+      "default": {
+        "sources": "./src/node/index.ts",
+        "types": "./dist/node/index.d.mts",
+        "import": "./dist/node/index.mjs",
+        "default": "./dist/node/index.mjs"
+      }
+    },
+    "./browser": {
+      "sources": "./src/browser/index.ts",
+      "default": {
+        "types": "./dist/browser/index.d.mts",
+        "import": "./dist/browser/index.mjs",
+        "default": "./dist/browser/index.mjs"
+      }
+    },
+    "./node/without-mcp": {
+      "sources": "./src/node/without-mcp/index.ts",
+      "default": {
+        "types": "./dist/node/without-mcp/index.d.mts",
+        "import": "./dist/node/without-mcp/index.mjs",
+        "default": "./dist/node/without-mcp/index.mjs"
+      }
+    },
+    "./node": {
+      "sources": "./src/node/index.ts",
+      "default": {
+        "types": "./dist/node/index.d.mts",
+        "import": "./dist/node/index.mjs",
+        "default": "./dist/node/index.mjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "dependencies": {
+    "defu": "^6.1.4",
+    "remeda": "^2.33.5",
+    "langium": "3.5.0",
+    "tinyrainbow": "^2.0.0",
+    "pathe": "^2.0.3",
+    "std-env": "^3.10.0",
+    "type-fest": "^4.41.0",
+    "vscode-languageserver-types": "3.17.5",
+    "@likec4/config": "1.48.0",
+    "@likec4/core": "1.48.0",
+    "@likec4/generators": "1.48.0",
+    "@likec4/icons": "1.46.4",
+    "@likec4/language-server": "1.48.0",
+    "@likec4/layouts": "1.48.0",
+    "@likec4/log": "1.48.0"
+  },
+  "devDependencies": {
+    "@types/node": "~22.19.10",
+    "obuild": "^0.4.27",
+    "oxlint": "1.43.0",
+    "tsx": "4.21.0",
+    "turbo": "2.8.3",
+    "typescript": "5.9.3",
+    "vitest": "4.0.18",
+    "@likec4/tsconfig": "1.48.0",
+    "@likec4/devops": "1.42.0"
+  },
+  "scripts": {
+    "typecheck": "tsc -b --verbose",
+    "build": "obuild",
+    "pack": "pnpm pack",
+    "lint": "oxlint --type-aware",
+    "lint:fix": "oxlint --type-aware --fix",
+    "lint:package": "pnpx publint ./package.tgz",
+    "clean": "likec4ops clean"
+  },
+  "types": "dist/node/index.d.mts",
+  "module": "dist/node/index.mjs",
+  "browser": {
+    "dist/node/index.mjs": "dist/browser/index.mjs"
+  }
+}