onsystem 0.6.0 → 0.8.0

package/dist/cli.js

@@ -1,140 +1,15 @@
 #!/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 isInside, D as updateBaseline, E as unrecordedRules, Et as toPosix, H as CONFIG_FILES, J as LEGACY_CONFIG_FILES, N as toDesignMd, O as writeBaseline, Ot as readProjectConfig, P as toDtcg, Q as excludedBy, S as countBaseline, St as SCRIPT_FILE, T as rulesRun, Tt as relativePath, U as ConfigError, W as DEFAULT_DOCS, Y as RULE_IDS, _ as NAME, b as LEGACY_BASELINE_FILE, c as silentLogger, ct as notReadYet, dt as declaredConfig, ft as detectProject, g as formatDiagnostics, h as escapeData, i as componentFiles, l as stderrLogger, lt as PACKAGE_FIELD, m as uncheckedNotice, mt as isDesignSystemName, nt as rulesFor, o as loadDesignSystem, s as tokenFiles, st as libraryTitle, v as VERSION, w as readBaseline, wt as matchesGlob, x as applyBaseline, xt as unique, y as BASELINE_FILE, yt as plural } from "./design-system-Dmcv7eHR.js";
+import { a as notReadNotices, i as missingDependencies, o as explainProject, s as librariesLeftOut, t as serveStdio } from "./stdio-MTS6QAgo.js";
+import { r as loadTarget } from "./workspace-CM1RyqZA.js";
 import fs from "node:fs";
 import path from "node:path";
 import { escapePath, glob } from "tinyglobby";
+import ts from "typescript";
 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. */
@@ -152,6 +27,9 @@ const GUIDE_FILE = "ONSYSTEM.md";
 * every app that depends on the package reads it, and writes ONSYSTEM.md, which tells those
 * apps' teams how to add the agent tools and the CI check. In an app that takes on such a
 * package's config, it writes no config of its own unless --force says to.
+*
+* In a terminal, it offers to add a short section on onsystem to the project's AGENTS.md or
+* CLAUDE.md, for coding agents.
 */
 async function init(configOptions, options, io, runCheck) {
 	const { config, workspace } = await loadTarget({
@@ -174,6 +52,8 @@ 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;
+	let found = false;
 	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 +68,24 @@ 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];
+			found = true;
+			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;
+		found = true;
+		if (declared && config.importPath) file.importPath = config.importPath;
 		const tokens = (await tokenFiles(config)).map(relative);
 		if (tokens.length) file.tokens = tokens;
 	} else {
@@ -232,16 +117,25 @@ async function init(configOptions, options, io, runCheck) {
 		const importPath = (await ask("How do apps import them? A package name such as @acme/ui, or leave it empty for tsconfig paths: ")).trim();
 		if (importPath) file.importPath = importPath;
 	}
+	if (!inherited && !workspace) notes.push(...await registryCode(config, file, found));
 	const written = [];
 	if (!inherited) {
 		const out = path.join(root, CONFIG_FILE);
 		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(", ")}.`);
@@ -291,12 +185,93 @@ async function init(configOptions, options, io, runCheck) {
 			baselineWritten = fs.existsSync(path.join(root, BASELINE_FILE));
 		} else io.stdout(`No baseline written; \`${NAME} check . --update-baseline\` records one later.`);
 	}
-	const commit = [...written, ...baselineWritten ? [BASELINE_FILE] : []];
+	const instructed = await agentRules(root, ask, io);
+	const commit = [
+		...written,
+		...baselineWritten ? [BASELINE_FILE] : [],
+		...instructed
+	];
 	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";
+/** The instruction files agents read, which `init` offers to add onsystem's section to. */
+const AGENT_FILES = ["AGENTS.md", "CLAUDE.md"];
+const RULES_BEGIN = "<!-- BEGIN:onsystem-agent-rules -->";
+const RULES_END = "<!-- END:onsystem-agent-rules -->";
+/** onsystem's section of AGENTS.md or CLAUDE.md: the MCP tools, and the CLI for agents without them. */
+const AGENT_RULES = [
+	RULES_BEGIN,
+	"# Design system",
+	"",
+	`This project's UI is checked against its design system by ${NAME}.`,
+	"",
+	`- Before writing UI, look up its components, props, variants and tokens with the ${NAME} tools (\`list_components\`, \`get_component\`, \`get_tokens\`).`,
+	`- After changing a \`.tsx\` or \`.jsx\` file, run \`check_ui\` on it and fix every error. Without the ${NAME} tools, run \`npx -y ${NAME} check <file>\` instead.`,
+	RULES_END
+].join("\n");
+/**
+* Offers to add onsystem's section to the AGENTS.md and CLAUDE.md in the root, between markers a
+* later run updates in place, so agents that read them check the UI they write, through the CLI
+* when they have no MCP config. A CLAUDE.md that imports AGENTS.md (an `@AGENTS.md` line) is left
+* alone: Claude Code reads the section there. Asked only in a terminal, never with --yes; nothing
+* is asked when neither file exists or the section is current. Returns the files it wrote.
+*/
+async function agentRules(root, ask, io) {
+	if (!ask) return [];
+	const found = AGENT_FILES.flatMap((name) => {
+		const file = path.join(root, name);
+		try {
+			return [{
+				name,
+				file,
+				text: fs.readFileSync(file, "utf8")
+			}];
+		} catch {
+			return [];
+		}
+	});
+	const imports = (text) => /^\s*@(?:\.\/)?AGENTS\.md\s*$/m.test(text);
+	const changes = found.filter((f) => !(f.name === "CLAUDE.md" && imports(f.text) && found.length > 1)).map((f) => ({
+		...f,
+		next: withAgentRules(f.text)
+	})).filter((f) => f.next !== f.text);
+	if (!changes.length) return [];
+	const names = andList(changes.map((f) => f.name));
+	const update = changes.every((f) => rulesSection(f.text) !== void 0);
+	const answer = (await ask(update ? `Update the onsystem section in ${names}? [Y/n] ` : `Add a short onsystem section to ${names}, so coding agents check the UI they write? [Y/n] `)).trim().toLowerCase();
+	if (answer !== "" && !answer.startsWith("y")) {
+		io.stdout(`${names} ${changes.length === 1 ? "was" : "were"} left as ${changes.length === 1 ? "it is" : "they are"}.`);
+		return [];
+	}
+	for (const f of changes) fs.writeFileSync(f.file, f.next);
+	io.stdout(update ? `Updated the onsystem section in ${names}.` : `Added an onsystem section to ${names}: it tells agents to run check_ui, or \`npx -y ${NAME} check <file>\` without the ${NAME} tools, on the UI files they change.`);
+	return changes.map((f) => f.name);
+}
+/** `text` with onsystem's section: replaced between its markers, or added at the end. */
+function withAgentRules(text) {
+	const eol = text.includes("\r\n") ? "\r\n" : "\n";
+	const rules = AGENT_RULES.replaceAll("\n", eol);
+	const found = rulesSection(text);
+	if (found) return `${text.slice(0, found.start)}${rules}${text.slice(found.end)}`;
+	if (!text.trim()) return `${rules}${eol}`;
+	return `${text.endsWith("\n") ? text : `${text}${eol}`}${eol}${rules}${eol}`;
+}
+/**
+* Where onsystem's section is in `text`, from its BEGIN marker to the end of its END marker: the
+* first END with a BEGIN before it, and the BEGIN nearest that END. A BEGIN whose END was deleted
+* is then not a section, so the text after it, which may be the user's, is never replaced.
+*/
+function rulesSection(text) {
+	for (let end = text.indexOf(RULES_END); end !== -1; end = text.indexOf(RULES_END, end + 1)) {
+		const start = text.lastIndexOf(RULES_BEGIN, end);
+		if (start !== -1) return {
+			start,
+			end: end + 33
+		};
+	}
+}
 function readManifest(root) {
 	const file = path.join(root, "package.json");
 	try {
@@ -346,16 +321,189 @@ 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.`;
+}
+const REGISTRY_DOCS = "https://onsystem.vercel.app/docs/configuration#code-from-shadcn-registries";
+/**
+* Sets apart the code `npx shadcn add` copies from the registries components.json names
+* (`"registries": { "@signoff-ui": … }`) into a folder of its own under the components alias
+* (`components/signoff-ui`). When `found` says "components" holds what zero config found, and
+* no `importPath` names a package for them, each such folder joins it: `check` and the hook skip
+* that code, as they skip components/ui, and the app's code is checked against its components.
+* A folder with no .tsx or .jsx file yet joins it too, and so does one that does not exist yet:
+* a registry is often named in components.json before its first `shadcn add`, and an item of
+* only .ts files (signoff-ui's ag-ui) makes the folder before a component comes. Otherwise the
+* notes name the folders `check` reads as the app's own code, and what to add to set them apart.
+* Folders the components already take in are left alone. Returns what to tell the user.
+*/
+async function registryCode(config, file, found) {
+	const root = config.root;
+	const folders = registryFolders(root, config.tsconfig);
+	if (!folders.length) return [];
+	const globs = Array.isArray(file.components) ? file.components : config.components;
+	const taken = new Set(await componentFiles({
+		...config,
+		components: globs
+	}));
+	const copied = [];
+	const pending = [];
+	const added = [];
+	for (const { namespace, dir } of folders) {
+		const glob = `${escapePath(dir)}/**/*.{tsx,jsx}`;
+		const files = await componentFiles({
+			...config,
+			components: [glob]
+		});
+		const folder = {
+			namespace,
+			dir,
+			glob,
+			files: files.length
+		};
+		if (files.some((f) => !taken.has(f))) copied.push(folder);
+		else if (files.length || globs.some((g) => matchesGlob(`${dir}/index.tsx`, g))) continue;
+		else pending.push(folder);
+		added.push(glob);
+	}
+	const add = found && file.importPath === void 0;
+	if (add && added.length) file.components = [...globs, ...added];
+	const listed = Array.isArray(file.components) && file.importPath === void 0;
+	const how = (list) => listed ? `add ${andList(list.map((f) => `"${f.glob}"`))} to "components" (${REGISTRY_DOCS})` : `turn the rules off for ${andList(list.map((f) => `"${escapePath(f.dir)}/**"`))} in "overrides" (${REGISTRY_DOCS})`;
+	const notes = [];
+	if (copied.length) {
+		const one = copied.length === 1;
+		notes.push(add ? `Added ${andList(copied.map((f) => `${f.dir} (${f.namespace}, ${count$1(f.files, "file")})`))} to "components": ${one ? "it holds" : "they hold"} the code \`shadcn add\` copied from ${one ? "that registry" : "those registries"} in components.json. \`check\` and the hook skip it as design-system code, and your code is checked against every component its files export, helpers included, so a native element such as <img> can be told to use one of them. To leave the helpers out, see ${REGISTRY_DOCS}; to check that code as your own, take ${one ? "the folder" : "the folders"} out of "components".` : `components.json names the ${one ? "registry" : "registries"} ${andList(copied.map((f) => f.namespace))}, which \`shadcn add\` copies into ${andList(copied.map((f) => f.dir))}: \`check\` reads ${one ? "its" : "their"} code as your own. To set it apart, ${how(copied)}.`);
+	}
+	if (pending.length) {
+		const one = pending.length === 1;
+		const state = pending.some((f) => isDirectory(path.join(root, f.dir))) ? `${one ? "holds" : "hold"} no .tsx or .jsx file yet` : `${one ? "does" : "do"} not exist yet`;
+		notes.push(add ? `${copied.length ? "Also added" : "Added"} ${andList(pending.map((f) => `${f.dir} (${f.namespace})`))} to "components", though ${one ? "it" : "they"} ${state}: \`check\` and the hook skip the code \`shadcn add\` copies there from ${one ? "that registry" : "those registries"} in components.json. Code a registry copies somewhere else, such as loose into ${path.posix.dirname(pending[0]?.dir ?? "")}/, is checked as your own (${REGISTRY_DOCS}).` : `components.json ${copied.length ? "also " : ""}names ${andList(pending.map((f) => f.namespace))}, and ${andList(pending.map((f) => f.dir))} ${state}: once \`shadcn add\` copies a .tsx or .jsx file there, \`check\` reads it as your own. To set it apart, ${how(pending)}.`);
+	}
+	return notes;
+}
+function isDirectory(dir) {
+	try {
+		return fs.statSync(dir).isDirectory();
+	} catch {
+		return false;
+	}
+}
+/**
+* The folders, relative to the root, that `npx shadcn add` copies the code of the registries
+* components.json names into: the components alias, resolved through tsconfig `paths`, and the
+* namespace without its `@` (`@/components` and `@signoff-ui` → `components/signoff-ui`).
+*/
+function registryFolders(root, tsconfig) {
+	let json;
+	try {
+		json = JSON.parse(fs.readFileSync(path.join(root, "components.json"), "utf8"));
+	} catch {
+		return [];
+	}
+	const alias = json?.aliases?.components;
+	const registries = json?.registries;
+	if (typeof alias !== "string" || !registries || typeof registries !== "object") return [];
+	const namespaces = Object.keys(registries).filter((n) => /^@[a-z0-9][\w-]*$/i.test(n)).sort();
+	const base = namespaces.length ? aliasFolder(alias, readProjectConfig(root, tsconfig)) : void 0;
+	if (!base || !isInside(root, base)) return [];
+	return namespaces.map((namespace) => ({
+		namespace,
+		dir: relativePath(root, path.join(base, namespace.slice(1)))
+	}));
+}
+/**
+* A components.json alias (`@/components`) through tsconfig `paths` (`"@/*": ["./*"]`), as zero
+* config resolves the ui alias, when the folder exists.
+*/
+function aliasFolder(alias, project) {
+	for (const [pattern, targets] of Object.entries(project.paths)) {
+		const star = pattern.indexOf("*");
+		const prefix = star === -1 ? pattern : pattern.slice(0, star);
+		const suffix = star === -1 ? "" : pattern.slice(star + 1);
+		if (!(star === -1 ? alias === pattern : alias.startsWith(prefix) && alias.endsWith(suffix) && alias.length >= prefix.length + suffix.length)) continue;
+		const middle = star === -1 ? "" : alias.slice(prefix.length, alias.length - suffix.length);
+		for (const target of targets) {
+			const dir = path.resolve(project.pathsBase, target.replace("*", middle));
+			try {
+				if (fs.statSync(dir).isDirectory()) return dir;
+			} catch {}
+		}
+	}
 }
 /** Whether npm's `files` list publishes `file`, a path relative to the package. */
 function ships(files, file) {
@@ -413,6 +561,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 +605,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
@@ -461,6 +615,9 @@ Options
                           files, which are skipped by default
   --include-tests         check: also lint tests and stories (*.test.tsx,
                           *.spec.tsx, *.stories.tsx) in folders and globs
+  --skip-excluded         check: leave out files named outright that the config's
+                          exclude covers, as folders and globs leave them out
+                          (the Claude Code hook passes it)
   --quiet-without-design-system
                           check: print nothing and exit 0 when the project has no
                           design-system components and no config (tokens alone
@@ -468,7 +625,8 @@ Options
                           many projects
   --require-design-system
                           check: exit 2 when no components or no color tokens
-                          are found, so CI cannot pass by checking nothing
+                          are found, or when the folders and globs given leave
+                          no file to check, so CI cannot pass by checking nothing
   --explain               inspect: every candidate zero config looked at and why
                           it was taken or not, the resolved config, unresolved
                           tokens, and components whose props did not resolve
@@ -544,6 +702,10 @@ async function main(argv, io = defaultIo) {
 					type: "boolean",
 					default: false
 				},
+				"prune-baseline": {
+					type: "boolean",
+					default: false
+				},
 				"ignore-baseline": {
 					type: "boolean",
 					default: false
@@ -557,6 +719,10 @@ async function main(argv, io = defaultIo) {
 					type: "boolean",
 					default: false
 				},
+				"skip-excluded": {
+					type: "boolean",
+					default: false
+				},
 				"require-design-system": {
 					type: "boolean",
 					default: false
@@ -666,6 +832,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;
@@ -690,15 +860,34 @@ async function check(patterns, configOptions, values, io) {
 	warnDeprecated(configWarnings(target), format, io);
 	const selection = target.workspace ? await selectInWorkspace(target.workspace, patterns, values, format, io) : await selectInProject(target.config, patterns, values, format, io);
 	if (typeof selection === "number") return selection;
+	const command = (flag) => checkCommand(patterns, configOptions, values, flag);
+	if ("noMatch" in selection) {
+		const jsx = jsxNotice(selection, io.cwd, command);
+		io.stderr(jsx ? `check: nothing to check in ${patterns.join(" ")}. ${jsx}` : `check: no files match ${patterns.join(" ")}`);
+		return 2;
+	}
 	const { files, notes } = selection;
+	const notify = (text) => {
+		if (format === "pretty") io.stdout(text);
+		else if (format === "github") io.stdout(`::warning title=${NAME}::${text}`);
+		else io.stderr(text);
+	};
+	const jsx = jsxNotice(selection, io.cwd, command);
 	if (!files.length) {
-		if (format === "pretty") {
-			const hints = [selection.skipped ? `Pass --include-design-system to check ${selection.skipped === 1 ? "it" : "them"}.` : "", selection.testsLeftOut ? "Pass --include-tests to check tests and stories." : ""].filter(Boolean);
-			io.stdout(`Nothing to check: ${notes.join("; ")}. ${hints.join(" ")}`.trimEnd());
-		} else printNoResults(format, io);
+		const hints = jsx ? [jsx] : [selection.skipped ? `Pass --include-design-system to check ${selection.skipped === 1 ? "it" : "them"}.` : "", selection.testsLeftOut ? "Pass --include-tests to check tests and stories." : ""].filter(Boolean);
+		if (values["require-design-system"] && selection.searched) {
+			io.stderr(`check --require-design-system: nothing was checked${notes.length ? ` (${notes.join("; ")})` : ""}. ${hints.join(" ")}`.trimEnd());
+			return 2;
+		}
+		if (format === "pretty") io.stdout(`Nothing to check${notes.length ? `: ${notes.join("; ")}` : ""}. ${hints.join(" ")}`.trimEnd());
+		else {
+			printNoResults(format, io);
+			if (jsx) notify(jsx);
+		}
 		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 +896,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 +909,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 +919,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,28 +941,56 @@ 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);
+		if (jsx) io.stderr(jsx);
 		return 0;
 	}
+	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 [...selection.notices, unchecked]) {
-		if (!text) continue;
-		if (format === "pretty") io.stdout(text);
-		else if (format === "github") io.stdout(`::warning title=${NAME}::${text}`);
-		else io.stderr(text);
-	}
+	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,
+		jsx
+	]) if (text) notify(text);
 	const errors = results.reduce((n, r) => n + r.errorCount, 0);
 	const warnings = results.reduce((n, r) => n + r.warningCount, 0);
 	if (errors > 0) return 1;
@@ -804,10 +1029,15 @@ function repositoryPath(cwd, env) {
 		return root ? relativePath(root, absolute) : toPosix(file);
 	};
 }
-/** Splits the patterns into files named outright and globs (a folder: every TSX/JSX file under it). */
+/**
+* Splits the patterns into files named outright and globs (a folder: every TSX/JSX file under
+* it). `scripts` globs the `.js` files under the folders, which are not checked, to say which
+* of them have JSX.
+*/
 function expandPatterns(patterns, cwd) {
 	const named = [];
 	const globs = [];
+	const scripts = [];
 	for (const pattern of patterns) {
 		const stat = fs.statSync(path.resolve(cwd, pattern), { throwIfNoEntry: false });
 		if (stat && !stat.isDirectory()) {
@@ -815,47 +1045,131 @@ function expandPatterns(patterns, cwd) {
 			continue;
 		}
 		const literal = stat ? escapePath(toPosix(path.join(pattern, "."))) : toPosix(pattern);
-		globs.push(!stat ? literal : literal === "." ? "**/*.{tsx,jsx}" : `${literal}/**/*.{tsx,jsx}`);
+		if (!stat) {
+			globs.push(literal);
+			continue;
+		}
+		const under = literal === "." ? "**/*" : `${literal}/**/*`;
+		globs.push(`${under}.{tsx,jsx}`);
+		scripts.push(`${under}.js`);
 	}
 	return {
 		named,
-		globs
+		globs,
+		scripts
 	};
 }
+/** A `.js` file larger than this is a bundle or generated, not a page: not read for JSX. */
+const MAX_PAGE_BYTES = 524288;
+/**
+* `.js` files the folders hold that have JSX, which are not checked: folders expand to TSX and
+* JSX files, and a JavaScript app writes its pages as `.js` (Next.js's JavaScript template has
+* `app/page.js`). Files the run checks anyway (a glob names them), what git ignores and what
+* `leftOut` says (the config's `exclude`, the design system's own files) are not counted, nor
+* are minified files and files over 512 KB, which are bundles rather than pages.
+*/
+async function jsxLeftOut(scripts, taken, cwd, leftOut) {
+	if (!scripts.length) return [];
+	const checked = new Set(taken.map(realPath));
+	const found = oncePerFile((await findFiles(scripts, {
+		cwd,
+		absolute: true,
+		expandDirectories: false,
+		ignore: ["**/node_modules/**", "**/*.min.js"]
+	})).filter((file) => !checked.has(realPath(file)))).sort();
+	const ignored = gitIgnored(cwd, found);
+	const files = [];
+	for (const file of found) {
+		if (ignored.has(file) || await leftOut(file)) continue;
+		let code;
+		try {
+			if (fs.statSync(file).size > MAX_PAGE_BYTES) continue;
+			code = fs.readFileSync(file, "utf8");
+		} catch {
+			continue;
+		}
+		if (hasJsx(code)) files.push(file);
+	}
+	return files;
+}
+/**
+* Where a JSX element can start: after `(`, `,`, `=`, `=>`, `?` (not a regex's `(?<name>`), `:`,
+* `[`, `{`, `&`, `|`, `return`, `yield`, `await` or `default`, with spaces and short comments
+* between. Plain JavaScript has a `<` and a name there only in strings and comments.
+*/
+const JSX_START = /(?:(?<!\()\?|=>|[(,=:[{&|]|\b(?:return|yield|await|default))(?:\s|\/\/[^\n]{0,200}\n|\/\*(?:[^*]|\*(?!\/)){0,500}\*\/)*<([A-Za-z][\w.:-]*|>(?=[\s<{]))/g;
+/**
+* Whether the code may have JSX: an element starts where only JSX can start one, and it is a
+* fragment, its closing tag is there, or a `/>` follows it. A library bundle whose strings hold
+* HTML rarely passes, so most `.js` files are never parsed.
+*/
+function mayHaveJsx(code) {
+	for (const match of code.matchAll(JSX_START)) {
+		const name = match[1] ?? "";
+		if (name === ">" || code.includes(`</${name}>`)) return true;
+		const from = match.index + match[0].length;
+		const close = code.indexOf("/>", from);
+		if (close >= 0 && close - from < 2e3) return true;
+	}
+	return false;
+}
+/** Whether the code has a JSX element or fragment. */
+function hasJsx(code) {
+	if (!code.includes("/>") && !code.includes("</")) return false;
+	if (!mayHaveJsx(code)) return false;
+	const source = ts.createSourceFile("file.js", code, ts.ScriptTarget.Latest, false, ts.ScriptKind.JSX);
+	const visit = (node) => ts.isJsxElement(node) || ts.isJsxSelfClosingElement(node) || ts.isJsxFragment(node) || ts.forEachChild(node, visit) === true;
+	try {
+		return visit(source);
+	} catch {
+		return false;
+	}
+}
+/** Which `.js` files with JSX the folders left out, and the command that checks them. */
+function jsxNotice(selection, cwd, command) {
+	const files = selection.jsx.map((file) => relativePath(cwd, file));
+	if (!files.length) return void 0;
+	const check = command(selection.jsxGlobs.map(shellQuote).join(" "));
+	return files.length === 1 ? `${files[0] ?? ""} has JSX, but folders are checked for .tsx and .jsx files, so it was not checked. Name it to check it: \`${check}\`.` : `${files.length.toLocaleString("en-US")} .js files have JSX (${listOf(files)}), but folders are checked for .tsx and .jsx files, so they were not checked. Name them to check them: \`${check}\`.`;
+}
 /** One project: the root's config and design system for every file. */
 async function selectInProject(config, patterns, values, format, io) {
 	const ds = await loadDesignSystem(config, {
 		cache: values.cache,
 		logger: silentLogger
 	});
-	const { named, globs } = expandPatterns(patterns, io.cwd);
+	const { named: given, globs, scripts } = expandPatterns(patterns, io.cwd);
 	const options = {
 		cwd: io.cwd,
 		absolute: true,
 		expandDirectories: false
 	};
-	const all = globs.length ? await findFiles(globs, {
+	const globbed = globs.length ? await findFiles(globs, {
 		...options,
 		ignore: ["**/node_modules/**"]
 	}) : [];
-	const excludes = config.exclude.filter((e) => !(values["include-tests"] && isTestPattern(e))).map((e) => excludeFromCwd(e, config.root, io.cwd)).filter((e) => e !== void 0);
-	const kept = globs.length ? await findFiles(globs, {
-		...options,
-		ignore: unique(["**/node_modules/**", ...excludes])
-	}) : [];
+	const named = given.filter((file) => SCRIPT_FILE.test(file));
+	const all = globbed.filter((file) => SCRIPT_FILE.test(file));
+	const excluded = (file) => excludedBy(config, relativePath(config.root, file), { includeTests: values["include-tests"] }) !== void 0;
+	const ownFiles = async () => new Set(config.includeDesignSystem ? [] : (await componentFiles(config)).map(realPath));
+	const jsxIn = (taken, own) => jsxLeftOut(scripts, taken, io.cwd, (file) => excluded(file) || own.has(realPath(file)));
+	const skip = values["skip-excluded"];
+	const leftOut = unique([...skip ? named : [], ...all]).filter(excluded);
+	const leftOutSet = new Set(leftOut);
+	const kept = all.filter((file) => !leftOutSet.has(file));
 	const ignored = gitIgnored(io.cwd, kept);
-	const keptSet = new Set(kept);
-	const leftOut = all.filter((file) => !keptSet.has(file));
 	const left = {
 		tests: leftOut.filter((file) => TEST_FILE.test(file)).length,
 		excluded: leftOut.filter((file) => !TEST_FILE.test(file)).length,
-		gitignored: ignored.size
+		gitignored: ignored.size,
+		notScripts: notScripts(given, globbed)
+	};
+	let files = oncePerFile([...skip ? named.filter((file) => !leftOutSet.has(file)) : named, ...kept.filter((file) => !ignored.has(file))]).sort();
+	if (!files.length && !all.length && !leftOut.length && !left.notScripts) return {
+		noMatch: true,
+		jsx: scripts.length ? await jsxIn([], await ownFiles()) : [],
+		jsxGlobs: scripts
 	};
-	let files = unique([...named, ...kept.filter((file) => !ignored.has(file))]).sort();
-	if (!files.length && !all.length) {
-		io.stderr(`check: no files match ${patterns.join(" ")}`);
-		return 2;
-	}
 	if (values["quiet-without-design-system"] && !config.configFile && !ds.components.length) {
 		printNoResults(format, io);
 		return 0;
@@ -863,23 +1177,28 @@ 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;
-	if (!config.includeDesignSystem) {
-		const own = new Set((await componentFiles(config)).map(realPath));
+	const own = await ownFiles();
+	if (own.size) {
 		const rest = files.filter((file) => !own.has(realPath(file)));
 		skipped = files.length - rest.length;
 		files = rest;
 	}
+	const jsx = await jsxIn([...named, ...all], own);
 	return {
 		files,
 		designSystemOf: () => ds,
 		root: ds.root,
 		notes: scopeNotes(skipped, left),
-		notices: notice ? [notice] : [],
+		notices: [...notice ? [notice] : [], ...notReadNotices([{ ds }])],
 		skipped,
-		testsLeftOut: left.tests
+		testsLeftOut: left.tests,
+		jsx,
+		jsxGlobs: scripts,
+		searched: globs.length > 0
 	};
 }
 /**
@@ -888,13 +1207,15 @@ async function selectInProject(config, patterns, values, format, io) {
 * config, exactly as `check` from that folder (and the Claude Code hook) would check it.
 */
 async function selectInWorkspace(workspace, patterns, values, format, io) {
-	const { named, globs } = expandPatterns(patterns, io.cwd);
-	const all = globs.length ? await findFiles(globs, {
+	const { named: given, globs, scripts } = expandPatterns(patterns, io.cwd);
+	const globbed = globs.length ? await findFiles(globs, {
 		cwd: io.cwd,
 		absolute: true,
 		expandDirectories: false,
 		ignore: ["**/node_modules/**"]
 	}) : [];
+	const named = given.filter((file) => SCRIPT_FILE.test(file));
+	const all = globbed.filter((file) => SCRIPT_FILE.test(file));
 	const projectOf = /* @__PURE__ */ new Map();
 	for (const file of unique([...named, ...all])) projectOf.set(file, await workspace.projectFor(file));
 	const project = (file) => {
@@ -914,24 +1235,42 @@ async function selectInWorkspace(workspace, patterns, values, format, io) {
 		}
 		return ds;
 	};
-	const leftOut = all.filter((file) => {
+	const excluded = (file) => {
 		const { root, config } = project(file);
 		const relative = relativePath(root, file);
-		return config.exclude.some((e) => !(values["include-tests"] && isTestPattern(e)) && matchesGlob(relative, e));
-	});
+		return excludedBy(config, relative, { includeTests: values["include-tests"] }) !== void 0;
+	};
+	const skip = values["skip-excluded"];
+	const leftOut = unique([...skip ? named : [], ...all]).filter(excluded);
 	const leftOutSet = new Set(leftOut);
 	const kept = all.filter((file) => !leftOutSet.has(file));
 	const ignored = gitIgnored(io.cwd, kept);
 	const left = {
 		tests: leftOut.filter((file) => TEST_FILE.test(file)).length,
 		excluded: leftOut.filter((file) => !TEST_FILE.test(file)).length,
-		gitignored: ignored.size
+		gitignored: ignored.size,
+		notScripts: notScripts(given, globbed)
+	};
+	let files = oncePerFile([...skip ? named.filter((file) => !leftOutSet.has(file)) : named, ...kept.filter((file) => !ignored.has(file))]).sort();
+	const own = /* @__PURE__ */ new Map();
+	const ownFiles = async (p) => {
+		let mine = own.get(p.root);
+		if (!mine) {
+			mine = new Set(p.config.includeDesignSystem ? [] : (await componentFiles(p.config)).map(realPath));
+			own.set(p.root, mine);
+		}
+		return mine;
+	};
+	const jsxIn = (taken) => jsxLeftOut(scripts, taken, io.cwd, async (file) => {
+		const p = await workspace.projectFor(file);
+		projectOf.set(file, p);
+		return excluded(file) || (await ownFiles(p)).has(realPath(file));
+	});
+	if (!files.length && !all.length && !leftOut.length && !left.notScripts) return {
+		noMatch: true,
+		jsx: await jsxIn([]),
+		jsxGlobs: scripts
 	};
-	let files = unique([...named, ...kept.filter((file) => !ignored.has(file))]).sort();
-	if (!files.length && !all.length) {
-		io.stderr(`check: no files match ${patterns.join(" ")}`);
-		return 2;
-	}
 	const loaded = /* @__PURE__ */ new Map();
 	for (const p of unique(files.map(project))) loaded.set(p.root, await load(p));
 	const designSystemOf = (file) => {
@@ -958,14 +1297,11 @@ async function selectInWorkspace(workspace, patterns, values, format, io) {
 			return 2;
 		}
 	}
-	const own = /* @__PURE__ */ new Map();
-	for (const p of unique(files.map(project))) {
-		if (p.config.includeDesignSystem) continue;
-		own.set(p.root, new Set((await componentFiles(p.config)).map(realPath)));
-	}
+	for (const p of unique(files.map(project))) await ownFiles(p);
 	const rest = files.filter((file) => !own.get(project(file).root)?.has(realPath(file)));
 	const skipped = files.length - rest.length;
 	files = rest;
+	const jsx = await jsxIn([...named, ...all]);
 	const gaps = /* @__PURE__ */ new Map();
 	for (const p of unique(files.map(project))) {
 		const ds = loaded.get(p.root);
@@ -979,6 +1315,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,
@@ -987,7 +1331,10 @@ async function selectInWorkspace(workspace, patterns, values, format, io) {
 		notes: [...used > 1 ? [plural(used, "project")] : [], ...scopeNotes(skipped, left)],
 		notices: notices.filter(Boolean),
 		skipped,
-		testsLeftOut: left.tests
+		testsLeftOut: left.tests,
+		jsx,
+		jsxGlobs: scripts,
+		searched: globs.length > 0
 	};
 }
 /** `apps/web`, `apps/web and packages/ui`, `a, b, c and 4 more`. */
@@ -1041,6 +1388,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 +1397,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 +1502,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. */
@@ -1202,9 +1560,12 @@ function defaultBaseline(root, warn) {
 }
 /** Tests and stories, which `check` leaves out of folders and globs unless asked. */
 const TEST_FILE = /\.(?:test|spec|stories)\.[cm]?[jt]sx?$|[\\/]__(?:tests|stories|mocks)__[\\/]/;
-/** The default patterns `--include-tests` lifts. */
-function isTestPattern(pattern) {
-	return pattern === "**/*.{test,spec,stories}.{ts,tsx,js,jsx}" || pattern === "**/__{tests,stories,mocks}__/**";
+/**
+* How many of the files named outright or matched by a glob are not JS or TS (styles, docs,
+* JSON), which are not checked.
+*/
+function notScripts(named, globbed) {
+	return oncePerFile([...named, ...globbed].filter((file) => !SCRIPT_FILE.test(file))).length;
 }
 /** What a run left out, for the summary line: `5 design-system files skipped`. */
 function scopeNotes(skipped, left) {
@@ -1212,22 +1573,11 @@ function scopeNotes(skipped, left) {
 		skipped ? `${plural(skipped, "design-system file")} skipped` : "",
 		left.tests ? `${left.tests.toLocaleString("en-US")} ${left.tests === 1 ? "test or story" : "tests and stories"} left out` : "",
 		left.excluded ? `${plural(left.excluded, "excluded file")} left out` : "",
-		left.gitignored ? `${plural(left.gitignored, "file")} git ignores left out` : ""
+		left.gitignored ? `${plural(left.gitignored, "file")} git ignores left out` : "",
+		left.notScripts ? `${plural(left.notScripts, "file")} that ${left.notScripts === 1 ? "is" : "are"} not JS or TS skipped` : ""
 	].filter(Boolean);
 }
 /**
-* A config `exclude` pattern, relative to the root, as a pattern relative to the
-* working directory the globs run from; undefined when it only covers files
-* outside that directory. `**\/` patterns hold anywhere.
-*/
-function excludeFromCwd(pattern, root, cwd) {
-	if (pattern.startsWith("**/")) return pattern;
-	const fromRoot = toPosix(path.relative(root, cwd));
-	if (!fromRoot) return pattern;
-	if (fromRoot.startsWith("..")) return toPosix(path.join(path.relative(cwd, root), pattern));
-	return pattern.startsWith(`${fromRoot}/`) ? pattern.slice(fromRoot.length + 1) : void 0;
-}
-/**
 * Files a glob matches, as Node spells absolute paths (with backslashes on Windows, where
 * tinyglobby gives forward slashes), so they compare equal to `path.resolve` and git's.
 */
@@ -1259,6 +1609,51 @@ 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");
+	if (values["skip-excluded"]) args.push("--skip-excluded");
+	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 +1666,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);