onsystem 0.4.0 → 0.5.0

package/dist/{stdio-BcJth14k.js → design-system-CnEv5sIL.js}

@@ -1,6 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
+import { pathToFileURL } from "node:url";
 import * as z from "zod";
 import { escapePath, glob, globSync } from "tinyglobby";
 import ts from "typescript";
@@ -10,8 +10,6 @@ import fs$1 from "node:fs/promises";
 import os from "node:os";
 import postcss from "postcss";
 import { stemmer } from "stemmer";
-import { McpServer, ResourceTemplate } from "@modelcontextprotocol/server";
-import { serveStdio } from "@modelcontextprotocol/server/stdio";
 //#region src/extract/program.ts
 const DEFAULT_OPTIONS = {
 	target: ts.ScriptTarget.ES2022,
@@ -756,7 +754,7 @@ function fromComponentsJson(root, dir, json, project, packages, note = ignore) {
 	let uiDir = resolveThroughPaths(ui, project);
 	let imports = [];
 	if (!uiDir) {
-		const name = packageName$1(ui);
+		const name = packageName(ui);
 		const pkgDir = name ? packages.find(name) : void 0;
 		const pkg = pkgDir ? readJson(path.join(pkgDir, "package.json")) : void 0;
 		if (!name || !pkgDir || !pkg) {
@@ -1027,7 +1025,7 @@ function resolveThroughPaths(specifier, project) {
 		const middle = star === -1 ? "" : specifier.slice(prefix.length, specifier.length - suffix.length);
 		for (const target of targets) {
 			const dir = path.resolve(project.pathsBase, target.replace("*", middle));
-			if (isDirectory$2(dir)) return dir;
+			if (isDirectory$1(dir)) return dir;
 		}
 	}
 }
@@ -1038,16 +1036,16 @@ function resolveThroughExports(specifier, imports, root) {
 		if (star === -1) continue;
 		if (specifier !== mapping.specifier.slice(0, star).replace(/\/$/, "")) continue;
 		const dir = path.resolve(root, mapping.target.slice(0, mapping.target.indexOf("*")));
-		if (isDirectory$2(dir)) return dir;
+		if (isDirectory$1(dir)) return dir;
 	}
 }
 /** `/components` under a package: the folder itself, or under `src`. */
 function subpathDir(pkgDir, subpath) {
 	const rel = subpath.replace(/^\//, "");
-	return [path.join(pkgDir, rel), path.join(pkgDir, "src", rel)].find(isDirectory$2);
+	return [path.join(pkgDir, rel), path.join(pkgDir, "src", rel)].find(isDirectory$1);
 }
 /** `@scope/name/sub` → `@scope/name`; `name/sub` → `name`; aliases such as `@/x` and `~/x` → undefined. */
-function packageName$1(specifier) {
+function packageName(specifier) {
 	const [first = "", second] = specifier.split("/");
 	if (first.startsWith("@")) return first.length > 1 && second ? `${first}/${second}` : void 0;
 	return /^[a-z0-9]/i.test(first) ? first : void 0;
@@ -1062,7 +1060,7 @@ function moduleResolver(root) {
 	const packages = new PackageFinder(root);
 	return (specifier, fromFile) => {
 		if (specifier.startsWith(".")) return moduleFile(path.resolve(path.dirname(fromFile), specifier));
-		const name = packageName$1(specifier);
+		const name = packageName(specifier);
 		const dir = name ? packages.find(name) : void 0;
 		if (!name || !dir) return void 0;
 		const subpath = specifier.slice(name.length + 1);
@@ -1083,7 +1081,7 @@ function workspaceModule(root) {
 	return (specifier, fromFile) => {
 		const file = resolve(specifier, fromFile);
 		if (file) return { file };
-		const name = packageName$1(specifier);
+		const name = packageName(specifier);
 		const dir = name ? packages.find(name) : void 0;
 		if (!name || !dir) return void 0;
 		const source = moduleFile(path.join(dir, "src", specifier.slice(name.length + 1) || "index"));
@@ -1249,7 +1247,7 @@ function isFile(file) {
 		return false;
 	}
 }
-function isDirectory$2(dir) {
+function isDirectory$1(dir) {
 	try {
 		return fs.statSync(dir).isDirectory();
 	} catch {
@@ -1841,13 +1839,14 @@ async function loadConfig(options = {}) {
 	let raw = {};
 	if (configFile) {
 		if (!fs.existsSync(configFile)) throw new ConfigError(`Config file not found: ${configFile}`);
+		if (options.jsonConfigOnly && !configFile.endsWith(".json")) throw new ConfigError(`${configFile} was not run: the server runs a JavaScript or TypeScript config only in a project it was started in (its working directory, --root or the client's roots), not in one found from the path a tool call names. Start the server in the project, or use onsystem.config.json.`);
 		raw = await readConfigFile(configFile);
 	}
 	const parsed = configSchema.safeParse(raw);
 	if (!parsed.success) throw new ConfigError(`Invalid config in ${configFile ?? "(defaults)"}:\n${z.prettifyError(parsed.error)}`);
 	const config = parsed.data;
 	const root = options.root ? path.resolve(cwd, options.root) : configFile ? path.dirname(configFile) : cwd;
-	if (!isDirectory$1(root)) throw new ConfigError(`Project root not found: ${root}`);
+	if (!isDirectory(root)) throw new ConfigError(`Project root not found: ${root}`);
 	const base = options.base ? path.resolve(cwd, options.base) : root;
 	const inherited = base !== root;
 	const fromBase = (p) => inherited ? toPosix(path.relative(root, path.resolve(base, slashGlob(p)))) || "." : p;
@@ -1963,7 +1962,7 @@ async function readConfigFile(file) {
 		throw new ConfigError(`Could not load ${file}: ${message}.${message.includes("@dgesteves/design-system-mcp") ? " The package is now onsystem: import { defineConfig } from 'onsystem'." : /\.m?ts$/.test(file) ? " TypeScript configs need Node.js 22.18+ (type stripping); use JSON or .mjs otherwise." : ""}`);
 	}
 }
-function isDirectory$1(dir) {
+function isDirectory(dir) {
 	try {
 		return fs.statSync(dir).isDirectory();
 	} catch {
@@ -3937,7 +3936,7 @@ function parseDtcgTokens(text, file, options = {}) {
 			warnings: [`${file}: invalid JSON (${error.message})`]
 		};
 	}
-	if (!isObject(json)) return {
+	if (!isObject$1(json)) return {
 		tokens: [],
 		warnings: [`${file}: expected a JSON object`]
 	};
@@ -3963,7 +3962,7 @@ function parseDtcgTokens(text, file, options = {}) {
 			return value;
 		}
 		if (Array.isArray(value)) return value.map((v) => resolve(v, seen));
-		if (isObject(value)) {
+		if (isObject$1(value)) {
 			const ref = value.$ref;
 			if (typeof ref === "string" && Object.keys(value).length === 1) {
 				const pointer = ref.replace(/^#\//, "").split("/").filter((p) => p !== "$value");
@@ -4028,16 +4027,16 @@ function walk(node, path, inheritedType, out, lines) {
 		return;
 	}
 	for (const [key, child] of Object.entries(node)) {
-		if (key.startsWith("$") || !isObject(child)) continue;
+		if (key.startsWith("$") || !isObject$1(child)) continue;
 		walk(child, [...path, key], type, out, lines);
 	}
 }
 /** Modes are not standardised yet; accept the common `$extensions.mode(s)` shape. */
 function modesOf(extensions) {
-	if (!isObject(extensions)) return void 0;
+	if (!isObject$1(extensions)) return void 0;
 	for (const key of ["modes", "mode"]) {
 		const value = extensions[key];
-		if (isObject(value)) return value;
+		if (isObject$1(value)) return value;
 	}
 }
 function categorize(type, path) {
@@ -4105,7 +4104,7 @@ function pct255(component) {
 	if (component === void 0 || component === "none") return "none";
 	return String(Math.round(Number(component) * 255));
 }
-function isObject(value) {
+function isObject$1(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 /**
@@ -5441,7 +5440,7 @@ const preferDesignSystemComponent = {
 			if (!component) continue;
 			if (hiddenFromUser(element)) continue;
 			if (styledByParent(element, context)) continue;
-			if (isBare$1(element)) continue;
+			if (isBare(element)) continue;
 			if (styledByOwnVariants(element, context)) continue;
 			if (enclosingComponent(element.node) === component.name) continue;
 			const dropIn = context.target.isDropIn(component, key);
@@ -5492,7 +5491,7 @@ function styledByOwnVariants(element, context) {
 * `className` or `style`: an element type to render into, not styled UI. Void elements
 * (`<input />`, `<img />`) are always self-closing and stay UI.
 */
-function isBare$1(element) {
+function isBare(element) {
 	return [
 		"button",
 		"a",
@@ -6449,16 +6448,27 @@ function lengthReplacement(context, category, px, prefix) {
 		tailwind: false
 	};
 }
-const noHardcodedSpacing = lengthRule("no-hardcoded-spacing", "Padding, margin and gap must use the spacing scale, not arbitrary px/rem values.", {
-	category: "spacing",
-	prefixes: SPACING_PREFIXES,
-	styleProperties: STYLE_SPACING_PROPERTIES
-});
-const noHardcodedRadius = lengthRule("no-hardcoded-radius", "Border radius must use radius tokens, not arbitrary values.", {
-	category: "radius",
-	prefixes: RADIUS_PREFIXES,
-	styleProperties: STYLE_RADIUS_PROPERTIES
-});
+//#endregion
+//#region src/lint/rules/index.ts
+/** Every rule, in the order they run. */
+const RULES = [
+	noHardcodedColor,
+	lengthRule("no-hardcoded-spacing", "Padding, margin and gap must use the spacing scale, not arbitrary px/rem values.", {
+		category: "spacing",
+		prefixes: SPACING_PREFIXES,
+		styleProperties: STYLE_SPACING_PROPERTIES
+	}),
+	lengthRule("no-hardcoded-radius", "Border radius must use radius tokens, not arbitrary values.", {
+		category: "radius",
+		prefixes: RADIUS_PREFIXES,
+		styleProperties: STYLE_RADIUS_PROPERTIES
+	}),
+	preferDesignSystemComponent,
+	noUnknownComponent,
+	noUnknownProp,
+	noUnknownVariant,
+	iconButtonAccessibleName
+];
 //#endregion
 //#region src/lint/suppress.ts
 /**
@@ -6536,6 +6546,265 @@ function insideLiteral(sourceFile, offset) {
 	return ts.isStringLiteralLike(node) || ts.isTemplateLiteralToken(node) || ts.isJsxText(node) || ts.isRegularExpressionLiteral(node);
 }
 //#endregion
+//#region src/baseline.ts
+const BASELINE_FILE = "onsystem.baseline.json";
+/** The baseline's name from before the rename to onsystem: still read when the new one is absent. */
+const LEGACY_BASELINE_FILE = "design-system-mcp.baseline.json";
+/**
+* A finding's identity within its file and rule: the offending text with
+* whitespace collapsed, and without the quotes of a string literal, so a
+* formatter switching quote style does not make every finding look new.
+* SARIF fingerprints use it too, so code scanning tracks a finding as a baseline does.
+*/
+function findingKey(diagnostic) {
+	const text = diagnostic.source.replace(/\s+/g, " ").trim();
+	return (/^(['"`])(.*)\1$/.exec(text)?.[2] ?? text).slice(0, 200);
+}
+/** The baseline's entries, or undefined when the file does not exist. */
+function readBaseline(file) {
+	let text;
+	try {
+		text = fs.readFileSync(file, "utf8");
+	} catch (error) {
+		if (error.code === "ENOENT") return void 0;
+		throw new ConfigError(`Could not read baseline ${file}: ${error.message}`);
+	}
+	const invalid = (why) => new ConfigError(`${file} is not a valid onsystem baseline (${why}). Fix it, or delete it and run check --update-baseline.`);
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch (error) {
+		throw invalid(error.message);
+	}
+	if (!isObject(parsed) || parsed.version !== 1) throw invalid("expected \"version\": 1");
+	if (!isObject(parsed.files)) throw invalid("\"files\" must be an object");
+	const entries = /* @__PURE__ */ new Map();
+	for (const [name, rules] of Object.entries(parsed.files)) {
+		if (!isObject(rules)) throw invalid(`"${name}" must map rules to findings`);
+		const byRule = /* @__PURE__ */ new Map();
+		for (const [rule, sources] of Object.entries(rules)) {
+			if (!isObject(sources)) throw invalid(`"${name}" › "${rule}" must map findings to counts`);
+			const counts = /* @__PURE__ */ new Map();
+			for (const [source, count] of Object.entries(sources)) {
+				if (!Number.isInteger(count) || count < 1) throw invalid(`"${name}" › "${rule}" › "${source}" must be a positive whole number`);
+				counts.set(source, count);
+			}
+			byRule.set(rule, counts);
+		}
+		entries.set(name, byRule);
+	}
+	return entries;
+}
+/**
+* Removes the findings the baseline accepts for `file`. Within a file and
+* rule, each entry accepts that many findings with the same source text, in
+* order; any beyond the count are new. Entries of `disabled` rules are not
+* counted as fixed: the rule is off, not satisfied.
+*/
+function applyBaseline(baseline, file, result, disabled = /* @__PURE__ */ new Set()) {
+	const remaining = /* @__PURE__ */ new Map();
+	for (const [rule, sources] of baseline.get(file) ?? []) {
+		if (disabled.has(rule)) continue;
+		for (const [source, count] of sources) remaining.set(`${rule}\0${source}`, count);
+	}
+	const diagnostics = [];
+	let baselined = 0;
+	for (const diagnostic of result.diagnostics) {
+		const id = `${diagnostic.ruleId}\0${findingKey(diagnostic)}`;
+		const left = remaining.get(id) ?? 0;
+		if (left > 0) {
+			remaining.set(id, left - 1);
+			baselined++;
+		} else diagnostics.push(diagnostic);
+	}
+	let fixed = 0;
+	for (const count of remaining.values()) fixed += count;
+	return {
+		result: {
+			...result,
+			diagnostics,
+			errorCount: diagnostics.filter((d) => d.severity === "error").length,
+			warningCount: diagnostics.filter((d) => d.severity === "warning").length
+		},
+		baselined,
+		fixed
+	};
+}
+/**
+* The baseline after a run over `checked` (file → its findings): those files
+* get exactly their current findings, plus their previous entries for
+* `disabled` rules; other files keep their entries while they still exist
+* under `root`.
+*/
+function updateBaseline(previous, checked, root, disabled = /* @__PURE__ */ new Set()) {
+	const disabledIn = typeof disabled === "function" ? disabled : () => disabled;
+	const next = /* @__PURE__ */ new Map();
+	for (const [file, rules] of previous ?? []) if (!checked.has(file) && fs.existsSync(path.resolve(root, file))) next.set(file, rules);
+	for (const [file, diagnostics] of checked) {
+		const rules = /* @__PURE__ */ new Map();
+		const off = disabledIn(file);
+		for (const [rule, sources] of previous?.get(file) ?? []) if (off.has(rule)) rules.set(rule, sources);
+		for (const diagnostic of diagnostics) {
+			let sources = rules.get(diagnostic.ruleId);
+			if (!sources) rules.set(diagnostic.ruleId, sources = /* @__PURE__ */ new Map());
+			const id = findingKey(diagnostic);
+			sources.set(id, (sources.get(id) ?? 0) + 1);
+		}
+		if (rules.size) next.set(file, rules);
+	}
+	return next;
+}
+function countBaseline(entries) {
+	let findings = 0;
+	for (const rules of entries.values()) for (const sources of rules.values()) for (const count of sources.values()) findings += count;
+	return {
+		findings,
+		files: entries.size
+	};
+}
+/** Writes the baseline sorted at every level, so it diffs cleanly in review. */
+function writeBaseline(file, entries) {
+	const sorted = (map) => [...map].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+	const files = {};
+	for (const [name, rules] of sorted(entries)) {
+		const byRule = {};
+		for (const [rule, sources] of sorted(rules)) byRule[rule] = Object.fromEntries(sorted(sources));
+		Object.defineProperty(files, name, {
+			value: byRule,
+			enumerable: true,
+			writable: true
+		});
+	}
+	const baseline = {
+		version: 1,
+		files
+	};
+	try {
+		fs.writeFileSync(file, `${JSON.stringify(baseline, null, 2)}\n`);
+	} catch (error) {
+		throw new ConfigError(`Could not write baseline ${file}: ${error.message}`);
+	}
+}
+function isObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region package.json
+var name = "onsystem";
+//#endregion
+//#region src/version.ts
+const VERSION = "0.5.0";
+const NAME = name;
+//#endregion
+//#region src/lint/sarif.ts
+const SCHEMA = "https://docs.oasis-open.org/sarif/sarif/v2.1.0/errata01/os/schemas/sarif-schema-2.1.0.json";
+const REPO = "https://github.com/dgesteves/onsystem";
+const RULES_PAGE = "https://onsystem.vercel.app/rules";
+/** The rules, and the two kinds of finding that are not a rule of their own. */
+function descriptors() {
+	return [
+		...RULES.map((rule) => ({
+			id: rule.id,
+			description: rule.description,
+			level: DEFAULT_SEVERITY[rule.id] === "warn" ? "warning" : "error",
+			anchor: rule.id
+		})),
+		{
+			id: "syntax",
+			description: "The file must parse. A syntax error, or code nested too deeply to parse, makes the other findings in the file unreliable.",
+			level: "error",
+			anchor: "fixes"
+		},
+		{
+			id: "suppression",
+			description: "Suppression comments must name known rules: a misspelled rule name suppresses nothing.",
+			level: "warning",
+			anchor: "suppressing-findings"
+		}
+	];
+}
+/** A path relative to the repository root as a URI reference: `app/blog/%5Bslug%5D/page.tsx`. */
+function toUri(file) {
+	return file.replaceAll("\\", "/").split("/").map((segment) => segment === "." || segment === ".." ? segment : encodeURIComponent(segment)).join("/");
+}
+/**
+* Check results as a SARIF 2.1.0 log, for GitHub code scanning
+* (`github/codeql-action/upload-sarif`) and other SARIF consumers.
+*
+* `uri` maps a result's file to its path relative to the repository root, which code scanning
+* resolves locations against. Each result carries a fingerprint built like a baseline entry
+* (file, rule, the offending text and its occurrence), so an alert keeps its identity when
+* lines above it move.
+*/
+function formatSarif(results, uri = (file) => file) {
+	const rules = descriptors();
+	const index = new Map(rules.map((rule, i) => [rule.id, i]));
+	const sarifResults = results.flatMap((result) => {
+		const location = toUri(uri(result.file));
+		const seen = /* @__PURE__ */ new Map();
+		return result.diagnostics.map((d) => {
+			const identity = `${d.ruleId}\0${findingKey(d)}`;
+			const occurrence = seen.get(identity) ?? 0;
+			seen.set(identity, occurrence + 1);
+			return sarifResult(d, location, index.get(d.ruleId), fingerprint$1(location, identity, occurrence));
+		});
+	});
+	const log = {
+		$schema: SCHEMA,
+		version: "2.1.0",
+		runs: [{
+			tool: { driver: {
+				name: NAME,
+				version: VERSION,
+				semanticVersion: VERSION,
+				informationUri: REPO,
+				rules: rules.map((rule) => {
+					const helpUri = `${RULES_PAGE}#${rule.anchor}`;
+					return {
+						id: rule.id,
+						shortDescription: { text: rule.description },
+						fullDescription: { text: rule.description },
+						helpUri,
+						help: {
+							text: `${rule.description} See ${helpUri}`,
+							markdown: `${rule.description}\n\n[${rule.id} in the rules catalog](${helpUri})`
+						},
+						defaultConfiguration: { level: rule.level }
+					};
+				})
+			} },
+			columnKind: "utf16CodeUnits",
+			results: sarifResults
+		}]
+	};
+	return JSON.stringify(log, null, 2);
+}
+function sarifResult(d, uri, ruleIndex, fingerprint) {
+	return {
+		ruleId: d.ruleId,
+		...ruleIndex === void 0 ? {} : { ruleIndex },
+		level: d.severity,
+		message: { text: d.message },
+		locations: [{ physicalLocation: {
+			artifactLocation: {
+				uri,
+				uriBaseId: "%SRCROOT%"
+			},
+			region: {
+				startLine: d.line,
+				startColumn: d.column,
+				endLine: d.endLine,
+				endColumn: d.endColumn,
+				...d.source ? { snippet: { text: d.source } } : {}
+			}
+		} }],
+		partialFingerprints: { [`${NAME}/v1`]: fingerprint }
+	};
+}
+function fingerprint$1(uri, identity, occurrence) {
+	return createHash("sha256").update(`${uri}\0${identity}\0${String(occurrence)}`).digest("hex");
+}
+//#endregion
 //#region src/lint/format.ts
 const color = (code) => (text, enabled) => enabled ? `\u001b[${code}m${text}\u001b[39m` : text;
 const red = color(31);
@@ -6546,15 +6815,20 @@ const bold = (text, enabled) => enabled ? `\u001b[1m${text}\u001b[22m` : text;
 * Renders check results:
 * - `pretty`: grouped by file, for terminals and agents,
 * - `json`: the raw results,
-* - `github`: workflow commands that GitHub Actions turns into PR annotations.
+* - `github`: workflow commands that GitHub Actions turns into PR annotations,
+* - `sarif`: a SARIF 2.1.0 log, for GitHub code scanning and other SARIF consumers.
 */
 function formatDiagnostics(results, format, options = {}) {
 	const { fixedHint } = options;
 	if (format === "json") return JSON.stringify(results, null, 2);
+	if (format === "sarif") return formatSarif(results, options.uri);
 	if (format === "github") {
-		const lines = results.flatMap((result) => result.diagnostics.map((d) => {
-			return `::${d.severity === "error" ? "error" : "warning"} ${`file=${escapeProperty(result.file)},line=${d.line},col=${d.column},endLine=${d.endLine},endColumn=${d.endColumn},title=${escapeProperty(d.ruleId)}`}::${escapeData(d.message)}`;
-		}));
+		const lines = results.flatMap((result) => {
+			const file = options.uri ? options.uri(result.file) : result.file;
+			return result.diagnostics.map((d) => {
+				return `::${d.severity === "error" ? "error" : "warning"} ${`file=${escapeProperty(file)},line=${d.line},col=${d.column},endLine=${d.endLine},endColumn=${d.endColumn},title=${escapeProperty(d.ruleId)}`}::${escapeData(d.message)}`;
+			});
+		});
 		if (fixedHint) lines.push(`::notice title=onsystem baseline::${escapeData(fixedHint)}`);
 		return lines.join("\n");
 	}
@@ -6591,16 +6865,6 @@ function escapeProperty(value) {
 }
 //#endregion
 //#region src/lint/index.ts
-const RULES = [
-	noHardcodedColor,
-	noHardcodedSpacing,
-	noHardcodedRadius,
-	preferDesignSystemComponent,
-	noUnknownComponent,
-	noUnknownProp,
-	noUnknownVariant,
-	iconButtonAccessibleName
-];
 /**
 * Lints a TSX/JSX snippet or file against the design system. Purely
 * syntactic: no type-checking of the snippet, so it works on fragments an
@@ -7108,13 +7372,6 @@ const silentLogger = {
 	error: () => void 0
 };
 //#endregion
-//#region package.json
-var name = "onsystem";
-//#endregion
-//#region src/version.ts
-const VERSION = "0.4.0";
-const NAME = name;
-//#endregion
 //#region src/design-system.ts
 /** A loaded design system: the model plus the indexes the tools query. */
 var DesignSystem = class {
@@ -7202,7 +7459,7 @@ var DesignSystem = class {
 		});
 	}
 };
-const CONFIGURATION_DOCS = "https://design-system-mcp-demo.vercel.app/docs/configuration";
+const CONFIGURATION_DOCS = "https://onsystem.vercel.app/docs/configuration";
 /** `border-ring` → token `ring`, for color utilities a token's usage list does not spell out. */
 function matchUtility(base, tokens) {
 	const key = COLOR_UTILITY.exec(base)?.[1];
@@ -7581,1481 +7838,4 @@ var DesignSystemHost = class {
 	}
 };
 //#endregion
-//#region src/types.ts
-/**
-* The design-system model the server exposes. Everything here is plain JSON so
-* it can be cached on disk and returned as MCP structured content.
-*/
-const TOKEN_CATEGORIES = [
-	"color",
-	"spacing",
-	"radius",
-	"typography",
-	"shadow",
-	"other"
-];
-//#endregion
-//#region src/server/render.ts
-/**
-* Tool results are read by models, so they are rendered as compact Markdown:
-* fewer tokens than JSON, and the same information. The JSON is still sent
-* as structured content.
-*/
-function firstSentence(text, max = 140) {
-	if (!text) return "";
-	return truncate((/^[\s\S]*?[.!?](?=\s+[A-Z`"(]|\s*$)/.exec(text.trim())?.[0] ?? text.trim()).replace(/\s+/g, " "), max);
-}
-function importStatement(component) {
-	return `import { ${component.exportName.split(".")[0] ?? component.name} } from "${component.importPath}"`;
-}
-function variantSummary(component) {
-	return component.variants.map((v) => `${v.name}: ${v.values.join(" | ")}${v.default ? ` (default ${v.default})` : ""}`);
-}
-/** `project`: the folder of a workspace root's project the list is for. */
-function renderComponentList(ds, project) {
-	const roots = ds.roots();
-	if (!roots.length) return `No components found${project ? ` in ${project}` : ""}. Check the "components" globs in the config (root: ${ds.root}).`;
-	const parts = ds.components.length - roots.length;
-	const lines = [`${plural$1(roots.length, "component")}${parts ? ` (+${plural$1(parts, "part")})` : ""}${project ? ` in ${project}` : ""}. Call get_component before using one.`, ""];
-	for (const component of roots) lines.push(...listItem(component));
-	return lines.join("\n");
-}
-function listItem(component, note = "") {
-	const element = component.element ? ` <${component.element}>` : "";
-	const lines = [`${component.name}${element}${note} — ${firstSentence(component.description) || "No description."}`];
-	for (const variant of variantSummary(component)) lines.push(`  ${variant}`);
-	if (component.subcomponents.length) lines.push(`  parts: ${component.subcomponents.join(", ")}`);
-	lines.push(`  ${importStatement(component)}`);
-	return lines;
-}
-/** `apps/web`, `apps/web and packages/ui`, `a, b, c and 4 more`. */
-function listOf$1(items, max = 3) {
-	if (items.length <= 1) return items[0] ?? "";
-	if (items.length <= max) return `${items.slice(0, -1).join(", ")} and ${items.at(-1) ?? ""}`;
-	return `${items.slice(0, max).join(", ")} and ${items.length - max} more`;
-}
-const PICK_PROJECT = "This is a monorepo root: pass `path`, the file you are editing, to get_component, get_tokens and check_ui so they answer for its project.";
-/** Every project's components at a workspace root, grouped by the package they come from. */
-function renderCatalogList(catalog) {
-	const roots = catalog.roots();
-	if (!roots.length) return `No components found in any project of this monorepo (root: ${catalog.root}). Run \`onsystem inspect\` there to see what was looked at.`;
-	const byPackage = /* @__PURE__ */ new Map();
-	for (const entry of roots) byPackage.set(entry.package, [...byPackage.get(entry.package) ?? [], entry]);
-	const parts = catalog.entries.length - roots.length;
-	const lines = [`${plural$1(roots.length, "component")}${parts ? ` (+${plural$1(parts, "part")})` : ""} from ${plural$1(byPackage.size, "package")}, used by ${plural$1(catalog.projects.length, "project")}. ${PICK_PROJECT}`];
-	for (const [pkg, entries] of byPackage) {
-		const projects = [...new Set(entries.flatMap((e) => e.projects))];
-		lines.push("", `## ${pkg} (used by ${listOf$1(projects)})`);
-		for (const entry of entries) {
-			const others = entry.ambiguous ? catalog.roots().filter((e) => e !== entry && e.component.name === entry.component.name) : [];
-			const note = others.length ? ` (also in ${[...new Set(others.map((e) => e.package))].join(", ")})` : "";
-			lines.push(...listItem(entry.component, note));
-		}
-	}
-	return lines.join("\n");
-}
-/** Several components under one name at a workspace root, and how to pick one. */
-function renderAmbiguous(name, entries) {
-	const lines = [`"${name}" is the name of ${entries.length} components in this monorepo:`];
-	for (const entry of entries) lines.push(`- ${entry.package}: ${entry.component.source.file}, used by ${listOf$1(entry.projects)} (${importStatement(entry.component)})`);
-	const dirs = [...new Set(entries.flatMap((e) => e.projects))];
-	lines.push("", `Pass \`path\`: the file you are editing, or its project folder (${dirs.join(", ")}), to get the one that project uses.`);
-	return lines.join("\n");
-}
-/** Inherited attributes worth naming, per element; the rest are summarised. */
-const NOTABLE_INHERITED = {
-	button: [
-		"onClick",
-		"type",
-		"disabled",
-		"form"
-	],
-	input: [
-		"type",
-		"value",
-		"defaultValue",
-		"onChange",
-		"placeholder",
-		"disabled",
-		"name",
-		"required"
-	],
-	textarea: [
-		"value",
-		"defaultValue",
-		"onChange",
-		"placeholder",
-		"disabled",
-		"name",
-		"rows"
-	],
-	select: [
-		"value",
-		"defaultValue",
-		"onChange",
-		"disabled",
-		"name"
-	],
-	a: [
-		"href",
-		"target",
-		"rel"
-	],
-	img: [
-		"src",
-		"alt",
-		"width",
-		"height"
-	],
-	label: ["htmlFor"],
-	default: [
-		"onClick",
-		"id",
-		"role",
-		"children"
-	]
-};
-/** What callers of a React Aria component most often need, from its inherited props. */
-const REACT_ARIA_NOTABLE = [
-	"onPress",
-	"onChange",
-	"onAction",
-	"onSelectionChange",
-	"onOpenChange",
-	"value",
-	"defaultValue",
-	"isDisabled",
-	"isRequired",
-	"isInvalid",
-	"isReadOnly",
-	"autoFocus"
-];
-function renderProp(prop) {
-	const optional = prop.required ? "" : "?";
-	const fallback = prop.default !== void 0 ? ` = ${prop.default}` : "";
-	const deprecated = prop.deprecated ? ` DEPRECATED${prop.deprecated === true ? "" : `: ${prop.deprecated}`}.` : "";
-	const description = prop.description ? ` — ${prop.description.replace(/\s*\n\s*/g, " ")}` : "";
-	return `- ${prop.name}${optional}: ${prop.type}${fallback}${description}${deprecated}`;
-}
-/** `origin`: at a workspace root, the package the component comes from and who uses it. */
-function renderComponent(ds, component, origin) {
-	const lines = [`# ${component.name}`];
-	if (component.deprecated) lines.push(`DEPRECATED${component.deprecated === true ? "" : `: ${component.deprecated}`}`);
-	if (component.description) lines.push(component.description);
-	lines.push("", importStatement(component));
-	const facts = [
-		component.element ? `Renders <${component.element}>` : void 0,
-		component.parent ? `Part of ${component.parent}` : void 0,
-		component.aliases.length ? `Also available as ${component.aliases.join(", ")}` : void 0,
-		`${component.source.file}:${component.source.line}`,
-		component.docs ? `docs: ${component.docs.file}` : void 0
-	].filter(Boolean);
-	lines.push(facts.join(" · "));
-	if (origin) lines.push(`From ${origin.package}, used by ${listOf$1(origin.projects)}.`);
-	lines.push("", "## Props");
-	if (!component.props.length && !component.inherits.length) lines.push("No props.");
-	for (const prop of component.props) lines.push(renderProp(prop));
-	for (const inherited of component.inherits) {
-		const names = ds.model.propSets[inherited.set] ?? [];
-		const notable = (names.some((n) => n === "onPress" || n === "onFocusChange") ? REACT_ARIA_NOTABLE : NOTABLE_INHERITED[component.element ?? ""] ?? NOTABLE_INHERITED.default ?? []).filter((n) => names.includes(n) && !inherited.deprecated?.includes(n));
-		lines.push(`- …plus ${inherited.count} props from ${inherited.from}` + (notable.length ? ` (${notable.join(", ")}, aria-*, data-*, …)` : ""));
-	}
-	if (component.openProps) lines.push("- Part of the props type could not be resolved; extra props may be accepted.");
-	if (component.variants.length) {
-		lines.push("", "## Variants");
-		for (const variant of component.variants) {
-			lines.push(`${variant.name}${variant.default ? ` (default "${variant.default}")` : ""}`);
-			const width = Math.max(...variant.values.map((v) => v.length));
-			for (const value of variant.values) lines.push(`  ${value.padEnd(width)}  ${variant.classes[value] ?? ""}`.trimEnd());
-		}
-		for (const compound of component.compoundVariants) {
-			const when = Object.entries(compound.when).map(([k, v]) => `${k}=${Array.isArray(v) ? v.join("|") : v}`).join(" & ");
-			lines.push(`  when ${when}: ${compound.classes}`);
-		}
-	}
-	if (component.subcomponents.length) {
-		lines.push("", "## Parts");
-		for (const name of component.subcomponents) {
-			const part = ds.getComponent(name);
-			lines.push(`- ${name}${part?.description ? ` — ${firstSentence(part.description)}` : ""}`);
-		}
-	}
-	const tokens = ds.relatedTokens(component);
-	if (tokens.length) {
-		lines.push("", "## Design tokens used");
-		lines.push(tokens.map((t) => `${t.name} (${t.usage[0] ?? t.value})`).join(", "));
-	}
-	if (component.docs?.sections.length) {
-		lines.push("", `## Docs (${component.docs.file})`);
-		for (const section of component.docs.sections) {
-			if (/^examples?$/i.test(section.heading) && !section.body) continue;
-			lines.push(`### ${section.heading}`);
-			if (section.body) lines.push(section.body);
-		}
-	}
-	if (component.examples.length) {
-		lines.push("", "## Examples");
-		for (const example of component.examples) {
-			if (example.title) lines.push(`### ${example.title}`);
-			lines.push(`\`\`\`${example.lang}`, example.code, "```");
-		}
-	}
-	return lines.join("\n");
-}
-function renderSearch(query, hits) {
-	if (!hits.length) return `No components match "${query}". Try other words, or list_components to browse.`;
-	const lines = [`Components for "${query}", best first:`, ""];
-	hits.forEach((hit, i) => {
-		const c = hit.component;
-		const parent = c.parent ? ` (part of ${c.parent})` : "";
-		lines.push(`${i + 1}. ${c.name}${parent} — ${firstSentence(c.description) || "No description."}`);
-		lines.push(`   score ${hit.score} · matched: ${hit.matched.join(", ")} · ${importStatement(c)}`);
-	});
-	lines.push("", "Call get_component for props, variants and examples.");
-	return lines.join("\n");
-}
-/** Search hits at a workspace root, each with the package it comes from. */
-function renderCatalogSearch(query, hits) {
-	if (!hits.length) return `No components match "${query}" in any project. Try other words, or list_components to browse.`;
-	const lines = [`Components for "${query}" across the monorepo's projects, best first:`, ""];
-	hits.forEach((hit, i) => {
-		const c = hit.component;
-		const parent = c.parent ? ` (part of ${c.parent})` : "";
-		lines.push(`${i + 1}. ${c.name}${parent} from ${hit.entry.package} — ${firstSentence(c.description) || "No description."}`);
-		lines.push(`   score ${hit.score} · matched: ${hit.matched.join(", ")} · used by ${listOf$1(hit.entry.projects)} · ${importStatement(c)}`);
-	});
-	lines.push("", `Call get_component for props, variants and examples. ${PICK_PROJECT}`);
-	return lines.join("\n");
-}
-/** Tokens at a workspace root, grouped by category, each with the package that defines it. */
-function renderCatalogTokens(catalog, tokens, filter = {}) {
-	if (!catalog.tokens.length) return `No design tokens found in any project of this monorepo (root: ${catalog.root}). Set "tokens" in a project's config: https://design-system-mcp-demo.vercel.app/docs/configuration`;
-	if (!tokens.length) {
-		const what = [filter.category, filter.query && `"${filter.query}"`].filter(Boolean).join(" ");
-		return `No tokens match${what ? ` ${what}` : ""} in any project; call get_tokens without filters to see them.`;
-	}
-	const groups = /* @__PURE__ */ new Map();
-	for (const t of tokens) groups.set(t.token.category, [...groups.get(t.token.category) ?? [], t]);
-	const lines = [PICK_PROJECT, ""];
-	for (const [category, list] of groups) {
-		lines.push(`## ${category} (${list.length})`);
-		for (const { token, package: pkg } of list) {
-			const usage = token.usage.length ? ` → ${token.usage.join(", ")}` : "";
-			lines.push(`- ${token.name}: ${token.value}${usage} (${pkg})`);
-		}
-		lines.push("");
-	}
-	return lines.join("\n").trimEnd();
-}
-function renderTokens(ds, tokens, filter = {}) {
-	if (!ds.tokens.length) return `No design tokens found in this project (root: ${ds.root}): no stylesheet or *.tokens.json defines any. Set "tokens" in the config: https://design-system-mcp-demo.vercel.app/docs/configuration`;
-	if (!tokens.length) {
-		const counts = /* @__PURE__ */ new Map();
-		for (const token of ds.tokens) counts.set(token.category, (counts.get(token.category) ?? 0) + 1);
-		const categories = [...counts].map(([category, n]) => `${category} (${n})`).join(", ");
-		const what = [filter.category, filter.query && `"${filter.query}"`].filter(Boolean).join(" ");
-		return `No tokens match${what ? ` ${what}` : ""}. The design system has ${categories}; call get_tokens without filters to see them.`;
-	}
-	const groups = /* @__PURE__ */ new Map();
-	for (const token of tokens) groups.set(token.category, [...groups.get(token.category) ?? [], token]);
-	const lines = [];
-	for (const [category, list] of groups) {
-		lines.push(`## ${category} (${list.length})`);
-		for (const token of list) {
-			const px = token.category === "spacing" || token.category === "radius" ? ds.tokenIndex.toPx(token.value) : void 0;
-			const value = px !== void 0 && !/^-?[\d.]+px$/.test(token.value) ? `${token.value} = ${formatPx(px)}` : token.value;
-			const modes = token.modes ? ` (${Object.entries(token.modes).map(([mode, v]) => `${mode}: ${v}`).join(", ")})` : "";
-			const usage = token.usage.length ? ` → ${token.usage.join(", ")}` : "";
-			const description = token.description ? ` — ${token.description}` : "";
-			const deprecated = token.deprecated ? " DEPRECATED" : "";
-			lines.push(`- ${token.name}: ${value}${modes}${usage}${description}${deprecated}`);
-		}
-		lines.push("");
-	}
-	return lines.join("\n").trimEnd();
-}
-function capDiagnostics(result, limit) {
-	const ordered = [...result.diagnostics.filter((d) => d.severity === "error"), ...result.diagnostics.filter((d) => d.severity !== "error")];
-	const byRule = {};
-	for (const d of result.diagnostics) {
-		const counts = byRule[d.ruleId] ??= {
-			errors: 0,
-			warnings: 0
-		};
-		if (d.severity === "error") counts.errors++;
-		else counts.warnings++;
-	}
-	const shown = ordered.slice(0, limit);
-	return {
-		shown,
-		omitted: ordered.length - shown.length,
-		byRule
-	};
-}
-function renderCheck(result, capped = capDiagnostics(result, Infinity)) {
-	if (result.skipped) return `${result.file}: not checked. ${result.skipped}`;
-	if (!result.diagnostics.length) return `${result.file}: no design-system problems found.`;
-	const lines = [`${result.file}: ${plural$1(result.errorCount, "error")}, ${plural$1(result.warningCount, "warning")}`, ""];
-	for (const d of capped.shown) lines.push(`${d.line}:${d.column} ${d.severity} [${d.ruleId}] ${d.message}`);
-	if (capped.omitted) {
-		const rules = Object.entries(capped.byRule).sort(([, a], [, b]) => b.errors + b.warnings - (a.errors + a.warnings)).map(([rule, c]) => `${rule} ${(c.errors + c.warnings).toLocaleString("en-US")}`).join(", ");
-		lines.push("", `Showing ${capped.shown.length} of ${result.diagnostics.length.toLocaleString("en-US")} (errors first). By rule: ${rules}.`, `${capped.omitted.toLocaleString("en-US")} more not shown: fix these, then run check_ui again, or pass a higher \`limit\`.`);
-	}
-	lines.push("", result.errorCount ? "Fix every error, then run check_ui again." : "Only warnings: fix them if the design system has an equivalent.");
-	return lines.join("\n");
-}
-//#endregion
-//#region src/server/index.ts
-const INSTRUCTIONS = `This server describes the project's design system: its React components (props, variants, parts), design tokens and usage docs, and lints UI code against it.
-When writing or changing UI in this project:
-1. Find components with search_components (by intent) or list_components.
-2. Read get_component before using a component: use only the props and variant values it lists.
-3. Style with tokens from get_tokens, never with hex/rgb colors, arbitrary px values or Tailwind's default palette.
-4. Run check_ui on every snippet or file you write and fix all errors before you finish.
-In a monorepo served from its root, pass \`path\` (the file you are editing) to list_components, get_component, search_components and get_tokens, and \`path\` or \`filename\` to check_ui, so each answer comes from that file's own project.`;
-const READ_ONLY = {
-	readOnlyHint: true,
-	idempotentHint: true,
-	openWorldHint: false
-};
-/** What a client may cache: what never changes while the server runs, and what does. */
-const STATIC = {
-	ttlMs: 36e5,
-	cacheScope: "private"
-};
-const FRESH = {
-	ttlMs: 0,
-	cacheScope: "private"
-};
-/** Input limits, so one oversized request cannot stall the server. */
-const MAX_NAME = 256;
-const MAX_QUERY = 1e3;
-const MAX_PATH = 4096;
-/** Larger than any hand-written source file; generated bundles are not UI to check. */
-const MAX_CODE = 1e6;
-/** Diagnostics check_ui returns by default: a 3,000-line file can have thousands, more than a context holds. */
-const DEFAULT_LIMIT = 50;
-const MAX_LIMIT = 1e3;
-/**
-* An integer, without the ±9007199254740991 bounds zod adds to the JSON Schema,
-* which every client would otherwise read in each tool definition.
-*/
-const int = () => z.number().int().meta({
-	minimum: void 0,
-	maximum: void 0
-});
-/** At a workspace root, where a component comes from. */
-const originShape = {
-	package: z.string().optional().describe("At a workspace root: the package its source belongs to, e.g. \"@acme/ui\"."),
-	projects: z.array(z.string()).optional().describe("At a workspace root: the folders of the projects that use it.")
-};
-const diagnosticSchema = z.object({
-	ruleId: z.string(),
-	severity: z.enum(["error", "warning"]),
-	message: z.string(),
-	line: int(),
-	column: int(),
-	endLine: int(),
-	endColumn: int(),
-	source: z.string(),
-	suggestion: z.string().optional(),
-	fix: z.array(z.object({
-		range: z.array(int()).length(2),
-		text: z.string()
-	})).optional().describe("Edits (0-based offsets into the checked code) that apply the suggestion.")
-});
-const deprecatedSchema = z.union([z.string(), z.literal(true)]).optional();
-const componentSchema = {
-	name: z.string().describe("How the component is written in JSX: Button, CardHeader, Tabs.List."),
-	aliases: z.array(z.string()),
-	description: z.string().optional(),
-	deprecated: deprecatedSchema,
-	importPath: z.string(),
-	exportName: z.string(),
-	source: z.object({
-		file: z.string(),
-		line: int()
-	}),
-	parent: z.string().optional(),
-	subcomponents: z.array(z.string()),
-	element: z.string().optional().describe("The native element it renders or wraps."),
-	props: z.array(z.object({
-		name: z.string(),
-		type: z.string(),
-		required: z.boolean(),
-		default: z.string().optional(),
-		description: z.string().optional(),
-		values: z.array(z.string()).optional(),
-		deprecated: deprecatedSchema,
-		kind: z.enum(["prop", "variant"])
-	})),
-	inherits: z.array(z.object({
-		from: z.string(),
-		count: int(),
-		set: z.string(),
-		deprecated: z.array(z.string()).optional()
-	})),
-	openProps: z.boolean().describe("Part of the props type did not resolve; extra props may be accepted."),
-	variants: z.array(z.object({
-		name: z.string(),
-		values: z.array(z.string()),
-		default: z.string().optional(),
-		classes: z.record(z.string(), z.string())
-	})),
-	compoundVariants: z.array(z.object({
-		when: z.record(z.string(), z.union([z.string(), z.array(z.string())])),
-		classes: z.string()
-	})),
-	examples: z.array(z.object({
-		title: z.string().optional(),
-		code: z.string(),
-		lang: z.string(),
-		source: z.enum(["docs", "jsdoc"])
-	})),
-	docs: z.object({
-		file: z.string(),
-		description: z.string().optional(),
-		sections: z.array(z.object({
-			heading: z.string(),
-			body: z.string()
-		})),
-		frontmatter: z.record(z.string(), z.union([z.string(), z.array(z.string())]))
-	}).optional(),
-	classNames: z.array(z.string()),
-	cssVars: z.array(z.string()),
-	import: z.string().describe("The import statement to use."),
-	tokens: z.array(z.string()).describe("Names of the design tokens its classes use."),
-	...originShape
-};
-const componentSummarySchema = z.object({
-	name: z.string(),
-	description: z.string().optional(),
-	importPath: z.string(),
-	element: z.string().optional(),
-	variants: z.record(z.string(), z.array(z.string())),
-	subcomponents: z.array(z.string()),
-	...originShape
-});
-const tokenSchema = z.object({
-	name: z.string(),
-	category: z.enum(TOKEN_CATEGORIES),
-	value: z.string(),
-	modes: z.record(z.string(), z.string()).optional(),
-	cssVar: z.string().optional(),
-	tailwind: z.string().optional(),
-	usage: z.array(z.string()),
-	description: z.string().optional(),
-	...originShape
-});
-/** The optional `path` that picks a project at a workspace root. */
-const projectPath = z.string().max(MAX_PATH).optional().describe("In a monorepo served from its root: the file you are editing, or a project folder, relative to the root, to answer from that project. Without it, every project is listed together. Ignored in a single project.");
-/** A component's source path relative to `root`, the workspace root the client knows. */
-function fromRoot(ds, component, root) {
-	if (!root || root === ds.root) return component;
-	const file = relativePath(root, path.resolve(ds.root, component.source.file));
-	return {
-		...component,
-		source: {
-			...component.source,
-			file
-		}
-	};
-}
-/** `a, b and c`, `a, b, c and 4 more`. */
-function listOf(items, max) {
-	if (items.length <= 1) return items[0] ?? "";
-	if (items.length <= max) return `${items.slice(0, -1).join(", ")} and ${items.at(-1) ?? ""}`;
-	return `${items.slice(0, max).join(", ")} and ${items.length - max} more`;
-}
-function errorResult(text) {
-	return {
-		isError: true,
-		content: [{
-			type: "text",
-			text
-		}]
-	};
-}
-function origin(entry) {
-	return {
-		package: entry.package,
-		projects: entry.projects
-	};
-}
-function summary(c) {
-	return {
-		name: c.name,
-		...c.description ? { description: c.description } : {},
-		importPath: c.importPath,
-		...c.element ? { element: c.element } : {},
-		variants: Object.fromEntries(c.variants.map((v) => [v.name, v.values])),
-		subcomponents: c.subcomponents
-	};
-}
-/** Builds the MCP server: five tools, two resources and one prompt. Transport-agnostic. */
-function createServer({ getDesignSystem, getProjects }) {
-	const server = new McpServer({
-		name: NAME,
-		title: "onsystem",
-		version: VERSION
-	}, {
-		instructions: INSTRUCTIONS,
-		capabilities: { resources: { listChanged: true } },
-		cacheHints: {
-			"server/discover": STATIC,
-			"tools/list": STATIC,
-			"prompts/list": STATIC,
-			"resources/templates/list": STATIC,
-			"resources/list": FRESH,
-			"resources/read": FRESH
-		}
-	});
-	/** The design system for `target` at a workspace root, or the merged catalog without one. */
-	const scope = async (target) => {
-		const set = await getProjects?.();
-		if (!set) return { ds: await getDesignSystem() };
-		if (target !== void 0 && target !== "") {
-			const project = await set.forPath(target);
-			return {
-				ds: project.ds,
-				project,
-				root: set.root
-			};
-		}
-		return {
-			set,
-			catalog: await set.catalog()
-		};
-	};
-	/** `scope`, with a path outside the workspace as an error result instead of a throw. */
-	const scoped = async (target) => {
-		try {
-			return await scope(target);
-		} catch (error) {
-			return errorResult(error.message);
-		}
-	};
-	const isResult = (value) => "content" in value;
-	server.registerTool("list_components", {
-		title: "List design-system components",
-		description: "List every component in the project design system with a one-line description, the native element it renders, its variant values, its parts and its import. Call this before writing UI in this project. At a monorepo root, pass `path` for the project of the file you are editing; without it, every project is listed, each component with its package.",
-		inputSchema: z.object({ path: projectPath }),
-		outputSchema: z.object({ components: z.array(componentSummarySchema) }),
-		annotations: READ_ONLY
-	}, async ({ path: target }) => {
-		const found = await scoped(target);
-		if (isResult(found)) return found;
-		if ("catalog" in found) {
-			const { catalog } = found;
-			return {
-				content: [{
-					type: "text",
-					text: renderCatalogList(catalog)
-				}],
-				structuredContent: { components: catalog.roots().map((entry) => ({
-					...summary(entry.component),
-					...origin(entry)
-				})) }
-			};
-		}
-		const { ds } = found;
-		return {
-			content: [{
-				type: "text",
-				text: renderComponentList(ds, found.project?.dir)
-			}],
-			structuredContent: { components: ds.roots().map(summary) }
-		};
-	});
-	server.registerTool("get_component", {
-		title: "Get a component contract",
-		description: "Get the full contract of one component: import, props with types and defaults, cva variants and the classes each applies, parts (sub-components), design tokens it uses, usage guidelines and examples from its docs. Call it before using a component. Accepts \"Button\", \"CardHeader\" or \"Card.Header\". At a monorepo root, pass `path` (the file you are editing) to get the component its project uses.",
-		inputSchema: z.object({
-			name: z.string().min(1).max(MAX_NAME).describe("Component name, e.g. \"Button\" or \"CardHeader\"."),
-			path: projectPath
-		}),
-		outputSchema: z.object(componentSchema),
-		annotations: READ_ONLY
-	}, async ({ name, path: target }) => {
-		const found = await scoped(target);
-		if (isResult(found)) return found;
-		if ("catalog" in found) {
-			const { catalog } = found;
-			const matches = catalog.find(name);
-			const [entry] = matches;
-			if (!entry) {
-				const guess = catalog.suggest(name);
-				const names = [...new Set(catalog.roots().map((e) => e.component.name))];
-				return errorResult(`No component named "${name}" in any project.` + (guess ? ` Did you mean "${guess}"?` : "") + ` Available: ${names.join(", ")}.`);
-			}
-			if (matches.length > 1) return errorResult(renderAmbiguous(name, matches));
-			return {
-				content: [{
-					type: "text",
-					text: renderComponent(entry.ds, entry.component, entry)
-				}],
-				structuredContent: {
-					...entry.component,
-					import: importStatement(entry.component),
-					tokens: entry.ds.relatedTokens(entry.component).map((t) => t.name),
-					...origin(entry)
-				}
-			};
-		}
-		const { ds } = found;
-		const component = ds.getComponent(name);
-		if (!component) {
-			const guess = ds.suggestComponent(name);
-			return {
-				isError: true,
-				content: [{
-					type: "text",
-					text: `No component named "${name}".` + (guess ? ` Did you mean "${guess}"?` : "") + ` Available: ${ds.roots().map((c) => c.name).join(", ")}.`
-				}]
-			};
-		}
-		const shown = fromRoot(ds, component, found.root);
-		return {
-			content: [{
-				type: "text",
-				text: renderComponent(ds, shown)
-			}],
-			structuredContent: {
-				...shown,
-				import: importStatement(component),
-				tokens: ds.relatedTokens(component).map((t) => t.name)
-			}
-		};
-	});
-	server.registerTool("search_components", {
-		title: "Search components by intent",
-		description: "Find components by what you want to build, e.g. \"confirm a destructive action\", \"status label\", \"text field with validation\". Ranks names, descriptions, docs, props and variant values with BM25 (local, no API key). Use it when you do not know which component fits.",
-		inputSchema: z.object({
-			query: z.string().min(1).max(MAX_QUERY).describe("What the UI should do, in plain words."),
-			limit: z.number().int().min(1).max(20).default(5).describe("Maximum results."),
-			path: projectPath
-		}),
-		outputSchema: z.object({ results: z.array(z.object({
-			name: z.string(),
-			parent: z.string().optional(),
-			description: z.string().optional(),
-			importPath: z.string(),
-			score: z.number(),
-			matched: z.array(z.string()),
-			...originShape
-		})) }),
-		annotations: READ_ONLY
-	}, async ({ query, limit, path: target }) => {
-		const found = await scoped(target);
-		if (isResult(found)) return found;
-		if ("catalog" in found) {
-			const hits = found.catalog.search(query, limit);
-			return {
-				content: [{
-					type: "text",
-					text: renderCatalogSearch(query, hits)
-				}],
-				structuredContent: { results: hits.map((h) => ({
-					name: h.component.name,
-					...h.component.parent ? { parent: h.component.parent } : {},
-					...h.component.description ? { description: h.component.description } : {},
-					importPath: h.component.importPath,
-					score: h.score,
-					matched: h.matched,
-					...origin(h.entry)
-				})) }
-			};
-		}
-		const { ds } = found;
-		const hits = ds.search(query, limit);
-		return {
-			content: [{
-				type: "text",
-				text: renderSearch(query, hits)
-			}],
-			structuredContent: { results: hits.map((h) => ({
-				name: h.component.name,
-				...h.component.parent ? { parent: h.component.parent } : {},
-				...h.component.description ? { description: h.component.description } : {},
-				importPath: h.component.importPath,
-				score: h.score,
-				matched: h.matched
-			})) }
-		};
-	});
-	server.registerTool("get_tokens", {
-		title: "Get design tokens",
-		description: "List design tokens with resolved values, dark-mode values and how to use each (Tailwind class or CSS variable). Filter by category (color, spacing, radius, typography, shadow, other) or a substring. Use these instead of hex codes, px values or Tailwind default palette classes.",
-		inputSchema: z.object({
-			category: z.enum(TOKEN_CATEGORIES).optional().describe("Only tokens of this category."),
-			query: z.string().max(MAX_QUERY).optional().describe("Substring to match in names, usages or descriptions."),
-			path: projectPath
-		}),
-		outputSchema: z.object({ tokens: z.array(tokenSchema) }),
-		annotations: READ_ONLY
-	}, async ({ category, query, path: target }) => {
-		const found = await scoped(target);
-		if (isResult(found)) return found;
-		if ("catalog" in found) {
-			const tokens = found.catalog.getTokens({
-				category,
-				query
-			});
-			return {
-				content: [{
-					type: "text",
-					text: renderCatalogTokens(found.catalog, tokens, {
-						category,
-						query
-					})
-				}],
-				structuredContent: { tokens: tokens.map(({ token: t, package: pkg, projects }) => ({
-					name: t.name,
-					category: t.category,
-					value: t.value,
-					...t.modes ? { modes: t.modes } : {},
-					...t.cssVar ? { cssVar: t.cssVar } : {},
-					...t.tailwind !== void 0 ? { tailwind: t.tailwind } : {},
-					usage: t.usage,
-					...t.description ? { description: t.description } : {},
-					package: pkg,
-					projects
-				})) }
-			};
-		}
-		const { ds } = found;
-		const tokens = ds.getTokens({
-			category,
-			query
-		});
-		return {
-			content: [{
-				type: "text",
-				text: renderTokens(ds, tokens, {
-					category,
-					query
-				})
-			}],
-			structuredContent: { tokens: tokens.map((t) => ({
-				name: t.name,
-				category: t.category,
-				value: t.value,
-				...t.modes ? { modes: t.modes } : {},
-				...t.cssVar ? { cssVar: t.cssVar } : {},
-				...t.tailwind !== void 0 ? { tailwind: t.tailwind } : {},
-				usage: t.usage,
-				...t.description ? { description: t.description } : {}
-			})) }
-		};
-	});
-	server.registerTool("check_ui", {
-		title: "Check UI code against the design system",
-		description: "Lint TSX/JSX against the design system. Reports hardcoded colors, spacing and radius (with the nearest token), native elements that have a design-system component, unknown components, props and variant values, and icon-only buttons without an accessible name. Each diagnostic has line/column, a rule id, a message and a suggested fix. Run it on every snippet or file you write and fix all errors. Pass `code` for unsaved code, or `path` for a file in the project.",
-		inputSchema: z.object({
-			code: z.string().max(MAX_CODE).optional().describe(`TSX/JSX source to check (up to ${MAX_CODE.toLocaleString("en")} characters).`),
-			path: z.string().max(MAX_PATH).optional().describe("Path of a file to check, relative to the project root (the monorepo root, when served from there)."),
-			filename: z.string().max(MAX_PATH).optional().describe("Name to report `code` under; a .jsx extension parses it as JSX. At a monorepo root, the path the code will be saved under, which picks the project whose design system checks it."),
-			limit: z.number().int().min(1).max(MAX_LIMIT).default(DEFAULT_LIMIT).describe(`Most diagnostics to return, errors first (default ${DEFAULT_LIMIT}). The counts and byRule cover all of them.`)
-		}),
-		outputSchema: z.object({
-			file: z.string(),
-			ok: z.boolean().describe("True when there are no errors."),
-			errorCount: int(),
-			warningCount: int(),
-			diagnostics: z.array(diagnosticSchema).describe("Up to `limit` diagnostics, errors first; `omitted` says how many more there are."),
-			omitted: int().describe("Diagnostics left out by `limit`."),
-			byRule: z.record(z.string(), z.object({
-				errors: int(),
-				warnings: int()
-			})).describe("Every finding per rule, shown or not."),
-			skipped: z.string().optional().describe("Why the file was not checked: it renders an image (next/og) or an email."),
-			unchecked: z.object({
-				names: z.array(z.string()),
-				modules: z.array(z.string())
-			}).optional().describe("Components imported from modules the model does not include, not checked."),
-			notice: z.string().optional().describe("Set when no components or no color tokens were found, so rules did not run, or when components came from modules the model does not include.")
-		}),
-		annotations: READ_ONLY
-	}, async ({ code, path: filePath, filename, limit }) => {
-		if (code === void 0 && !filePath) return errorResult("Pass either `code` or `path`.");
-		const set = await getProjects?.();
-		const routeBy = code === void 0 ? filePath : filename ?? void 0;
-		let ds;
-		if (!set) ds = await getDesignSystem();
-		else if (routeBy) {
-			const found = await scoped(routeBy);
-			if (isResult(found)) return found;
-			if (!("ds" in found)) return errorResult(`Cannot find the project of ${routeBy}.`);
-			ds = found.ds;
-		} else if (set.dirs.length <= 1) ds = (await set.forPath(set.dirs[0] ?? ".")).ds;
-		else return errorResult(`This is a monorepo root with ${set.dirs.length} projects (${listOf(set.dirs, 6)}). Pass \`filename\`, the path the code will be saved under relative to the root, so the right project's design system checks it.`);
-		const base = set?.root ?? ds.root;
-		let source = code;
-		let file = filename ?? "snippet.tsx";
-		let shown = file;
-		if (set && filename) file = relativePath(ds.root, path.resolve(base, filename));
-		if (source === void 0) {
-			if (!filePath) return errorResult("Pass either `code` or `path`.");
-			const absolute = path.resolve(base, filePath);
-			const outside = errorResult(`${filePath} is outside the project root (${base}).`);
-			if (!isInside(base, absolute)) return outside;
-			try {
-				const [root, real] = await Promise.all([fs$1.realpath(base), fs$1.realpath(absolute)]);
-				if (!isInside(root, real)) return outside;
-				if ((await fs$1.stat(real)).size > MAX_CODE) return {
-					isError: true,
-					content: [{
-						type: "text",
-						text: `${filePath} is too large to check.`
-					}]
-				};
-				source = await fs$1.readFile(real, "utf8");
-			} catch {
-				return {
-					isError: true,
-					content: [{
-						type: "text",
-						text: `Cannot read ${filePath}.`
-					}]
-				};
-			}
-			file = relativePath(ds.root, absolute);
-			shown = relativePath(base, absolute);
-		}
-		const checked = ds.check(source, file);
-		const result = set ? {
-			...checked,
-			file: shown
-		} : checked;
-		const capped = capDiagnostics(result, limit);
-		const notice = result.skipped ? void 0 : [ds.notice(), uncheckedNotice([result])].filter(Boolean).join("\n\n") || void 0;
-		return {
-			content: [{
-				type: "text",
-				text: renderCheck(result, capped) + (notice ? `\n\n${notice}` : "")
-			}],
-			structuredContent: {
-				...result,
-				diagnostics: capped.shown,
-				omitted: capped.omitted,
-				byRule: capped.byRule,
-				ok: result.errorCount === 0,
-				...notice ? { notice } : {}
-			}
-		};
-	});
-	server.registerResource("component", new ResourceTemplate("ds://components/{name}", {
-		list: async () => {
-			const found = await scope();
-			if ("catalog" in found) return { resources: found.catalog.entries.map(({ component: c, ambiguous, projects }) => ({
-				uri: `ds://components/${c.name}${ambiguous ? `?path=${encodeURIComponent(projects[0] ?? ".")}` : ""}`,
-				name: c.name,
-				title: c.name,
-				...c.description ? { description: c.description } : {},
-				mimeType: "text/markdown"
-			})) };
-			return { resources: found.ds.components.map((c) => ({
-				uri: `ds://components/${c.name}`,
-				name: c.name,
-				title: c.name,
-				...c.description ? { description: c.description } : {},
-				mimeType: "text/markdown"
-			})) };
-		},
-		complete: { name: async (value) => {
-			const found = await scope();
-			const lower = value.toLowerCase();
-			const names = "catalog" in found ? found.catalog.entries.map((e) => e.component.name) : found.ds.components.map((c) => c.name);
-			return [...new Set(names)].filter((n) => n.toLowerCase().startsWith(lower));
-		} }
-	}), {
-		title: "Design-system component",
-		description: "Props, variants, parts, tokens, guidelines and examples for one component.",
-		mimeType: "text/markdown"
-	}, async (uri, { name }) => {
-		const wanted = decodeURIComponent(String(name).split("?")[0] ?? "");
-		const found = await scope(uri.searchParams.get("path") ?? void 0);
-		if ("catalog" in found) {
-			const matches = found.catalog.find(wanted);
-			const [entry] = matches;
-			if (!entry) throw new Error(`No component named "${wanted}".`);
-			if (matches.length > 1) throw new Error(renderAmbiguous(wanted, matches));
-			return { contents: [{
-				uri: uri.href,
-				mimeType: "text/markdown",
-				text: renderComponent(entry.ds, entry.component, entry)
-			}] };
-		}
-		const { ds } = found;
-		const component = ds.getComponent(wanted);
-		if (!component) throw new Error(`No component named "${wanted}".`);
-		const text = renderComponent(ds, fromRoot(ds, component, found.root));
-		return { contents: [{
-			uri: uri.href,
-			mimeType: "text/markdown",
-			text
-		}] };
-	});
-	server.registerResource("tokens", "ds://tokens", {
-		title: "Design tokens",
-		description: "Every design token with resolved values, modes and usages, as JSON.",
-		mimeType: "application/json"
-	}, async (uri) => {
-		const found = await scope();
-		const tokens = "catalog" in found ? found.catalog.getTokens().map(({ token, package: pkg, projects }) => ({
-			...token,
-			package: pkg,
-			projects
-		})) : found.ds.getTokens();
-		return { contents: [{
-			uri: uri.href,
-			mimeType: "application/json",
-			text: JSON.stringify(tokens, null, 2)
-		}] };
-	});
-	server.registerPrompt("build-with-design-system", {
-		title: "Build UI with the design system",
-		description: "Build a piece of UI using only design-system components and tokens, then verify it with check_ui.",
-		argsSchema: z.object({ task: z.string().max(MAX_QUERY * 4).describe("What to build, e.g. \"a settings card that lets owners delete the workspace\".") })
-	}, async ({ task }) => {
-		const found = await scope();
-		const roots = "catalog" in found ? [...new Map(found.catalog.roots().map((e) => [e.component.name, e.component])).values()] : found.ds.roots();
-		const allTokens = "catalog" in found ? found.catalog.getTokens().map((t) => t.token) : found.ds.tokens;
-		const components = roots.map((c) => {
-			const extras = [...c.variants.map((v) => v.name), ...c.subcomponents.length ? [`+${c.subcomponents.length} parts`] : []];
-			return `${c.name}${extras.length ? ` (${extras.join(", ")})` : ""}`;
-		}).join(", ");
-		const counts = /* @__PURE__ */ new Map();
-		for (const token of allTokens) counts.set(token.category, (counts.get(token.category) ?? 0) + 1);
-		const tokens = [...counts].map(([category, n]) => `${n} ${category}`).join(", ");
-		return {
-			description: "Build UI with the design system",
-			messages: [{
-				role: "user",
-				content: {
-					type: "text",
-					text: `Build this UI with the project's design system: ${task}
-
-Work like this:
-1. Find components: search_components for each piece of the UI (for example "confirm a destructive action"), or list_components for an overview.
-2. Read the contract: get_component for every component you use. Use only the props and variant values it lists, and compose parts the way its examples do.
-3. Style with tokens: get_tokens when you need a color, spacing or radius. Never write hex/rgb colors, arbitrary px values or Tailwind default palette classes such as bg-blue-500.
-4. Use design-system components instead of native elements (<Button>, not <button>).
-5. Verify: run check_ui on the code you wrote, fix every error, and run it again until it reports none.
-
-Design system: ${components || "no components found"}.
-Tokens: ${tokens || "none"}.${"catalog" in found ? `\n\nThis is a monorepo root with ${found.set.dirs.length} projects (${found.set.dirs.join(", ")}): pass \`path\` with the file you are writing to get_component, get_tokens and check_ui, so they answer for its project.` : ""}`
-				}
-			}]
-		};
-	});
-	return server;
-}
-//#endregion
-//#region src/workspace.ts
-/**
-* What marks the folder a file belongs to: the nearest one at or above it with a config,
-* a components.json, a package.json or an Nx project.json. The Claude Code hook finds a
-* file's project the same way, so `check` from a workspace root and the hook agree on
-* every file.
-*/
-const PROJECT_MARKERS = [
-	...CONFIG_FILES,
-	...LEGACY_CONFIG_FILES,
-	"components.json",
-	"package.json",
-	"project.json"
-];
-/**
-* A monorepo seen from its root: every workspace package with a design system (an app
-* that uses one, or the design-system package itself), and how to find the project of
-* any file in it. Without a design system at the root, `check`, `inspect` and the MCP
-* server work from here, each file checked by its own project's design system.
-*/
-var Workspace = class {
-	root;
-	source;
-	projects;
-	others;
-	configFile;
-	options;
-	rootConfig;
-	bare = /* @__PURE__ */ new Map();
-	constructor(root, source, projects, others, configFile, options, rootConfig) {
-		this.root = root;
-		this.source = source;
-		this.projects = projects;
-		this.others = others;
-		this.configFile = configFile;
-		this.options = options;
-		this.rootConfig = rootConfig;
-	}
-	/**
-	* The project `target` (a file or a folder) belongs to: the nearest folder at or above
-	* it with one of the `PROJECT_MARKERS`, as the hook finds it, up to the workspace root. A folder that holds no design system still gets
-	* its config, so its files are checked as `check` from that folder would check them.
-	*/
-	async projectFor(target) {
-		const dir = projectDirOf(path.resolve(this.root, target), this.root);
-		const known = this.projects.find((p) => p.root === dir);
-		if (known) return known;
-		let project = this.bare.get(dir);
-		if (!project) {
-			project = dir === this.root ? Promise.resolve(this.rootProject()) : this.load(dir);
-			this.bare.set(dir, project);
-		}
-		return project;
-	}
-	rootProject() {
-		return {
-			root: this.root,
-			dir: ".",
-			name: packageName(this.root),
-			config: this.rootConfig
-		};
-	}
-	/** A project's config read again, as `check` from its folder would read it. */
-	configFor(project) {
-		return project.root === this.root ? loadConfig(this.options) : loadProjectConfig(project.root, this.root, this.configFile, this.options);
-	}
-	async load(dir) {
-		return {
-			root: dir,
-			dir: relativePath(this.root, dir) || ".",
-			name: packageName(dir),
-			config: await loadProjectConfig(dir, this.root, this.configFile, this.options)
-		};
-	}
-};
-/**
-* The config at `root`, or a `Workspace` when `root` is a monorepo root with no design
-* system of its own. The root is one project, as before, when a config file or
-* `--components` sets the components, when `--config`, `--tokens` or `--docs` is given,
-* or when zero config finds a design system there.
-*/
-async function loadTarget(options) {
-	const config = await loadConfig(options);
-	if (options.config !== void 0 || Boolean(options.components?.length) || Boolean(options.tokens?.length) || Boolean(options.docs?.length) || config.configured || !isWorkspaceRoot(config.root)) return { config };
-	if (config.detected !== void 0 || (await componentFiles(config)).length) return { config };
-	return {
-		config,
-		workspace: await discoverWorkspace(config, options)
-	};
-}
-/** Every workspace package with a design system, and the rest by folder. */
-async function discoverWorkspace(rootConfig, options) {
-	const { root } = rootConfig;
-	const source = [
-		workspacePatterns(root).source,
-		fs.existsSync(path.join(root, "nx.json")) ? "nx.json" : "",
-		fs.existsSync(path.join(root, "turbo.json")) ? "turbo.json" : ""
-	].filter(Boolean).join(", ");
-	const projects = [];
-	const others = [];
-	for (const dir of workspacePackageDirs(root)) {
-		const config = await loadProjectConfig(dir, root, rootConfig.configFile, options);
-		const files = (await componentFiles(config)).length;
-		const own = config.configFile !== void 0 && config.configFile !== rootConfig.configFile;
-		if (files || own) projects.push({
-			root: dir,
-			dir: relativePath(root, dir),
-			name: packageName(dir),
-			config,
-			componentFiles: files
-		});
-		else others.push(relativePath(root, dir));
-	}
-	return new Workspace(root, source, projects, others, rootConfig.configFile, options, rootConfig);
-}
-/**
-* A project's config: its own config file, or the workspace root's, with paths relative to
-* the workspace root, or zero config. CLI flags that apply to every project carry over.
-*/
-function loadProjectConfig(dir, workspaceRoot, rootConfigFile, options) {
-	const shared = {
-		cwd: options.cwd,
-		includeDesignSystem: options.includeDesignSystem
-	};
-	if ([...CONFIG_FILES, ...LEGACY_CONFIG_FILES].some((name) => fs.existsSync(path.join(dir, name))) || !rootConfigFile) return loadConfig({
-		...shared,
-		root: dir
-	});
-	return loadConfig({
-		...shared,
-		root: dir,
-		config: rootConfigFile,
-		base: workspaceRoot
-	});
-}
-/** The nearest folder at or above `target` (a file or folder) with a project marker, up to `root`. */
-function projectDirOf(target, root) {
-	let dir = isDirectory(target) ? target : path.dirname(target);
-	while (isInside(root, dir) && dir !== root) {
-		if (PROJECT_MARKERS.some((name) => fs.existsSync(path.join(dir, name)))) return dir;
-		dir = path.dirname(dir);
-	}
-	return root;
-}
-function packageName(dir) {
-	try {
-		const name = JSON.parse(fs.readFileSync(path.join(dir, "package.json"), "utf8")).name;
-		return typeof name === "string" ? name : void 0;
-	} catch {
-		return;
-	}
-}
-function isDirectory(target) {
-	try {
-		return fs.statSync(target).isDirectory();
-	} catch {
-		return false;
-	}
-}
-//#endregion
-//#region src/catalog.ts
-/**
-* Every project's components and tokens in one list, for a workspace root when no path
-* picks a project. A component used by several projects (a design-system package) is
-* listed once, tagged with its package; two different components under one name are both
-* listed, each with its package, and a lookup by that name returns both.
-*/
-var Catalog = class {
-	root;
-	projects;
-	entries;
-	tokens;
-	index;
-	constructor(root, projects) {
-		this.root = root;
-		this.projects = projects;
-		const byKey = /* @__PURE__ */ new Map();
-		const owner = packageOwner(root);
-		for (const { ds, dir } of projects) for (const component of ds.components) {
-			const file = path.resolve(ds.root, component.source.file);
-			const key = `${file}\0${component.name}`;
-			const known = byKey.get(key);
-			if (known) {
-				if (!known.projects.includes(dir)) known.projects.push(dir);
-				if (isBare(component.importPath) && !isBare(known.component.importPath)) {
-					known.component = rebase(component, root, file);
-					known.ds = ds;
-				}
-				continue;
-			}
-			byKey.set(key, {
-				component: rebase(component, root, file),
-				ds,
-				package: owner(file),
-				projects: [dir],
-				ambiguous: false
-			});
-		}
-		this.entries = [...byKey.values()];
-		const names = /* @__PURE__ */ new Map();
-		for (const entry of this.entries) names.set(entry.component.name, (names.get(entry.component.name) ?? 0) + 1);
-		for (const entry of this.entries) entry.ambiguous = (names.get(entry.component.name) ?? 0) > 1;
-		this.index = buildSearchIndex(this.entries.map((e) => e.component));
-		const tokens = /* @__PURE__ */ new Map();
-		for (const { ds, dir } of projects) for (const token of ds.getTokens()) {
-			const file = path.resolve(ds.root, token.source.file);
-			const key = `${file}\0${token.name}\0${token.value}`;
-			const known = tokens.get(key);
-			if (known) {
-				if (!known.projects.includes(dir)) known.projects.push(dir);
-				continue;
-			}
-			tokens.set(key, {
-				token: {
-					...token,
-					source: {
-						...token.source,
-						file: relativePath(root, file)
-					}
-				},
-				ds,
-				package: owner(file),
-				projects: [dir]
-			});
-		}
-		this.tokens = [...tokens.values()];
-	}
-	/** Top-level components, not parts of another. */
-	roots() {
-		return this.entries.filter((e) => !e.component.parent);
-	}
-	/** Every distinct component a name resolves to, through each project's lookup. */
-	find(name) {
-		const found = [];
-		for (const { ds } of this.projects) {
-			const component = ds.getComponent(name);
-			if (!component) continue;
-			const file = path.resolve(ds.root, component.source.file);
-			const entry = this.entries.find((e) => e.component.name === component.name && path.resolve(this.root, e.component.source.file) === file);
-			if (entry && !found.includes(entry)) found.push(entry);
-		}
-		return found;
-	}
-	suggest(name) {
-		return closest(name, unique(this.entries.map((e) => e.component.name)), .5);
-	}
-	search(query, limit = 5) {
-		return searchComponents(this.index, query, limit).flatMap((hit) => {
-			const entry = this.entries.find((e) => e.component === hit.component);
-			return entry ? [{
-				...hit,
-				entry
-			}] : [];
-		});
-	}
-	/** Tokens as `get_tokens` filters them, core ones before scoped families. */
-	getTokens(filter = {}) {
-		const query = filter.query?.toLowerCase();
-		const scoped = (t) => Number(t.ds.tokenIndex.scopedFamilyOf(t.token) !== void 0);
-		return this.tokens.filter(({ token: t }) => (!filter.category || t.category === filter.category) && (!query || t.name.toLowerCase().includes(query) || (t.description ?? "").toLowerCase().includes(query) || t.usage.some((u) => u.toLowerCase().includes(query)))).sort((a, b) => scoped(a) - scoped(b));
-	}
-};
-/** A specifier apps import by package name, not a relative path or a tsconfig alias. */
-function isBare(specifier) {
-	return !/^(?:\.|@\/|~\/|#)/.test(specifier);
-}
-function rebase(component, root, file) {
-	return {
-		...component,
-		source: {
-			...component.source,
-			file: relativePath(root, file)
-		}
-	};
-}
-/** The name of the package a file belongs to (its nearest package.json), cached per folder. */
-function packageOwner(root) {
-	const names = /* @__PURE__ */ new Map();
-	return (file) => {
-		const visited = [];
-		let name;
-		for (let dir = path.dirname(file);; dir = path.dirname(dir)) {
-			const known = names.get(dir);
-			if (known !== void 0) {
-				name = known;
-				break;
-			}
-			visited.push(dir);
-			try {
-				const pkg = JSON.parse(fs.readFileSync(path.join(dir, "package.json"), "utf8"));
-				name = typeof pkg.name === "string" ? pkg.name : relativePath(root, dir) || ".";
-				break;
-			} catch {}
-			if (dir === root || dir === path.dirname(dir)) {
-				name = relativePath(root, dir) || ".";
-				break;
-			}
-		}
-		for (const dir of visited) names.set(dir, name);
-		return name;
-	};
-}
-//#endregion
-//#region src/server/projects.ts
-/**
-* A workspace root's projects for the MCP server: one `DesignSystemHost` per project,
-* created on first use and watched from then on, and the merged catalog, rebuilt when a
-* project reloads.
-*/
-var WorkspaceProjects = class {
-	workspace;
-	options;
-	hosts = /* @__PURE__ */ new Map();
-	merged;
-	constructor(workspace, options) {
-		this.workspace = workspace;
-		this.options = options;
-	}
-	get root() {
-		return this.workspace.root;
-	}
-	get dirs() {
-		return this.workspace.projects.map((p) => p.dir);
-	}
-	async forPath(target) {
-		const absolute = path.resolve(this.root, target);
-		if (!isInside(this.root, absolute)) throw new Error(`${target} is outside the workspace root (${this.root}).`);
-		const project = await this.workspace.projectFor(absolute);
-		return {
-			ds: await this.host(project).get(),
-			dir: project.dir,
-			name: project.name
-		};
-	}
-	async all() {
-		const served = [];
-		for (const project of this.workspace.projects) served.push({
-			ds: await this.host(project).get(),
-			dir: project.dir,
-			name: project.name
-		});
-		return served;
-	}
-	async catalog() {
-		const all = await this.all();
-		const from = all.map((p) => p.ds);
-		if (this.merged?.from.length !== from.length || this.merged.from.some((ds, i) => ds !== from[i])) this.merged = {
-			from,
-			catalog: new Catalog(this.root, all)
-		};
-		return this.merged.catalog;
-	}
-	close() {
-		for (const host of this.hosts.values()) host.close();
-		this.hosts.clear();
-	}
-	host(project) {
-		let host = this.hosts.get(project.root);
-		if (host) return host;
-		host = new DesignSystemHost(project.config, {
-			cache: this.options.cache,
-			logger: this.options.logger,
-			loadConfig: () => this.workspace.configFor(project)
-		});
-		host.onChange(() => this.options.onChange?.());
-		if (this.options.watch) host.watch();
-		this.hosts.set(project.root, host);
-		return host;
-	}
-};
-//#endregion
-//#region src/server/stdio.ts
-/**
-* Starts the server (on stdio unless another transport is given), for clients on
-* either protocol era: a 2026-07-28 client (stateless, `server/discover`) and a
-* 2025-era one (the `initialize` handshake) are both served, the era chosen by the
-* client's first message.
-*
-* The project root comes from `--root` or `--config`, a config file in the working
-* directory, or the working directory itself when it holds a project (a
-* package.json, a components.json). MCP roots, which the 2026-07-28 revision
-* deprecates, are the fallback for a 2025-era client that starts servers somewhere
-* else (Claude Desktop starts them in `/`): its first `file://` root. At a monorepo
-* root with no design system of its own, every project in it is served.
-*/
-function serveStdio$1(options) {
-	const { logger } = options;
-	let resolveHost = () => void 0;
-	let rejectHost = () => void 0;
-	const hostReady = new Promise((resolve, reject) => {
-		resolveHost = resolve;
-		rejectHost = reject;
-	});
-	hostReady.catch(() => void 0);
-	const instances = /* @__PURE__ */ new Set();
-	const notify = () => {
-		for (const server of instances) {
-			if (!server.isConnected()) continue;
-			server.server.sendResourceListChanged().catch((error) => {
-				logger.warn(`could not notify the client: ${error.message}`);
-			});
-		}
-	};
-	const closers = [];
-	let started = false;
-	let askingRoots = false;
-	const start = async (root) => {
-		if (started) return;
-		started = true;
-		try {
-			const { config, workspace } = await loadTarget({
-				...options,
-				root
-			});
-			for (const text of config.deprecations ?? []) logger.warn(text);
-			if (workspace) {
-				const projects = new WorkspaceProjects(workspace, {
-					cache: options.cache,
-					watch: options.watch,
-					logger,
-					onChange: notify
-				});
-				logger.info(`monorepo root: ${workspace.projects.length} of ${workspace.projects.length + workspace.others.length} workspace packages have a design system${workspace.projects.length ? ` (${workspace.projects.map((p) => p.dir).join(", ")})` : ""}`);
-				closers.push(() => {
-					projects.close();
-				});
-				resolveHost({ projects });
-				return;
-			}
-			if (config.detected) logger.info(`found the design system through ${config.detected}`);
-			const host = new DesignSystemHost(config, {
-				cache: options.cache,
-				logger,
-				loadConfig: () => loadConfig({
-					...options,
-					root
-				})
-			});
-			host.onChange(notify);
-			if (options.watch) host.watch();
-			host.get().catch((error) => {
-				logger.error(error.message);
-			});
-			closers.push(() => {
-				host.close();
-			});
-			resolveHost({ host });
-		} catch (error) {
-			logger.error(error.message);
-			rejectHost(error);
-		}
-	};
-	const configured = options.root !== void 0 || options.config !== void 0 || [...CONFIG_FILES, ...LEGACY_CONFIG_FILES].some((file) => fs.existsSync(path.join(options.cwd, file)));
-	const cwdIsProject = PROJECT_MARKERS.some((file) => fs.existsSync(path.join(options.cwd, file)));
-	if (configured || cwdIsProject) start(options.root);
-	/** The working directory, when nothing else has said where the project is by the first request. */
-	const ready = async () => {
-		if (!started && !askingRoots) start(void 0);
-		return hostReady;
-	};
-	const factory = ({ era }) => {
-		const server = createServer({
-			getDesignSystem: async () => {
-				const served = await ready();
-				if ("host" in served) return served.host.get();
-				throw new Error("This server serves a workspace root: pass a path.");
-			},
-			getProjects: async () => {
-				const served = await ready();
-				return "projects" in served ? served.projects : void 0;
-			}
-		});
-		instances.add(server);
-		if (!started && era === "legacy") server.server.oninitialized = () => {
-			askingRoots = true;
-			clientRoot(server).then((root) => {
-				if (root && root !== options.cwd) logger.info(`using client root ${root}`);
-				return start(root);
-			});
-		};
-		return server;
-	};
-	const handle = serveStdio(factory, {
-		...options.transport ? { transport: options.transport } : {},
-		onerror: (error) => {
-			logger.warn(error.message);
-		}
-	});
-	logger.info(options.transport ? "ready" : "ready on stdio");
-	return Promise.resolve({ close: async () => {
-		for (const close of closers.splice(0)) close();
-		await handle.close();
-	} });
-}
-/** First `file://` root the client reports, if it supports roots (deprecated in 2026-07-28). */
-async function clientRoot(server) {
-	if (!server.server.getClientCapabilities()?.roots) return void 0;
-	try {
-		const { roots } = await server.server.listRoots(void 0, { timeout: 3e3 });
-		const uri = roots.find((r) => r.uri.startsWith("file://"))?.uri;
-		return uri ? fileURLToPath(uri) : void 0;
-	} catch {
-		return;
-	}
-}
-//#endregion
-export { CONFIG_FILES as A, loadConfig as B, loadTokens as C, attachDocs as D, parseCssTokens as E, DEFAULT_TEST_FOLDERS as F, unique as G, findVariantDefinitions as H, LEGACY_CONFIG_FILES as I, toPosix as J, matchesGlob as K, RULE_IDS as L, DEFAULT_DOCS as M, DEFAULT_SEVERITY as N, parseDoc as O, DEFAULT_TEST_EXCLUDE as P, configJsonSchema as R, TokenIndex as S, parseDtcgTokens as T, detectProject as U, rulesFor as V, plural$1 as W, RULES as _, DesignSystem as a, uncheckedNotice as b, componentFiles as c, tokenFiles as d, NAME as f, searchComponents as g, stderrLogger as h, createServer as i, ConfigError as j, extractComponents as k, fingerprint as l, silentLogger as m, loadTarget as n, DesignSystemHost as o, VERSION as p, relativePath as q, INSTRUCTIONS as r, buildModel as s, serveStdio$1 as t, loadDesignSystem as u, applyFixes as v, mergeTokens as w, formatDiagnostics as x, checkSource as y, defineConfig as z };
+export { plural$1 as $, parseDtcgTokens as A, DEFAULT_TEST_FOLDERS as B, updateBaseline as C, loadTokens as D, TokenIndex as E, CONFIG_FILES as F, loadConfig as G, RULE_IDS as H, ConfigError as I, detectProject as J, rulesFor as K, DEFAULT_DOCS as L, attachDocs as M, parseDoc as N, mergeTokens as O, extractComponents as P, closest as Q, DEFAULT_SEVERITY as R, readBaseline as S, RULES as T, configJsonSchema as U, LEGACY_CONFIG_FILES as V, defineConfig as W, workspacePackageDirs as X, isWorkspaceRoot as Y, workspacePatterns as Z, VERSION as _, fingerprint as a, toPosix as at, applyBaseline as b, silentLogger as c, searchComponents as d, truncate as et, applyFixes as f, NAME as g, formatDiagnostics as h, componentFiles as i, relativePath as it, parseCssTokens as j, formatPx as k, stderrLogger as l, uncheckedNotice as m, DesignSystemHost as n, isInside as nt, loadDesignSystem as o, checkSource as p, findVariantDefinitions as q, buildModel as r, matchesGlob as rt, tokenFiles as s, DesignSystem as t, unique as tt, buildSearchIndex as u, BASELINE_FILE as v, writeBaseline as w, countBaseline as x, LEGACY_BASELINE_FILE as y, DEFAULT_TEST_EXCLUDE as z };