onsystem 0.10.1 → 0.10.3

package/dist/{stdio-BK2kMN1x.js → stdio-B31hp2UZ.js}

@@ -1,5 +1,5 @@
-import { Et as isInside, Ft as unique, It as defaultProjectConfig, Mt as json, Nt as plural, Ot as pathOf, Pt as truncate, Tt as SCRIPT_FILE, 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, jt as closest, kt as relativePath, 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-CPH4C7-1.js";
-import { n as hasProjectMarker, r as loadTarget, t as findProjectRoot } from "./workspace-BINqxi7p.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-7wZoJsMm.js";
+import { i as projectDirOf, n as hasProjectMarker, r as loadTarget, t as findProjectRoot } from "./workspace-C5pMS6Xv.js";
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -7,7 +7,7 @@ import * as z from "zod";
 import fsp from "node:fs/promises";
 import { McpServer, ResourceTemplate } from "@modelcontextprotocol/server";
 import { serveStdio } from "@modelcontextprotocol/server/stdio";
-//#region src/explain.ts
+// src/explain.ts
 /**
 * What `inspect --explain` says about one project: every candidate zero config looked
 * at and why each was taken or not, the config it resolved to, tokens whose value did
@@ -19,8 +19,11 @@ 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.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 {
+	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`);
+		const unpublished = unpublishedComponents(ds);
+		if (unpublished) out(`  ${unpublished}`);
+	} else {
 		const steps = [];
 		detectProject(config.root, config.tsconfig, steps, config.designSystemPackage);
 		for (const step of steps) out(`  ${(step.accepted ? "found" : "no").padEnd(6)} ${step.candidate}: ${step.reason}`);
@@ -85,6 +88,22 @@ function explainProject(ds, cwd, indent = "") {
 	}
 	return lines;
 }
+/**
+* Why a project that takes on the config of a design-system package installed in node_modules
+* knows none of its components: the package publishes neither their sources nor their type
+* declarations, or `"libraries": false` turns off the declarations it publishes. The one message
+* for it, where a project without components would otherwise be told to check the "components"
+* globs. Undefined otherwise.
+*/
+function unpublishedComponents(ds) {
+	const declared = ds.config.designSystemPackage;
+	if (!declared?.installed || !ds.config.inherits || ds.model.components.length) return void 0;
+	const tokens = ds.model.tokens.length ? " The token rules still check against the tokens it publishes." : "";
+	const name = pathOf(declared.name);
+	const see = "See https://onsystem.vercel.app/docs/design-system-packages#what-apps-get";
+	if (ds.config.librariesOff?.some((library) => library.package === declared.name)) return `${name} publishes no component sources, and "libraries": false in the config turns off the type declarations it publishes, so its components are unknown here and the component rules did not run: set "libraries" to [], which reads its declarations and no library, or remove it.${tokens} ${see}`;
+	return `${name} publishes neither its component sources nor their type declarations, so its components are unknown here and the component rules did not run: ask its team to add its sources to "files" in its package.json, or to publish type declarations.${tokens} ${see}`;
+}
 /** Why a library the project depends on is not read: `left out by "libraries" in onsystem.config.json`. */
 function librariesLeftOut(config, cwd) {
 	return `left out by "libraries" in ${config.configFile ? display(cwd, config.configFile) : "the config"}`;
@@ -151,8 +170,7 @@ function packageSteps(config, cwd) {
 		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
-//#region src/not-read.ts
+// src/not-read.ts
 const LIMITS_DOCS = "https://onsystem.vercel.app/docs/how-it-works#limits";
 /**
 * What `check` and `check_ui` could not read, said after the results as the notice for missing
@@ -228,8 +246,7 @@ function listOf$2(items, max = 3) {
 	if (items.length <= max) return `${items.slice(0, -1).join(", ")} and ${items.at(-1) ?? ""}`;
 	return `${items.slice(0, max).join(", ")} and ${items.length - max} more`;
 }
-//#endregion
-//#region src/server/render.ts
+// src/server/render.ts
 /**
 * Tool results are read by models, so they are rendered as compact Markdown:
 * fewer tokens than JSON, and the same information. The JSON is still sent
@@ -564,8 +581,12 @@ function listTail(listed) {
 	if (listed.omitted) lines.push("", `${listed.omitted.toLocaleString("en-US")} more not shown: pass a higher \`limit\`, or a \`query\`.`);
 	return lines;
 }
-/** The shared explanation when a project has no design-system components to show. */
-function noComponentsMessage(root, project, monorepo = false) {
+/**
+* The shared explanation when a project has no design-system components to show. `reason`, when
+* known, says why instead ({@link unpublishedComponents}).
+*/
+function noComponentsMessage(root, project, monorepo = false, reason) {
+	if (reason) return answer([reason]);
 	if (monorepo) return answer([`No design-system components found in any project of this monorepo (root: ${root}). Check the "components" globs in the config. Run \`onsystem inspect\` there to see what was looked at.`]);
 	return answer([`No design-system components found${project ? ` in ${pathOf(project)}` : ""}. Check the "components" globs in the config (root: ${root}).`]);
 }
@@ -573,7 +594,7 @@ function noComponentsMessage(root, project, monorepo = false) {
 function renderComponentList(ds, project, filter = {}) {
 	const roots = ds.roots();
 	const where = project ? ` in ${pathOf(project)}` : "";
-	if (!roots.length) return noComponentsMessage(ds.root, project);
+	if (!roots.length) return noComponentsMessage(ds.root, project, false, unpublishedComponents(ds));
 	const listed = listComponents(roots, (c) => c, filter);
 	if (!listed.matched) return answer([`No components match ${filterText(filter)}${where} (${roots.length} in all). Call list_components without filters to see them.`]);
 	const marks = new Marks();
@@ -688,7 +709,7 @@ function renderAmbiguous(name, entries) {
 }
 /** get_component's answer for a name no component has, with the nearest and all of them. */
 function renderNotFound(name, guess, names, where = "") {
-	return answer([`No component named ${json(name)}${where}.` + (guess ? ` Did you mean ${json(guess)}?` : "") + ` Available: ${names.join(", ")}.`]);
+	return answer([`No component named ${json(name)}${where}.` + (guess ? ` Did you mean ${json(guess)}?` : "") + (names.length ? ` Available: ${names.join(", ")}.` : "")]);
 }
 /**
 * The build-with-design-system prompt: `task`, the steps, and what the design system has, its
@@ -1080,8 +1101,7 @@ function renderCheck(result, capped = capDiagnostics(result, Infinity), notices
 	lines.push("", result.errorCount ? "Fix every error, then run check_ui again." : "Only warnings: fix them if the design system has an equivalent.", ...after);
 	return answer(lines);
 }
-//#endregion
-//#region src/server/index.ts
+// src/server/index.ts
 const INSTRUCTIONS = `This server describes the project's design system: its React components (props, variants, parts), design tokens and usage docs, and lints UI code against it.
 When writing or changing UI in this project:
 1. Find components with search_components (by intent) or list_components.
@@ -1555,7 +1575,7 @@ function register(serve, { getDesignSystem, getProjects }) {
 		const { ds } = found;
 		const component = ds.getComponent(name);
 		if (!component) {
-			if (!ds.roots().length) return refuse(noComponentsMessage(ds.root, found.project?.dir));
+			if (!ds.roots().length) return refuse(noComponentsMessage(ds.root, found.project?.dir, false, unpublishedComponents(ds)));
 			const names = ds.roots().map((c) => c.name);
 			return refuse(renderNotFound(name, ds.suggestComponent(name), names));
 		}
@@ -1822,8 +1842,7 @@ function register(serve, { getDesignSystem, getProjects }) {
 		return prompted("Build UI with the design system", renderPrompt(task, "catalog" in found ? [...new Map(found.catalog.roots().map((e) => [e.component.name, e.component])).values()] : found.ds.roots(), "catalog" in found ? found.catalog.getTokens().map((t) => t.token) : found.ds.tokens, "catalog" in found ? found.set.dirs : void 0));
 	});
 }
-//#endregion
-//#region src/catalog.ts
+// src/catalog.ts
 /**
 * Every project's components and tokens in one list, for a workspace root when no path
 * picks a project. A component used by several projects (a design-system package) is
@@ -1965,8 +1984,7 @@ function packageOwner(root) {
 		return name;
 	};
 }
-//#endregion
-//#region src/server/projects.ts
+// src/server/projects.ts
 /**
 * A workspace root's projects for the MCP server: one `DesignSystemHost` per project,
 * created on first use and watched from then on, and the merged catalog, rebuilt when a
@@ -2025,6 +2043,7 @@ var WorkspaceProjects = class {
 		host = new DesignSystemHost(project.config, {
 			cache: this.options.cache,
 			logger: this.options.logger,
+			build: this.options.build,
 			loadConfig: () => this.workspace.configFor(project)
 		});
 		host.onChange(() => this.options.onChange?.());
@@ -2033,8 +2052,7 @@ var WorkspaceProjects = class {
 		return host;
 	}
 };
-//#endregion
-//#region src/server/stdio.ts
+// src/server/stdio.ts
 /**
 * Starts the server (on stdio unless another transport is given), for clients on
 * either protocol era: a 2026-07-28 client (stateless, `server/discover`) and a
@@ -2054,8 +2072,17 @@ var WorkspaceProjects = class {
 * project marker, or the monorepo root above that, served as if the server had been
 * started there, except that a config there is read only when it is JSON: a prompt can
 * choose the path, so a JavaScript or TypeScript config is not run. Each root found is
-* loaded once and kept; a request without an absolute path is answered from the one root
-* found so far.
+* loaded once and kept, by its real path; a request without an absolute path is answered from
+* the one root found so far. The same holds for a `--root` (or a client's root) that is no
+* project but holds projects in its folders, such as a folder of repositories, except that only
+* an absolute path in that folder is answered, from the project in it that holds the file (never
+* from a folder outside or above it), and a file in none of them from that folder, as before.
+* Links are resolved: a path, or the project it leads to, that is really outside the folder is
+* refused, a workspace in it serves only its packages that are really in it, and a project in it
+* that a link replaces while the server runs is not built again from where the link leads.
+*
+* A load that fails, such as on an invalid config, is not kept: the next request loads
+* again, so fixing the config is enough, also when it was invalid at startup.
 */
 function serveStdio$1(options) {
 	const { logger } = options;
@@ -2076,15 +2103,28 @@ function serveStdio$1(options) {
 	/**
 	* The project at `root` (the working directory when undefined), or a monorepo root's
 	* projects. `jsonConfigOnly` for a root found from a tool call's path: its configs, and those
-	* of the projects in it, are read only when they are JSON, never run.
+	* of the projects in it, are read only when they are JSON, never run. `within`: the folder of
+	* projects it was found in, for the error on a config that is not JSON, and outside which no
+	* workspace package is served, and no project or package is built.
 	*/
-	const load = async (root, jsonConfigOnly = false) => {
+	const load = async (root, jsonConfigOnly = false, within) => {
 		const configOptions = {
 			...options,
 			root,
-			jsonConfigOnly
+			jsonConfigOnly,
+			jsonConfigWithin: jsonConfigOnly ? within?.dir : void 0
 		};
-		const { config, workspace } = await loadTarget(configOptions);
+		const target = await loadTarget(configOptions);
+		const { config } = target;
+		let { workspace } = target;
+		if (workspace && within) {
+			const outside = workspace.projects.filter((p) => !isInside(within.real, realPath(p.root)));
+			if (outside.length) {
+				logger.warn(`${pathOf(workspace.root)} names workspace packages outside ${pathOf(within.dir)}, the folder the server answers for (links resolved), which it leaves out: ${outside.map((p) => pathOf(p.root)).join(", ")}. To include them, start the server with --root ${pathOf(workspace.root)}.`);
+				workspace = workspace.without(outside.map((p) => p.root));
+			}
+		}
+		const build = within ? buildWithin(within) : void 0;
 		for (const text of config.deprecations ?? []) logger.warn(text);
 		for (const text of (workspace ? workspace.warnings : config.warnings) ?? []) logger.warn(text);
 		if (workspace) {
@@ -2092,7 +2132,8 @@ function serveStdio$1(options) {
 				cache: options.cache,
 				watch: options.watch,
 				logger,
-				onChange: notify
+				onChange: notify,
+				build
 			});
 			logger.info(`monorepo root: ${workspace.projects.length} of ${workspace.projects.length + workspace.others.length} workspace packages have a design system${workspace.projects.length ? ` (${workspace.projects.map((p) => p.dir).join(", ")})` : ""}`);
 			closers.push(() => {
@@ -2104,7 +2145,8 @@ function serveStdio$1(options) {
 		const host = new DesignSystemHost(config, {
 			cache: options.cache,
 			logger,
-			loadConfig: () => loadConfig(configOptions)
+			loadConfig: () => loadConfig(configOptions),
+			build
 		});
 		host.onChange(notify);
 		if (options.watch) host.watch();
@@ -2116,44 +2158,85 @@ function serveStdio$1(options) {
 		});
 		return { host };
 	};
+	/**
+	* The roots loaded or loading, by `key` (the real path of `dir`, for a root found from a path).
+	* One that fails is logged and dropped, so the next request loads it again, and until then it
+	* is no project found.
+	*/
+	const found = /* @__PURE__ */ new Map();
+	const loadOnce = (key, dir, start) => {
+		const known = found.get(key);
+		if (known) return known.served;
+		const served = start();
+		found.set(key, {
+			dir,
+			served
+		});
+		served.catch((error) => {
+			logger.error(error.message);
+			if (found.get(key)?.served === served) found.delete(key);
+		});
+		return served;
+	};
 	let started = false;
 	/** One project for every request: the one at `root`, or the working directory. */
 	const serveOne = (root) => {
 		if (started) return;
 		started = true;
-		const served = load(root);
-		served.catch((error) => {
-			logger.error(error.message);
-		});
-		decide(() => served);
+		const dir = path.resolve(options.cwd, root ?? ".");
+		const served = () => loadOnce(dir, dir, () => load(root));
+		served();
+		decide(served);
 	};
-	/** Each request's project, from the absolute path it names. */
-	const serveByPath = () => {
+	/**
+	* Each request's project, from the absolute path it names. `within`: a folder that is no
+	* project but holds some (the `--root` or client root the server was started for), which
+	* answers for a file in none of them. Then only a path in it is answered, from a project in
+	* it: never from a folder outside or above it, links resolved, nor from a relative path, which
+	* the tools would read against whichever project answers.
+	*/
+	const serveByPath = (within) => {
 		if (started) return;
 		started = true;
-		logger.info(`${options.cwd} holds no project and the client reported no roots: finding each request's project from the absolute path it names`);
-		const found = /* @__PURE__ */ new Map();
+		const folder = within === void 0 ? void 0 : {
+			dir: within,
+			real: realPath(within)
+		};
+		const where = within ? `${pathOf(within)} holds no project of its own, only projects in its folders` : `${options.cwd} holds no project and the client reported no roots`;
+		logger.info(`${where}: finding each request's project from the absolute path it names`);
+		const askForPath = `Pass \`path\` (for check_ui with \`code\`, \`filename\`) as the absolute path of the file you are editing, and it answers from that file's project. Or start the server with --root <project folder>.`;
 		decide(async (target) => {
-			if (target !== void 0 && path.isAbsolute(target)) {
-				const dir = findProjectRoot(target);
-				if (!dir) throw new ProjectNotFoundError(`No project at or above ${target}: no folder from there up holds a package.json, components.json, project.json or onsystem config (the home folder and the filesystem root do not count). Pass the absolute path of a file in your project.`);
-				let served = found.get(dir);
-				if (!served) {
-					logger.info(`using ${dir}, the project of ${target}`);
-					served = load(dir, true);
-					served.catch((error) => {
-						logger.error(error.message);
-					});
-					found.set(dir, served);
-				}
-				return served;
+			const named = target !== void 0 && target !== "";
+			if (within && named && !path.isAbsolute(target)) throw new ProjectNotFoundError(`onsystem cannot tell which project ${pathOf(target)} is in: it is a relative path, and ${pathOf(within)} holds no project of its own, only projects in its folders. ${askForPath}`);
+			if (named && path.isAbsolute(target)) {
+				const file = path.resolve(target);
+				if (within && !isInside(within, file)) throw new ProjectNotFoundError(`${pathOf(target)} is outside ${pathOf(within)}, the folder the server answers for. Pass the absolute path of a file inside it, or start the server with --root <project folder>.`);
+				const up = findProjectRoot(file);
+				const dir = within && !(up && isInside(within, up)) ? projectDirOf(file, within) : up;
+				if (!dir) throw new ProjectNotFoundError(`No project at or above ${pathOf(target)}: no folder from there up holds a package.json, components.json, project.json or onsystem config (the home folder and the filesystem root do not count). Pass the absolute path of a file in your project.`);
+				const real = realPath(dir);
+				if (folder && !(isInside(folder.real, real) && isInside(folder.real, realPath(file)))) throw new ProjectNotFoundError(`${pathOf(target)} leads outside ${pathOf(folder.dir)}, the folder the server answers for, through a link. Pass the absolute path of a file inside it, or start the server with --root <project folder>.`);
+				if (!found.has(real)) logger.info(`using ${dir}, the project of ${target}`);
+				return loadOnce(real, dir, () => load(dir, dir !== within, folder));
 			}
 			const [only, ...others] = found.values();
-			if (only && !others.length) return only;
-			throw new ProjectNotFoundError(only ? `Requests have named files in ${found.size} projects (${[...found.keys()].join(", ")}). Pass \`path\` (for check_ui with \`code\`, \`filename\`) as the absolute path of the file you are editing, so the answer comes from its project.` : `onsystem cannot tell which project to answer for: it was started in ${options.cwd}, which holds no project, and the client reported no workspace roots. Pass \`path\` (for check_ui with \`code\`, \`filename\`) as the absolute path of the file you are editing, and it answers from that file's project. Or start the server with --root <project folder>.`);
+			if (only && !others.length) return only.served;
+			throw new ProjectNotFoundError(only ? `Requests have named files in ${found.size} projects (${[...found.values()].map((f) => pathOf(f.dir)).join(", ")}). Pass \`path\` (for check_ui with \`code\`, \`filename\`) as the absolute path of the file you are editing, so the answer comes from its project.` : within ? `onsystem cannot tell which project to answer for: ${pathOf(within)} holds no project of its own, only projects in its folders. ${askForPath}` : `onsystem cannot tell which project to answer for: it was started in ${options.cwd}, which holds no project, and the client reported no workspace roots. ${askForPath}`);
 		});
 	};
-	if (options.root !== void 0 || options.config !== void 0 || [...CONFIG_FILES, ...LEGACY_CONFIG_FILES].some((file) => fs.existsSync(path.join(options.cwd, file))) || hasProjectMarker(options.cwd)) serveOne(options.root);
+	/** Flags that describe the project themselves: the folder they apply to is the one served. */
+	const described = options.config !== void 0 || Boolean(options.components?.length || options.tokens?.length || options.docs?.length);
+	/**
+	* The project at `root` (the working directory when undefined). A folder that is no project but
+	* holds projects (a folder of repositories, which `--root ${workspaceFolder}` names when the
+	* editor has their parent open) would mix their tokens: each request is answered from its path.
+	*/
+	const serveAt = (root) => {
+		const dir = root === void 0 ? void 0 : path.resolve(options.cwd, root);
+		if (dir !== void 0 && !described && holdsOnlyProjects(dir)) serveByPath(dir);
+		else serveOne(root);
+	};
+	if (options.root !== void 0 || options.config !== void 0 || [...CONFIG_FILES, ...LEGACY_CONFIG_FILES].some((file) => fs.existsSync(path.join(options.cwd, file))) || hasProjectMarker(options.cwd)) serveAt(options.root);
 	/**
 	* When nothing else says where the project is: the working directory when flags
 	* (`--components`, `--tokens`, `--docs`) describe it, else each request's path.
@@ -2189,7 +2272,7 @@ function serveStdio$1(options) {
 					return;
 				}
 				if (root !== options.cwd) logger.info(`using client root ${root}`);
-				serveOne(root);
+				serveAt(root);
 			});
 		};
 		return server;
@@ -2206,6 +2289,49 @@ function serveStdio$1(options) {
 		await handle.close();
 	} });
 }
+/**
+* `buildModel` for a project found in the folder `within`, which refuses to build it once its
+* folder leads outside `within` (a project or workspace package replaced by a link while the
+* server watches it): that rebuild fails, so the model built from inside the folder stays.
+*/
+function buildWithin(within) {
+	return async (config, options) => {
+		if (!isInside(within.real, realPath(config.root))) throw new ConfigError(`${pathOf(config.root)} now leads outside ${pathOf(within.dir)}, the folder the server answers for, through a link: it is not read from there.`);
+		return buildModel(config, options);
+	};
+}
+/**
+* Whether `dir` is no project (no project marker, no workspace file) but a folder in it, or in one
+* of its folders, is one. Dot folders and `node_modules` are not looked in.
+*/
+function holdsOnlyProjects(dir) {
+	if (hasProjectMarker(dir) || isWorkspaceRoot(dir)) return false;
+	const folders = (from) => {
+		try {
+			return fs.readdirSync(from, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules").map((e) => path.join(from, e.name));
+		} catch {
+			return [];
+		}
+	};
+	const below = folders(dir);
+	return below.some(hasProjectMarker) || below.some((f) => folders(f).some(hasProjectMarker));
+}
+/**
+* Where `p` really is: links resolved, in the letter case the file system keeps
+* (`realpathSync.native`; plain `realpathSync` keeps the case given on macOS). A path that does
+* not exist yet, such as the `filename` of new code, from the nearest folder above it that does.
+*/
+function realPath(p) {
+	const rest = [];
+	for (let dir = path.resolve(p);;) try {
+		return path.join(fs.realpathSync.native(dir), ...rest);
+	} catch {
+		const parent = path.dirname(dir);
+		if (parent === dir) return path.resolve(p);
+		rest.unshift(path.basename(dir));
+		dir = parent;
+	}
+}
 /** First `file://` root the client reports, if it supports roots (deprecated in 2026-07-28). */
 async function clientRoot(server) {
 	if (!server.server.getClientCapabilities()?.roots) return void 0;
@@ -2217,5 +2343,4 @@ async function clientRoot(server) {
 		return;
 	}
 }
-//#endregion
 export { notReadNotices as a, missingDependencies as i, INSTRUCTIONS as n, explainProject as o, createServer as r, librariesLeftOut as s, serveStdio$1 as t };

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

@@ -1,21 +1,8 @@
-import { Ct as workspacePackageDirs, Et as isInside, St as isWorkspaceRoot, _t as PackageFinder, bt as findDesignSystemPackage, ct as loadConfigWith, i as componentFiles, kt as relativePath, ot as hasOwnConfig, q as CONFIG_FILES, st as loadConfig, tt as LEGACY_CONFIG_FILES, wt as workspacePatterns } from "./design-system-CPH4C7-1.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-7wZoJsMm.js";
 import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
-//#region src/workspace.ts
-/**
-* What marks the folder a file belongs to: the nearest one at or above it with a config,
-* a components.json, a package.json or an Nx project.json. The Claude Code hook finds a
-* file's project the same way, so `check` from a workspace root and the hook agree on
-* every file.
-*/
-const PROJECT_MARKERS = [
-	...CONFIG_FILES,
-	...LEGACY_CONFIG_FILES,
-	"components.json",
-	"package.json",
-	"project.json"
-];
+// src/workspace.ts
 /**
 * A monorepo seen from its root: every workspace package with a design system (an app
 * that uses one, from source or a published library, or the design-system package
@@ -23,7 +10,7 @@ const PROJECT_MARKERS = [
 * any file in it. Without a design system at the root, `check`, `inspect` and the MCP
 * server work from here, each file checked by its own project's design system.
 */
-var Workspace = class {
+var Workspace = class Workspace {
 	root;
 	source;
 	projects;
@@ -71,6 +58,10 @@ var Workspace = class {
 		}
 		return project;
 	}
+	/** The workspace without the projects at `roots`. */
+	without(roots) {
+		return new Workspace(this.root, this.source, this.projects.filter((p) => !roots.includes(p.root)), this.others, this.configFile, this.options, this.rootConfig, this.otherConfigs);
+	}
 	rootProject() {
 		return {
 			root: this.root,
@@ -148,7 +139,8 @@ function loadProjectConfig(dir, workspaceRoot, rootConfigFile, options) {
 	const shared = {
 		cwd: options.cwd,
 		includeDesignSystem: options.includeDesignSystem,
-		jsonConfigOnly: options.jsonConfigOnly
+		jsonConfigOnly: options.jsonConfigOnly,
+		jsonConfigWithin: options.jsonConfigWithin
 	};
 	const packages = new PackageFinder(dir);
 	if (!rootConfigFile || hasOwnConfig(dir)) return loadConfigWith({
@@ -224,5 +216,4 @@ function isDirectory(target) {
 		return false;
 	}
 }
-//#endregion
-export { hasProjectMarker as n, loadTarget as r, findProjectRoot as t };
+export { projectDirOf as i, hasProjectMarker as n, loadTarget as r, findProjectRoot as t };

package/package.json

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