onsystem 0.8.0 → 0.9.1

package/dist/{design-system-Dmcv7eHR.js → design-system-DZm2aP1z.js}

@@ -5,10 +5,10 @@ import * as z from "zod";
 import { escapePath, glob, globSync } from "tinyglobby";
 import ts from "typescript";
 import os from "node:os";
+import postcss from "postcss";
 import { clampChroma, colorsNamed, converter, differenceEuclidean, formatHex, parse, wcagContrast } from "culori";
 import { createHash } from "node:crypto";
 import fsp from "node:fs/promises";
-import postcss from "postcss";
 import { LineCounter, isMap, isScalar, parseDocument, stringify } from "yaml";
 import { stemmer } from "stemmer";
 //#region src/extract/program.ts
@@ -142,7 +142,7 @@ function slashGlob(pattern) {
 * `.mjs` and `.cjs` forms, in any case. CSS, Markdown or JSON parsed as TSX gives hundreds of
 * syntax errors (209 for a shadcn/ui `app/globals.css`).
 */
-const SCRIPT_FILE$1 = /\.(?:[jt]sx?|[cm][jt]s)$/i;
+const SCRIPT_FILE$2 = /\.(?:[jt]sx?|[cm][jt]s)$/i;
 /** Path relative to `root`, always with forward slashes. */
 function relativePath(root, file) {
 	return toPosix(path.relative(root, file));
@@ -514,6 +514,59 @@ function isFile$1(file) {
 	}
 }
 //#endregion
+//#region src/tokens/imports.ts
+/** Enough stylesheets for a theme split over files, without reading a whole design system. */
+const MAX_IMPORTED = 50;
+/**
+* The specifiers a stylesheet `@import`s: `@import "./theme.css" layer(base)`,
+* `@import url(theme.css)`, `@import "@acme/theme"`. Empty for CSS that does not parse.
+*/
+function cssImports(css) {
+	let root;
+	try {
+		root = postcss.parse(css);
+	} catch {
+		return [];
+	}
+	const out = [];
+	for (const node of root.nodes) {
+		if (node.type !== "atrule" || node.name !== "import") continue;
+		const match = /^\s*(?:url\(\s*)?(?:"([^"]+)"|'([^']+)'|([^\s"')]+)\s*\))/.exec(node.params);
+		const specifier = match?.[1] ?? match?.[2] ?? match?.[3];
+		if (specifier) out.push(specifier);
+	}
+	return out;
+}
+/**
+* The stylesheets `files` import, and the ones those import in turn, each once, in the order
+* the cascade ranks them, for a reader that keeps the first declaration of a variable. CSS
+* puts an imported stylesheet where its `@import` is, so a later import overrides an earlier
+* one, and the importing stylesheet's own rules override both: `@import "./base.css";
+* @import "./brand.css";` lists brand.css, then what brand.css imports, then base.css. The
+* files themselves are not repeated, and come before all of these.
+*/
+function importedStylesheets(files, resolve) {
+	const seen = new Set(files);
+	const out = [];
+	const visit = (file) => {
+		let text;
+		try {
+			text = fs.readFileSync(file, "utf8");
+		} catch {
+			return;
+		}
+		for (const specifier of cssImports(text).reverse()) {
+			const target = resolve(specifier, file);
+			if (!target || seen.has(target) || out.length >= MAX_IMPORTED) continue;
+			seen.add(target);
+			out.push(target);
+			visit(target);
+		}
+	};
+	for (const file of files) visit(file);
+	return out;
+}
+//#endregion
 //#region src/util/strings.ts
 /** `alert-dialog` / `alert_dialog` / `alertDialog` → `AlertDialog`. */
 function pascalCase(input) {
@@ -579,7 +632,7 @@ function unique(items) {
 const ignore = () => void 0;
 const COMPONENT_FILE = /\.[jt]sx$/;
 /** A module a barrel can lead to: TypeScript or JavaScript, not a declaration file. */
-const SCRIPT_FILE = /(?<!\.d)\.[cm]?[jt]sx?$/;
+const SCRIPT_FILE$1 = /(?<!\.d)\.[cm]?[jt]sx?$/;
 const STYLESHEETS = [
 	"src/styles/globals.css",
 	"src/globals.css",
@@ -588,6 +641,18 @@ const STYLESHEETS = [
 	"src/index.css"
 ];
 /**
+* An app's own stylesheets, where zero config looks for them without components.json (the
+* stylesheets of `DEFAULT_TOKENS` in config.ts).
+*/
+const APP_STYLESHEETS = [
+	"app/globals.css",
+	"src/app/globals.css",
+	"styles/globals.css",
+	"src/styles/globals.css",
+	"src/index.css",
+	"app/app.css"
+];
+/**
 * Finds the design system without a config:
 *
 * 1. `components.json` (shadcn/ui): the `ui` alias, resolved through tsconfig
@@ -660,6 +725,15 @@ function detectProject(root, tsconfig, trace, declared, packages = new PackageFi
 	const names = unique([...declared ? [declared.name] : [], ...dependencies.filter(isDesignSystemName)]);
 	if (!names.length) step("workspace design-system packages", false, `no dependency is named like one (@acme/ui, acme-ui, @acme/design-system) among ${plural(dependencies.length, "dependency", "dependencies")}`);
 	let imported;
+	let declarations;
+	/** What the trace adds for an installed package whose sources are not read. */
+	const declarationsNote = (name, dir, pkg) => {
+		declarations ??= new Set(declarationsPackages(root, packages).map((p) => p.name));
+		if (declarations.has(name)) return "; its components are read from its type declarations instead";
+		if (!declaresTypes(dir, pkg)) return "";
+		const scope = scopeOf$1(name);
+		return `; its type declarations are read when it declares its onsystem config${scope ? `, when the app is in its npm scope (${scope}/…)` : ""} or when the app's config sets "importPath" to "${name}"`;
+	};
 	for (const name of names) {
 		const own = name === declared?.name ? declared : void 0;
 		const workspaceDir = own ? void 0 : packages.find(name);
@@ -687,7 +761,10 @@ function detectProject(root, tsconfig, trace, declared, packages = new PackageFi
 				prefixes: [name]
 			});
 			step(candidate, true, `${relativePath(root, dir)}, ${countFiles(root, result)}`);
-		} else step(candidate, false, result ? "its components match no file" : unique(reasons).join("; ") || "nothing to read");
+		} else {
+			const reason = result ? "its components match no file" : unique(reasons).join("; ") || "nothing to read";
+			step(candidate, false, kind === "installed" ? `${reason}${declarationsNote(name, dir, pkg)}` : reason);
+		}
 	}
 	const registries = shadcn && project && fromShadcn && !withDefaults ? fromRegistries(root, shadcn, fromShadcn, found, project, step) : [];
 	if (found.length) {
@@ -880,15 +957,28 @@ function fromComponentsJson(root, dir, json, project, packages, note = ignore) {
 	}
 	const tailwind = asRecord(json.tailwind);
 	const css = typeof tailwind.css === "string" && tailwind.css ? path.resolve(dir, tailwind.css) : void 0;
+	const named = css && fs.existsSync(css) ? [css] : [];
 	return {
 		components: [`${escapePath(relativePath(root, uiDir) || ".")}/**/*.{tsx,jsx}`],
-		tokens: css && fs.existsSync(css) ? [escapePath(relativePath(root, css))] : [],
+		tokens: (dir === root ? withAppStylesheets(root, named) : named).map((f) => escapePath(relativePath(root, f))),
 		imports,
 		dirs: [uiDir],
 		source: `${ui} → ${relativePath(root, uiDir) || "."}`,
 		...ownerPackage(root, uiDir, ui)
 	};
 }
+/**
+* The stylesheets an app's tokens come from when its components.json names a stylesheet in
+* another package, as cal.com's names coss/ui's: the app's own stylesheets first, which hold
+* its own tokens, then the named one, unless they import it, so that the cascade places it.
+*/
+function withAppStylesheets(root, named) {
+	if (named.every((file) => isInside(root, file))) return named;
+	const own = APP_STYLESHEETS.map((f) => path.join(root, f)).filter(isFile);
+	if (!own.length) return named;
+	const imported = new Set(importedStylesheets(own, stylesheetResolver(root)));
+	return [...own, ...named.filter((file) => !imported.has(file))];
+}
 /** How a shadcn registry is named in components.json: `@` and a name, so none leads out of the folder. */
 const REGISTRY_NAMESPACE = /^@[a-z0-9][\w-]*$/i;
 /**
@@ -1044,7 +1134,7 @@ function fromPackage(root, dir, pkg, note = ignore, installed = false) {
 	for (const mapping of mappings) {
 		const file = path.resolve(root, mapping.target);
 		if (installed && isCompiledExport(dir, file)) continue;
-		if (mapping.target.includes("*") || !SCRIPT_FILE.test(file) || !isFile(file)) {
+		if (mapping.target.includes("*") || !SCRIPT_FILE$1.test(file) || !isFile(file)) {
 			add(mapping, COMPONENT_FILE.test(mapping.target));
 			continue;
 		}
@@ -1334,7 +1424,7 @@ function presetResolver(root) {
 		if (file || specifier.startsWith(".")) return file;
 		const name = packageName(specifier);
 		const dir = name ? packages.find(name) : void 0;
-		return name && dir ? exportedFile(dir, `.${specifier.slice(name.length)}`, (f) => SCRIPT_FILE.test(f)) : void 0;
+		return name && dir ? exportedFile(dir, `.${specifier.slice(name.length)}`, (f) => SCRIPT_FILE$1.test(f)) : void 0;
 	};
 }
 /**
@@ -1342,15 +1432,21 @@ function presetResolver(root) {
 * (`./theme.css`, or `theme.css` as plain CSS reads it), or a stylesheet of a workspace
 * package (`@acme/theme/colors.css`, or `@acme/theme` through its `exports` or its `style`
 * field). An installed package resolves only when zero config reads it as a design system
-* ({@link installedDesignSystem}), and a stylesheet in it imports others of that package alone.
-* In an installed package, a stylesheet in a build folder (`dist/index.css`) is compiled, and
-* resolves to nothing. Other installed packages (`tailwindcss`) and URLs resolve to nothing.
+* ({@link installedDesignSystem}) or reads its type declarations ({@link declarationsPackages}:
+* by its config, its scope or the config's `importPath`), and a stylesheet in it imports others
+* of that package alone. In an installed package, a stylesheet in a build folder
+* (`dist/index.css`) is compiled, and resolves to nothing. Other installed packages
+* (`tailwindcss`) and URLs resolve to nothing.
 */
-function stylesheetResolver(root) {
+function stylesheetResolver(root, { importPath } = {}) {
 	const packages = new PackageFinder(root);
 	const designSystems = /* @__PURE__ */ new Map();
+	let declarations;
 	const designSystem = (name) => {
-		if (!designSystems.has(name)) designSystems.set(name, installedDesignSystem(root, name, packages));
+		if (!designSystems.has(name)) {
+			declarations ??= new Set(declarationsPackages(root, packages, { importPath }).map((p) => p.name));
+			designSystems.set(name, installedDesignSystem(root, name, packages) ?? (declarations.has(name) ? packages.installed(name) : void 0));
+		}
 		return designSystems.get(name);
 	};
 	const stylesheet = (file, within) => [file, `${file}.css`].find((f) => f.endsWith(".css") && (within === void 0 || isInside(within, f) && !isBuildOutput(within, f)) && !/(?:^|[\\/])node_modules[\\/]/.test(within === void 0 ? f : path.relative(within, f)) && isFile(f));
@@ -1566,6 +1662,87 @@ function packageImports(root, dir) {
 	return pkg ? fromPackage(root, dir, pkg)?.imports ?? [] : [];
 }
 /**
+* The dependencies of `root` (in `dependencies` or `devDependencies`) whose components are read
+* from their type declarations: design-system packages installed from a registry that name
+* `.d.ts` files, and whose component sources the root does not read (`options.components`
+* matches no file in them), as when they publish only compiled code. A design-system package
+* is one that declares its onsystem config (set up with `init`); one named like a design system
+* in the root's own npm scope (`@acme/ui` for `@acme/web`); or the dependency the root's config
+* names as its `importPath`, whatever its name or scope (`@dub/ui` in an unscoped app). A kit
+* from another scope named like one (`@sanity/ui`, `@react-email/components`) is not the app's
+* design system unless the config says so, and is not read. Workspace packages are read from
+* their sources. None at a workspace root, whose projects each find their own.
+*/
+function declarationsPackages(root, packages = new PackageFinder(root), options = {}) {
+	const own = readJson$1(path.join(root, "package.json"));
+	if (!own || isWorkspaceRoot(root)) return [];
+	const scope = scopeOf$1(own.name);
+	const found = [];
+	let sources;
+	for (const name of Object.keys({
+		...asRecord(own.dependencies),
+		...asRecord(own.devDependencies)
+	})) {
+		const located = packages.locate(name);
+		if (!located) continue;
+		const declaration = located.json["onsystem"] === void 0 ? void 0 : declaredConfig(packages.place(located.dir).dir, located.json);
+		const by = declaration !== void 0 && "file" in declaration ? "config" : scope !== void 0 && scopeOf$1(name) === scope && isDesignSystemName(name) ? "scope" : name === options.importPath ? "importPath" : void 0;
+		if (!by) continue;
+		const installed = packages.installed(name);
+		const pkg = installed ? cachedManifest(path.join(installed, "package.json")) : void 0;
+		if (!installed || !pkg || !declaresTypes(installed, pkg)) continue;
+		sources ??= componentSources(root, options.components ?? []);
+		if (sources.some((file) => isInside(realPath(installed), file))) continue;
+		const version = typeof pkg.version === "string" ? pkg.version : void 0;
+		found.push({
+			name,
+			dir: path.resolve(located.dir),
+			version,
+			by
+		});
+	}
+	return found;
+}
+/** `@acme` for `@acme/web`; undefined for an unscoped name. */
+function scopeOf$1(name) {
+	return typeof name === "string" && /^@[^/]+\/./.test(name) ? name.split("/")[0] : void 0;
+}
+/** Whether a package names type declarations: `types`, a `types` export condition, or `index.d.ts`. */
+function declaresTypes(dir, pkg) {
+	if (typeof pkg.types === "string" || typeof pkg.typings === "string") return true;
+	const hasTypes = (value) => Array.isArray(value) ? value.some(hasTypes) : value !== null && typeof value === "object" && Object.entries(value).some(([key, nested]) => key === "types" || hasTypes(nested));
+	return hasTypes(pkg.exports) || isFile(path.join(dir, "index.d.ts"));
+}
+/** Files that hold no component to read: declarations, tests and stories, as `exclude` has them. */
+const NOT_COMPONENT_SOURCES = [
+	"**/*.d.ts",
+	"**/*.{test,spec,stories}.{ts,tsx,js,jsx}",
+	"**/__{tests,stories,mocks}__/**"
+];
+/**
+* The real paths of the component files in `node_modules` that `patterns` (relative to `root`)
+* match: the sources of an installed package that the root reads, through a design-system
+* package's config or zero config. Tests and stories are not components.
+*/
+function componentSources(root, patterns) {
+	const named = patterns.filter((p) => p.includes("node_modules"));
+	if (!named.length) return [];
+	return globSync(named, {
+		cwd: root,
+		absolute: true,
+		expandDirectories: false,
+		ignore: NOT_COMPONENT_SOURCES
+	}).map(realPath);
+}
+/** A path with its links resolved, or as it is when it cannot be. */
+function realPath(file) {
+	try {
+		return fs.realpathSync(file);
+	} catch {
+		return path.resolve(file);
+	}
+}
+/**
 * Dependencies' package.json files, parsed, by path: read again only when one's size or mtime
 * changes, so a config loaded again (the ESLint plugin's and the MCP server's reloads) does not
 * read every dependency again.
@@ -1910,7 +2087,7 @@ const KEYWORDS = /* @__PURE__ */ new Set([
 * `/ alpha` allowed): how Tailwind v3 projects, and shadcn/ui before v4, store
 * colors, to be used as `hsl(var(--border))`.
 */
-const BARE_HSL = /^(-?\d*\.?\d+)(deg)?(?:\s*,\s*|\s+)(\d*\.?\d+)%(?:\s*,\s*|\s+)(\d*\.?\d+)%(?:\s*\/\s*(\d*\.?\d+%?))?$/;
+const BARE_HSL = /^(-?(?:\d+(?:\.\d+)?|\.\d+))(deg)?(?:\s*,\s*|\s+)(\d+(?:\.\d+)?|\.\d+)%(?:\s*,\s*|\s+)(\d+(?:\.\d+)?|\.\d+)%(?:\s*\/\s*((?:\d+(?:\.\d+)?|\.\d+)%?))?$/;
 function isBareHsl(value) {
 	return BARE_HSL.test(value.trim());
 }
@@ -1920,7 +2097,7 @@ function isBareHsl(value) {
 * Three numbers alone are no sure color, so they count as one only in a token already
 * known to be a color: one the Tailwind config reads with `rgb()`.
 */
-const BARE_RGB = /^(\d{1,3})(?:\s*,\s*|\s+)(\d{1,3})(?:\s*,\s*|\s+)(\d{1,3})(?:\s*\/\s*(\d*\.?\d+%?))?$/;
+const BARE_RGB = /^(\d{1,3})(?:\s*,\s*|\s+)(\d{1,3})(?:\s*,\s*|\s+)(\d{1,3})(?:\s*\/\s*((?:\d+(?:\.\d+)?|\.\d+)%?))?$/;
 function isBareRgb(value) {
 	const match = BARE_RGB.exec(value.trim());
 	return match !== null && match.slice(1, 4).every((channel) => Number(channel) <= 255);
@@ -2432,9 +2609,23 @@ const UNREAD_LIBRARIES = [
 function libraryAdapter(name) {
 	return LIBRARIES.find((library) => library.package === name);
 }
-/** A library's name for messages, read or not: `MUI`, `Chakra UI`. */
+/** What a design-system package read from its type declarations is called in messages. */
+const PACKAGE_TITLE = "Design-system package";
+/** A library's name for messages, read or not: `MUI`, `Chakra UI`, `Design-system package`. */
 function libraryTitle(name) {
-	return [...LIBRARIES, ...UNREAD_LIBRARIES].find((l) => l.package === name)?.title ?? name;
+	return [...LIBRARIES, ...UNREAD_LIBRARIES].find((l) => l.package === name)?.title ?? PACKAGE_TITLE;
+}
+/**
+* The adapter for a design-system package read from its type declarations (`@acme/ui`): its
+* components and their props, with no theme to read, and the app's augmentations of its modules.
+*/
+function packageAdapter(name) {
+	const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	return {
+		package: name,
+		title: PACKAGE_TITLE,
+		augments: new RegExp(`declare\\s+module\\s+['"]${escaped}(?:/[\\w./-]*)?['"]`)
+	};
 }
 /** Why a library in `UNREAD_LIBRARIES` is not read: `a dependency onsystem does not read yet (…)`. */
 function notReadYet() {
@@ -2446,8 +2637,15 @@ function notReadYet() {
 * folder above it, as a monorepo hoists it. Nothing in the package is run. `ids` is the config's
 * `libraries`: undefined reads every library onsystem supports, false none, a list those named;
 * the dependencies it leaves out are `off`. Those in `UNREAD_LIBRARIES` are `unread`.
-*/
-function detectLibraries(root, ids) {
+*
+* The design-system packages installed without their component sources that the app depends
+* on ({@link declarationsPackages}) come after them, read from their type declarations unless
+* `libraries` is false. A list names libraries, not packages, so it leaves them in. `options`
+* is what the config says of them: its `importPath`, which makes the dependency it names one,
+* and the component globs that read a package from its sources instead. A library onsystem
+* knows is never read as one, whatever `importPath` says.
+*/
+function detectLibraries(root, ids, options = {}) {
 	const pkg = readJson(path.join(root, "package.json"));
 	if (!pkg) return {
 		read: [],
@@ -2476,9 +2674,16 @@ function detectLibraries(root, ids) {
 		source: sourceOf(library.package)
 	}));
 	const wanted = (id) => ids === void 0 || ids !== false && ids.includes(id);
+	const known = new Set([...LIBRARIES, ...UNREAD_LIBRARIES].map((library) => library.package));
+	const packages = declarationsPackages(root, void 0, options).filter((p) => !known.has(p.name)).map((p) => ({
+		package: p.name,
+		dir: p.dir,
+		version: p.version,
+		designSystem: true
+	}));
 	return {
-		read: found.filter((f) => wanted(f.id)).map((f) => f.source),
-		off: found.filter((f) => !wanted(f.id)).map((f) => f.source),
+		read: [...found.filter((f) => wanted(f.id)).map((f) => f.source), ...ids === false ? [] : packages],
+		off: [...found.filter((f) => !wanted(f.id)).map((f) => f.source), ...ids === false ? packages : []],
 		unread: UNREAD_LIBRARIES.filter((library) => dependencies.has(library.package)).map((library) => sourceOf(library.package))
 	};
 }
@@ -2630,7 +2835,7 @@ function classText(node) {
 	visit(node);
 	return parts.join(" ").replace(/\s+/g, " ").trim();
 }
-const LENGTH = /^(-?(?:\d+\.?\d*|\.\d+))(px|rem|em)?$/i;
+const LENGTH = /^(-?(?:\d+(?:\.\d*)?|\.\d+))(px|rem|em)?$/i;
 /** `"0.5rem"` → 8, `"12px"` → 12, `"4"` → 4. Returns undefined for anything else. */
 function lengthToPx(value) {
 	if (typeof value === "number") return Number.isFinite(value) ? value : void 0;
@@ -2658,13 +2863,27 @@ function evaluateLength(value, resolve, depth = 0) {
 function expandVars(value, resolve, depth) {
 	let out = "";
 	let last = 0;
-	for (const match of value.matchAll(/var\(\s*(--[\w-]+)\s*(?:,\s*([^)]+))?\)/g)) {
-		const [whole, name = "", fallback] = match;
+	for (let at = value.indexOf("var(", last); at !== -1; at = value.indexOf("var(", last)) {
+		let level = 0;
+		let comma = -1;
+		let end = -1;
+		for (let i = at + 3; i < value.length; i++) {
+			const c = value[i];
+			if (c === "(") level++;
+			else if (c === ")" && --level === 0) {
+				end = i;
+				break;
+			} else if (c === "," && level === 1 && comma === -1) comma = i;
+		}
+		if (end === -1) return void 0;
+		const name = value.slice(at + 4, comma === -1 ? end : comma).trim();
+		if (!/^--[\w-]+$/.test(name)) return void 0;
+		const fallback = comma === -1 ? void 0 : value.slice(comma + 1, end);
 		const resolved = resolve(name) ?? fallback;
 		const px = resolved === void 0 ? void 0 : evaluateLength(resolved, resolve, depth + 1);
 		if (px === void 0) return void 0;
-		out += `${value.slice(last, match.index)}${px}px`;
-		last = match.index + whole.length;
+		out += `${value.slice(last, at)}${px}px`;
+		last = end + 1;
 	}
 	return out + value.slice(last);
 }
@@ -2790,6 +3009,10 @@ function utilities(namespace, key) {
 //#region src/tokens/tailwind-config.ts
 /** A preset chain is a few files deep; anything beyond is not a Tailwind config. */
 const MAX_FILES = 12;
+/** A config or preset module, which is read for its theme. */
+const SCRIPT_FILE = /\.[cm]?[jt]s$/;
+/** Tailwind's own modules, such as `tailwindcss/defaultTheme`, which hold its defaults. */
+const TAILWIND_MODULE = /^tailwindcss(?:\/|$)/;
 /**
 * Reads which custom property backs which color class from a Tailwind v3
 * config, without running it: every `colors` object in the file
@@ -2819,7 +3042,7 @@ function readTailwindColors(file, resolve) {
 			}
 			const specifier = importedSpecifier(node);
 			const target = specifier === void 0 ? void 0 : resolve(specifier, current);
-			if (target && /\.[cm]?[jt]s$/.test(target)) queue.push(target);
+			if (target && SCRIPT_FILE.test(target)) queue.push(target);
 			ts.forEachChild(node, visit);
 		};
 		visit(source);
@@ -2851,13 +3074,47 @@ function collect(object, keys, colors, rgb) {
 	}
 }
 /**
+* Tailwind v3's default `borderRadius` scale, which `theme.extend.borderRadius` adds to and
+* `theme.borderRadius` replaces. `none` (0) is left out, as the rule skips zero, and `full`
+* is the token index's own `rounded-full`.
+*/
+const TAILWIND_V3_RADIUS = {
+	sm: "0.125rem",
+	DEFAULT: "0.25rem",
+	md: "0.375rem",
+	lg: "0.5rem",
+	xl: "0.75rem",
+	"2xl": "1rem",
+	"3xl": "1.5rem"
+};
+/** borderRadius entries by key, and which of them are Tailwind's default scale rather than the config's. */
+var RadiusEntries = class extends Map {
+	defaults = /* @__PURE__ */ new Set();
+};
+/**
 * Reads `borderRadius` entries from a Tailwind v3 config without running it:
 * every `borderRadius` object in the file, then in the project modules it
-* imports, such as a shared preset. The config's own entries win.
+* imports, such as a shared preset. The config's own entries win. Tailwind's
+* default scale follows, for the keys none of them sets, unless the first
+* `theme.borderRadius` outside `extend` replaces it without spreading it back
+* in (`...defaultTheme.borderRadius`), a `theme` is a whole module or spreads
+* one (`theme: require("./theme")`, `theme: { ...require("./theme") }`), other
+* than Tailwind's own, `presets: []` drops Tailwind's default config
+* and no `theme.borderRadius` spreads the scale back in, or the scale comes from
+* somewhere this cannot read. That is a module that is no project file (one
+* installed from npm, other than Tailwind's own) that the config takes as a
+* preset, a theme, or the config itself (`module.exports = require("x")`,
+* `{ ...require("x"), content }`), or spreads into a theme, its `extend` or a
+* `borderRadius`; a `presets` that is no array; or a `theme.borderRadius` or
+* `theme.extend.borderRadius` that is no object (`borderRadius: radius`,
+* `borderRadius: ({ theme }) => …`) or spreads anything but Tailwind's scale.
 */
 function readTailwindRadii(file, resolve) {
-	const radii = /* @__PURE__ */ new Map();
+	const radii = new RadiusEntries();
 	const files = [];
+	let keepsDefaults;
+	let unread = false;
+	let noDefaultConfig = false;
 	const queue = [file];
 	while (queue.length && files.length < MAX_FILES) {
 		const current = queue.shift() ?? "";
@@ -2870,18 +3127,58 @@ function readTailwindRadii(file, resolve) {
 		}
 		files.push(current);
 		const source = ts.createSourceFile(current, text, ts.ScriptTarget.Latest, true, scriptKind(current));
+		const bindings = importBindings(source);
+		const external = (specifier) => {
+			if (specifier === void 0 || TAILWIND_MODULE.test(specifier)) return false;
+			const target = resolve(specifier, current);
+			return !(target && SCRIPT_FILE.test(target));
+		};
+		const fromPackage = (value) => external(moduleOf(value, bindings));
+		const fromTailwind = (value) => TAILWIND_MODULE.test(moduleOf(value, bindings) ?? "");
 		const visit = (node) => {
-			if (ts.isPropertyAssignment(node) && propertyName(node.name) === "borderRadius" && ts.isObjectLiteralExpression(node.initializer)) {
-				collectRadius(node.initializer, radii);
-				return;
+			if ((ts.isPropertyAssignment(node) || ts.isShorthandPropertyAssignment(node)) && propertyName(node.name) === "borderRadius") {
+				const value = ts.isPropertyAssignment(node) ? node.initializer : void 0;
+				const holder = themeSection(node.parent);
+				if (value && ts.isObjectLiteralExpression(value)) {
+					collectRadius(value, radii);
+					let spreads = false;
+					for (const property of value.properties) {
+						if (!ts.isSpreadAssignment(property)) continue;
+						if (fromTailwind(property.expression)) spreads = true;
+						else unread = true;
+					}
+					if (holder === "theme") keepsDefaults ??= spreads;
+					return;
+				}
+				if (holder === "theme") keepsDefaults ??= false;
+				else if (holder === "extend") unread = true;
 			}
+			if ((ts.isPropertyAssignment(node) || ts.isShorthandPropertyAssignment(node)) && propertyName(node.name) === "presets") {
+				const value = ts.isPropertyAssignment(node) ? node.initializer : void 0;
+				if (value && ts.isArrayLiteralExpression(value)) {
+					if (!value.elements.length) noDefaultConfig = true;
+					for (const element of value.elements) if (fromPackage(ts.isSpreadElement(element) ? element.expression : element)) unread = true;
+				} else unread = true;
+			}
+			if ((ts.isShorthandPropertyAssignment(node) || ts.isPropertyAssignment(node) && !ts.isObjectLiteralExpression(node.initializer)) && propertyName(node.name) === "theme" && !ts.isPropertyAssignment(node.parent.parent)) {
+				keepsDefaults ??= false;
+				if (fromPackage(ts.isPropertyAssignment(node) ? node.initializer : node.name)) unread = true;
+			}
+			if (ts.isSpreadAssignment(node) && fromPackage(node.expression) && (themeSection(node.parent) !== void 0 || !ts.isPropertyAssignment(node.parent.parent) && !themeValueOnly(node.parent, source))) unread = true;
+			if (ts.isSpreadAssignment(node) && themeSection(node.parent) === "theme" && !fromTailwind(node.expression)) keepsDefaults ??= false;
+			if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken && isModuleExports(node.left) && fromPackage(node.right) || ts.isExportAssignment(node) && fromPackage(node.expression) || ts.isExportDeclaration(node) && !node.isTypeOnly && node.exportClause !== void 0 && ts.isNamedExports(node.exportClause) && node.exportClause.elements.some((element) => element.name.text === "default") && node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier) && external(node.moduleSpecifier.text)) unread = true;
 			const specifier = importedSpecifier(node);
 			const target = specifier === void 0 ? void 0 : resolve(specifier, current);
-			if (target && /\.[cm]?[jt]s$/.test(target)) queue.push(target);
+			if (target && SCRIPT_FILE.test(target)) queue.push(target);
 			ts.forEachChild(node, visit);
 		};
 		visit(source);
 	}
+	if ((noDefaultConfig ? keepsDefaults === true : keepsDefaults !== false) && !unread) for (const [key, value] of Object.entries(TAILWIND_V3_RADIUS)) {
+		if (radii.has(key)) continue;
+		radii.set(key, value);
+		radii.defaults.add(key);
+	}
 	return {
 		radii,
 		files
@@ -2901,6 +3198,10 @@ function collectRadius(object, radii) {
 		radii.set(key, raw);
 	}
 }
+/** `module.exports`, as in `module.exports = require("@acme/tailwind-config")`. */
+function isModuleExports(node) {
+	return ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "module" && node.name.text === "exports";
+}
 /**
 * Gives radius tokens their Tailwind v3 class names: each config entry is
 * evaluated (its `var()` against radius token values, so
@@ -2909,15 +3210,29 @@ function collectRadius(object, radii) {
 * token add a synthetic one, so the scale step exists as a candidate
 * (mirrors the spacing-steps synthesis); without it the literal would keep
 * matching the nearest unrelated token. Config entries win over presets.
+*
+* The steps of Tailwind's default scale ({@link RadiusEntries.defaults}) only add
+* a token for a size that has none, named after nothing the project names:
+* `rounded-xl` is 12px in a shadcn/ui v3 project, whose config extends the scale
+* with `lg`, `md` and `sm`. They add none when a config step has no size (its
+* `var(--radius)` is in no stylesheet read), as they would make a scale with
+* holes, nor when the tokens are a Tailwind v4 theme, whose own scale is read from
+* its stylesheet: Tailwind v4's defaults, or a token of an `@theme` variable outside
+* the colors (only v4 reads `@theme`; a v3 config names colors too).
 */
 function applyTailwindRadii(tokens, radii, configFile = "tailwind.config") {
 	const byVar = /* @__PURE__ */ new Map();
 	for (const token of tokens) if (token.category === "radius" && token.cssVar) byVar.set(token.cssVar, token.value);
 	const resolve = (name) => byVar.get(name);
+	const defaults = radii instanceof RadiusEntries ? radii.defaults : /* @__PURE__ */ new Set();
+	const v4 = tokens.some((t) => t.origin === "tailwind-default" || t.category !== "color" && t.tailwind !== void 0);
 	const byPx = /* @__PURE__ */ new Map();
+	let unsized = false;
 	for (const [key, raw] of radii) {
+		if (defaults.has(key)) continue;
 		const px = evaluateLength(raw, resolve);
-		if (px !== void 0 && !byPx.has(px)) byPx.set(px, key);
+		if (px === void 0) unsized = true;
+		else if (!byPx.has(px)) byPx.set(px, key);
 	}
 	const havePx = /* @__PURE__ */ new Set();
 	for (const token of tokens) {
@@ -2949,6 +3264,123 @@ function applyTailwindRadii(tokens, radii, configFile = "tailwind.config") {
 		tokens.push(token);
 		havePx.add(px);
 	}
+	if (unsized || v4) return;
+	const names = new Set(tokens.map((t) => t.name));
+	for (const key of defaults) {
+		const value = radii.get(key) ?? "";
+		const px = evaluateLength(value, resolve);
+		const name = `radius-${key}`;
+		if (px === void 0 || havePx.has(px) || names.has(name)) continue;
+		const token = {
+			name,
+			category: "radius",
+			value,
+			tailwind: key,
+			usage: usageFor({
+				category: "radius",
+				tailwind: key
+			}, "--radius"),
+			description: "Tailwind's default radius scale.",
+			origin: "tailwind-default",
+			source: {
+				file: configFile,
+				line: 1
+			}
+		};
+		tokens.push(token);
+		havePx.add(px);
+	}
+}
+/**
+* Whether an object is the value of a variable that its file uses only as a theme value of a
+* key other than `extend` and `borderRadius`, such as `const brand = { ...blue, ...blueDark }`
+* with `theme: { extend: { colors: brand } }`. What it spreads is then no config, theme or
+* radius scale. A variable that is exported, or used in any other way, may be one.
+*/
+function themeValueOnly(object, source) {
+	let value = object;
+	while (ts.isParenthesizedExpression(value.parent) || ts.isAsExpression(value.parent) || ts.isSatisfiesExpression(value.parent)) value = value.parent;
+	const declaration = value.parent;
+	if (!ts.isVariableDeclaration(declaration) || declaration.initializer !== value || !ts.isIdentifier(declaration.name) || !ts.isVariableStatement(declaration.parent.parent) || declaration.parent.parent.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword)) return false;
+	const name = declaration.name;
+	let only = true;
+	const visit = (node) => {
+		if (!only) return;
+		const parent = node.parent;
+		const key = parent !== void 0 && (ts.isPropertyAssignment(parent) || ts.isPropertyAccessExpression(parent)) && parent.name === node;
+		if (ts.isIdentifier(node) && node !== name && node.text === name.text && !key) only = isThemeValue(node);
+		ts.forEachChild(node, visit);
+	};
+	visit(source);
+	return only;
+}
+/**
+* Whether a name is a theme value, under a key other than `extend` and `borderRadius`:
+* `colors: brand`, or `colors: { brand }`.
+*/
+function isThemeValue(reference) {
+	const parent = reference.parent;
+	let property;
+	if (ts.isPropertyAssignment(parent) && parent.initializer === reference) property = parent;
+	else if (ts.isShorthandPropertyAssignment(parent)) property = parent;
+	else return false;
+	for (;;) {
+		const key = propertyName(property.name);
+		const object = property.parent;
+		if (themeSection(object) !== void 0) return key !== void 0 && key !== "extend" && key !== "borderRadius";
+		const holder = object.parent;
+		if (!ts.isPropertyAssignment(holder) || holder.initializer !== object) return false;
+		property = holder;
+	}
+}
+/** `theme` or `extend` for a property of `theme: {…}` or of `theme.extend: {…}`; else undefined. */
+function themeSection(object) {
+	const holder = object.parent;
+	if (!ts.isObjectLiteralExpression(object) || !ts.isPropertyAssignment(holder)) return void 0;
+	const key = propertyName(holder.name);
+	if (key === "theme") return "theme";
+	return key === "extend" && themeSection(holder.parent) === "theme" ? "extend" : void 0;
+}
+/**
+* The names a module binds to what it imports or requires, by specifier: `acme` for
+* `import acme from "x"`, `import { acme } from "x"`, `const acme = require("x")` or
+* `const { default: acme } = require("x")`.
+*/
+function importBindings(source) {
+	const bindings = /* @__PURE__ */ new Map();
+	const bind = (name, specifier) => {
+		if (ts.isIdentifier(name)) {
+			bindings.set(name.text, specifier);
+			return;
+		}
+		for (const element of name.elements) if (!ts.isOmittedExpression(element)) bind(element.name, specifier);
+	};
+	for (const statement of source.statements) if (ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier)) {
+		const specifier = statement.moduleSpecifier.text;
+		const clause = statement.importClause;
+		if (clause?.name) bind(clause.name, specifier);
+		const named = clause?.namedBindings;
+		if (named && ts.isNamespaceImport(named)) bind(named.name, specifier);
+		else if (named) for (const element of named.elements) bind(element.name, specifier);
+	} else if (ts.isVariableStatement(statement)) for (const declaration of statement.declarationList.declarations) {
+		const specifier = declaration.initializer && moduleOf(declaration.initializer, bindings);
+		if (specifier !== void 0) bind(declaration.name, specifier);
+	}
+	return bindings;
+}
+/**
+* The module an expression takes its value from: `"x"` for `require("x")`, `import("x")`, a
+* name bound to either ({@link importBindings}), a call of any of these
+* (`createPreset({…})`, `require("x")()`) or a property of one (`require("x").default`).
+*/
+function moduleOf(node, bindings) {
+	let current = node;
+	for (;;) if (ts.isParenthesizedExpression(current) || ts.isAsExpression(current) || ts.isSatisfiesExpression(current) || ts.isNonNullExpression(current) || ts.isAwaitExpression(current) || ts.isPropertyAccessExpression(current)) current = current.expression;
+	else if (ts.isCallExpression(current)) {
+		const specifier = importedSpecifier(current);
+		if (specifier !== void 0) return specifier;
+		current = current.expression;
+	} else return ts.isIdentifier(current) ? bindings.get(current.text) : void 0;
 }
 /** The specifier of `require("x")`, `import x from "x"`, `export { default } from "x"` or `import("x")`. */
 function importedSpecifier(node) {
@@ -3297,7 +3729,11 @@ async function loadConfigWith(options, context = {}) {
 		const absolute = path.resolve(root, slashGlob(file));
 		if (!/[*?[\]{}()!]/.test(file) && !fs.existsSync(absolute)) throw new ConfigError(`Token file not found: ${absolute} (from ${explicitTokens?.from})`);
 	}
-	const libraries = detectLibraries(root, config.libraries);
+	const components = (options.components?.length ? options.components : configComponents !== void 0 ? configComponents.map(fromBase) : detection ? [...detection.withDefaults ? DEFAULT_COMPONENTS : [], ...detection.components] : DEFAULT_COMPONENTS).map(slashGlob);
+	const libraries = detectLibraries(root, config.libraries, {
+		importPath: config.importPath,
+		components
+	});
 	const tokenSources = options.tokens?.length ? options.tokens.map((p) => ({ path: p })) : configTokens !== void 0 ? configTokens.map((t) => typeof t === "string" ? { path: fromBase(t) } : {
 		...t,
 		path: fromBase(t.path)
@@ -3316,7 +3752,7 @@ async function loadConfigWith(options, context = {}) {
 	return {
 		root,
 		configFile,
-		components: (options.components?.length ? options.components : configComponents !== void 0 ? configComponents.map(fromBase) : detection ? [...detection.withDefaults ? DEFAULT_COMPONENTS : [], ...detection.components] : DEFAULT_COMPONENTS).map(slashGlob),
+		components,
 		exclude: declared && config.exclude ? [.../* @__PURE__ */ new Set([...DEFAULT_EXCLUDE, ...exclude])] : exclude,
 		...declared && config.exclude ? { designSystemExclude: exclude } : {},
 		tokens: tokenSources.map((t) => ({
@@ -4481,9 +4917,9 @@ function dedent(code) {
 const MAX_LISTED_INHERITED = 40;
 /**
 * Reads a published library's components from its type declarations with the TypeScript
-* checker: every value its entry exports under a capitalised name whose type takes props
-* (function and class components, `forwardRef` and MUI's `OverridableComponent`), with the
-* props of each call signature, their string-literal values (custom ones the app declares by
+* checker: every value its entry exports under a capitalised name whose type takes props and
+* renders (function and class components, `forwardRef` and MUI's `OverridableComponent`), with
+* the props of each call signature, their string-literal values (custom ones the app declares by
 * module augmentation included), JSDoc, the element it renders, and the module that
 * default-exports it. A signature generic over the element to render (MUI's `component`) marks
 * that prop as polymorphic instead of adding its props.
@@ -4505,16 +4941,27 @@ function extractLibrary(options) {
 		return empty(`${adapter.package}: ${dir} could not be read`);
 	}
 	const resolve = (specifier) => ts.resolveModuleName(specifier, path.join(root, "__onsystem__.tsx"), options.project.options, ts.sys).resolvedModule?.resolvedFileName;
-	const entry = resolve(adapter.package) ?? path.join(real, typesEntry(real));
-	if (!fs.existsSync(entry) || !/\.d\.[cm]?ts$/.test(entry)) return empty(`${adapter.package}: no type declarations at ${relativePath(root, entry)}`);
+	const main = resolve(adapter.package) ?? path.join(real, typesEntry(real));
+	const entries = isDeclarations(main) ? [{
+		specifier: adapter.package,
+		file: main
+	}] : subpathEntries(real, adapter.package, resolve);
+	if (!entries.length) return empty(`${adapter.package}: no type declarations at ${relativePath(root, main)}`);
 	const program = ts.createProgram({
-		rootNames: [entry, ...options.augmentations],
-		options: options.project.options
+		rootNames: [...entries.map((e) => e.file), ...options.augmentations],
+		options: options.project.options,
+		host: declarationsHost(options.project.options)
 	});
 	const checker = program.getTypeChecker();
-	const entryFile = program.getSourceFile(entry);
-	const moduleSymbol = entryFile ? checker.getSymbolAtLocation(entryFile) : void 0;
-	if (!moduleSymbol) return empty(`${adapter.package}: ${entry} has no exports`);
+	const modules = entries.flatMap((e) => {
+		const file = program.getSourceFile(e.file);
+		const symbol = file ? checker.getSymbolAtLocation(file) : void 0;
+		return symbol ? [{
+			...e,
+			symbol
+		}] : [];
+	});
+	if (!modules.length) return empty(`${adapter.package}: ${entries[0]?.file ?? main} has no exports`);
 	const shown = (file) => {
 		const absolute = path.resolve(file);
 		return relativePath(root, isInside(real, absolute) ? path.join(dir, path.relative(real, absolute)) : absolute);
@@ -4523,38 +4970,45 @@ function extractLibrary(options) {
 		checker,
 		adapter,
 		propSets: /* @__PURE__ */ new Map(),
-		scope: adapter.package.startsWith("@") ? `${adapter.package.split("/")[0] ?? ""}/` : adapter.package
+		scope: adapter.package.startsWith("@") ? `${adapter.package.split("/")[0] ?? ""}/` : adapter.package,
+		icons: /* @__PURE__ */ new Set()
 	};
 	const exportNames = /* @__PURE__ */ new Set();
 	const bySymbol = /* @__PURE__ */ new Map();
 	const components = [];
-	for (const exported of checker.getExportsOfModule(moduleSymbol)) {
-		const name = exported.getName();
-		const symbol = exported.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(exported) : exported;
-		if (!(symbol.flags & ts.SymbolFlags.Value)) continue;
-		exportNames.add(name);
-		if (!/^[A-Z]/.test(name)) continue;
-		const known = bySymbol.get(symbol);
-		if (known) {
-			known.aliases.push(name);
-			continue;
+	for (const module of modules) {
+		const subpath = module.specifier !== adapter.package;
+		for (const exported of checker.getExportsOfModule(module.symbol)) {
+			const symbol = exported.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(exported) : exported;
+			if (!(symbol.flags & ts.SymbolFlags.Value)) continue;
+			const declaration = symbol.valueDeclaration ?? symbol.declarations?.[0];
+			const isDefault = exported.getName() === "default";
+			const name = isDefault && subpath && declaration ? ts.getNameOfDeclaration(declaration)?.getText() ?? "default" : exported.getName();
+			if (isDefault && !/^[A-Z]/.test(name)) continue;
+			exportNames.add(name);
+			if (!/^[A-Z]/.test(name)) continue;
+			const known = bySymbol.get(symbol);
+			if (known) {
+				if (known.name !== name && !known.aliases.includes(name)) known.aliases.push(name);
+				continue;
+			}
+			if (!declaration) continue;
+			const component = buildComponent(context, name, symbol);
+			if (!component) continue;
+			const file = declaration.getSourceFile();
+			const line = file.getLineAndCharacterOfPosition(declaration.getStart(file)).line + 1;
+			component.source = {
+				file: shown(file.fileName),
+				line
+			};
+			if (subpath) component.importPath = module.specifier;
+			const defaultImport = isDefault ? module.specifier : defaultModule(program, checker, resolve, adapter.package, file, symbol);
+			if (defaultImport) component.defaultImport = defaultImport;
+			bySymbol.set(symbol, component);
+			components.push(component);
 		}
-		const declaration = symbol.valueDeclaration ?? symbol.declarations?.[0];
-		if (!declaration) continue;
-		const component = buildComponent(context, name, symbol);
-		if (!component) continue;
-		const file = declaration.getSourceFile();
-		const line = file.getLineAndCharacterOfPosition(declaration.getStart(file)).line + 1;
-		component.source = {
-			file: shown(file.fileName),
-			line
-		};
-		const defaultImport = defaultModule(program, checker, resolve, adapter.package, file, symbol);
-		if (defaultImport) component.defaultImport = defaultImport;
-		bySymbol.set(symbol, component);
-		components.push(component);
 	}
-	linkSlots(components);
+	linkSlots(components, context.icons);
 	return {
 		components,
 		propSets: Object.fromEntries(context.propSets),
@@ -4563,6 +5017,29 @@ function extractLibrary(options) {
 		dependencies: unique(projectFiles(program))
 	};
 }
+/**
+* A compiler host that resolves what the app's own resolution leaves unresolved in a package's
+* declarations by path, as Node.js's old resolution does. A bundler emits declarations that
+* import a dependency's file by its path (`class-variance-authority/dist/types`, for the
+* `ClassProp` behind every `cva()` variant), which that dependency's `exports` do not name: with
+* `"moduleResolution": "bundler"` the import is `any`, and a component's variants and props go
+* with it. The app's own files resolve as they do for tsc.
+*/
+function declarationsHost(options) {
+	const host = ts.createCompilerHost(options);
+	const cache = ts.createModuleResolutionCache(host.getCurrentDirectory(), (file) => host.getCanonicalFileName(file), options);
+	const byPath = {
+		...options,
+		moduleResolution: ts.ModuleResolutionKind.Node10
+	};
+	host.resolveModuleNameLiterals = (literals, containingFile, redirected, compilerOptions, file) => literals.map((literal) => {
+		const resolved = ts.resolveModuleName(literal.text, containingFile, compilerOptions, host, cache, redirected, ts.getModeForUsageLocation(file, literal, compilerOptions));
+		if (resolved.resolvedModule || !/[\\/]node_modules[\\/].*\.d\.[cm]?ts$/.test(containingFile)) return resolved;
+		const fallback = ts.resolveModuleName(literal.text, containingFile, byPath, host);
+		return fallback.resolvedModule && /\.d\.[cm]?ts$/.test(fallback.resolvedModule.resolvedFileName) ? fallback : resolved;
+	});
+	return host;
+}
 /** The declaration entry of an installed package: its `types`, else `index.d.ts`. */
 function typesEntry(dir) {
 	try {
@@ -4572,9 +5049,106 @@ function typesEntry(dir) {
 	} catch {}
 	return "index.d.ts";
 }
-/** Call and construct signatures that take props, across a union (`React.ComponentType`). */
-function propSignatures(type) {
-	return (type.isUnion() ? type.types : [type]).flatMap((member) => [...member.getCallSignatures(), ...member.getConstructSignatures()]).filter((signature) => signature.getParameters().length >= 1);
+/** A type declarations file on disk: `.d.ts`, `.d.mts` or `.d.cts`. */
+function isDeclarations(file) {
+	return /\.d\.[cm]?ts$/.test(file) && fs.existsSync(file);
+}
+/** Packages exporting more subpaths than this are read from the first ones, sorted. */
+const MAX_SUBPATHS = 500;
+/**
+* The declarations of each subpath a package without an entry of its own exports (`./button`,
+* `./card`, or the files a `./*` pattern maps), with the specifier apps import it by
+* (`@acme/ui/button`): as the app's own imports resolve it, else through the `types` condition
+* its `exports` give it. Subpaths that name no declarations (`./theme.css`) are left out.
+*/
+function subpathEntries(dir, name, resolve) {
+	let exports;
+	try {
+		exports = JSON.parse(fs.readFileSync(path.join(dir, "package.json"), "utf8")).exports;
+	} catch {
+		return [];
+	}
+	if (!exports || typeof exports !== "object" || Array.isArray(exports)) return [];
+	const found = /* @__PURE__ */ new Map();
+	const add = (subpath, target) => {
+		const specifier = `${name}/${subpath}`;
+		const file = resolve(specifier) ?? (target ? path.resolve(dir, target) : void 0);
+		if (file && isInside(dir, path.resolve(file)) && isDeclarations(file)) found.set(specifier, file);
+	};
+	for (const [key, value] of Object.entries(exports)) {
+		if (!key.startsWith("./") || key === "./package.json") continue;
+		const target = typesTarget(value);
+		const star = key.indexOf("*");
+		if (star === -1) {
+			add(key.slice(2), target);
+			continue;
+		}
+		const at = target?.indexOf("*") ?? -1;
+		if (!target || at === -1) continue;
+		const prefix = path.posix.normalize(target.slice(0, at)).replace(/^\.\//, "");
+		const suffix = target.slice(at + 1);
+		const folder = prefix.slice(0, prefix.lastIndexOf("/") + 1);
+		const files = globSync(`${escapePath(folder)}**/*${escapePath(suffix)}`, {
+			cwd: dir,
+			ignore: ["**/node_modules/**"],
+			expandDirectories: false
+		});
+		for (const file of files.sort()) {
+			if (!file.startsWith(prefix) || !file.endsWith(suffix)) continue;
+			const middle = file.slice(prefix.length, file.length - suffix.length);
+			add(`${key.slice(2, star)}${middle}${key.slice(star + 1)}`, path.join(dir, file));
+		}
+	}
+	return [...found].sort(([a], [b]) => a.localeCompare(b)).slice(0, MAX_SUBPATHS).map(([specifier, file]) => ({
+		specifier,
+		file
+	}));
+}
+/** The first `types` target an `exports` value gives, through nested conditions. */
+function typesTarget(value) {
+	if (Array.isArray(value)) {
+		for (const item of value) {
+			const found = typesTarget(item);
+			if (found) return found;
+		}
+		return;
+	}
+	if (!value || typeof value !== "object") return void 0;
+	for (const [condition, nested] of Object.entries(value)) {
+		if (condition === "types" && typeof nested === "string") return nested;
+		const found = typesTarget(nested);
+		if (found) return found;
+	}
+}
+/**
+* Call and construct signatures that take props and render, across a union
+* (`React.ComponentType`): a call that returns an element, and a class whose instances have
+* `render`. A capitalised function that returns anything else (`Format(value): string`) is no
+* component.
+*/
+function propSignatures(checker, type) {
+	return (type.isUnion() ? type.types : [type]).flatMap((member) => [...member.getCallSignatures().filter((s) => rendersElement(checker, checker.getReturnTypeOfSignature(s))), ...member.getConstructSignatures().filter((s) => checker.getPropertyOfType(checker.getReturnTypeOfSignature(s), "render") !== void 0)]).filter((signature) => signature.getParameters().length >= 1);
+}
+/**
+* Whether a call's return type is what a component returns: a React element (`JSX.Element`,
+* `ReactElement`), a `ReactNode` that can be one, a promise of one (a server component), or
+* nothing (`null`). `any`, where React's types do not resolve, counts.
+*/
+function rendersElement(checker, type) {
+	if (type.flags & (ts.TypeFlags.Any | ts.TypeFlags.Null)) return true;
+	const members = (type.isUnion() ? type.types : [type]).filter((member) => !(member.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined)));
+	if (!members.length) return true;
+	return members.some((member) => {
+		if (member.flags & ts.TypeFlags.Any) return true;
+		if (checker.getPropertyOfType(member, "props") !== void 0 && checker.getPropertyOfType(member, "type") !== void 0) return true;
+		const awaited = checker.getPropertyOfType(member, "then") ? checker.getAwaitedType(member) : void 0;
+		return awaited !== void 0 && awaited !== member && rendersElement(checker, awaited);
+	});
+}
+/** A conditional type the checker cannot resolve yet, or a union or intersection with one. */
+function hasConditional(type) {
+	if (type.flags & ts.TypeFlags.Conditional) return true;
+	return type.isUnionOrIntersection() && type.types.some((member) => hasConditional(member));
 }
 /** A React context (`ButtonGroupContext`): callable in React 19's types, but not a component to offer. */
 function isContext(checker, type) {
@@ -4603,7 +5177,7 @@ function buildComponent(context, name, symbol) {
 	const { checker, adapter } = context;
 	const type = checker.getTypeOfSymbol(symbol);
 	if (isContext(checker, type)) return void 0;
-	const signatures = propSignatures(type);
+	const signatures = propSignatures(checker, type);
 	if (!signatures.length) return void 0;
 	let polymorphic;
 	const plain = [];
@@ -4624,6 +5198,7 @@ function buildComponent(context, name, symbol) {
 			openProps = true;
 			continue;
 		}
+		if (signature.getTypeParameters()?.length && hasConditional(propsType)) openProps = true;
 		for (const part of propsType.isUnion() ? propsType.types : [propsType]) {
 			members++;
 			if (checker.getIndexInfosOfType(part).length) openProps = true;
@@ -4650,7 +5225,8 @@ function buildComponent(context, name, symbol) {
 	const byOrigin = /* @__PURE__ */ new Map();
 	for (const [propName, { origin }] of entries) byOrigin.set(origin, [...byOrigin.get(origin) ?? [], propName]);
 	const summarised = new Set([...byOrigin].filter(([origin, names]) => !own(origin) && (origin === "react" || names.length > MAX_LISTED_INHERITED)).map(([origin]) => origin));
-	const element = renderedElement(checker, used.at(-1));
+	const rendered = elementText(checker, used.at(-1));
+	const element = renderedElement(rendered);
 	const props = [];
 	const variants = [];
 	for (const [propName, entry] of entries) {
@@ -4704,6 +5280,7 @@ function buildComponent(context, name, symbol) {
 	};
 	if (polymorphic) info.polymorphic = polymorphic.name;
 	if (element) info.element = element;
+	if (rendered && /\bSVG\w*Element\b/.test(rendered)) context.icons.add(info);
 	const jsdoc = ts.displayPartsToString(symbol.getDocumentationComment(checker)).trim();
 	const description = jsdoc ? adapter.describe?.(jsdoc, name) ?? jsdoc : void 0;
 	if (description) info.description = description;
@@ -4805,15 +5382,23 @@ function literalValues$1(checker, type, depth = 0) {
 	}
 	return values.length ? unique(values) : void 0;
 }
-/** The native element behind a signature, from the type of the `ref` its props take. */
-function renderedElement(checker, signature) {
+/** The native element an {@link elementText} names: `button` for `Ref<HTMLButtonElement>`. */
+function renderedElement(text) {
+	const element = text ? /\bHTML(\w+?)Element\b/.exec(text)?.[1] : void 0;
+	return element ? ELEMENT_INTERFACES[element] : void 0;
+}
+/**
+* What names the native element behind a signature, as text: the type of the `ref` its props
+* take, or without one, of the DOM event handler they take (`HTMLAttributes<HTMLSpanElement>`
+* gives `onFocus: FocusEventHandler<HTMLSpanElement>`), as a function component's props declare
+* it. An icon's names an SVG element (`FocusEventHandler<SVGSVGElement>`).
+*/
+function elementText(checker, signature) {
 	const param = signature?.getParameters()[0];
 	if (!param) return void 0;
-	const ref = checker.getPropertyOfType(checker.getTypeOfSymbol(param), "ref");
-	if (!ref) return void 0;
-	const text = checker.typeToString(checker.getTypeOfSymbol(ref));
-	const element = /\bHTML(\w+?)Element\b/.exec(text)?.[1];
-	return element ? ELEMENT_INTERFACES[element] : void 0;
+	const props = checker.getTypeOfSymbol(param);
+	const typed = checker.getPropertyOfType(props, "ref") ?? checker.getPropertyOfType(props, "onFocus");
+	return typed ? checker.typeToString(checker.getTypeOfSymbol(typed)) : void 0;
 }
 /**
 * The folder module that default-exports a component (`@mui/material/Button` for
@@ -4831,16 +5416,36 @@ function defaultModule(program, checker, resolve, name, file, symbol) {
 }
 /**
 * Styled slots a library exports next to the component they belong to (`SliderThumb` in
-* `Slider.d.ts`) become its parts, so lists show the component and its parts under it.
-*/
-function linkSlots(components) {
+* `Slider.d.ts`, `CardHeader` and `CardContent` next to `Card` in a bundle's one `index.d.ts`)
+* become its parts, so lists show the component and its parts under it. A name that only goes
+* on in lower case (`Tabs` next to `Tab`) is another component, and so is a lone container
+* (`CheckboxGroup` next to `Checkbox`), as for source components. Icons are no parts and have
+* none (`UserCheck` next to `User`). In a file that declares several components of their own,
+* as a bundle does, a component with one such name next to it is no family
+* (`ButtonTooltip` next to `Button`): only two or more are its parts.
+*/
+function linkSlots(components, icons) {
 	const byFile = /* @__PURE__ */ new Map();
-	for (const component of components) byFile.set(component.source.file, [...byFile.get(component.source.file) ?? [], component]);
-	for (const group of byFile.values()) for (const component of group) {
-		const owner = group.filter((other) => other !== component && component.name.length > other.name.length && component.name.startsWith(other.name)).sort((a, b) => b.name.length - a.name.length)[0];
-		if (!owner) continue;
-		component.parent = owner.name;
-		owner.subcomponents.push(component.name);
+	for (const component of components) {
+		if (icons.has(component)) continue;
+		byFile.set(component.source.file, [...byFile.get(component.source.file) ?? [], component]);
+	}
+	for (const group of byFile.values()) {
+		const parts = /* @__PURE__ */ new Map();
+		for (const component of group) {
+			const owner = group.filter((other) => other !== component && component.name.length > other.name.length && component.name.startsWith(other.name) && /^[A-Z]/.test(component.name.charAt(other.name.length))).sort((a, b) => b.name.length - a.name.length)[0];
+			if (owner) parts.set(owner, [...parts.get(owner) ?? [], component]);
+		}
+		const owned = new Set([...parts.values()].flat());
+		const bundle = group.filter((component) => !owned.has(component)).length > 1;
+		for (const [owner, family] of parts) {
+			if (family.every((part) => /^(?:Group|List)$/.test(part.name.slice(owner.name.length)))) continue;
+			if (bundle && family.length < 2) continue;
+			for (const part of family) {
+				part.parent = owner.name;
+				owner.subcomponents.push(part.name);
+			}
+		}
 	}
 }
 //#endregion
@@ -4861,7 +5466,8 @@ const NOT_SOURCES = [
 /**
 * The components and tokens of the libraries `config` found (`config.libraries`): each one's
 * components from its type declarations, read together with the app's files that augment them,
-* and the tokens of the theme the app creates for it.
+* and the tokens of the theme the app creates for it. A design-system package installed without
+* its sources is read the same way, with no theme.
 */
 async function loadLibraries(config) {
 	const loaded = {
@@ -4873,7 +5479,7 @@ async function loadLibraries(config) {
 		dependencies: []
 	};
 	const libraries = (config.libraries ?? []).flatMap((source) => {
-		const adapter = libraryAdapter(source.package);
+		const adapter = libraryAdapter(source.package) ?? (source.designSystem ? packageAdapter(source.package) : void 0);
 		return adapter ? [{
 			source,
 			adapter
@@ -5892,7 +6498,7 @@ function cssSheetTokens(sheets) {
 		const category = isSpacingBase ? "spacing" : namespace?.[1] ?? "other";
 		const tailwindKey = isSpacingBase ? "" : variable.name.slice(namespace?.[0].length ?? 0);
 		const tailwindNamespace = isSpacingBase ? "--spacing" : namespace?.[0].slice(0, -1) ?? "";
-		const alias = /^var\(\s*(--[\w-]+)\s*\)$/.exec(variable.value)?.[1];
+		const alias = themeAlias(variable.value, base, lookup);
 		const target = alias ? base.get(alias) : void 0;
 		if (alias && target) {
 			consumed.add(alias);
@@ -5913,7 +6519,7 @@ function cssSheetTokens(sheets) {
 		add(finalize({
 			name: variable.name.slice(2),
 			category,
-			value: variable.value,
+			value: resolveValue(variable.value, lookup),
 			modes: modeValues(variable.name, modes, lookup),
 			cssVar: variable.inline ? void 0 : variable.name,
 			tailwind: tailwindKey,
@@ -6044,6 +6650,22 @@ function categorize$1(name, value) {
 function varAlias(value) {
 	return /^var\(\s*(--[\w-]+)\s*\)$/.exec(value.trim())?.[1];
 }
+/**
+* The base variable an `@theme` variable stands for: `--x` for `var(--x)`, and for
+* `hsl(var(--x))` or `rgb(var(--x))` when `--x` holds bare HSL or RGB channels, as
+* shadcn/ui's Tailwind v4 codemod leaves a v3 theme (`--color-primary: hsl(var(--primary))`).
+* The token is then `--x`, whose usage already wraps the channels (`hsl(var(--primary))`).
+*/
+function themeAlias(value, base, lookup) {
+	const plain = varAlias(value);
+	if (plain) return plain;
+	const match = /^(hsl|rgb)a?\(\s*var\(\s*(--[\w-]+)\s*\)\s*(?:\/\s*<alpha-value>\s*)?\)$/.exec(value.trim());
+	const name = match?.[2];
+	const target = name ? base.get(name) : void 0;
+	if (!match || !name || !target) return void 0;
+	const channels = resolveValue(target.value, lookup);
+	return (match[1] === "hsl" ? isBareHsl(channels) : isBareRgb(channels)) ? name : void 0;
+}
 /** Follows plain `var(--x)` aliases so the token shows its concrete value. */
 function resolveValue(value, lookup, depth = 0) {
 	const alias = /^var\(\s*(--[\w-]+)\s*\)$/.exec(value)?.[1];
@@ -6665,24 +7287,33 @@ const CORE_FAMILIES = /* @__PURE__ */ new Set([
 	"overlay",
 	"link"
 ]);
-/** Name segments of status colors: what happened, rather than how it looks. */
-const STATUS_WORDS = /* @__PURE__ */ new Set([
-	"destructive",
-	"danger",
-	"error",
-	"critical",
-	"negative",
-	"invalid",
-	"warning",
-	"warn",
-	"caution",
-	"success",
-	"positive",
-	"valid",
-	"info",
-	"information",
-	"notice"
-]);
+/** Name segments of status colors, by the status they show: what happened, rather than how it looks. */
+const STATUS_KINDS = {
+	destructive: [
+		"destructive",
+		"danger",
+		"error",
+		"critical",
+		"negative",
+		"invalid"
+	],
+	warning: [
+		"warning",
+		"warn",
+		"caution"
+	],
+	success: [
+		"success",
+		"positive",
+		"valid"
+	],
+	info: [
+		"info",
+		"information",
+		"notice"
+	]
+};
+const STATUS_WORDS = new Set(Object.values(STATUS_KINDS).flat());
 /** The family a color token belongs to: the first segment of its name (`sidebar`, `sh`, `rainbow`). */
 function tokenFamily(token) {
 	return tokenKey(token).split("-")[0] ?? "";
@@ -6725,6 +7356,19 @@ function scopesIn(families, ...texts) {
 function isStatusToken(token) {
 	return roleKey(token).split("-").some((segment) => STATUS_WORDS.has(segment));
 }
+/**
+* The statuses a theme has a color for: `success` for `--success`, Dub's `content-success` or a
+* DTCG `color.feedback.positive`, `destructive` for shadcn/ui's `--destructive` or `error`.
+*/
+function statusKinds(tokens) {
+	const kinds = /* @__PURE__ */ new Set();
+	for (const token of tokens) {
+		if (token.category !== "color") continue;
+		const segments = roleKey(token).split("-");
+		for (const [kind, words] of Object.entries(STATUS_KINDS)) if (segments.some((segment) => words.includes(segment))) kinds.add(kind);
+	}
+	return kinds;
+}
 /** `primary` for `--color-primary`, `text-muted` for the DTCG token `color.text.muted`. */
 function tokenKey(token) {
 	return (token.tailwind || token.name).toLowerCase().replace(/[.\s_]+/g, "-").replace(/^colou?rs?-/, "");
@@ -6887,7 +7531,7 @@ function toDtcg(tokens) {
 	const paths = assignPaths(tokens, warnings);
 	const lookup = varLookup(tokens);
 	const byName = new Map(tokens.map((t) => [t.name, t]));
-	const tree = {};
+	const tree = Object.create(null);
 	let count = 0;
 	for (const category of TOKEN_CATEGORIES) for (const token of tokens) {
 		const path = token.category === category ? paths.get(token) : void 0;
@@ -6969,7 +7613,7 @@ function insert(tree, path, node) {
 		const next = group[key];
 		if (isObject$1(next)) group = next;
 		else {
-			const created = {};
+			const created = Object.create(null);
 			group[key] = created;
 			group = created;
 		}
@@ -7201,7 +7845,7 @@ function colorObject(css) {
 	else if (spec.space === "srgb" && components.every((c) => typeof c === "number" && Math.abs(c * 255 - Math.round(c * 255)) < .001)) out.hex = formatHex(color);
 	return out;
 }
-const PLAIN_LENGTH = /^(-?(?:\d+\.?\d*|\.\d+))(px|rem)$/;
+const PLAIN_LENGTH = /^(-?(?:\d+(?:\.\d*)?|\.\d+))(px|rem)$/;
 /** `0.5rem` → `{ value: 0.5, unit: "rem" }`; a `calc()` of tokens → its px value. */
 function dimensionValue(value, lookup) {
 	const plain = plainDimension(value);
@@ -7231,8 +7875,8 @@ function plainDimension(value) {
 		unit: match[2] ?? "px"
 	} : void 0;
 }
-const COMPOSITE = /^[\w-]+\s*:\s*[^;]+(?:;\s*[\w-]+\s*:\s*[^;]+)*;?$/;
-const NUMBER = /^-?(?:\d+\.?\d*|\.\d+)$/;
+const COMPOSITE = /^[\w-]+\s*:[^;]+(?:;\s*[\w-]+\s*:[^;]+)*;?$/;
+const NUMBER = /^-?(?:\d+(?:\.\d*)?|\.\d+)$/;
 /** What a typography token sets, from its name and Tailwind class (`font-sans`, `text-sm`). */
 function typographyKind(token) {
 	const value = token.value.trim();
@@ -7492,7 +8136,7 @@ function frontMatterValue(token, key, lookup) {
 	}
 }
 /** A DESIGN.md dimension: px, em or rem. */
-const DESIGN_DIMENSION = /^-?(?:\d+\.?\d*|\.\d+)(?:px|rem|em)$/;
+const DESIGN_DIMENSION = /^-?(?:\d+(?:\.\d*)?|\.\d+)(?:px|rem|em)$/;
 /**
 * A typography token as a DESIGN.md typography level: `{ fontFamily: "Inter" }` for
 * `--font-sans`, every property of a composite. A `var()` is no font name (`next/font` sets
@@ -9557,6 +10201,35 @@ function labelledByParent(context, element) {
 	return !ts.isJsxElement(value) && !ts.isJsxSelfClosingElement(value) && !ts.isJsxFragment(value);
 }
 /**
+* What an `id` or `htmlFor` holds, to compare the two: a string as itself (`"dark-mode"`, `{"x"}`),
+* an expression as written (`{id}`, `` {`${id}-switch`} ``) together with the function it is in,
+* since two components in one file can each have their own `id`. Undefined when it holds nothing.
+*/
+function idValue(context, attribute) {
+	const init = attribute?.initializer;
+	if (!init) return void 0;
+	const value = ts.isJsxExpression(init) ? init.expression : init;
+	if (!value) return void 0;
+	if (ts.isStringLiteralLike(value)) return value.text.trim() ? `"${value.text}"` : void 0;
+	const scope = ts.findAncestor(value, ts.isFunctionLike);
+	return `${String(scope?.pos ?? -1)}:${value.getText(context.sourceFile)}`;
+}
+/**
+* Whether a label with content names the button through its `id`: `<label htmlFor={id}>Dark
+* mode</label>` next to `<button id={id} role="switch">`, or the design system's `<Label>`. A
+* button is a labelable element, so the label's text is its accessible name.
+*/
+function labelledByFor(context, element) {
+	const id = idValue(context, findAttribute(element, "id"));
+	if (id === void 0) return false;
+	return context.analysis.elements.some((label) => {
+		if (label === element) return false;
+		if (idValue(context, findAttribute(label, "htmlFor") ?? findAttribute(label, "for")) !== id) return false;
+		const content = classify(label.children, context, []);
+		return content === "text" || content === "unknown";
+	});
+}
+/**
 * The element whose `render` prop this one is, as in Base UI's
 * `<Dialog.Close render={<Button size="icon" />}><XIcon /></Dialog.Close>`:
 * the rendered button takes the host's children and attributes. Also through
@@ -9662,6 +10335,7 @@ const iconButtonAccessibleName = {
 			if (host && (isButton(context, host) || host.hasSpread)) continue;
 			if (hasLabel(element.attributes) || host && hasLabel(host.attributes)) continue;
 			if (labelledByParent(context, element)) continue;
+			if (labelledByFor(context, element) || host && labelledByFor(context, host)) continue;
 			const icons = [];
 			const children = host ? [...host.children, ...element.children] : element.children;
 			const content = host && !children.length ? "unknown" : classify(children, context, icons);
@@ -9946,8 +10620,63 @@ const noHardcodedColor = {
 				}
 			}
 		}
+		reportChartTokens(context, allow);
 	}
 };
+/** Packages that draw charts: Recharts, Chart.js, Nivo, visx, Victory, Tremor, MUI X Charts, D3. */
+const CHART_LIBRARY = /chart|^@nivo\/|^@visx\/|^victory|^@tremor\/|^d3(?:-|$)/i;
+/** Roles of an element that is a drawing: a chart drawn by hand is an image. */
+const DRAWING_ROLE = /^(?:img|figure|graphics-[a-z]+)$/;
+const CHART_TOKEN = "is a chart color, and this is not a chart: it changes with the chart palette, and it does not say what a status or brand color says. For a status color, add a token for it to the theme, such as `--success`; otherwise use the semantic token that fits.";
+/**
+* Warns on a chart token outside a chart: `text-chart-2` on a green "Active" label in a theme
+* with no success color. The class is a token, so the color rule would call it clean, but it
+* says nothing a status or brand color says, and it changes with the chart palette (a gray or a
+* blue in some shadcn/ui themes). A file that draws a chart is in scope throughout, legend dots
+* and all: one that imports a chart library, renders a tag such as `<ChartContainer>` or
+* `<BarChart>`, declares a name such as `chartData`, or is named for charts. So is an element
+* in a drawing (`<svg>`, `role="img"`), as a chart drawn by hand is. When the design system's
+* own components use chart tokens outside a chart, they are a palette it shares: nothing is
+* reported.
+*/
+function reportChartTokens(context, allow) {
+	const { tokens } = context.target;
+	if (!tokens.scopedFamilies.has("chart")) return;
+	const chart = /* @__PURE__ */ new Set(["chart"]);
+	if ([...tokens.familyFiles.get("chart") ?? []].some((file) => !scopesIn(chart, file).size)) return;
+	const { elements, imports, declared } = context.analysis;
+	if (scopesIn(chart, ...[
+		context.file,
+		...elements.map((e) => e.tag),
+		...declared
+	]).size) return;
+	if ([...imports.values()].some((binding) => CHART_LIBRARY.test(binding.source))) return;
+	for (const classString of context.analysis.classStrings) {
+		const { element } = classString;
+		if (element && inDrawing(element)) continue;
+		for (const cls of splitClasses(classString.text, classString.start)) {
+			const key = COLOR_UTILITY.exec(parseUtility(cls.value).base)?.[1];
+			if (!key?.startsWith("chart-") || !tokens.colorKeys.has(key)) continue;
+			if (allow.has(cls.value.toLowerCase())) continue;
+			context.report({
+				start: cls.start,
+				end: cls.end,
+				message: `\`${cls.value}\` ${CHART_TOKEN}`,
+				severity: "warning"
+			});
+		}
+	}
+}
+/** Whether the element is, or is in, a drawing: an `<svg>`, a `<figure>` or a `role="img"`. */
+function inDrawing(element) {
+	return ts.findAncestor(element.node, (node) => {
+		if (!ts.isJsxElement(node) && !ts.isJsxSelfClosingElement(node)) return false;
+		const opening = ts.isJsxElement(node) ? node.openingElement : node;
+		const tag = opening.tagName.getText(element.node.getSourceFile());
+		if (tag === "svg" || tag === "figure") return true;
+		return opening.attributes.properties.some((attribute) => ts.isJsxAttribute(attribute) && attributeName(attribute) === "role" && literalValues(attribute).some((value) => DRAWING_ROLE.test(value.text)));
+	}) !== void 0;
+}
 function reportLiteralColors(context, literal, element, options) {
 	const start = literal.getStart(context.sourceFile) + 1;
 	const text = context.text.slice(start, literal.end - 1);
@@ -10984,28 +11713,36 @@ function readBaseline(file) {
 		rules: parsed.rules ? new Set(parsed.rules) : void 0
 	};
 }
+/** Whether `diagnostic` is on one of the `lines`, such as those a pull request changed. */
+function onLines(lines, diagnostic) {
+	return lines?.some(([start, end]) => start <= diagnostic.endLine && end >= diagnostic.line) ?? false;
+}
 /**
 * Removes the findings the baseline accepts for `file`. Within a file and
 * rule, each entry accepts that many findings with the same source text, in
-* order; any beyond the count are new. Entries of `disabled` rules are not
-* counted as fixed: the rule is off, not satisfied.
+* order; any beyond the count are new. With `changed`, the lines a pull request
+* changed, findings on other lines are accepted first: a copy of a baselined
+* line inserted above it is the new one, not the line that was there. Entries
+* of `disabled` rules are not counted as fixed: the rule is off, not satisfied.
 */
-function applyBaseline(baseline, file, result, disabled = /* @__PURE__ */ new Set()) {
+function applyBaseline(baseline, file, result, disabled = /* @__PURE__ */ new Set(), changed) {
 	const remaining = /* @__PURE__ */ new Map();
 	for (const [rule, sources] of baseline.get(file) ?? []) {
 		if (disabled.has(rule)) continue;
 		for (const [source, count] of sources) remaining.set(`${rule}\0${source}`, count);
 	}
-	const diagnostics = [];
-	let baselined = 0;
-	for (const diagnostic of result.diagnostics) {
+	const accepted = /* @__PURE__ */ new Set();
+	for (const later of [false, true]) for (const diagnostic of result.diagnostics) {
+		if (onLines(changed, diagnostic) !== later) continue;
 		const id = `${diagnostic.ruleId}\0${findingKey(diagnostic)}`;
 		const left = remaining.get(id) ?? 0;
 		if (left > 0) {
 			remaining.set(id, left - 1);
-			baselined++;
-		} else diagnostics.push(diagnostic);
+			accepted.add(diagnostic);
+		}
 	}
+	const diagnostics = result.diagnostics.filter((d) => !accepted.has(d));
+	const baselined = accepted.size;
 	let fixed = 0;
 	for (const count of remaining.values()) fixed += count;
 	return {
@@ -11020,15 +11757,116 @@ function applyBaseline(baseline, file, result, disabled = /* @__PURE__ */ new Se
 	};
 }
 /**
+* Whether the key `file`, relative to the real `root`, still names a file by that spelling. On a
+* disk that ignores case (macOS, Windows), `Billing.tsx` still opens after a rename to
+* `billing.tsx`, but `check` keys the file by its new spelling, so the old key is gone, as on
+* Linux.
+*/
+function existsAs(root, file) {
+	try {
+		return relativePath(root, fs.realpathSync.native(path.resolve(root, file))).normalize("NFC") === file;
+	} catch {
+		return false;
+	}
+}
+/**
+* The files with baseline entries that no longer exist under `root`, deleted or renamed, among
+* those `include` takes. `checked` are files a run read, which exist.
+*/
+function goneFiles(entries, root, checked, include = () => true) {
+	return [...entries.keys()].filter((file) => !checked.has(file) && include(file) && !existsAs(root, file));
+}
+/**
+* Renamed and moved files (`git mv`, a folder reorganised): each file of `unrecorded` (file → its
+* findings), which has no entries of its own, paired with a file of `gone` whose entries match at
+* least half of its findings and half of those entries match its findings, as git counts a
+* rename from 50% similarity. Each file of `gone` pairs with one file at most, so a copy of a
+* file is new however many copies there are. Entries of rules `disabled` for the new file are
+* left out, as `applyBaseline` leaves them out. Returns new file → old file.
+*
+* Best match first: the file with most matching findings that are not `fresh`, then the one with
+* most matching findings, then the pair with fewest findings and entries the other does not
+* match. With `fresh`, the findings on the lines a pull request changed, a file the pull request
+* did not touch keeps the entries it took over in an earlier move, and a copy the pull request
+* adds is the new one, as `applyBaseline` spends entries on the other lines first.
+* Without it, as in a plain `check`, ties go to a file that kept the old one's name (a folder
+* moved), then to one in the old one's folder (a file renamed), then to path order.
+*/
+function findMoves(entries, unrecorded, gone, disabled = () => /* @__PURE__ */ new Set(), fresh = () => false) {
+	const recorded = /* @__PURE__ */ new Map();
+	for (const file of gone) for (const [rule, sources] of entries.get(file) ?? []) for (const [source, count] of sources) {
+		const id = `${rule}\0${source}`;
+		const list = recorded.get(id) ?? [];
+		list.push({
+			file,
+			count
+		});
+		recorded.set(id, list);
+	}
+	const pairs = [];
+	for (const [to, diagnostics] of unrecorded) {
+		if (entries.has(to) || !diagnostics.length) continue;
+		const found = /* @__PURE__ */ new Map();
+		for (const diagnostic of diagnostics) {
+			const id = `${diagnostic.ruleId}\0${findingKey(diagnostic)}`;
+			const n = found.get(id) ?? {
+				all: 0,
+				old: 0
+			};
+			n.all += 1;
+			if (!fresh(to, diagnostic)) n.old += 1;
+			found.set(id, n);
+		}
+		const matched = /* @__PURE__ */ new Map();
+		for (const [id, { all, old }] of found) for (const { file, count } of recorded.get(id) ?? []) {
+			const m = matched.get(file) ?? {
+				matched: 0,
+				kept: 0
+			};
+			m.matched += Math.min(all, count);
+			m.kept += Math.min(old, count);
+			matched.set(file, m);
+		}
+		const off = disabled(to);
+		for (const [from, { matched: n, kept }] of matched) {
+			let size = 0;
+			for (const [rule, sources] of entries.get(from) ?? []) {
+				if (off.has(rule)) continue;
+				for (const count of sources.values()) size += count;
+			}
+			const unmatched = diagnostics.length + size - 2 * n;
+			if (n * 2 >= diagnostics.length && n * 2 >= size) pairs.push({
+				to,
+				from,
+				matched: n,
+				kept,
+				unmatched
+			});
+		}
+	}
+	const sameName = (pair) => path.posix.basename(pair.to) === path.posix.basename(pair.from) ? 0 : 1;
+	const sameFolder = (pair) => path.posix.dirname(pair.to) === path.posix.dirname(pair.from) ? 0 : 1;
+	const order = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+	pairs.sort((a, b) => b.kept - a.kept || b.matched - a.matched || a.unmatched - b.unmatched || sameName(a) - sameName(b) || sameFolder(a) - sameFolder(b) || order(a.to, b.to) || order(a.from, b.from));
+	const moves = /* @__PURE__ */ new Map();
+	const taken = /* @__PURE__ */ new Set();
+	for (const { to, from } of pairs) {
+		if (moves.has(to) || taken.has(from)) continue;
+		moves.set(to, from);
+		taken.add(from);
+	}
+	return moves;
+}
+/**
 * The baseline after a run over `checked` (file → its findings): those files
 * get exactly their current findings, plus their previous entries for
 * `disabled` rules; other files keep their entries while they still exist
-* under `root`.
+* under `root` by the same spelling.
 */
 function updateBaseline(previous, checked, root, disabled = /* @__PURE__ */ new Set()) {
 	const disabledIn = typeof disabled === "function" ? disabled : () => disabled;
 	const next = /* @__PURE__ */ new Map();
-	for (const [file, rules] of previous ?? []) if (!checked.has(file) && fs.existsSync(path.resolve(root, file))) next.set(file, rules);
+	for (const [file, rules] of previous ?? []) if (!checked.has(file) && existsAs(root, file)) next.set(file, rules);
 	for (const [file, diagnostics] of checked) {
 		const rules = /* @__PURE__ */ new Map();
 		const off = disabledIn(file);
@@ -11063,14 +11901,21 @@ function rulesRun(previous, next, checked, ran, wholeRoot) {
 * The baseline without the entries a run over `checked` (file → its findings) shows no longer
 * occur: a checked file keeps at most as many of each finding as it still has, plus its entries
 * for `disabled` rules, and files the run did not check keep theirs while they still exist under
-* `root`. Nothing is added, so a new finding stays new, unlike with `updateBaseline`.
+* `root` by the same spelling. Nothing is added, so a new finding stays new, unlike with
+* `updateBaseline`. A file of `moves` (new file → old file, from `findMoves`) takes the old
+* file's entries as its own.
 */
-function pruneBaseline(previous, checked, root, disabled) {
+function pruneBaseline(previous, checked, root, disabled, moves = /* @__PURE__ */ new Map()) {
+	const files = new Map(previous);
+	for (const [to, from] of moves) {
+		const rules = previous.get(from);
+		if (rules && !previous.has(to)) files.set(to, rules);
+	}
 	const next = /* @__PURE__ */ new Map();
-	for (const [file, rules] of previous) {
+	for (const [file, rules] of files) {
 		const diagnostics = checked.get(file);
 		if (!diagnostics) {
-			if (fs.existsSync(path.resolve(root, file))) next.set(file, rules);
+			if (existsAs(root, file)) next.set(file, rules);
 			continue;
 		}
 		const found = /* @__PURE__ */ new Map();
@@ -11153,7 +11998,7 @@ function isObject(value) {
 var name = "onsystem";
 //#endregion
 //#region src/version.ts
-const VERSION = "0.8.0";
+const VERSION = "0.9.1";
 const NAME = name;
 //#endregion
 //#region src/lint/sarif.ts
@@ -11837,6 +12682,89 @@ const WEIGHTS = {
 	props: 1,
 	examples: .5
 };
+/**
+* What the components of shadcn/ui's registry are for, by the name its file exports them
+* under (`Badge` in `badge.tsx`). Its files have no JSDoc, so without these a stock shadcn/ui
+* app lists every component as undescribed and search finds them by name alone.
+*/
+const SHADCN_DESCRIPTIONS = {
+	Accordion: "Stacked sections whose headings expand and collapse their content.",
+	Alert: "A callout that draws attention to a message, with an optional title and icon.",
+	AlertDialog: "A modal dialog that asks the user to confirm an action, such as a deletion, before it happens.",
+	AspectRatio: "Keeps its content, such as an image or a video, at a fixed width-to-height ratio.",
+	Avatar: "A user's picture, with a fallback such as initials while it loads or when it is missing.",
+	Badge: "A small label for a status, a count or a category.",
+	Breadcrumb: "The path to the current page, as a trail of links.",
+	Button: "Triggers an action, such as submitting a form or opening a dialog.",
+	ButtonGroup: "Joins related buttons into one bar.",
+	Calendar: "A month grid to pick a date or a range of dates.",
+	Card: "A bordered surface that groups related content, with a header, content and footer.",
+	Carousel: "Shows a row of slides one at a time, with previous and next buttons.",
+	Checkbox: "A box the user ticks to turn an option on or off.",
+	Collapsible: "Shows and hides a panel of content from a trigger.",
+	Combobox: "A text input with a list of options that narrows as the user types.",
+	Command: "A searchable list of commands or options, as in a command palette.",
+	ContextMenu: "A menu of actions that opens on right-click.",
+	Dialog: "A modal window over the page, for a task or a message that needs the user first.",
+	Drawer: "A panel that slides in from an edge of the screen, often from the bottom on phones.",
+	DropdownMenu: "A menu of actions or options that opens from a button.",
+	Empty: "An empty state: what to show when there is nothing yet, with an action to start.",
+	Field: "A form field: its label, control, description and error message together.",
+	HoverCard: "A card of preview content that opens while the pointer rests on a link.",
+	Input: "A single-line text field.",
+	InputGroup: "An input with icons, text or buttons inside its border.",
+	InputOTP: "A row of one-character slots for a one-time code.",
+	Item: "A row of content for lists: media, a title, a description and actions.",
+	Kbd: "Shows a keyboard key or shortcut.",
+	Label: "The text label of a form control.",
+	Menubar: "A horizontal bar of menus, as in a desktop app.",
+	NativeSelect: "A styled native <select> element.",
+	NavigationMenu: "A site's main navigation links, with panels that open from them.",
+	Pagination: "Links to move between pages of results, with previous and next.",
+	Popover: "Rich content in a floating panel that opens from a button.",
+	Progress: "A bar that shows how far a task has got.",
+	RadioGroup: "A set of options of which the user picks exactly one.",
+	ScrollArea: "A scrollable region with styled scrollbars.",
+	Select: "Lets the user pick one value from a list that opens from a button.",
+	Separator: "A thin line between content, horizontal or vertical.",
+	Sheet: "A panel that slides in over the page from an edge of the screen, for secondary content.",
+	Sidebar: "The app's side navigation: a collapsible panel of grouped menu items.",
+	Skeleton: "A placeholder shape shown while content loads.",
+	Slider: "Picks a number, or a range, by dragging along a track.",
+	Spinner: "An animated indicator that something is loading.",
+	Switch: "A toggle that turns a setting on or off at once.",
+	Table: "Rows and columns of data.",
+	Tabs: "Switches between panels of content, one visible at a time.",
+	Textarea: "A multi-line text field.",
+	Toggle: "A button that stays pressed or not, such as Bold in a toolbar.",
+	ToggleGroup: "A set of toggle buttons, of which one or several can be on.",
+	Tooltip: "A short hint that appears while the pointer rests on, or focus is in, an element."
+};
+/**
+* What shadcn/ui's component of this name is for, when `component` is laid out as `npx shadcn
+* add` writes it: exported under the registry's name from the file named for it, in a `ui`
+* folder (`Badge` from `components/ui/badge.tsx`, components.json's default `ui` alias). A
+* component of the same name elsewhere (`Sheet` in a design system's `src/sheet.tsx`) is not
+* shadcn/ui's, and may be something else entirely.
+*/
+function shadcnPurpose(component) {
+	if (component.library || component.parent) return void 0;
+	if (!Object.hasOwn(SHADCN_DESCRIPTIONS, component.name)) return void 0;
+	const [folder, file = ""] = component.source.file.split(/[\\/]/).slice(-2);
+	if (folder !== "ui") return void 0;
+	const kebab = splitWords(component.name).join("-").toLowerCase();
+	return file.replace(/\.[jt]sx?$/, "") === kebab ? SHADCN_DESCRIPTIONS[component.name] : void 0;
+}
+/**
+* The component's own description or, for a shadcn/ui component without one (`Badge` in
+* `components/ui/badge.tsx`, no JSDoc), what shadcn/ui's component of that name is for, said
+* as shadcn/ui's: `shadcn/ui's Badge: A small label for a status, a count or a category.`
+*/
+function descriptionOf(component) {
+	if (component.description) return component.description;
+	const purpose = shadcnPurpose(component);
+	return purpose && `shadcn/ui's ${component.name}: ${purpose}`;
+}
 function buildSearchIndex(components) {
 	const index = new Bm25Index();
 	for (const component of components) index.add(component, [
@@ -11845,7 +12773,7 @@ function buildSearchIndex(components) {
 			...component.aliases,
 			component.parent ?? ""
 		].join(" ")), WEIGHTS.name],
-		[tokenize(component.description ?? ""), WEIGHTS.description],
+		[tokenize(component.description ?? shadcnPurpose(component) ?? ""), WEIGHTS.description],
 		[tokenize(component.variants.flatMap((v) => [v.name, ...v.values]).join(" ")), WEIGHTS.variants],
 		[tokenize((component.docs?.sections ?? []).map((s) => `${s.heading} ${s.body}`).join(" ")), WEIGHTS.docs],
 		[tokenize(component.props.map((p) => `${p.name} ${p.description ?? ""}`).join(" ")), WEIGHTS.props],
@@ -11853,61 +12781,49 @@ function buildSearchIndex(components) {
 	]);
 	return index;
 }
-function searchComponents(index, query, limit = 5) {
-	return index.search(expandQuery(query), limit).map((hit) => ({
-		component: hit.item,
-		score: Math.round(hit.score * 100) / 100,
-		matched: hit.terms
-	}));
-}
-//#endregion
-//#region src/tokens/imports.ts
-/** Enough stylesheets for a theme split over files, without reading a whole design system. */
-const MAX_IMPORTED = 50;
-/**
-* The specifiers a stylesheet `@import`s: `@import "./theme.css" layer(base)`,
-* `@import url(theme.css)`, `@import "@acme/theme"`. Empty for CSS that does not parse.
-*/
-function cssImports(css) {
-	let root;
-	try {
-		root = postcss.parse(css);
-	} catch {
-		return [];
-	}
-	const out = [];
-	for (const node of root.nodes) {
-		if (node.type !== "atrule" || node.name !== "import") continue;
-		const match = /^\s*(?:url\(\s*)?(?:"([^"]+)"|'([^']+)'|([^\s"')]+)\s*\))/.exec(node.params);
-		const specifier = match?.[1] ?? match?.[2] ?? match?.[3];
-		if (specifier) out.push(specifier);
+/** The query's words, each with the terms that find it: `modal` is found by modal and dialog. */
+function queryWords(query) {
+	const words = /* @__PURE__ */ new Map();
+	for (const word of splitWords(query)) {
+		const stems = tokenize(word);
+		const key = stems.join(" ");
+		if (stems.length && !words.has(key)) words.set(key, {
+			stems,
+			terms: [...expandQuery(word).keys()]
+		});
 	}
-	return out;
+	return [...words.values()];
 }
 /**
-* The stylesheets `files` import, and the ones those import in turn, each once and in the
-* order they are imported. The files themselves are not repeated.
+* Components for `query`, best first. A hit matches clearly when a word of the query is in
+* its name (`button` for Button) or when it has more than half of the query's words, each
+* itself or through a synonym (`modal` through `dialog`). The hits that do not are left out
+* when any does, and otherwise come back marked `weak`: "a dropdown menu to pick a country",
+* in a design system with no select, finds only a card's action slot that mentions a menu,
+* which is not an answer to give as the best match.
 */
-function importedStylesheets(files, resolve) {
-	const seen = new Set(files);
-	const out = [];
-	const visit = (file) => {
-		let text;
-		try {
-			text = fs.readFileSync(file, "utf8");
-		} catch {
-			return;
-		}
-		for (const specifier of cssImports(text)) {
-			const target = resolve(specifier, file);
-			if (!target || seen.has(target) || out.length >= MAX_IMPORTED) continue;
-			seen.add(target);
-			out.push(target);
-			visit(target);
-		}
-	};
-	for (const file of files) visit(file);
-	return out;
+function searchComponents(index, query, limit = 5) {
+	const words = queryWords(query);
+	const hits = index.search(expandQuery(query), index.size).map((hit) => {
+		const matched = new Set(hit.terms);
+		const covered = words.filter((word) => word.terms.some((term) => matched.has(term))).length;
+		const names = new Set(tokenize([hit.item.name, ...hit.item.aliases].join(" ")));
+		const clear = covered * 2 > words.length || words.some((word) => word.stems.some((s) => names.has(s)));
+		return {
+			found: {
+				component: hit.item,
+				score: Math.round(hit.score * 100) / 100,
+				matched: hit.terms
+			},
+			clear
+		};
+	});
+	const clear = hits.filter((hit) => hit.clear);
+	if (clear.length) return clear.slice(0, limit).map((hit) => hit.found);
+	return hits.slice(0, limit).map((hit) => ({
+		...hit.found,
+		weak: true
+	}));
 }
 //#endregion
 //#region src/util/log.ts
@@ -12255,7 +13171,7 @@ async function resolveFiles(config) {
 * `@dub/tailwind-config` and its `themes.css`), with what they import. May repeat a file.
 */
 function linkedStylesheets(config, found) {
-	const resolve = stylesheetResolver(config.root);
+	const resolve = stylesheetResolver(config.root, { importPath: config.importPath });
 	const preset = config.tailwindConfig ? presetStylesheets(readTailwindColors(config.tailwindConfig, presetResolver(config.root)), config.root) : [];
 	return [
 		...importedStylesheets(found.filter((f) => f.endsWith(".css")), resolve),
@@ -12595,4 +13511,4 @@ var DesignSystemHost = class {
 	}
 };
 //#endregion
-export { hasOwnConfig as $, TokenIndex as A, parseDoc as B, pruneBaseline as C, isInside as Ct, updateBaseline as D, defaultProjectConfig as Dt, unrecordedRules as E, toPosix as Et, TOKEN_CATEGORIES as F, DEFAULT_SEVERITY as G, CONFIG_FILES as H, parseDtcgTokens as I, LEGACY_CONFIG_FILES as J, DEFAULT_TEST_EXCLUDE as K, parseDesignMd as L, mergeTokens as M, toDesignMd as N, writeBaseline as O, readProjectConfig as Ot, toDtcg as P, excludedBy as Q, parseCssTokens as R, countBaseline as S, SCRIPT_FILE$1 as St, rulesRun as T, relativePath as Tt, ConfigError as U, extractComponents as V, DEFAULT_DOCS as W, configJsonSchema as X, RULE_IDS as Y, defineConfig as Z, NAME as _, workspacePatterns as _t, fingerprint as a, LIBRARIES as at, LEGACY_BASELINE_FILE as b, truncate as bt, silentLogger as c, notReadYet as ct, searchComponents as d, declaredConfig as dt, loadConfig as et, applyFixes as f, detectProject as ft, formatDiagnostics as g, workspacePackageDirs as gt, escapeData as h, isWorkspaceRoot as ht, componentFiles as i, findVariantDefinitions as it, loadTokens as j, RULES as k, stderrLogger as l, PACKAGE_FIELD as lt, uncheckedNotice as m, isDesignSystemName as mt, DesignSystemHost as n, rulesFor as nt, loadDesignSystem as o, LIBRARY_IDS as ot, checkSource as p, findDesignSystemPackage as pt, DEFAULT_TEST_FOLDERS as q, buildModel as r, formatPx as rt, tokenFiles as s, libraryTitle as st, DesignSystem as t, loadConfigWith as tt, buildSearchIndex as u, PackageFinder as ut, VERSION as v, closest as vt, readBaseline as w, matchesGlob as wt, applyBaseline as x, unique as xt, BASELINE_FILE as y, plural$1 as yt, attachDocs as z };
+export { LEGACY_CONFIG_FILES as $, unrecordedRules as A, relativePath as At, statusKinds as B, countBaseline as C, closest as Ct, pruneBaseline as D, SCRIPT_FILE$2 as Dt, onLines as E, unique as Et, loadTokens as F, parseDoc as G, parseDesignMd as H, mergeTokens as I, ConfigError as J, extractComponents as K, toDesignMd as L, writeBaseline as M, defaultProjectConfig as Mt, RULES as N, readProjectConfig as Nt, readBaseline as O, isInside as Ot, TokenIndex as P, DEFAULT_TEST_FOLDERS as Q, toDtcg as R, applyBaseline as S, workspacePatterns as St, goneFiles as T, truncate as Tt, parseCssTokens as U, parseDtcgTokens as V, attachDocs as W, DEFAULT_SEVERITY as X, DEFAULT_DOCS as Y, DEFAULT_TEST_EXCLUDE as Z, formatDiagnostics as _, detectProject as _t, fingerprint as a, loadConfig as at, BASELINE_FILE as b, isWorkspaceRoot as bt, silentLogger as c, formatPx as ct, descriptionOf as d, LIBRARY_IDS as dt, RULE_IDS as et, searchComponents as f, libraryTitle as ft, escapeData as g, declaredConfig as gt, uncheckedNotice as h, PackageFinder as ht, componentFiles as i, hasOwnConfig as it, updateBaseline as j, toPosix as jt, rulesRun as k, matchesGlob as kt, stderrLogger as l, findVariantDefinitions as lt, checkSource as m, PACKAGE_FIELD as mt, DesignSystemHost as n, defineConfig as nt, loadDesignSystem as o, loadConfigWith as ot, applyFixes as p, notReadYet as pt, CONFIG_FILES as q, buildModel as r, excludedBy as rt, tokenFiles as s, rulesFor as st, DesignSystem as t, configJsonSchema as tt, buildSearchIndex as u, LIBRARIES as ut, NAME as v, findDesignSystemPackage as vt, findMoves as w, plural$1 as wt, LEGACY_BASELINE_FILE as x, workspacePackageDirs as xt, VERSION as y, isDesignSystemName as yt, TOKEN_CATEGORIES as z };