onsystem 0.10.1 → 0.10.2

package/dist/index.d.ts

@@ -1,8 +1,7 @@
-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 { 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-JaNAiR9Z.js";
 import ts from "typescript";
 import { Oklch } from "culori";
 import { McpServer, Transport } from "@modelcontextprotocol/server";
-//#region src/lint/analyze.d.ts
 interface ImportBinding {
   source: string;
   /** Imported name, `default`, or `*` for namespace imports. */
@@ -37,8 +36,6 @@ interface Analysis {
   classStrings: ClassString[];
   styles: StyleObject[];
 }
-//#endregion
-//#region src/modules.d.ts
 /** Where an import points: a file relative to the root, or `{}` for a declared module not on disk. */
 interface ModuleLocation {
   file?: string;
@@ -83,8 +80,6 @@ declare class ModuleResolver {
   exportsOf(file: string): ModuleExports | undefined;
   private createResolver;
 }
-//#endregion
-//#region src/tokens/roles.d.ts
 /**
  * What a color utility paints, which decides the tokens that fit it: `text-*`
  * wants a foreground, `bg-*` a surface, `border-*` a border color.
@@ -100,8 +95,6 @@ type ColorRole = 'text' | 'surface' | 'line';
  * palette (`color-red-500`).
  */
 type ScopedFamily = string;
-//#endregion
-//#region src/tokens/css.d.ts
 /**
  * Reads design tokens from CSS custom properties, the way shadcn/ui and
  * Tailwind v4 projects define them:
@@ -114,14 +107,10 @@ export declare function parseCssTokens(css: string, file: string): {
   tokens: Token[];
   warnings: string[];
 };
-//#endregion
-//#region src/tokens/design-md.d.ts
 export declare function parseDesignMd(text: string, file: string): {
   tokens: Token[];
   warnings: string[];
 };
-//#endregion
-//#region src/tokens/dtcg.d.ts
 interface DtcgOptions {
   /** Prefix for generated custom property names: `ds` → `--ds-color-primary`. */
   prefix?: string;
@@ -130,8 +119,6 @@ export declare function parseDtcgTokens(text: string, file: string, options?: Dt
   tokens: Token[];
   warnings: string[];
 };
-//#endregion
-//#region src/tokens/export.d.ts
 /**
  * Writes the tokens onsystem found as a DTCG 2025.10 file or a DESIGN.md. Both are grouped by
  * category; reading the DTCG file back gives the same tokens, with the same names.
@@ -158,8 +145,6 @@ export declare function toDtcg(tokens: readonly Token[]): Exported;
 export declare function toDesignMd(tokens: readonly Token[], options: {
   name: string;
 }): Exported;
-//#endregion
-//#region src/tokens/index.d.ts
 interface TokenSource {
   file: string;
   /** DTCG only: prefix for generated custom property names. */
@@ -281,8 +266,6 @@ export declare class TokenIndex {
   /** px value of a token-like length string, resolving `var()` against the token set. */
   toPx(value: string): number | undefined;
 }
-//#endregion
-//#region src/lint/target.d.ts
 /** What the lint rules need to know about the design system. */
 declare class LintTarget {
   readonly model: DesignSystemModel;
@@ -378,8 +361,6 @@ declare class LintTarget {
   /** Component names for "did you mean" suggestions. */
   names(): string[];
 }
-//#endregion
-//#region src/lint/context.d.ts
 interface Report {
   start: number;
   end: number;
@@ -440,12 +421,8 @@ type Resolution =
 {
   kind: 'external';
 };
-//#endregion
-//#region src/lint/rules/index.d.ts
 /** Every rule, in the order they run. */
 export declare const RULES: readonly Rule[];
-//#endregion
-//#region src/lint/format.d.ts
 type OutputFormat = 'pretty' | 'json' | 'github' | 'sarif';
 /**
  * Renders check results:
@@ -468,8 +445,6 @@ export declare function formatDiagnostics(results: CheckResult[], format: Output
    */
   uri?: ((file: string) => string) | undefined;
 }): string;
-//#endregion
-//#region src/lint/index.d.ts
 interface CheckOptions {
   /** File name used in results and to pick TSX vs JSX parsing. Default `snippet.tsx`. */
   filename?: string | undefined;
@@ -483,8 +458,6 @@ interface CheckOptions {
 export declare function checkSource(code: string, target: LintTarget, options: CheckOptions): CheckResult;
 /** Applies non-overlapping fixes from the end of the file backwards. */
 export declare function applyFixes(code: string, diagnostics: Diagnostic[]): string;
-//#endregion
-//#region src/search/bm25.d.ts
 /**
  * Okapi BM25 over weighted fields (BM25F-style: field weights scale term
  * frequency and document length). Small, dependency-free and deterministic,
@@ -512,8 +485,6 @@ declare class Bm25Index<T> {
   get size(): number;
   search(query: Map<string, number>, limit?: number): Bm25Hit<T>[];
 }
-//#endregion
-//#region src/search/index.d.ts
 interface SearchHit {
   component: ComponentInfo;
   score: number;
@@ -530,8 +501,6 @@ interface SearchHit {
  * which is not an answer to give as the best match.
  */
 export declare function searchComponents(index: Bm25Index<ComponentInfo>, query: string, limit?: number): SearchHit[];
-//#endregion
-//#region src/util/log.d.ts
 /**
  * Diagnostics go to stderr: in stdio mode stdout carries JSON-RPC and must
  * never receive anything else.
@@ -541,8 +510,6 @@ interface Logger {
   warn(message: string): void;
   error(message: string): void;
 }
-//#endregion
-//#region src/design-system.d.ts
 /** A loaded design system: the model plus the indexes the tools query. */
 export declare class DesignSystem {
   readonly model: DesignSystemModel;
@@ -659,6 +626,11 @@ export declare class DesignSystemHost {
   constructor(config: ResolvedConfig, options?: HostOptions);
   get(): Promise<DesignSystem>;
   reload(): Promise<DesignSystem>;
+  /**
+   * `build`, dropped if it fails with no earlier model to serve instead (a first build that
+   * fails), so the next `get()` builds again.
+   */
+  private kept;
   onChange(listener: (ds: DesignSystem) => void): () => void;
   /** Watches the component, token and docs locations, the config and the tsconfig chain. */
   watch(): void;
@@ -677,8 +649,6 @@ export declare class DesignSystemHost {
   private reloadConfig;
   private build;
 }
-//#endregion
-//#region src/extract/components.d.ts
 interface ExtractComponentsOptions {
   root: string;
   /** Absolute paths of the component source files. */
@@ -708,8 +678,6 @@ interface ExtractComponentsResult {
  * `Tabs.List` via static members or `Object.assign`).
  */
 export declare function extractComponents(options: ExtractComponentsOptions): ExtractComponentsResult;
-//#endregion
-//#region src/extract/cva.d.ts
 /** A `cva()` (class-variance-authority) or `tv()` (tailwind-variants) definition. */
 interface VariantDefinition {
   /** The variable it is assigned to, e.g. `buttonVariants`. */
@@ -721,8 +689,6 @@ interface VariantDefinition {
 }
 /** Finds every `const x = cva(base, { variants, defaultVariants })` in a file. */
 export declare function findVariantDefinitions(sourceFile: ts.SourceFile): Map<string, VariantDefinition>;
-//#endregion
-//#region src/extract/docs.d.ts
 interface ParsedDoc {
   file: string;
   title?: string;
@@ -739,8 +705,6 @@ interface ParsedDoc {
 export declare function parseDoc(text: string, file: string): ParsedDoc;
 /** Attaches docs and their examples to components. Returns warnings for unmatched pages. */
 export declare function attachDocs(components: ComponentInfo[], docs: ParsedDoc[]): string[];
-//#endregion
-//#region src/catalog.d.ts
 /** One project's design system at a workspace root. */
 interface ServedProject {
   ds: DesignSystem;
@@ -809,8 +773,6 @@ declare class Catalog {
     query?: string | undefined;
   }): CatalogToken[];
 }
-//#endregion
-//#region src/server/index.d.ts
 export declare 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.\nWhen writing or changing UI in this project:\n1. Find components with search_components (by intent) or list_components.\n2. Read get_component before using a component: use only the props and variant values it lists.\n3. Style with tokens from get_tokens, never with hex/rgb colors, arbitrary px values or Tailwind's default palette. chart-* and sidebar-* tokens are for charts and the sidebar only: for a status color the theme has no token for (success, warning, info), add a token or keep the Tailwind color as check_ui says, and never use a chart-* or sidebar-* token for it.\n4. Run check_ui on every snippet or file you write and fix all errors before you finish.\nIn a monorepo served from its root, pass `path` (the file you are editing) to list_components, get_component, search_components and get_tokens, and `path` or `filename` to check_ui, so each answer comes from that file's own project.";
 interface CreateServerOptions {
   /**
@@ -827,8 +789,6 @@ interface CreateServerOptions {
 }
 /** Builds the MCP server: five tools, two resources and one prompt. Transport-agnostic. */
 export declare function createServer(options: CreateServerOptions): McpServer;
-//#endregion
-//#region src/server/stdio.d.ts
 interface ServeOptions extends LoadConfigOptions {
   cwd: string;
   cache: boolean;
@@ -860,12 +820,18 @@ interface ServerHandle {
  * 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.
  */
 export declare function serveStdio(options: ServeOptions): Promise<ServerHandle>;
-//#endregion
-//#region src/version.d.ts
 export declare const VERSION: string;
-//#endregion
 export { type CheckResult, type ComponentDocs, type ComponentInfo, type CompoundVariantInfo, type Config, type DesignSystemModel, type Diagnostic, type DocSection, type ExampleInfo, type HostOptions, type InheritedProps, type LoadConfigOptions, type LoadOptions, type OutputFormat, type PropInfo, RULE_IDS, type ResolvedConfig, type RuleId, type Severity, type SourceLocation, type TOKEN_CATEGORIES, type TextEdit, type Token, type TokenCategory, type VariantInfo, configJsonSchema, defineConfig, loadConfig };

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, 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-CPH4C7-1.js";
-import { n as INSTRUCTIONS, r as createServer, t as serveStdio } from "./stdio-BK2kMN1x.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-rl__N6tw.js";
+import { n as INSTRUCTIONS, r as createServer, t as serveStdio } from "./stdio-CkczPt_1.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-BK2kMN1x.js → stdio-CkczPt_1.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-rl__N6tw.js";
+import { i as projectDirOf, n as hasProjectMarker, r as loadTarget, t as findProjectRoot } from "./workspace-INef0Yqt.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
@@ -151,8 +151,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 +227,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
@@ -1080,8 +1078,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.
@@ -1822,8 +1819,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 +1961,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 +2020,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 +2029,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 +2049,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 +2080,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 +2109,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 +2122,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 +2135,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 +2249,7 @@ function serveStdio$1(options) {
 					return;
 				}
 				if (root !== options.cwd) logger.info(`using client root ${root}`);
-				serveOne(root);
+				serveAt(root);
 			});
 		};
 		return server;
@@ -2206,6 +2266,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 +2320,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-INef0Yqt.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-rl__N6tw.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.2",
   "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": [