@master/css-mcp 2.0.0-rc.76

package/LICENSE

@@ -0,0 +1,21 @@
+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/README.md

@@ -0,0 +1,59 @@
+# Master CSS MCP Server
+
+Model Context Protocol server for Master CSS tooling. It lets AI clients inspect a Master CSS workspace, read the active project manifest, scan source files, inspect classes, render generated CSS, run lint diagnostics, request syntax suggestions, and apply reviewed fix previews.
+
+## Installation
+
+```bash
+npm install -D @master/css-mcp
+```
+
+You can also run it directly:
+
+```bash
+npx -y @master/css-mcp@rc --root /absolute/path/to/project
+```
+
+## MCP client config
+
+Most MCP clients accept a command and arguments for stdio servers:
+
+```json
+{
+  "mcpServers": {
+    "master-css": {
+      "command": "npx",
+      "args": ["-y", "@master/css-mcp@rc", "--root", "/absolute/path/to/project"]
+    }
+  }
+}
+```
+
+Use an absolute `--root` path so the server resolves the intended workspace.
+
+## Tools
+
+| Tool | Use |
+| --- | --- |
+| `mastercss_workspace_info` | Report workspace roots, resolved packages, and manifest status. |
+| `mastercss_inspect_class` | Inspect one class and return generated rules and CSS text. |
+| `mastercss_render_css` | Generate CSS from HTML or a class list. |
+| `mastercss_scan_project` | Scan sources, check optional classes, and report scanner state, stylesheet entries, generated CSS metadata, and missing CSS diagnostics. |
+| `mastercss_lint_project` | Run class-list diagnostics for workspace files without writing files. |
+| `mastercss_lint_content` | Run class-list diagnostics on an in-memory source buffer without writing files. |
+| `mastercss_suggest_syntax` | Return language-service completions and hover context. |
+| `mastercss_preview_fixes` | Create a diff preview and confirmation token. |
+| `mastercss_apply_preview` | Apply a preview after token, hash, and workspace checks. |
+
+## Machine-readable results
+
+Project scan and lint reports use `version: 1`. Tooling can rely on stable top-level fields such as `version`, `root`, `manifest`, `inputs`, `files`, `diagnostics`, and `summary` when present. Nested diagnostic `data` objects may gain additional fields over time.
+
+## Safety
+
+Read-only tools do not write files. File writes use a two-step preview/apply flow, validate workspace containment, and verify original file hashes before writing.
+
+## Related docs
+
+- [MCP Server guide](https://rc.css.master.co/guide/mcp-server)
+- [AI Coding guide](https://rc.css.master.co/guide/ai-coding)

package/dist/bin/index.d.ts

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

package/dist/bin/index.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+import { startStdioServer } from "../server.js";
+import { readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+//#region src/bin/index.ts
+function readPackageVersion() {
+	const directory = dirname(fileURLToPath(import.meta.url));
+	try {
+		return JSON.parse(readFileSync(resolve(directory, "../../package.json"), "utf8")).version || "0.0.0";
+	} catch {
+		return "0.0.0";
+	}
+}
+function printHelp() {
+	process.stdout.write(`Usage: master-css-mcp [options]
+
+Options:
+  --root <dir>          Workspace root. Defaults to the current working directory.
+  --preview-ttl <ms>    Preview confirmation token TTL in milliseconds.
+  --version             Print version.
+  --help                Print help.
+`);
+}
+function parseArgs(argv) {
+	const options = {};
+	for (let index = 0; index < argv.length; index++) {
+		const arg = argv[index];
+		switch (arg) {
+			case "--root":
+				options.root = argv[++index];
+				if (!options.root) throw new Error("--root requires a directory.");
+				break;
+			case "--preview-ttl": {
+				const value = Number(argv[++index]);
+				if (!Number.isFinite(value) || value <= 0) throw new Error("--preview-ttl requires a positive number.");
+				options.previewTTL = value;
+				break;
+			}
+			case "--version":
+				process.stdout.write(`${readPackageVersion()}\n`);
+				process.exit(0);
+				break;
+			case "--help":
+				printHelp();
+				process.exit(0);
+				break;
+			default: throw new Error(`Unknown option: ${arg}`);
+		}
+	}
+	return options;
+}
+try {
+	await startStdioServer(parseArgs(process.argv.slice(2)));
+} catch (error) {
+	console.error(error instanceof Error ? error.message : String(error));
+	process.exit(1);
+}
+//#endregion
+export {};

package/dist/context.d.ts

@@ -0,0 +1,60 @@
+//#region src/context.d.ts
+interface MasterCSSMCPContextOptions {
+  root?: string;
+  roots?: string[];
+  previewTTL?: number;
+}
+interface PreviewChange {
+  filePath: string;
+  beforeText?: string;
+  afterText: string;
+}
+interface StoredPreviewChange {
+  filePath: string;
+  beforeHash: string | null;
+  afterHash: string;
+  beforeExists: boolean;
+  beforeBytes: number;
+  afterBytes: number;
+  afterText: string;
+  diff: string;
+}
+interface StoredPreview {
+  confirmToken: string;
+  createdAt: number;
+  expiresAt: number;
+  changes: StoredPreviewChange[];
+}
+interface PreviewResult {
+  confirmToken?: string;
+  expiresAt?: number;
+  changes: StoredPreviewChange[];
+  summary: {
+    files: number;
+    bytesBefore: number;
+    bytesAfter: number;
+  };
+}
+declare class MasterCSSMCPContext {
+  readonly root: string;
+  readonly roots: string[];
+  readonly previewTTL: number;
+  private readonly containmentRoots;
+  private previews;
+  constructor(options?: MasterCSSMCPContextOptions);
+  assertContained(filePath: string): string;
+  resolveVirtualPath(filePath: string): string;
+  resolveExistingFile(filePath: string): Promise<string>;
+  resolveWritableFile(filePath: string): Promise<string>;
+  validateGlobPatterns(patterns: string[]): void;
+  createPreview(changes: PreviewChange[], ttl?: number): Promise<PreviewResult>;
+  applyPreview(confirmToken: string): Promise<{
+    applied: boolean;
+    changes: {
+      filePath: string;
+      afterHash: string;
+    }[];
+  }>;
+}
+//#endregion
+export { MasterCSSMCPContextOptions, PreviewChange, PreviewResult, StoredPreview, StoredPreviewChange, MasterCSSMCPContext as default };

package/dist/context.js

@@ -0,0 +1,189 @@
+import { createHash, randomBytes } from "node:crypto";
+import { existsSync, realpathSync, statSync } from "node:fs";
+import { mkdir, readFile, realpath, stat, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, relative, resolve } from "node:path";
+//#region src/context.ts
+const DEFAULT_PREVIEW_TTL = 300 * 1e3;
+function sha256(text) {
+	return createHash("sha256").update(text).digest("hex");
+}
+function isContained(root, filePath) {
+	const path = relative(root, filePath);
+	return path === "" || Boolean(path && !path.startsWith("..") && !isAbsolute(path));
+}
+function pushUniquePath(paths, filePath) {
+	if (!paths.includes(filePath)) paths.push(filePath);
+}
+function collectPathAliases(filePath) {
+	const aliases = [];
+	const resolved = resolve(filePath);
+	pushUniquePath(aliases, resolved);
+	try {
+		pushUniquePath(aliases, realpathSync(resolved));
+	} catch {}
+	try {
+		pushUniquePath(aliases, realpathSync.native(resolved));
+	} catch {}
+	return aliases;
+}
+function assertFilePattern(pattern) {
+	if (isAbsolute(pattern)) throw new Error(`Absolute glob patterns are not allowed: ${pattern}`);
+	if (pattern.split(/[\\/]+/).includes("..")) throw new Error(`Glob patterns may not escape the workspace root: ${pattern}`);
+}
+function formatDiff(filePath, beforeText, afterText) {
+	if (beforeText === afterText) return "";
+	const beforeLines = beforeText.length ? beforeText.split("\n") : [];
+	const afterLines = afterText.length ? afterText.split("\n") : [];
+	return [
+		`--- ${filePath}`,
+		`+++ ${filePath}`,
+		"@@",
+		...beforeLines.map((line) => `-${line}`),
+		...afterLines.map((line) => `+${line}`)
+	].join("\n");
+}
+var MasterCSSMCPContext = class {
+	root;
+	roots;
+	previewTTL;
+	containmentRoots;
+	previews = /* @__PURE__ */ new Map();
+	constructor(options = {}) {
+		const configuredRoots = options.roots?.length ? options.roots : [options.root || process.cwd()];
+		const roots = [];
+		const containmentRoots = [];
+		for (const root of configuredRoots) {
+			const [resolved] = collectPathAliases(root);
+			if (!existsSync(resolved)) throw new Error(`Workspace root does not exist: ${resolved}`);
+			const real = realpathSync(resolved);
+			if (!statSync(real).isDirectory()) throw new Error(`Workspace root is not a directory: ${real}`);
+			roots.push(real);
+			containmentRoots.push(...collectPathAliases(resolved));
+		}
+		this.roots = roots;
+		this.root = this.roots[0];
+		this.containmentRoots = [...new Set(containmentRoots)];
+		this.previewTTL = options.previewTTL ?? DEFAULT_PREVIEW_TTL;
+	}
+	assertContained(filePath) {
+		const resolvedPath = resolve(filePath);
+		const pathAliases = collectPathAliases(resolvedPath);
+		if (!this.containmentRoots.some((root) => pathAliases.some((pathAlias) => isContained(root, pathAlias)))) throw new Error(`Path is outside the allowed workspace roots: ${filePath}`);
+		return resolvedPath;
+	}
+	resolveVirtualPath(filePath) {
+		const resolved = resolve(this.root, filePath);
+		return this.assertContained(resolved);
+	}
+	async resolveExistingFile(filePath) {
+		const realPath = await realpath$1(resolve(this.root, filePath));
+		this.assertContained(realPath);
+		if (!(await stat(realPath)).isFile()) throw new Error(`Path is not a file: ${realPath}`);
+		return realPath;
+	}
+	async resolveWritableFile(filePath) {
+		const resolved = resolve(this.root, filePath);
+		if (existsSync(resolved)) {
+			const realPath = await realpath$1(resolved);
+			this.assertContained(realPath);
+			if (!(await stat(realPath)).isFile()) throw new Error(`Path is not a file: ${realPath}`);
+			return realPath;
+		}
+		this.assertContained(resolved);
+		const parent = await realpath$1(dirname(resolved));
+		this.assertContained(parent);
+		return resolved;
+	}
+	validateGlobPatterns(patterns) {
+		for (const pattern of patterns) assertFilePattern(pattern);
+	}
+	async createPreview(changes, ttl = this.previewTTL) {
+		const storedChanges = [];
+		for (const change of changes) {
+			const filePath = await this.resolveWritableFile(change.filePath);
+			const beforeText = change.beforeText ?? await readFileIfExists(filePath);
+			if (beforeText === change.afterText) continue;
+			const beforeExists = existsSync(filePath);
+			storedChanges.push({
+				filePath,
+				beforeHash: beforeExists ? sha256(beforeText) : null,
+				afterHash: sha256(change.afterText),
+				beforeExists,
+				beforeBytes: beforeText.length,
+				afterBytes: change.afterText.length,
+				afterText: change.afterText,
+				diff: formatDiff(filePath, beforeText, change.afterText)
+			});
+		}
+		const summary = {
+			files: storedChanges.length,
+			bytesBefore: storedChanges.reduce((total, change) => total + change.beforeBytes, 0),
+			bytesAfter: storedChanges.reduce((total, change) => total + change.afterBytes, 0)
+		};
+		if (!storedChanges.length) return {
+			changes: [],
+			summary
+		};
+		const confirmToken = randomBytes(24).toString("base64url");
+		const createdAt = Date.now();
+		const expiresAt = createdAt + ttl;
+		this.previews.set(confirmToken, {
+			confirmToken,
+			createdAt,
+			expiresAt,
+			changes: storedChanges
+		});
+		return {
+			confirmToken,
+			expiresAt,
+			changes: storedChanges,
+			summary
+		};
+	}
+	async applyPreview(confirmToken) {
+		const preview = this.previews.get(confirmToken);
+		if (!preview) throw new Error("Unknown or already applied preview token.");
+		if (preview.expiresAt < Date.now()) {
+			this.previews.delete(confirmToken);
+			throw new Error("Preview token has expired.");
+		}
+		for (const change of preview.changes) {
+			const filePath = await this.resolveWritableFile(change.filePath);
+			if (filePath !== change.filePath) throw new Error(`Preview path changed while applying: ${change.filePath}`);
+			const currentText = await readFileIfExists(filePath);
+			const currentExists = existsSync(filePath);
+			if (change.beforeHash === null) {
+				if (currentExists) throw new Error(`File was created after preview generation: ${filePath}`);
+			} else if (sha256(currentText) !== change.beforeHash) throw new Error(`File changed after preview generation: ${filePath}`);
+		}
+		for (const change of preview.changes) {
+			await mkdir(dirname(change.filePath), { recursive: true });
+			await writeFile(change.filePath, change.afterText);
+		}
+		this.previews.delete(confirmToken);
+		return {
+			applied: true,
+			changes: preview.changes.map(({ filePath, afterHash }) => ({
+				filePath,
+				afterHash
+			}))
+		};
+	}
+};
+async function realpath$1(filePath) {
+	try {
+		return await realpath(filePath);
+	} catch (error) {
+		throw new Error(`Unable to resolve path: ${filePath}${error instanceof Error ? ` (${error.message})` : ""}`);
+	}
+}
+async function readFileIfExists(filePath) {
+	try {
+		return await readFile(filePath, "utf8");
+	} catch (error) {
+		if (typeof error === "object" && error && "code" in error && error.code === "ENOENT") return "";
+		throw error;
+	}
+}
+//#endregion
+export { MasterCSSMCPContext as default };

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import { MasterCSSMCPServerInstance, createMasterCSSMCPServer, startStdioServer } from "./server.js";
+import MasterCSSMCPContext, { MasterCSSMCPContextOptions } from "./context.js";
+export { MasterCSSMCPContext, type MasterCSSMCPContextOptions, type MasterCSSMCPServerInstance, createMasterCSSMCPServer, startStdioServer };

package/dist/index.js

@@ -0,0 +1,3 @@
+import MasterCSSMCPContext from "./context.js";
+import { createMasterCSSMCPServer, startStdioServer } from "./server.js";
+export { MasterCSSMCPContext, createMasterCSSMCPServer, startStdioServer };

package/dist/language.d.ts

@@ -0,0 +1,25 @@
+import MasterCSSMCPContext from "./context.js";
+
+//#region src/language.d.ts
+interface SuggestSyntaxOptions {
+  content: string;
+  filePath: string;
+  position: {
+    line: number;
+    character: number;
+  };
+  triggerCharacter?: string;
+  limit?: number;
+}
+declare function suggestSyntax(context: MasterCSSMCPContext, options: SuggestSyntaxOptions): Promise<{
+  manifest: {
+    error?: string | undefined;
+    status: "loaded" | "error";
+    entries: string[];
+  };
+  completions: import("vscode-languageserver-protocol").CompletionItem[];
+  total: number;
+  hover: import("vscode-languageserver-protocol").Hover | undefined;
+}>;
+//#endregion
+export { SuggestSyntaxOptions, suggestSyntax };

package/dist/language.js

@@ -0,0 +1,46 @@
+import { loadWorkspaceManifest } from "./project.js";
+import { extname } from "node:path";
+import { pathToFileURL } from "node:url";
+import CSSLanguageService from "@master/css-language-service";
+import { TextDocument } from "vscode-languageserver-textdocument";
+//#region src/language.ts
+const languageByExtension = {
+	".astro": "astro",
+	".css": "css",
+	".htm": "html",
+	".html": "html",
+	".js": "javascript",
+	".jsx": "javascriptreact",
+	".less": "less",
+	".md": "markdown",
+	".mdx": "mdx",
+	".scss": "scss",
+	".svelte": "svelte",
+	".ts": "typescript",
+	".tsx": "typescriptreact",
+	".vue": "vue"
+};
+async function suggestSyntax(context, options) {
+	const filePath = context.resolveVirtualPath(options.filePath);
+	const manifest = await loadWorkspaceManifest(context);
+	const service = new CSSLanguageService(manifest.status === "loaded" ? { manifest: manifest.manifest } : void 0);
+	const document = TextDocument.create(pathToFileURL(filePath).href, languageByExtension[extname(filePath).toLowerCase()] || "html", 0, options.content);
+	const completions = service.suggestSyntax(document, options.position, {
+		triggerKind: options.triggerCharacter ? 2 : 1,
+		...options.triggerCharacter ? { triggerCharacter: options.triggerCharacter } : {}
+	}) ?? [];
+	const hover = service.inspectSyntax(document, options.position);
+	const limit = options.limit ?? 50;
+	return {
+		manifest: {
+			status: manifest.status,
+			entries: manifest.entries,
+			...manifest.status === "error" ? { error: manifest.error } : {}
+		},
+		completions: completions.slice(0, limit),
+		total: completions.length,
+		hover
+	};
+}
+//#endregion
+export { suggestSyntax };

package/dist/lint.d.ts

@@ -0,0 +1,56 @@
+import { MasterCSSLintFileResult, MasterCSSLintSourceDiagnostic } from "@master/css-lint";
+import MasterCSSMCPContext from "./context.js";
+
+//#region src/lint.d.ts
+interface LintProjectOptions {
+  patterns?: string[];
+  rules?: string;
+}
+interface LintContentOptions {
+  content: string;
+  filePath: string;
+  rules?: string;
+}
+interface PreviewFixesOptions extends LintProjectOptions {
+  includeDirectiveFixes?: boolean;
+  ttlMs?: number;
+}
+declare function lintProject(context: MasterCSSMCPContext, options?: LintProjectOptions): Promise<{
+  version: number;
+  root: string;
+  manifest: {
+    status: "loaded" | "error";
+    entries: string[];
+    diagnostics: MasterCSSLintSourceDiagnostic[];
+  };
+  files: MasterCSSLintFileResult[];
+  summary: import("@master/css-lint").MasterCSSLintSummary;
+}>;
+declare function lintContent(context: MasterCSSMCPContext, options: LintContentOptions): Promise<{
+  version: number;
+  root: string;
+  manifest: {
+    status: "loaded" | "error";
+    entries: string[];
+    diagnostics: MasterCSSLintSourceDiagnostic[];
+  };
+  files: MasterCSSLintFileResult[];
+  summary: import("@master/css-lint").MasterCSSLintSummary;
+}>;
+declare function previewLintFixes(context: MasterCSSMCPContext, options?: PreviewFixesOptions): Promise<{
+  mode: string;
+  preview: import("./context.js").PreviewResult;
+  lint: {
+    version: number;
+    root: string;
+    manifest: {
+      status: "loaded" | "error";
+      entries: string[];
+      diagnostics: MasterCSSLintSourceDiagnostic[];
+    };
+    files: MasterCSSLintFileResult[];
+    summary: import("@master/css-lint").MasterCSSLintSummary;
+  };
+}>;
+//#endregion
+export { LintContentOptions, LintProjectOptions, PreviewFixesOptions, lintContent, lintProject, previewLintFixes };

package/dist/lint.js

@@ -0,0 +1,132 @@
+import { loadWorkspaceManifest } from "./project.js";
+import { resolveSourceFiles } from "./scan.js";
+import { readFile } from "node:fs/promises";
+import { createCSSWithNativeDeclarations } from "@master/css-validator/native-declaration";
+import { fixMasterCSSContent, lintMasterCSSContent, resolveMasterCSSLintRules, summarizeMasterCSSLintFiles } from "@master/css-lint";
+//#region src/lint.ts
+const DEFAULT_LINT_SOURCE_PATTERNS = ["**/*.{html,htm,js,jsx,cjs,ts,tsx,mts,cts,svelte,astro,vue,md,mdx,pug,php,css,scss,less}"];
+const DEFAULT_IGNORE_PATTERNS = ["**/node_modules/**", "node_modules"];
+const LINT_REPORT_VERSION = 1;
+function createManifestDiagnostic(context, message) {
+	return {
+		ruleId: "manifest",
+		code: "manifest-loading-error",
+		severity: "error",
+		message,
+		range: {
+			start: 0,
+			end: 0
+		},
+		loc: {
+			start: {
+				line: 1,
+				column: 1
+			},
+			end: {
+				line: 1,
+				column: 1
+			}
+		},
+		source: "Master CSS",
+		sourceKind: "manifest",
+		data: { cwd: context.root }
+	};
+}
+async function loadLintState(context, options = {}) {
+	const rules = resolveMasterCSSLintRules(options.rules);
+	const manifest = await loadWorkspaceManifest(context);
+	const css = manifest.status === "loaded" ? createCSSWithNativeDeclarations(manifest.manifest) : void 0;
+	const files = await resolveSourceFiles(context, options.patterns ?? DEFAULT_LINT_SOURCE_PATTERNS, options.patterns ? [] : DEFAULT_IGNORE_PATTERNS);
+	return {
+		rules,
+		manifest,
+		css,
+		inputs: await Promise.all(files.map(async (filePath) => ({
+			filePath,
+			content: await readFile(filePath, "utf8")
+		})))
+	};
+}
+function lintInputs(inputs, css, rules) {
+	return inputs.map((input) => lintMasterCSSContent({
+		content: input.content,
+		filePath: input.filePath,
+		css,
+		rules
+	})).filter((result) => result.diagnostics.length);
+}
+function createManifestFileResult(context, diagnostic) {
+	return {
+		filePath: context.root,
+		languageId: "manifest",
+		sourceKind: "manifest",
+		diagnostics: [diagnostic]
+	};
+}
+async function lintProject(context, options = {}) {
+	const state = await loadLintState(context, options);
+	const files = state.manifest.status === "error" || !state.css ? [createManifestFileResult(context, createManifestDiagnostic(context, `Failed to load Master CSS manifest: ${state.manifest.error}`))] : lintInputs(state.inputs, state.css, state.rules);
+	return {
+		version: LINT_REPORT_VERSION,
+		root: context.root,
+		manifest: {
+			status: state.manifest.status,
+			entries: state.manifest.entries,
+			diagnostics: state.manifest.status === "error" ? files[0].diagnostics : []
+		},
+		files,
+		summary: summarizeMasterCSSLintFiles(files)
+	};
+}
+async function lintContent(context, options) {
+	const rules = resolveMasterCSSLintRules(options.rules);
+	const filePath = context.resolveVirtualPath(options.filePath);
+	const manifest = await loadWorkspaceManifest(context);
+	const files = manifest.status === "error" ? [createManifestFileResult(context, createManifestDiagnostic(context, `Failed to load Master CSS manifest: ${manifest.error}`))] : [lintMasterCSSContent({
+		content: options.content,
+		filePath,
+		css: createCSSWithNativeDeclarations(manifest.manifest),
+		rules
+	})];
+	return {
+		version: LINT_REPORT_VERSION,
+		root: context.root,
+		manifest: {
+			status: manifest.status,
+			entries: manifest.entries,
+			diagnostics: manifest.status === "error" ? files[0].diagnostics : []
+		},
+		files,
+		summary: summarizeMasterCSSLintFiles(files)
+	};
+}
+async function previewLintFixes(context, options = {}) {
+	const state = await loadLintState(context, options);
+	if (state.manifest.status === "error" || !state.css) return {
+		mode: "lint-fixes",
+		preview: await context.createPreview([], options.ttlMs),
+		lint: await lintProject(context, options)
+	};
+	const changes = [];
+	for (const input of state.inputs) {
+		const fixed = fixMasterCSSContent({
+			content: input.content,
+			filePath: input.filePath,
+			css: state.css,
+			rules: state.rules,
+			includeDirectiveFixes: Boolean(options.includeDirectiveFixes)
+		});
+		if (fixed !== input.content) changes.push({
+			filePath: input.filePath,
+			beforeText: input.content,
+			afterText: fixed
+		});
+	}
+	return {
+		mode: "lint-fixes",
+		preview: await context.createPreview(changes, options.ttlMs),
+		lint: await lintProject(context, options)
+	};
+}
+//#endregion
+export { lintContent, lintProject, previewLintFixes };