onsystem 0.9.0 → 0.10.0

package/dist/{design-system-Bykei5W0.js → design-system-D53Jxybo.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
@@ -892,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;
 /**
@@ -1056,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;
 		}
@@ -1346,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;
 	};
 }
 /**
@@ -2009,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());
 }
@@ -2019,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);
@@ -2757,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;
@@ -2785,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);
 }
@@ -2917,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
@@ -2946,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);
@@ -2978,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() ?? "";
@@ -2997,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
@@ -3028,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
@@ -3036,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) {
@@ -3076,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) {
@@ -3263,12 +3568,13 @@ const librariesSchema = z.union([z.literal(false), z.array(z.enum(LIBRARY_IDS))]
 } });
 const configShape = {
 	$schema: z.string().optional(),
+	extends: z.boolean({ error: (issue) => `"extends" is true or false, not ${JSON.stringify(issue.input)}: the design-system package is found from the dependencies, the one whose package.json declares its config ("onsystem"). Leave "extends" out to build on it, or set it to false to read this config alone.` }).optional().describe("Whether this config builds on the one a design-system package declares (\"onsystem\" in the package.json of a dependency, found from the dependencies): its rules apply over the package's, and, unless it sets components of its own, what it leaves out comes from the package's (components with their importPath, docs, elements, tokens and libraries). Default: true. false reads this config alone."),
 	components: globsSchema.optional().describe("Globs for component source files, relative to the root."),
 	exclude: z.array(z.string()).optional().describe("Globs for files to leave out, relative to the root: `check` in folders and globs, the ESLint plugin, the Claude Code hook and check_ui leave them out, and finding components skips them. A folder (`app/legacy`) covers everything in it. Adds to the defaults (node_modules, .d.ts files, tests and stories); a pattern that starts with `!` takes out the default it names, such as `!**/*.d.ts`."),
 	tokens: z.union([tokenSourceSchema, z.array(tokenSourceSchema)]).optional().describe("Token files: W3C DTCG JSON (*.json), CSS custom properties (*.css) or a DESIGN.md's front matter (*.md)."),
 	docs: globsSchema.optional().describe("Globs for per-component Markdown/MDX docs."),
 	tsconfig: z.string().optional().describe("tsconfig used to resolve types and path aliases."),
-	importPath: z.string().optional().describe("Package name components are imported from, e.g. \"@acme/ui\", or a pattern for packages imported by path: \"@acme/ui/{path}\" is @acme/ui/primitives/button for primitives/button.tsx in the package. Default: inferred from package exports and tsconfig paths."),
+	importPath: z.string().optional().describe("Package name components are imported from, e.g. \"@acme/ui\", or a pattern for packages imported by path: \"@acme/ui/{path}\" is @acme/ui/primitives/button for primitives/button.tsx in the package. An installed dependency it names exactly, whose component sources the project does not read, is read from its type declarations (.d.ts). Default: inferred from package exports and tsconfig paths."),
 	elements: z.record(z.string(), z.string()).optional().describe("Extra native element → component mappings, e.g. { \"a\": \"Link\" }."),
 	libraries: librariesSchema.optional().describe(`Published component libraries to read from their type declarations when the project depends on them. Omitted: every one onsystem reads (${LIBRARY_IDS.join(", ")}). false: none. A list: only those, e.g. ["mui"].`),
 	includeDesignSystem: z.boolean().optional().describe("check: lint the design system's own component files too. Off by default: they implement the scale and primitives the rules enforce."),
@@ -3348,9 +3654,11 @@ async function loadConfigWith(options, context = {}) {
 	let packages = context.packages?.root === searchDir ? context.packages : void 0;
 	const finder = (dir) => packages?.root === dir ? packages : packages = new PackageFinder(dir);
 	let lookup = context.lookup;
+	/**
+	* The project's own config: a config file in the folder searched, `--config`, or a workspace
+	* root's that a project in it takes on.
+	*/
 	let configFile;
-	/** The design-system package whose config this project takes on, having none of its own. */
-	let declared;
 	if (options.config) configFile = path.resolve(cwd, options.config);
 	else {
 		const find = (names) => names.map((name) => path.join(searchDir, name)).find((file) => fs.existsSync(file));
@@ -3358,120 +3666,131 @@ async function loadConfigWith(options, context = {}) {
 		const legacy = find(LEGACY_CONFIG_FILES);
 		if (legacy) deprecations.push(legacyConfigNotice(legacy, configFile));
 		configFile ??= legacy ?? ownDeclaredConfig(searchDir);
-		if (!configFile) {
-			lookup ??= findDesignSystemPackage(searchDir, finder(searchDir));
-			if (lookup?.problems.length) throw declarationError(lookup, searchDir);
-			declared = lookup?.found;
-			configFile = declared?.config;
-		}
 	}
-	for (const { name, problem } of lookup?.skipped ?? []) warnings.push(`${name}'s onsystem config was skipped: ${problem} ${name} is installed in node_modules, so this project is read as if it declared none.`);
-	let raw = {};
-	if (configFile) {
-		if (!fs.existsSync(configFile)) throw new ConfigError(`Config file not found: ${configFile}`);
-		if (options.jsonConfigOnly && !configFile.endsWith(".json")) throw new ConfigError(`${configFile} was not run: the server runs a JavaScript or TypeScript config only in a project it was started in (its working directory, --root or the client's roots), not in one found from the path a tool call names. Start the server in the project, or use onsystem.config.json.`);
-		raw = await readConfigFile(configFile);
-	}
-	const parsed = configSchema.safeParse(raw);
-	if (!parsed.success) throw new ConfigError(`Invalid config in ${configFile ?? "(defaults)"}:\n${z.prettifyError(parsed.error)}`);
-	const config = parsed.data;
+	const config = configFile ? await readConfig(configFile, options) : {};
 	const root = options.root ? path.resolve(cwd, options.root) : options.config && configFile ? path.dirname(configFile) : searchDir;
 	if (!isDirectory(root)) throw new ConfigError(`Project root not found: ${root}`);
-	const base = declared ? declared.dir : options.base ? path.resolve(cwd, options.base) : root;
-	const inherited = base !== root;
-	const fromBase = (p) => inherited ? toPosix(path.relative(root, path.resolve(base, slashGlob(p)))) || "." : p;
+	let declared;
+	if (config.extends !== false) {
+		lookup ??= findDesignSystemPackage(root, finder(root));
+		if (!lookup?.problems.length) declared = lookup?.found;
+		else if (!configFile) throw declarationError(lookup, root);
+		else warnings.push(`${lookup.problems.map((p) => `${p.name}: ${p.problem}`).join("\n")}\nSo ${configFile} is read alone, without the config a design-system package declares. Fix the "${PACKAGE_FIELD}" field in that package, or set "extends": false in ${path.basename(configFile)}.`);
+	}
+	for (const { name, problem } of lookup?.skipped ?? []) warnings.push(`${name}'s onsystem config was skipped: ${problem} ${name} is installed in node_modules, so this project is read as if it declared none.`);
+	const pkg = declared ? await readConfig(declared.config, options) : void 0;
+	const base = options.base ? path.resolve(cwd, options.base) : root;
+	const rebase = (from) => (p) => from === root ? p : toPosix(path.relative(root, path.resolve(from, slashGlob(p)))) || ".";
+	const fromBase = rebase(base);
+	const fromPackage = rebase(declared?.dir ?? root);
 	const toProject = toPosix(path.relative(base, root));
 	const excludeFromBase = (e) => {
-		if (!inherited || e.startsWith("**/")) return e;
-		if (declared) return fromBase(e);
+		if (base === root || e.startsWith("**/")) return e;
 		if (e === toProject) return "**";
 		return e.startsWith(`${toProject}/`) ? e.slice(toProject.length + 1) : void 0;
 	};
+	const excludeFromPackage = (e) => e.startsWith("**/") ? e : fromPackage(e);
 	const outside = [];
 	const within = (field) => (p) => {
 		if (!declared || staysIn(declared.dir, declared.boundary, slashGlob(p))) return true;
 		outside.push(`${field} ${p}`);
 		return false;
 	};
-	const configComponents = config.components === void 0 ? void 0 : toArray(config.components).filter(within("components"));
-	const configTokens = config.tokens === void 0 ? void 0 : toArray(config.tokens).filter((t) => within("tokens")(typeof t === "string" ? t : t.path));
-	const configDocs = config.docs === void 0 ? void 0 : toArray(config.docs).filter(within("docs"));
+	const pathOf = (t) => typeof t === "string" ? t : t.path;
+	const tokensFrom = (move) => (t) => typeof t === "string" ? { path: move(t) } : {
+		...t,
+		path: move(t.path)
+	};
+	const packageComponents = pkg?.components === void 0 ? void 0 : toArray(pkg.components).filter(within("components")).map(fromPackage);
+	const packageTokens = pkg?.tokens === void 0 ? void 0 : toArray(pkg.tokens).filter((t) => within("tokens")(pathOf(t))).map(tokensFrom(fromPackage));
+	const packageDocs = pkg?.docs === void 0 ? void 0 : toArray(pkg.docs).filter(within("docs")).map(fromPackage);
 	if (declared && outside.length) warnings.push(`${declared.name}'s onsystem config names paths outside ${declared.installed ? "the package" : "the workspace"}, which were ignored: ${outside.join(", ")}.`);
+	const inherits = pkg !== void 0 && config.components === void 0;
+	const configComponents = config.components === void 0 ? packageComponents : toArray(config.components).map(fromBase);
+	const configTokens = config.tokens === void 0 ? inherits ? packageTokens : void 0 : toArray(config.tokens).map(tokensFrom(fromBase));
+	const configDocs = config.docs === void 0 ? inherits ? packageDocs : void 0 : toArray(config.docs).map(fromBase);
+	const importPath = config.importPath ?? (inherits ? pkg.importPath : void 0);
+	const librariesSetting = config.libraries ?? (inherits ? pkg.libraries : void 0);
 	const rules = {};
 	for (const id of RULE_IDS) {
-		const setting = config.rules?.[id];
+		const setting = config.rules?.[id] ?? pkg?.rules?.[id];
 		rules[id] = setting === void 0 ? {
 			severity: DEFAULT_SEVERITY[id],
 			options: {}
 		} : resolveRule(setting);
 	}
-	const overrides = (declared ? [] : config.overrides ?? []).map((override) => ({
+	const overrides = (config.overrides ?? []).map((override) => ({
 		files: toArray(override.files).map(slashGlob),
 		rules: Object.fromEntries(Object.entries(override.rules).map(([id, setting]) => [id, resolveRule(setting)]))
 	}));
-	const tsconfig = config.tsconfig === void 0 || declared ? void 0 : fromBase(config.tsconfig.replaceAll("\\", "/"));
+	const tsconfig = config.tsconfig === void 0 ? void 0 : fromBase(config.tsconfig.replaceAll("\\", "/"));
 	if (tsconfig !== void 0 && !fs.existsSync(path.resolve(root, tsconfig))) throw new ConfigError(`tsconfig not found: ${path.resolve(root, tsconfig)} (from "tsconfig" in ${configFile ?? "the config"})`);
-	const componentsSet = Boolean(options.components?.length) || config.components !== void 0;
+	const componentsSet = Boolean(options.components?.length) || configComponents !== void 0;
 	const detection = componentsSet ? void 0 : detectProject(root, tsconfig, void 0, declared, finder(root));
 	const explicitTokens = options.tokens?.length ? {
 		paths: options.tokens,
 		from: "--tokens"
-	} : config.tokens !== void 0 && !declared ? {
-		paths: toArray(config.tokens).map((t) => fromBase(typeof t === "string" ? t : t.path)),
+	} : config.tokens !== void 0 ? {
+		paths: toArray(config.tokens).map((t) => fromBase(pathOf(t))),
 		from: `"tokens" in ${configFile ?? "the config"}`
 	} : void 0;
 	for (const file of explicitTokens?.paths ?? []) {
 		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 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,
+	const components = (options.components?.length ? options.components : configComponents ?? (detection ? [...detection.withDefaults ? DEFAULT_COMPONENTS : [], ...detection.components] : DEFAULT_COMPONENTS)).map(slashGlob);
+	const libraries = detectLibraries(root, librariesSetting, {
+		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)
-	}) : [...(detection?.tokens.length ? [...detection.tokens, ...DEFAULT_TOKENS.filter((t) => t.endsWith(".json"))] : DEFAULT_TOKENS).map((p) => ({ path: p })), ...FALLBACK_TOKENS.map((p) => ({
+	const tokenSources = options.tokens?.length ? options.tokens.map((p) => ({ path: p })) : configTokens ?? [...(detection?.tokens.length ? [...detection.tokens, ...DEFAULT_TOKENS.filter((t) => t.endsWith(".json"))] : DEFAULT_TOKENS).map((p) => ({ path: p })), ...FALLBACK_TOKENS.map((p) => ({
 		path: p,
 		fallback: true
 	}))];
 	const tidy = (e) => slashGlob(e).replace(/^(?:\.\/)+/, "").replace(/(.)\/+$/, "$1");
-	const listed = config.exclude ?? [];
-	const dropped = new Set(listed.filter((e) => e.startsWith("!")).map((e) => tidy(e.slice(1))));
-	for (const pattern of dropped) {
-		if (DEFAULT_EXCLUDE.includes(pattern)) continue;
-		warnings.push(`"!${pattern}" in "exclude" takes out none of the defaults, which are ${DEFAULT_EXCLUDE.map((d) => `"${d}"`).join(", ")}: a pattern that starts with "!" names one of them.`);
-	}
-	const exclude = [.../* @__PURE__ */ new Set([...DEFAULT_EXCLUDE.filter((d) => !dropped.has(d)), ...listed.filter((e) => !e.startsWith("!")).map(tidy)])].map(excludeFromBase).filter((e) => e !== void 0);
+	const excludeOf = (listed, move) => {
+		const dropped = new Set(listed.filter((e) => e.startsWith("!")).map((e) => tidy(e.slice(1))));
+		for (const pattern of dropped) {
+			if (DEFAULT_EXCLUDE.includes(pattern)) continue;
+			warnings.push(`"!${pattern}" in "exclude" takes out none of the defaults, which are ${DEFAULT_EXCLUDE.map((d) => `"${d}"`).join(", ")}: a pattern that starts with "!" names one of them.`);
+		}
+		return [.../* @__PURE__ */ new Set([...DEFAULT_EXCLUDE.filter((d) => !dropped.has(d)), ...listed.filter((e) => !e.startsWith("!")).map(tidy)])].map(move).filter((e) => e !== void 0);
+	};
+	const exclude = excludeOf(config.exclude ?? [], excludeFromBase);
+	const packageExclude = pkg?.exclude ? excludeOf(pkg.exclude, excludeFromPackage) : void 0;
 	return {
 		root,
-		configFile,
+		configFile: configFile ?? declared?.config,
 		components,
-		exclude: declared && config.exclude ? [.../* @__PURE__ */ new Set([...DEFAULT_EXCLUDE, ...exclude])] : exclude,
-		...declared && config.exclude ? { designSystemExclude: exclude } : {},
+		exclude: packageExclude ? [.../* @__PURE__ */ new Set([...exclude, ...packageExclude.filter((e) => !DEFAULT_EXCLUDE.includes(e))])] : exclude,
+		...packageExclude && inherits ? { designSystemExclude: packageExclude } : {},
 		tokens: tokenSources.map((t) => ({
 			...t,
 			path: slashGlob(t.path)
 		})),
 		...!options.tokens?.length && configTokens === void 0 ? { tokensDetected: true } : {},
-		docs: (options.docs?.length ? options.docs : configDocs === void 0 ? [.../* @__PURE__ */ new Set([...DEFAULT_DOCS, ...detection?.docs ?? []])] : configDocs.map(fromBase)).map(slashGlob),
+		docs: (options.docs?.length ? options.docs : configDocs ?? [.../* @__PURE__ */ new Set([...DEFAULT_DOCS, ...detection?.docs ?? []])]).map(slashGlob),
 		tsconfig,
-		importPath: config.importPath,
-		imports: detection?.imports ?? (declared && componentsSet ? packageImports(root, declared.dir) : []),
+		importPath,
+		imports: detection?.imports ?? (declared && inherits && componentsSet ? packageImports(root, declared.dir) : []),
 		detected: detection?.source,
 		...detection?.designSystems ? { designSystems: detection.designSystems } : {},
 		tailwindConfig: findTailwindConfig(root),
 		libraries: libraries.read,
-		libraryIds: config.libraries,
+		libraryIds: librariesSetting,
 		librariesOff: libraries.off,
 		librariesUnread: libraries.unread,
-		elements: config.elements ?? {},
-		includeDesignSystem: options.includeDesignSystem ?? (declared ? void 0 : config.includeDesignSystem) ?? false,
+		elements: {
+			...inherits ? pkg.elements : {},
+			...config.elements
+		},
+		includeDesignSystem: options.includeDesignSystem ?? config.includeDesignSystem ?? false,
 		rules,
 		overrides,
-		...inherited && !declared ? { base } : {},
+		...base !== root ? { base } : {},
 		...declared ? { designSystemPackage: declared } : {},
+		...inherits ? { inherits: true } : {},
+		...config.extends === false ? { extendsOff: true } : {},
 		configured: componentsSet,
 		...deprecations.length ? { deprecations } : {},
 		...warnings.length ? { warnings } : {}
@@ -3480,7 +3799,7 @@ async function loadConfigWith(options, context = {}) {
 /**
 * Whether `dir` has a config of its own: a config file under its current or old name, or one its
 * package.json names in its `onsystem` field. Without one, a project takes on its design-system
-* package's config, else the workspace root's.
+* package's config, and, from a workspace root, the root's over it.
 */
 function hasOwnConfig(dir) {
 	if ([...CONFIG_FILES, ...LEGACY_CONFIG_FILES].some((name) => fs.existsSync(path.join(dir, name)))) return true;
@@ -3558,6 +3877,14 @@ function nodeRunsTypeScript(version = process.versions.node) {
 	const [major = 0, minor = 0] = version.replace(/^v/, "").split(".").map(Number);
 	return major > 23 || major === 23 && minor >= 6 || major === 22 && minor >= 18;
 }
+/** A config file, read and validated: a JSON one only with `jsonConfigOnly`. */
+async function readConfig(file, options) {
+	if (!fs.existsSync(file)) throw new ConfigError(`Config file not found: ${file}`);
+	if (options.jsonConfigOnly && !file.endsWith(".json")) throw new ConfigError(`${file} was not run: the server runs a JavaScript or TypeScript config only in a project it was started in (its working directory, --root or the client's roots), not in one found from the path a tool call names. Start the server in the project, or use onsystem.config.json.`);
+	const parsed = configSchema.safeParse(await readConfigFile(file));
+	if (!parsed.success) throw new ConfigError(`Invalid config in ${file}:\n${z.prettifyError(parsed.error)}`);
+	return parsed.data;
+}
 async function readConfigFile(file) {
 	if (/\.[cm]?ts$/.test(file) && !nodeRunsTypeScript()) throw new ConfigError(`${file} is TypeScript, which Node.js runs from 22.18; this is ${process.version}. Use onsystem.config.json or .mjs, or Node.js 22.18 or later.`);
 	if (file.endsWith(".json")) try {
@@ -6193,7 +6520,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);
@@ -6214,7 +6541,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,
@@ -6345,6 +6672,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];
@@ -7210,7 +7553,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;
@@ -7292,7 +7635,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;
 		}
@@ -7524,7 +7867,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);
@@ -7554,8 +7897,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();
@@ -7815,7 +8158,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
@@ -7858,7 +8201,8 @@ function table(tokens, keys) {
 		use(token),
 		...described ? [token.description ?? ""] : []
 	]);
-	const line = (cells) => `| ${cells.map((c) => c.replace(/\|/g, "\\|")).join(" | ")} |`;
+	const oneLine = (text) => text.split(/\r\n?|\n/).map((part) => part.trim()).filter(Boolean).join(" ");
+	const line = (cells) => `| ${cells.map((c) => oneLine(c).replace(/\|/g, "\\|")).join(" | ")} |`;
 	return [
 		line(header),
 		line(header.map(() => "---")),
@@ -11677,7 +12021,7 @@ function isObject(value) {
 var name = "onsystem";
 //#endregion
 //#region src/version.ts
-const VERSION = "0.9.0";
+const VERSION = "0.10.0";
 const NAME = name;
 //#endregion
 //#region src/lint/sarif.ts
@@ -12505,55 +12849,6 @@ function searchComponents(index, query, limit = 5) {
 	}));
 }
 //#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 and in the
-* order they are imported. The files themselves are not repeated.
-*/
-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;
-}
-//#endregion
 //#region src/util/log.ts
 const stderrLogger = {
 	info: (message) => process.stderr.write(`[onsystem] ${message}\n`),
@@ -13134,15 +13429,16 @@ var DesignSystemHost = class {
 		this.watchConfigFiles();
 	}
 	/**
-	* Watches the config file, the tsconfig and the tsconfigs it extends through
-	* their directories: editors save by renaming a new file over the old one,
-	* which ends a watch on the file. Called again after each build, so a new
-	* `extends` target is picked up.
+	* Watches the config file, the config a design-system package declares, which a project with
+	* a config of its own reads under that one, the tsconfig and the tsconfigs it extends through
+	* their directories: editors save by renaming a new file over the old one, which ends a watch
+	* on the file. Called again after each build, so a new `extends` target is picked up.
 	*/
 	watchConfigFiles() {
 		const { root, configFile, tsconfig, designSystemPackage } = this.config;
 		const files = [
 			configFile,
+			designSystemPackage?.config,
 			designSystemPackage && path.join(designSystemPackage.dir, "package.json"),
 			...DETECTION_FILES.map((f) => path.join(root, f)),
 			...tsconfig ? [path.resolve(root, tsconfig)] : PROJECT_CONFIG_FILES.map((f) => path.join(root, f)),
@@ -13200,7 +13496,7 @@ var DesignSystemHost = class {
 		const { root, configFile, designSystemPackage, warnings } = this.config;
 		const load = this.options.loadConfig ?? (() => loadConfig({
 			root,
-			config: designSystemPackage ? void 0 : configFile
+			config: configFile === designSystemPackage?.config ? void 0 : configFile
 		}));
 		try {
 			this.config = await load();
@@ -13239,4 +13535,4 @@ var DesignSystemHost = class {
 	}
 };
 //#endregion
-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$1 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 };
+export { DEFAULT_TOKENS as $, unrecordedRules as A, isInside as At, statusKinds as B, countBaseline as C, workspacePackageDirs as Ct, pruneBaseline as D, truncate as Dt, onLines as E, plural$1 as Et, loadTokens as F, readProjectConfig as Ft, parseDoc as G, parseDesignMd as H, mergeTokens as I, ConfigError as J, extractComponents as K, toDesignMd as L, writeBaseline as M, relativePath as Mt, RULES as N, toPosix as Nt, readBaseline as O, unique as Ot, TokenIndex as P, defaultProjectConfig as Pt, DEFAULT_TEST_FOLDERS as Q, toDtcg as R, applyBaseline as S, isWorkspaceRoot as St, goneFiles as T, closest 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 _, PackageFinder as _t, fingerprint as a, excludedBy as at, BASELINE_FILE as b, findDesignSystemPackage as bt, silentLogger as c, loadConfigWith as ct, descriptionOf as d, findVariantDefinitions as dt, FALLBACK_TOKENS as et, searchComponents as f, LIBRARIES as ft, escapeData as g, PACKAGE_FIELD as gt, uncheckedNotice as h, notReadYet as ht, componentFiles as i, defineConfig as it, updateBaseline as j, matchesGlob as jt, rulesRun as k, SCRIPT_FILE$2 as kt, stderrLogger as l, rulesFor as lt, checkSource as m, libraryTitle as mt, DesignSystemHost as n, RULE_IDS as nt, loadDesignSystem as o, hasOwnConfig as ot, applyFixes as p, LIBRARY_IDS as pt, CONFIG_FILES as q, buildModel as r, configJsonSchema as rt, tokenFiles as s, loadConfig as st, DesignSystem as t, LEGACY_CONFIG_FILES as tt, buildSearchIndex as u, formatPx as ut, NAME as v, declaredConfig as vt, findMoves as w, workspacePatterns as wt, LEGACY_BASELINE_FILE as x, isDesignSystemName as xt, VERSION as y, detectProject as yt, TOKEN_CATEGORIES as z };