onsystem 0.4.0 → 0.6.0

package/dist/stdio-CEChNFLR.js

@@ -0,0 +1,1396 @@
+import { Q as formatPx, R as CONFIG_FILES, W as LEGACY_CONFIG_FILES, Y as loadConfig, _ as VERSION, _t as relativePath, d as searchComponents, dt as closest, ft as plural, g as NAME, ht as isInside, j as TOKEN_CATEGORIES, m as uncheckedNotice, mt as unique, n as DesignSystemHost, pt as truncate, u as buildSearchIndex } from "./design-system-A3pRX3Ka.js";
+import { n as hasProjectMarker, r as loadTarget, t as findProjectRoot } from "./workspace-CHvUwgz9.js";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import * as z from "zod";
+import fsp from "node:fs/promises";
+import { McpServer, ResourceTemplate } from "@modelcontextprotocol/server";
+import { serveStdio } from "@modelcontextprotocol/server/stdio";
+//#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 "";
+	const sentence = /^[\s\S]*?[.!?](?=\s+[A-Z`"(]|\s*$)/.exec(text.trim())?.[0] ?? text.trim();
+	return truncate(sentence.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(roots.length, "component")}${parts ? ` (+${plural(parts, "part")})` : ""}${project ? ` in ${project}` : ""}. Call get_component before using one.`, ""];
+	const own = roots.filter((c) => !c.library);
+	for (const component of own) lines.push(...listItem(component));
+	for (const library of new Set(roots.flatMap((c) => c.library ? [c.library] : []))) {
+		if (own.length) lines.push("");
+		lines.push(`From ${library} (import { Name } from "${library}"):`, "");
+		for (const component of roots.filter((c) => c.library === library)) lines.push(...listItem(component, "", false));
+	}
+	return lines.join("\n");
+}
+function listItem(component, note = "", withImport = true) {
+	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(", ")}`);
+	if (withImport) 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(roots.length, "component")}${parts ? ` (+${plural(parts, "part")})` : ""} from ${plural(byPackage.size, "package")}, used by ${plural(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) {
+			if (!Object.values(variant.classes).some(Boolean)) {
+				lines.push(`${variant.name}: ${variant.values.join(" | ")}${variant.default ? ` (default "${variant.default}")` : ""}`);
+				continue;
+			}
+			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://onsystem.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://onsystem.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(result.errorCount, "error")}, ${plural(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,
+	destructiveHint: false,
+	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. When the server was started outside your project, pass the file as an absolute path: the project is found from it.");
+/**
+* Thrown by `getDesignSystem` or `getProjects` when nothing says which project a request is
+* about: the server was started outside any project, and the request names no absolute path.
+* Tools return its message as an error result; listing resources returns none.
+*/
+var ProjectNotFoundError = class extends Error {
+	name = "ProjectNotFoundError";
+};
+/** 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?.(target);
+		if (!set) return { ds: await getDesignSystem(target) };
+		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;
+	/** `scope` without a target, for listings: none yet, when no project is known. */
+	const listed = async () => {
+		try {
+			return await scope();
+		} catch (error) {
+			if (error instanceof ProjectNotFoundError) return void 0;
+			throw error;
+		}
+	};
+	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), or absolute."),
+			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. When the server was started outside your project, pass it as an absolute path: the project is found from 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 routeBy = code === void 0 ? filePath : filename ?? void 0;
+		const set = await getProjects?.(routeBy);
+		let ds;
+		if (!set) ds = await getDesignSystem(routeBy);
+		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 (filename) {
+			const absolute = path.resolve(base, filename);
+			if (set || isInside(ds.root, absolute)) file = relativePath(ds.root, absolute);
+		}
+		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([fsp.realpath(base), fsp.realpath(absolute)]);
+				if (!isInside(root, real)) return outside;
+				if ((await fsp.stat(real)).size > MAX_CODE) return {
+					isError: true,
+					content: [{
+						type: "text",
+						text: `${filePath} is too large to check.`
+					}]
+				};
+				source = await fsp.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 = file === shown ? checked : {
+			...checked,
+			file: shown
+		};
+		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 listed();
+			if (!found) return { resources: [] };
+			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 listed();
+			if (!found) return [];
+			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/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: component.library ?? 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.
+*
+* When none of those gives a project (a client that starts servers in the home or the
+* plugin's folder and reports no roots), each request's project is found from the
+* absolute path it names (`findProjectRoot`): the nearest folder at or above it with a
+* project marker, or the monorepo root above that, served as if the server had been
+* started there, except that a config there is read only when it is JSON: a prompt can
+* choose the path, so a JavaScript or TypeScript config is not run. Each root found is
+* loaded once and kept; a request without an absolute path is answered from the one root
+* found so far.
+*/
+function serveStdio$1(options) {
+	const { logger } = options;
+	let decide = () => void 0;
+	const decided = new Promise((resolve) => {
+		decide = resolve;
+	});
+	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 = [];
+	/**
+	* The project at `root` (the working directory when undefined), or a monorepo root's
+	* projects. `jsonConfigOnly` for a root found from a tool call's path: its configs, and those
+	* of the projects in it, are read only when they are JSON, never run.
+	*/
+	const load = async (root, jsonConfigOnly = false) => {
+		const configOptions = {
+			...options,
+			root,
+			jsonConfigOnly
+		};
+		const { config, workspace } = await loadTarget(configOptions);
+		for (const text of config.deprecations ?? []) logger.warn(text);
+		for (const text of (workspace ? workspace.warnings : config.warnings) ?? []) 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();
+			});
+			return { projects };
+		}
+		if (config.detected) logger.info(`found the design system through ${config.detected}`);
+		const host = new DesignSystemHost(config, {
+			cache: options.cache,
+			logger,
+			loadConfig: () => loadConfig(configOptions)
+		});
+		host.onChange(notify);
+		if (options.watch) host.watch();
+		host.get().catch((error) => {
+			logger.error(error.message);
+		});
+		closers.push(() => {
+			host.close();
+		});
+		return { host };
+	};
+	let started = false;
+	/** One project for every request: the one at `root`, or the working directory. */
+	const serveOne = (root) => {
+		if (started) return;
+		started = true;
+		const served = load(root);
+		served.catch((error) => {
+			logger.error(error.message);
+		});
+		decide(() => served);
+	};
+	/** Each request's project, from the absolute path it names. */
+	const serveByPath = () => {
+		if (started) return;
+		started = true;
+		logger.info(`${options.cwd} holds no project and the client reported no roots: finding each request's project from the absolute path it names`);
+		const found = /* @__PURE__ */ new Map();
+		decide(async (target) => {
+			if (target !== void 0 && path.isAbsolute(target)) {
+				const dir = findProjectRoot(target);
+				if (!dir) throw new ProjectNotFoundError(`No project at or above ${target}: no folder from there up holds a package.json, components.json, project.json or onsystem config (the home folder and the filesystem root do not count). Pass the absolute path of a file in your project.`);
+				let served = found.get(dir);
+				if (!served) {
+					logger.info(`using ${dir}, the project of ${target}`);
+					served = load(dir, true);
+					served.catch((error) => {
+						logger.error(error.message);
+					});
+					found.set(dir, served);
+				}
+				return served;
+			}
+			const [only, ...others] = found.values();
+			if (only && !others.length) return only;
+			throw new ProjectNotFoundError(only ? `Requests have named files in ${found.size} projects (${[...found.keys()].join(", ")}). Pass \`path\` (for check_ui with \`code\`, \`filename\`) as the absolute path of the file you are editing, so the answer comes from its project.` : `onsystem cannot tell which project to answer for: it was started in ${options.cwd}, which holds no project, and the client reported no workspace roots. Pass \`path\` (for check_ui with \`code\`, \`filename\`) as the absolute path of the file you are editing, and it answers from that file's project. Or start the server with --root <project folder>.`);
+		});
+	};
+	if (options.root !== void 0 || options.config !== void 0 || [...CONFIG_FILES, ...LEGACY_CONFIG_FILES].some((file) => fs.existsSync(path.join(options.cwd, file))) || hasProjectMarker(options.cwd)) serveOne(options.root);
+	/**
+	* When nothing else says where the project is: the working directory when flags
+	* (`--components`, `--tokens`, `--docs`) describe it, else each request's path.
+	*/
+	const fallback = () => {
+		if (options.components?.length || options.tokens?.length || options.docs?.length) serveOne(void 0);
+		else serveByPath();
+	};
+	let askingRoots = false;
+	/** What answers requests, once decided; nothing has said where the project is by the first request. */
+	const resolve = async (target) => {
+		if (!started && !askingRoots) fallback();
+		return (await decided)(target);
+	};
+	const factory = ({ era }) => {
+		const server = createServer({
+			getDesignSystem: async (target) => {
+				const served = await resolve(target);
+				if ("host" in served) return served.host.get();
+				throw new Error("This server serves a workspace root: pass a path.");
+			},
+			getProjects: async (target) => {
+				const served = await resolve(target);
+				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) {
+					fallback();
+					return;
+				}
+				if (root !== options.cwd) logger.info(`using client root ${root}`);
+				serveOne(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 { INSTRUCTIONS as n, createServer as r, serveStdio$1 as t };