@master/css-language-server 2.0.0-rc.9 → 2.0.0

package/README.md

@@ -0,0 +1,104 @@
+<br>
+<div align="center">
+
+<p align="center">
+  <a href="https://css.master.co">
+    <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="https://user-images.githubusercontent.com/33840671/201701649-3bb7d698-abec-4d5f-ac30-ccc4d7bafcd4.svg">
+      <source media="(prefers-color-scheme: light)" srcset="https://user-images.githubusercontent.com/33840671/201703010-77bf2373-9899-40cc-98f5-30cf9b546941.svg">
+      <img alt="Master CSS" src="https://user-images.githubusercontent.com/33840671/201703010-77bf2373-9899-40cc-98f5-30cf9b546941.svg" width="100%">
+    </picture>
+  </a>
+</p>
+<p align="center">Language Server for Master CSS</p>
+
+<p align="center">
+  <a aria-label="GitHub release (latest by date including pre-releases)" href="https://github.com/master-co/css/releases">
+    <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="https://img.shields.io/github/v/release/master-co/css?include_prereleases&color=212022&label=&style=for-the-badge&logo=github&logoColor=fff">
+      <source media="(prefers-color-scheme: light)" srcset="https://img.shields.io/github/v/release/master-co/css?include_prereleases&color=f6f7f8&label=&style=for-the-badge&logo=github&logoColor=%23000">
+      <img alt="GitHub release" src="https://img.shields.io/github/v/release/master-co/css?include_prereleases&color=f6f7f8&label=&style=for-the-badge&logo=github">
+    </picture>
+  </a>
+  <a aria-label="NPM Package" href="https://www.npmjs.com/package/@master/css-language-server">
+    <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="https://img.shields.io/npm/dm/@master/css-language-server?color=212022&label=%20&logo=npm&style=for-the-badge">
+      <source media="(prefers-color-scheme: light)" srcset="https://img.shields.io/npm/dm/@master/css-language-server?color=f6f7f8&label=%20&logo=npm&style=for-the-badge">
+      <img alt="NPM package ( download / month )" src="https://img.shields.io/npm/dm/@master/css-language-server?color=f6f7f8&label=%20&logo=npm&style=for-the-badge">
+    </picture>
+  </a>
+  <a aria-label="JSDelivr" href="https://www.jsdelivr.com/package/npm/@master/css-language-server">
+    <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="https://img.shields.io/jsdelivr/npm/hm/@master/css-language-server?color=212022&label=%20&logo=jsdelivr&style=for-the-badge">
+      <source media="(prefers-color-scheme: light)" srcset="https://img.shields.io/jsdelivr/npm/hm/@master/css-language-server?color=f6f7f8&label=%20&logo=jsdelivr&style=for-the-badge">
+      <img alt="JSDelivr hits (npm scoped)" src="https://img.shields.io/jsdelivr/npm/hm/@master/css-language-server?color=f6f7f8&label=%20&logo=jsdelivr&style=for-the-badge">
+    </picture>
+  </a>
+  <a aria-label="Follow @mastercorg" href="https://twitter.com/mastercorg">
+    <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="https://img.shields.io/static/v1?label=%20&message=twitter&color=212022&logo=twitter&style=for-the-badge">
+      <source media="(prefers-color-scheme: light)" srcset="https://img.shields.io/static/v1?label=%20&message=twitter&color=f6f7f8&logo=twitter&style=for-the-badge">
+      <img alt="Follow @mastercorg" src="https://img.shields.io/static/v1?label=%20&message=twitter&color=f6f7f8&logo=twitter&style=for-the-badge">
+    </picture>
+  </a>
+  <a aria-label="GitHub Actions" href="https://github.com/master-co/css/actions/workflows/release.yml">
+    <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="https://img.shields.io/github/actions/workflow/status/master-co/css/release.yml?branch=main&label=%20&color=212022&logo=githubactions&style=for-the-badge">
+      <source media="(prefers-color-scheme: light)" srcset="https://img.shields.io/github/actions/workflow/status/master-co/css/release.yml?branch=main&label=%20&color=f6f7f8&logo=githubactions&style=for-the-badge&logoColor=%23000">
+      <img alt="GitHub release workflow" src="https://img.shields.io/github/actions/workflow/status/master-co/css/release.yml?branch=main&label=%20&color=f6f7f8&logo=githubactions&style=for-the-badge&logoColor=%23000">
+    </picture>
+  </a>
+</p>
+
+</div>
+
+## Installation
+
+```bash
+npm install @master/css-language-server
+```
+
+## Usage
+
+```js
+import { MasterCSSLanguageServer } from '@master/css-language-server'
+
+const languageServer = new MasterCSSLanguageServer(connection, customSettings)
+```
+
+`MasterCSSLanguageServer` wraps `@master/css-language-service` with LSP workspace lifecycle, completion, hover, document color, color presentation, semantic token, and directive formatting handlers. Call `dispose()` when the transport shuts down.
+
+Diagnostics are intentionally limited to language-server-owned behavior: CSS directive diagnostics and project manifest loading diagnostics. Class syntax and policy rules such as sorting, canonical class preference, conflict detection, invalid classes, and raw-value approval are owned by `@master/eslint-plugin-css`.
+
+## Semantic tokens
+
+The language server supports full-document and active-position semantic tokens.
+
+| `embeddedSyntaxHighlighting` | Behavior |
+| --- | --- |
+| `always` | Advertises the standard LSP `semanticTokensProvider` and handles `textDocument/semanticTokens/full`. |
+| `active` | Uses the VS Code extension request for active class-context highlighting. |
+| `off` | Disables embedded utility highlighting. |
+
+CSS directive syntax is highlighted by the shared TextMate grammar. Server semantic tokens cover Master CSS class-list spans and directive class-list spans such as `@safelist`.
+
+## Formatting
+
+The server advertises `documentFormattingProvider` and `documentRangeFormattingProvider` when `formatDirectives` is enabled. Formatting returns directive-only edits for CSS, SCSS, and LESS documents, plus CSS-family `<style>` blocks in Vue, Svelte, and Astro documents.
+
+Directive formatting normalizes safe directive spacing and repairs class-list important markers such as `(background-color:transparent) !` to `(background-color:transparent)!`. It does not run the compiler and does not change generated CSS output.
+
+## Settings
+
+```js
+import { defaultLanguageServerSettings } from '@master/css-language-server'
+```
+
+| Setting | Type | Default | Description |
+| --- | --- | --- | --- |
+| `workspaces` | `FastGlobPattern[] \| 'auto'` | `'auto'` | Workspace roots where independent language services are created. The root workspace is always included. |
+| `verbose` | `boolean` | `false` | Print server logs. |
+| `formatDirectives` | `boolean` | `true` | Enables LSP document and range formatting for Master CSS directives. |
+| `embeddedSyntaxHighlighting` | `'active' \| 'always' \| 'off'` | `'active'` | Inherited language-service semantic token mode. |
+
+With `workspaces: 'auto'`, the server creates workspaces from CSS files importing `@master/css`, and `package.json` files that declare Master CSS package dependencies.

package/dist/core.d.ts

@@ -0,0 +1,96 @@
+import { MasterCSSLanguageServerSettings } from "./settings.js";
+import { ClientCapabilities, ColorInformation, ColorPresentation, ColorPresentationParams, CompletionItem, CompletionParams, Connection, DidChangeConfigurationParams, DocumentColorParams, DocumentFormattingParams, DocumentRangeFormattingParams, Hover, HoverParams, InitializeParams, InitializeResult, RemoteConsole, SemanticTokens, SemanticTokensParams, TextDocumentChangeEvent, TextDocumentPositionParams, TextDocuments, TextEdit, WorkspaceFolder } from "vscode-languageserver/node";
+import { TextDocument } from "vscode-languageserver-textdocument";
+import { MasterCSSLanguageService } from "@master/css-language-service";
+import { MasterCSSManifest } from "@master/css-schema/manifest";
+interface MasterCSSResolvedWorkspacePackage {
+  readonly name: string;
+  readonly entry: string;
+  readonly directory: string;
+  readonly packageJSON?: string;
+  readonly version?: string;
+}
+interface MasterCSSWorkspacePackageResolution {
+  readonly workspaceDir: string;
+  readonly css?: MasterCSSResolvedWorkspacePackage;
+  readonly presetManifest?: MasterCSSResolvedWorkspacePackage;
+  readonly languageServer?: MasterCSSResolvedWorkspacePackage;
+  readonly errors: readonly {
+    readonly name: string;
+    readonly message: string;
+  }[];
+}
+declare interface MasterCSSWorkspace {
+  uri: string;
+  openedTextDocuments: TextDocument[];
+  languageService?: MasterCSSLanguageService;
+  languageServiceSettings: MasterCSSLanguageServerSettings;
+  baseManifest?: MasterCSSManifest;
+  manifestResolution?: MasterCSSWorkspacePackageResolution;
+  manifestSource?: 'workspace' | 'bundled';
+  manifestErrors?: unknown[];
+  planEntries?: string[];
+  designSystemFiles?: readonly string[];
+}
+declare const ACTIVE_SEMANTIC_TOKENS_REQUEST = "masterCSS/renderActiveSemanticTokens";
+declare const DOCUMENT_SEMANTIC_TOKENS_REQUEST = "masterCSS/renderDocumentSemanticTokens";
+declare class MasterCSSLanguageServer implements Disposable {
+  connection: Connection;
+  customSettings?: MasterCSSLanguageServerSettings | undefined;
+  workspaceFolders: WorkspaceFolder[];
+  workspaces: Map<string, MasterCSSWorkspace>;
+  globalWorkspace: MasterCSSWorkspace;
+  documents: TextDocuments<TextDocument>;
+  initializing?: Promise<void>;
+  clientCapabilities: ClientCapabilities;
+  settings?: MasterCSSLanguageServerSettings;
+  console: RemoteConsole;
+  private disposables;
+  private workspaceLanguageServiceInitializations;
+  private disposed;
+  constructor(connection?: Connection, customSettings?: MasterCSSLanguageServerSettings | undefined);
+  start(): void;
+  init(): Promise<void>;
+  onInitialize(params: InitializeParams): InitializeResult;
+  onHover(params: HoverParams): Promise<Hover | undefined>;
+  onDefinition(params: TextDocumentPositionParams): Promise<{
+    uri: string;
+    range: {
+      start: import("vscode-languageserver-textdocument").Position;
+      end: import("vscode-languageserver-textdocument").Position;
+    };
+  } | undefined>;
+  onCompletion(params: CompletionParams): Promise<CompletionItem[] | undefined>;
+  onDocumentColor(params: DocumentColorParams): Promise<ColorInformation[]>;
+  onColorPresentation(params: ColorPresentationParams): Promise<ColorPresentation[]>;
+  private getWorkspaceDocument;
+  onDocumentFormatting(params: DocumentFormattingParams): Promise<TextEdit[]>;
+  onDocumentRangeFormatting(params: DocumentRangeFormattingParams): Promise<TextEdit[]>;
+  onSemanticTokens(params: SemanticTokensParams): Promise<SemanticTokens>;
+  onDocumentSemanticTokens(params: SemanticTokensParams): Promise<SemanticTokens>;
+  onActiveSemanticTokens(params: TextDocumentPositionParams): Promise<SemanticTokens>;
+  onDidOpen(params: TextDocumentChangeEvent<TextDocument>): Promise<void>;
+  onDidChangeContent(params: TextDocumentChangeEvent<TextDocument>): Promise<void>;
+  onDidClose(params: TextDocumentChangeEvent<TextDocument>): Promise<void>;
+  onDidSave(params: TextDocumentChangeEvent<TextDocument>): Promise<void>;
+  onDidChangeConfiguration({ settings: changedSettings }: DidChangeConfigurationParams): Promise<void>;
+  private initWorkspaceFolder;
+  initWorkspaceLanguageService(workspace: MasterCSSWorkspace): Promise<void>;
+  private ensureWorkspaceLanguageService;
+  private loadWorkspacePlan;
+  private loadWorkspaceBaseManifest;
+  destroyLanguageService(workspace: MasterCSSWorkspace): void;
+  findClosestWorkspace(textDocumentURI: string): MasterCSSWorkspace;
+  private publishDiagnostics;
+  private createDesignSystemDiagnostics;
+  private createCSSDirectiveDiagnostics;
+  private createManifestLoadingDiagnostics;
+  private createMasterCSSDiagnostic;
+  private createCSSDirectiveDiagnostic;
+  private createCSSDirectiveRelatedInformation;
+  private createCSSDirectiveRange;
+  private refreshSemanticTokens;
+  dispose(): void;
+  [Symbol.dispose](): void;
+}
+export { ACTIVE_SEMANTIC_TOKENS_REQUEST, DOCUMENT_SEMANTIC_TOKENS_REQUEST, MasterCSSLanguageServer, MasterCSSWorkspace };

package/dist/core.js

@@ -0,0 +1,605 @@
+import { discoverBuildWorkspaceDirectories } from "./internal/src/workspace-directories.js";
+import { resolveMasterCSSWorkspacePackages } from "./internal/src/workspace.js";
+import { defaultLanguageServerSettings } from "./settings.js";
+import { getCSSDiagnosticSources, getMasterCSSDiagnostics, isCSSDiagnosticDocument, toCSSDirectiveError, toLSPDiagnosticSeverity } from "./diagnostics.js";
+import { DiagnosticSeverity, TextDocumentSyncKind, TextDocuments, createConnection } from "vscode-languageserver/node";
+import { TextDocument } from "vscode-languageserver-textdocument";
+import path from "node:path";
+import { readFile } from "node:fs/promises";
+import { MasterCSSLanguageService } from "@master/css-language-service";
+import { compileManifestSync } from "@master/css-compiler/node";
+import { discoverManifestEntries, loadProjectManifest } from "@master/css-compiler/project";
+import { defu } from "defu";
+import defaultManifestJSON from "@master/css-preset/default-manifest.json" with { type: "json" };
+import { AT_TRIGGER_CHARACTER, INVOKED_TRIGGER_CHARACTERS, QUERY_TRIGGER_CHARACTERS, SELECTOR_TRIGGER_CHARACTERS, VALUE_TRIGGER_CHARACTERS } from "@master/css-language-service/common";
+import { createToolingSession } from "@master/css-tooling";
+import { SEMANTIC_TOKENS_LEGEND } from "@master/css-tooling/language";
+import glob from "fast-glob";
+import { URI } from "vscode-uri";
+// src/core.ts
+const defaultManifest = defaultManifestJSON;
+const ACTIVE_SEMANTIC_TOKENS_REQUEST = "masterCSS/renderActiveSemanticTokens";
+const DOCUMENT_SEMANTIC_TOKENS_REQUEST = "masterCSS/renderDocumentSemanticTokens";
+const SERVER_CAPABILITIES = {
+	textDocumentSync: TextDocumentSyncKind.Incremental,
+	completionProvider: {
+		resolveProvider: false,
+		workDoneProgress: false,
+		triggerCharacters: [.../* @__PURE__ */ new Set([
+			...INVOKED_TRIGGER_CHARACTERS,
+			...VALUE_TRIGGER_CHARACTERS,
+			...SELECTOR_TRIGGER_CHARACTERS,
+			...QUERY_TRIGGER_CHARACTERS,
+			AT_TRIGGER_CHARACTER
+		])]
+	},
+	colorProvider: true,
+	hoverProvider: true,
+	definitionProvider: true,
+	documentFormattingProvider: true,
+	documentRangeFormattingProvider: true,
+	semanticTokensProvider: {
+		legend: SEMANTIC_TOKENS_LEGEND,
+		full: true
+	},
+	workspace: { workspaceFolders: { supported: true } }
+};
+function getInitializationSettings(initializationOptions) {
+	if (!initializationOptions || typeof initializationOptions !== "object") return;
+	const options = initializationOptions;
+	return options.masterCSS ?? options;
+}
+function isWindowsFilePath(fsPath) {
+	return /^[a-z]:[\\/]/i.test(fsPath) || fsPath.startsWith("\\\\") || fsPath.startsWith("//");
+}
+function getFilePathTools(...fsPaths) {
+	return fsPaths.some(isWindowsFilePath) ? path.win32 : path;
+}
+function toComparableFilePath(uri) {
+	const parsedURI = URI.parse(uri);
+	if (parsedURI.scheme !== "file") return;
+	const fsPath = parsedURI.fsPath;
+	if (!fsPath) return;
+	const resolvedPath = getFilePathTools(fsPath).resolve(fsPath);
+	return isWindowsFilePath(resolvedPath) ? resolvedPath.toLowerCase() : resolvedPath;
+}
+function containsFilePath(parentPath, childPath) {
+	const filePathTools = getFilePathTools(parentPath, childPath);
+	const relativePath = filePathTools.relative(parentPath, childPath);
+	return relativePath === "" || !!relativePath && relativePath !== ".." && !relativePath.startsWith(`..${filePathTools.sep}`) && !filePathTools.isAbsolute(relativePath);
+}
+var MasterCSSLanguageServer = class {
+	connection;
+	customSettings;
+	workspaceFolders = [];
+	workspaces = /* @__PURE__ */ new Map();
+	globalWorkspace = {
+		uri: "",
+		openedTextDocuments: [],
+		languageServiceSettings: this.settings,
+		baseManifest: defaultManifest,
+		manifestSource: "bundled"
+	};
+	documents;
+	initializing;
+	clientCapabilities = {};
+	settings;
+	console;
+	disposables = [];
+	workspaceLanguageServiceInitializations = /* @__PURE__ */ new Map();
+	disposed = false;
+	constructor(connection = process.argv.includes("--stdio") ? createConnection(process.stdin, process.stdout) : createConnection(), customSettings) {
+		this.connection = connection;
+		this.customSettings = customSettings;
+		this.documents = new TextDocuments(TextDocument);
+		this.settings = defu(this.customSettings, defaultLanguageServerSettings);
+		this.globalWorkspace.languageServiceSettings = this.settings;
+		this.console = new Proxy(this.connection.console, { get: (target, prop) => {
+			if (!this.settings?.verbose) return () => {};
+			return this.connection.console[prop];
+		} });
+	}
+	start() {
+		this.disposables.push(this.documents.onDidSave(this.onDidSave.bind(this)), this.documents.onDidOpen(this.onDidOpen.bind(this)), this.documents.onDidChangeContent(this.onDidChangeContent.bind(this)), this.documents.onDidClose(this.onDidClose.bind(this)), this.documents.listen(this.connection), this.connection.onDidChangeConfiguration(this.onDidChangeConfiguration.bind(this)), this.connection.onHover(this.onHover.bind(this)), this.connection.onDefinition(this.onDefinition.bind(this)), this.connection.onCompletion(this.onCompletion.bind(this)), this.connection.onDocumentColor(this.onDocumentColor.bind(this)), this.connection.onColorPresentation(this.onColorPresentation.bind(this)), this.connection.onDocumentFormatting(this.onDocumentFormatting.bind(this)), this.connection.onDocumentRangeFormatting(this.onDocumentRangeFormatting.bind(this)), this.connection.languages.semanticTokens.on(this.onSemanticTokens.bind(this)), this.connection.onRequest(DOCUMENT_SEMANTIC_TOKENS_REQUEST, this.onDocumentSemanticTokens.bind(this)), this.connection.onRequest(ACTIVE_SEMANTIC_TOKENS_REQUEST, this.onActiveSemanticTokens.bind(this)), this.connection.onInitialize(this.onInitialize.bind(this)), this.connection.onInitialized(() => this.init()));
+		this.connection.listen();
+	}
+	init() {
+		if (this.initializing) return this.initializing;
+		return this.initializing = Promise.all(this.workspaceFolders.map((folder) => this.initWorkspaceFolder(folder.uri))).then(() => void 0).catch((error) => {
+			this.initializing = void 0;
+			throw error;
+		});
+	}
+	onInitialize(params) {
+		this.clientCapabilities = params.capabilities;
+		const initializationSettings = getInitializationSettings(params.initializationOptions);
+		if (initializationSettings) {
+			this.customSettings = defu(initializationSettings, this.customSettings);
+			this.settings = defu(this.customSettings, defaultLanguageServerSettings);
+			this.globalWorkspace.languageServiceSettings = this.settings;
+		}
+		if (params.workspaceFolders?.length) this.workspaceFolders = params.workspaceFolders;
+		const capabilities = { ...SERVER_CAPABILITIES };
+		if (this.settings?.embeddedSyntaxHighlighting !== "always") delete capabilities.semanticTokensProvider;
+		if (!this.settings?.formatDirectives) {
+			delete capabilities.documentFormattingProvider;
+			delete capabilities.documentRangeFormattingProvider;
+		}
+		return { capabilities };
+	}
+	async onHover(params) {
+		await this.init();
+		const workspace = this.findClosestWorkspace(params.textDocument.uri);
+		if (workspace?.languageService) {
+			const document = this.documents.get(params.textDocument.uri);
+			if (document) return workspace.languageService.inspectSyntax(document, params.position);
+		}
+	}
+	async onDefinition(params) {
+		await this.init();
+		const service = this.findClosestWorkspace(params.textDocument.uri)?.languageService;
+		const document = this.documents.get(params.textDocument.uri);
+		if (!service || !document) return;
+		const position = service.getClassPosition(document, params.position);
+		if (!position) return;
+		const source = service.session.inspectClassName(position.token).definitionSource;
+		if (!source?.file) return;
+		const uri = URI.file(source.file).toString();
+		const target = this.documents.get(uri) ?? TextDocument.create(uri, "css", 0, await readFile(source.file, "utf8"));
+		return {
+			uri,
+			range: {
+				start: target.positionAt(source.range.start),
+				end: target.positionAt(source.range.end)
+			}
+		};
+	}
+	async onCompletion(params) {
+		await this.init();
+		const workspace = this.findClosestWorkspace(params.textDocument.uri);
+		if (workspace?.languageService) {
+			const document = this.documents.get(params.textDocument.uri);
+			if (document) return workspace.languageService.suggestSyntax(document, params.position, params.context);
+		}
+	}
+	async onDocumentColor(params) {
+		await this.init();
+		const workspace = this.findClosestWorkspace(params.textDocument.uri);
+		if (workspace?.languageService) {
+			const document = this.documents.get(params.textDocument.uri);
+			if (document) return await workspace.languageService.renderSyntaxColors(document) ?? [];
+		}
+		return [];
+	}
+	async onColorPresentation(params) {
+		await this.init();
+		const workspace = this.findClosestWorkspace(params.textDocument.uri);
+		if (workspace?.languageService) {
+			const document = this.documents.get(params.textDocument.uri);
+			if (document) return workspace.languageService.editSyntaxColors(document, params.color, params.range) ?? [];
+		}
+		return [];
+	}
+	getWorkspaceDocument(uri) {
+		const workspace = this.findClosestWorkspace(uri);
+		if (!workspace?.languageService) return;
+		const document = this.documents.get(uri) ?? workspace.openedTextDocuments.find((document) => document.uri === uri);
+		if (!document) return;
+		return {
+			workspace,
+			document
+		};
+	}
+	async onDocumentFormatting(params) {
+		await this.init();
+		const context = this.getWorkspaceDocument(params.textDocument.uri);
+		return context?.workspace.languageService?.formatDirectives(context.document) ?? [];
+	}
+	async onDocumentRangeFormatting(params) {
+		await this.init();
+		const context = this.getWorkspaceDocument(params.textDocument.uri);
+		return context?.workspace.languageService?.formatDirectives(context.document, params.range) ?? [];
+	}
+	async onSemanticTokens(params) {
+		await this.init();
+		const context = this.getWorkspaceDocument(params.textDocument.uri);
+		if (context) return context.workspace.languageService?.renderSemanticTokens(context.document) ?? { data: [] };
+		return { data: [] };
+	}
+	async onDocumentSemanticTokens(params) {
+		return this.onSemanticTokens(params);
+	}
+	async onActiveSemanticTokens(params) {
+		await this.init();
+		const context = this.getWorkspaceDocument(params.textDocument.uri);
+		if (context) return context.workspace.languageService?.renderSemanticTokensAtPosition(context.document, params.position) ?? { data: [] };
+		return { data: [] };
+	}
+	async onDidOpen(params) {
+		await this.init();
+		const workspace = this.findClosestWorkspace(params.document.uri);
+		if (!workspace) return;
+		const documentIndex = workspace.openedTextDocuments.findIndex(({ uri }) => uri === params.document.uri);
+		if (documentIndex < 0) workspace.openedTextDocuments.push(params.document);
+		else workspace.openedTextDocuments[documentIndex] = params.document;
+		await this.ensureWorkspaceLanguageService(workspace);
+		if (!workspace.openedTextDocuments.some(({ uri }) => uri === params.document.uri)) return;
+		this.publishDiagnostics(params.document, workspace);
+	}
+	async onDidChangeContent(params) {
+		await this.init();
+		const workspace = this.findClosestWorkspace(params.document.uri);
+		if (!workspace) return;
+		const documentIndex = workspace.openedTextDocuments.findIndex(({ uri }) => uri === params.document.uri);
+		if (documentIndex >= 0) workspace.openedTextDocuments[documentIndex] = params.document;
+		this.publishDiagnostics(params.document, workspace);
+	}
+	async onDidClose(params) {
+		await this.init();
+		const workspace = this.findClosestWorkspace(params.document.uri);
+		if (!workspace) return;
+		const documentIndex = workspace.openedTextDocuments.findIndex(({ uri }) => uri === params.document.uri);
+		if (documentIndex >= 0) workspace.openedTextDocuments.splice(documentIndex, 1);
+		this.connection.sendDiagnostics({
+			uri: params.document.uri,
+			diagnostics: []
+		});
+		if (!workspace.openedTextDocuments.length) this.destroyLanguageService(workspace);
+	}
+	async onDidSave(params) {
+		await this.init();
+		const workspace = this.findClosestWorkspace(params.document.uri);
+		if (!workspace) return;
+		this.publishDiagnostics(params.document, workspace);
+		if (path.basename(URI.parse(params.document.uri).fsPath).endsWith(".css")) {
+			this.refreshSemanticTokens();
+			this.connection.sendRequest("masterCSS/restart", { title: "Updating Master CSS configuration" });
+		}
+	}
+	async onDidChangeConfiguration({ settings: changedSettings }) {
+		await this.init();
+		if (changedSettings?.masterCSS) {
+			this.connection.sendNotification("masterCSS/globalSettingsChanged", changedSettings.masterCSS);
+			this.customSettings = changedSettings.masterCSS;
+			this.settings = defu(this.customSettings, defaultLanguageServerSettings);
+			this.globalWorkspace.languageServiceSettings = this.settings;
+			this.refreshSemanticTokens();
+			this.connection.sendRequest("masterCSS/restart", { title: "Updating Master CSS settings" });
+			for (const workspace of [this.globalWorkspace, ...this.workspaces.values()]) for (const document of workspace.openedTextDocuments) this.publishDiagnostics(document, workspace);
+		}
+	}
+	async initWorkspaceFolder(workspaceFolderURI) {
+		const workspaceFolderCWD = URI.parse(workspaceFolderURI).fsPath;
+		let customWorkspaceFolderSettings;
+		if (this.clientCapabilities.workspace?.configuration) customWorkspaceFolderSettings = await this.connection.workspace.getConfiguration({
+			scopeUri: workspaceFolderURI,
+			section: "masterCSS"
+		});
+		const { workspaces, ...languageServiceSettings } = defu(customWorkspaceFolderSettings, this.customSettings, defaultLanguageServerSettings);
+		const resolvedWorkspaceDirectories = /* @__PURE__ */ new Set([workspaceFolderCWD]);
+		if (workspaceFolderCWD) this.console.info(`Registered workspace folder ${workspaceFolderURI}`);
+		else this.console.info(`Registered global workspace folder`);
+		if (workspaces === "auto") {
+			const manifestEntries = await discoverManifestEntries({ root: workspaceFolderCWD });
+			for (const workspaceDir of await discoverBuildWorkspaceDirectories(workspaceFolderCWD, manifestEntries)) resolvedWorkspaceDirectories.add(workspaceDir);
+		} else if (workspaces?.length) (await glob([...workspaces], {
+			cwd: workspaceFolderCWD,
+			absolute: true,
+			onlyDirectories: true,
+			ignore: ["**/node_modules/**"]
+		})).forEach((workspaceDir) => resolvedWorkspaceDirectories.add(path.resolve(workspaceDir)));
+		for (const workspaceDir of resolvedWorkspaceDirectories) {
+			const workspaceURI = URI.file(workspaceDir).toString();
+			this.console.info(`Added workspace ${workspaceURI}`);
+			this.workspaces.set(workspaceURI, {
+				uri: workspaceURI,
+				openedTextDocuments: [],
+				languageServiceSettings,
+				planEntries: [...await discoverManifestEntries({ root: workspaceDir })]
+			});
+		}
+	}
+	async initWorkspaceLanguageService(workspace) {
+		workspace.baseManifest = await this.loadWorkspaceBaseManifest(workspace);
+		let workspacePlan;
+		workspace.manifestErrors = [];
+		workspace.designSystemFiles = [];
+		if (workspace !== this.globalWorkspace) {
+			try {
+				workspacePlan = await this.loadWorkspacePlan(workspace, workspace.baseManifest);
+			} catch (e) {
+				workspace.manifestErrors = [e];
+				this.console.info(`Failed to load manifest from ${workspace.uri}`);
+				this.console.error(e instanceof Error ? e.stack : e.toString());
+			}
+			if (workspacePlan) this.console.info(`Initialized workspace ${workspace.planEntries?.length ? "(with manifest entry)" : "(with manifest)"} ${workspace.uri}`);
+			else this.console.info(`Initialized workspace ${workspace.uri}`);
+		}
+		const manifest = workspacePlan?.manifest ?? workspace.languageServiceSettings.manifest ?? workspace.baseManifest;
+		workspace.designSystemFiles = workspacePlan?.sourceGraph?.files.filter((file) => file.projectOwned).map((file) => file.source) ?? [];
+		workspace.languageService = new MasterCSSLanguageService({
+			...workspace.languageServiceSettings,
+			manifest
+		}, { session: await createToolingSession({
+			manifest,
+			nativeClassNames: workspacePlan?.nativeClassNames
+		}) });
+	}
+	async ensureWorkspaceLanguageService(workspace) {
+		if (workspace.languageService) return;
+		let initialization = this.workspaceLanguageServiceInitializations.get(workspace);
+		if (!initialization) {
+			initialization = this.initWorkspaceLanguageService(workspace);
+			this.workspaceLanguageServiceInitializations.set(workspace, initialization);
+		}
+		try {
+			await initialization;
+		} finally {
+			if (this.workspaceLanguageServiceInitializations.get(workspace) === initialization) this.workspaceLanguageServiceInitializations.delete(workspace);
+			if ((this.disposed || !workspace.openedTextDocuments.length) && workspace.languageService) this.destroyLanguageService(workspace);
+		}
+	}
+	async loadWorkspacePlan(workspace, baseManifest) {
+		const entries = workspace.planEntries ?? [];
+		if (!entries.length) return void 0;
+		const cwd = workspace.uri ? URI.parse(workspace.uri).fsPath : process.cwd();
+		return await loadProjectManifest({
+			root: cwd,
+			entries,
+			baseManifest,
+			includeSourceGraph: Boolean(workspace.languageServiceSettings.designSystem)
+		});
+	}
+	async loadWorkspaceBaseManifest(workspace) {
+		if (workspace === this.globalWorkspace || !workspace.uri) {
+			workspace.manifestSource = "bundled";
+			return defaultManifest;
+		}
+		const cwd = URI.parse(workspace.uri).fsPath;
+		let resolution;
+		try {
+			resolution = resolveMasterCSSWorkspacePackages(cwd);
+			workspace.manifestResolution = resolution;
+			const presetManifestPackage = resolution.presetManifest;
+			if (!presetManifestPackage) throw new Error("Missing workspace package @master/css-preset/default-manifest.json.");
+			const manifest = JSON.parse(await readFile(presetManifestPackage.entry, "utf8"));
+			workspace.manifestSource = "workspace";
+			this.console.info(`Using workspace Master CSS manifest ${presetManifestPackage.version ?? "(unknown version)"} from ${presetManifestPackage.directory}`);
+			if (resolution.errors.length) this.console.info(`MasterCSSWorkspace Master CSS manifest optional resolution warnings: ${resolution.errors.map(({ name, message }) => `${name}: ${message}`).join("; ")}`);
+			return manifest;
+		} catch (error) {
+			workspace.manifestSource = "bundled";
+			this.console.info(`Using bundled Master CSS manifest for ${workspace.uri}`);
+			if (resolution?.errors.length) this.console.info(`MasterCSSWorkspace Master CSS package resolution errors: ${resolution.errors.map(({ name, message }) => `${name}: ${message}`).join("; ")}`);
+			this.console.error(error instanceof Error ? error.stack || error.message : String(error));
+			return defaultManifest;
+		}
+	}
+	destroyLanguageService(workspace) {
+		this.console.info(`Destroyed workspace ${workspace.uri}`);
+		workspace.languageService?.dispose();
+		delete workspace.languageService;
+	}
+	findClosestWorkspace(textDocumentURI) {
+		const documentPath = toComparableFilePath(textDocumentURI);
+		if (!documentPath) {
+			this.console.info(`This is an external document ${textDocumentURI} with the global workspace`);
+			return this.globalWorkspace;
+		}
+		let foundWorkspace;
+		let foundWorkspacePath = "";
+		for (const [uri, workspace] of this.workspaces) {
+			if (!uri) continue;
+			const workspacePath = toComparableFilePath(uri);
+			if (!workspacePath) continue;
+			if (containsFilePath(workspacePath, documentPath) && workspacePath.length > foundWorkspacePath.length) {
+				foundWorkspace = workspace;
+				foundWorkspacePath = workspacePath;
+			}
+		}
+		if (foundWorkspace) return foundWorkspace;
+		this.console.info(`This is an external document ${textDocumentURI} with the global workspace`);
+		return this.globalWorkspace;
+	}
+	publishDiagnostics(textDocument, workspace) {
+		const diagnostics = [];
+		diagnostics.push(...this.createManifestLoadingDiagnostics(textDocument, workspace));
+		diagnostics.push(...this.createCSSDirectiveDiagnostics(textDocument, workspace));
+		diagnostics.push(...this.createDesignSystemDiagnostics(textDocument, workspace));
+		this.connection.sendDiagnostics({
+			uri: textDocument.uri,
+			diagnostics
+		});
+	}
+	createDesignSystemDiagnostics(document, workspace) {
+		const options = workspace.languageServiceSettings.designSystem;
+		if (!options || !workspace.languageService || workspace.manifestErrors?.length || document.languageId !== "css") return [];
+		const source = path.resolve(URI.parse(document.uri).fsPath);
+		if (!workspace.designSystemFiles?.includes(source)) return [];
+		try {
+			const report = workspace.languageService.session.inspectDesignSystem({
+				...options,
+				stylesheets: [{
+					source,
+					content: document.getText()
+				}]
+			});
+			return report.diagnostics.map((item) => ({
+				range: {
+					start: document.positionAt(item.range?.start ?? 0),
+					end: document.positionAt(item.range?.end ?? 0)
+				},
+				severity: item.severity === "error" ? DiagnosticSeverity.Error : item.severity === "warning" ? DiagnosticSeverity.Warning : DiagnosticSeverity.Information,
+				source: "Master CSS",
+				code: item.code,
+				message: item.message,
+				data: {
+					version: report.version,
+					coverage: report.coverage,
+					...item.data
+				}
+			}));
+		} catch (error) {
+			return [{
+				range: {
+					start: document.positionAt(0),
+					end: document.positionAt(0)
+				},
+				severity: DiagnosticSeverity.Error,
+				source: "Master CSS",
+				code: "DESIGN_SYSTEM_INSPECTION_ERROR",
+				message: error instanceof Error ? error.message : String(error)
+			}];
+		}
+	}
+	createCSSDirectiveDiagnostics(textDocument, workspace) {
+		if (!isCSSDiagnosticDocument(textDocument)) return [];
+		const diagnostics = [];
+		const documentFile = path.resolve(URI.parse(textDocument.uri).fsPath);
+		for (const { source, offset } of getCSSDiagnosticSources(textDocument)) try {
+			compileManifestSync(source, {
+				from: documentFile,
+				baseManifest: workspace.baseManifest ?? defaultManifest
+			});
+		} catch (error) {
+			const structuredDiagnostics = getMasterCSSDiagnostics(error);
+			if (structuredDiagnostics?.length) {
+				for (const structuredDiagnostic of structuredDiagnostics) {
+					const diagnostic = this.createMasterCSSDiagnostic(structuredDiagnostic, textDocument, documentFile, source, offset);
+					if (diagnostic) diagnostics.push(diagnostic);
+				}
+				continue;
+			}
+			const directiveError = toCSSDirectiveError(error);
+			if (!directiveError) continue;
+			const diagnostic = this.createCSSDirectiveDiagnostic(directiveError, textDocument, documentFile, offset);
+			if (diagnostic) diagnostics.push(diagnostic);
+		}
+		return diagnostics;
+	}
+	createManifestLoadingDiagnostics(textDocument, workspace) {
+		if (!workspace.manifestErrors?.length) return [];
+		const documentFile = path.resolve(URI.parse(textDocument.uri).fsPath);
+		return workspace.manifestErrors.flatMap((error) => {
+			const structuredDiagnostics = getMasterCSSDiagnostics(error);
+			if (structuredDiagnostics?.length) return structuredDiagnostics.map((diagnostic) => this.createMasterCSSDiagnostic(diagnostic, textDocument, documentFile, textDocument.getText(), 0, {
+				allowExternalSource: true,
+				messagePrefix: "Failed to load Master CSS manifest: "
+			})).filter((diagnostic) => !!diagnostic);
+			const directiveError = toCSSDirectiveError(error);
+			const source = directiveError?.source;
+			return [{
+				range: source && (!source.file || path.resolve(source.file) === documentFile) ? this.createCSSDirectiveRange(source, textDocument, documentFile, 0) : {
+					start: {
+						line: 0,
+						character: 0
+					},
+					end: {
+						line: 0,
+						character: 0
+					}
+				},
+				severity: DiagnosticSeverity.Error,
+				code: "manifest-loading-error",
+				source: "Master CSS",
+				message: `Failed to load Master CSS manifest: ${error instanceof Error ? error.message : String(error)}`,
+				relatedInformation: directiveError ? this.createCSSDirectiveRelatedInformation(directiveError.related, textDocument, documentFile, 0) : void 0
+			}];
+		});
+	}
+	createMasterCSSDiagnostic(diagnostic, textDocument, documentFile, sourceText, sourceOffset, options = {}) {
+		const externalSource = !!diagnostic.source && path.resolve(diagnostic.source) !== documentFile;
+		if (externalSource && !options.allowExternalSource) return;
+		const sourceDocument = TextDocument.create("inmemory://master-css/diagnostic.css", "css", 0, sourceText);
+		const range = diagnostic.range && !externalSource ? {
+			start: textDocument.positionAt(sourceOffset + sourceDocument.offsetAt(diagnostic.range.start)),
+			end: textDocument.positionAt(sourceOffset + sourceDocument.offsetAt(diagnostic.range.end))
+		} : {
+			start: textDocument.positionAt(sourceOffset),
+			end: textDocument.positionAt(sourceOffset)
+		};
+		const relatedMessages = [...diagnostic.notes ?? [], ...diagnostic.help ? [diagnostic.help] : []];
+		return {
+			range,
+			severity: toLSPDiagnosticSeverity(diagnostic.severity),
+			code: diagnostic.code,
+			source: "Master CSS",
+			message: `${options.messagePrefix ?? ""}${diagnostic.message}`,
+			relatedInformation: relatedMessages.length ? relatedMessages.map((message) => ({
+				message,
+				location: {
+					uri: textDocument.uri,
+					range
+				}
+			})) : void 0
+		};
+	}
+	createCSSDirectiveDiagnostic(error, textDocument, documentFile, sourceOffset) {
+		if (error.source?.file && path.resolve(error.source.file) !== documentFile) return;
+		return {
+			range: this.createCSSDirectiveRange(error.source, textDocument, documentFile, sourceOffset),
+			severity: DiagnosticSeverity.Error,
+			code: error.code,
+			source: "Master CSS",
+			message: error.message,
+			relatedInformation: this.createCSSDirectiveRelatedInformation(error.related, textDocument, documentFile, sourceOffset)
+		};
+	}
+	createCSSDirectiveRelatedInformation(related, textDocument, documentFile, sourceOffset) {
+		if (!related?.length) return;
+		return related.map(({ message, source }) => ({
+			message,
+			location: {
+				uri: source?.file ? URI.file(source.file).toString() : textDocument.uri,
+				range: this.createCSSDirectiveRange(source, textDocument, documentFile, sourceOffset)
+			}
+		}));
+	}
+	createCSSDirectiveRange(source, textDocument, documentFile, sourceOffset) {
+		if (source?.file && path.resolve(source.file) !== documentFile) return source.loc ? {
+			start: {
+				line: Math.max(0, source.loc.start.line - 1),
+				character: Math.max(0, source.loc.start.column - 1)
+			},
+			end: {
+				line: Math.max(0, source.loc.end.line - 1),
+				character: Math.max(0, source.loc.end.column - 1)
+			}
+		} : {
+			start: {
+				line: 0,
+				character: 0
+			},
+			end: {
+				line: 0,
+				character: 0
+			}
+		};
+		const start = Math.max(0, (source?.range.start || 0) + sourceOffset);
+		const end = Math.max(start, (source?.range.end || 0) + sourceOffset);
+		return {
+			start: textDocument.positionAt(start),
+			end: textDocument.positionAt(end)
+		};
+	}
+	refreshSemanticTokens() {
+		if (this.settings?.embeddedSyntaxHighlighting !== "always") return;
+		if (!this.clientCapabilities.workspace?.semanticTokens?.refreshSupport) return;
+		this.connection.languages.semanticTokens.refresh();
+	}
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.connection.sendNotification("masterCSS/dispose");
+		for (const workspace of [this.globalWorkspace, ...this.workspaces.values()]) this.destroyLanguageService(workspace);
+		this.disposables.forEach((disposable) => disposable.dispose());
+		this.disposables.length = 0;
+		this.workspaceLanguageServiceInitializations.clear();
+		this.connection.dispose();
+		this.initializing = void 0;
+	}
+	[Symbol.dispose]() {
+		this.dispose();
+	}
+};
+export { ACTIVE_SEMANTIC_TOKENS_REQUEST, DOCUMENT_SEMANTIC_TOKENS_REQUEST, MasterCSSLanguageServer };

package/dist/diagnostics.js

@@ -0,0 +1,78 @@
+import { DiagnosticSeverity } from "vscode-languageserver/node";
+import { CSSDirectiveError } from "@master/css-schema/css-directives";
+import { MasterCSSError } from "@master/css-schema";
+// src/diagnostics.ts
+const CSS_DIAGNOSTIC_LANGUAGE_IDS = /* @__PURE__ */ new Set([
+	"css",
+	"scss",
+	"less"
+]);
+const SFC_DIAGNOSTIC_LANGUAGE_IDS = /* @__PURE__ */ new Set([
+	"vue",
+	"svelte",
+	"astro"
+]);
+const STYLE_BLOCK_RE = /<style\b([^>]*)>([\s\S]*?)<\/style>/gi;
+function getMasterCSSDiagnostics(error) {
+	if (error instanceof MasterCSSError) return error.diagnostics;
+	if (!error || typeof error !== "object" || error.name !== "MasterCSSError") return;
+	const diagnostics = error.diagnostics;
+	if (!Array.isArray(diagnostics)) return;
+	return diagnostics;
+}
+function toLSPDiagnosticSeverity(severity) {
+	switch (severity) {
+		case "warning": return DiagnosticSeverity.Warning;
+		case "information": return DiagnosticSeverity.Information;
+		default: return DiagnosticSeverity.Error;
+	}
+}
+function isCSSDiagnosticDocument(textDocument) {
+	return CSS_DIAGNOSTIC_LANGUAGE_IDS.has(textDocument.languageId) || SFC_DIAGNOSTIC_LANGUAGE_IDS.has(textDocument.languageId);
+}
+function getSFCStyleLanguage(attributes) {
+	const match = /\blang\s*=\s*(?:"([^"]+)"|'([^']+)'|([^\s>]+))/i.exec(attributes);
+	return (match?.[1] || match?.[2] || match?.[3] || "css").toLowerCase();
+}
+function getCSSDiagnosticSources(textDocument) {
+	const text = textDocument.getText();
+	if (CSS_DIAGNOSTIC_LANGUAGE_IDS.has(textDocument.languageId)) return [{
+		source: text,
+		offset: 0
+	}];
+	if (!SFC_DIAGNOSTIC_LANGUAGE_IDS.has(textDocument.languageId)) return [];
+	const sources = [];
+	STYLE_BLOCK_RE.lastIndex = 0;
+	for (const match of text.matchAll(STYLE_BLOCK_RE)) {
+		const styleLanguage = getSFCStyleLanguage(match[1]);
+		if (!CSS_DIAGNOSTIC_LANGUAGE_IDS.has(styleLanguage)) continue;
+		const source = match[2];
+		const offset = (match.index || 0) + match[0].indexOf(">") + 1;
+		sources.push({
+			source,
+			offset
+		});
+	}
+	return sources;
+}
+function isCSSDirectiveError(error) {
+	return error instanceof CSSDirectiveError || !!error && typeof error === "object" && error.name === "CSSDirectiveError" && typeof error.code === "string";
+}
+function toCSSDirectiveError(error) {
+	if (isCSSDirectiveError(error)) return error;
+	if (!error || typeof error !== "object") return;
+	const diagnostic = error;
+	if (typeof diagnostic.code !== "string" || typeof diagnostic.message !== "string") return;
+	const range = diagnostic.range;
+	if (!range || typeof range !== "object") return;
+	const { start, end } = range;
+	if (typeof start !== "number" || typeof end !== "number") return;
+	return new CSSDirectiveError(diagnostic.code, diagnostic.message, {
+		...typeof diagnostic.source === "string" && diagnostic.source ? { file: diagnostic.source } : {},
+		range: {
+			start,
+			end
+		}
+	});
+}
+export { getCSSDiagnosticSources, getMasterCSSDiagnostics, isCSSDiagnosticDocument, toCSSDirectiveError, toLSPDiagnosticSeverity };

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import { MasterCSSLanguageServerSettings, defaultLanguageServerSettings } from "./settings.js";
+import { ACTIVE_SEMANTIC_TOKENS_REQUEST, DOCUMENT_SEMANTIC_TOKENS_REQUEST, MasterCSSLanguageServer, MasterCSSWorkspace } from "./core.js";
+export { ACTIVE_SEMANTIC_TOKENS_REQUEST, DOCUMENT_SEMANTIC_TOKENS_REQUEST, MasterCSSLanguageServer, type MasterCSSLanguageServerSettings, type MasterCSSWorkspace, defaultLanguageServerSettings };

package/dist/index.js

@@ -0,0 +1,3 @@
+import { defaultLanguageServerSettings } from "./settings.js";
+import { ACTIVE_SEMANTIC_TOKENS_REQUEST, DOCUMENT_SEMANTIC_TOKENS_REQUEST, MasterCSSLanguageServer } from "./core.js";
+export { ACTIVE_SEMANTIC_TOKENS_REQUEST, DOCUMENT_SEMANTIC_TOKENS_REQUEST, MasterCSSLanguageServer, defaultLanguageServerSettings };

package/dist/internal/src/workspace-directories.js

@@ -0,0 +1,63 @@
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { readFile, readdir } from "node:fs/promises";
+import "node:fs";
+// ../internal/src/workspace-directories.ts
+const IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
+	"node_modules",
+	"dist",
+	"out",
+	".master",
+	".next",
+	".nuxt",
+	".svelte-kit"
+]);
+const MASTER_CSS_PACKAGE_NAME = /^@master\/css(?:$|[.-])/;
+const DEPENDENCY_FIELDS = [
+	"dependencies",
+	"devDependencies",
+	"peerDependencies",
+	"optionalDependencies"
+];
+function hasMasterCSSDependency(packageJSON) {
+	return DEPENDENCY_FIELDS.some((field) => {
+		const dependencies = packageJSON[field];
+		return dependencies && typeof dependencies === "object" && Object.keys(dependencies).some((dependency) => MASTER_CSS_PACKAGE_NAME.test(dependency));
+	});
+}
+async function collectPackageDirectories(directory, directories) {
+	try {
+		for (const dirent of await readdir(directory, { withFileTypes: true })) {
+			const file = join(directory, dirent.name);
+			if (dirent.isDirectory()) {
+				if (!IGNORED_DIRECTORIES.has(dirent.name)) await collectPackageDirectories(file, directories);
+			} else if (dirent.isFile() && dirent.name === "package.json") try {
+				if (hasMasterCSSDependency(JSON.parse(await readFile(file, "utf8")))) directories.add(dirname(file));
+			} catch {}
+		}
+	} catch {}
+}
+function isSameOrChildPath(parent, child) {
+	const path = relative(parent, child);
+	return path === "" || path !== ".." && !path.startsWith(`..${sep}`) && !isAbsolute(path);
+}
+function resolveEntryWorkspace(entry, directories) {
+	const absoluteEntry = resolve(entry);
+	let closest;
+	for (const directory of directories) {
+		const absoluteDirectory = resolve(directory);
+		if (isSameOrChildPath(absoluteDirectory, absoluteEntry) && (!closest || absoluteDirectory.length > closest.length)) closest = absoluteDirectory;
+	}
+	return closest ?? dirname(absoluteEntry);
+}
+function finalizeWorkspaceDirectories(root, packageDirectories, manifestEntries) {
+	const directories = /* @__PURE__ */ new Set([root, ...packageDirectories]);
+	for (const entry of manifestEntries) directories.add(resolveEntryWorkspace(entry, packageDirectories));
+	return Object.freeze([...directories].sort());
+}
+async function discoverBuildWorkspaceDirectories(rootDirectory, manifestEntries = []) {
+	const root = resolve(rootDirectory);
+	const packageDirectories = /* @__PURE__ */ new Set();
+	await collectPackageDirectories(root, packageDirectories);
+	return finalizeWorkspaceDirectories(root, packageDirectories, manifestEntries);
+}
+export { discoverBuildWorkspaceDirectories };

package/dist/internal/src/workspace.js

@@ -0,0 +1,70 @@
+import { createRequire } from "node:module";
+import { dirname, join, resolve } from "node:path";
+import { existsSync, readFileSync, statSync } from "node:fs";
+// ../internal/src/workspace.ts
+function readPackageJSON(file) {
+	try {
+		return JSON.parse(readFileSync(file, "utf8"));
+	} catch {
+		return;
+	}
+}
+function findPackageDir(entry, packageName) {
+	let current = statSync(entry).isDirectory() ? entry : dirname(entry);
+	while (current !== dirname(current)) {
+		const packageJSONPath = join(current, "package.json");
+		if (existsSync(packageJSONPath)) {
+			const packageJSON = readPackageJSON(packageJSONPath);
+			if (packageJSON?.name === packageName) return {
+				directory: current,
+				packageJSONPath,
+				version: typeof packageJSON.version === "string" ? packageJSON.version : void 0
+			};
+		}
+		current = dirname(current);
+	}
+}
+function resolvePackage(name, resolver) {
+	const entry = resolver.resolve(name);
+	const packageRoot = findPackageDir(entry, name.startsWith("@master/css-preset/") ? "@master/css-preset" : name.startsWith("@master/css-schema/") ? "@master/css-schema" : name.startsWith("@master/css-language-server/") ? "@master/css-language-server" : name);
+	if (!packageRoot) throw new Error(`Unable to find package root for ${name} from ${entry}`);
+	return {
+		name,
+		entry,
+		directory: packageRoot.directory,
+		packageJSON: packageRoot.packageJSONPath,
+		version: packageRoot.version
+	};
+}
+function tryResolvePackage(name, resolver, errors) {
+	try {
+		return resolvePackage(name, resolver);
+	} catch (error) {
+		errors.push({
+			name,
+			message: error instanceof Error ? error.message : String(error)
+		});
+	}
+}
+function createWorkspaceRequire(workspaceDir) {
+	return createRequire(join(resolve(workspaceDir), "package.json"));
+}
+function createPackageRequire(resolvedPackage) {
+	return createRequire(resolvedPackage.packageJSON || join(resolvedPackage.directory, "package.json"));
+}
+function resolveMasterCSSWorkspacePackages(workspaceDir = process.cwd()) {
+	const errors = [];
+	const workspaceRequire = createWorkspaceRequire(workspaceDir);
+	const css = tryResolvePackage("@master/css", workspaceRequire, errors);
+	const result = {
+		workspaceDir: resolve(workspaceDir),
+		errors,
+		...css ? { css } : {}
+	};
+	if (css) result.presetManifest = tryResolvePackage("@master/css-preset/default-manifest.json", createPackageRequire(css), errors);
+	try {
+		result.languageServer = resolvePackage("@master/css-language-server/server", workspaceRequire);
+	} catch {}
+	return result;
+}
+export { resolveMasterCSSWorkspacePackages };

package/dist/server.d.ts

@@ -1 +1 @@
-export {};
+export { };

package/dist/server.js

@@ -0,0 +1,7 @@
+import { MasterCSSLanguageServer } from "./core.js";
+// src/server.ts
+new MasterCSSLanguageServer(void 0, { verbose: true }).start();
+process.on("unhandledRejection", (error) => {
+	console.error("Unhandled rejection", error);
+});
+export {};

package/dist/settings.d.ts

@@ -0,0 +1,11 @@
+import { MasterCSSLanguageServiceSettings } from "@master/css-language-service";
+import { Pattern } from "fast-glob";
+import { MasterCSSDesignSystemOptions } from "@master/css-tooling/lint";
+declare const defaultLanguageServerSettings: Readonly<MasterCSSLanguageServerSettings>;
+type MasterCSSLanguageServerSettings = MasterCSSLanguageServiceSettings & {
+  workspaces?: readonly Pattern[] | 'auto';
+  verbose?: boolean;
+  /** Opt-in checks for authored CSS in this workspace's managed stylesheet graph. */
+  designSystem?: MasterCSSDesignSystemOptions;
+};
+export { MasterCSSLanguageServerSettings, defaultLanguageServerSettings };

package/dist/settings.js

@@ -0,0 +1,8 @@
+import { defaultLanguageServiceSettings } from "@master/css-language-service";
+// src/settings.ts
+const defaultLanguageServerSettings = Object.freeze({
+	...defaultLanguageServiceSettings,
+	workspaces: "auto",
+	verbose: false
+});
+export { defaultLanguageServerSettings };

package/package.json

@@ -1 +1,58 @@
-{"name":"@master/css-language-server","scripts":{"build":"techor pack --platform node --declare","dev":"pnpm run build --watch","type-check":"tsc --noEmit","lint":"eslint src","test":"jest"},"description":"Master CSS Language Server","author":"Aoyue Design LLC.","license":"MIT","dependencies":{"@master/css":"^2.0.0-rc.9","@master/css-language-service":"^2.0.0-rc.9","explore-config":"^2.5.24","js-beautify":"^1.14.7","minimatch":"^9.0.1","vscode-languageserver":"^7.0.0","vscode-languageserver-textdocument":"^1.0.9"},"main":"./dist/server.bundle.js","types":"./dist/server.d.ts","files":["dist"],"publishConfig":{"access":"public"},"version":"2.0.0-rc.9"}
+{
+    "name": "@master/css-language-server",
+    "type": "module",
+    "engines": {
+        "node": "^24"
+    },
+    "scripts": {
+        "build": "bun --bun tsdown --config ../../shared/tsdown-package.config.ts",
+        "dev": "bun --bun tsdown --config ../../shared/tsdown-package.config.ts --watch",
+        "type-check": "bun --bun tsc -b tsconfig.typecheck.json",
+        "lint": "bun --bun eslint",
+        "test": "bun --bun vitest run"
+    },
+    "description": "Master CSS Language Server",
+    "author": "Aoyue Design LLC.",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/master-co/css.git",
+        "directory": "packages/language-server"
+    },
+    "dependencies": {
+        "@master/css-compiler": "2.0.0",
+        "@master/css-language-service": "2.0.0",
+        "@master/css-preset": "2.0.0",
+        "@master/css-tooling": "2.0.0",
+        "defu": "^6.1.7",
+        "fast-glob": "^3.3.3",
+        "nanoid": "^6.0.2",
+        "vscode-languageserver": "^11.0.0",
+        "vscode-languageserver-textdocument": "^1.0.16",
+        "vscode-uri": "^3.2.0",
+        "@master/css-schema": "2.0.0"
+    },
+    "sideEffects": false,
+    "types": "./dist/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js",
+            "default": "./dist/index.js"
+        },
+        "./server": {
+            "types": "./dist/server.d.ts",
+            "import": "./dist/server.js",
+            "default": "./dist/server.js"
+        }
+    },
+    "files": [
+        "dist"
+    ],
+    "publishConfig": {
+        "access": "public",
+        "provenance": true
+    },
+    "version": "2.0.0",
+    "gitHead": "6bf9adc4432b67e62613caea59d3b554711b4d54"
+}

package/dist/server.bundle.js

@@ -1 +0,0 @@
-"use strict";var W=Object.create;var S=Object.defineProperty;var U=Object.getOwnPropertyDescriptor;var H=Object.getOwnPropertyNames;var K=Object.getPrototypeOf,L=Object.prototype.hasOwnProperty;var E=(t,e,n,s)=>{if(e&&typeof e=="object"||typeof e=="function")for(let i of H(e))!L.call(t,i)&&i!==n&&S(t,i,{get:()=>e[i],enumerable:!(s=U(e,i))||s.enumerable});return t};var h=(t,e,n)=>(n=t!=null?W(K(t)):{},E(e||!t||!t.__esModule?S(n,"default",{value:t,enumerable:!0}):n,t));var u=require("vscode-languageserver/node"),w=require("@master/css"),b=require("minimatch"),P=require("vscode-languageserver-textdocument"),k=h(require("path")),T=require("url"),o=require("@master/css-language-service"),v=h(require("explore-config")),a=(0,u.createConnection)(u.ProposedFeatures.all),f=new u.TextDocuments(P.TextDocument),C=!1,D=!1,O=!1,l,g,I;var M=o.settings,p=new Map;a.onDidChangeConfiguration(t=>{C?p.clear():M=t.settings.masterCSS||o.settings,f.all().forEach(y)});async function B(t){if(!C)return Promise.resolve(M);let e=p.get(t);return e||(e=a.workspace.getConfiguration({scopeUri:t,section:"masterCSS"}),p.set(t,e)),e}f.onDidClose(t=>{p.delete(t.document.uri)});f.onDidOpen(t=>{y(t.document)});f.onDidSave(async t=>{k.default.parse(t.document.uri).name==="master.css"&&await A(t.document.uri)});async function y(t){l=await B(t.uri),await A(t.uri)}async function A(t){let e=await a.workspace.getWorkspaceFolders(),n;if(e?.length===1?n=e[0]:n=e?.find(s=>t.includes(s.uri)),n?.uri){let s=(0,T.fileURLToPath)(n.uri.replace("%3A",":"));I=(0,v.default)(l.config||"master.css.*",{cwd:s}),g=new w.MasterCSS(I)}}a.onInitialize(t=>{let e=t.capabilities;C=!!(e.workspace&&e.workspace.configuration),D=!!(e.workspace&&e.workspace.workspaceFolders),O=!!(e.textDocument&&e.textDocument.publishDiagnostics&&e.textDocument.publishDiagnostics.relatedInformation);let n={capabilities:{textDocumentSync:u.TextDocumentSyncKind.Incremental,completionProvider:{resolveProvider:!0,workDoneProgress:!1,triggerCharacters:[":","@","'"]},colorProvider:{},hoverProvider:!0}};return D&&(n.capabilities.workspace={workspaceFolders:{supported:!0}}),n});a.onInitialized(()=>{C&&a.client.register(u.DidChangeConfigurationNotification.type,void 0)});a.onCompletion(t=>{if(l.suggestions==!0&&x(t.textDocument.uri)){let e=t.textDocument.uri,n=f.get(e),s=e.substring(e.lastIndexOf(".")+1),i=t.position;if(n){let c=n.getText(),d=n.offsetAt(i)??0,r=n.offsetAt({line:i.line-100,character:0})??0,F=n.offsetAt({line:i.line+100,character:0})??void 0,R=(0,o.positionCheck)(c.substring(r,F),d,r,l.classMatch).IsMatch,z=n.getText({start:{line:i.line,character:0},end:{line:i.line,character:i.character}}).trim(),m=(0,o.getLastInstance)(z,i,s);if(m.isInstance==!0&&R==!0)return(0,o.getCompletionItem)(m.lastKey,m.triggerKey,m.isStart,m.language,g);if(m.isInstance==!0&&(0,o.checkConfigColorsBlock)(n,t.position)==!0)return(0,o.getConfigColorsCompletionItem)(g)}}return[]});a.onCompletionResolve(t=>t);a.onDocumentColor(async t=>{if(l==null)return[];if(l.previewColors==!0&&x(t.textDocument.uri)){let e=t.textDocument.uri,n=f.get(e);if(n){let s=n.getText()??"";if(typeof n==null)return[];let i=await(0,o.getDocumentColors)(s,g),c=new Set;return i.filter(r=>c.has(r.index.start)?!1:(c.add(r.index.start),!0)).map(r=>({range:{start:n.positionAt(r.index.start),end:n.positionAt(r.index.end)},color:r.color}))}}return[]});a.onColorPresentation(t=>{if(l.previewColors==!0&&x(t.textDocument.uri)){let e=f.get(t.textDocument.uri);if(e){let n=e.getText(),s=["(?<=colors:\\s*{\\s*.*)([^}]*)}"],i=e.offsetAt(t.range.start)??0,c=e.offsetAt({line:t.range.start.line-100,character:0})??0,d=e.offsetAt({line:t.range.start.line+100,character:0})??void 0,r=(0,o.positionCheck)(n.substring(c,d),i,c,s);return(0,o.getColorPresentation)(t,r.IsMatch)}}return[]});a.onHover(t=>{if(l.inspect==!0&&x(t.textDocument.uri)){let e=f.get(t.textDocument.uri),n=t.position;if(e){let s=e.getText(),i=e.offsetAt(n)??0,c=e.offsetAt({line:n.line-100,character:0})??0,d=e.offsetAt({line:n.line+100,character:0})??void 0,r=(0,o.positionCheck)(s.substring(c,d),i,c,l.classMatch);if(r.IsMatch)return(0,o.doHover)(r.instance.instanceString,N(r.instance.index,e),I)}}return null});function x(t){for(let e of l.files.exclude)if((0,b.minimatch)(t,e))return!1;return!0}function N(t,e){return{start:e.positionAt(t.start),end:e.positionAt(t.end)}}f.listen(a);a.listen();