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

package/README.md

@@ -17,7 +17,7 @@
     <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="NPM Version" src="https://img.shields.io/github/v/release/master-co/css?include_prereleases&color=f6f7f8&label=&style=for-the-badge&logo=github">
+      <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">
@@ -34,13 +34,6 @@
       <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="Discord Community" href="https://discord.gg/sZNKpAAAw6">
-    <picture>
-      <source media="(prefers-color-scheme: dark)" srcset="https://img.shields.io/discord/917780624314613760?color=212022&label=%20&logo=discord&style=for-the-badge">
-      <source media="(prefers-color-scheme: light)" srcset="https://img.shields.io/discord/917780624314613760?color=f6f7f8&label=%20&logo=discord&style=for-the-badge">
-      <img alt="Discord online" src="https://img.shields.io/discord/917780624314613760?color=f6f7f8&label=%20&logo=discord&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">
@@ -48,11 +41,11 @@
       <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/ci-release.yml">
+  <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/ci-release.yml?branch=rc&label=%20&message=twitter&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/ci-release.yml?branch=rc&label=%20&message=twitter&color=f6f7f8&logo=githubactions&style=for-the-badge&logoColor=%23000">
-      <img alt="Github release actions" src="https://img.shields.io/github/actions/workflow/status/master-co/css/ci-release.yml?branch=rc&label=%20&message=twitter&color=f6f7f8&logo=githubactions&style=for-the-badge&logoColor=%23000">
+      <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>
@@ -68,12 +61,12 @@ npm install @master/css-language-server
 ## Usage
 
 ```js
-import CSSLanguageServer from '@master/css-language-server'
+import { MasterCSSLanguageServer } from '@master/css-language-server'
 
-const languageServer = new CSSLanguageServer(connection, customSettings)
+const languageServer = new MasterCSSLanguageServer(connection, customSettings)
 ```
 
-`CSSLanguageServer` wraps `@master/css-language-service` with LSP workspace lifecycle, completion, hover, document color, color presentation, semantic token, and directive formatting handlers.
+`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`.
 
@@ -87,18 +80,18 @@ The language server supports full-document and active-position semantic tokens.
 | `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 `@compose` and `@safelist`.
+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 `bg:transparent !` to `bg:transparent!`. It does not run the compiler and does not change generated CSS output.
+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 { settings } from '@master/css-language-server'
+import { defaultLanguageServerSettings } from '@master/css-language-server'
 ```
 
 | Setting | Type | Default | Description |
@@ -108,4 +101,4 @@ import { settings } from '@master/css-language-server'
 | `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`, CSS files containing the lightweight `@master entry;` marker, and `package.json` files that declare Master CSS package dependencies.
+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

@@ -1,69 +1,96 @@
-import { ClientCapabilities, ColorPresentationParams, CompletionParams, Connection, DidChangeConfigurationParams, DocumentColorParams, DocumentFormattingParams, DocumentRangeFormattingParams, HoverParams, InitializeParams, InitializeResult, RemoteConsole, SemanticTokensParams, TextDocumentChangeEvent, TextDocumentPositionParams, TextDocuments, TextEdit, WorkspaceFolder } from "vscode-languageserver/node";
+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 CSSLanguageService from "@master/css-language-service";
-import { MasterCSSWorkspacePackageResolution } from "@master/css-project/workspace";
-import { CSSLanguageRuntime } from "@master/css-language";
-import { Settings as Settings$1 } from "./settings.js";
-//#region src/core.d.ts
-declare interface Workspace {
+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?: CSSLanguageService;
-  languageServiceSettings: Settings$1;
-  languageRuntime?: CSSLanguageRuntime;
-  languageRuntimeResolution?: MasterCSSWorkspacePackageResolution;
-  languageRuntimeSource?: 'workspace' | 'bundled';
+  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 CSSLanguageServer {
+declare class MasterCSSLanguageServer implements Disposable {
   connection: Connection;
-  customSettings?: Settings$1 | undefined;
+  customSettings?: MasterCSSLanguageServerSettings | undefined;
   workspaceFolders: WorkspaceFolder[];
-  workspaces: Map<string, Workspace>;
-  globalWorkspace: Workspace;
+  workspaces: Map<string, MasterCSSWorkspace>;
+  globalWorkspace: MasterCSSWorkspace;
   documents: TextDocuments<TextDocument>;
   initializing?: Promise<void>;
   clientCapabilities: ClientCapabilities;
-  settings?: Settings$1;
+  settings?: MasterCSSLanguageServerSettings;
   console: RemoteConsole;
   private disposables;
-  constructor(connection?: Connection, customSettings?: Settings$1 | undefined);
+  private workspaceLanguageServiceInitializations;
+  private disposed;
+  constructor(connection?: Connection, customSettings?: MasterCSSLanguageServerSettings | undefined);
   start(): void;
   init(): Promise<void>;
   onInitialize(params: InitializeParams): InitializeResult;
-  onHover(params: HoverParams): Promise<import("vscode-languageserver-protocol").Hover | undefined>;
-  onCompletion(params: CompletionParams): Promise<import("vscode-languageserver-protocol").CompletionItem[] | undefined>;
-  onDocumentColor(params: DocumentColorParams): Promise<import("vscode-languageserver-protocol").ColorInformation[]>;
-  onColorPresentation(params: ColorPresentationParams): Promise<import("vscode-languageserver-protocol").ColorPresentation[]>;
+  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<import("vscode-languageserver-protocol").SemanticTokens>;
-  onDocumentSemanticTokens(params: SemanticTokensParams): Promise<import("vscode-languageserver-protocol").SemanticTokens>;
-  onActiveSemanticTokens(params: TextDocumentPositionParams): Promise<import("vscode-languageserver-protocol").SemanticTokens>;
+  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: Workspace): Promise<void>;
+  initWorkspaceLanguageService(workspace: MasterCSSWorkspace): Promise<void>;
+  private ensureWorkspaceLanguageService;
   private loadWorkspacePlan;
-  private loadWorkspaceLanguageRuntime;
-  private importWorkspaceModule;
-  destroyLanguageService(workspace: Workspace): void;
-  findClosestWorkspace(textDocumentURI: string): Workspace;
+  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;
-  stop(): void;
+  dispose(): void;
+  [Symbol.dispose](): void;
 }
-//#endregion
-export { ACTIVE_SEMANTIC_TOKENS_REQUEST, DOCUMENT_SEMANTIC_TOKENS_REQUEST, Workspace, CSSLanguageServer as default };
+export { ACTIVE_SEMANTIC_TOKENS_REQUEST, DOCUMENT_SEMANTIC_TOKENS_REQUEST, MasterCSSLanguageServer, MasterCSSWorkspace };

package/dist/core.js

@@ -1,21 +1,23 @@
-import settings$1 from "./settings.js";
+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 { pathToFileURL } from "node:url";
-import CSSLanguageService from "@master/css-language-service";
-import { compileCSSManifest } from "@master/css-compiler";
-import { findCSSManifestEntryFiles, findMasterCSSWorkspaceDirectories } from "@master/css-project/entries";
-import { loadProjectManifest } from "@master/css-project/manifest";
-import { resolveMasterCSSWorkspacePackages } from "@master/css-project/workspace";
+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 { AT_TRIGGER_CHARACTER, DECLARATION_SEPARATOR_TRIGGER_CHARACTER, GROUP_TRIGGER_CHARACTER, INVOKED_TRIGGER_CHARACTERS, QUERY_TRIGGER_CHARACTERS, SELECTOR_TRIGGER_CHARACTERS, VALUE_TRIGGER_CHARACTERS } from "@master/css-language-service/common";
-import { SEMANTIC_TOKENS_LEGEND, defaultCSSLanguageRuntime, matchesLanguageServiceNativeDeclaration } from "@master/css-language";
+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";
-import { CSSDirectiveError } from "@master/css-schema/css-directives";
-//#region src/core.ts
+// src/core.ts
+const defaultManifest = defaultManifestJSON;
 const ACTIVE_SEMANTIC_TOKENS_REQUEST = "masterCSS/renderActiveSemanticTokens";
 const DOCUMENT_SEMANTIC_TOKENS_REQUEST = "masterCSS/renderDocumentSemanticTokens";
 const SERVER_CAPABILITIES = {
@@ -28,13 +30,12 @@ const SERVER_CAPABILITIES = {
 			...VALUE_TRIGGER_CHARACTERS,
 			...SELECTOR_TRIGGER_CHARACTERS,
 			...QUERY_TRIGGER_CHARACTERS,
-			DECLARATION_SEPARATOR_TRIGGER_CHARACTER,
-			AT_TRIGGER_CHARACTER,
-			GROUP_TRIGGER_CHARACTER
+			AT_TRIGGER_CHARACTER
 		])]
 	},
 	colorProvider: true,
 	hoverProvider: true,
+	definitionProvider: true,
 	documentFormattingProvider: true,
 	documentRangeFormattingProvider: true,
 	semanticTokensProvider: {
@@ -43,48 +44,6 @@ const SERVER_CAPABILITIES = {
 	},
 	workspace: { workspaceFolders: { supported: true } }
 };
-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 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(source);
-		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 getInitializationSettings(initializationOptions) {
 	if (!initializationOptions || typeof initializationOptions !== "object") return;
 	const options = initializationOptions;
@@ -109,7 +68,7 @@ function containsFilePath(parentPath, childPath) {
 	const relativePath = filePathTools.relative(parentPath, childPath);
 	return relativePath === "" || !!relativePath && relativePath !== ".." && !relativePath.startsWith(`..${filePathTools.sep}`) && !filePathTools.isAbsolute(relativePath);
 }
-var CSSLanguageServer = class {
+var MasterCSSLanguageServer = class {
 	connection;
 	customSettings;
 	workspaceFolders = [];
@@ -118,8 +77,8 @@ var CSSLanguageServer = class {
 		uri: "",
 		openedTextDocuments: [],
 		languageServiceSettings: this.settings,
-		languageRuntime: defaultCSSLanguageRuntime,
-		languageRuntimeSource: "bundled"
+		baseManifest: defaultManifest,
+		manifestSource: "bundled"
 	};
 	documents;
 	initializing;
@@ -127,11 +86,13 @@ var CSSLanguageServer = class {
 	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, settings$1);
+		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 () => {};
@@ -139,14 +100,14 @@ var CSSLanguageServer = class {
 		} });
 	}
 	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.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.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 = new Promise(async (resolve) => {
-			await Promise.all(this.workspaceFolders.map((folder) => this.initWorkspaceFolder(folder.uri)));
-			resolve();
+		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) {
@@ -154,7 +115,7 @@ var CSSLanguageServer = class {
 		const initializationSettings = getInitializationSettings(params.initializationOptions);
 		if (initializationSettings) {
 			this.customSettings = defu(initializationSettings, this.customSettings);
-			this.settings = defu(this.customSettings, settings$1);
+			this.settings = defu(this.customSettings, defaultLanguageServerSettings);
 			this.globalWorkspace.languageServiceSettings = this.settings;
 		}
 		if (params.workspaceFolders?.length) this.workspaceFolders = params.workspaceFolders;
@@ -174,6 +135,25 @@ var CSSLanguageServer = class {
 			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);
@@ -239,25 +219,27 @@ var CSSLanguageServer = class {
 		await this.init();
 		const workspace = this.findClosestWorkspace(params.document.uri);
 		if (!workspace) return;
-		if (workspace.openedTextDocuments.includes(params.document)) {
-			this.publishDiagnostics(params.document, workspace);
-			return;
-		}
-		if (!workspace.openedTextDocuments.length) await this.initWorkspaceLanguageService(workspace);
-		workspace.openedTextDocuments.push(params.document);
+		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;
-		workspace.openedTextDocuments.splice(workspace.openedTextDocuments.indexOf(params.document), 1);
+		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: []
@@ -279,7 +261,7 @@ var CSSLanguageServer = class {
 		if (changedSettings?.masterCSS) {
 			this.connection.sendNotification("masterCSS/globalSettingsChanged", changedSettings.masterCSS);
 			this.customSettings = changedSettings.masterCSS;
-			this.settings = defu(this.customSettings, settings$1);
+			this.settings = defu(this.customSettings, defaultLanguageServerSettings);
 			this.globalWorkspace.languageServiceSettings = this.settings;
 			this.refreshSemanticTokens();
 			this.connection.sendRequest("masterCSS/restart", { title: "Updating Master CSS settings" });
@@ -293,12 +275,14 @@ var CSSLanguageServer = class {
 			scopeUri: workspaceFolderURI,
 			section: "masterCSS"
 		});
-		const { workspaces, ...languageServiceSettings } = defu(customWorkspaceFolderSettings, this.customSettings, settings$1);
+		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") for (const workspaceDir of await findMasterCSSWorkspaceDirectories(workspaceFolderCWD)) resolvedWorkspaceDirectories.add(workspaceDir);
-		else if (workspaces?.length) (await glob(workspaces, {
+		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,
@@ -311,17 +295,18 @@ var CSSLanguageServer = class {
 				uri: workspaceURI,
 				openedTextDocuments: [],
 				languageServiceSettings,
-				planEntries: await findCSSManifestEntryFiles(workspaceDir)
+				planEntries: [...await discoverManifestEntries({ root: workspaceDir })]
 			});
 		}
 	}
 	async initWorkspaceLanguageService(workspace) {
-		workspace.languageRuntime = await this.loadWorkspaceLanguageRuntime(workspace);
+		workspace.baseManifest = await this.loadWorkspaceBaseManifest(workspace);
 		let workspacePlan;
 		workspace.manifestErrors = [];
+		workspace.designSystemFiles = [];
 		if (workspace !== this.globalWorkspace) {
 			try {
-				workspacePlan = await this.loadWorkspacePlan(workspace);
+				workspacePlan = await this.loadWorkspacePlan(workspace, workspace.baseManifest);
 			} catch (e) {
 				workspace.manifestErrors = [e];
 				this.console.info(`Failed to load manifest from ${workspace.uri}`);
@@ -330,71 +315,69 @@ var CSSLanguageServer = class {
 			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}`);
 		}
-		workspace.languageService = new CSSLanguageService({
+		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: workspacePlan
-		}, { runtime: workspace.languageRuntime });
+			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) {
-		const result = await loadProjectManifest(workspace.uri ? URI.parse(workspace.uri).fsPath : process.cwd(), { baseManifest: (workspace.languageRuntime ?? defaultCSSLanguageRuntime).defaultManifest });
-		return result.entries.length ? result.manifest : workspace.languageServiceSettings.manifest;
+	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 loadWorkspaceLanguageRuntime(workspace) {
+	async loadWorkspaceBaseManifest(workspace) {
 		if (workspace === this.globalWorkspace || !workspace.uri) {
-			workspace.languageRuntimeSource = "bundled";
-			return defaultCSSLanguageRuntime;
+			workspace.manifestSource = "bundled";
+			return defaultManifest;
 		}
 		const cwd = URI.parse(workspace.uri).fsPath;
 		let resolution;
 		try {
 			resolution = resolveMasterCSSWorkspacePackages(cwd);
-			workspace.languageRuntimeResolution = resolution;
-			const missingPackages = [
-				!resolution.css && "@master/css",
-				!resolution.engine && "@master/css-engine",
-				!resolution.presetManifest && "@master/css-preset/default-manifest.json"
-			].filter(Boolean);
-			if (missingPackages.length) throw new Error(`Missing workspace package(s): ${missingPackages.join(", ")}`);
-			const cssPackage = resolution.css;
-			const enginePackage = resolution.engine;
+			workspace.manifestResolution = resolution;
 			const presetManifestPackage = resolution.presetManifest;
-			if (!cssPackage || !enginePackage || !presetManifestPackage) throw new Error("Missing required workspace Master CSS runtime packages.");
-			const [cssModule, engineModule, utilityTypeModule] = await Promise.all([
-				this.importWorkspaceModule(cssPackage.entry),
-				this.importWorkspaceModule(enginePackage.entry),
-				resolution.utilityType ? this.importWorkspaceModule(resolution.utilityType.entry) : void 0
-			]);
-			const MasterCSS = cssModule.MasterCSS || cssModule.default;
-			const builtinKeyAliases = engineModule.builtinKeyAliases;
-			const builtinNativeValueNamespaces = engineModule.builtinNativeValueNamespaces;
-			if (!MasterCSS) throw new Error(`Missing MasterCSS export from ${cssPackage.entry}`);
-			if (!builtinKeyAliases) throw new Error(`Missing builtinKeyAliases export from ${enginePackage.entry}`);
-			if (!builtinNativeValueNamespaces) throw new Error(`Missing builtinNativeValueNamespaces export from ${enginePackage.entry}`);
+			if (!presetManifestPackage) throw new Error("Missing workspace package @master/css-preset/default-manifest.json.");
 			const manifest = JSON.parse(await readFile(presetManifestPackage.entry, "utf8"));
-			workspace.languageRuntimeSource = "workspace";
-			this.console.info(`Using workspace Master CSS runtime ${cssPackage.version ?? "(unknown version)"} from ${cssPackage.directory}`);
-			if (resolution.errors.length) this.console.info(`Workspace Master CSS runtime optional resolution warnings: ${resolution.errors.map(({ name, message }) => `${name}: ${message}`).join("; ")}`);
-			return {
-				MasterCSS,
-				UtilityType: utilityTypeModule?.UtilityType || utilityTypeModule?.default || defaultCSSLanguageRuntime.UtilityType,
-				defaultManifest: manifest,
-				builtinKeyAliases,
-				builtinNativeValueNamespaces,
-				nativeDeclarationMatcher: matchesLanguageServiceNativeDeclaration
-			};
+			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.languageRuntimeSource = "bundled";
-			this.console.info(`Using bundled Master CSS runtime for ${workspace.uri}`);
-			if (resolution?.errors.length) this.console.info(`Workspace Master CSS package resolution errors: ${resolution.errors.map(({ name, message }) => `${name}: ${message}`).join("; ")}`);
+			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 defaultCSSLanguageRuntime;
+			return defaultManifest;
 		}
 	}
-	async importWorkspaceModule(path) {
-		return await import(pathToFileURL(path).href);
-	}
 	destroyLanguageService(workspace) {
 		this.console.info(`Destroyed workspace ${workspace.uri}`);
+		workspace.languageService?.dispose();
 		delete workspace.languageService;
 	}
 	findClosestWorkspace(textDocumentURI) {
@@ -422,23 +405,74 @@ var CSSLanguageServer = class {
 		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 {
-			compileCSSManifest(source, {
+			compileManifestSync(source, {
 				from: documentFile,
-				baseManifest: (workspace.languageRuntime ?? defaultCSSLanguageRuntime).defaultManifest
+				baseManifest: workspace.baseManifest ?? defaultManifest
 			});
 		} catch (error) {
-			if (!isCSSDirectiveError(error)) continue;
-			const diagnostic = this.createCSSDirectiveDiagnostic(error, textDocument, documentFile, offset);
+			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;
@@ -446,10 +480,15 @@ var CSSLanguageServer = class {
 	createManifestLoadingDiagnostics(textDocument, workspace) {
 		if (!workspace.manifestErrors?.length) return [];
 		const documentFile = path.resolve(URI.parse(textDocument.uri).fsPath);
-		return workspace.manifestErrors.map((error) => {
-			const directiveError = isCSSDirectiveError(error) ? error : void 0;
+		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 {
+			return [{
 				range: source && (!source.file || path.resolve(source.file) === documentFile) ? this.createCSSDirectiveRange(source, textDocument, documentFile, 0) : {
 					start: {
 						line: 0,
@@ -465,9 +504,36 @@ var CSSLanguageServer = class {
 				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 {
@@ -521,13 +587,19 @@ var CSSLanguageServer = class {
 		if (!this.clientCapabilities.workspace?.semanticTokens?.refreshSupport) return;
 		this.connection.languages.semanticTokens.refresh();
 	}
-	stop() {
+	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();
+	}
 };
-//#endregion
-export { ACTIVE_SEMANTIC_TOKENS_REQUEST, DOCUMENT_SEMANTIC_TOKENS_REQUEST, CSSLanguageServer as default };
+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

@@ -1,3 +1,3 @@
-import settings, { Settings } from "./settings.js";
-import CSSLanguageServer, { ACTIVE_SEMANTIC_TOKENS_REQUEST, DOCUMENT_SEMANTIC_TOKENS_REQUEST, Workspace, default as core_default } from "./core.js";
-export { ACTIVE_SEMANTIC_TOKENS_REQUEST, CSSLanguageServer, DOCUMENT_SEMANTIC_TOKENS_REQUEST, type Settings, type Workspace, core_default as default, settings };
+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

@@ -1,3 +1,3 @@
-import settings from "./settings.js";
-import CSSLanguageServer, { ACTIVE_SEMANTIC_TOKENS_REQUEST, DOCUMENT_SEMANTIC_TOKENS_REQUEST } from "./core.js";
-export { ACTIVE_SEMANTIC_TOKENS_REQUEST, CSSLanguageServer, DOCUMENT_SEMANTIC_TOKENS_REQUEST, CSSLanguageServer as default, settings };
+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.js

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

package/dist/settings.d.ts

@@ -1,10 +1,11 @@
-import { Settings as Settings$1 } from "@master/css-language-service";
+import { MasterCSSLanguageServiceSettings } from "@master/css-language-service";
 import { Pattern } from "fast-glob";
-//#region src/settings.d.ts
-declare const settings: Settings;
-declare type Settings = Settings$1 & {
-  workspaces?: Pattern[] | 'auto';
+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;
 };
-//#endregion
-export { Settings, settings as default };
+export { MasterCSSLanguageServerSettings, defaultLanguageServerSettings };

package/dist/settings.js

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

package/package.json

@@ -1,60 +1,58 @@
 {
-  "name": "@master/css-language-server",
-  "type": "module",
-  "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": {
-    "defu": "^6.1.7",
-    "fast-glob": "^3.3.3",
-    "js-beautify": "^1.15.4",
-    "nanoid": "^5.1.15",
-    "vscode-languageserver": "^10.0.0",
-    "vscode-languageserver-textdocument": "^1.0.12",
-    "vscode-uri": "^3.1.0",
-    "@master/css-compiler": "^2.0.0-rc.88",
-    "@master/css": "^2.0.0-rc.88",
-    "@master/css-language-service": "^2.0.0-rc.88",
-    "@master/css-language": "^2.0.0-rc.88",
-    "@master/css-project": "^2.0.0-rc.88",
-    "@master/css-schema": "^2.0.0-rc.88"
-  },
-  "sideEffects": false,
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "jsnext:main": "./dist/index.js",
-  "esnext": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "default": "./dist/index.js"
+    "name": "@master/css-language-server",
+    "type": "module",
+    "engines": {
+        "node": "^24"
     },
-    "./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-rc.88",
-  "scripts": {
-    "build": "tsdown --config ../../shared/tsdown-package.config.ts",
-    "dev": "tsdown --config ../../shared/tsdown-package.config.ts --watch",
-    "type-check": "tsc -b tsconfig.typecheck.json",
-    "lint": "eslint",
-    "test": "vitest"
-  }
-}
+    "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/LICENSE

@@ -1,21 +0,0 @@
-The MIT License
-
-Copyright (c) Aoyue Design LLC.
-
-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/dist/utils/create-document.d.ts

@@ -1,8 +0,0 @@
-import { TextDocument } from "vscode-languageserver-textdocument";
-//#region src/utils/create-document.d.ts
-declare function createDocument(text: string, options?: {
-  lang?: string;
-  dir?: string;
-}): TextDocument;
-//#endregion
-export { createDocument as default };

package/dist/utils/create-document.js

@@ -1,28 +0,0 @@
-import { TextDocument } from "vscode-languageserver-textdocument";
-import { URI } from "vscode-uri";
-import { nanoid } from "nanoid";
-import path from "path";
-//#region src/utils/create-document.ts
-const extOfLang = {
-	typescript: "ts",
-	typescriptreact: "tsx",
-	javascript: "js",
-	javascriptreact: "jsx",
-	css: "css",
-	scss: "scss",
-	less: "less",
-	html: "html",
-	json: "json",
-	vue: "vue",
-	svelte: "svelte",
-	astro: "astro"
-};
-function createDocument(text, options) {
-	const lang = options?.lang || "html";
-	const dir = options?.dir || "./";
-	const filePath = path.join(dir, `${nanoid()}.${extOfLang[lang]}`);
-	const fileURI = URI.file(filePath).toString();
-	return TextDocument.create(fileURI, lang, 0, text);
-}
-//#endregion
-export { createDocument as default };