@yahoo/uds-create-config 5.27.0 → 5.28.0

package/dist/configs/system.js

@@ -68,6 +68,7 @@ import { linkOverrideRefMigration } from "../migrations/20261009193004_link_over
 import { linkedComponentModulesMigration } from "../migrations/20261012200606_linked_component_modules.js";
 import { componentStatesMigration } from "../migrations/20261013154037_component_states.js";
 import { tokenOverridesListMigration } from "../migrations/20261013164300_token_overrides_list.js";
+import { linkExcludeOpMigration } from "../migrations/20261013182150_link_exclude_op.js";
 const System = defineConfig({
 	name: WEB_CONFIG_NAME,
 	description: "A design system: the values, primitives and compositions an app is built from. A ref is written `{ \"__ref\": \"<kind>:<path>\" }`, so a token is `{ \"__ref\": \"token:<group>/<name>\" }` and a token group is `{ \"__ref\": \"token:<group>\" }`. Build it in this order. Tokens first, in groups by purpose (colors, spacing, radii, type sizes), since everything else names them. Then style properties, each with `values` holding one ref to the token group whose members it accepts (`{ \"__ref\": \"token:color\" }`), so a prop takes token names rather than raw CSS; add a string keyword only for a value no token holds. A style rule's bag holds a prop's values (`\"padding\": \"4\"`, `\"bg\": \"brand\"`), never raw CSS. Then a few primitive components, one layer each, whose props are style properties (a box for layout and surface, a text for type, a pressable for interaction). Then every other component composed from those primitives: its layers name a primitive or an element, its anatomy places them (a node renders a layer, a tag or `Slot` where a slot prop's content lands; `children` is the edge list; `visible` is `{ \"$state\": \"<prop>\" }`; a prop shown in a nested layer is a `forward` route, and `$state` never sits in a node's props), and its style rules set style-property values per layer, keyed by prop values when a variant changes them. Modes (a dark mode is `{ type: \"selector\", value: \".dark\" }`) change token values through a token's `overrides`, so a component never restyles for a mode; modifiers (hover, focus, disabled) name a state, and a style rule applies under one as a `_hover` block inside a layer bag. Composites bundle style values that recur. Last, register canvas roles: the canvas draws with them, one entity per tool (`frame` for the layout primitive, `text` for the text primitive, `image`) whose entries name the components that tool inserts, and a tool whose role is unregistered is disabled. Give each component a `preview` entry under `*` so it shows content, and never write a CSS property name where a style-property name belongs.",
@@ -147,5 +148,6 @@ if (!registeredSchemaMigrations().has(20261009193004)) registerSchemaMigrations(
 if (!registeredSchemaMigrations().has(20261012200606)) registerSchemaMigrations(linkedComponentModulesMigration);
 if (!registeredSchemaMigrations().has(20261013154037)) registerSchemaMigrations(componentStatesMigration);
 if (!registeredSchemaMigrations().has(20261013164300)) registerSchemaMigrations(tokenOverridesListMigration);
+if (!registeredSchemaMigrations().has(20261013182150)) registerSchemaMigrations(linkExcludeOpMigration);
 //#endregion
 export { System };

package/dist/entities/system/LinkedSystem.d.ts

@@ -143,6 +143,18 @@ declare const LinkedSystemDefinition: EntityClass<z.ZodObject<{
       data: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"*">, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<"*">, z.ZodArray<z.ZodString>]>>]>>;
     }, z.core.$strip>;
   };
+  readonly exclude: {
+    readonly input: z.ZodObject<{
+      path: z.ZodType<string, string | undefined, z.core.$ZodTypeInternals<string, string | undefined>>;
+      data: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+  };
+  readonly 'exclude-plan': {
+    readonly input: z.ZodObject<{
+      path: z.ZodType<string, string | undefined, z.core.$ZodTypeInternals<string, string | undefined>>;
+      data: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+  };
   readonly break: {
     readonly input: z.ZodObject<{
       path: z.ZodType<string, string | undefined, z.core.$ZodTypeInternals<string, string | undefined>>;

package/dist/entities/system/LinkedSystem.js

@@ -6,8 +6,9 @@ import { kindBorrowable } from "../../framework/registry.js";
 import { defineEntity } from "../../framework/defineEntity.js";
 import { storedStyleRules } from "./Component.js";
 import { sourceUnreachable } from "../../framework/sources.js";
+import { covers, excludes } from "./link-declaration.js";
 import { planCopy } from "./copy-plan.js";
-import { planBreak, planLink, planUnlink, sourceRowStates } from "./link-plan.js";
+import { planBreak, planExclude, planLink, planUnlink, sourceRowStates } from "./link-plan.js";
 import { z } from "zod";
 //#region src/entities/system/LinkedSystem.ts
 /**
@@ -177,6 +178,12 @@ const unlinkInput = z.object({
 	/** What to stop drawing, in `link`'s shape; everything when omitted. */
 	data: z.union([z.literal("*"), z.record(z.string(), copyPaths)]).optional()
 });
+const excludeInput = z.object({
+	path: pathInput("linked-system"),
+	/** What to leave out, keyed by accessor the way the pin's `link` is: the source's paths, where a
+	*  folder leaves out its members. */
+	data: z.record(z.string(), z.array(z.string().min(1)).min(1))
+});
 const breakInput = z.object({
 	path: pathInput("linked-system"),
 	/** Whether every value drawn through the pin becomes this config's own first. */
@@ -197,6 +204,13 @@ function copyInputOf(input) {
 		...input.onConflict === void 0 ? {} : { onConflict: input.onConflict }
 	};
 }
+/** The parsed `exclude` input as the plan takes it. */
+function excludePlanInputOf(input) {
+	return {
+		path: String(input.path),
+		data: input.data
+	};
+}
 /** The parsed `link` input as the plan takes it. */
 function linkPlanInputOf(input) {
 	return {
@@ -270,7 +284,11 @@ const LinkedSystemDefinition = defineEntity({
 	kind: "linked-system",
 	label: "Linked system",
 	labelPlural: "Linked systems",
-	invariants: (config) => [...config.list("linked-system").filter(({ path }) => !isLinkSlug(path)).map(({ path }) => `Link "${path}": ${LINK_SLUG_MESSAGE}`), ...linkRedirects(config).filter((redirect) => redirect.problem !== void 0 && redirect.problem !== "missing").map(redirectSentence)],
+	invariants: (config) => [
+		...config.list("linked-system").filter(({ path }) => !isLinkSlug(path)).map(({ path }) => `Link "${path}": ${LINK_SLUG_MESSAGE}`),
+		...linkRedirects(config).filter((redirect) => redirect.problem !== void 0 && redirect.problem !== "missing").map(redirectSentence),
+		...excludedDirectives(config)
+	],
 	schemas: {
 		create: { example: ({ config }) => {
 			const path = freeExampleSlug(config);
@@ -372,6 +390,45 @@ const LinkedSystemDefinition = defineEntity({
 			}
 		},
 		/**
+		* Leave part of a linked system out for good: a `!` entry per path in the pin's `link`. Unlike
+		* `unlink`, nothing derives there however the link reaches it, and the linked tokens' overrides
+		* under an excluded modifier are left out of the build. `link` with the same path lifts it.
+		*/
+		exclude: {
+			input: excludeInput,
+			readOnly: false,
+			label: "Exclude from",
+			description: "Leave paths of a linked system out, keyed by accessor the way `link` is: `{ modifiers: ['text'] }` leaves out the `text` folder's members. Stronger than `unlink`: nothing derives at an excluded path however the link reaches it, even when a linked token's override names it, and the source's token overrides under an excluded modifier are left out of the build. The pin's `options` entries at those paths go with them. `exclude-plan` names what goes; `link` with the same path brings it back.",
+			scope: "item",
+			approval: "reference-change",
+			title: (entity) => `Exclude something from ${entity}`,
+			example: linkExample,
+			handler: (input, config) => {
+				const { patches, blocked } = planExclude({
+					config,
+					input: excludePlanInputOf(input)
+				});
+				if (blocked !== void 0) rejectData(blocked);
+				return config.applyAll(patches);
+			}
+		},
+		"exclude-plan": {
+			input: excludeInput,
+			readOnly: true,
+			label: "Plan an exclusion",
+			description: "What `exclude` with the same input leaves out — the minted rows that stop deriving, the linked tokens' overrides under an excluded modifier (`leftOut`), and the pin's `options` entries that go with the paths (`dropped`) — and why the config would refuse it. Writes nothing.",
+			scope: "item",
+			title: (entity) => `Plan an exclusion from ${entity}`,
+			example: linkExample,
+			handler: (input, config) => {
+				const { patches: _patches, ...plan } = planExclude({
+					config,
+					input: excludePlanInputOf(input)
+				});
+				return plan;
+			}
+		},
+		/**
 		* Break the link: the pin goes, and everything drawn through it either becomes this config's own
 		* or goes with it.
 		*/
@@ -541,6 +598,7 @@ const LinkedSystemDefinition = defineEntity({
 		* link: { tokens: '*', icons: '*' }                    // those kinds whole
 		* link: { tokens: ['color/brand', 'color/paper'] }     // those entities
 		* link: { components: ['actions'] }                    // a folder: its members
+		* link: { '*': '*', modifiers: ['*', '!text'] }        // everything but one folder
 		* ```
 		* `Config.withDerivedRows` reads it and makes a pointer row per entity it covers — on every build,
 		* and inside the apply of any patch to this pin — so a link's cost in authored source is this one
@@ -566,14 +624,38 @@ const LinkedSystemDefinition = defineEntity({
 		* build would make it again on the next pass, and a delete that comes back is worse than one that
 		* was refused. To own one of their entities, `copy` it; to stop drawing it, `unlink` it.
 		*
-		* The gestures that write this are the kind's own ops — `link`, `unlink`, `break` — each with a
-		* `-plan` read beside it, so a surface never assembles the declaration by hand.
+		* The gestures that write this are the kind's own ops — `link`, `unlink`, `exclude`, `break` —
+		* each with a `-plan` read beside it, so a surface never assembles the declaration by hand.
 		*
 		* `'*'` means every kind that may be drawn on, which is every kind that may be borrowed — each
 		* kind says which it is (`EntityKind.linkable`). Nothing is subtracted: a pin and a `file` aren't
 		* borrowable, so no borrow of one exists for this to cover.
+		*
+		* **Leaving part of a kind out.** A record's `'*'` key stands for every accessor it doesn't name,
+		* and a list entry `'*'` for every path, so everything but one folder is spelled
+		* ```ts
+		* link: { '*': '*', modifiers: ['*', '!text'] }
+		* ```
+		* A `!` entry leaves that path out, or a folder's members, whatever else in the list reaches it.
+		* Unlike a path a list doesn't name, an excluded path derives no row however the link reaches it —
+		* a linked token whose override is under a `text` modifier names that modifier, and it still
+		* stays out — so the name is free for this config to author, and the source's entity stays
+		* reachable qualified. A token's overrides under an excluded modifier are left out of the build
+		* rather than refused (`unstatableConditions`), which is what a consumer without one of the
+		* source's mode axes means. A linked component's rule keyed on one still reaches the source's
+		* modifier, as a rule on any modifier the link doesn't take does. See `covers` and `excludes`.
+		*
+		* Exclusions win wherever they sit, so `['!text', '*']` is `['*', '!text']`, and a list of them
+		* alone (`['!text']`) takes nothing by name and still keeps `text` out. An `options` entry at an
+		* excluded path is refused (an invariant), since no row derives there for it to adjust. `exclude`
+		* writes one (and drops such entries with it), and `link` lifts one over what it takes. `unlink`
+		* keeps them and writes none, because a `!` also drops the overrides under the path, which
+		* unlinking never has.
+		*
+		* No entity path can be misread here: `entityPathProblem` refuses a segment that starts with `!`,
+		* a segment that is `*`, and an empty segment, wherever a path becomes an identity.
 		*/
-		link: z.union([z.literal("*"), z.record(z.string(), z.union([z.literal("*"), z.array(z.string().min(1)).min(1)]))]).optional().describe("What this system draws from the source, standing: `'*'` for everything, or a record by kind."),
+		link: z.union([z.literal("*"), z.record(z.string(), z.union([z.literal("*"), z.array(z.string().min(1)).min(1)]))]).optional().describe("What this system draws from the source, standing: `'*'` for everything, or a record by kind (`'*'` keys every kind it doesn't name). A list's `'!path'` entry leaves that path out."),
 		/**
 		* What this system does to individual entities of the source, keyed by accessor, then by the path
 		* the source spells, then by verb.
@@ -715,20 +797,22 @@ displayName: ({ member, path }) => typeof member.name === "string" && member.nam
 	* question and the delete gate's, answered here because `link` is this kind's field and its shape
 	* is this kind's to interpret.
 	*
-	* `'*'` at either level covers everything under it; a list covers the paths it names, as the source
-	* spells them, and a named folder covers its members. Nothing excludes a kind here — a kind a
-	* whole-source take does not reach is one no borrow of it exists for (`EntityKind.linkable`), so
-	* the claim is unreachable rather than filtered.
+	* `'*'` at either level covers everything under it, and a record's `'*'` key stands for every
+	* accessor it doesn't name; a list covers the paths it names, as the source spells them, and a named
+	* folder covers its members, less what its `!` entries leave out. Nothing else excludes a kind here
+	* — a kind a whole-source take does not reach is one no borrow of it exists for
+	* (`EntityKind.linkable`), so the claim is unreachable rather than filtered.
 	*/
-	bulkAdopts: ({ body, kind, accessor, path }) => {
-		const declared = body.link;
-		if (declared === void 0) return false;
-		if (declared === "*") return true;
-		const paths = declared[accessor ?? kind];
-		if (paths === void 0) return false;
-		if (paths === "*") return true;
-		return paths.some((declaredPath) => declaredPath === path || path.startsWith(`${declaredPath}/`));
-	},
+	bulkAdopts: ({ body, kind, accessor, path }) => covers({
+		declared: body.link,
+		accessor: accessor ?? kind,
+		path
+	}),
+	bulkExcludes: ({ body, kind, accessor, path }) => excludes({
+		declared: body.link,
+		accessor: accessor ?? kind,
+		path
+	}),
 	bulkOverlay: ({ body, kind, accessor, path }) => {
 		const directive = directiveAt(body, accessor ?? kind, path);
 		if (!directive) return void 0;
@@ -794,6 +878,18 @@ function linkedSystemItem(def) {
 	};
 }
 const LinkedSystem = Object.assign(LinkedSystemDefinition, { item: linkedSystemItem });
+/** Each `options` entry at a path its pin's `link` excludes, which derives no row for it to adjust. */
+function excludedDirectives(config) {
+	return config.list("linked-system").flatMap(({ path: slug }) => {
+		const body = config.storedBody("linked-system", slug);
+		if (!body?.options) return [];
+		return Object.entries(body.options).flatMap(([accessor, entries]) => isPlainObject(entries) ? Object.keys(entries).filter((path) => excludes({
+			declared: body.link,
+			accessor,
+			path
+		})).map((path) => `Link "${slug}": options.${accessor}["${path}"] adjusts a path its \`link\` excludes, which derives no row. Drop the entry, or the exclusion.`) : []);
+	});
+}
 /** The `options` entry for one path, or `undefined` where the pin says nothing about it. */
 function directiveAt(body, accessor, path) {
 	return body.options?.[accessor]?.[path];

package/dist/entities/system/link-declaration.d.ts

@@ -3,19 +3,60 @@ import type { LinkDeclaration } from './LinkedSystem';
 export declare const PIN_KIND = "linked-system";
 /** The pin's `link` as stored. */
 export declare function declarationOf(config: Config, slug: string): LinkDeclaration | undefined;
-/** Whether a declaration covers the accessor's path: the whole source, the kind, the path, or a folder above it. */
+/**
+ * What a declaration says about one accessor: its own entry, or the record's `'*'` entry, which stands
+ * for every accessor the record doesn't name (`{ '*': '*', modifiers: ['*', '!text'] }`).
+ */
+export declare function entriesFor(declared: LinkDeclaration | undefined, accessor: string): '*' | readonly string[] | undefined;
+/** The paths a list leaves out, without their `!`. */
+export declare function excludedIn(entries: '*' | readonly string[] | undefined): string[];
+/**
+ * Whether a declaration leaves the accessor's path out on purpose: a `!` entry names it or a folder
+ * above it. An excluded path derives no row however the link reaches it, a ref pulling it in included.
+ */
+export declare function excludes({ declared, accessor, path, }: {
+    declared: LinkDeclaration | undefined;
+    accessor: string;
+    path: string;
+}): boolean;
+/**
+ * Whether a declaration covers the accessor's path: the whole source, the kind, the path, or a folder
+ * above it, and no `!` entry leaves it out. An exclusion wins whatever else in the list reaches the
+ * path, so `['*', '!text']` is every path but `text`'s.
+ */
 export declare function covers({ declared, accessor, path, }: {
     declared: LinkDeclaration | undefined;
     accessor: string;
     path: string;
 }): boolean;
+/**
+ * A list with `paths` taken into it: each is added unless a path the list takes already reaches it,
+ * and an exclusion that would leave one out is lifted. One naming the path or a folder under it goes;
+ * one naming a folder above it is spelled out as the folder's other members, so they stay out.
+ */
+export declare function includePaths({ config, slug, kind, entries, paths, }: {
+    config: Config;
+    slug: string;
+    kind: string;
+    entries: readonly string[];
+    paths: readonly string[];
+}): string[];
+/**
+ * A list with `paths` left out: a `!` entry for each the list doesn't exclude already. A path the
+ * list names under one of them goes, since the exclusion now says it, and so does a narrower
+ * exclusion a new one reaches. A folder named above an excluded path stays, less that path. With
+ * nothing listed, the list is the exclusions alone, which still keep the paths out when a linked row
+ * reaches them.
+ */
+export declare function excludePaths(entries: '*' | readonly string[] | undefined, paths: readonly string[]): string[];
 /**
  * The declaration with `removal` taken out of it, or `undefined` when nothing stays declared.
  *
  * A declaration of everything is spelled out first, one kind per accessor the source has rows for, so
  * one kind can be taken out of it; a kind taken whole is spelled out as the source's top-level paths
  * so some can go; a declared folder above a removed path is spelled out as its other members, so the
- * rest of it stays covered.
+ * rest of it stays covered. A list that takes every path (`['*', …]`) is spelled out the same way.
+ * Its `!` entries stay, a list of them alone included, and narrowing writes none.
  */
 export declare function narrowDeclaration({ config, slug, current, removal, verb, }: {
     config: Config;

package/dist/entities/system/link-declaration.js

@@ -7,14 +7,90 @@ function declarationOf(config, slug) {
 	if (!pin) rejectData(`No linked system "${slug}".`);
 	return pin.link;
 }
-/** Whether a declaration covers the accessor's path: the whole source, the kind, the path, or a folder above it. */
+/** An entry that leaves a path out: `'!text'`. */
+const EXCLUDE = "!";
+/** Whether a declared entry names `path` or a folder above it. */
+const reaches = (entry, path) => entry === "*" || entry === path || path.startsWith(`${entry}/`);
+/**
+* What a declaration says about one accessor: its own entry, or the record's `'*'` entry, which stands
+* for every accessor the record doesn't name (`{ '*': '*', modifiers: ['*', '!text'] }`).
+*/
+function entriesFor(declared, accessor) {
+	if (declared === void 0 || declared === "*") return declared;
+	return declared[accessor] ?? declared["*"];
+}
+/** The paths a list leaves out, without their `!`. */
+function excludedIn(entries) {
+	if (entries === void 0 || entries === "*") return [];
+	return entries.filter((entry) => entry.startsWith(EXCLUDE)).map((entry) => entry.slice(1));
+}
+/**
+* Whether a declaration leaves the accessor's path out on purpose: a `!` entry names it or a folder
+* above it. An excluded path derives no row however the link reaches it, a ref pulling it in included.
+*/
+function excludes({ declared, accessor, path }) {
+	return excludedIn(entriesFor(declared, accessor)).some((excluded) => reaches(excluded, path));
+}
+/**
+* Whether a declaration covers the accessor's path: the whole source, the kind, the path, or a folder
+* above it, and no `!` entry leaves it out. An exclusion wins whatever else in the list reaches the
+* path, so `['*', '!text']` is every path but `text`'s.
+*/
 function covers({ declared, accessor, path }) {
-	if (declared === void 0) return false;
-	if (declared === "*") return true;
-	const paths = declared[accessor];
-	if (paths === void 0) return false;
-	if (paths === "*") return true;
-	return paths.some((declaredPath) => declaredPath === path || path.startsWith(`${declaredPath}/`));
+	const entries = entriesFor(declared, accessor);
+	if (entries === void 0) return false;
+	if (entries === "*") return true;
+	if (excludes({
+		declared,
+		accessor,
+		path
+	})) return false;
+	return entries.some((entry) => !entry.startsWith(EXCLUDE) && reaches(entry, path));
+}
+/**
+* A list with `paths` taken into it: each is added unless a path the list takes already reaches it,
+* and an exclusion that would leave one out is lifted. One naming the path or a folder under it goes;
+* one naming a folder above it is spelled out as the folder's other members, so they stay out.
+*/
+function includePaths({ config, slug, kind, entries, paths }) {
+	const source = config.sourceFor(slug);
+	const included = [];
+	const exclusions = [];
+	for (const entry of entries) {
+		if (!entry.startsWith(EXCLUDE)) {
+			included.push(entry);
+			continue;
+		}
+		const excluded = entry.slice(1);
+		if (paths.some((path) => reaches(path, excluded))) continue;
+		if (!paths.some((path) => reaches(excluded, path))) {
+			exclusions.push(entry);
+			continue;
+		}
+		for (const member of source?.members(kind, excluded) ?? []) if (!paths.some((path) => reaches(path, member.path))) exclusions.push(`${EXCLUDE}${member.path}`);
+	}
+	for (const path of paths) {
+		if (included.some((entry) => reaches(entry, path))) continue;
+		included.push(path);
+	}
+	return [...included, ...exclusions];
+}
+/**
+* A list with `paths` left out: a `!` entry for each the list doesn't exclude already. A path the
+* list names under one of them goes, since the exclusion now says it, and so does a narrower
+* exclusion a new one reaches. A folder named above an excluded path stays, less that path. With
+* nothing listed, the list is the exclusions alone, which still keep the paths out when a linked row
+* reaches them.
+*/
+function excludePaths(entries, paths) {
+	const list = entries === void 0 ? [] : entries === "*" ? ["*"] : entries;
+	const excluded = excludedIn(list);
+	const added = [...new Set(paths)].filter((path) => !excluded.some((already) => reaches(already, path)));
+	return [...list.filter((entry) => {
+		if (entry === "*") return true;
+		const path = entry.startsWith(EXCLUDE) ? entry.slice(1) : entry;
+		return !added.some((adding) => reaches(adding, path));
+	}), ...added.map((path) => `${EXCLUDE}${path}`)];
 }
 /**
 * The declaration with `removal` taken out of it, or `undefined` when nothing stays declared.
@@ -22,7 +98,8 @@ function covers({ declared, accessor, path }) {
 * A declaration of everything is spelled out first, one kind per accessor the source has rows for, so
 * one kind can be taken out of it; a kind taken whole is spelled out as the source's top-level paths
 * so some can go; a declared folder above a removed path is spelled out as its other members, so the
-* rest of it stays covered.
+* rest of it stays covered. A list that takes every path (`['*', …]`) is spelled out the same way.
+* Its `!` entries stay, a list of them alone included, and narrowing writes none.
 */
 function narrowDeclaration({ config, slug, current, removal, verb }) {
 	const source = config.sourceFor(slug);
@@ -31,7 +108,18 @@ function narrowDeclaration({ config, slug, current, removal, verb }) {
 		if (source && source.list(kind).length === 0) continue;
 		next[config.accessorOf(kind) ?? kind] = "*";
 	}
-	else Object.assign(next, current);
+	else {
+		Object.assign(next, current);
+		const fallback = current["*"];
+		if (fallback !== void 0) {
+			delete next["*"];
+			for (const kind of config.borrowableKinds(slug)) {
+				if (source && source.list(kind).length === 0) continue;
+				const accessor = config.accessorOf(kind) ?? kind;
+				if (!(accessor in current)) next[accessor] = fallback;
+			}
+		}
+	}
 	for (const [accessor, paths] of removal) {
 		const before = next[accessor];
 		if (before === void 0) continue;
@@ -40,25 +128,32 @@ function narrowDeclaration({ config, slug, current, removal, verb }) {
 			continue;
 		}
 		const kind = config.accessors()[accessor]?.kind ?? accessor;
+		const excluded = excludedIn(before);
 		let declaredPaths;
-		if (before === "*") {
+		if (before === "*" || before.includes("*")) {
 			if (!source) rejectData(`Cannot ${verb} ${paths.join(", ")} through "${slug}" — the declaration takes every "${accessor}", and nothing has resolved that link to spell them out. Unlink the kind (\`{ "${accessor}": "*" }\`) instead.`, ["data", accessor]);
 			declaredPaths = source.tree(kind).map((node) => node.path);
-		} else declaredPaths = before;
+		} else declaredPaths = before.filter((entry) => !entry.startsWith(EXCLUDE));
 		const removed = (candidate) => paths.some((path) => path === candidate || candidate.startsWith(`${path}/`));
 		const kept = [];
 		for (const declaredPath of declaredPaths) {
 			if (removed(declaredPath)) continue;
+			if (excluded.some((path) => reaches(path, declaredPath))) continue;
 			if (!paths.some((path) => path.startsWith(`${declaredPath}/`)) || !source) {
 				kept.push(declaredPath);
 				continue;
 			}
-			for (const member of source.members(kind, declaredPath)) if (!removed(member.path)) kept.push(member.path);
+			for (const member of source.members(kind, declaredPath)) {
+				if (removed(member.path)) continue;
+				if (excluded.some((path) => reaches(path, member.path))) continue;
+				kept.push(member.path);
+			}
 		}
-		if (kept.length === 0) delete next[accessor];
-		else next[accessor] = kept;
+		const exclusions = excluded.map((path) => `${EXCLUDE}${path}`);
+		if (kept.length === 0 && exclusions.length === 0) delete next[accessor];
+		else next[accessor] = [...kept, ...exclusions];
 	}
 	return Object.keys(next).length === 0 ? void 0 : next;
 }
 //#endregion
-export { PIN_KIND, covers, declarationOf, narrowDeclaration };
+export { PIN_KIND, covers, declarationOf, entriesFor, excludePaths, excludes, includePaths, narrowDeclaration };

package/dist/entities/system/link-plan.js

@@ -1,7 +1,8 @@
 import { rejectData } from "../../framework/rejection.js";
 import { collectRefs, isMintedRow, ref, sourceOf, splitRef } from "../../framework/utils/refs.js";
 import { blockedBy } from "../../framework/plan.js";
-import { PIN_KIND, covers, declarationOf, narrowDeclaration } from "./link-declaration.js";
+import { excludedCondition } from "../../framework/source-integrity.js";
+import { PIN_KIND, covers, declarationOf, entriesFor, excludePaths, excludes, includePaths, narrowDeclaration } from "./link-declaration.js";
 import { planCopy, sourceEntries } from "./copy-plan.js";
 //#region src/entities/system/link-plan.ts
 /** The kinds `data` names, with what to take of each. An accessor this config has no kind for is a typo, refused by name. */
@@ -201,7 +202,7 @@ function planLink({ config, input }) {
 	} else {
 		const next = { ...current ?? {} };
 		for (const [accessor, gain] of gains) {
-			const before = next[accessor];
+			const before = entriesFor(current, accessor);
 			if (before === "*") continue;
 			if (gain === "*") {
 				next[accessor] = "*";
@@ -213,7 +214,13 @@ function planLink({ config, input }) {
 				path
 			}));
 			if (added.length === 0) continue;
-			next[accessor] = [...before ?? [], ...new Set(added)];
+			next[accessor] = includePaths({
+				config,
+				slug,
+				kind: config.accessors()[accessor]?.kind ?? accessor,
+				entries: before ?? [],
+				paths: [...new Set(added)]
+			});
 		}
 		for (const [accessor, value] of Object.entries(next)) {
 			if (current !== void 0 && current[accessor] === value) continue;
@@ -361,6 +368,104 @@ function planUnlink({ config, input }) {
 	};
 }
 /**
+* Leave paths of a linked system out, with a `!` entry each in the pin's `link`. Stronger than
+* `unlink`: nothing derives there however the link reaches it, a linked token naming it included,
+* and the linked tokens' overrides under an excluded modifier are left out of the build. `link` with
+* the same path lifts it again.
+*/
+function planExclude({ config, input }) {
+	const { path: slug } = input;
+	const source = config.sourceFor(slug);
+	if (!source) rejectData(`Cannot exclude through "${slug}" — nothing has resolved that link.`);
+	const current = declarationOf(config, slug);
+	const next = current === void 0 ? {} : current === "*" ? { "*": "*" } : { ...current };
+	for (const { kind, accessor, paths } of wantedKinds({
+		config,
+		slug,
+		data: input.data,
+		verb: "exclude"
+	})) {
+		if (paths === "*") rejectData(`Cannot exclude every "${accessor}" through "${slug}" — name the paths to leave out, or \`unlink\` the kind.`, ["data", accessor]);
+		for (const path of paths) if (sourceEntries({
+			source,
+			kind,
+			path
+		}).length === 0) rejectData(`Cannot exclude "${path}" through "${slug}" — the source has no ${kind} there.`, ["data", accessor]);
+		next[accessor] = excludePaths(entriesFor(current, accessor), paths);
+	}
+	const declared = next;
+	const dropped = [];
+	const optionDeletes = {};
+	const options = config.storedBody("linked-system", slug).options ?? {};
+	for (const [accessor, entries] of Object.entries(options)) {
+		if (!entries || typeof entries !== "object") continue;
+		const kind = config.accessors()[accessor]?.kind ?? accessor;
+		for (const path of Object.keys(entries)) {
+			if (!excludes({
+				declared,
+				accessor,
+				path
+			})) continue;
+			dropped.push({
+				kind,
+				path
+			});
+			optionDeletes[`options.${accessor}.${path}`] = null;
+		}
+	}
+	const patches = [{
+		kind: PIN_KIND,
+		operation: "update",
+		path: slug,
+		data: {
+			link: declared,
+			...optionDeletes
+		}
+	}];
+	if (Object.entries(input.data).every(([accessor, paths]) => paths.every((path) => excludes({
+		declared: current,
+		accessor,
+		path
+	})))) return {
+		declared: current,
+		removed: [],
+		leftOut: [],
+		dropped: [],
+		blocked: `Nothing would change: what "${slug}" declares already leaves everything named out.`,
+		patches: []
+	};
+	const blocked = blockedBy(() => config.applyAll(patches));
+	const removed = [];
+	const leftOut = [];
+	if (blocked === void 0) {
+		const after = config.applyAll(patches);
+		for (const kind of config.borrowableKinds(slug)) for (const item of config.list(kind)) {
+			if (item.borrowedFrom !== slug) continue;
+			if (after.resolve(kind, item.path)?.borrowedFrom === slug) continue;
+			removed.push({
+				kind,
+				path: item.path
+			});
+		}
+		for (const item of after.list("token")) {
+			if (item.borrowedFrom !== slug) continue;
+			const body = source.resolve("token", item.path)?.toJSON();
+			for (const [override, { on }] of Object.entries(body?.overrides ?? {})) if (excludedCondition(after, on)) leftOut.push({
+				token: item.path,
+				override
+			});
+		}
+	}
+	return {
+		declared,
+		removed,
+		leftOut,
+		dropped,
+		...blocked === void 0 ? {} : { blocked },
+		patches
+	};
+}
+/**
 * The linked rows that point at what `data` names, followed to a fixpoint: a row pointing at one of
 * those, and so on. Read off both ref graphs, since a linked row's refs are the source's spelling and
 * this config's index holds them qualified.
@@ -832,4 +937,4 @@ function sourceRowStates({ config, slug }) {
 	return rows;
 }
 //#endregion
-export { planBreak, planLink, planUnlink, sourceRowStates };
+export { planBreak, planExclude, planLink, planUnlink, sourceRowStates };

package/dist/framework/Config.d.ts

@@ -73,7 +73,7 @@ interface RecordedSource {
  * The dense-counter `2` a short-lived scheme stamped before the chain existed reads as the mint
  * that replaced it (see `detectedWireVersion`).
  */
-declare const SERIALIZED_CONFIG_VERSION = 20261013164300;
+declare const SERIALIZED_CONFIG_VERSION = 20261013182150;
 interface SerializedConfig {
   /** See {@link SERIALIZED_CONFIG_VERSION}. Always written; a stored artifact may lack it. */
   readonly version: number;
@@ -1785,6 +1785,11 @@ declare class Config {
    * subject is the overlay rather than whether a row is minted at all.
    */
   sourceOverlay(slug: string, kind: string, path: string): SourceOverlay | undefined;
+  /**
+   * Whether the declared source at `slug` excludes one of its paths ({@link EntityKind.bulkExcludes}):
+   * left out on purpose, so no row derives there. Matched on the path the source spells.
+   */
+  sourceExcludes(slug: string, kind: string, path: string): boolean;
   /**
    * The field-path delta that records `overlay` as the pin's directive for one path, or `null` when
    * there is nothing to write.
@@ -2179,9 +2184,8 @@ declare class Config {
    * only the reached ones would leave those rows absent from the artifact. Reachability stays the
    * floor either way, so a ref always brings its target whether or not a declaration claims it.
    *
-   * Shared rather than computed per caller: the CSS emitter needs it to know what to declare, and the
-   * build's validation needs the same set to know what to check — two answers to that question would
-   * drift, and the drift would look like a token that emits but isn't validated.
+   * Preserves the original source definitions for saved configs and Web emission. Native emission
+   * and condition validation use runtimeSourceClosure to follow the definitions after overrides.
    *
    * `kind` narrows it for a caller that emits or validates one kind, which is the caller's business
    * to name; the walk itself follows refs wherever they go, so borrowing something other than a token
@@ -2190,6 +2194,14 @@ declare class Config {
    * Sorted, so anything built from it is deterministic.
    */
   sourceClosure(slug: string, kind?: string): string[];
+  /** References used after local overrides; sourceClosure also preserves the original bases. */
+  runtimeSourceClosure({
+    slug,
+    kind
+  }: {
+    slug: string;
+    kind?: string;
+  }): string[];
   /**
    * The walk behind {@link sourceClosure}, run once per snapshot and source set.
    *