onsystem 0.10.2 → 0.11.0

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
-import { $ as DEFAULT_TOKENS, A as unrecordedRules, At as relativePath, B as statusKinds, C as countBaseline, D as pruneBaseline, Dt as isInside, E as onLines, Et as SCRIPT_FILE, It as unique, J as ConfigError, L as toDesignMd, M as writeBaseline, O as readBaseline, Ot as matchesGlob, Pt as plural, R as toDtcg, Rt as readProjectConfig, S as applyBaseline, St as isDesignSystemName, T as goneFiles, Y as DEFAULT_DOCS, _ as formatDiagnostics, _t as PACKAGE_FIELD, b as BASELINE_FILE, bt as detectProject, c as silentLogger, et as FALLBACK_TOKENS, g as escapeData, gt as notReadYet, h as uncheckedNotice, ht as libraryTitle, i as componentFiles, j as updateBaseline, jt as toPosix, k as rulesRun, l as stderrLogger, o as loadDesignSystem, ot as excludedBy, q as CONFIG_FILES, rt as RULE_IDS, s as tokenFiles, tt as LEGACY_CONFIG_FILES, ut as rulesFor, v as NAME, w as findMoves, x as LEGACY_BASELINE_FILE, y as VERSION, yt as declaredConfig } from "./design-system-rl__N6tw.js";
-import { a as notReadNotices, i as missingDependencies, o as explainProject, s as librariesLeftOut, t as serveStdio } from "./stdio-CkczPt_1.js";
-import { r as loadTarget } from "./workspace-INef0Yqt.js";
+import { $ as DEFAULT_TOKENS, A as unrecordedRules, At as relativePath, B as statusKinds, C as countBaseline, D as pruneBaseline, Dt as isInside, E as onLines, Et as SCRIPT_FILE, It as unique, J as ConfigError, L as toDesignMd, M as writeBaseline, O as readBaseline, Ot as matchesGlob, Pt as plural, R as toDtcg, Rt as readProjectConfig, S as applyBaseline, St as isDesignSystemName, T as goneFiles, Y as DEFAULT_DOCS, _ as formatDiagnostics, _t as PACKAGE_FIELD, b as BASELINE_FILE, bt as detectProject, c as silentLogger, et as FALLBACK_TOKENS, g as escapeData, gt as notReadYet, h as uncheckedNotice, ht as libraryTitle, i as componentFiles, j as updateBaseline, jt as toPosix, k as rulesRun, l as stderrLogger, o as loadDesignSystem, ot as excludedBy, q as CONFIG_FILES, rt as RULE_IDS, s as tokenFiles, tt as LEGACY_CONFIG_FILES, ut as rulesFor, v as NAME, w as findMoves, x as LEGACY_BASELINE_FILE, y as VERSION, yt as declaredConfig } from "./design-system-Csqts7Eq.js";
+import { a as notReadNotices, i as missingDependencies, o as explainProject, s as librariesLeftOut, t as serveStdio } from "./stdio-0TpyqZaD.js";
+import { r as loadTarget } from "./workspace-Dbxubo9n.js";
 import fs from "node:fs";
 import path from "node:path";
 import { escapePath, glob } from "tinyglobby";
@@ -324,7 +324,9 @@ function readManifest(root) {
 /**
 * Declares the config in the package's package.json, `"onsystem": "./onsystem.config.json"`,
 * and adds it to `files` when the package lists the files it publishes, so apps that install it
-* get it too. Writes ONSYSTEM.md for the apps' teams unless one exists. Returns what it wrote.
+* get it too. Writes ONSYSTEM.md for the apps' teams unless one exists, and adds it to `files`
+* as well, for the teams of apps that install the package, unless `files` leaves it out
+* (`!ONSYSTEM.md`). Returns what it wrote.
 */
 function declarePackage(root, manifest, name, force, notes) {
 	const written = [];
@@ -336,15 +338,18 @@ function declarePackage(root, manifest, name, force, notes) {
 		changed = true;
 	}
 	const files = Array.isArray(json.files) ? json.files : void 0;
-	if (files && !ships(files, CONFIG_FILE)) {
-		files.push(CONFIG_FILE);
+	const added = [];
+	for (const file of [CONFIG_FILE, GUIDE_FILE]) {
+		if (!files || ships(files, file) || file === "ONSYSTEM.md" && excludes(files, file)) continue;
+		files.push(file);
+		added.push(file);
 		changed = true;
 	}
 	if (changed) {
 		fs.writeFileSync(manifest.file, `${JSON.stringify(json, null, manifest.indent)}${manifest.newline ? "\n" : ""}`);
 		written.push("package.json");
 	}
-	notes.push(`This is a design-system package: package.json declares its config ("${PACKAGE_FIELD}": "${value}"${files ? ", also added to \"files\"" : ""}), which every app that depends on ${name} reads, under its own config when it has one.`);
+	notes.push(`This is a design-system package: package.json declares its config ("${PACKAGE_FIELD}": "${value}"${added.length ? `, with ${added.join(" and ")} added to "files"` : ""}), which every app that depends on ${name} reads, under its own config when it has one.`);
 	const guide = path.join(root, GUIDE_FILE);
 	if (force || !fs.existsSync(guide)) {
 		fs.writeFileSync(guide, consumerGuide(name));
@@ -625,6 +630,14 @@ function aliasFolder(alias, project) {
 		}
 	}
 }
+/** Whether npm's `files` list leaves `file` out with a negated entry: `!ONSYSTEM.md`, `!*.md`. */
+function excludes(files, file) {
+	return files.some((entry) => {
+		if (typeof entry !== "string" || !entry.startsWith("!")) return false;
+		const pattern = entry.slice(1).replace(/^\.?\//, "");
+		return pattern === file || matchesGlob(file, pattern);
+	});
+}
 /** Whether npm's `files` list publishes `file`, a path relative to the package. */
 function ships(files, file) {
 	return files.some((entry) => {

package/dist/{design-system-rl__N6tw.js → design-system-Csqts7Eq.js}

@@ -387,7 +387,7 @@ function moduleFile(base, extensions = MODULE_EXTENSIONS, within) {
 		base,
 		...extensions.map((ext) => `${base}${ext}`),
 		...extensions.map((ext) => path.join(base, `index${ext}`))
-	].find((file) => isFile$1(file) && !/(?:^|[\\/])node_modules[\\/]/.test(within ? path.relative(within, file) : file));
+	].find((file) => isFile$2(file) && !/(?:^|[\\/])node_modules[\\/]/.test(within ? path.relative(within, file) : file));
 }
 const BUILD_CONFIGS = [
 	"tsup",
@@ -580,7 +580,7 @@ function reexports(source) {
 		barrel
 	};
 }
-function isFile$1(file) {
+function isFile$2(file) {
 	try {
 		return fs.statSync(file).isFile();
 	} catch {
@@ -985,7 +985,7 @@ function fromComponentsJson(root, dir, json, project, packages, note = ignore) {
 */
 function withAppStylesheets(root, named) {
 	if (named.every((file) => isInside(root, file))) return named;
-	const own = APP_STYLESHEETS.map((f) => path.join(root, f)).filter(isFile);
+	const own = APP_STYLESHEETS.map((f) => path.join(root, f)).filter(isFile$1);
 	if (!own.length) return named;
 	const imported = new Set(importedStylesheets(own, stylesheetResolver(root)));
 	return [...own, ...named.filter((file) => !imported.has(file))];
@@ -1145,7 +1145,7 @@ function fromPackage(root, dir, pkg, note = ignore, installed = false) {
 	for (const mapping of mappings) {
 		const file = path.resolve(root, mapping.target);
 		if (installed && isCompiledExport(dir, file)) continue;
-		if (mapping.target.includes("*") || !SCRIPT_FILE$1.test(file) || !isFile(file)) {
+		if (mapping.target.includes("*") || !SCRIPT_FILE$1.test(file) || !isFile$1(file)) {
 			add(mapping, COMPONENT_FILE.test(mapping.target));
 			continue;
 		}
@@ -1460,7 +1460,7 @@ function stylesheetResolver(root, { importPath } = {}) {
 		}
 		return designSystems.get(name);
 	};
-	const stylesheet = (file, within) => [file, `${file}.css`].find((f) => f.endsWith(".css") && (within === void 0 || isInside(within, f) && !isBuildOutput(within, f)) && !/(?:^|[\\/])node_modules[\\/]/.test(within === void 0 ? f : path.relative(within, f)) && isFile(f));
+	const stylesheet = (file, within) => [file, `${file}.css`].find((f) => f.endsWith(".css") && (within === void 0 || isInside(within, f) && !isBuildOutput(within, f)) && !/(?:^|[\\/])node_modules[\\/]/.test(within === void 0 ? f : path.relative(within, f)) && isFile$1(f));
 	return (specifier, fromFile) => {
 		if (/^(?:[a-z][\w+.-]*:|\/)/i.test(specifier)) return void 0;
 		const relative = stylesheet(path.resolve(path.dirname(fromFile), specifier), installedPackageOf(fromFile));
@@ -1491,7 +1491,7 @@ function installedStylesheet(dir, subpath) {
 	if (!match) return void 0;
 	const target = exportTargets(match.value, APP_CONDITIONS).map((t) => t.replaceAll("*", match.middle)).find((t) => t.endsWith(".css"));
 	const file = target === void 0 ? void 0 : path.resolve(dir, target);
-	return file && isInside(dir, file) && !isBuildOutput(dir, file) && isFile(file) ? file : null;
+	return file && isInside(dir, file) && !isBuildOutput(dir, file) && isFile$1(file) ? file : null;
 }
 /**
 * The folder of `name` installed from a registry, when zero config reads it as a design system:
@@ -1521,12 +1521,15 @@ function installedPackageOf(file) {
 function exportedFile(dir, subpath, accept) {
 	for (const { middle, value } of exportMatches(dir, subpath)) for (const target of exportTargets(value)) {
 		const file = path.resolve(dir, target.replaceAll("*", middle));
-		if (isInside(dir, file) && accept(file) && isFile(file)) return file;
+		if (isInside(dir, file) && accept(file) && isFile$1(file)) return file;
 	}
 }
 /**
 * The entries of package `dir`'s `exports` that map `subpath`, with what their `*` stands for:
-* an exact subpath first, then the most specific pattern, as Node.js picks them.
+* an exact subpath first, then the patterns, as Node.js orders them (`PATTERN_KEY_COMPARE`): the
+* longest prefix before the `*` first, then the longest key, so `./components/*.js` comes before
+* `./components/*` for `./components/tip.js`. A pattern has one `*`, which stands for at least
+* one character.
 */
 function exportMatches(dir, subpath) {
 	const exports = readJson$1(path.join(dir, "package.json"))?.exports;
@@ -1538,22 +1541,35 @@ function exportMatches(dir, subpath) {
 			if (key === subpath) matches.push({
 				middle: "",
 				value,
-				rank: Infinity
+				rank: Infinity,
+				length: key.length
 			});
 			continue;
 		}
+		if (key.lastIndexOf("*") !== star) continue;
 		const prefix = key.slice(0, star);
 		const suffix = key.slice(star + 1);
-		if (subpath.startsWith(prefix) && subpath.endsWith(suffix) && subpath.length >= prefix.length + suffix.length) {
+		if (subpath.startsWith(prefix) && subpath.endsWith(suffix) && subpath.length > prefix.length + suffix.length) {
 			const middle = subpath.slice(prefix.length, subpath.length - suffix.length);
 			matches.push({
 				middle,
 				value,
-				rank: prefix.length
+				rank: prefix.length,
+				length: key.length
 			});
 		}
 	}
-	return matches.sort((a, b) => b.rank - a.rank);
+	return matches.sort((a, b) => b.rank - a.rank || b.length - a.length);
+}
+/**
+* The targets package `dir`'s `exports` map `subpath` (`./components/tooltip`) to, as written:
+* through the entry Node.js picks (its exact subpath, else the most specific pattern) and every
+* condition but `types`, with `*` filled in. Undefined when no entry maps the subpath; none when
+* the entry blocks it (`null`).
+*/
+function exportedTargets(dir, subpath) {
+	const [match] = exportMatches(dir, subpath);
+	return match && exportTargets(match.value).map((t) => t.replaceAll("*", match.middle));
 }
 /** Every target of an export condition map, in order, but its types, or those of `conditions` alone. */
 function exportTargets(value, conditions) {
@@ -1603,7 +1619,7 @@ function declaredConfig(dir, pkg = readJson$1(path.join(dir, "package.json"))) {
 	if (typeof value !== "string" || !value.endsWith(".json")) return { problem: `${field} is ${JSON.stringify(value)}: it names a JSON config file in the package, such as "./onsystem.config.json".` };
 	const file = path.resolve(dir, value);
 	if (!isInside(dir, file) || file === path.resolve(dir)) return { problem: `${field} names ${JSON.stringify(value)}, which is outside the package.` };
-	if (!isFile(file)) return { problem: `${field} names ${JSON.stringify(value)}, which does not exist.` };
+	if (!isFile$1(file)) return { problem: `${field} names ${JSON.stringify(value)}, which does not exist.` };
 	return { file };
 }
 /**
@@ -1722,7 +1738,7 @@ function scopeOf$1(name) {
 function declaresTypes(dir, pkg) {
 	if (typeof pkg.types === "string" || typeof pkg.typings === "string") return true;
 	const hasTypes = (value) => Array.isArray(value) ? value.some(hasTypes) : value !== null && typeof value === "object" && Object.entries(value).some(([key, nested]) => key === "types" || hasTypes(nested));
-	return hasTypes(pkg.exports) || isFile(path.join(dir, "index.d.ts"));
+	return hasTypes(pkg.exports) || isFile$1(path.join(dir, "index.d.ts"));
 }
 /** Files that hold no component to read: declarations, tests and stories, as `exclude` has them. */
 const NOT_COMPONENT_SOURCES = [
@@ -2061,7 +2077,7 @@ function readJson$1(file) {
 function asRecord(value) {
 	return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
-function isFile(file) {
+function isFile$1(file) {
 	try {
 		return fs.statSync(file).isFile();
 	} catch {
@@ -8130,21 +8146,29 @@ function toDesignMd(tokens, options) {
 		const list = tokens.filter((t) => t.category === section.category);
 		if (!list.length) continue;
 		if (section.key) {
-			const values = {};
+			const values = /* @__PURE__ */ new Map();
+			let steps;
 			for (const token of list) {
+				if (isSpacingUnit(token)) {
+					steps = spacingSteps(token, lookup);
+					continue;
+				}
 				const key = keys.get(token);
 				if (key === void 0) continue;
 				const target = token.aliasOf ? byName.get(token.aliasOf) : void 0;
-				const targetKey = target?.category === token.category && frontMatterValue(target, section.key, lookup) !== void 0 ? keys.get(target) : void 0;
+				const targetKey = section.key !== "typography" && target?.category === token.category && !isSpacingUnit(target) && frontMatterValue(target, section.key, lookup) !== void 0 ? keys.get(target) : void 0;
 				const value = targetKey === void 0 ? frontMatterValue(token, section.key, lookup) : `{${section.key}.${targetKey}}`;
 				if (value === void 0) continue;
-				if (key in values) {
+				if (values.has(key)) {
 					warnings.push(`${token.name} is left out of the front matter: another token has its key`);
 					continue;
 				}
-				values[key] = value;
+				values.set(key, value);
 			}
-			if (Object.keys(values).length) sections[section.key] = values;
+			for (const [key, value] of steps ?? []) if (!values.has(key)) values.set(key, value);
+			const step = (key) => Number.isFinite(Number(key)) ? Number(key) : Infinity;
+			const ordered = steps ? new Map([...values].sort(([a], [b]) => step(a) - step(b) || 0)) : values;
+			if (ordered.size) sections[section.key] = ordered;
 		}
 		body.push("", `## ${section.heading}`, "", section.intro, "", ...table(list, keys));
 	}
@@ -8164,6 +8188,59 @@ function designKeys(tokens) {
 	}
 	return out;
 }
+/** Tailwind's spacing unit, `--spacing`, which `p-4` takes 4 times. */
+function isSpacingUnit(token) {
+	return token.category === "spacing" && token.tailwind === "";
+}
+/** The steps of Tailwind's default spacing scale, `p-0.5` to `p-96`, in spacing units. */
+const SPACING_STEPS = [
+	.5,
+	1,
+	1.5,
+	2,
+	2.5,
+	3,
+	3.5,
+	4,
+	5,
+	6,
+	7,
+	8,
+	9,
+	10,
+	11,
+	12,
+	14,
+	16,
+	20,
+	24,
+	28,
+	32,
+	36,
+	40,
+	44,
+	48,
+	52,
+	56,
+	60,
+	64,
+	72,
+	80,
+	96
+];
+/**
+* Tailwind's spacing unit as the steps it makes: `"4": 1rem` for `p-4`. A DESIGN.md has no
+* multiplier: a reader takes each spacing entry as a step, so the unit alone (`base: 0.25rem`)
+* would make 4px the only one.
+*/
+function spacingSteps(token, lookup) {
+	const plain = PLAIN_LENGTH.exec(token.value.trim());
+	const [amount, unit] = plain ? [Number(plain[1]), plain[2] ?? "px"] : [evaluateLength(token.value, lookup), "px"];
+	const steps = /* @__PURE__ */ new Map();
+	if (amount === void 0 || !Number.isFinite(amount) || amount <= 0) return steps;
+	for (const n of SPACING_STEPS) steps.set(String(n), `${round(n * amount)}${unit}`);
+	return steps;
+}
 function frontMatterValue(token, key, lookup) {
 	const value = token.value.trim();
 	switch (key) {
@@ -8243,6 +8320,7 @@ async function loadTokens(root, sources) {
 	const warnings = [];
 	const all = [];
 	const sheets = [];
+	const sheetFiles = [];
 	let sheetsAt;
 	for (const source of sources) {
 		const rel = relativePath(root, source.file);
@@ -8266,6 +8344,7 @@ async function loadTokens(root, sources) {
 				warnings.push(...result.warnings);
 			} else {
 				sheets.push(readCssSheet(text, rel));
+				sheetFiles.push(rel);
 				sheetsAt ??= all.length;
 			}
 		} catch (error) {
@@ -8273,6 +8352,9 @@ async function loadTokens(root, sources) {
 		}
 	}
 	if (sheets.length) {
+		const partial = sheets.findIndex((s) => s.theme.size > 0 || s.resets.size > 0);
+		const sheet = sheets[partial];
+		if (sheet && !sheets.some((s) => s.tailwind) && await runsTailwindV4(root)) sheet.tailwind = sheetFiles[partial];
 		const result = cssSheetTokens(sheets);
 		all.splice(sheetsAt ?? all.length, 0, ...result.tokens);
 		warnings.push(...result.warnings);
@@ -8282,24 +8364,65 @@ async function loadTokens(root, sources) {
 		warnings
 	};
 }
+/** The packages that run Tailwind CSS v4 in a build: PostCSS's, Vite's and its CLI. */
+const TAILWIND_V4_PACKAGES = [
+	"@tailwindcss/postcss",
+	"@tailwindcss/vite",
+	"@tailwindcss/cli"
+];
+/**
+* Whether the project at `root` runs Tailwind CSS v4, whose default theme has a spacing unit and
+* the radius scale up to `rounded-4xl`: its package.json depends on a package that runs v4, or on
+* `tailwindcss` in a range that is not v3's (`^3.4.1`, `~3.4`, `3.x`), which has neither. Its
+* plugins (`@tailwindcss/typography`) say nothing of the version.
+*/
+async function runsTailwindV4(root) {
+	let pkg;
+	try {
+		pkg = JSON.parse(await fsp.readFile(path.join(root, "package.json"), "utf8"));
+	} catch {
+		return false;
+	}
+	if (typeof pkg !== "object" || pkg === null) return false;
+	const lists = [];
+	for (const field of [
+		"dependencies",
+		"devDependencies",
+		"peerDependencies"
+	]) {
+		const dependencies = pkg[field];
+		if (typeof dependencies === "object" && dependencies !== null) lists.push(dependencies);
+	}
+	if (lists.some((list) => TAILWIND_V4_PACKAGES.some((name) => Object.hasOwn(list, name)))) return true;
+	const declared = lists.find((list) => Object.hasOwn(list, "tailwindcss"));
+	return declared !== void 0 && !beforeV4(declared.tailwindcss);
+}
+/** A range of Tailwind CSS v3 or older in package.json: `^3.4.1`, `~3`, `3.x`, `^2 || ^3`. */
+function beforeV4(range) {
+	return typeof range === "string" && range.split("||").every((alternative) => /^(?:npm:tailwindcss@)?[\^~=v]*\s*[0-3](?:\.|$)/.test(alternative.trim()));
+}
 /**
 * DTCG files and the CSS generated from them often describe the same tokens.
 * Merge entries that share a custom property: keep the DTCG name and
-* description, and add the Tailwind mapping from CSS.
+* description, and add the Tailwind mapping from CSS. A token without one (a
+* `@theme inline` value, `rounded-sm`) merges with the token of its name and
+* Tailwind key, such as the one a DTCG file exported from the stylesheet has.
 */
 function mergeTokens(tokens) {
 	const overridden = new Set(tokens.filter((t) => t.origin !== "tailwind-default").map((t) => themeKey(t)));
-	const byVar = /* @__PURE__ */ new Map();
+	const byKey = /* @__PURE__ */ new Map();
 	const out = [];
 	for (const token of tokens) {
 		if (token.origin === "tailwind-default" && overridden.has(themeKey(token))) continue;
-		const existing = token.cssVar ? byVar.get(token.cssVar) : void 0;
+		const key = token.cssVar ?? (token.tailwind === void 0 ? void 0 : `${token.name}:${token.tailwind}`);
+		const existing = key === void 0 ? void 0 : byKey.get(key);
 		if (!existing) {
-			if (token.cssVar) byVar.set(token.cssVar, token);
+			if (key !== void 0) byKey.set(key, token);
 			out.push(token);
 			continue;
 		}
 		if (existing.tailwind === void 0 && token.tailwind !== void 0) existing.tailwind = token.tailwind;
+		if (existing.category === "other" && token.category !== "other") existing.category = token.category;
 		existing.usage = [.../* @__PURE__ */ new Set([...token.usage, ...existing.usage])];
 		existing.description ??= token.description;
 		if (token.modes) existing.modes = {
@@ -8976,6 +9099,8 @@ var LintTarget = class {
 	sources;
 	/** Published libraries the model read from type declarations: `@mui/material`. */
 	libraries;
+	/** The name in each package.json read, by its path: undefined where there is none. */
+	manifests = /* @__PURE__ */ new Map();
 	/**
 	* `resolver` finds the module an import points at and what it exports
 	* (`@calcom/ui/components/icon` → `components/icon/index.ts`), so a name from
@@ -9052,14 +9177,49 @@ var LintTarget = class {
 	* model left out rather than an invented one: its module exists outside the
 	* folders extraction read and exports `name`, or re-exports from such a
 	* module (an excluded `icons/` folder, a barrel's `export * from "./icons"`).
-	* A module declared in a package's `exports` but not on disk counts too,
-	* except the design system's own import path.
+	* A module declared in a package's `exports` but not on disk counts too (built to `dist/`,
+	* not built yet), except the design system's own import path, and one whose export, as the
+	* package.json writes it, leads to a source file only: `@acme/ui/components/tooltip` is
+	* `src/components/tooltip.tsx` through `"./components/*": "./src/components/*.tsx"`, and with
+	* no such file it does not exist.
 	*/
 	outsideModel(specifier, name, fromFile = "snippet.tsx") {
 		const location = this.resolver?.locate(specifier, fromFile);
 		if (!location) return false;
-		if (!location.file) return !this.importPaths.has(specifier) && specifier !== this.config.importPath;
-		return this.mayExport(location.file, name, 0);
+		if (location.file) return this.mayExport(location.file, name, 0);
+		if (this.importPaths.has(specifier) || specifier === this.config.importPath) return false;
+		const source = this.exportedSource(specifier);
+		return source === void 0 || this.mayExport(source, name, 0);
+	}
+	/**
+	* The module a design-system package's `exports` lead `specifier` to, relative to the root, as
+	* its package.json writes them: the first of the entry's targets that is on disk, else, when
+	* each of them is a source file, the first (which does not exist). Undefined when a target
+	* leads to a build folder (`"./*": "./dist/components/*.js"`, maybe not built yet, whose
+	* sources may be anywhere), the entry blocks the subpath (`null`), or no entry maps it.
+	*/
+	exportedSource(specifier) {
+		const name = packageOf(specifier);
+		const led = this.config.imports?.find((m) => packageOf(m.specifier) === name);
+		const dir = led && this.packageDir(path.resolve(this.model.root, led.target), name);
+		const targets = dir ? exportedTargets(dir, `.${specifier.slice(name.length)}`) : void 0;
+		if (!dir || !targets?.length) return void 0;
+		const files = targets.map((target) => path.resolve(dir, target));
+		const file = files.flatMap((f) => f.endsWith(".jsx") ? [f, `${f.slice(0, -4)}.tsx`] : [f]).find((f) => isInside(dir, f) && isFile(f)) ?? (targets.every(isSourceFile) ? files[0] : void 0);
+		return file && relativePath(this.model.root, file);
+	}
+	/**
+	* The folder of package `name` that `file` is in: the nearest package.json above it with a
+	* name, when that name is `name`. One without a name (`{"type": "module"}` in a subfolder) is
+	* no package's. Each package.json is read once.
+	*/
+	packageDir(file, name) {
+		for (let dir = path.dirname(file); dir !== path.dirname(dir); dir = path.dirname(dir)) {
+			const manifest = path.join(dir, "package.json");
+			if (!this.manifests.has(manifest)) this.manifests.set(manifest, manifestName(manifest));
+			const found = this.manifests.get(manifest);
+			if (found !== void 0) return found === name ? dir : void 0;
+		}
 	}
 	/**
 	* The component a JSX tag means when `name` is imported from `specifier`, among the
@@ -9236,6 +9396,30 @@ function fit(component, element) {
 function isPackageName(specifier) {
 	return specifier.startsWith("@") ? /^@[^/]+\/[^/]+$/.test(specifier) : /^[a-z0-9][^/]*$/i.test(specifier);
 }
+/** The name a package.json gives its package; undefined when it has none, or there is none. */
+function manifestName(manifest) {
+	try {
+		const { name } = JSON.parse(fs.readFileSync(manifest, "utf8")) ?? {};
+		return typeof name === "string" && name ? name : void 0;
+	} catch {
+		return;
+	}
+}
+function isFile(file) {
+	return fs.statSync(file, { throwIfNoEntry: false })?.isFile() ?? false;
+}
+/** The package an import specifier names: `@acme/ui` for `@acme/ui/components/button`. */
+function packageOf(specifier) {
+	return specifier.split("/").slice(0, specifier.startsWith("@") ? 2 : 1).join("/");
+}
+/**
+* An export target that is a TypeScript or JSX source file (`./src/components/tooltip.tsx`), not
+* a declaration file or a file in a build folder (`./dist/tooltip.tsx`, not built yet).
+*/
+function isSourceFile(target) {
+	if (/\.d\.[cm]?ts$/.test(target) || /^(?:\.\/)?(?:dist|build|lib|out|esm|cjs)\//.test(target)) return false;
+	return /\.(?:[cm]?tsx?|jsx)$/.test(target);
+}
 function stripExtension(file) {
 	return file.replace(/\.(?:[cm]?[jt]sx?)$/, "");
 }
@@ -12124,7 +12308,7 @@ function isObject(value) {
 // package.json
 var name = "onsystem";
 // src/version.ts
-const VERSION = "0.10.2";
+const VERSION = "0.11.0";
 const NAME = name;
 // src/lint/sarif.ts
 const SCHEMA = "https://docs.oasis-open.org/sarif/sarif/v2.1.0/errata01/os/schemas/sarif-schema-2.1.0.json";

package/dist/eslint-worker.d.ts

@@ -31,4 +31,6 @@ export interface Call {
   signal: Int32Array;
   port: MessagePort;
 }
+/** Resolves when the looks under way have ended. Nothing waits on them but tests. */
+export declare function looking(): Promise<unknown>;
 export declare function load(request: LoadRequest): Promise<LoadResponse>;

package/dist/eslint-worker.js

@@ -1,5 +1,6 @@
-import { At as relativePath, i as componentFiles, ot as excludedBy, r as buildModel } from "./design-system-rl__N6tw.js";
-import { r as loadTarget } from "./workspace-INef0Yqt.js";
+import { At as relativePath, a as fingerprint, i as componentFiles, ot as excludedBy, r as buildModel } from "./design-system-Csqts7Eq.js";
+import { r as loadTarget } from "./workspace-Dbxubo9n.js";
+import { createHash } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
 import { parentPort } from "node:worker_threads";
@@ -8,13 +9,25 @@ import { parentPort } from "node:worker_threads";
 * The ESLint plugin's loader, in a worker thread. ESLint rules run synchronously, and finding a
 * 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`).
+*
+* The worker keeps what it loaded and answers from it at once. Once that is two seconds old, the
+* next lint starts a look at the project again (its config, then its design system's files) in
+* the background, and the lints after the look get what it found. Waiting for the look instead
+* held up every lint after a pause in an editor for as long as the look took, which grows with
+* the design system.
 */
 /** 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. */
+/** How long what a look found is used before a lint starts the next look. */
 const FRESH_MS = 2e3;
+/** By where ESLint runs and its settings. */
 const targets = /* @__PURE__ */ new Map();
+/**
+* By target and project root: two targets can reach the same project with configs of their own
+* (runs from two folders, two ESLint configs), and neither may be answered with the other's.
+*/
 const projects = /* @__PURE__ */ new Map();
+const looks = /* @__PURE__ */ new Set();
 function realPath(file) {
 	try {
 		return fs.realpathSync.native(file);
@@ -22,46 +35,122 @@ function realPath(file) {
 		return file;
 	}
 }
-async function targetFor({ cwd, root, config }) {
-	const key = JSON.stringify([
-		cwd,
-		root,
-		config
-	]);
-	const cached = targets.get(key);
-	if (cached && Date.now() - cached.at < FRESH_MS) return cached.target;
-	const target = loadTarget({
+function loadTargetFor({ cwd, root, config }) {
+	return loadTarget({
 		cwd,
 		root: root === void 0 ? void 0 : path.resolve(cwd, root),
 		config: config === void 0 ? void 0 : path.resolve(cwd, config)
 	});
-	targets.set(key, {
+}
+function keep(target) {
+	target.catch(() => void 0);
+	return {
 		at: Date.now(),
 		target
+	};
+}
+/** The config a file is checked with: its own project's, from a monorepo root. */
+async function configFor(target, file) {
+	return target.workspace ? (await target.workspace.projectFor(file)).config : target.config;
+}
+function versionOf(key, config) {
+	return createHash("sha256").update(key).update(JSON.stringify(config)).digest("hex");
+}
+async function build(config) {
+	const { model, key = String(Date.now()), dependencies = [] } = await buildModel(config, { cache: true });
+	const own = new Set((await componentFiles(config)).map(realPath));
+	return {
+		at: Date.now(),
+		key,
+		dependencies,
+		version: versionOf(key, config),
+		config,
+		model,
+		own
+	};
+}
+/**
+* `project` for `config` as the files are now: the same model when nothing it is built from has
+* changed (a config edit that only changes rules, or no change at all), else a new build.
+*/
+async function rebuild(project, config) {
+	if (await fingerprint(config, project.dependencies) !== project.key) return build(config);
+	const { key, dependencies, model, own } = project;
+	return {
+		at: Date.now(),
+		key,
+		dependencies,
+		version: versionOf(key, config),
+		config,
+		model,
+		own
+	};
+}
+/**
+* Runs a look in the background, held in `looks` until it ends. It starts on a later turn of the
+* event loop, after the lint that started it has its answer: the start of a look (finding the
+* project, reading its config, listing the design system's files) runs synchronously, and run at
+* once it held up that answer for as long.
+*/
+function background(look) {
+	const running = new Promise((resolve) => setImmediate(resolve)).then(look).catch(() => void 0).finally(() => looks.delete(running));
+	looks.add(running);
+	return running;
+}
+function projectKey(key, config) {
+	return JSON.stringify([key, config.root]);
+}
+/** A build that fails drops the project, so that the next lint builds it again and says why. */
+function lookAtProject(slot, project, config) {
+	project.looking = background(async () => {
+		try {
+			projects.set(slot, await rebuild(project, config));
+		} catch (error) {
+			if (projects.get(slot) === project) projects.delete(slot);
+			throw error;
+		}
+	});
+	return project.looking;
+}
+function lookAtTarget(key, kept, request) {
+	kept.looking = background(async () => {
+		const loading = loadTargetFor(request);
+		await loading.catch(() => void 0);
+		targets.set(key, keep(loading));
+		const config = await configFor(await loading, request.file);
+		const slot = projectKey(key, config);
+		const project = projects.get(slot);
+		if (project && !project.looking) await lookAtProject(slot, project, config);
 	});
-	return target;
+	return kept.looking;
+}
+/** Resolves when the looks under way have ended. Nothing waits on them but tests. */
+function looking() {
+	return Promise.all(looks);
 }
 async function load(request) {
-	const target = await targetFor(request);
-	const config = target.workspace ? (await target.workspace.projectFor(request.file)).config : target.config;
+	const key = JSON.stringify([
+		request.cwd,
+		request.root,
+		request.config
+	]);
+	let kept = targets.get(key);
+	if (!kept) {
+		kept = keep(loadTargetFor(request));
+		targets.set(key, kept);
+	} else if (!kept.looking && Date.now() - kept.at >= FRESH_MS) lookAtTarget(key, kept, request);
+	const config = await configFor(await kept.target, request.file);
 	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 });
-		const own = new Set((await componentFiles(config)).map(realPath));
-		project = {
-			at: Date.now(),
-			version: key ?? String(Date.now()),
-			config,
-			model,
-			own
-		};
-		projects.set(config.root, project);
-	}
+	const slot = projectKey(key, config);
+	let project = projects.get(slot);
+	if (!project) {
+		project = await build(config);
+		projects.set(slot, project);
+	} else if (!kept.looking && !project.looking && (project.config !== config || Date.now() - project.at >= FRESH_MS)) lookAtProject(slot, project, config);
 	const relative = relativePath(config.root, request.file);
 	const excluded = excludedBy(config, relative, { includeTests: true });
 	if (excluded) return { skip: `excluded by "${excluded}"` };
@@ -89,4 +178,4 @@ parentPort?.on("message", ({ request, signal, port }) => {
 		reply({ error: error.message });
 	});
 });
-export { load };
+export { load, looking };

package/dist/eslint.js

@@ -1,4 +1,4 @@
-import { At as relativePath, N as RULES, Q as DEFAULT_TEST_FOLDERS, X as DEFAULT_SEVERITY, Z as DEFAULT_TEST_EXCLUDE, t as DesignSystem, v as NAME, y as VERSION } from "./design-system-rl__N6tw.js";
+import { At as relativePath, N as RULES, Q as DEFAULT_TEST_FOLDERS, X as DEFAULT_SEVERITY, Z as DEFAULT_TEST_EXCLUDE, m as checkSource, rt as RULE_IDS, t as DesignSystem, ut as rulesFor, v as NAME, y as VERSION } from "./design-system-Csqts7Eq.js";
 import path from "node:path";
 import { MessageChannel, Worker, receiveMessageOnPort } from "node:worker_threads";
 // src/eslint/bridge.ts
@@ -51,7 +51,8 @@ function loadSync(request) {
 * working directory), with the project's config: its `rules` and `overrides` turn rules off
 * per file, `// onsystem-disable-*` comments suppress findings, and the files `check .` leaves
 * out (the config's `exclude`, the design system's own components) are not checked. ESLint's
-* config sets each rule's severity.
+* config sets each rule's severity, and can set a rule's options (`allow`) over the project's.
+* `onsystem/suppression` reports a misspelled rule in a suppression comment, as check does.
 */
 const RULES_PAGE = "https://onsystem.vercel.app/rules";
 /** Design systems by project root, at the version the loader last reported. */
@@ -101,7 +102,25 @@ function run(cwd, file, text, settings) {
 	if (result.skipped) return { skipped: true };
 	return {
 		result,
-		fromSystem: (specifier) => ds.lint.isDesignSystemImport(specifier, relative)
+		fromSystem: (specifier) => ds.lint.isDesignSystemImport(specifier, relative),
+		checkWith(id, options) {
+			const own = rulesFor(ds.config, relative)[id];
+			const off = {
+				severity: "off",
+				options: {}
+			};
+			const rules = Object.fromEntries(RULE_IDS.map((rule) => [rule, rule === id ? {
+				...own,
+				options: {
+					...own.options,
+					...options
+				}
+			} : off]));
+			return checkSource(text, ds.lint, {
+				filename: relative,
+				rules
+			});
+		}
 	};
 }
 /**
@@ -153,27 +172,45 @@ function typeOnly(def) {
 	const kind = (node) => node?.importKind;
 	return def.type === "ImportBinding" && (kind(def.node) === "type" || kind(def.parent) === "type");
 }
+/** A rule's options in ESLint's config, as in onsystem.config.json: `['error', { allow: ['#fff'] }]`. */
+const OPTIONS_SCHEMA = [{
+	type: "object",
+	properties: { allow: {
+		type: "array",
+		items: { type: "string" }
+	} },
+	additionalProperties: false
+}];
+/**
+* Check's misspelled rule names in `// onsystem-disable-*` comments, which suppress nothing. A rule
+* of its own, so that it is a warning, as check reports it, and can be turned off like the others.
+*/
+const SUPPRESSION = "suppression";
 function createRule(id, description) {
+	const suppression = id === SUPPRESSION;
 	return {
 		meta: {
 			type: "problem",
 			docs: {
 				description,
-				url: `${RULES_PAGE}#${id}`
+				url: `${RULES_PAGE}#${suppression ? "suppressing-findings" : id}`
+			},
+			...suppression ? {} : {
+				fixable: "code",
+				hasSuggestions: true
 			},
-			fixable: "code",
-			hasSuggestions: true,
-			schema: []
+			schema: suppression ? [] : OPTIONS_SCHEMA
 		},
 		create(context) {
 			const file = path.resolve(context.cwd, context.filename);
 			const settings = context.settings.onsystem ?? {};
+			const options = context.options?.[0];
 			return { "Program:exit"(node) {
 				const pass = passFor(context, file, settings);
 				const { outcome } = pass;
 				if ("skipped" in outcome) return;
 				if ("error" in outcome) {
-					if (pass.reported) return;
+					if (suppression || pass.reported) return;
 					pass.reported = true;
 					context.report({
 						node,
@@ -181,7 +218,8 @@ function createRule(id, description) {
 					});
 					return;
 				}
-				for (const d of outcome.result.diagnostics) {
+				const { diagnostics } = !suppression && options && Object.keys(options).length ? outcome.checkWith(id, options) : outcome.result;
+				for (const d of diagnostics) {
 					if (d.ruleId !== id) continue;
 					const edits = d.fix ?? [];
 					const fix = (fixer) => edits.map((e) => fixer.replaceTextRange(e.range, e.text));
@@ -209,6 +247,7 @@ function createRule(id, description) {
 	};
 }
 const rules = Object.fromEntries(RULES.map((rule) => [rule.id, createRule(rule.id, rule.description)]));
+rules[SUPPRESSION] = createRule(SUPPRESSION, "Suppression comments must name rules that exist.");
 const plugin = {
 	meta: {
 		name: NAME,
@@ -218,14 +257,17 @@ const plugin = {
 	configs: {}
 };
 /**
-* Every rule at its default severity, for `.tsx` and `.jsx` files other than tests and stories,
-* which `check` also leaves out unless asked (`--include-tests`).
+* Every rule at its default severity, and `suppression` as a warning, for `.tsx` and `.jsx` files
+* other than tests and stories, which `check` also leaves out unless asked (`--include-tests`).
 */
 plugin.configs.recommended = {
 	name: "onsystem/recommended",
 	files: ["**/*.{tsx,jsx}"],
 	ignores: [DEFAULT_TEST_EXCLUDE, DEFAULT_TEST_FOLDERS],
 	plugins: { onsystem: plugin },
-	rules: Object.fromEntries(RULES.map((rule) => [`onsystem/${rule.id}`, DEFAULT_SEVERITY[rule.id]]))
+	rules: {
+		...Object.fromEntries(RULES.map((rule) => [`onsystem/${rule.id}`, DEFAULT_SEVERITY[rule.id]])),
+		[`onsystem/${SUPPRESSION}`]: "warn"
+	}
 };
 export { plugin as default };

package/dist/index.d.ts

@@ -157,7 +157,9 @@ export declare function loadTokens(root: string, sources: TokenSource[]): Promis
 /**
  * DTCG files and the CSS generated from them often describe the same tokens.
  * Merge entries that share a custom property: keep the DTCG name and
- * description, and add the Tailwind mapping from CSS.
+ * description, and add the Tailwind mapping from CSS. A token without one (a
+ * `@theme inline` value, `rounded-sm`) merges with the token of its name and
+ * Tailwind key, such as the one a DTCG file exported from the stylesheet has.
  */
 export declare function mergeTokens(tokens: Token[]): Token[];
 interface ColorCandidate {
@@ -269,7 +271,7 @@ export declare class TokenIndex {
 /** What the lint rules need to know about the design system. */
 declare class LintTarget {
   readonly model: DesignSystemModel;
-  readonly config: Pick<ResolvedConfig, 'elements' | 'importPath'> & Partial<Pick<ResolvedConfig, 'designSystems'>>;
+  readonly config: Pick<ResolvedConfig, 'elements' | 'importPath'> & Partial<Pick<ResolvedConfig, 'designSystems' | 'imports'>>;
   private readonly resolver?;
   readonly components: Map<string, ComponentInfo>;
   /** Every component under each name and alias, when two design systems share one (`Button`). */
@@ -291,13 +293,15 @@ declare class LintTarget {
   private readonly sources?;
   /** Published libraries the model read from type declarations: `@mui/material`. */
   readonly libraries: Set<string>;
+  /** The name in each package.json read, by its path: undefined where there is none. */
+  private readonly manifests;
   /**
    * `resolver` finds the module an import points at and what it exports
    * (`@calcom/ui/components/icon` → `components/icon/index.ts`), so a name from
    * a module the model left out is not taken for an invented one. Without it,
    * every missing name is invented.
    */
-  constructor(model: DesignSystemModel, config: Pick<ResolvedConfig, 'elements' | 'importPath'> & Partial<Pick<ResolvedConfig, 'designSystems'>>, resolver?: Pick<ModuleResolver, "locate" | "exportsOf"> | undefined);
+  constructor(model: DesignSystemModel, config: Pick<ResolvedConfig, 'elements' | 'importPath'> & Partial<Pick<ResolvedConfig, 'designSystems' | 'imports'>>, resolver?: Pick<ModuleResolver, "locate" | "exportsOf"> | undefined);
   /**
    * Whether an import specifier points at the design system. Relative
    * specifiers are resolved against `fromFile` (relative to the root) and
@@ -318,10 +322,27 @@ declare class LintTarget {
    * model left out rather than an invented one: its module exists outside the
    * folders extraction read and exports `name`, or re-exports from such a
    * module (an excluded `icons/` folder, a barrel's `export * from "./icons"`).
-   * A module declared in a package's `exports` but not on disk counts too,
-   * except the design system's own import path.
+   * A module declared in a package's `exports` but not on disk counts too (built to `dist/`,
+   * not built yet), except the design system's own import path, and one whose export, as the
+   * package.json writes it, leads to a source file only: `@acme/ui/components/tooltip` is
+   * `src/components/tooltip.tsx` through `"./components/*": "./src/components/*.tsx"`, and with
+   * no such file it does not exist.
    */
   outsideModel(specifier: string, name: string, fromFile?: string): boolean;
+  /**
+   * The module a design-system package's `exports` lead `specifier` to, relative to the root, as
+   * its package.json writes them: the first of the entry's targets that is on disk, else, when
+   * each of them is a source file, the first (which does not exist). Undefined when a target
+   * leads to a build folder (`"./*": "./dist/components/*.js"`, maybe not built yet, whose
+   * sources may be anywhere), the entry blocks the subpath (`null`), or no entry maps it.
+   */
+  private exportedSource;
+  /**
+   * The folder of package `name` that `file` is in: the nearest package.json above it with a
+   * name, when that name is `name`. One without a name (`{"type": "module"}` in a subfolder) is
+   * no package's. Each package.json is read once.
+   */
+  private packageDir;
   /**
    * The component a JSX tag means when `name` is imported from `specifier`, among the
    * model's components of that name: the one declared where the import leads, through

package/dist/index.js

@@ -1,3 +1,3 @@
-import { F as loadTokens, G as parseDoc, H as parseDesignMd, I as mergeTokens, K as extractComponents, L as toDesignMd, N as RULES, P as TokenIndex, R as toDtcg, U as parseCssTokens, V as parseDtcgTokens, W as attachDocs, _ as formatDiagnostics, a as fingerprint, at as defineConfig, ct as loadConfig, f as searchComponents, ft as findVariantDefinitions, it as configJsonSchema, m as checkSource, n as DesignSystemHost, o as loadDesignSystem, p as applyFixes, r as buildModel, rt as RULE_IDS, t as DesignSystem, y as VERSION } from "./design-system-rl__N6tw.js";
-import { n as INSTRUCTIONS, r as createServer, t as serveStdio } from "./stdio-CkczPt_1.js";
+import { F as loadTokens, G as parseDoc, H as parseDesignMd, I as mergeTokens, K as extractComponents, L as toDesignMd, N as RULES, P as TokenIndex, R as toDtcg, U as parseCssTokens, V as parseDtcgTokens, W as attachDocs, _ as formatDiagnostics, a as fingerprint, at as defineConfig, ct as loadConfig, f as searchComponents, ft as findVariantDefinitions, it as configJsonSchema, m as checkSource, n as DesignSystemHost, o as loadDesignSystem, p as applyFixes, r as buildModel, rt as RULE_IDS, t as DesignSystem, y as VERSION } from "./design-system-Csqts7Eq.js";
+import { n as INSTRUCTIONS, r as createServer, t as serveStdio } from "./stdio-0TpyqZaD.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-CkczPt_1.js → stdio-0TpyqZaD.js}

@@ -1,5 +1,5 @@
-import { At as relativePath, Ct as isWorkspaceRoot, Dt as isInside, Et as SCRIPT_FILE, Ft as truncate, It as unique, J as ConfigError, Lt as defaultProjectConfig, Mt as closest, Nt as json, Pt as plural, X as DEFAULT_SEVERITY, bt as detectProject, ct as loadConfig, d as descriptionOf, dt as formatPx, f as searchComponents, gt as notReadYet, h as uncheckedNotice, ht as libraryTitle, kt as pathOf, mt as LIBRARY_IDS, n as DesignSystemHost, ot as excludedBy, pt as LIBRARIES, q as CONFIG_FILES, r as buildModel, rt as RULE_IDS, tt as LEGACY_CONFIG_FILES, u as buildSearchIndex, v as NAME, xt as findDesignSystemPackage, y as VERSION, z as TOKEN_CATEGORIES } from "./design-system-rl__N6tw.js";
-import { i as projectDirOf, n as hasProjectMarker, r as loadTarget, t as findProjectRoot } from "./workspace-INef0Yqt.js";
+import { At as relativePath, Ct as isWorkspaceRoot, Dt as isInside, Et as SCRIPT_FILE, Ft as truncate, It as unique, J as ConfigError, Lt as defaultProjectConfig, Mt as closest, Nt as json, Pt as plural, X as DEFAULT_SEVERITY, bt as detectProject, ct as loadConfig, d as descriptionOf, dt as formatPx, f as searchComponents, gt as notReadYet, h as uncheckedNotice, ht as libraryTitle, kt as pathOf, mt as LIBRARY_IDS, n as DesignSystemHost, ot as excludedBy, pt as LIBRARIES, q as CONFIG_FILES, r as buildModel, rt as RULE_IDS, tt as LEGACY_CONFIG_FILES, u as buildSearchIndex, v as NAME, xt as findDesignSystemPackage, y as VERSION, z as TOKEN_CATEGORIES } from "./design-system-Csqts7Eq.js";
+import { i as projectDirOf, n as hasProjectMarker, r as loadTarget, t as findProjectRoot } from "./workspace-Dbxubo9n.js";
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -19,8 +19,11 @@ function explainProject(ds, cwd, indent = "") {
 	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.inherits && config.designSystemPackage ? display(cwd, config.designSystemPackage.config) : config.configFile ? `${display(cwd, config.configFile)}${over(config, cwd)}` : "--components"}, so zero config did not look`);
-	else {
+	if (config.configured) {
+		out(`  components come from ${config.inherits && config.designSystemPackage ? display(cwd, config.designSystemPackage.config) : config.configFile ? `${display(cwd, config.configFile)}${over(config, cwd)}` : "--components"}, so zero config did not look`);
+		const unpublished = unpublishedComponents(ds);
+		if (unpublished) out(`  ${unpublished}`);
+	} 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}`);
@@ -85,6 +88,22 @@ function explainProject(ds, cwd, indent = "") {
 	}
 	return lines;
 }
+/**
+* Why a project that takes on the config of a design-system package installed in node_modules
+* knows none of its components: the package publishes neither their sources nor their type
+* declarations, or `"libraries": false` turns off the declarations it publishes. The one message
+* for it, where a project without components would otherwise be told to check the "components"
+* globs. Undefined otherwise.
+*/
+function unpublishedComponents(ds) {
+	const declared = ds.config.designSystemPackage;
+	if (!declared?.installed || !ds.config.inherits || ds.model.components.length) return void 0;
+	const tokens = ds.model.tokens.length ? " The token rules still check against the tokens it publishes." : "";
+	const name = pathOf(declared.name);
+	const see = "See https://onsystem.vercel.app/docs/design-system-packages#what-apps-get";
+	if (ds.config.librariesOff?.some((library) => library.package === declared.name)) return `${name} publishes no component sources, and "libraries": false in the config turns off the type declarations it publishes, so its components are unknown here and the component rules did not run: set "libraries" to [], which reads its declarations and no library, or remove it.${tokens} ${see}`;
+	return `${name} publishes neither its component sources nor their type declarations, so its components are unknown here and the component rules did not run: ask its team to add its sources to "files" in its package.json, or to publish type declarations.${tokens} ${see}`;
+}
 /** 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"}`;
@@ -562,8 +581,12 @@ function listTail(listed) {
 	if (listed.omitted) lines.push("", `${listed.omitted.toLocaleString("en-US")} more not shown: pass a higher \`limit\`, or a \`query\`.`);
 	return lines;
 }
-/** The shared explanation when a project has no design-system components to show. */
-function noComponentsMessage(root, project, monorepo = false) {
+/**
+* The shared explanation when a project has no design-system components to show. `reason`, when
+* known, says why instead ({@link unpublishedComponents}).
+*/
+function noComponentsMessage(root, project, monorepo = false, reason) {
+	if (reason) return answer([reason]);
 	if (monorepo) return answer([`No design-system components found in any project of this monorepo (root: ${root}). Check the "components" globs in the config. Run \`onsystem inspect\` there to see what was looked at.`]);
 	return answer([`No design-system components found${project ? ` in ${pathOf(project)}` : ""}. Check the "components" globs in the config (root: ${root}).`]);
 }
@@ -571,7 +594,7 @@ function noComponentsMessage(root, project, monorepo = false) {
 function renderComponentList(ds, project, filter = {}) {
 	const roots = ds.roots();
 	const where = project ? ` in ${pathOf(project)}` : "";
-	if (!roots.length) return noComponentsMessage(ds.root, project);
+	if (!roots.length) return noComponentsMessage(ds.root, project, false, unpublishedComponents(ds));
 	const listed = listComponents(roots, (c) => c, filter);
 	if (!listed.matched) return answer([`No components match ${filterText(filter)}${where} (${roots.length} in all). Call list_components without filters to see them.`]);
 	const marks = new Marks();
@@ -686,7 +709,7 @@ function renderAmbiguous(name, entries) {
 }
 /** get_component's answer for a name no component has, with the nearest and all of them. */
 function renderNotFound(name, guess, names, where = "") {
-	return answer([`No component named ${json(name)}${where}.` + (guess ? ` Did you mean ${json(guess)}?` : "") + ` Available: ${names.join(", ")}.`]);
+	return answer([`No component named ${json(name)}${where}.` + (guess ? ` Did you mean ${json(guess)}?` : "") + (names.length ? ` Available: ${names.join(", ")}.` : "")]);
 }
 /**
 * The build-with-design-system prompt: `task`, the steps, and what the design system has, its
@@ -1552,7 +1575,7 @@ function register(serve, { getDesignSystem, getProjects }) {
 		const { ds } = found;
 		const component = ds.getComponent(name);
 		if (!component) {
-			if (!ds.roots().length) return refuse(noComponentsMessage(ds.root, found.project?.dir));
+			if (!ds.roots().length) return refuse(noComponentsMessage(ds.root, found.project?.dir, false, unpublishedComponents(ds)));
 			const names = ds.roots().map((c) => c.name);
 			return refuse(renderNotFound(name, ds.suggestComponent(name), names));
 		}

package/dist/{workspace-INef0Yqt.js → workspace-Dbxubo9n.js}

@@ -1,4 +1,4 @@
-import { At as relativePath, Ct as isWorkspaceRoot, Dt as isInside, Tt as workspacePatterns, ct as loadConfig, i as componentFiles, lt as loadConfigWith, nt as PROJECT_MARKERS, st as hasOwnConfig, vt as PackageFinder, wt as workspacePackageDirs, xt as findDesignSystemPackage } from "./design-system-rl__N6tw.js";
+import { At as relativePath, Ct as isWorkspaceRoot, Dt as isInside, Tt as workspacePatterns, ct as loadConfig, i as componentFiles, lt as loadConfigWith, nt as PROJECT_MARKERS, st as hasOwnConfig, vt as PackageFinder, wt as workspacePackageDirs, xt as findDesignSystemPackage } from "./design-system-Csqts7Eq.js";
 import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "onsystem",
-  "version": "0.10.2",
+  "version": "0.11.0",
   "mcpName": "io.github.dgesteves/onsystem",
   "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": [