onsystem 0.10.3 → 0.11.1

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
-import { $ as DEFAULT_TOKENS, A as unrecordedRules, At as relativePath, B as statusKinds, C as countBaseline, D as pruneBaseline, Dt as isInside, E as onLines, Et as SCRIPT_FILE, It as unique, J as ConfigError, L as toDesignMd, M as writeBaseline, O as readBaseline, Ot as matchesGlob, Pt as plural, R as toDtcg, Rt as readProjectConfig, S as applyBaseline, St as isDesignSystemName, T as goneFiles, Y as DEFAULT_DOCS, _ as formatDiagnostics, _t as PACKAGE_FIELD, b as BASELINE_FILE, bt as detectProject, c as silentLogger, et as FALLBACK_TOKENS, g as escapeData, gt as notReadYet, h as uncheckedNotice, ht as libraryTitle, i as componentFiles, j as updateBaseline, jt as toPosix, k as rulesRun, l as stderrLogger, o as loadDesignSystem, ot as excludedBy, q as CONFIG_FILES, rt as RULE_IDS, s as tokenFiles, tt as LEGACY_CONFIG_FILES, ut as rulesFor, v as NAME, w as findMoves, x as LEGACY_BASELINE_FILE, y as VERSION, yt as declaredConfig } from "./design-system-7wZoJsMm.js";
-import { a as notReadNotices, i as missingDependencies, o as explainProject, s as librariesLeftOut, t as serveStdio } from "./stdio-B31hp2UZ.js";
-import { r as loadTarget } from "./workspace-C5pMS6Xv.js";
+import { $ as DEFAULT_TOKENS, A as unrecordedRules, At as relativePath, B as statusKinds, C as countBaseline, D as pruneBaseline, Dt as isInside, E as onLines, Et as SCRIPT_FILE, It as unique, J as ConfigError, L as toDesignMd, M as writeBaseline, O as readBaseline, Ot as matchesGlob, Pt as plural, R as toDtcg, Rt as readProjectConfig, S as applyBaseline, St as isDesignSystemName, T as goneFiles, Y as DEFAULT_DOCS, _ as formatDiagnostics, _t as PACKAGE_FIELD, b as BASELINE_FILE, bt as detectProject, c as silentLogger, et as FALLBACK_TOKENS, g as escapeData, gt as notReadYet, h as uncheckedNotice, ht as libraryTitle, i as componentFiles, j as updateBaseline, jt as toPosix, k as rulesRun, l as stderrLogger, o as loadDesignSystem, ot as excludedBy, q as CONFIG_FILES, rt as RULE_IDS, s as tokenFiles, tt as LEGACY_CONFIG_FILES, ut as rulesFor, v as NAME, w as findMoves, x as LEGACY_BASELINE_FILE, y as VERSION, yt as declaredConfig } from "./design-system-D7ppJYbd.js";
+import { a as notReadNotices, i as missingDependencies, o as explainProject, s as librariesLeftOut, t as serveStdio } from "./stdio-c3Y34to3.js";
+import { r as loadTarget } from "./workspace-DUgzMLGs.js";
 import fs from "node:fs";
 import path from "node:path";
 import { escapePath, glob } from "tinyglobby";

package/dist/{design-system-7wZoJsMm.js → design-system-D7ppJYbd.js}

@@ -678,7 +678,8 @@ const APP_STYLESHEETS = [
 *    from a registry is read through its `exports` alone, when they point at the
 *    component sources it publishes, not from `dist/` back to `src/`.
 * 4. A flat folder of components that wrap a primitives library, the way React
-*    Aria's Tailwind starter ships them (`src/Button.tsx`, `src/Checkbox.tsx`).
+*    Aria's Tailwind starter ships them (`src/Button.tsx`, `src/Checkbox.tsx`), or the
+*    same files copied into an app's `src/components/`, `components/` or `app/components/`.
 *
 * With more than one design system, the one the root's code imports most comes first
 * (`designSystems`). A candidate whose globs match no file is skipped. Returns undefined
@@ -818,7 +819,7 @@ function detectProject(root, tsconfig, trace, declared, packages = new PackageFi
 		};
 	}
 	let flatWhy = "no package.json";
-	const flat = own ? fromFlatFolder(root, own, (r) => {
+	const flat = own ? fromFlatFolder(root, own, "src", (r) => {
 		flatWhy = r;
 	}) : void 0;
 	if (flat && matchesAny(root, flat)) {
@@ -826,6 +827,19 @@ function detectProject(root, tsconfig, trace, declared, packages = new PackageFi
 		return detection(root, [flat], false, flat.source);
 	}
 	step("a flat src/ of components", false, flatWhy);
+	if (!own || !primitivesDependencies(own).length) return void 0;
+	for (const folder of COMPONENT_FOLDERS) {
+		if (!fs.existsSync(path.join(root, folder))) continue;
+		let why = "";
+		const inFolder = fromFlatFolder(root, own, folder, (r) => {
+			why = r;
+		});
+		if (inFolder && matchesAny(root, inFolder)) {
+			step(`a flat ${folder}/ of components`, true, inFolder.source);
+			return detection(root, [inFolder], true, inFolder.source);
+		}
+		step(`a flat ${folder}/ of components`, false, why || "its components match no file");
+	}
 }
 /** `12 component files`, for the trace. */
 function countFiles(root, found) {
@@ -850,8 +864,11 @@ function componentGlob(root, patterns) {
 function plural(n, one, many = `${one}s`) {
 	return `${n.toLocaleString("en-US")} ${n === 1 ? one : many}`;
 }
-/** Libraries of unstyled primitives that design systems wrap. */
-const PRIMITIVES = /^(?:react-aria-components|react-aria|radix-ui|@radix-ui\/react-[\w-]+|@base-ui-components\/react|@base-ui\/react|@headlessui\/react|@ark-ui\/react)(?:\/|$)/;
+/**
+* Libraries of unstyled primitives that design systems wrap. Not Radix's icons
+* (`@radix-ui/react-icons`), which an app's own components import as much as a design system's.
+*/
+const PRIMITIVES = /^(?:react-aria-components|react-aria|radix-ui|@radix-ui\/react-(?!icons(?:\/|$))[\w-]+|@base-ui-components\/react|@base-ui\/react|@headlessui\/react|@ark-ui\/react)(?:\/|$)/;
 /** Files that make `src/` an app rather than a library: entries and route folders. */
 const APP_ENTRIES = /^(?:main|index|App|app|root|entry-client|entry-server)\.[jt]sx?$/;
 const APP_FOLDERS = /* @__PURE__ */ new Set([
@@ -859,41 +876,62 @@ const APP_FOLDERS = /* @__PURE__ */ new Set([
 	"pages",
 	"routes"
 ]);
-/** Fewer PascalCase files than this in `src/` are an app's, not a component library. */
+/** Fewer PascalCase files than this in the folder are an app's, not a component library. */
 const MIN_FLAT_COMPONENTS = 5;
 /**
-* A flat `src/` of components, as React Aria's Tailwind starter has it. It needs all of:
-* a dependency on a primitives library, no app entry (`main.tsx`, `App.tsx`) or route
-* folder in `src/`, and at least five PascalCase `.tsx`/`.jsx` files at its top level, four
-* in five of which import the primitives library. An app whose `src/` holds pages or
-* features imports its own components, not primitives, so it does not qualify.
+* An app's folders of components, read like a flat `src/` when they are one: React Aria's
+* starter copied into an app (`src/components/Button.tsx` next to `src/App.tsx`), or into a
+* Next.js app's `components/` or `app/components/`.
 */
-function fromFlatFolder(root, pkg, note = ignore) {
-	const dependencies = Object.keys({
+const COMPONENT_FOLDERS = [
+	"src/components",
+	"components",
+	"app/components"
+];
+/** The primitives libraries among a package's dependencies. */
+function primitivesDependencies(pkg) {
+	return Object.keys({
 		...asRecord(pkg.dependencies),
 		...asRecord(pkg.devDependencies),
 		...asRecord(pkg.peerDependencies)
 	}).filter((name) => PRIMITIVES.test(name));
+}
+/** `react-aria-components`, or `a primitives library (@radix-ui/react-dialog, @radix-ui/react-slot)`. */
+function primitivesNamed(dependencies) {
+	if (dependencies.length <= 1) return dependencies[0] ?? "a primitives library";
+	const shown = dependencies.slice(0, 3).join(", ");
+	const more = dependencies.length - 3;
+	return `a primitives library (${more > 0 ? `${shown} and ${String(more)} more` : shown})`;
+}
+/**
+* A flat folder of components, as React Aria's Tailwind starter has `src/`. It needs all of:
+* a dependency on a primitives library, at least five PascalCase `.tsx`/`.jsx` files at the
+* folder's top level, four in five of which import the primitives library, and, for `src/`,
+* no app entry (`main.tsx`, `App.tsx`) or route folder in it. An app whose folder holds pages
+* or features imports its own components, not primitives, so it does not qualify.
+*/
+function fromFlatFolder(root, pkg, folder, note = ignore) {
+	const dependencies = primitivesDependencies(pkg);
 	if (!dependencies.length) {
 		note("no dependency on a primitives library (React Aria, Radix, Base UI, Headless UI, Ark UI)");
 		return;
 	}
-	const dir = path.join(root, "src");
+	const dir = path.join(root, folder);
 	let entries;
 	try {
 		entries = fs.readdirSync(dir, { withFileTypes: true });
 	} catch {
-		note("no src/ folder");
+		note(`no ${folder}/ folder`);
 		return;
 	}
-	const app = entries.find((e) => e.isFile() && APP_ENTRIES.test(e.name) || e.isDirectory() && APP_FOLDERS.has(e.name));
+	const app = folder === "src" ? entries.find((e) => e.isFile() && APP_ENTRIES.test(e.name) || e.isDirectory() && APP_FOLDERS.has(e.name)) : void 0;
 	if (app) {
 		note(`src/${app.name} makes src/ an app`);
 		return;
 	}
 	const files = entries.filter((e) => e.isFile() && /^[A-Z][A-Za-z0-9]*\.[jt]sx$/.test(e.name)).map((e) => e.name);
 	if (files.length < MIN_FLAT_COMPONENTS) {
-		note(`${plural(files.length, "PascalCase .tsx file")} in src/, fewer than ${MIN_FLAT_COMPONENTS}`);
+		note(`${plural(files.length, "PascalCase .tsx file")} in ${folder}/, fewer than ${MIN_FLAT_COMPONENTS}`);
 		return;
 	}
 	const libraries = /* @__PURE__ */ new Map();
@@ -914,17 +952,17 @@ function fromFlatFolder(root, pkg, note = ignore) {
 		for (const library of used) libraries.set(library, (libraries.get(library) ?? 0) + 1);
 	}
 	if (wrapping * 5 < files.length * 4) {
-		note(`${wrapping} of ${files.length} files in src/ import ${dependencies[0] ?? "a primitives library"}, fewer than four in five`);
+		note(`${wrapping} of ${files.length} files in ${folder}/ import ${primitivesNamed(dependencies)}, fewer than four in five`);
 		return;
 	}
 	const library = [...libraries].sort((a, b) => b[1] - a[1])[0]?.[0] ?? dependencies[0] ?? "";
-	const stylesheet = STYLESHEETS.map((f) => path.join(root, f)).find((f) => fs.existsSync(f));
+	const stylesheet = folder === "src" ? STYLESHEETS.map((f) => path.join(root, f)).find((f) => fs.existsSync(f)) : void 0;
 	return {
-		components: ["src/*.{tsx,jsx}"],
+		components: [`${folder}/*.{tsx,jsx}`],
 		tokens: stylesheet ? [escapePath(relativePath(root, stylesheet))] : [],
 		imports: [],
 		dirs: [dir],
-		source: `src/ (${String(files.length)} components wrapping ${library})`
+		source: `${folder}/ (${String(files.length)} components wrapping ${library})`
 	};
 }
 function detection(root, found, withDefaults, source) {
@@ -8146,21 +8184,29 @@ function toDesignMd(tokens, options) {
 		const list = tokens.filter((t) => t.category === section.category);
 		if (!list.length) continue;
 		if (section.key) {
-			const values = {};
+			const values = /* @__PURE__ */ new Map();
+			let steps;
 			for (const token of list) {
+				if (isSpacingUnit(token)) {
+					steps = spacingSteps(token, lookup);
+					continue;
+				}
 				const key = keys.get(token);
 				if (key === void 0) continue;
 				const target = token.aliasOf ? byName.get(token.aliasOf) : void 0;
-				const targetKey = target?.category === token.category && frontMatterValue(target, section.key, lookup) !== void 0 ? keys.get(target) : void 0;
+				const targetKey = section.key !== "typography" && target?.category === token.category && !isSpacingUnit(target) && frontMatterValue(target, section.key, lookup) !== void 0 ? keys.get(target) : void 0;
 				const value = targetKey === void 0 ? frontMatterValue(token, section.key, lookup) : `{${section.key}.${targetKey}}`;
 				if (value === void 0) continue;
-				if (key in values) {
+				if (values.has(key)) {
 					warnings.push(`${token.name} is left out of the front matter: another token has its key`);
 					continue;
 				}
-				values[key] = value;
+				values.set(key, value);
 			}
-			if (Object.keys(values).length) sections[section.key] = values;
+			for (const [key, value] of steps ?? []) if (!values.has(key)) values.set(key, value);
+			const step = (key) => Number.isFinite(Number(key)) ? Number(key) : Infinity;
+			const ordered = steps ? new Map([...values].sort(([a], [b]) => step(a) - step(b) || 0)) : values;
+			if (ordered.size) sections[section.key] = ordered;
 		}
 		body.push("", `## ${section.heading}`, "", section.intro, "", ...table(list, keys));
 	}
@@ -8180,6 +8226,59 @@ function designKeys(tokens) {
 	}
 	return out;
 }
+/** Tailwind's spacing unit, `--spacing`, which `p-4` takes 4 times. */
+function isSpacingUnit(token) {
+	return token.category === "spacing" && token.tailwind === "";
+}
+/** The steps of Tailwind's default spacing scale, `p-0.5` to `p-96`, in spacing units. */
+const SPACING_STEPS = [
+	.5,
+	1,
+	1.5,
+	2,
+	2.5,
+	3,
+	3.5,
+	4,
+	5,
+	6,
+	7,
+	8,
+	9,
+	10,
+	11,
+	12,
+	14,
+	16,
+	20,
+	24,
+	28,
+	32,
+	36,
+	40,
+	44,
+	48,
+	52,
+	56,
+	60,
+	64,
+	72,
+	80,
+	96
+];
+/**
+* Tailwind's spacing unit as the steps it makes: `"4": 1rem` for `p-4`. A DESIGN.md has no
+* multiplier: a reader takes each spacing entry as a step, so the unit alone (`base: 0.25rem`)
+* would make 4px the only one.
+*/
+function spacingSteps(token, lookup) {
+	const plain = PLAIN_LENGTH.exec(token.value.trim());
+	const [amount, unit] = plain ? [Number(plain[1]), plain[2] ?? "px"] : [evaluateLength(token.value, lookup), "px"];
+	const steps = /* @__PURE__ */ new Map();
+	if (amount === void 0 || !Number.isFinite(amount) || amount <= 0) return steps;
+	for (const n of SPACING_STEPS) steps.set(String(n), `${round(n * amount)}${unit}`);
+	return steps;
+}
 function frontMatterValue(token, key, lookup) {
 	const value = token.value.trim();
 	switch (key) {
@@ -8343,21 +8442,25 @@ function beforeV4(range) {
 /**
 * DTCG files and the CSS generated from them often describe the same tokens.
 * Merge entries that share a custom property: keep the DTCG name and
-* description, and add the Tailwind mapping from CSS.
+* description, and add the Tailwind mapping from CSS. A token without one (a
+* `@theme inline` value, `rounded-sm`) merges with the token of its name and
+* Tailwind key, such as the one a DTCG file exported from the stylesheet has.
 */
 function mergeTokens(tokens) {
 	const overridden = new Set(tokens.filter((t) => t.origin !== "tailwind-default").map((t) => themeKey(t)));
-	const byVar = /* @__PURE__ */ new Map();
+	const byKey = /* @__PURE__ */ new Map();
 	const out = [];
 	for (const token of tokens) {
 		if (token.origin === "tailwind-default" && overridden.has(themeKey(token))) continue;
-		const existing = token.cssVar ? byVar.get(token.cssVar) : void 0;
+		const key = token.cssVar ?? (token.tailwind === void 0 ? void 0 : `${token.name}:${token.tailwind}`);
+		const existing = key === void 0 ? void 0 : byKey.get(key);
 		if (!existing) {
-			if (token.cssVar) byVar.set(token.cssVar, token);
+			if (key !== void 0) byKey.set(key, token);
 			out.push(token);
 			continue;
 		}
 		if (existing.tailwind === void 0 && token.tailwind !== void 0) existing.tailwind = token.tailwind;
+		if (existing.category === "other" && token.category !== "other") existing.category = token.category;
 		existing.usage = [.../* @__PURE__ */ new Set([...token.usage, ...existing.usage])];
 		existing.description ??= token.description;
 		if (token.modes) existing.modes = {
@@ -12243,7 +12346,7 @@ function isObject(value) {
 // package.json
 var name = "onsystem";
 // src/version.ts
-const VERSION = "0.10.3";
+const VERSION = "0.11.1";
 const NAME = name;
 // src/lint/sarif.ts
 const SCHEMA = "https://docs.oasis-open.org/sarif/sarif/v2.1.0/errata01/os/schemas/sarif-schema-2.1.0.json";

package/dist/eslint-worker.d.ts

@@ -31,4 +31,6 @@ export interface Call {
   signal: Int32Array;
   port: MessagePort;
 }
+/** Resolves when the looks under way have ended. Nothing waits on them but tests. */
+export declare function looking(): Promise<unknown>;
 export declare function load(request: LoadRequest): Promise<LoadResponse>;

package/dist/eslint-worker.js

@@ -1,5 +1,6 @@
-import { At as relativePath, i as componentFiles, ot as excludedBy, r as buildModel } from "./design-system-7wZoJsMm.js";
-import { r as loadTarget } from "./workspace-C5pMS6Xv.js";
+import { At as relativePath, a as fingerprint, i as componentFiles, ot as excludedBy, r as buildModel } from "./design-system-D7ppJYbd.js";
+import { r as loadTarget } from "./workspace-DUgzMLGs.js";
+import { createHash } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
 import { parentPort } from "node:worker_threads";
@@ -8,13 +9,25 @@ import { parentPort } from "node:worker_threads";
 * The ESLint plugin's loader, in a worker thread. ESLint rules run synchronously, and finding a
 * project's design system does not (config files written in code, globs, the extraction
 * cache), so the plugin asks this worker and waits for the answer (see `bridge.ts`).
+*
+* The worker keeps what it loaded and answers from it at once. Once that is two seconds old, the
+* next lint starts a look at the project again (its config, then its design system's files) in
+* the background, and the lints after the look get what it found. Waiting for the look instead
+* held up every lint after a pause in an editor for as long as the look took, which grows with
+* the design system.
 */
 /** What the configs said (a design-system package's skipped, or its paths ignored), each said once. */
 const warned = /* @__PURE__ */ new Set();
-/** How long a loaded design system is trusted before its files are looked at again. */
+/** How long what a look found is used before a lint starts the next look. */
 const FRESH_MS = 2e3;
+/** By where ESLint runs and its settings. */
 const targets = /* @__PURE__ */ new Map();
+/**
+* By target and project root: two targets can reach the same project with configs of their own
+* (runs from two folders, two ESLint configs), and neither may be answered with the other's.
+*/
 const projects = /* @__PURE__ */ new Map();
+const looks = /* @__PURE__ */ new Set();
 function realPath(file) {
 	try {
 		return fs.realpathSync.native(file);
@@ -22,46 +35,122 @@ function realPath(file) {
 		return file;
 	}
 }
-async function targetFor({ cwd, root, config }) {
-	const key = JSON.stringify([
-		cwd,
-		root,
-		config
-	]);
-	const cached = targets.get(key);
-	if (cached && Date.now() - cached.at < FRESH_MS) return cached.target;
-	const target = loadTarget({
+function loadTargetFor({ cwd, root, config }) {
+	return loadTarget({
 		cwd,
 		root: root === void 0 ? void 0 : path.resolve(cwd, root),
 		config: config === void 0 ? void 0 : path.resolve(cwd, config)
 	});
-	targets.set(key, {
+}
+function keep(target) {
+	target.catch(() => void 0);
+	return {
 		at: Date.now(),
 		target
+	};
+}
+/** The config a file is checked with: its own project's, from a monorepo root. */
+async function configFor(target, file) {
+	return target.workspace ? (await target.workspace.projectFor(file)).config : target.config;
+}
+function versionOf(key, config) {
+	return createHash("sha256").update(key).update(JSON.stringify(config)).digest("hex");
+}
+async function build(config) {
+	const { model, key = String(Date.now()), dependencies = [] } = await buildModel(config, { cache: true });
+	const own = new Set((await componentFiles(config)).map(realPath));
+	return {
+		at: Date.now(),
+		key,
+		dependencies,
+		version: versionOf(key, config),
+		config,
+		model,
+		own
+	};
+}
+/**
+* `project` for `config` as the files are now: the same model when nothing it is built from has
+* changed (a config edit that only changes rules, or no change at all), else a new build.
+*/
+async function rebuild(project, config) {
+	if (await fingerprint(config, project.dependencies) !== project.key) return build(config);
+	const { key, dependencies, model, own } = project;
+	return {
+		at: Date.now(),
+		key,
+		dependencies,
+		version: versionOf(key, config),
+		config,
+		model,
+		own
+	};
+}
+/**
+* Runs a look in the background, held in `looks` until it ends. It starts on a later turn of the
+* event loop, after the lint that started it has its answer: the start of a look (finding the
+* project, reading its config, listing the design system's files) runs synchronously, and run at
+* once it held up that answer for as long.
+*/
+function background(look) {
+	const running = new Promise((resolve) => setImmediate(resolve)).then(look).catch(() => void 0).finally(() => looks.delete(running));
+	looks.add(running);
+	return running;
+}
+function projectKey(key, config) {
+	return JSON.stringify([key, config.root]);
+}
+/** A build that fails drops the project, so that the next lint builds it again and says why. */
+function lookAtProject(slot, project, config) {
+	project.looking = background(async () => {
+		try {
+			projects.set(slot, await rebuild(project, config));
+		} catch (error) {
+			if (projects.get(slot) === project) projects.delete(slot);
+			throw error;
+		}
+	});
+	return project.looking;
+}
+function lookAtTarget(key, kept, request) {
+	kept.looking = background(async () => {
+		const loading = loadTargetFor(request);
+		await loading.catch(() => void 0);
+		targets.set(key, keep(loading));
+		const config = await configFor(await loading, request.file);
+		const slot = projectKey(key, config);
+		const project = projects.get(slot);
+		if (project && !project.looking) await lookAtProject(slot, project, config);
 	});
-	return target;
+	return kept.looking;
+}
+/** Resolves when the looks under way have ended. Nothing waits on them but tests. */
+function looking() {
+	return Promise.all(looks);
 }
 async function load(request) {
-	const target = await targetFor(request);
-	const config = target.workspace ? (await target.workspace.projectFor(request.file)).config : target.config;
+	const key = JSON.stringify([
+		request.cwd,
+		request.root,
+		request.config
+	]);
+	let kept = targets.get(key);
+	if (!kept) {
+		kept = keep(loadTargetFor(request));
+		targets.set(key, kept);
+	} else if (!kept.looking && Date.now() - kept.at >= FRESH_MS) lookAtTarget(key, kept, request);
+	const config = await configFor(await kept.target, request.file);
 	for (const text of config.warnings ?? []) {
 		if (warned.has(text)) continue;
 		warned.add(text);
 		process.stderr.write(`onsystem: ${text}\n`);
 	}
-	let project = projects.get(config.root);
-	if (!project || Date.now() - project.at >= FRESH_MS) {
-		const { model, key } = await buildModel(config, { cache: true });
-		const own = new Set((await componentFiles(config)).map(realPath));
-		project = {
-			at: Date.now(),
-			version: key ?? String(Date.now()),
-			config,
-			model,
-			own
-		};
-		projects.set(config.root, project);
-	}
+	const slot = projectKey(key, config);
+	let project = projects.get(slot);
+	if (!project) {
+		project = await build(config);
+		projects.set(slot, project);
+	} else if (!kept.looking && !project.looking && (project.config !== config || Date.now() - project.at >= FRESH_MS)) lookAtProject(slot, project, config);
 	const relative = relativePath(config.root, request.file);
 	const excluded = excludedBy(config, relative, { includeTests: true });
 	if (excluded) return { skip: `excluded by "${excluded}"` };
@@ -89,4 +178,4 @@ parentPort?.on("message", ({ request, signal, port }) => {
 		reply({ error: error.message });
 	});
 });
-export { load };
+export { load, looking };

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-7wZoJsMm.js";
+import { At as relativePath, N as RULES, Q as DEFAULT_TEST_FOLDERS, X as DEFAULT_SEVERITY, Z as DEFAULT_TEST_EXCLUDE, m as checkSource, rt as RULE_IDS, t as DesignSystem, ut as rulesFor, v as NAME, y as VERSION } from "./design-system-D7ppJYbd.js";
 import path from "node:path";
 import { MessageChannel, Worker, receiveMessageOnPort } from "node:worker_threads";
 // src/eslint/bridge.ts
@@ -51,7 +51,8 @@ function loadSync(request) {
 * working directory), with the project's config: its `rules` and `overrides` turn rules off
 * per file, `// onsystem-disable-*` comments suppress findings, and the files `check .` leaves
 * out (the config's `exclude`, the design system's own components) are not checked. ESLint's
-* config sets each rule's severity.
+* config sets each rule's severity, and can set a rule's options (`allow`) over the project's.
+* `onsystem/suppression` reports a misspelled rule in a suppression comment, as check does.
 */
 const RULES_PAGE = "https://onsystem.vercel.app/rules";
 /** Design systems by project root, at the version the loader last reported. */
@@ -101,7 +102,25 @@ function run(cwd, file, text, settings) {
 	if (result.skipped) return { skipped: true };
 	return {
 		result,
-		fromSystem: (specifier) => ds.lint.isDesignSystemImport(specifier, relative)
+		fromSystem: (specifier) => ds.lint.isDesignSystemImport(specifier, relative),
+		checkWith(id, options) {
+			const own = rulesFor(ds.config, relative)[id];
+			const off = {
+				severity: "off",
+				options: {}
+			};
+			const rules = Object.fromEntries(RULE_IDS.map((rule) => [rule, rule === id ? {
+				...own,
+				options: {
+					...own.options,
+					...options
+				}
+			} : off]));
+			return checkSource(text, ds.lint, {
+				filename: relative,
+				rules
+			});
+		}
 	};
 }
 /**
@@ -153,27 +172,45 @@ function typeOnly(def) {
 	const kind = (node) => node?.importKind;
 	return def.type === "ImportBinding" && (kind(def.node) === "type" || kind(def.parent) === "type");
 }
+/** A rule's options in ESLint's config, as in onsystem.config.json: `['error', { allow: ['#fff'] }]`. */
+const OPTIONS_SCHEMA = [{
+	type: "object",
+	properties: { allow: {
+		type: "array",
+		items: { type: "string" }
+	} },
+	additionalProperties: false
+}];
+/**
+* Check's misspelled rule names in `// onsystem-disable-*` comments, which suppress nothing. A rule
+* of its own, so that it is a warning, as check reports it, and can be turned off like the others.
+*/
+const SUPPRESSION = "suppression";
 function createRule(id, description) {
+	const suppression = id === SUPPRESSION;
 	return {
 		meta: {
 			type: "problem",
 			docs: {
 				description,
-				url: `${RULES_PAGE}#${id}`
+				url: `${RULES_PAGE}#${suppression ? "suppressing-findings" : id}`
+			},
+			...suppression ? {} : {
+				fixable: "code",
+				hasSuggestions: true
 			},
-			fixable: "code",
-			hasSuggestions: true,
-			schema: []
+			schema: suppression ? [] : OPTIONS_SCHEMA
 		},
 		create(context) {
 			const file = path.resolve(context.cwd, context.filename);
 			const settings = context.settings.onsystem ?? {};
+			const options = context.options?.[0];
 			return { "Program:exit"(node) {
 				const pass = passFor(context, file, settings);
 				const { outcome } = pass;
 				if ("skipped" in outcome) return;
 				if ("error" in outcome) {
-					if (pass.reported) return;
+					if (suppression || pass.reported) return;
 					pass.reported = true;
 					context.report({
 						node,
@@ -181,7 +218,8 @@ function createRule(id, description) {
 					});
 					return;
 				}
-				for (const d of outcome.result.diagnostics) {
+				const { diagnostics } = !suppression && options && Object.keys(options).length ? outcome.checkWith(id, options) : outcome.result;
+				for (const d of diagnostics) {
 					if (d.ruleId !== id) continue;
 					const edits = d.fix ?? [];
 					const fix = (fixer) => edits.map((e) => fixer.replaceTextRange(e.range, e.text));
@@ -209,6 +247,7 @@ function createRule(id, description) {
 	};
 }
 const rules = Object.fromEntries(RULES.map((rule) => [rule.id, createRule(rule.id, rule.description)]));
+rules[SUPPRESSION] = createRule(SUPPRESSION, "Suppression comments must name rules that exist.");
 const plugin = {
 	meta: {
 		name: NAME,
@@ -218,14 +257,17 @@ const plugin = {
 	configs: {}
 };
 /**
-* Every rule at its default severity, for `.tsx` and `.jsx` files other than tests and stories,
-* which `check` also leaves out unless asked (`--include-tests`).
+* Every rule at its default severity, and `suppression` as a warning, for `.tsx` and `.jsx` files
+* other than tests and stories, which `check` also leaves out unless asked (`--include-tests`).
 */
 plugin.configs.recommended = {
 	name: "onsystem/recommended",
 	files: ["**/*.{tsx,jsx}"],
 	ignores: [DEFAULT_TEST_EXCLUDE, DEFAULT_TEST_FOLDERS],
 	plugins: { onsystem: plugin },
-	rules: Object.fromEntries(RULES.map((rule) => [`onsystem/${rule.id}`, DEFAULT_SEVERITY[rule.id]]))
+	rules: {
+		...Object.fromEntries(RULES.map((rule) => [`onsystem/${rule.id}`, DEFAULT_SEVERITY[rule.id]])),
+		[`onsystem/${SUPPRESSION}`]: "warn"
+	}
 };
 export { plugin as default };

package/dist/index.d.ts

@@ -157,7 +157,9 @@ export declare function loadTokens(root: string, sources: TokenSource[]): Promis
 /**
  * DTCG files and the CSS generated from them often describe the same tokens.
  * Merge entries that share a custom property: keep the DTCG name and
- * description, and add the Tailwind mapping from CSS.
+ * description, and add the Tailwind mapping from CSS. A token without one (a
+ * `@theme inline` value, `rounded-sm`) merges with the token of its name and
+ * Tailwind key, such as the one a DTCG file exported from the stylesheet has.
  */
 export declare function mergeTokens(tokens: Token[]): Token[];
 interface ColorCandidate {

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 defineConfig, ct as loadConfig, f as searchComponents, ft as findVariantDefinitions, it as configJsonSchema, m as checkSource, n as DesignSystemHost, o as loadDesignSystem, p as applyFixes, r as buildModel, rt as RULE_IDS, t as DesignSystem, y as VERSION } from "./design-system-7wZoJsMm.js";
-import { n as INSTRUCTIONS, r as createServer, t as serveStdio } from "./stdio-B31hp2UZ.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, at as defineConfig, ct as loadConfig, f as searchComponents, ft as findVariantDefinitions, it as configJsonSchema, m as checkSource, n as DesignSystemHost, o as loadDesignSystem, p as applyFixes, r as buildModel, rt as RULE_IDS, t as DesignSystem, y as VERSION } from "./design-system-D7ppJYbd.js";
+import { n as INSTRUCTIONS, r as createServer, t as serveStdio } from "./stdio-c3Y34to3.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-B31hp2UZ.js → stdio-c3Y34to3.js}

@@ -1,5 +1,5 @@
-import { At as relativePath, Ct as isWorkspaceRoot, Dt as isInside, Et as SCRIPT_FILE, Ft as truncate, It as unique, J as ConfigError, Lt as defaultProjectConfig, Mt as closest, Nt as json, Pt as plural, X as DEFAULT_SEVERITY, bt as detectProject, ct as loadConfig, d as descriptionOf, dt as formatPx, f as searchComponents, gt as notReadYet, h as uncheckedNotice, ht as libraryTitle, kt as pathOf, mt as LIBRARY_IDS, n as DesignSystemHost, ot as excludedBy, pt as LIBRARIES, q as CONFIG_FILES, r as buildModel, rt as RULE_IDS, tt as LEGACY_CONFIG_FILES, u as buildSearchIndex, v as NAME, xt as findDesignSystemPackage, y as VERSION, z as TOKEN_CATEGORIES } from "./design-system-7wZoJsMm.js";
-import { i as projectDirOf, n as hasProjectMarker, r as loadTarget, t as findProjectRoot } from "./workspace-C5pMS6Xv.js";
+import { At as relativePath, Ct as isWorkspaceRoot, Dt as isInside, Et as SCRIPT_FILE, Ft as truncate, It as unique, J as ConfigError, Lt as defaultProjectConfig, Mt as closest, Nt as json, Pt as plural, X as DEFAULT_SEVERITY, bt as detectProject, ct as loadConfig, d as descriptionOf, dt as formatPx, f as searchComponents, gt as notReadYet, h as uncheckedNotice, ht as libraryTitle, kt as pathOf, mt as LIBRARY_IDS, n as DesignSystemHost, ot as excludedBy, pt as LIBRARIES, q as CONFIG_FILES, r as buildModel, rt as RULE_IDS, tt as LEGACY_CONFIG_FILES, u as buildSearchIndex, v as NAME, xt as findDesignSystemPackage, y as VERSION, z as TOKEN_CATEGORIES } from "./design-system-D7ppJYbd.js";
+import { i as projectDirOf, n as hasProjectMarker, r as loadTarget, t as findProjectRoot } from "./workspace-DUgzMLGs.js";
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";

package/dist/{workspace-C5pMS6Xv.js → workspace-DUgzMLGs.js}

@@ -1,4 +1,4 @@
-import { At as relativePath, Ct as isWorkspaceRoot, Dt as isInside, Tt as workspacePatterns, ct as loadConfig, i as componentFiles, lt as loadConfigWith, nt as PROJECT_MARKERS, st as hasOwnConfig, vt as PackageFinder, wt as workspacePackageDirs, xt as findDesignSystemPackage } from "./design-system-7wZoJsMm.js";
+import { At as relativePath, Ct as isWorkspaceRoot, Dt as isInside, Tt as workspacePatterns, ct as loadConfig, i as componentFiles, lt as loadConfigWith, nt as PROJECT_MARKERS, st as hasOwnConfig, vt as PackageFinder, wt as workspacePackageDirs, xt as findDesignSystemPackage } from "./design-system-D7ppJYbd.js";
 import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "onsystem",
-  "version": "0.10.3",
+  "version": "0.11.1",
   "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": [