onsystem 0.6.0 → 0.7.0

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
-import { A as toDtcg, B as DEFAULT_DOCS, C as updateBaseline, G as RULE_IDS, R as CONFIG_FILES, S as readBaseline, V as DEFAULT_SEVERITY, W as LEGACY_CONFIG_FILES, Z as rulesFor, _ as VERSION, _t as relativePath, at as detectProject, b as applyBaseline, c as silentLogger, et as LIBRARY_IDS, ft as plural, g as NAME, gt as matchesGlob, h as formatDiagnostics, ht as isInside, i as componentFiles, it as declaredConfig, k as toDesignMd, l as stderrLogger, m as uncheckedNotice, mt as unique, nt as PACKAGE_FIELD, o as loadDesignSystem, ot as findDesignSystemPackage, s as tokenFiles, st as isDesignSystemName, tt as libraryAdapter, v as BASELINE_FILE, vt as toPosix, w as writeBaseline, x as countBaseline, y as LEGACY_BASELINE_FILE, z as ConfigError } from "./design-system-A3pRX3Ka.js";
-import { t as serveStdio } from "./stdio-CEChNFLR.js";
-import { r as loadTarget } from "./workspace-CHvUwgz9.js";
+import { C as pruneBaseline, Ct as relativePath, D as updateBaseline, E as unrecordedRules, H as CONFIG_FILES, J as LEGACY_CONFIG_FILES, N as toDesignMd, O as writeBaseline, P as toDtcg, S as countBaseline, St as matchesGlob, T as rulesRun, U as ConfigError, W as DEFAULT_DOCS, Y as RULE_IDS, _ as NAME, b as LEGACY_BASELINE_FILE, bt as unique, c as silentLogger, ct as PACKAGE_FIELD, dt as detectProject, g as formatDiagnostics, h as escapeData, i as componentFiles, l as stderrLogger, m as uncheckedNotice, o as loadDesignSystem, ot as libraryTitle, pt as isDesignSystemName, s as tokenFiles, st as notReadYet, tt as rulesFor, ut as declaredConfig, v as VERSION, vt as plural, w as readBaseline, wt as toPosix, x as applyBaseline, xt as isInside, y as BASELINE_FILE } from "./design-system-C4bhqLLw.js";
+import { a as notReadNotices, i as missingDependencies, o as explainProject, s as librariesLeftOut, t as serveStdio } from "./stdio-BojAQ6JP.js";
+import { r as loadTarget } from "./workspace-Z0tZf_Dv.js";
 import fs from "node:fs";
 import path from "node:path";
 import { escapePath, glob } from "tinyglobby";
@@ -9,132 +9,6 @@ import fsp from "node:fs/promises";
 import { spawnSync } from "node:child_process";
 import readline from "node:readline/promises";
 import { parseArgs } from "node:util";
-//#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)}`);
-	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$1(config.components) || "(none)");
-	field("exclude", listOf$1(config.exclude));
-	field("tokens", listOf$1(config.tokens.map((t) => `${t.path}${t.prefix ? ` (prefix ${t.prefix})` : ""}${t.fallback ? " (when nothing else is found)" : ""}`)));
-	field("docs", listOf$1(config.docs));
-	field("tsconfig", config.tsconfig ?? (fs.existsSync(path.join(config.root, "tsconfig.json")) ? "tsconfig.json" : "(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$1(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/init.ts
 const SCHEMA = "https://unpkg.com/onsystem/schema.json";
 /** More detected globs than this are files, not folders: zero config keeps them. */
@@ -174,6 +48,7 @@ async function init(configOptions, options, io, runCheck) {
 	const notes = [];
 	const relative = (abs) => relativePath(root, abs);
 	const inherited = options.force ? void 0 : config.designSystemPackage;
+	const replaced = options.force ? config.designSystemPackage : void 0;
 	if (inherited) notes.push(`This project takes on the config ${inherited.name} declares in its package.json (${relativePath(io.cwd, inherited.config) || inherited.config}), so it needs none of its own; nothing was written. Pass --force to write one, which is read instead.`);
 	else if (configOptions.components?.length) {
 		file.components = configOptions.components;
@@ -188,19 +63,22 @@ async function init(configOptions, options, io, runCheck) {
 		else if (config.components.length > MAX_GLOBS) notes.push(`"components" is left to zero config: it found ${config.components.length} files through the package's exports, which it keeps following as the package changes.`);
 		else {
 			file.components = config.components;
-			if ([...specifiers][0]) file.importPath = [...specifiers][0];
+			const [specifier] = specifiers;
+			if (specifier && !specifier.includes("*")) file.importPath = specifier;
 			const docs = config.docs.filter((d) => !DEFAULT_DOCS.includes(d));
 			if (docs.length) file.docs = [...DEFAULT_DOCS, ...docs];
 		}
 		if (tokens.length) file.tokens = tokens;
 	} else if ((await componentFiles(config)).length) {
+		const declared = replaced && config.configured;
 		const matching = [];
 		for (const glob of config.components) if ((await componentFiles({
 			...config,
 			components: [glob]
 		})).length) matching.push(glob);
-		notes.push(`Found the design system in the default folders: ${matching.join(", ")}.`);
+		notes.push(declared ? `Found the design system through the config ${replaced.name} declares: ${matching.join(", ")}.` : `Found the design system in the default folders: ${matching.join(", ")}.`);
 		file.components = matching;
+		if (declared && config.importPath) file.importPath = config.importPath;
 		const tokens = (await tokenFiles(config)).map(relative);
 		if (tokens.length) file.tokens = tokens;
 	} else {
@@ -238,10 +116,18 @@ async function init(configOptions, options, io, runCheck) {
 		fs.writeFileSync(out, `${JSON.stringify(file, null, 2)}\n`);
 		written.push(CONFIG_FILE);
 	}
+	if (replaced) {
+		const own = (await loadTarget({
+			...configOptions,
+			config: void 0
+		})).config;
+		notes.push(await replacedNote(replaced, config, own, io.cwd));
+	}
+	let registry;
 	if (designSystem && manifest && name) {
 		written.push(...declarePackage(root, manifest, name, options.force, notes));
-		const shipped = await unshipped(config, manifest.json);
-		if (shipped) notes.push(shipped);
+		registry = await unshipped(config, manifest.json);
+		if (registry) notes.push(...registry.notes);
 	}
 	for (const note of notes) io.stdout(note);
 	if (written.length) io.stdout(`Wrote ${written.map((f) => relativePath(io.cwd, path.join(root, f)) || f).join(", ")}.`);
@@ -293,7 +179,7 @@ async function init(configOptions, options, io, runCheck) {
 	}
 	const commit = [...written, ...baselineWritten ? [BASELINE_FILE] : []];
 	const files = commit.length > 1 ? `${commit.slice(0, -1).join(", ")} and ${commit.at(-1) ?? ""}` : commit[0];
-	io.stdout(designSystem && name ? `Next: commit ${files}. An app that depends on ${name} now finds it with no config of its own: run \`npx ${NAME} inspect\` in one to see it, and give its team ${GUIDE_FILE}.` : `Next: ${files ? `commit ${files}, and ` : ""}run \`npx ${NAME} check . --format github --require-design-system\` in CI.`);
+	io.stdout(designSystem && name ? registry ? `Next: commit ${files}. A workspace app that depends on ${name} now finds it with no config of its own: run \`npx ${NAME} inspect\` in one to see it, and give its team ${GUIDE_FILE}. An app that installs ${name} from a registry ${registry.next}.` : `Next: commit ${files}. An app that depends on ${name} now finds it with no config of its own: run \`npx ${NAME} inspect\` in one to see it, and give its team ${GUIDE_FILE}.` : `Next: ${files ? `commit ${files}, and ` : ""}run \`npx ${NAME} check . --format github --require-design-system\` in CI.`);
 	return 0;
 }
 const CONFIG_FILE = "onsystem.config.json";
@@ -346,16 +232,82 @@ function declarePackage(root, manifest, name, force, notes) {
 }
 /**
 * What apps that install the package from a registry will not find: the component and token
-* files its `files` list leaves out of the published package. Undefined for a private package,
-* one without a `files` list (npm then ships everything), or when nothing is left out.
+* files its `files` list leaves out of the published package, and those outside the package
+* (`../tailwind-config/theme.css`), which an installed package's config cannot reach. Undefined
+* for a private package, or when they find every file. Without a `files` list, npm publishes
+* everything in the package.
 */
 async function unshipped(config, json) {
-	if (json.private === true || !Array.isArray(json.files)) return void 0;
-	const files = json.files;
-	const missing = [...await componentFiles(config), ...await tokenFiles(config)].map((f) => relativePath(config.root, f)).filter((f) => !f.startsWith("../")).filter((f) => !ships(files, f));
-	if (!missing.length) return void 0;
-	const folders = [...new Set(missing.map((f) => f.includes("/") ? `${f.slice(0, f.indexOf("/"))}/` : f))];
-	return `Apps that install ${typeof json.name === "string" ? json.name : "the package"} from a registry get only what "files" in package.json publishes, which leaves out ${folders.join(", ")} (${count$1(missing.length, "component or token file")}): they will not find those. Add ${folders.length === 1 ? "it" : "them"} to "files" for them; workspace apps read the sources either way.`;
+	if (json.private === true) return void 0;
+	const name = typeof json.name === "string" ? json.name : "the package";
+	const files = Array.isArray(json.files) ? json.files : void 0;
+	const relative = (abs) => abs.map((f) => relativePath(config.root, f));
+	const components = relative(await componentFiles(config));
+	const tokens = relative(await tokenFiles(config));
+	const outside = (f) => f.startsWith("../");
+	const left = (list) => files ? list.filter((f) => !outside(f) && !ships(files, f)) : [];
+	const missing = {
+		components: left(components),
+		tokens: left(tokens)
+	};
+	const away = {
+		components: components.filter(outside),
+		tokens: tokens.filter(outside)
+	};
+	const noComponents = components.length > 0 && missing.components.length + away.components.length === components.length;
+	const lost = (lists, one) => {
+		const c = lists.components.length;
+		const t = lists.tokens.length;
+		const kinds = andList([...c ? [count$1(c, "component file")] : [], ...t ? [count$1(t, "token file")] : []]);
+		const what = andList([...c ? ["components"] : [], ...t ? ["tokens"] : []], "or");
+		const checks = c && noComponents ? `: they get no component, prop, variant or native-element checks, and \`${NAME} check --require-design-system\` fails in them` : "";
+		return `(${kinds}). Those apps do not know the ${what} in ${one ? "it" : "them"}${checks}.`;
+	};
+	const notes = [];
+	const top = (f) => f.includes("/") ? `${f.slice(0, f.indexOf("/"))}/` : f;
+	const folders = [...new Set([...missing.components, ...missing.tokens].map(top))];
+	if (folders.length) {
+		const one = folders.length === 1;
+		notes.push(`Apps that install ${name} from a registry get only what "files" in package.json publishes, which leaves out ${andList(folders)} ${lost(missing, one)} Add ${one ? "it" : "them"} to "files" for them; workspace apps read the sources either way.`);
+	}
+	const beyond = [...away.components, ...away.tokens];
+	if (beyond.length) {
+		const one = beyond.length === 1;
+		notes.push(`Apps that install ${name} from a registry read only the files in it, so they skip ${andList(beyond)}, outside the package ${lost(away, one)} Workspace apps read ${one ? "it" : "them"}. To give installed apps what ${one ? "it holds" : "they hold"}, keep a copy in the package, publish it, and name the copy in the config instead.`);
+	}
+	if (!notes.length) return void 0;
+	return {
+		notes,
+		next: noComponents && missing.components.length ? `gets no component checks until "files" publishes ${andList([...new Set(missing.components.map(top))])}` : `does not read ${andList([...folders, ...beyond])}`
+	};
+}
+/**
+* Said when --force writes a config in an app that took on a design-system package's: the new
+* one is read instead, and what it does not take from the package. `taken` is the config the
+* app took on, `own` the one it reads now.
+*/
+async function replacedNote(pkg, taken, own, cwd) {
+	const lacks = async (list) => {
+		const kept = new Set((await list(own)).map((f) => path.resolve(f)));
+		return (await list(taken)).some((f) => !kept.has(path.resolve(f)));
+	};
+	const components = await lacks(componentFiles);
+	const importPath = taken.importPath !== void 0 && own.importPath === void 0;
+	const tokens = await lacks(tokenFiles);
+	const declared = relativePath(cwd, pkg.config) || pkg.config;
+	const replaced = `This project took on the config ${pkg.name} declares (${declared}); with --force it has one of its own, which is read instead, so ${pkg.name}'s rules and later changes to its config no longer reach it.`;
+	if (!components && !importPath && !tokens) return replaced;
+	const effects = andList([
+		...components ? [`does not know ${pkg.name}'s components`] : [],
+		...importPath && !components ? [`does not match imports from ${pkg.name} to its components`] : [],
+		...tokens ? [`does not read ${pkg.name}'s tokens`] : []
+	]);
+	const fields = [
+		...components ? ["\"components\""] : [],
+		...importPath || components && taken.importPath !== void 0 ? ["\"importPath\""] : [],
+		...tokens ? ["\"tokens\""] : []
+	];
+	return `${replaced} It ${effects}: ${(!components || taken.configured === true) && (!tokens || taken.tokensDetected !== true) ? `copy ${andList(fields)} from ${declared} into ${CONFIG_FILE}, or ` : ""}delete ${CONFIG_FILE} to take on ${pkg.name}'s config again.`;
 }
 /** Whether npm's `files` list publishes `file`, a path relative to the package. */
 function ships(files, file) {
@@ -413,6 +365,10 @@ function consumerGuide(name) {
 function count$1(n, word) {
 	return `${n.toLocaleString("en-US")} ${n === 1 ? word : `${word}s`}`;
 }
+/** `a`, `a and b`, `a, b and c` (or `or`). */
+function andList(items, conjunction = "and") {
+	return items.length > 1 ? `${items.slice(0, -1).join(", ")} ${conjunction} ${items.at(-1) ?? ""}` : items.join("");
+}
 //#endregion
 //#region src/cli.ts
 const DOCS = "https://onsystem.vercel.app/docs";
@@ -453,6 +409,8 @@ Options
   --out <file>            export: write to this file instead of stdout
   --max-warnings <n>      check: exit 1 when there are more than n warnings
   --update-baseline       check: record the current findings as accepted, and exit 0
+  --prune-baseline        check: drop baseline entries that no longer occur, and
+                          accept nothing new
   --baseline <file>       check: baseline file (default: ${BASELINE_FILE} in the root,
                           used whenever it exists)
   --ignore-baseline       check: report every finding, baseline or not
@@ -544,6 +502,10 @@ async function main(argv, io = defaultIo) {
 					type: "boolean",
 					default: false
 				},
+				"prune-baseline": {
+					type: "boolean",
+					default: false
+				},
 				"ignore-baseline": {
 					type: "boolean",
 					default: false
@@ -666,6 +628,10 @@ async function check(patterns, configOptions, values, io) {
 		io.stderr("check: pass --quiet-without-design-system or --require-design-system, not both");
 		return 2;
 	}
+	for (const other of ["update-baseline", "ignore-baseline"]) if (values["prune-baseline"] && values[other]) {
+		io.stderr(`check: pass --prune-baseline or --${other}, not both`);
+		return 2;
+	}
 	if (!patterns.length) {
 		io.stderr(`check: pass files, folders or globs, e.g. ${NAME} check .`);
 		return 2;
@@ -699,6 +665,7 @@ async function check(patterns, configOptions, values, io) {
 		return 0;
 	}
 	const update = values["update-baseline"];
+	const prune = values["prune-baseline"];
 	const baselineFile = values.baseline ? path.resolve(io.cwd, values.baseline) : defaultBaseline(selection.root, values["ignore-baseline"] ? void 0 : (text) => {
 		warnDeprecated([text], format, io);
 	});
@@ -707,6 +674,10 @@ async function check(patterns, configOptions, values, io) {
 		io.stderr(`check: baseline not found: ${displayPath(io.cwd, baselineFile)}`);
 		return 2;
 	}
+	if (prune && !baseline) {
+		io.stderr(`check --prune-baseline: no baseline to prune at ${displayPath(io.cwd, baselineFile)}. Pass --baseline <file> to prune another one, or record the current findings with \`${checkCommand(patterns, configOptions, values, "--update-baseline")}\`.`);
+		return 2;
+	}
 	const disabledFor = (file) => {
 		const ds = selection.designSystemOf(file);
 		return new Set(Object.entries(rulesFor(ds.config, relativePath(ds.root, file))).filter(([, rule]) => rule.severity === "off").map(([id]) => id));
@@ -716,6 +687,7 @@ async function check(patterns, configOptions, values, io) {
 	const baselineKey = (file) => relativePath(realRoot, fs.realpathSync.native(file)).normalize("NFC");
 	const results = [];
 	const checked = /* @__PURE__ */ new Map();
+	const ran = /* @__PURE__ */ new Set();
 	let baselined = 0;
 	let fixed = 0;
 	for (const file of files) {
@@ -725,9 +697,12 @@ async function check(patterns, configOptions, values, io) {
 		const key = baselineKey(file);
 		const disabled = disabledFor(file);
 		disabledByKey.set(key, disabled);
-		if (update) checked.set(key, result.diagnostics);
+		if (update || prune) checked.set(key, result.diagnostics);
+		if (update) {
+			for (const rule of RULE_IDS) if (!disabled.has(rule) && canRun(ds, rule)) ran.add(rule);
+		}
 		if (baseline && !update) {
-			const match = applyBaseline(baseline, key, result, disabled);
+			const match = applyBaseline(baseline.entries, key, result, disabled);
 			result = {
 				...match.result,
 				baselined: match.baselined
@@ -744,22 +719,51 @@ async function check(patterns, configOptions, values, io) {
 	if (elsewhere) notes.push(`${plural(elsewhere, "image or email file")} not checked`);
 	const unchecked = uncheckedNotice(results);
 	if (update) {
-		const next = updateBaseline(baseline, checked, realRoot, (key) => disabledByKey.get(key) ?? /* @__PURE__ */ new Set());
-		writeBaseline(baselineFile, next);
+		const next = updateBaseline(baseline?.entries, checked, realRoot, (key) => disabledByKey.get(key) ?? /* @__PURE__ */ new Set());
+		const wholeRoot = patterns.some((pattern) => {
+			const dir = path.resolve(io.cwd, pattern);
+			return Boolean(fs.statSync(dir, { throwIfNoEntry: false })?.isDirectory() && isInside(realPath(dir), realRoot));
+		});
+		writeBaseline(baselineFile, next, {
+			onsystem: VERSION,
+			rules: rulesRun(baseline, next, checked, ran, wholeRoot)
+		});
 		const counts = countBaseline(next);
-		io.stdout(`Baseline: ${count(counts.findings, "finding")} in ${count(counts.files, "file")} → ${displayPath(io.cwd, baselineFile)}`);
+		const summary = `Baseline: ${count(counts.findings, "finding")} in ${count(counts.files, "file")} → ${displayPath(io.cwd, baselineFile)}`;
+		if (format === "pretty") io.stdout(summary);
+		else io.stderr(summary);
 		for (const text of selection.notices) io.stderr(text);
 		if (unchecked) io.stderr(unchecked);
 		return 0;
 	}
+	const command = (flag) => checkCommand(patterns, configOptions, values, flag);
+	const baselineNotes = [];
+	if (baseline) {
+		const fresh = results.flatMap((r) => r.diagnostics);
+		const unrecorded = unrecordedRules(baseline, fresh);
+		if (unrecorded.size) baselineNotes.push(unrecordedNote(unrecorded, fresh.length, baseline.onsystem, command("--update-baseline")));
+	}
+	if (prune && baseline) {
+		const next = pruneBaseline(baseline.entries, checked, realRoot, (key) => disabledByKey.get(key) ?? /* @__PURE__ */ new Set());
+		const left = countBaseline(next);
+		const dropped = countBaseline(baseline.entries).findings - left.findings;
+		if (dropped) writeBaseline(baselineFile, next, {
+			onsystem: baseline.onsystem,
+			rules: baseline.rules
+		});
+		baselineNotes.push(`Baseline: ${dropped ? `dropped ${count(dropped, "finding")} that no longer ${dropped === 1 ? "occurs" : "occur"}` : "nothing to drop"}; ${count(left.findings, "finding")} in ${count(left.files, "file")} → ${displayPath(io.cwd, baselineFile)}`);
+	}
 	const output = formatDiagnostics(format === "json" ? results : results.filter((r) => !r.skipped), format, {
 		color: io.color,
 		uri: format === "sarif" || format === "github" ? repositoryPath(io.cwd, io.env ?? process.env) : void 0,
 		baselined: baseline ? baselined : void 0,
 		notes,
-		fixedHint: fixed ? `${count(fixed, "baseline finding")} no longer ${fixed === 1 ? "occurs" : "occur"}: run \`check ${patterns.map(shellQuote).join(" ")} --update-baseline\` to drop ${fixed === 1 ? "it" : "them"}.` : void 0
+		fixedHint: fixed && !prune ? `${count(fixed, "baseline finding")} no longer ${fixed === 1 ? "occurs" : "occur"}: run \`${command("--prune-baseline")}\` to drop ${fixed === 1 ? "it" : "them"}.` : void 0
 	});
 	if (output) io.stdout(output);
+	for (const text of baselineNotes) if (format === "pretty") io.stdout(text);
+	else if (format === "github") io.stdout(`::notice title=${NAME} baseline::${escapeData(text)}`);
+	else io.stderr(text);
 	for (const text of [...selection.notices, unchecked]) {
 		if (!text) continue;
 		if (format === "pretty") io.stdout(text);
@@ -851,7 +855,7 @@ async function selectInProject(config, patterns, values, format, io) {
 		excluded: leftOut.filter((file) => !TEST_FILE.test(file)).length,
 		gitignored: ignored.size
 	};
-	let files = unique([...named, ...kept.filter((file) => !ignored.has(file))]).sort();
+	let files = oncePerFile([...named, ...kept.filter((file) => !ignored.has(file))]).sort();
 	if (!files.length && !all.length) {
 		io.stderr(`check: no files match ${patterns.join(" ")}`);
 		return 2;
@@ -863,6 +867,7 @@ async function selectInProject(config, patterns, values, format, io) {
 	const notice = ds.notice();
 	if (notice && values["require-design-system"] && !ds.hasDesignSystem()) {
 		io.stderr(`check --require-design-system: ${notice}`);
+		for (const text of notReadNotices([{ ds }])) io.stderr(text);
 		return 2;
 	}
 	let skipped = 0;
@@ -877,7 +882,7 @@ async function selectInProject(config, patterns, values, format, io) {
 		designSystemOf: () => ds,
 		root: ds.root,
 		notes: scopeNotes(skipped, left),
-		notices: notice ? [notice] : [],
+		notices: [...notice ? [notice] : [], ...notReadNotices([{ ds }])],
 		skipped,
 		testsLeftOut: left.tests
 	};
@@ -927,7 +932,7 @@ async function selectInWorkspace(workspace, patterns, values, format, io) {
 		excluded: leftOut.filter((file) => !TEST_FILE.test(file)).length,
 		gitignored: ignored.size
 	};
-	let files = unique([...named, ...kept.filter((file) => !ignored.has(file))]).sort();
+	let files = oncePerFile([...named, ...kept.filter((file) => !ignored.has(file))]).sort();
 	if (!files.length && !all.length) {
 		io.stderr(`check: no files match ${patterns.join(" ")}`);
 		return 2;
@@ -979,6 +984,14 @@ async function selectInWorkspace(workspace, patterns, values, format, io) {
 		gaps.set(notice, gap);
 	}
 	const notices = [...gaps.values()].map(({ ds, dirs }) => ds.notice(listOf(dirs)) ?? "");
+	const checkedProjects = unique(files.map(project)).flatMap((p) => {
+		const ds = loaded.get(p.root);
+		return ds ? [{
+			ds,
+			dir: p.dir
+		}] : [];
+	});
+	notices.push(...notReadNotices(checkedProjects));
 	const used = unique(files.map((file) => project(file).root)).length;
 	return {
 		files,
@@ -1041,6 +1054,8 @@ async function inspect(configOptions, values, io) {
 	}
 	if (values.explain) lines.push("", ...explainProject(ds, io.cwd));
 	io.stdout(lines.join("\n"));
+	const missing = values.explain ? void 0 : missingDependencies([{ ds }]);
+	if (missing) io.stderr(missing);
 	return 0;
 }
 /**
@@ -1048,12 +1063,16 @@ async function inspect(configOptions, values, io) {
 * project depends on, including those the config's `libraries` leaves out.
 */
 function describeLibraries(config, model, cwd) {
-	const name = (library) => `${libraryAdapter(library.package)?.title ?? library.package} (${library.package}${library.version ? ` ${library.version}` : ""})`;
-	return [...(config.libraries ?? []).map((library) => {
-		if (!library.dir) return `${name(library)}: a dependency, but not installed`;
-		const count = model.components.filter((c) => c.library === library.package).length;
-		return `${name(library)}: ${plural(count, "component")} from its type declarations`;
-	}), ...(config.librariesOff ?? []).map((library) => `${name(library)}: ${librariesLeftOut(config, cwd)}`)];
+	const name = (library) => `${libraryTitle(library.package)} (${library.package}${library.version ? ` ${library.version}` : ""})`;
+	return [
+		...(config.libraries ?? []).map((library) => {
+			if (!library.dir) return `${name(library)}: a dependency, but not installed`;
+			const count = model.components.filter((c) => c.library === library.package).length;
+			return `${name(library)}: ${plural(count, "component")} from its type declarations`;
+		}),
+		...(config.librariesOff ?? []).map((library) => `${name(library)}: ${librariesLeftOut(config, cwd)}`),
+		...(config.librariesUnread ?? []).map((library) => `${name(library)}: ${notReadYet()}`)
+	];
 }
 /**
 * `export --format dtcg|design-md`: the project's tokens as a DTCG 2025.10 file or a
@@ -1149,6 +1168,11 @@ async function inspectWorkspace(workspace, values, io) {
 	lines.push("", `Each file is checked by its project's design system. For one project's components, tokens and warnings: ${NAME} inspect --root <folder>`);
 	if (values.explain) lines.push("", ...explainWorkspace(workspace, loaded, io.cwd));
 	io.stdout(lines.join("\n"));
+	const missing = values.explain ? void 0 : missingDependencies(loaded.map(({ project, ds }) => ({
+		ds,
+		dir: project.dir
+	})));
+	if (missing) io.stderr(missing);
 	return 0;
 }
 /** Why the root is read as a monorepo, then each project's explanation. */
@@ -1259,6 +1283,50 @@ function gitIgnored(cwd, files) {
 function count(n, word) {
 	return `${n.toLocaleString("en-US")} ${n === 1 ? word : `${word}s`}`;
 }
+/**
+* `check` as this run was given, with `flag`: the patterns and the options that decide what it
+* finds and which baseline it reads (output options left out).
+*/
+function checkCommand(patterns, configOptions, values, flag) {
+	const args = [...patterns];
+	const option = (name, value) => {
+		if (value !== void 0) args.push(`--${name}`, value);
+	};
+	option("root", configOptions.root);
+	option("config", configOptions.config);
+	for (const name of [
+		"components",
+		"tokens",
+		"docs"
+	]) for (const value of configOptions[name] ?? []) option(name, value);
+	option("baseline", values.baseline);
+	if (configOptions.includeDesignSystem !== void 0) args.push(`--${configOptions.includeDesignSystem ? "" : "no-"}include-design-system`);
+	if (values["include-tests"]) args.push("--include-tests");
+	return `check ${args.map(shellQuote).join(" ")} ${flag}`;
+}
+/**
+* Whether a rule has something to compare against in a design system, as `notice()` says when
+* it has not: no-hardcoded-color needs color tokens, the spacing and radius rules tokens of
+* their kind, and the component rules components. Keep it in step with `DesignSystem.notice()`
+* in src/design-system.ts, or the baseline records a rule as run when it was skipped, or the
+* other way round.
+*/
+function canRun(ds, rule) {
+	switch (rule) {
+		case "no-hardcoded-color": return ds.tokenIndex.has("color");
+		case "no-hardcoded-spacing": return ds.tokenIndex.has("spacing");
+		case "no-hardcoded-radius": return ds.tokenIndex.has("radius");
+		case "icon-button-accessible-name": return true;
+		default: return ds.model.components.length > 0;
+	}
+}
+/** Why findings of rules that did not run when the baseline was recorded are new to it. */
+function unrecordedNote(byRule, total, version, update) {
+	const rules = [...byRule.keys()].sort();
+	const n = [...byRule.values()].reduce((sum, k) => sum + k, 0);
+	const others = total - n;
+	return `${listOf(rules, rules.length)} did not run when the baseline was written${version ? ` (onsystem ${version})` : ""}, so ${rules.length === 1 ? "its" : "their"} ${count(n, "finding")} ${n === 1 ? "is" : "are"} new to the baseline, not necessarily to the code. To accept ${n === 1 ? "it" : "them"}, run \`${update}\`${others ? `, which also accepts the ${count(others, "other new finding")}` : ""}.`;
+}
 /** Quotes a pattern for the hint when the shell would expand or split it. */
 function shellQuote(pattern) {
 	return /^[\w./@-]+$/.test(pattern) ? pattern : `"${pattern.replace(/(["\\$`])/g, "\\$1")}"`;
@@ -1271,6 +1339,19 @@ function realPath(file) {
 		return file;
 	}
 }
+/**
+* One path per file, links resolved: a folder that links back to its parent reaches the same
+* files again. The shortest path stays.
+*/
+function oncePerFile(files) {
+	const kept = /* @__PURE__ */ new Map();
+	for (const file of files) {
+		const real = realPath(file);
+		const previous = kept.get(real);
+		if (previous === void 0 || file.length < previous.length) kept.set(real, file);
+	}
+	return [...kept.values()];
+}
 /** Relative to cwd when the file is below it, absolute otherwise. */
 function displayPath(cwd, file) {
 	const rel = path.relative(cwd, file);

package/dist/{config-lbfW91qB.d.ts → config-1XSTYI44.d.ts}

@@ -391,6 +391,12 @@ interface ResolvedConfig {
    */
   designSystemExclude?: string[] | undefined;
   tokens: TokenSourceConfig[];
+  /**
+   * `tokens` comes from zero config (detection or the default paths), not the config or
+   * `--tokens`: the stylesheets those files import are read too, and so are the ones in a
+   * shared Tailwind preset's workspace package that set the colors the config maps.
+   */
+  tokensDetected?: boolean | undefined;
   docs: string[];
   tsconfig?: string | undefined;
   importPath?: string | undefined;
@@ -418,6 +424,8 @@ interface ResolvedConfig {
   libraryIds?: false | LibraryId[] | undefined;
   /** Libraries the project depends on that `libraries` leaves out, so they are not read. */
   librariesOff?: LibrarySource[] | undefined;
+  /** Component libraries the project depends on that onsystem does not read yet (Chakra UI). */
+  librariesUnread?: LibrarySource[] | undefined;
   elements: Record<string, string>;
   /** `check` lints the component files themselves, which it skips by default. */
   includeDesignSystem: boolean;