onsystem 0.9.1 → 0.10.0

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
-import { $ as LEGACY_CONFIG_FILES, A as unrecordedRules, At as relativePath, B as statusKinds, C as countBaseline, D as pruneBaseline, Dt as SCRIPT_FILE, E as onLines, Et as unique, J as ConfigError, L as toDesignMd, M as writeBaseline, Nt as readProjectConfig, O as readBaseline, Ot as isInside, R as toDtcg, S as applyBaseline, T as goneFiles, Y as DEFAULT_DOCS, _ as formatDiagnostics, _t as detectProject, b as BASELINE_FILE, c as silentLogger, et as RULE_IDS, ft as libraryTitle, g as escapeData, gt as declaredConfig, h as uncheckedNotice, i as componentFiles, j as updateBaseline, jt as toPosix, k as rulesRun, kt as matchesGlob, l as stderrLogger, mt as PACKAGE_FIELD, o as loadDesignSystem, pt as notReadYet, q as CONFIG_FILES, rt as excludedBy, s as tokenFiles, st as rulesFor, v as NAME, w as findMoves, wt as plural, x as LEGACY_BASELINE_FILE, y as VERSION, yt as isDesignSystemName } from "./design-system-DZm2aP1z.js";
-import { a as notReadNotices, i as missingDependencies, o as explainProject, s as librariesLeftOut, t as serveStdio } from "./stdio-BJvjEnKW.js";
-import { r as loadTarget } from "./workspace-Dqu3nkYM.js";
+import { $ as DEFAULT_TOKENS, A as unrecordedRules, At as isInside, B as statusKinds, C as countBaseline, D as pruneBaseline, E as onLines, Et as plural, Ft as readProjectConfig, J as ConfigError, L as toDesignMd, M as writeBaseline, Mt as relativePath, Nt as toPosix, O as readBaseline, Ot as unique, R as toDtcg, S as applyBaseline, T as goneFiles, Y as DEFAULT_DOCS, _ as formatDiagnostics, at as excludedBy, b as BASELINE_FILE, c as silentLogger, et as FALLBACK_TOKENS, g as escapeData, gt as PACKAGE_FIELD, h as uncheckedNotice, ht as notReadYet, i as componentFiles, j as updateBaseline, jt as matchesGlob, k as rulesRun, kt as SCRIPT_FILE, l as stderrLogger, lt as rulesFor, mt as libraryTitle, nt as RULE_IDS, o as loadDesignSystem, q as CONFIG_FILES, s as tokenFiles, tt as LEGACY_CONFIG_FILES, v as NAME, vt as declaredConfig, w as findMoves, x as LEGACY_BASELINE_FILE, xt as isDesignSystemName, y as VERSION, yt as detectProject } from "./design-system-D53Jxybo.js";
+import { a as notReadNotices, i as missingDependencies, o as explainProject, s as librariesLeftOut, t as serveStdio } from "./stdio-ha4IF0CU.js";
+import { r as loadTarget } from "./workspace-DAa_08uB.js";
 import fs from "node:fs";
 import path from "node:path";
 import { escapePath, glob } from "tinyglobby";
@@ -26,7 +26,8 @@ const GUIDE_FILE = "ONSYSTEM.md";
 * (`"onsystem": "./onsystem.config.json"`, and in `files` when the package lists them), so
 * every app that depends on the package reads it, and writes ONSYSTEM.md, which tells those
 * apps' teams how to add the agent tools and the CI check. In an app that takes on such a
-* package's config, it writes no config of its own unless --force says to.
+* package's config, it writes no config of its own unless --force says to, and then one that
+* builds on the package's, for the app's own rules and overrides.
 *
 * In a terminal, it offers to add a short section on onsystem to the project's AGENTS.md or
 * CLAUDE.md, for coding agents.
@@ -52,20 +53,28 @@ async function init(configOptions, options, io, runCheck) {
 	const notes = [];
 	const relative = (abs) => relativePath(root, abs);
 	const inherited = options.force ? void 0 : config.designSystemPackage;
-	const replaced = options.force ? config.designSystemPackage : void 0;
+	const declaring = options.force && !configOptions.components?.length ? config.designSystemPackage : void 0;
+	const replaced = declaring && (config.inherits || !await namesOwnComponents(config, declaring)) ? declaring : void 0;
 	let found = false;
-	if (inherited) notes.push(`This project takes on the config ${inherited.name} declares in its package.json (${relativePath(io.cwd, inherited.config) || inherited.config}), so it needs none of its own; nothing was written. Pass --force to write one, which is read instead.`);
+	if (inherited) notes.push(`This project takes on the config ${inherited.name} declares in its package.json (${relativePath(io.cwd, inherited.config) || inherited.config}), so it needs none of its own; nothing was written. Pass --force to write one for its own rules and overrides, which builds on ${inherited.name}'s.`);
 	else if (configOptions.components?.length) {
 		file.components = configOptions.components;
 		if (configOptions.tokens?.length) file.tokens = configOptions.tokens;
 		if (configOptions.docs?.length) file.docs = configOptions.docs;
-	} else if (workspace) notes.push(`This is a monorepo root: ${workspace.projects.length} of ${workspace.projects.length + workspace.others.length} workspace packages have a design system (${workspace.projects.map((p) => p.dir).join(", ") || "none"}). Each keeps zero config; rules and overrides you add here apply to every project without a config of its own.`);
+	} else if (replaced) {
+		const tokens = existing ? ownTokens(existing, root, replaced) : void 0;
+		if (tokens) file.tokens = tokens;
+	} else if (workspace) notes.push(`This is a monorepo root: ${workspace.projects.length} of ${workspace.projects.length + workspace.others.length} workspace packages have a design system (${workspace.projects.map((p) => p.dir).join(", ") || "none"}). Each keeps zero config; rules and overrides you add here apply to every project without a config of its own when it is checked from this folder, over the config its design-system package declares.`);
 	else if (config.detected) {
 		notes.push(`Found the design system through ${config.detected}.`);
 		const specifiers = new Set((config.imports ?? []).map((m) => m.specifier));
 		const tokens = (await tokenFiles(config)).map(relative);
-		if (specifiers.size > 1) notes.push(`"components" is left to zero config: apps import them by ${specifiers.size} specifiers from the package's exports (${[...specifiers].slice(0, 2).join(", ")}, …), which a config cannot spell.`);
+		const fromInstalled = installedFields(config.components, tokens);
+		if (fromInstalled.length) notes.push(installedNote(fromInstalled, tokens));
+		const changed = fromInstalled.includes("tokens") && !fromInstalled.includes("components") ? await tokensWithComponents(config, tokens) : void 0;
+		if (fromInstalled.includes("components")) {} else if (specifiers.size > 1) notes.push(`"components" is left to zero config: apps import them by ${specifiers.size} specifiers from the package's exports (${[...specifiers].slice(0, 2).join(", ")}, …), which a config cannot spell.`);
 		else if (config.components.length > MAX_GLOBS) notes.push(`"components" is left to zero config: it found ${config.components.length} files through the package's exports, which it keeps following as the package changes.`);
+		else if (changed) notes.push(`"components" is left to zero config as well: a config that names them reads the tokens only from the usual stylesheets (${DEFAULT_TOKENS[0]} and the like)${changed.lost.length ? `, which leave out ${andList(changed.lost)}` : ", not the ones zero config reads"}.`);
 		else {
 			file.components = config.components;
 			found = true;
@@ -74,20 +83,20 @@ async function init(configOptions, options, io, runCheck) {
 			const docs = config.docs.filter((d) => !DEFAULT_DOCS.includes(d));
 			if (docs.length) file.docs = [...DEFAULT_DOCS, ...docs];
 		}
-		if (tokens.length) file.tokens = tokens;
+		if (tokens.length && !fromInstalled.includes("tokens")) file.tokens = tokens;
 	} else if ((await componentFiles(config)).length) {
-		const declared = replaced && config.configured;
 		const matching = [];
 		for (const glob of config.components) if ((await componentFiles({
 			...config,
 			components: [glob]
 		})).length) matching.push(glob);
-		notes.push(declared ? `Found the design system through the config ${replaced.name} declares: ${matching.join(", ")}.` : `Found the design system in the default folders: ${matching.join(", ")}.`);
+		notes.push(`Found the design system in the default folders: ${matching.join(", ")}.`);
 		file.components = matching;
 		found = true;
-		if (declared && config.importPath) file.importPath = config.importPath;
 		const tokens = (await tokenFiles(config)).map(relative);
-		if (tokens.length) file.tokens = tokens;
+		const fromInstalled = installedFields([], tokens);
+		if (fromInstalled.length) notes.push(installedNote(fromInstalled, tokens));
+		else if (tokens.length) file.tokens = tokens;
 	} else {
 		if (!ask) {
 			io.stderr(`init: zero config found no design system in ${root}. Pass --components (and --tokens) to say where it is, or run init in a terminal to answer a few questions. \`${NAME} inspect --explain\` shows what it looked at.`);
@@ -124,13 +133,7 @@ async function init(configOptions, options, io, runCheck) {
 		fs.writeFileSync(out, `${JSON.stringify(file, null, 2)}\n`);
 		written.push(CONFIG_FILE);
 	}
-	if (replaced) {
-		const own = (await loadTarget({
-			...configOptions,
-			config: void 0
-		})).config;
-		notes.push(await replacedNote(replaced, config, own, io.cwd));
-	}
+	if (replaced) notes.push(replacedNote(replaced, io.cwd, file.tokens !== void 0));
 	let registry;
 	if (designSystem && manifest && name) {
 		written.push(...declarePackage(root, manifest, name, options.force, notes));
@@ -341,7 +344,7 @@ function declarePackage(root, manifest, name, force, notes) {
 		fs.writeFileSync(manifest.file, `${JSON.stringify(json, null, manifest.indent)}${manifest.newline ? "\n" : ""}`);
 		written.push("package.json");
 	}
-	notes.push(`This is a design-system package: package.json declares its config ("${PACKAGE_FIELD}": "${value}"${files ? ", also added to \"files\"" : ""}), which every app that depends on ${name} reads when it has no config of its own.`);
+	notes.push(`This is a design-system package: package.json declares its config ("${PACKAGE_FIELD}": "${value}"${files ? ", also added to \"files\"" : ""}), which every app that depends on ${name} reads, under its own config when it has one.`);
 	const guide = path.join(root, GUIDE_FILE);
 	if (force || !fs.existsSync(guide)) {
 		fs.writeFileSync(guide, consumerGuide(name));
@@ -354,7 +357,8 @@ function declarePackage(root, manifest, name, force, notes) {
 * files its `files` list leaves out of the published package, and those outside the package
 * (`../tailwind-config/theme.css`), which an installed package's config cannot reach. Undefined
 * for a private package, or when they find every file. Without a `files` list, npm publishes
-* everything in the package.
+* everything in the package. Without any component file, those apps read the components from
+* the type declarations the package publishes, when it names some.
 */
 async function unshipped(config, json) {
 	if (json.private === true) return void 0;
@@ -374,13 +378,14 @@ async function unshipped(config, json) {
 		tokens: tokens.filter(outside)
 	};
 	const noComponents = components.length > 0 && missing.components.length + away.components.length === components.length;
+	const declarations = noComponents ? publishedDeclarations(config.root, json, files) : [];
 	const lost = (lists, one) => {
 		const c = lists.components.length;
 		const t = lists.tokens.length;
 		const kinds = andList([...c ? [count$1(c, "component file")] : [], ...t ? [count$1(t, "token file")] : []]);
-		const what = andList([...c ? ["components"] : [], ...t ? ["tokens"] : []], "or");
-		const checks = c && noComponents ? `: they get no component, prop, variant or native-element checks, and \`${NAME} check --require-design-system\` fails in them` : "";
-		return `(${kinds}). Those apps do not know the ${what} in ${one ? "it" : "them"}${checks}.`;
+		const them = one ? "it" : "them";
+		if (c && noComponents && declarations.length) return `(${kinds}). Those apps read the components from the type declarations it publishes instead (${andList(declarations)})${t ? `, and do not know the tokens in ${them}` : ""}.`;
+		return `(${kinds}). Those apps do not know the ${andList([...c ? ["components"] : [], ...t ? ["tokens"] : []], "or")} in ${them}${c && noComponents ? `: with no type declarations published either, they get no component, prop, variant or native-element checks, and \`${NAME} check --require-design-system\` fails in them` : ""}.`;
 	};
 	const notes = [];
 	const top = (f) => f.includes("/") ? `${f.slice(0, f.indexOf("/"))}/` : f;
@@ -397,36 +402,121 @@ async function unshipped(config, json) {
 	if (!notes.length) return void 0;
 	return {
 		notes,
-		next: noComponents && missing.components.length ? `gets no component checks until "files" publishes ${andList([...new Set(missing.components.map(top))])}` : `does not read ${andList([...folders, ...beyond])}`
+		next: noComponents && missing.components.length ? declarations.length ? `reads its components from the type declarations it publishes, not from ${andList([...new Set(missing.components.map(top))])}` : `gets no component checks until "files" publishes ${andList([...new Set(missing.components.map(top))])}` : `does not read ${andList([...folders, ...beyond])}`
 	};
 }
 /**
-* Said when --force writes a config in an app that took on a design-system package's: the new
-* one is read instead, and what it does not take from the package. `taken` is the config the
-* app took on, `own` the one it reads now.
+* The type declarations a package's package.json names, as apps that install it look for them:
+* `types` or `typings`, a `types` condition in its `exports`, or an `index.d.ts` beside it, each
+* that its `files` list publishes. Relative to the package.
 */
-async function replacedNote(pkg, taken, own, cwd) {
-	const lacks = async (list) => {
-		const kept = new Set((await list(own)).map((f) => path.resolve(f)));
-		return (await list(taken)).some((f) => !kept.has(path.resolve(f)));
+function publishedDeclarations(root, json, files) {
+	const named = [];
+	for (const field of ["types", "typings"]) {
+		const value = json[field];
+		if (typeof value === "string") named.push(value);
+	}
+	const conditions = (value, key) => {
+		if (typeof value === "string") {
+			if (key === "types") named.push(value);
+		} else if (Array.isArray(value)) for (const item of value) conditions(item);
+		else if (value && typeof value === "object") for (const [k, v] of Object.entries(value)) conditions(v, k);
 	};
-	const components = await lacks(componentFiles);
-	const importPath = taken.importPath !== void 0 && own.importPath === void 0;
-	const tokens = await lacks(tokenFiles);
+	conditions(json.exports);
+	if (fs.existsSync(path.join(root, "index.d.ts"))) named.push("index.d.ts");
+	return [...new Set(named.map((f) => f.replace(/^\.\//, "")))].filter((f) => !files || ships(files, f));
+}
+/**
+* Said when --force writes a config in an app on a design-system package that declares one: the
+* new config builds on the package's, which still gives it what it leaves out.
+*/
+function replacedNote(pkg, cwd, keptTokens) {
 	const declared = relativePath(cwd, pkg.config) || pkg.config;
-	const replaced = `This project took on the config ${pkg.name} declares (${declared}); with --force it has one of its own, which is read instead, so ${pkg.name}'s rules and later changes to its config no longer reach it.`;
-	if (!components && !importPath && !tokens) return replaced;
-	const effects = andList([
-		...components ? [`does not know ${pkg.name}'s components`] : [],
-		...importPath && !components ? [`does not match imports from ${pkg.name} to its components`] : [],
-		...tokens ? [`does not read ${pkg.name}'s tokens`] : []
-	]);
-	const fields = [
-		...components ? ["\"components\""] : [],
-		...importPath || components && taken.importPath !== void 0 ? ["\"importPath\""] : [],
-		...tokens ? ["\"tokens\""] : []
-	];
-	return `${replaced} It ${effects}: ${(!components || taken.configured === true) && (!tokens || taken.tokensDetected !== true) ? `copy ${andList(fields)} from ${declared} into ${CONFIG_FILE}, or ` : ""}delete ${CONFIG_FILE} to take on ${pkg.name}'s config again.`;
+	const fields = keptTokens ? "\"components\" and \"importPath\"" : "\"components\", \"importPath\" and \"tokens\"";
+	const kept = keptTokens ? " It keeps the \"tokens\" the old one listed, which name a stylesheet of this project's own." : "";
+	return `This project reads the config ${pkg.name} declares (${declared}). With --force it has one of its own, ${CONFIG_FILE}, read over that one: what it leaves out, such as ${fields}, still comes from ${pkg.name}'s config, and the rules and overrides you add to it apply over ${pkg.name}'s rules.${kept} "extends": false in it reads it alone.`;
+}
+/**
+* The `tokens` an existing JSON config lists, when one of them is outside the design-system
+* package, links resolved: an app that takes the package's components and reads its own
+* stylesheet too lists both. A list of the package's files only is left to the package's config.
+*/
+function ownTokens(file, root, pkg) {
+	let tokens;
+	try {
+		tokens = JSON.parse(fs.readFileSync(file, "utf8")).tokens;
+	} catch {
+		return;
+	}
+	if (!Array.isArray(tokens) || !tokens.every((t) => typeof t === "string")) return;
+	const real = (abs) => {
+		try {
+			return fs.realpathSync(abs);
+		} catch {
+			return abs;
+		}
+	};
+	const dir = real(pkg.dir);
+	return tokens.some((t) => !isInside(dir, real(path.resolve(root, t)))) ? tokens : void 0;
+}
+/**
+* Whether the files a config's `components` match include some outside the design-system
+* package, links resolved: a config that names only the package's (copied from its config, as
+* `node_modules/@acme/ui/src/*.tsx`), or none, has no components of its own.
+*/
+async function namesOwnComponents(config, pkg) {
+	const real = (file) => {
+		try {
+			return fs.realpathSync(file);
+		} catch {
+			return path.resolve(file);
+		}
+	};
+	const dir = real(pkg.dir);
+	return (await componentFiles(config)).some((file) => !isInside(dir, real(file)));
+}
+/** Whether a path, relative to the root, is in a package installed in `node_modules`. */
+const isInstalledPath = (file) => /(?:^|\/)node_modules\//.test(file);
+/**
+* The fields `init` leaves to zero config because what zero config found for them is in a
+* package installed in `node_modules`: `components` (their globs) and `tokens` (files).
+*/
+function installedFields(components, tokens) {
+	return [...components.some(isInstalledPath) ? ["components"] : [], ...tokens.some(isInstalledPath) ? ["tokens"] : []];
+}
+/**
+* Why `fields` are left to zero config: a path into an installed package breaks when it is
+* upgraded, since pnpm keeps each version in a folder of its own
+* (`node_modules/.pnpm/@acme+ui@1.2.0_react@19.2.0/node_modules/@acme/ui`), and a list of its
+* files misses the ones a new version adds. Zero config finds it again each time.
+*/
+function installedNote(fields, tokens) {
+	const one = fields.length === 1;
+	const what = fields.includes("tokens") && !tokens.every(isInstalledPath) ? `${fields.includes("components") ? "the components and " : ""}some of the token files come` : one ? "it comes" : "they come";
+	return `${andList(fields.map((f) => `"${f}"`))} ${one ? "is" : "are"} left to zero config: ${what} from a package installed in node_modules, which zero config finds again after each upgrade, while a path written here would break once the package's folder or files change (pnpm keeps each version in a folder of its own in node_modules/.pnpm).`;
+}
+/**
+* What changes when a config names components and leaves `tokens` (relative to the root, as
+* zero config finds them) to zero config: such a config turns detection off, so the stylesheets
+* it found (components.json's `app/styles/tailwind.css`, and what they import from an installed
+* package) give way to the usual ones ({@link DEFAULT_TOKENS}), with what those import. Undefined
+* when that reads the same token files; else `lost` holds the ones it leaves out, the app's own
+* first.
+*/
+async function tokensWithComponents(config, tokens) {
+	const usual = await tokenFiles({
+		...config,
+		tokens: [...DEFAULT_TOKENS.map((p) => ({ path: p })), ...FALLBACK_TOKENS.map((p) => ({
+			path: p,
+			fallback: true
+		}))],
+		tokensDetected: true
+	});
+	const read = new Set(usual.map((f) => relativePath(config.root, f)));
+	if (read.size === tokens.length && tokens.every((t) => read.has(t))) return void 0;
+	const lost = tokens.filter((t) => !read.has(t));
+	const own = lost.filter((t) => !isInstalledPath(t));
+	return { lost: own.length ? own : lost };
 }
 const REGISTRY_DOCS = "https://onsystem.vercel.app/docs/configuration#code-from-shadcn-registries";
 /**
@@ -555,7 +645,7 @@ function consumerGuide(name) {
 		`npx -y ${NAME} inspect`,
 		"```",
 		"",
-		`An app with an ${CONFIG_FILE} of its own reads that instead.`,
+		`An app with an ${CONFIG_FILE} of its own reads it over ${name}'s config: the rules and overrides it sets apply over ${name}'s rules, and, unless it sets components of its own, what it leaves out, such as the components, \`importPath\` and tokens, comes from ${name}'s. \`"extends": false\` in it reads it alone.`,
 		"",
 		"## Coding agents",
 		"",
@@ -1427,7 +1517,7 @@ async function inspect(configOptions, values, io) {
 	}
 	const lines = [
 		`root     ${model.root}`,
-		`config   ${config.configFile ? `${displayPath(io.cwd, config.configFile)}${declaredBy(config)}` : "(defaults)"}`,
+		`config   ${config.configFile ? `${displayPath(io.cwd, config.configFile)}${declaredBy(config, (f) => displayPath(io.cwd, f))}` : "(defaults)"}`,
 		...config.detected ? [`detected ${config.detected}`] : [],
 		...describeLibraries(config, model, io.cwd).map((line) => `library  ${line}`),
 		`files    ${plural(model.stats.files.components, "component file")}, ${plural(model.stats.files.tokens, "token file")}, ${plural(model.stats.files.docs, "doc")}`,
@@ -1561,7 +1651,7 @@ async function inspectWorkspace(workspace, values, io) {
 		const { model } = ds;
 		const roots = ds.roots();
 		const tokens = [...tokenCounts(model)].map(([category, n]) => `${category} ${n}`);
-		const own = project.config.configFile && project.config.configFile !== workspace.configFile ? `${displayPath(workspace.root, project.config.configFile)}${declaredBy(project.config)}` : void 0;
+		const own = project.config.configFile && (project.config.configFile !== workspace.configFile || project.config.designSystemPackage) ? `${displayPath(workspace.root, project.config.configFile)}${declaredBy(project.config, (f) => displayPath(workspace.root, f))}` : void 0;
 		lines.push("", `${project.dir}${project.name ? ` (${project.name})` : ""}`, ...own ? [`  config     ${own}`] : [], ...project.config.detected ? [`  detected   ${project.config.detected}`] : [], ...describeLibraries(project.config, model, io.cwd).map((line) => `  library    ${line}`), `  files      ${plural(model.stats.files.components, "component file")}, ${plural(model.stats.files.tokens, "token file")}, ${plural(model.stats.files.docs, "doc")}`, `  components ${roots.length} + ${ds.components.length - roots.length} parts${roots.length ? `: ${listNames(roots.map((c) => c.name))}` : ""}`, `  tokens     ${tokens.length ? tokens.join(", ") : "none"}`, ...model.warnings.length ? [`  warnings   ${model.warnings.length}: ${model.warnings[0] ?? ""}`] : []);
 	}
 	if (!loaded.length) lines.push("", `No workspace package has a design system that zero config finds. See ${DOCS}/troubleshooting`);
@@ -1589,9 +1679,14 @@ function explainWorkspace(workspace, loaded, cwd) {
 	for (const { project, ds } of loaded) lines.push("", `${project.dir}${project.name ? ` (${project.name})` : ""}`, ...explainProject(ds, cwd, "  "));
 	return lines;
 }
-/** ` (declared by @acme/ui)` after a config a design-system package declares; empty otherwise. */
-function declaredBy(config) {
-	return config.designSystemPackage ? ` (declared by ${config.designSystemPackage.name})` : "";
+/**
+* ` (declared by @acme/ui)` after a config a design-system package declares, `, over
+* packages/ui/onsystem.config.json (declared by @acme/ui)` after one read over it; empty otherwise.
+*/
+function declaredBy(config, display) {
+	const declared = config.designSystemPackage;
+	if (!declared) return "";
+	return `${config.configFile === declared.config ? "" : `, over ${display(declared.config)}`} (declared by ${declared.name})`;
 }
 /** `A, B, C` up to a dozen names, then `and 40 more`. */
 function listNames(names, max = 12) {

package/dist/{config-B98w8bcg.d.ts → config-BbTW1jKU.d.ts}

@@ -303,6 +303,7 @@ declare const ruleOptionsSchema: z.ZodObject<{
 type RuleOptions = z.infer<typeof ruleOptionsSchema>;
 declare const configSchema: z.ZodObject<{
   $schema: z.ZodOptional<z.ZodString>;
+  extends: z.ZodOptional<z.ZodBoolean>;
   components: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
   exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
   tokens: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
@@ -450,12 +451,21 @@ interface ResolvedConfig {
    */
   base?: string | undefined;
   /**
-   * The design-system package whose config this is: a dependency whose package.json declares it
-   * (`"onsystem": "./onsystem.config.json"`), taken on by a project with no config of its own.
+   * The design-system package whose config this project reads: a dependency whose package.json
+   * declares it (`"onsystem": "./onsystem.config.json"`). A project with no config of its own
+   * takes it on (`configFile` is the package's); one with a config of its own, or a workspace
+   * root's, reads it under that one (`configFile` is that one), unless it sets `"extends": false`.
    * Its paths are rebased from the package; its `tsconfig`, `overrides` and
    * `includeDesignSystem` stay with it.
    */
   designSystemPackage?: DesignSystemPackage | undefined;
+  /**
+   * The project's config sets no `components`, so what it leaves out of `components`,
+   * `importPath`, `docs`, `elements`, `tokens` and `libraries` comes from `designSystemPackage`'s.
+   */
+  inherits?: boolean | undefined;
+  /** The project's config sets `"extends": false`, so no design-system package's config is read. */
+  extendsOff?: boolean | undefined;
   /** `components` comes from the config file or `--components`, not from detection or the defaults. */
   configured?: boolean | undefined;
   /**

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

@@ -3568,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."),
@@ -3653,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));
@@ -3663,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 } : {}
@@ -3785,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;
@@ -3863,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 {
@@ -8179,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(() => "---")),
@@ -11998,7 +12021,7 @@ function isObject(value) {
 var name = "onsystem";
 //#endregion
 //#region src/version.ts
-const VERSION = "0.9.1";
+const VERSION = "0.10.0";
 const NAME = name;
 //#endregion
 //#region src/lint/sarif.ts
@@ -13406,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)),
@@ -13472,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();
@@ -13511,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$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 };
+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 };

package/dist/eslint-worker.d.ts

@@ -1,4 +1,4 @@
-import { h as DesignSystemModel, i as ResolvedConfig } from "./config-B98w8bcg.js";
+import { h as DesignSystemModel, i as ResolvedConfig } from "./config-BbTW1jKU.js";
 import { MessagePort } from "node:worker_threads";
 //#region src/eslint/worker.d.ts
 export interface LoadRequest {

package/dist/eslint-worker.js

@@ -1,5 +1,5 @@
-import { At as relativePath, i as componentFiles, r as buildModel, rt as excludedBy } from "./design-system-DZm2aP1z.js";
-import { r as loadTarget } from "./workspace-Dqu3nkYM.js";
+import { Mt as relativePath, at as excludedBy, i as componentFiles, r as buildModel } from "./design-system-D53Jxybo.js";
+import { r as loadTarget } from "./workspace-DAa_08uB.js";
 import fs from "node:fs";
 import path from "node:path";
 import { parentPort } from "node:worker_threads";

package/dist/eslint.js

@@ -1,4 +1,4 @@
-import { At as relativePath, N as RULES, Q as DEFAULT_TEST_FOLDERS, X as DEFAULT_SEVERITY, Z as DEFAULT_TEST_EXCLUDE, t as DesignSystem, v as NAME, y as VERSION } from "./design-system-DZm2aP1z.js";
+import { Mt as relativePath, N as RULES, Q as DEFAULT_TEST_FOLDERS, X as DEFAULT_SEVERITY, Z as DEFAULT_TEST_EXCLUDE, t as DesignSystem, v as NAME, y as VERSION } from "./design-system-D53Jxybo.js";
 import path from "node:path";
 import { MessageChannel, Worker, receiveMessageOnPort } from "node:worker_threads";
 //#region src/eslint/bridge.ts

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { C as TOKEN_CATEGORIES, D as VariantInfo, E as TokenCategory, O as ImportMapping, S as SourceLocation, T as Token, _ as DocSection, a as ResolvedRule, b as PropInfo, c as configJsonSchema, d as CheckResult, f as ComponentDocs, g as Diagnostic, h as DesignSystemModel, i as ResolvedConfig, l as defineConfig, m as CompoundVariantInfo, n as LoadConfigOptions, o as RuleId, p as ComponentInfo, r as RULE_IDS, s as RuleOptions, t as Config, u as loadConfig, v as ExampleInfo, w as TextEdit, x as Severity, y as InheritedProps } from "./config-B98w8bcg.js";
+import { C as TOKEN_CATEGORIES, D as VariantInfo, E as TokenCategory, O as ImportMapping, S as SourceLocation, T as Token, _ as DocSection, a as ResolvedRule, b as PropInfo, c as configJsonSchema, d as CheckResult, f as ComponentDocs, g as Diagnostic, h as DesignSystemModel, i as ResolvedConfig, l as defineConfig, m as CompoundVariantInfo, n as LoadConfigOptions, o as RuleId, p as ComponentInfo, r as RULE_IDS, s as RuleOptions, t as Config, u as loadConfig, v as ExampleInfo, w as TextEdit, x as Severity, y as InheritedProps } from "./config-BbTW1jKU.js";
 import ts from "typescript";
 import { Oklch } from "culori";
 import { McpServer, Transport } from "@modelcontextprotocol/server";
@@ -663,10 +663,10 @@ export declare class DesignSystemHost {
   /** Watches the component, token and docs locations, the config and the tsconfig chain. */
   watch(): void;
   /**
-   * 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.
    */
   private watchConfigFiles;
   private changed;

package/dist/index.js

@@ -1,3 +1,3 @@
-import { F as loadTokens, G as parseDoc, H as parseDesignMd, I as mergeTokens, K as extractComponents, L as toDesignMd, N as RULES, P as TokenIndex, R as toDtcg, U as parseCssTokens, V as parseDtcgTokens, W as attachDocs, _ as formatDiagnostics, a as fingerprint, at as loadConfig, et as RULE_IDS, f as searchComponents, lt as findVariantDefinitions, m as checkSource, n as DesignSystemHost, nt as defineConfig, o as loadDesignSystem, p as applyFixes, r as buildModel, t as DesignSystem, tt as configJsonSchema, y as VERSION } from "./design-system-DZm2aP1z.js";
-import { n as INSTRUCTIONS, r as createServer, t as serveStdio } from "./stdio-BJvjEnKW.js";
+import { F as loadTokens, G as parseDoc, H as parseDesignMd, I as mergeTokens, K as extractComponents, L as toDesignMd, N as RULES, P as TokenIndex, R as toDtcg, U as parseCssTokens, V as parseDtcgTokens, W as attachDocs, _ as formatDiagnostics, a as fingerprint, dt as findVariantDefinitions, f as searchComponents, it as defineConfig, m as checkSource, n as DesignSystemHost, nt as RULE_IDS, o as loadDesignSystem, p as applyFixes, r as buildModel, rt as configJsonSchema, st as loadConfig, t as DesignSystem, y as VERSION } from "./design-system-D53Jxybo.js";
+import { n as INSTRUCTIONS, r as createServer, t as serveStdio } from "./stdio-ha4IF0CU.js";
 export { DesignSystem, DesignSystemHost, INSTRUCTIONS, RULES, RULE_IDS, TokenIndex, VERSION, applyFixes, attachDocs, buildModel, checkSource, configJsonSchema, createServer, defineConfig, extractComponents, findVariantDefinitions, fingerprint, formatDiagnostics, loadConfig, loadDesignSystem, loadTokens, mergeTokens, parseCssTokens, parseDesignMd, parseDoc, parseDtcgTokens, searchComponents, serveStdio, toDesignMd, toDtcg };

package/dist/{stdio-BJvjEnKW.js → stdio-ha4IF0CU.js}

@@ -1,5 +1,5 @@
-import { $ as LEGACY_CONFIG_FILES, At as relativePath, Ct as closest, Dt as SCRIPT_FILE, Et as unique, Mt as defaultProjectConfig, Ot as isInside, Tt as truncate, X as DEFAULT_SEVERITY, _t as detectProject, at as loadConfig, ct as formatPx, d as descriptionOf, dt as LIBRARY_IDS, et as RULE_IDS, f as searchComponents, ft as libraryTitle, h as uncheckedNotice, n as DesignSystemHost, pt as notReadYet, q as CONFIG_FILES, rt as excludedBy, u as buildSearchIndex, ut as LIBRARIES, v as NAME, vt as findDesignSystemPackage, wt as plural, y as VERSION, z as TOKEN_CATEGORIES } from "./design-system-DZm2aP1z.js";
-import { n as hasProjectMarker, r as loadTarget, t as findProjectRoot } from "./workspace-Dqu3nkYM.js";
+import { At as isInside, Dt as truncate, Et as plural, Mt as relativePath, Ot as unique, Pt as defaultProjectConfig, Tt as closest, X as DEFAULT_SEVERITY, at as excludedBy, bt as findDesignSystemPackage, d as descriptionOf, f as searchComponents, ft as LIBRARIES, h as uncheckedNotice, ht as notReadYet, kt as SCRIPT_FILE, mt as libraryTitle, n as DesignSystemHost, nt as RULE_IDS, pt as LIBRARY_IDS, q as CONFIG_FILES, st as loadConfig, tt as LEGACY_CONFIG_FILES, u as buildSearchIndex, ut as formatPx, v as NAME, y as VERSION, yt as detectProject, z as TOKEN_CATEGORIES } from "./design-system-D53Jxybo.js";
+import { n as hasProjectMarker, r as loadTarget, t as findProjectRoot } from "./workspace-DAa_08uB.js";
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -19,7 +19,7 @@ function explainProject(ds, cwd, indent = "") {
 	const out = (line = "") => lines.push(line ? `${indent}${line}` : "");
 	out("How the design system was found");
 	for (const step of packageSteps(config, cwd)) out(`  ${(step.accepted ? "found" : "no").padEnd(6)} ${step.candidate}: ${step.reason}`);
-	if (config.configured) out(`  components come from ${config.configFile ? display(cwd, config.configFile) : "--components"}, so zero config did not look`);
+	if (config.configured) out(`  components come from ${config.inherits && config.designSystemPackage ? display(cwd, config.designSystemPackage.config) : config.configFile ? `${display(cwd, config.configFile)}${over(config, cwd)}` : "--components"}, so zero config did not look`);
 	else {
 		const steps = [];
 		detectProject(config.root, config.tsconfig, steps, config.designSystemPackage);
@@ -37,7 +37,7 @@ function explainProject(ds, cwd, indent = "") {
 	out("Resolved config");
 	const field = (name, value) => out(`  ${name.padEnd(12)} ${value}`);
 	field("root", config.root);
-	field("config", config.configFile ? `${display(cwd, config.configFile)}${config.designSystemPackage ? ` (declared by ${config.designSystemPackage.name})` : ""}` : "(none)");
+	field("config", config.configFile ? `${display(cwd, config.configFile)}${over(config, cwd)}${config.designSystemPackage ? ` (declared by ${config.designSystemPackage.name})` : ""}` : "(none)");
 	field("components", listOf$3(config.components) || "(none)");
 	field("exclude", listOf$3(config.exclude));
 	field("tokens", listOf$3(config.tokens.map((t) => `${t.path}${t.prefix ? ` (prefix ${t.prefix})` : ""}${t.fallback ? " (when nothing else is found)" : ""}`)));
@@ -111,20 +111,34 @@ function nodeModulesFor(dir) {
 		if (current === path.dirname(current)) return void 0;
 	}
 }
+/** `, over packages/ui/onsystem.config.json` for a config read over a design-system package's. */
+function over(config, cwd) {
+	const declared = config.designSystemPackage;
+	return declared && config.configFile !== declared.config ? `, over ${display(cwd, declared.config)}` : "";
+}
 function display(cwd, file) {
 	const rel = relativePath(cwd, file);
 	return rel && !rel.startsWith("..") ? rel : file;
 }
 /**
-* Whether a dependency's declared config was taken on, for a project without a config of its
-* own: the package it came from and the others that declare one, or that none does.
+* Whether a dependency's declared config was read, taken on by a project without a config of its
+* own or under the one it has: the package it came from and the others that declare one, or that
+* none does.
 */
 function packageSteps(config, cwd) {
 	const declared = config.designSystemPackage;
-	if (config.configFile && !declared) return [];
+	const candidate = "a design-system package's config";
+	if (config.configFile && !declared) {
+		const found = config.extendsOff ? findDesignSystemPackage(config.root)?.found : void 0;
+		if (!found) return [];
+		return [{
+			candidate,
+			accepted: false,
+			reason: `${found.name} (${found.installed ? "installed" : "a workspace package"}) declares ${display(cwd, found.config)}, not read: "extends": false in ${display(cwd, config.configFile)} reads it alone`
+		}];
+	}
 	const lookup = findDesignSystemPackage(config.root);
 	if (!lookup) return [];
-	const candidate = "a design-system package's config";
 	const skipped = lookup.skipped.length ? `; ${lookup.skipped.map((p) => p.name).join(", ")} ${lookup.skipped.length === 1 ? "declares one" : "declare one"} that cannot be read, skipped since installed` : "";
 	if (!declared) return [{
 		candidate,
@@ -134,7 +148,7 @@ function packageSteps(config, cwd) {
 	return [{
 		candidate,
 		accepted: true,
-		reason: `${declared.name} (${declared.installed ? "installed" : "a workspace package"}) declares ${display(cwd, declared.config)}, which this project takes on, with its paths from ${display(cwd, declared.dir)}${lookup.others.length ? `; ${lookup.others.join(", ")} also declare one, not read: one config is taken on, from the package the code imports most` : ""}${skipped}`
+		reason: `${declared.name} (${declared.installed ? "installed" : "a workspace package"}) declares ${display(cwd, declared.config)}, which this project ${config.configFile === declared.config ? "takes on" : `reads under ${display(cwd, config.configFile ?? "")}`}, with its paths from ${display(cwd, declared.dir)}${lookup.others.length ? `; ${lookup.others.join(", ")} also declare one, not read: one config is taken on, from the package the code imports most` : ""}${skipped}`
 	}];
 }
 //#endregion

package/dist/{workspace-Dqu3nkYM.js → workspace-DAa_08uB.js}

@@ -1,4 +1,4 @@
-import { $ as LEGACY_CONFIG_FILES, At as relativePath, Ot as isInside, St as workspacePatterns, at as loadConfig, bt as isWorkspaceRoot, ht as PackageFinder, i as componentFiles, it as hasOwnConfig, ot as loadConfigWith, q as CONFIG_FILES, vt as findDesignSystemPackage, xt as workspacePackageDirs } from "./design-system-DZm2aP1z.js";
+import { At as isInside, Ct as workspacePackageDirs, Mt as relativePath, St as isWorkspaceRoot, _t as PackageFinder, bt as findDesignSystemPackage, ct as loadConfigWith, i as componentFiles, ot as hasOwnConfig, q as CONFIG_FILES, st as loadConfig, tt as LEGACY_CONFIG_FILES, wt as workspacePatterns } from "./design-system-D53Jxybo.js";
 import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
@@ -121,7 +121,7 @@ async function discoverWorkspace(rootConfig, options) {
 	for (const dir of workspacePackageDirs(root)) {
 		const config = await loadProjectConfig(dir, root, rootConfig.configFile, options);
 		const files = (await componentFiles(config)).length;
-		const own = config.configFile !== void 0 && config.configFile !== rootConfig.configFile;
+		const own = config.configFile !== void 0 && config.configFile !== rootConfig.configFile || config.designSystemPackage !== void 0;
 		const library = config.libraries?.some((l) => l.dir !== void 0) ?? false;
 		if (files || own || library) projects.push({
 			root: dir,
@@ -138,10 +138,11 @@ async function discoverWorkspace(rootConfig, options) {
 	return new Workspace(root, source, projects, others, rootConfig.configFile, options, rootConfig, otherConfigs);
 }
 /**
-* A project's config: its own config file, else the config its design-system package declares
-* (a dependency with `"onsystem"` in its package.json), else the workspace root's, with paths
-* relative to the workspace root, else zero config. `loadConfig` from the project's folder finds
-* the first two the same way. CLI flags that apply to every project carry over.
+* A project's config: its own config file, else the workspace root's, with paths relative to
+* the workspace root, read over the config its design-system package declares (a dependency with
+* `"onsystem"` in its package.json), else zero config. `loadConfig` from the project's folder
+* finds its own config and the package's the same way. CLI flags that apply to every project
+* carry over.
 */
 function loadProjectConfig(dir, workspaceRoot, rootConfigFile, options) {
 	const shared = {
@@ -155,7 +156,7 @@ function loadProjectConfig(dir, workspaceRoot, rootConfigFile, options) {
 		root: dir
 	}, { packages });
 	const lookup = findDesignSystemPackage(dir, packages);
-	if (lookup?.found || lookup?.problems.length) return loadConfigWith({
+	if (lookup?.problems.length) return loadConfigWith({
 		...shared,
 		root: dir
 	}, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "onsystem",
-  "version": "0.9.1",
+  "version": "0.10.0",
   "mcpName": "io.github.dgesteves/onsystem",
   "description": "Keeps coding agents on your design system: catches palette colors, native elements and APIs your system lacks, at every edit and pull request, with the fix. Set it up once in your design-system package; every app in your monorepo gets it.",
   "keywords": [

package/schema.json

@@ -7,6 +7,10 @@
     "$schema": {
       "type": "string"
     },
+    "extends": {
+      "description": "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.",
+      "type": "boolean"
+    },
     "components": {
       "description": "Globs for component source files, relative to the root.",
       "anyOf": [
@@ -103,7 +107,7 @@
       "type": "string"
     },
     "importPath": {
-      "description": "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.",
+      "description": "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.",
       "type": "string"
     },
     "elements": {