onsystem 0.6.0 → 0.7.0

package/dist/eslint-worker.d.ts

@@ -1,4 +1,4 @@
-import { h as DesignSystemModel, i as ResolvedConfig } from "./config-lbfW91qB.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 { H as DEFAULT_TEST_EXCLUDE, U as DEFAULT_TEST_FOLDERS, _t as relativePath, gt as matchesGlob, i as componentFiles, r as buildModel } from "./design-system-A3pRX3Ka.js";
-import { r as loadTarget } from "./workspace-CHvUwgz9.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";

package/dist/eslint.js

@@ -1,4 +1,4 @@
-import { H as DEFAULT_TEST_EXCLUDE, T as RULES, U as DEFAULT_TEST_FOLDERS, V as DEFAULT_SEVERITY, _ as VERSION, _t as relativePath, g as NAME, t as DesignSystem } from "./design-system-A3pRX3Ka.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 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-lbfW91qB.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";
@@ -214,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`). */
@@ -311,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

package/dist/index.js

@@ -1,3 +1,3 @@
-import { $ as findVariantDefinitions, A as toDtcg, D as loadTokens, E as TokenIndex, F as attachDocs, G as RULE_IDS, I as parseDoc, K as configJsonSchema, L as extractComponents, M as parseDtcgTokens, N as parseDesignMd, O as mergeTokens, P as parseCssTokens, T as RULES, Y as loadConfig, _ as VERSION, a as fingerprint, d as searchComponents, f as applyFixes, h as formatDiagnostics, k as toDesignMd, n as DesignSystemHost, o as loadDesignSystem, p as checkSource, q as defineConfig, r as buildModel, t as DesignSystem } from "./design-system-A3pRX3Ka.js";
-import { n as INSTRUCTIONS, r as createServer, t as serveStdio } from "./stdio-CEChNFLR.js";
+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-CEChNFLR.js → stdio-BojAQ6JP.js}

@@ -1,5 +1,5 @@
-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 { $ 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";
@@ -7,6 +7,211 @@ 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/explain.ts
+/**
+* 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.
+*/
+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
 /**
 * Tool results are read by models, so they are rendered as compact Markdown:
@@ -814,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 }) => {
@@ -872,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",
@@ -1393,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 };

package/dist/{workspace-CHvUwgz9.js → workspace-Z0tZf_Dv.js}

@@ -1,4 +1,4 @@
-import { J as hasOwnConfig, R as CONFIG_FILES, W as LEGACY_CONFIG_FILES, X as loadConfigWith, Y as loadConfig, _t as relativePath, ct as isWorkspaceRoot, ht as isInside, i as componentFiles, lt as workspacePackageDirs, ot as findDesignSystemPackage, rt as PackageFinder, ut as workspacePatterns } from "./design-system-A3pRX3Ka.js";
+import { $ as loadConfig, Ct as relativePath, H as CONFIG_FILES, J as LEGACY_CONFIG_FILES, Q as hasOwnConfig, et as loadConfigWith, ft as findDesignSystemPackage, gt as workspacePatterns, ht as workspacePackageDirs, i as componentFiles, lt as PackageFinder, mt as isWorkspaceRoot, xt as isInside } from "./design-system-C4bhqLLw.js";
 import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "onsystem",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "mcpName": "io.github.dgesteves/onsystem",
-  "description": "Keeps coding agents on your design system: it knows your real components, props, variants and tokens, catches the moment an agent invents one and has it fix it, and the same check gates your PRs. Local, zero config, works alongside @shadcn/lint.",
+  "description": "Keeps coding agents on your design system: catches palette colors, native elements and APIs your system lacks, at every edit and pull request, with the fix. Set it up once in your design-system package; every app in your monorepo gets it.",
   "keywords": [
     "design-system",
     "design-system-lint",
@@ -69,10 +69,10 @@
     "tinyglobby": "^0.2.17",
     "typescript": "~6.0.3",
     "yaml": "^2.9.1",
-    "zod": "^4.6.5"
+    "zod": "^4.6.6"
   },
   "peerDependencies": {
-    "eslint": ">=9.0.0"
+    "eslint": ">=8.57.0"
   },
   "peerDependenciesMeta": {
     "eslint": {
@@ -86,7 +86,7 @@
     "@modelcontextprotocol/client": "^2.3.1",
     "@modelcontextprotocol/sdk": "^1.32.1",
     "@types/culori": "^4.0.1",
-    "@types/node": "^24.19.1",
+    "@types/node": "^24.19.2",
     "ajv": "^8.20.0",
     "ajv-draft-04": "^1.0.0",
     "ajv-formats": "^3.0.1",
@@ -96,11 +96,11 @@
     "geist": "^1.7.2",
     "globals": "^17.13.0",
     "opentype.js": "^2.0.0",
-    "prettier": "^3.9.9",
+    "prettier": "^3.9.10",
     "publint": "^0.3.25",
-    "react-aria-components": "^1.21.1",
+    "react-aria-components": "^1.22.1",
     "tailwind-variants": "^3.3.1",
-    "tsdown": "^0.23.0",
+    "tsdown": "^0.23.1",
     "typescript-eslint": "^8.71.1",
     "vitest": "^5.0.3"
   },
@@ -114,7 +114,7 @@
     "test": "vitest run",
     "test:watch": "vitest",
     "smoke": "node scripts/smoke.mjs",
-    "pack-test": "node scripts/pack-test.mjs",
+    "pack-test": "node scripts/pack-test.mjs && node scripts/pack-test-eslint8.mjs",
     "assets": "node scripts/build-assets.mjs",
     "palette": "node scripts/build-palette.mjs",
     "sync-plugins": "node scripts/sync-plugins.mjs",