@yahoo/uds-create-config 5.27.1 → 5.29.0

package/dist/configs/react-native-system.d.ts

@@ -48,6 +48,7 @@ declare const ReactNativeSystemDefinition: ConfigClass<{
       }, _$zod_v4_core0.$strict>]>>;
       scope: _$zod.ZodOptional<_$zod.ZodString>;
       preflight: _$zod.ZodOptional<_$zod.ZodBoolean>;
+      fontFaces: _$zod.ZodOptional<_$zod.ZodBoolean>;
       rem: _$zod.ZodOptional<_$zod.ZodString>;
       content: _$zod.ZodOptional<_$zod.ZodArray<_$zod.ZodString>>;
       safelist: _$zod.ZodOptional<_$zod.ZodType<SafelistEntry[], readonly SafelistEntry[], _$zod_v4_core0.$ZodTypeInternals<SafelistEntry[], readonly SafelistEntry[]>>>;

package/dist/configs/system.js

@@ -68,6 +68,8 @@ 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";
+import { fontFacesMigration } from "../migrations/20261013201548_font_faces.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 +149,7 @@ 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);
+if (!registeredSchemaMigrations().has(20261013201548)) registerSchemaMigrations(fontFacesMigration);
 //#endregion
 export { System };

package/dist/entities/native/NativeSettings.d.ts

@@ -39,6 +39,7 @@ declare const NativeSettings: EntityClass<z.ZodObject<Omit<{
     }, z.core.$strict>]>>;
     scope: z.ZodOptional<z.ZodString>;
     preflight: z.ZodOptional<z.ZodBoolean>;
+    fontFaces: z.ZodOptional<z.ZodBoolean>;
     rem: z.ZodOptional<z.ZodString>;
     content: z.ZodOptional<z.ZodArray<z.ZodString>>;
     safelist: z.ZodOptional<z.ZodType<SafelistEntry[], readonly SafelistEntry[], z.core.$ZodTypeInternals<SafelistEntry[], readonly SafelistEntry[]>>>;

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

@@ -14,6 +14,9 @@ import { z } from "zod";
  * addresses the FAMILY and lets the browser pick by weight/style — but a native platform references
  * a file directly, and it can't be derived from the family name. Optional because nothing that feeds
  * a config records one today; it's author/upload-supplied.
+ *
+ * `weight` and `style` are checked as invariants rather than shapes, so an edit with a value
+ * `@font-face` doesn't accept is refused while a stored config holding one still loads.
  */
 declare const FontFileDefinition: SubEntityClass<z.ZodObject<{
   src: z.ZodString;
@@ -22,6 +25,22 @@ declare const FontFileDefinition: SubEntityClass<z.ZodObject<{
   style: z.ZodOptional<z.ZodString>;
   postscriptName: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>>;
+/** Whether a value is one the `@font-face` `font-weight` descriptor accepts. `bolder` and `lighter`
+ *  are relative to a parent and mean nothing on a face. */
+declare function isFontFaceWeight(value: number | string): boolean;
+/** Whether a value is one the `@font-face` `font-style` descriptor accepts. */
+declare function isFontFaceStyle(value: string): boolean;
+/**
+ * A file's weight and style as `@font-face` descriptor values. A stored config can still hold a value
+ * the schema now refuses, so one the descriptor doesn't accept is left out rather than written.
+ */
+declare function fontFileDescriptors(file: {
+  readonly weight?: number | string;
+  readonly style?: string;
+}): {
+  readonly weight?: string;
+  readonly style?: string;
+};
 interface FontFileClass extends Named<typeof FontFileDefinition> {}
 declare const FontFile: FontFileClass;
 /**
@@ -74,4 +93,4 @@ declare function fontFamilyStack(font: {
   readonly variable?: string | undefined;
 }): string;
 //#endregion
-export { Font, FontClass, FontFile, FontFileClass, cssString, fontFamilyStack };
+export { Font, FontClass, FontFile, FontFileClass, cssString, fontFamilyStack, fontFileDescriptors, isFontFaceStyle, isFontFaceWeight };

package/dist/entities/system/Font.js

@@ -1,7 +1,22 @@
 import { defineEntity } from "../../framework/defineEntity.js";
 import { defineSubEntity } from "../../framework/defineSubEntity.js";
 import { z } from "zod";
-const FontFile = defineSubEntity({
+//#region src/entities/system/Font.ts
+/**
+* One FILE of a font family — the unit `@font-face` needs a rule for. Named `files` rather than
+* `weights` because the two don't line up: a roman and an italic at 400 are two files sharing one
+* weight, and a variable font is one file covering many (`weight: '100 900'`). `weightCount` is the
+* derivation over these, not their count.
+*
+* `postscriptName` names this exact file (`YahooSans-BoldItalic`). CSS never needs it — a stylesheet
+* addresses the FAMILY and lets the browser pick by weight/style — but a native platform references
+* a file directly, and it can't be derived from the family name. Optional because nothing that feeds
+* a config records one today; it's author/upload-supplied.
+*
+* `weight` and `style` are checked as invariants rather than shapes, so an edit with a value
+* `@font-face` doesn't accept is refused while a stored config holding one still loads.
+*/
+const FontFileDefinition = defineSubEntity({
 	name: "file",
 	label: "Font file",
 	labelPlural: "Files",
@@ -9,11 +24,42 @@ const FontFile = defineSubEntity({
 		src: z.string(),
 		format: z.string().optional(),
 		/** `400`, or a RANGE (`'100 900'`) for a variable font's single file. */
-		weight: z.union([z.number(), z.string()]).optional(),
-		style: z.string().optional(),
+		weight: z.union([z.number(), z.string()]).refine(isFontFaceWeight, { error: "an `@font-face` font-weight: `auto`, `normal`, `bold`, or a number from 1 to 1000, or two of those as a range (`100 900`)." }).optional(),
+		style: z.string().refine(isFontFaceStyle, { error: "an `@font-face` font-style: `auto`, `normal`, `italic`, or `oblique` with up to two angles (`oblique 10deg`)." }).optional(),
 		postscriptName: z.string().optional()
 	})
 });
+const FONT_WEIGHT_PART = /^(normal|bold|\d+(\.\d+)?)$/i;
+const FONT_STYLE = /^(auto|normal|italic|oblique(\s+-?\d+(\.\d+)?deg){0,2})$/i;
+/** Whether a value is one the `@font-face` `font-weight` descriptor accepts. `bolder` and `lighter`
+*  are relative to a parent and mean nothing on a face. */
+function isFontFaceWeight(value) {
+	const text = String(value).trim();
+	if (/^auto$/i.test(text)) return true;
+	const parts = text.split(/\s+/);
+	return parts.length <= 2 && parts.every((part) => {
+		if (!FONT_WEIGHT_PART.test(part)) return false;
+		const number = Number(part);
+		return Number.isNaN(number) || number >= 1 && number <= 1e3;
+	});
+}
+/** Whether a value is one the `@font-face` `font-style` descriptor accepts. */
+function isFontFaceStyle(value) {
+	return FONT_STYLE.test(value.trim());
+}
+/**
+* A file's weight and style as `@font-face` descriptor values. A stored config can still hold a value
+* the schema now refuses, so one the descriptor doesn't accept is left out rather than written.
+*/
+function fontFileDescriptors(file) {
+	const weight = file.weight === void 0 ? void 0 : String(file.weight).trim();
+	const style = file.style?.trim();
+	return {
+		...weight !== void 0 && isFontFaceWeight(weight) ? { weight } : {},
+		...style !== void 0 && isFontFaceStyle(style) ? { style } : {}
+	};
+}
+const FontFile = FontFileDefinition;
 const Font = defineEntity({
 	kind: "font",
 	label: "Font",
@@ -73,4 +119,4 @@ function fontFamilyStack(font) {
 	return font.variable ? `var(${font.variable}, ${named})` : named;
 }
 //#endregion
-export { Font, FontFile, cssString, fontFamilyStack };
+export { Font, FontFile, cssString, fontFamilyStack, fontFileDescriptors, isFontFaceStyle, isFontFaceWeight };

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/Settings.d.ts

@@ -41,6 +41,7 @@ type CssPrefix = z.output<typeof prefix>;
 declare const CSS_DEFAULTS: {
   readonly prefix: "uds";
   readonly preflight: true;
+  readonly fontFaces: true;
   readonly rem: "16px";
 };
 /** The `css` section — how a web system names what it emits and where its stylesheet applies. A
@@ -52,6 +53,7 @@ declare const CssSectionDefinition: SubEntityClass<z.ZodObject<{
   }, z.core.$strict>]>>;
   scope: z.ZodOptional<z.ZodString>;
   preflight: z.ZodOptional<z.ZodBoolean>;
+  fontFaces: z.ZodOptional<z.ZodBoolean>;
   rem: z.ZodOptional<z.ZodString>;
   content: z.ZodOptional<z.ZodArray<z.ZodString>>;
   safelist: z.ZodOptional<z.ZodType<SafelistEntry[], readonly SafelistEntry[], z.core.$ZodTypeInternals<SafelistEntry[], readonly SafelistEntry[]>>>;
@@ -115,6 +117,7 @@ declare const SettingsDefinition: EntityClass<z.ZodObject<{
     }, z.core.$strict>]>>;
     scope: z.ZodOptional<z.ZodString>;
     preflight: z.ZodOptional<z.ZodBoolean>;
+    fontFaces: z.ZodOptional<z.ZodBoolean>;
     rem: z.ZodOptional<z.ZodString>;
     content: z.ZodOptional<z.ZodArray<z.ZodString>>;
     safelist: z.ZodOptional<z.ZodType<SafelistEntry[], readonly SafelistEntry[], z.core.$ZodTypeInternals<SafelistEntry[], readonly SafelistEntry[]>>>;

package/dist/entities/system/Settings.js

@@ -64,6 +64,7 @@ const prefix = z.union([z.string(), z.strictObject({
 const CSS_DEFAULTS = {
 	prefix: "uds",
 	preflight: true,
+	fontFaces: true,
 	rem: "16px"
 };
 const cssFields = z.strictObject({
@@ -84,6 +85,12 @@ const cssFields = z.strictObject({
 		description: "Start the stylesheet with the element resets, so buttons, inputs and headings begin from the same baseline in every browser. Off, the page keeps its own base styles. Unset, on.",
 		default: CSS_DEFAULTS.preflight
 	}).optional(),
+	/** Whether the app's stylesheet carries an `@font-face` rule for each file its fonts declare. */
+	fontFaces: z.boolean().meta({
+		title: "Font faces",
+		description: "Write an `@font-face` rule into the stylesheet for each file a font declares, so a `font-family` that names it loads that file. Off, the app loads its fonts itself, as with `next/font` or its own `@font-face` rules; Create's canvas still paints them. Unset, on.",
+		default: CSS_DEFAULTS.fontFaces
+	}).optional(),
 	/** The root font size of the page this sheet is for, as CSS — what one `rem` is. Stated, the app's
 	*  sheet sets it and a token's `px()` reads a `rem` value against it; a fixed size (`16px`, `62.5%`,
 	*  `1em`) folds to pixels against the browser's 16px default, a fluid one (`clamp(…)`) leaves a

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 };