onsystem 0.5.0 → 0.7.0

package/dist/eslint-worker.d.ts

@@ -1,4 +1,4 @@
-import { a as DesignSystemModel, x as ResolvedConfig } from "./types-DJtccu3A.js";
+import { h as DesignSystemModel, i as ResolvedConfig } from "./config-1XSTYI44.js";
 import { MessagePort } from "node:worker_threads";
 //#region src/eslint/worker.d.ts
 export interface LoadRequest {

package/dist/eslint-worker.js

@@ -1,5 +1,5 @@
-import { B as DEFAULT_TEST_FOLDERS, i as componentFiles, it as relativePath, r as buildModel, rt as matchesGlob, z as DEFAULT_TEST_EXCLUDE } from "./design-system-CnEv5sIL.js";
-import { r as loadTarget } from "./workspace-DzWQ4L8R.js";
+import { Ct as relativePath, K as DEFAULT_TEST_EXCLUDE, St as matchesGlob, i as componentFiles, q as DEFAULT_TEST_FOLDERS, r as buildModel } from "./design-system-C4bhqLLw.js";
+import { r as loadTarget } from "./workspace-Z0tZf_Dv.js";
 import fs from "node:fs";
 import path from "node:path";
 import { parentPort } from "node:worker_threads";
@@ -9,6 +9,8 @@ import { parentPort } from "node:worker_threads";
 * project's design system does not (config files written in code, globs, the extraction
 * cache), so the plugin asks this worker and waits for the answer (see `bridge.ts`).
 */
+/** What the configs said (a design-system package's skipped, or its paths ignored), each said once. */
+const warned = /* @__PURE__ */ new Set();
 /** How long a loaded design system is trusted before its files are looked at again. */
 const FRESH_MS = 2e3;
 const targets = /* @__PURE__ */ new Map();
@@ -44,6 +46,11 @@ async function targetFor({ cwd, root, config }) {
 async function load(request) {
 	const target = await targetFor(request);
 	const config = target.workspace ? (await target.workspace.projectFor(request.file)).config : target.config;
+	for (const text of config.warnings ?? []) {
+		if (warned.has(text)) continue;
+		warned.add(text);
+		process.stderr.write(`onsystem: ${text}\n`);
+	}
 	let project = projects.get(config.root);
 	if (!project || Date.now() - project.at >= FRESH_MS) {
 		const { model, key } = await buildModel(config, { cache: true });

package/dist/eslint.js

@@ -1,4 +1,4 @@
-import { B as DEFAULT_TEST_FOLDERS, R as DEFAULT_SEVERITY, T as RULES, _ as VERSION, g as NAME, it as relativePath, t as DesignSystem, z as DEFAULT_TEST_EXCLUDE } from "./design-system-CnEv5sIL.js";
+import { Ct as relativePath, G as DEFAULT_SEVERITY, K as DEFAULT_TEST_EXCLUDE, _ as NAME, k as RULES, q as DEFAULT_TEST_FOLDERS, t as DesignSystem, v as VERSION } from "./design-system-C4bhqLLw.js";
 import path from "node:path";
 import { MessageChannel, Worker, receiveMessageOnPort } from "node:worker_threads";
 //#region src/eslint/bridge.ts
@@ -96,8 +96,63 @@ function run(cwd, file, text, settings) {
 		designSystems.set(response.root, entry);
 	}
 	if (!entry) return { error: `no design system loaded for ${response.root}` };
-	const result = entry.ds.check(text, relativePath(entry.ds.root, file));
-	return result.skipped ? { skipped: true } : { result };
+	const { ds } = entry;
+	const relative = relativePath(ds.root, file);
+	const result = ds.check(text, relative);
+	if (result.skipped) return { skipped: true };
+	return {
+		result,
+		fromSystem: (specifier) => ds.lint.isDesignSystemImport(specifier, relative)
+	};
+}
+/**
+* The name an edit gives a JSX tag when that name does not mean the component there: `Button`
+* for `<button>` → `<Button>` in a file that does not import it, imports it as a type only, or
+* imports another `Button` from outside the design system. Applied, such a rename leaves a file
+* that does not compile.
+*/
+function unboundRename(sourceCode, edit, fromSystem) {
+	if (!edit.text.includes(".") && /^[a-z]/.test(edit.text)) return;
+	const [start, end] = edit.range;
+	let node = sourceCode.getNodeByRangeIndex(start);
+	while (node && (node.range[0] !== start || node.range[1] !== end)) node = node.parent ?? null;
+	const tag = node?.parent;
+	if (!node || !tag || !["JSXOpeningElement", "JSXClosingElement"].includes(tag.type)) return;
+	if (tag.name !== node) return;
+	const name = edit.text.split(".")[0] ?? edit.text;
+	for (let scope = sourceCode.getScope(node); scope; scope = scope.upper) {
+		const values = scope.set.get(name)?.defs.filter((def) => !typeOnly(def)) ?? [];
+		if (!values.length) continue;
+		return values.some((def) => isComponent(def, fromSystem)) ? void 0 : edit.text;
+	}
+	return edit.text;
+}
+/**
+* Whether a value binding can be the component a rename names: an import from the design
+* system, or a function, class, variable or parameter of the file. Not an import of the same
+* name from elsewhere (`Table<TData>` from @tanstack/react-table without `type`, an app's own
+* `Label`), nor an enum or a namespace.
+*/
+function isComponent(def, fromSystem) {
+	if (def.type === "ImportBinding") {
+		const source = def.parent?.source?.value;
+		return typeof source === "string" && fromSystem(source);
+	}
+	return [
+		"FunctionName",
+		"ClassName",
+		"Variable",
+		"Parameter"
+	].includes(def.type);
+}
+/**
+* A binding that is only a type: a type alias, interface or type parameter (typescript-eslint's
+* `Type` definition), or `import type { Button }` and `import { type Button }` (its `importKind`).
+*/
+function typeOnly(def) {
+	if (def.type === "Type") return true;
+	const kind = (node) => node?.importKind;
+	return def.type === "ImportBinding" && (kind(def.node) === "type" || kind(def.parent) === "type");
 }
 function createRule(id, description) {
 	return {
@@ -108,6 +163,7 @@ function createRule(id, description) {
 				url: `${RULES_PAGE}#${id}`
 			},
 			fixable: "code",
+			hasSuggestions: true,
 			schema: []
 		},
 		create(context) {
@@ -128,7 +184,9 @@ function createRule(id, description) {
 				}
 				for (const d of outcome.result.diagnostics) {
 					if (d.ruleId !== id) continue;
-					const edits = d.fix;
+					const edits = d.fix ?? [];
+					const fix = (fixer) => edits.map((e) => fixer.replaceTextRange(e.range, e.text));
+					const unbound = edits.map((e) => unboundRename(context.sourceCode, e, outcome.fromSystem)).find((name) => name !== void 0);
 					context.report({
 						loc: {
 							start: {
@@ -141,7 +199,10 @@ function createRule(id, description) {
 							}
 						},
 						message: d.message,
-						...edits?.length ? { fix: (fixer) => edits.map((e) => fixer.replaceTextRange(e.range, e.text)) } : {}
+						...!edits.length ? {} : unbound ? { suggest: [{
+							desc: `Rename to <${unbound}>, then import it`,
+							fix
+						}] } : { fix }
 					});
 				}
 			} };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { C as RuleId, D as loadConfig, E as defineConfig, O as ImportMapping, S as ResolvedRule, T as configJsonSchema, _ as VariantInfo, a as DesignSystemModel, b as RULE_IDS, c as ExampleInfo, d as Severity, f as SourceLocation, g as TokenCategory, h as Token, i as CompoundVariantInfo, l as InheritedProps, m as TextEdit, n as ComponentDocs, o as Diagnostic, p as TOKEN_CATEGORIES, r as ComponentInfo, s as DocSection, t as CheckResult, u as PropInfo, v as Config, w as RuleOptions, x as ResolvedConfig, y as LoadConfigOptions } from "./types-DJtccu3A.js";
+import { C as TOKEN_CATEGORIES, D as VariantInfo, E as TokenCategory, O as ImportMapping, S as SourceLocation, T as Token, _ as DocSection, a as ResolvedRule, b as PropInfo, c as configJsonSchema, d as CheckResult, f as ComponentDocs, g as Diagnostic, h as DesignSystemModel, i as ResolvedConfig, l as defineConfig, m as CompoundVariantInfo, n as LoadConfigOptions, o as RuleId, p as ComponentInfo, r as RULE_IDS, s as RuleOptions, t as Config, u as loadConfig, v as ExampleInfo, w as TextEdit, x as Severity, y as InheritedProps } from "./config-1XSTYI44.js";
 import ts from "typescript";
 import { Oklch } from "culori";
 import { McpServer, Transport } from "@modelcontextprotocol/server";
@@ -115,6 +115,12 @@ export declare function parseCssTokens(css: string, file: string): {
   warnings: string[];
 };
 //#endregion
+//#region src/tokens/design-md.d.ts
+export declare function parseDesignMd(text: string, file: string): {
+  tokens: Token[];
+  warnings: string[];
+};
+//#endregion
 //#region src/tokens/dtcg.d.ts
 interface DtcgOptions {
   /** Prefix for generated custom property names: `ds` → `--ds-color-primary`. */
@@ -125,6 +131,34 @@ export declare function parseDtcgTokens(text: string, file: string, options?: Dt
   warnings: string[];
 };
 //#endregion
+//#region src/tokens/export.d.ts
+/**
+ * Writes the tokens onsystem found as a DTCG 2025.10 file or a DESIGN.md. Both are grouped by
+ * category; reading the DTCG file back gives the same tokens, with the same names.
+ */
+interface Exported {
+  text: string;
+  /** How many tokens were written. */
+  count: number;
+  /** Tokens left out, and why. */
+  warnings: string[];
+}
+/**
+ * The tokens as a DTCG 2025.10 file: a group per category, colors as color objects in their
+ * own color space, lengths as `{ value, unit }`, aliases as references, and what DTCG has no
+ * field for (the token's name, the custom property, the Tailwind theme variable, dark and
+ * other modes) under `$extensions["com.github.dgesteves.onsystem"]`.
+ */
+export declare function toDtcg(tokens: readonly Token[]): Exported;
+/**
+ * The tokens as a DESIGN.md: front matter with the colors, typography, rounded corners and
+ * spacing in the spec's schema, then a heading per category with a table of its tokens, their
+ * values in each mode and how code uses them.
+ */
+export declare function toDesignMd(tokens: readonly Token[], options: {
+  name: string;
+}): Exported;
+//#endregion
 //#region src/tokens/index.d.ts
 interface TokenSource {
   file: string;
@@ -180,8 +214,19 @@ interface ColorSuggestion {
   reason?: 'far' | 'hue' | 'role' | 'status' | 'scoped' | undefined;
   /** With reason `status`: how far apart the hues are, in degrees. */
   hueOff?: number | undefined;
+  /**
+   * With reason `role`: a token that is close and of the same hue but made for
+   * another role (`content-muted`, a text color, for a border), when it is not the nearest.
+   */
+  otherRole?: Nearest<ColorCandidate> | undefined;
   /** Other tokens with the nearest one's value. */
   sameValue: Token[];
+  /**
+   * With a match that is no status color: a close status color of the color's hue that is
+   * about as near (within STATUS_MARGIN), so the color may mean that status (a red error
+   * message next to a rose brand), and the match is no sure fix.
+   */
+  closeStatus?: Nearest<ColorCandidate> | undefined;
 }
 interface NearestLength extends Nearest<LengthCandidate> {
   /** A radius so far above the scale that it means "fully rounded" (`rounded-full`). */
@@ -261,6 +306,8 @@ declare class LintTarget {
   private readonly moduleDirs;
   /** The files extraction read, when the model says. */
   private readonly sources?;
+  /** Published libraries the model read from type declarations: `@mui/material`. */
+  readonly libraries: Set<string>;
   /**
    * `resolver` finds the module an import points at and what it exports
    * (`@calcom/ui/components/icon` → `components/icon/index.ts`), so a name from
@@ -275,6 +322,14 @@ declare class LintTarget {
    * directory itself (a barrel: `../components/ui` and its index).
    */
   isDesignSystemImport(specifier: string, fromFile?: string): boolean;
+  /**
+   * Whether the component rules judge the components imported from `specifier`: it points at
+   * the design system, and the model has components to judge them by. A model with none (an
+   * app whose design-system package publishes only compiled `dist/`) still matches the
+   * configured `importPath`, but the component rules do not run there, as `check` says, so
+   * what comes from it is not called invented.
+   */
+  checksImport(specifier: string, fromFile?: string): boolean;
   /**
    * Whether `name`, imported from the design system, may be a real export the
    * model left out rather than an invented one: its module exists outside the
@@ -316,6 +371,10 @@ declare class LintTarget {
   /** The component a module exports as `default`, for `import Anything from "..."`. */
   defaultExport(specifier: string, fromFile?: string): ComponentInfo | undefined;
   private resolveRelative;
+  /** The library an import specifier points into (`@mui/material/Button`), if any. */
+  libraryOf(specifier: string): string | undefined;
+  /** The library's own component of that name: `Button` from `@mui/material`, not a wrapper. */
+  libraryComponent(name: string, library: string): ComponentInfo | undefined;
   /** Component names for "did you mean" suggestions. */
   names(): string[];
 }
@@ -480,6 +539,12 @@ export declare class DesignSystem {
   readonly config: ResolvedConfig;
   readonly lint: LintTarget;
   private readonly searchIndex;
+  /**
+   * The components the tools offer: all of them, except a library's (MUI's) where the project
+   * has its own of that name, a wrapper the team means to be used. The rules still check code
+   * that imports the library's directly against the library's.
+   */
+  private readonly offered;
   constructor(model: DesignSystemModel, config: ResolvedConfig);
   get root(): string;
   get components(): ComponentInfo[];
@@ -498,6 +563,14 @@ export declare class DesignSystem {
   }): Token[];
   /** Tokens a component's classes and CSS variables reference, e.g. `bg-primary` → `primary`. */
   relatedTokens(component: ComponentInfo): Token[];
+  /**
+   * Whether `check --require-design-system` (and the GitHub Action, where it is on by default)
+   * finds a design system to check against: components and color tokens, or components from a
+   * published library (MUI). A library is the design system whatever its theme: when the theme's
+   * colors cannot be read (a palette from Sass variables), the check still runs and `notice()`
+   * says that no-hardcoded-color did not.
+   */
+  hasDesignSystem(): boolean;
   /**
    * What the rules could not check, when it matters: without components the
    * component rules find nothing, and without color tokens neither does

package/dist/index.js

@@ -1,3 +1,3 @@
-import { A as parseDtcgTokens, D as loadTokens, E as TokenIndex, G as loadConfig, H as RULE_IDS, M as attachDocs, N as parseDoc, O as mergeTokens, P as extractComponents, T as RULES, U as configJsonSchema, W as defineConfig, _ as VERSION, a as fingerprint, d as searchComponents, f as applyFixes, h as formatDiagnostics, j as parseCssTokens, n as DesignSystemHost, o as loadDesignSystem, p as checkSource, q as findVariantDefinitions, r as buildModel, t as DesignSystem } from "./design-system-CnEv5sIL.js";
-import { n as INSTRUCTIONS, r as createServer, t as serveStdio } from "./stdio-DjfkiDMV.js";
-export { DesignSystem, DesignSystemHost, INSTRUCTIONS, RULES, RULE_IDS, TokenIndex, VERSION, applyFixes, attachDocs, buildModel, checkSource, configJsonSchema, createServer, defineConfig, extractComponents, findVariantDefinitions, fingerprint, formatDiagnostics, loadConfig, loadDesignSystem, loadTokens, mergeTokens, parseCssTokens, parseDoc, parseDtcgTokens, searchComponents, serveStdio };
+import { $ as loadConfig, A as TokenIndex, B as parseDoc, I as parseDtcgTokens, L as parseDesignMd, M as mergeTokens, N as toDesignMd, P as toDtcg, R as parseCssTokens, V as extractComponents, X as configJsonSchema, Y as RULE_IDS, Z as defineConfig, a as fingerprint, d as searchComponents, f as applyFixes, g as formatDiagnostics, j as loadTokens, k as RULES, n as DesignSystemHost, o as loadDesignSystem, p as checkSource, r as buildModel, rt as findVariantDefinitions, t as DesignSystem, v as VERSION, z as attachDocs } from "./design-system-C4bhqLLw.js";
+import { n as INSTRUCTIONS, r as createServer, t as serveStdio } from "./stdio-BojAQ6JP.js";
+export { DesignSystem, DesignSystemHost, INSTRUCTIONS, RULES, RULE_IDS, TokenIndex, VERSION, applyFixes, attachDocs, buildModel, checkSource, configJsonSchema, createServer, defineConfig, extractComponents, findVariantDefinitions, fingerprint, formatDiagnostics, loadConfig, loadDesignSystem, loadTokens, mergeTokens, parseCssTokens, parseDesignMd, parseDoc, parseDtcgTokens, searchComponents, serveStdio, toDesignMd, toDtcg };

package/dist/{stdio-DjfkiDMV.js → stdio-BojAQ6JP.js}

@@ -1,25 +1,216 @@
-import { $ as plural, F as CONFIG_FILES, G as loadConfig, Q as closest, V as LEGACY_CONFIG_FILES, _ as VERSION, d as searchComponents, et as truncate, g as NAME, it as relativePath, k as formatPx, m as uncheckedNotice, n as DesignSystemHost, nt as isInside, tt as unique, u as buildSearchIndex } from "./design-system-CnEv5sIL.js";
-import { n as hasProjectMarker, r as loadTarget, t as findProjectRoot } from "./workspace-DzWQ4L8R.js";
+import { $ as loadConfig, Ct as relativePath, F as TOKEN_CATEGORIES, G as DEFAULT_SEVERITY, H as CONFIG_FILES, J as LEGACY_CONFIG_FILES, Tt as defaultProjectConfig, Y as RULE_IDS, _ as NAME, _t as closest, at as LIBRARY_IDS, bt as unique, d as searchComponents, dt as detectProject, ft as findDesignSystemPackage, it as LIBRARIES, m as uncheckedNotice, n as DesignSystemHost, nt as formatPx, ot as libraryTitle, st as notReadYet, u as buildSearchIndex, v as VERSION, vt as plural, xt as isInside, yt as truncate } from "./design-system-C4bhqLLw.js";
+import { n as hasProjectMarker, r as loadTarget, t as findProjectRoot } from "./workspace-Z0tZf_Dv.js";
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import * as z from "zod";
-import fs$1 from "node:fs/promises";
+import fsp from "node:fs/promises";
 import { McpServer, ResourceTemplate } from "@modelcontextprotocol/server";
 import { serveStdio } from "@modelcontextprotocol/server/stdio";
-//#region src/types.ts
+//#region src/explain.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.
+* What `inspect --explain` says about one project: every candidate zero config looked
+* at and why each was taken or not, the config it resolved to, tokens whose value did
+* not resolve, and components without props, with the likely reason.
 */
-const TOKEN_CATEGORIES = [
-	"color",
-	"spacing",
-	"radius",
-	"typography",
-	"shadow",
-	"other"
-];
+function explainProject(ds, cwd, indent = "") {
+	const { config, model } = ds;
+	const lines = [];
+	const out = (line = "") => lines.push(line ? `${indent}${line}` : "");
+	out("How the design system was found");
+	for (const step of packageSteps(config, cwd)) out(`  ${(step.accepted ? "found" : "no").padEnd(6)} ${step.candidate}: ${step.reason}`);
+	if (config.configured) out(`  components come from ${config.configFile ? display(cwd, config.configFile) : "--components"}, so zero config did not look`);
+	else {
+		const steps = [];
+		detectProject(config.root, config.tsconfig, steps, config.designSystemPackage);
+		for (const step of steps) out(`  ${(step.accepted ? "found" : "no").padEnd(6)} ${step.candidate}: ${step.reason}`);
+		if (!config.detected) out(`  So the defaults apply: ${config.components.join(", ")}${model.stats.files.components ? "" : ", which match nothing"}.`);
+	}
+	const named = (library) => `${library.package}${library.version ? ` ${library.version}` : ""}`;
+	for (const library of config.libraries ?? []) {
+		const count = model.components.filter((c) => c.library === library.package).length;
+		out(library.dir ? `  ${"found".padEnd(6)} ${named(library)}: a dependency, ${count} components from its type declarations in ${display(cwd, library.dir)}` : `  ${"no".padEnd(6)} ${named(library)}: a dependency, but not installed`);
+	}
+	for (const library of config.librariesOff ?? []) out(`  ${"no".padEnd(6)} ${named(library)}: a dependency, ${librariesLeftOut(config, cwd)}`);
+	for (const library of config.librariesUnread ?? []) out(`  ${"no".padEnd(6)} ${named(library)}: ${notReadYet()}`);
+	out();
+	out("Resolved config");
+	const field = (name, value) => out(`  ${name.padEnd(12)} ${value}`);
+	field("root", config.root);
+	field("config", config.configFile ? `${display(cwd, config.configFile)}${config.designSystemPackage ? ` (declared by ${config.designSystemPackage.name})` : ""}` : "(none)");
+	field("components", listOf$3(config.components) || "(none)");
+	field("exclude", listOf$3(config.exclude));
+	field("tokens", listOf$3(config.tokens.map((t) => `${t.path}${t.prefix ? ` (prefix ${t.prefix})` : ""}${t.fallback ? " (when nothing else is found)" : ""}`)));
+	field("docs", listOf$3(config.docs));
+	const projectConfig = defaultProjectConfig(config.root);
+	field("tsconfig", config.tsconfig ?? (projectConfig ? display(config.root, projectConfig) : "(none)"));
+	field("importPath", importPaths(ds));
+	field("libraries", config.libraryIds === void 0 ? `every library onsystem reads (${LIBRARY_IDS.join(", ")})` : config.libraryIds !== false && config.libraryIds.length ? config.libraryIds.join(", ") : `none ("libraries": ${JSON.stringify(config.libraryIds)})`);
+	if (config.tailwindConfig) field("tailwind", display(config.root, config.tailwindConfig));
+	if (config.designSystems) field("primary", config.designSystems.map((d, i) => `${i ? "then " : ""}${d.source} (${d.imports} imports)`).join("; "));
+	const changed = RULE_IDS.filter((id) => config.rules[id].severity !== DEFAULT_SEVERITY[id]);
+	field("rules", `${RULE_IDS.map((id) => `${id} ${config.rules[id].severity}`).join(", ")}${changed.length ? ` (changed: ${changed.join(", ")})` : ""}`);
+	if (config.overrides?.length) for (const override of config.overrides) field("override", `${override.files.join(", ")}: ${Object.entries(override.rules).map(([id, rule]) => `${id} ${rule.severity}`).join(", ")}`);
+	if (config.base) field("relative to", `${config.base} (a config at the workspace root)`);
+	out();
+	out("Tokens");
+	const found = ds.tokens;
+	const files = model.stats.files.tokens;
+	const themed = found.filter((t) => t.origin === "library");
+	out(`  ${found.length - themed.length} tokens from ${files} ${files === 1 ? "file" : "files"}${files ? "" : `: no file matches ${config.tokens.map((t) => t.path).join(", ")}`}`);
+	if (themed.length) {
+		const sources = [...new Set(themed.map((t) => t.source.file))];
+		out(`  ${themed.length} tokens from a library's theme in ${sources.join(", ")}`);
+	}
+	const defined = new Set(found.map((t) => t.cssVar).filter((v) => Boolean(v)));
+	const missing = (value) => [...value.matchAll(/var\(\s*(--[\w-]+)/g)].map((m) => m[1] ?? "").filter((v) => !defined.has(v));
+	const unresolved = found.filter((t) => missing(t.value).length);
+	if (unresolved.length) out(`  ${unresolved.length} unresolved, reading a custom property no token file defines: ${unresolved.slice(0, 8).map((t) => `${t.cssVar ?? t.name}: ${t.value}`).join(", ")}${unresolved.length > 8 ? `, and ${unresolved.length - 8} more` : ""}`);
+	else if (found.length) out("  every value resolves");
+	for (const warning of model.warnings.filter((w) => /alias|token/i.test(w))) out(`  ${warning}`);
+	out();
+	out("Props");
+	const empty = ds.roots().filter((c) => c.openProps && !c.props.length && !c.inherits.length);
+	const open = ds.components.filter((c) => c.openProps);
+	if (!open.length) out(`  every component's props resolved (${ds.components.length} components)`);
+	else {
+		const installed = nodeModulesFor(config.root);
+		const names = (list) => `${list.slice(0, 6).map((c) => c.name).join(", ")}${list.length > 6 ? ` and ${list.length - 6} more` : ""}`;
+		if (empty.length) out(`  ${empty.length} ${empty.length === 1 ? "component has" : "components have"} 0 props: ${names(empty)}.`);
+		out(`  ${open.length} ${open.length === 1 ? "component has" : "components have"} props that did not fully resolve${empty.length === open.length ? "" : `: ${names(open)}`}, so no-unknown-prop skips ${open.length === 1 ? "it" : "them"}.`);
+		out(installed ? `  Dependencies are installed (${display(cwd, installed)}): a package without types, a type error, or a props type that depends on a type argument leaves them open.` : `  The dependencies are not installed: no node_modules in ${config.root} or a folder above it. Their props come from the packages they wrap (Radix, React Aria), so install them (npm install, pnpm install) and run again.`);
+	}
+	return lines;
+}
+/** Why a library the project depends on is not read: `left out by "libraries" in onsystem.config.json`. */
+function librariesLeftOut(config, cwd) {
+	return `left out by "libraries" in ${config.configFile ? display(cwd, config.configFile) : "the config"}`;
+}
+/** The first few, then how many more: a package's exports can name hundreds of files. */
+function listOf$3(items, max = 8) {
+	const shown = items.slice(0, max).join(", ");
+	return items.length > max ? `${shown}, and ${items.length - max} more` : shown;
+}
+/** How components are suggested to be imported. */
+function importPaths(ds) {
+	if (ds.config.importPath) return `${ds.config.importPath} (from the config)`;
+	const counts = /* @__PURE__ */ new Map();
+	for (const c of ds.roots()) counts.set(c.importPath, (counts.get(c.importPath) ?? 0) + 1);
+	const top = [...counts].sort((a, b) => b[1] - a[1]).slice(0, 3);
+	const from = ds.config.imports?.length ? "package exports" : "tsconfig paths or relative paths";
+	return top.length ? `inferred from ${from}: ${top.map(([p, n]) => `${p} (${n})`).join(", ")}${counts.size > 3 ? `, and ${counts.size - 3} more` : ""}` : `inferred from ${from}`;
+}
+/** The nearest node_modules at or above `dir`, if any. */
+function nodeModulesFor(dir) {
+	for (let current = path.resolve(dir);; current = path.dirname(current)) {
+		const candidate = path.join(current, "node_modules");
+		if (fs.existsSync(candidate)) return candidate;
+		if (current === path.dirname(current)) return void 0;
+	}
+}
+function display(cwd, file) {
+	const rel = relativePath(cwd, file);
+	return rel && !rel.startsWith("..") ? rel : file;
+}
+/**
+* Whether a dependency's declared config was taken on, for a project without a config of its
+* own: the package it came from and the others that declare one, or that none does.
+*/
+function packageSteps(config, cwd) {
+	const declared = config.designSystemPackage;
+	if (config.configFile && !declared) return [];
+	const lookup = findDesignSystemPackage(config.root);
+	if (!lookup) return [];
+	const candidate = "a design-system package's config";
+	const skipped = lookup.skipped.length ? `; ${lookup.skipped.map((p) => p.name).join(", ")} ${lookup.skipped.length === 1 ? "declares one" : "declare one"} that cannot be read, skipped since installed` : "";
+	if (!declared) return [{
+		candidate,
+		accepted: false,
+		reason: `no dependency declares one ("onsystem" in its package.json) among ${lookup.dependencies} ${lookup.dependencies === 1 ? "dependency" : "dependencies"}${skipped}`
+	}];
+	return [{
+		candidate,
+		accepted: true,
+		reason: `${declared.name} (${declared.installed ? "installed" : "a workspace package"}) declares ${display(cwd, declared.config)}, which this project takes on, with its paths from ${display(cwd, declared.dir)}${lookup.others.length ? `; ${lookup.others.join(", ")} also declare one, not read: one config is taken on, from the package the code imports most` : ""}${skipped}`
+	}];
+}
+//#endregion
+//#region src/not-read.ts
+const LIMITS_DOCS = "https://onsystem.vercel.app/docs/how-it-works#limits";
+/**
+* What `check` and `check_ui` could not read, said after the results as the notice for missing
+* components and tokens is, so a clean result is not mistaken for a checked one: a component
+* library the project depends on that onsystem does not read yet, and dependencies that are not
+* installed. Projects with the same gap share one notice that names them.
+*/
+function notReadNotices(projects) {
+	return [...unreadLibraries(projects), missingDependencies(projects)].filter((notice) => notice !== void 0);
+}
+/**
+* A component library onsystem does not read yet (Chakra UI, Mantine), in a project without
+* components of its own, whose code is then checked by the accessibility rule alone. One notice
+* per set of libraries.
+*/
+function unreadLibraries(projects) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const { ds, dir } of projects) {
+		const packages = (ds.config.librariesUnread ?? []).map((library) => library.package);
+		if (!packages.length || ds.components.length) continue;
+		const key = packages.join(" ");
+		const group = groups.get(key) ?? {
+			packages,
+			dirs: []
+		};
+		if (dir !== void 0) group.dirs.push(dir);
+		groups.set(key, group);
+	}
+	return [...groups.values()].map(({ packages, dirs }) => {
+		const one = packages.length === 1;
+		const names = listOf$2(packages.map((name) => `${libraryTitle(name)} (${name})`), packages.length);
+		const of = dirs.length ? ` of ${listOf$2(dirs)}` : "";
+		return `${names} ${one ? "is a dependency" : "are dependencies"}${of}, but onsystem does not read ${one ? "it" : "them"} yet: of the published component libraries, it reads only ${LIBRARIES.map((l) => l.title).join(", ")} so far. Wrap ${one ? "its" : "their"} components in your own and point "components" in the config at those. See ${LIMITS_DOCS}`;
+	});
+}
+/**
+* Dependencies that are not installed: no `node_modules` at or above a project that declares
+* some, so the props of components that come from them (Radix, React's own) do not resolve and
+* `no-unknown-prop` skips those components. For plain `inspect` too, on stderr.
+*/
+function missingDependencies(projects) {
+	const dirs = [];
+	let skipped = 0;
+	for (const { ds, dir } of projects) {
+		if (ds.config.rules["no-unknown-prop"].severity === "off") continue;
+		const open = ds.components.filter((c) => c.openProps).length;
+		if (!open || nodeModulesFor(ds.config.root) || !declaresDependencies(ds.config.root)) continue;
+		skipped += open;
+		if (dir !== void 0) dirs.push(dir);
+	}
+	if (!skipped) return void 0;
+	return `The dependencies${dirs.length ? ` of ${listOf$2(dirs)}` : ""} are not installed (no node_modules): no-unknown-prop skips ${plural(skipped, "component")} whose props come from them. Install them (npm install, pnpm install) and run again.`;
+}
+/** Whether `root`'s package.json lists dependencies, devDependencies or peerDependencies. */
+function declaresDependencies(root) {
+	try {
+		const pkg = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf8"));
+		return [
+			"dependencies",
+			"devDependencies",
+			"peerDependencies"
+		].some((field) => {
+			const value = pkg[field];
+			return Boolean(value && typeof value === "object" && Object.keys(value).length);
+		});
+	} catch {
+		return false;
+	}
+}
+/** `apps/web`, `apps/web and packages/ui`, `a, b, c and 4 more`. */
+function listOf$2(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`;
+}
 //#endregion
 //#region src/server/render.ts
 /**
@@ -44,15 +235,21 @@ function renderComponentList(ds, project) {
 	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.`, ""];
-	for (const component of roots) lines.push(...listItem(component));
+	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 = "") {
+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(", ")}`);
-	lines.push(`  ${importStatement(component)}`);
+	if (withImport) lines.push(`  ${importStatement(component)}`);
 	return lines;
 }
 /** `apps/web`, `apps/web and packages/ui`, `a, b, c and 4 more`. */
@@ -191,6 +388,10 @@ function renderComponent(ds, component, origin) {
 	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());
@@ -818,7 +1019,7 @@ function createServer({ getDesignSystem, getProjects }) {
 				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.")
+			notice: z.string().optional().describe("Set when no components or no color tokens were found, so rules did not run, when components came from modules the model does not include, when the project depends on a component library onsystem does not read yet, or when its dependencies are not installed.")
 		}),
 		annotations: READ_ONLY
 	}, async ({ code, path: filePath, filename, limit }) => {
@@ -848,16 +1049,16 @@ function createServer({ getDesignSystem, getProjects }) {
 			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)]);
+				const [root, real] = await Promise.all([fsp.realpath(base), fsp.realpath(absolute)]);
 				if (!isInside(root, real)) return outside;
-				if ((await fs$1.stat(real)).size > MAX_CODE) return {
+				if ((await fsp.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");
+				source = await fsp.readFile(real, "utf8");
 			} catch {
 				return {
 					isError: true,
@@ -876,7 +1077,11 @@ function createServer({ getDesignSystem, getProjects }) {
 			file: shown
 		};
 		const capped = capDiagnostics(result, limit);
-		const notice = result.skipped ? void 0 : [ds.notice(), uncheckedNotice([result])].filter(Boolean).join("\n\n") || void 0;
+		const notice = result.skipped ? void 0 : [
+			ds.notice(),
+			...notReadNotices([{ ds }]),
+			uncheckedNotice([result])
+		].filter(Boolean).join("\n\n") || void 0;
 		return {
 			content: [{
 				type: "text",
@@ -1035,7 +1240,7 @@ var Catalog = class {
 			byKey.set(key, {
 				component: rebase(component, root, file),
 				ds,
-				package: owner(file),
+				package: component.library ?? owner(file),
 				projects: [dir],
 				ambiguous: false
 			});
@@ -1265,6 +1470,7 @@ function serveStdio$1(options) {
 		};
 		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,
@@ -1396,4 +1602,4 @@ async function clientRoot(server) {
 	}
 }
 //#endregion
-export { INSTRUCTIONS as n, createServer as r, serveStdio$1 as t };
+export { notReadNotices as a, missingDependencies as i, INSTRUCTIONS as n, explainProject as o, createServer as r, librariesLeftOut as s, serveStdio$1 as t };