@master/css-mcp 2.0.0-rc.88 → 2.0.0

package/dist/server.js

@@ -1,23 +1,47 @@
-import { jsonResourceResult, jsonToolResult } from "./result.js";
+import MasterCSSMCPContext from "./context.js";
+import { executeTool, jsonResourceResult } from "./result.js";
 import { getWorkspaceInfo, loadWorkspaceManifest } from "./project.js";
 import { inspectClass, previewGeneratedCSS, renderCSS, scanProject } from "./scan.js";
-import { extractClasses, traceClass } from "./classes.js";
-import { compareCSS } from "./compare.js";
-import MasterCSSMCPContext from "./context.js";
-import { getChangeImpact, getPackageGraph, getRepoContext, getTestRouter } from "./contributor.js";
-import { inspectDirectives } from "./directives.js";
-import { previewDirectiveFormat } from "./format.js";
 import { suggestSyntax } from "./language.js";
 import { lintContent, lintProject, previewLintFixes } from "./lint.js";
 import { auditSetup } from "./setup.js";
+import { inspectDirectives } from "./directives.js";
+import { extractClasses, traceClass } from "./classes.js";
 import { queryManifest } from "./manifest-query.js";
+import { previewDirectiveFormat } from "./format.js";
+import { compareCSS } from "./compare.js";
+import { projectSnapshot } from "./project-comparison-schema.js";
+import { designSystemOptions } from "./design-system-schema.js";
+import { toolOutputSchema } from "./output-schema.js";
+import { suggestClasses } from "./suggest.js";
+import { readFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { readFileSync } from "node:fs";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import * as z from "zod/v4";
-//#region src/server.ts
+// src/server.ts
+var MasterCSSMCPServer = class {
+	#server;
+	#context;
+	#disposed = false;
+	constructor(server, context) {
+		this.#server = server;
+		this.#context = context;
+	}
+	connect(transport) {
+		return this.#server.connect(transport);
+	}
+	async dispose() {
+		if (this.#disposed) return;
+		this.#disposed = true;
+		this.#context.dispose();
+		await this.#server.close();
+	}
+	[Symbol.asyncDispose]() {
+		return this.dispose();
+	}
+};
 function readPackageVersion() {
 	const directory = dirname(fileURLToPath(import.meta.url));
 	try {
@@ -48,7 +72,8 @@ function registerResources(server, context) {
 		description: "Resolved Master CSS package locations for this workspace.",
 		mimeType: "application/json"
 	}, async (uri) => {
-		return jsonResourceResult(uri, (await getWorkspaceInfo(context)).packages);
+		const info = await getWorkspaceInfo(context);
+		return jsonResourceResult(uri, info.packages);
 	});
 }
 function registerPrompts(server) {
@@ -74,21 +99,39 @@ function registerPrompts(server) {
 	}] }));
 	server.registerPrompt("migrate-to-mastercss", {
 		title: "Migrate To Master CSS",
-		description: "Plan a migration from existing markup/styles to Master CSS classes."
+		description: "Plan a conversion from an external styling system to current Master CSS."
 	}, () => ({ messages: [{
 		role: "user",
 		content: {
 			type: "text",
 			text: [
-				"Use the Master CSS MCP tools to plan an incremental migration to Master CSS before editing.",
+				"Use the Master CSS MCP tools to plan a migration from CSS, CSS Modules, Sass, Tailwind CSS, CSS-in-JS, or component-library styling to current Master CSS before editing.",
+				"This workflow accepts external styling systems only. A project whose only styling system is Master CSS is outside its scope. Do not propose Master CSS version upgrades or invoke a version-conversion command.",
+				"Named tokens use hyphens; native declarations use a parenthesized (property:value) head with full native CSS properties and explicit var() references. Verify target syntax against the current project manifest, preserve cascade behavior, and leave uncertain dynamic or custom syntax for manual review.",
 				"Inspect the workspace, identify the framework, package manager, current styling systems, stylesheet entries, source extraction coverage, existing theme tokens, component classes, and available validation commands.",
 				"Produce a migration plan with the recommended rendering mode, the first reviewable migration batch, CSS output risks, manual visual checks, and the formatter, lint, type-check, test, or build commands to run.",
+				"Define utility tokens as direct custom properties in top-level @theme, with optional static retention or inline substitution. Keep selectors and conditions in native CSS outside @theme. Native custom properties do not register utility names.",
 				"Preserve CSS output unless a deliberate behavior change is requested, keep vendor or generated CSS in place, and use write previews only for safe, scoped changes."
 			].join("\n")
 		}
 	}] }));
 }
 function registerTools(server, context) {
+	server.registerTool("mastercss_suggest_classes", {
+		title: "Suggest Master CSS Classes",
+		description: "Suggest project-aware classes for an isolated CSS declaration block. Preserves the complete block when conversion needs review. Checks declaration output, not surrounding cascade or browser rendering. Does not write files.",
+		inputSchema: {
+			declarations: z.string().max(32768),
+			context: z.enum(["project", "preset"]).optional()
+		},
+		outputSchema: toolOutputSchema("mastercss_suggest_classes"),
+		annotations: {
+			readOnlyHint: true,
+			destructiveHint: false,
+			idempotentHint: true,
+			openWorldHint: false
+		}
+	}, async (input) => executeTool(() => suggestClasses(context, input)));
 	const rangeSchema = z.object({
 		start: z.object({
 			line: z.number().int().min(0),
@@ -102,249 +145,216 @@ function registerTools(server, context) {
 	server.registerTool("mastercss_workspace_info", {
 		title: "Master CSS Workspace Info",
 		description: "Report workspace roots, resolved Master CSS packages, and project manifest status.",
+		outputSchema: toolOutputSchema("mastercss_workspace_info"),
 		annotations: {
 			readOnlyHint: true,
 			destructiveHint: false,
 			idempotentHint: true,
 			openWorldHint: false
 		}
-	}, async () => jsonToolResult(await getWorkspaceInfo(context)));
+	}, async () => executeTool(() => getWorkspaceInfo(context)));
 	server.registerTool("mastercss_setup_audit", {
 		title: "Audit Master CSS Setup",
 		description: "Audit package, entry stylesheet, manifest, integration, and package-resolution setup for a workspace.",
+		outputSchema: toolOutputSchema("mastercss_setup_audit"),
 		annotations: {
 			readOnlyHint: true,
 			destructiveHint: false,
 			idempotentHint: true,
 			openWorldHint: false
 		}
-	}, async () => jsonToolResult(await auditSetup(context)));
+	}, async () => executeTool(() => auditSetup(context)));
 	server.registerTool("mastercss_inspect_class", {
 		title: "Inspect Master CSS Class",
 		description: "Inspect one Master CSS class and return semantic parts, generated rules, variables, and CSS text.",
 		inputSchema: {
-			className: z.string().min(1),
-			mode: z.string().optional()
+			context: z.enum(["project", "preset"]).optional(),
+			className: z.string().min(1)
 		},
+		outputSchema: toolOutputSchema("mastercss_inspect_class"),
 		annotations: {
 			readOnlyHint: true,
 			destructiveHint: false,
 			idempotentHint: true,
 			openWorldHint: false
 		}
-	}, async (input) => jsonToolResult(await inspectClass(context, input)));
+	}, async (input) => executeTool(() => inspectClass(context, input)));
 	server.registerTool("mastercss_trace_class", {
 		title: "Trace Master CSS Class",
 		description: "Trace one class from project extraction through generated CSS, missing CSS classification, and engine inspection.",
 		inputSchema: {
+			context: z.enum(["project", "preset"]).optional(),
 			className: z.string().min(1),
 			patterns: z.array(z.string()).optional(),
-			includeCss: z.boolean().optional(),
-			mode: z.string().optional()
+			includeCss: z.boolean().optional()
 		},
+		outputSchema: toolOutputSchema("mastercss_trace_class"),
 		annotations: {
 			readOnlyHint: true,
 			destructiveHint: false,
 			idempotentHint: true,
 			openWorldHint: false
 		}
-	}, async (input) => jsonToolResult(await traceClass(context, input)));
+	}, async (input) => executeTool(() => traceClass(context, input)));
 	server.registerTool("mastercss_extract_classes", {
 		title: "Extract Master CSS Classes",
 		description: "Extract class positions and validation summaries from project files or an in-memory source buffer.",
 		inputSchema: {
+			context: z.enum(["project", "preset"]).optional(),
 			content: z.string().optional(),
 			filePath: z.string().optional(),
 			patterns: z.array(z.string()).optional(),
 			includeRules: z.boolean().optional()
 		},
+		outputSchema: toolOutputSchema("mastercss_extract_classes"),
 		annotations: {
 			readOnlyHint: true,
 			destructiveHint: false,
 			idempotentHint: true,
 			openWorldHint: false
 		}
-	}, async (input) => jsonToolResult(await extractClasses(context, input)));
+	}, async (input) => executeTool(() => extractClasses(context, input)));
 	server.registerTool("mastercss_inspect_directives", {
 		title: "Inspect Master CSS Directives",
 		description: "Inspect CSS-first directives from a stylesheet entry or in-memory CSS content and report manifest/CSS effects.",
 		inputSchema: {
+			context: z.enum(["project", "preset"]).optional(),
 			content: z.string().optional(),
 			filePath: z.string().optional(),
 			entryPath: z.string().optional(),
 			preserveNativeCSS: z.boolean().optional()
 		},
+		outputSchema: toolOutputSchema("mastercss_inspect_directives"),
 		annotations: {
 			readOnlyHint: true,
 			destructiveHint: false,
 			idempotentHint: true,
 			openWorldHint: false
 		}
-	}, async (input) => jsonToolResult(await inspectDirectives(context, input)));
+	}, async (input) => executeTool(() => inspectDirectives(context, input)));
 	server.registerTool("mastercss_render_css", {
 		title: "Render Master CSS",
 		description: "Generate CSS from an HTML fragment or a whitespace-separated class list.",
 		inputSchema: {
+			context: z.enum(["project", "preset"]).optional(),
 			html: z.string().optional(),
 			classList: z.string().optional()
 		},
+		outputSchema: toolOutputSchema("mastercss_render_css"),
 		annotations: {
 			readOnlyHint: true,
 			destructiveHint: false,
 			idempotentHint: true,
 			openWorldHint: false
 		}
-	}, async (input) => jsonToolResult(await renderCSS(context, input)));
+	}, async (input) => executeTool(() => renderCSS(context, input)));
 	server.registerTool("mastercss_scan_project", {
 		title: "Scan Master CSS Project",
-		description: "Scan source files, register stylesheet entries, and report scanner state and generated CSS metadata.",
+		description: "Scan source files and stylesheet entries. Set includeSnapshot to capture a resolved project state for later impact comparison. Pass designSystem to inspect stylesheet token references and design policies; add routeStylesheets globs for stylesheets imported from JavaScript.",
 		inputSchema: {
+			context: z.enum(["project", "preset"]).optional(),
 			patterns: z.array(z.string()).optional(),
 			classes: z.array(z.string()).optional(),
-			includeCss: z.boolean().optional()
-		},
-		annotations: {
-			readOnlyHint: true,
-			destructiveHint: false,
-			idempotentHint: true,
-			openWorldHint: false
-		}
-	}, async (input) => jsonToolResult(await scanProject(context, input)));
-	server.registerTool("mastercss_repo_context", {
-		title: "Master CSS Repository Context",
-		description: "Route Master CSS repository contributor work to affected packages, required context files, risks, and validation commands.",
-		inputSchema: {
-			task: z.string().optional(),
-			paths: z.array(z.string()).optional(),
-			diff: z.string().optional()
-		},
-		annotations: {
-			readOnlyHint: true,
-			destructiveHint: false,
-			idempotentHint: true,
-			openWorldHint: false
-		}
-	}, async (input) => jsonToolResult(await getRepoContext(context, input)));
-	server.registerTool("mastercss_change_impact", {
-		title: "Master CSS Change Impact",
-		description: "Classify contributor change risk for CSS output, runtime, extraction, language, ESLint, docs, and package boundaries.",
-		inputSchema: {
-			task: z.string().optional(),
-			paths: z.array(z.string()).optional(),
-			diff: z.string().optional()
-		},
-		annotations: {
-			readOnlyHint: true,
-			destructiveHint: false,
-			idempotentHint: true,
-			openWorldHint: false
-		}
-	}, async (input) => jsonToolResult(await getChangeImpact(context, input)));
-	server.registerTool("mastercss_test_router", {
-		title: "Master CSS Test Router",
-		description: "Return focused validation commands for Master CSS repository contributor changes.",
-		inputSchema: {
-			task: z.string().optional(),
-			paths: z.array(z.string()).optional(),
-			diff: z.string().optional()
-		},
-		annotations: {
-			readOnlyHint: true,
-			destructiveHint: false,
-			idempotentHint: true,
-			openWorldHint: false
-		}
-	}, async (input) => jsonToolResult(await getTestRouter(context, input)));
-	server.registerTool("mastercss_package_graph", {
-		title: "Master CSS Package Graph",
-		description: "Report Master CSS workspace package ownership, scripts, exports, workspace dependencies, and dependents.",
-		inputSchema: {
-			packageName: z.string().optional(),
-			includeExamples: z.boolean().optional()
+			includeCss: z.boolean().optional(),
+			includeSnapshot: z.boolean().optional(),
+			designSystem: designSystemOptions.optional(),
+			routeStylesheets: z.array(z.string()).optional()
 		},
+		outputSchema: toolOutputSchema("mastercss_scan_project"),
 		annotations: {
 			readOnlyHint: true,
 			destructiveHint: false,
 			idempotentHint: true,
 			openWorldHint: false
 		}
-	}, async (input) => jsonToolResult(await getPackageGraph(context, input)));
+	}, async (input) => executeTool(() => scanProject(context, input)));
 	server.registerTool("mastercss_manifest_query", {
 		title: "Query Master CSS Manifest",
-		description: "Query active manifest tokens, utilities, variants, modes, conditions, and aliases.",
+		description: "Query active manifest tokens, utilities, mixins, custom media, custom containers, and token families.",
 		inputSchema: {
+			context: z.enum(["project", "preset"]).optional(),
 			query: z.string().optional(),
 			kind: z.enum([
 				"all",
 				"token",
 				"utility",
-				"variant",
-				"mode",
-				"condition",
-				"alias"
+				"mixin",
+				"custom-media",
+				"custom-container",
+				"family"
 			]).optional(),
 			namespace: z.string().optional(),
 			limit: z.number().int().min(1).max(500).optional()
 		},
+		outputSchema: toolOutputSchema("mastercss_manifest_query"),
 		annotations: {
 			readOnlyHint: true,
 			destructiveHint: false,
 			idempotentHint: true,
 			openWorldHint: false
 		}
-	}, async (input) => jsonToolResult(await queryManifest(context, input)));
+	}, async (input) => executeTool(() => queryManifest(context, input)));
 	server.registerTool("mastercss_css_compare", {
 		title: "Compare Master CSS Output",
-		description: "Compare generated CSS for before/after class lists, HTML fragments, or source buffers.",
+		description: "Compare class lists or source buffers under one manifest, or pass beforeSnapshot and afterSnapshot to compare resolved projects, including changed definitions and known consumers. Does not verify browser rendering.",
 		inputSchema: {
+			context: z.enum(["project", "preset"]).optional(),
 			beforeClassList: z.string().optional(),
 			afterClassList: z.string().optional(),
 			beforeHtml: z.string().optional(),
 			afterHtml: z.string().optional(),
 			beforeContent: z.string().optional(),
 			afterContent: z.string().optional(),
+			beforeSnapshot: projectSnapshot.optional(),
+			afterSnapshot: projectSnapshot.optional(),
 			filePath: z.string().optional()
 		},
+		outputSchema: toolOutputSchema("mastercss_css_compare"),
 		annotations: {
 			readOnlyHint: true,
 			destructiveHint: false,
 			idempotentHint: true,
 			openWorldHint: false
 		}
-	}, async (input) => jsonToolResult(await compareCSS(context, input)));
+	}, async (input) => executeTool(() => compareCSS(context, input)));
 	server.registerTool("mastercss_lint_project", {
 		title: "Lint Master CSS Project",
 		description: "Run Master CSS class-list diagnostics and return fix proposals without writing files.",
 		inputSchema: {
+			context: z.enum(["project", "preset"]).optional(),
 			patterns: z.array(z.string()).optional(),
 			rules: z.string().optional()
 		},
+		outputSchema: toolOutputSchema("mastercss_lint_project"),
 		annotations: {
 			readOnlyHint: true,
 			destructiveHint: false,
 			idempotentHint: true,
 			openWorldHint: false
 		}
-	}, async (input) => jsonToolResult(await lintProject(context, input)));
+	}, async (input) => executeTool(() => lintProject(context, input)));
 	server.registerTool("mastercss_lint_content", {
 		title: "Lint Master CSS Content",
 		description: "Run Master CSS class-list diagnostics on an in-memory source buffer without writing files.",
 		inputSchema: {
+			context: z.enum(["project", "preset"]).optional(),
 			content: z.string(),
 			filePath: z.string(),
 			rules: z.string().optional()
 		},
+		outputSchema: toolOutputSchema("mastercss_lint_content"),
 		annotations: {
 			readOnlyHint: true,
 			destructiveHint: false,
 			idempotentHint: true,
 			openWorldHint: false
 		}
-	}, async (input) => jsonToolResult(await lintContent(context, input)));
+	}, async (input) => executeTool(() => lintContent(context, input)));
 	server.registerTool("mastercss_suggest_syntax", {
 		title: "Suggest Master CSS Syntax",
 		description: "Return language-service completions and hover context for a document position.",
 		inputSchema: {
+			context: z.enum(["project", "preset"]).optional(),
 			content: z.string(),
 			filePath: z.string(),
 			position: z.object({
@@ -354,24 +364,26 @@ function registerTools(server, context) {
 			triggerCharacter: z.string().optional(),
 			limit: z.number().int().min(1).max(200).optional()
 		},
+		outputSchema: toolOutputSchema("mastercss_suggest_syntax"),
 		annotations: {
 			readOnlyHint: true,
 			destructiveHint: false,
 			idempotentHint: true,
 			openWorldHint: false
 		}
-	}, async (input) => jsonToolResult(await suggestSyntax(context, input)));
+	}, async (input) => executeTool(() => suggestSyntax(context, input)));
 	server.registerTool("mastercss_preview_fixes", {
 		title: "Preview Master CSS Fixes",
 		description: "Create a diff preview for lint fixes or generated CSS output and return a confirmation token.",
 		inputSchema: {
+			context: z.enum(["project", "preset"]).optional(),
 			mode: z.enum(["lint-fixes", "generated-css"]).optional(),
 			patterns: z.array(z.string()).optional(),
 			rules: z.string().optional(),
-			includeDirectiveFixes: z.boolean().optional(),
 			outputPath: z.string().optional(),
-			ttlMs: z.number().int().min(1e3).max(3600 * 1e3).optional()
+			ttlMs: z.number().int().min(1e3).max(36e5).optional()
 		},
+		outputSchema: toolOutputSchema("mastercss_preview_fixes"),
 		annotations: {
 			readOnlyHint: false,
 			destructiveHint: false,
@@ -381,43 +393,47 @@ function registerTools(server, context) {
 	}, async (input) => {
 		if (input.mode === "generated-css") {
 			if (!input.outputPath) throw new Error("outputPath is required when mode is \"generated-css\".");
-			return jsonToolResult(await previewGeneratedCSS(context, {
+			return executeTool(() => previewGeneratedCSS(context, {
+				context: input.context,
 				patterns: input.patterns,
 				includeCss: true,
 				outputPath: input.outputPath,
 				ttlMs: input.ttlMs
 			}));
 		}
-		return jsonToolResult(await previewLintFixes(context, input));
+		return executeTool(() => previewLintFixes(context, input));
 	});
 	server.registerTool("mastercss_preview_directive_format", {
 		title: "Preview Master CSS Directive Format",
 		description: "Create a safe preview for formatting Master CSS directives, or format in-memory content without writing files.",
 		inputSchema: {
+			context: z.enum(["project", "preset"]).optional(),
 			content: z.string().optional(),
 			filePath: z.string().optional(),
 			patterns: z.array(z.string()).optional(),
 			range: rangeSchema.optional(),
-			ttlMs: z.number().int().min(1e3).max(3600 * 1e3).optional()
+			ttlMs: z.number().int().min(1e3).max(36e5).optional()
 		},
+		outputSchema: toolOutputSchema("mastercss_preview_directive_format"),
 		annotations: {
 			readOnlyHint: false,
 			destructiveHint: false,
 			idempotentHint: false,
 			openWorldHint: false
 		}
-	}, async (input) => jsonToolResult(await previewDirectiveFormat(context, input)));
+	}, async (input) => executeTool(() => previewDirectiveFormat(context, input)));
 	server.registerTool("mastercss_apply_preview", {
 		title: "Apply Master CSS Preview",
 		description: "Apply a previously generated preview token after validating hashes and workspace containment.",
 		inputSchema: { confirmToken: z.string().min(1) },
+		outputSchema: toolOutputSchema("mastercss_apply_preview"),
 		annotations: {
 			readOnlyHint: false,
 			destructiveHint: true,
 			idempotentHint: false,
 			openWorldHint: false
 		}
-	}, async (input) => jsonToolResult(await context.applyPreview(input.confirmToken)));
+	}, async (input) => executeTool(() => context.applyPreview(input.confirmToken)));
 }
 function createMasterCSSMCPServer(options = {}) {
 	const context = new MasterCSSMCPContext(options);
@@ -428,16 +444,12 @@ function createMasterCSSMCPServer(options = {}) {
 	registerResources(server, context);
 	registerPrompts(server);
 	registerTools(server, context);
-	return {
-		server,
-		context
-	};
+	return new MasterCSSMCPServer(server, context);
 }
-async function startStdioServer(options = {}) {
-	const { server } = createMasterCSSMCPServer(options);
+async function startMasterCSSMCPStdioServer(options = {}) {
+	const server = createMasterCSSMCPServer(options);
 	const transport = new StdioServerTransport();
 	await server.connect(transport);
 	return server;
 }
-//#endregion
-export { createMasterCSSMCPServer, startStdioServer };
+export { createMasterCSSMCPServer, startMasterCSSMCPStdioServer };

package/dist/setup.js

@@ -1,17 +1,17 @@
+import { resolveMasterCSSWorkspacePackages } from "./internal/src/workspace.js";
 import { getErrorMessage } from "./result.js";
-import { loadWorkspaceManifest } from "./project.js";
-import { readFile } from "node:fs/promises";
-import { join } from "node:path";
-import { findCSSManifestEntryFiles } from "@master/css-project/entries";
-import { resolveMasterCSSWorkspacePackages } from "@master/css-project/workspace";
+import { loadWorkspaceManifest, manifestMetadata } from "./project.js";
 import { existsSync } from "node:fs";
-//#region src/setup.ts
+import { join } from "node:path";
+import { readFile } from "node:fs/promises";
+import { discoverManifestEntries } from "@master/css-compiler/project";
+// src/setup.ts
 const SETUP_AUDIT_VERSION = 1;
 const LOCKFILES = {
-	pnpm: "pnpm-lock.yaml",
-	npm: "package-lock.json",
-	yarn: "yarn.lock",
-	bun: "bun.lockb"
+	pnpm: ["pnpm-lock.yaml"],
+	npm: ["package-lock.json"],
+	yarn: ["yarn.lock"],
+	bun: ["bun.lock", "bun.lockb"]
 };
 const MASTER_CSS_PACKAGES = [
 	"@master/css",
@@ -20,28 +20,27 @@ const MASTER_CSS_PACKAGES = [
 	"@master/create-css",
 	"@master/css-runtime",
 	"@master/css-language-server",
-	"@master/css.vite",
-	"@master/css.webpack",
-	"@master/css.next",
-	"@master/css.nuxt",
-	"@master/css.astro",
-	"@master/css.svelte",
-	"@master/css-sv",
+	"@master/css-vite",
+	"@master/css-webpack",
+	"@master/css-next",
+	"@master/css-nuxt",
+	"@master/css-astro",
+	"@master/css-svelte",
+	"@master/css-svelte-addon",
 	"@master/eslint-config-css",
 	"@master/eslint-plugin-css"
 ];
 const INTEGRATION_PACKAGES = [
 	"@master/css-cli",
-	"@master/css.vite",
-	"@master/css.webpack",
-	"@master/css.next",
-	"@master/css.nuxt",
-	"@master/css.astro",
-	"@master/css.svelte",
-	"@master/eslint-config-css",
-	"@master/eslint-plugin-css"
+	"@master/css-vite",
+	"@master/css-webpack",
+	"@master/css-next",
+	"@master/css-nuxt",
+	"@master/css-astro",
+	"@master/css-svelte",
+	"@master/eslint-config-css"
 ];
-const SETUP_PACKAGES = ["@master/create-css", "@master/css-sv"];
+const SETUP_PACKAGES = ["@master/create-css", "@master/css-svelte-addon"];
 function getDependencies(packageJSON) {
 	return {
 		...packageJSON?.dependencies,
@@ -65,7 +64,7 @@ async function readPackageJSON(context) {
 	}
 }
 function detectPackageManager(context, packageJSON) {
-	const lockfiles = Object.entries(LOCKFILES).filter(([, filename]) => existsSync(join(context.root, filename))).map(([name, filename]) => ({
+	const lockfiles = Object.entries(LOCKFILES).flatMap(([name, filenames]) => filenames.map((filename) => [name, filename])).filter(([, filename]) => existsSync(join(context.root, filename))).map(([name, filename]) => ({
 		name,
 		filePath: join(context.root, filename)
 	}));
@@ -122,7 +121,7 @@ async function auditSetup(context) {
 	const [packageJSONResult, manifest, discoveredEntries] = await Promise.all([
 		readPackageJSON(context),
 		loadWorkspaceManifest(context),
-		findCSSManifestEntryFiles(context.root).catch(() => [])
+		discoverManifestEntries({ root: context.root }).catch(() => [])
 	]);
 	const packageJSON = packageJSONResult.value;
 	const packageManager = detectPackageManager(context, packageJSON);
@@ -160,6 +159,7 @@ async function auditSetup(context) {
 		},
 		integrations,
 		manifest: {
+			...manifestMetadata(manifest),
 			status: manifest.status,
 			entries: manifest.entries.length ? manifest.entries : discoveredEntries,
 			dependencies: manifest.dependencies,
@@ -179,5 +179,4 @@ async function auditSetup(context) {
 		}
 	};
 }
-//#endregion
 export { auditSetup };