@yahoo/uds-create-config 5.19.1 → 5.20.0

package/dist/entities/system/motion-variants.js

@@ -71,6 +71,11 @@ const MOTION_VARIANT_STATES = [
 	"whileDrag"
 ];
 const jsBody = (config, path) => jsMotionBody(config, path);
+/** A named CSS preset's body. */
+const cssBody = (config, path) => {
+	const body = config.resolve("motion", path)?.toJSON();
+	return body?.runtime === "css" ? body : void 0;
+};
 /** The variant names one state holds: a name, a list of names, or none (values, `false`). */
 function stateVariantNames(value) {
 	if (typeof value === "string") return [value];
@@ -123,46 +128,55 @@ const composedComponents = (config, path) => {
 */
 const motionVariantGroups = createSliceMemo({
 	kinds: ["component", "motion"],
-	compute: (config) => {
-		const parent = /* @__PURE__ */ new Map();
-		const find = (node) => {
-			let root = node;
-			while (parent.has(root) && parent.get(root) !== root) root = parent.get(root);
-			parent.set(node, root);
-			return root;
-		};
-		const join = (a, b) => {
-			const ra = find(a);
-			const rb = find(b);
-			if (ra !== rb) parent.set(ra, rb);
-		};
-		const placing = /* @__PURE__ */ new Set();
-		for (const { component, preset } of placedMotions(config)) {
-			placing.add(component);
-			join(`c\u0000${component}`, `p\u0000${preset}`);
-		}
-		for (const component of placing) {
-			const seen = new Set([component]);
-			const queue = composedComponents(config, component);
-			while (queue.length > 0) {
-				const next = queue.shift();
-				if (seen.has(next)) continue;
-				seen.add(next);
-				if (placing.has(next)) join(`c\u0000${component}`, `c\u0000${next}`);
-				queue.push(...composedComponents(config, next));
-			}
-		}
-		const groups = /* @__PURE__ */ new Map();
-		for (const node of parent.keys()) {
-			if (node[0] !== "p") continue;
-			const root = find(node);
-			const group = groups.get(root) ?? /* @__PURE__ */ new Set();
-			group.add(node.slice(2));
-			groups.set(root, group);
+	compute: (config) => variantGroupsOf({
+		config,
+		placements: placedMotions(config)
+	})
+});
+/**
+* The presets that share variant names among `placements`, closed over placement and composition as
+* {@link motionVariantGroups} describes. The JS presets' groups and the CSS presets' are each this,
+* over their own placements.
+*/
+function variantGroupsOf({ config, placements }) {
+	const parent = /* @__PURE__ */ new Map();
+	const find = (node) => {
+		let root = node;
+		while (parent.has(root) && parent.get(root) !== root) root = parent.get(root);
+		parent.set(node, root);
+		return root;
+	};
+	const join = (a, b) => {
+		const ra = find(a);
+		const rb = find(b);
+		if (ra !== rb) parent.set(ra, rb);
+	};
+	const placing = /* @__PURE__ */ new Set();
+	for (const { component, preset } of placements) {
+		placing.add(component);
+		join(`c\u0000${component}`, `p\u0000${preset}`);
+	}
+	for (const component of placing) {
+		const seen = new Set([component]);
+		const queue = composedComponents(config, component);
+		while (queue.length > 0) {
+			const next = queue.shift();
+			if (seen.has(next)) continue;
+			seen.add(next);
+			if (placing.has(next)) join(`c\u0000${component}`, `c\u0000${next}`);
+			queue.push(...composedComponents(config, next));
 		}
-		return [...groups.values()];
 	}
-});
+	const groups = /* @__PURE__ */ new Map();
+	for (const node of parent.keys()) {
+		if (node[0] !== "p") continue;
+		const root = find(node);
+		const group = groups.get(root) ?? /* @__PURE__ */ new Set();
+		group.add(node.slice(2));
+		groups.set(root, group);
+	}
+	return [...groups.values()];
+}
 /** The presets that share variant names with `preset` — itself alone when no rule places it. */
 function motionVariantGroupOf(config, preset) {
 	return motionVariantGroups(config).find((group) => group.has(preset)) ?? new Set([preset]);
@@ -181,22 +195,25 @@ function renamedBody(body, from, to) {
 }
 const mentions = (body, name) => declaredVariants(body).includes(name) || namedVariants(body).includes(name);
 /**
-* Rename a variant across every preset that shares names with `path` ({@link motionVariantGroupOf}):
-* the key in each `variants` that declares it, and each state that names it. Refused when `path` is
-* not a JS preset that declares `from`, or when a preset in the set already declares `to`, since the
-* two would become one variant.
+* Rename a variant across every preset that shares names with `path` ({@link motionVariantGroupOf},
+* or `groupOf` for a CSS preset, whose presets share names among themselves): the key in each
+* `variants` that declares it, and each state that names it. Refused when `path` is no preset that
+* declares `from`, or when a preset in the set already declares `to`, since the two would become one
+* variant.
 */
-function renameMotionVariant(config, { path, from, to }) {
-	const own = jsBody(config, path);
-	if (!own) reject("NOT_FOUND", `"${path}" is not a JS motion preset, so it has no variants.`);
+function renameMotionVariant(config, { path, from, to, groupOf }) {
+	const css = cssBody(config, path) !== void 0;
+	const bodyOf = css ? cssBody : jsBody;
+	const own = bodyOf(config, path);
+	if (!own) reject("NOT_FOUND", `"${path}" is not a motion preset.`);
 	if (!declaredVariants(own).includes(from)) reject("NOT_FOUND", `"${path}" declares no variant "${from}".`);
 	if (from === to) return config;
-	const group = [...motionVariantGroupOf(config, path)];
-	const taken = group.filter((preset) => declaredVariants(jsBody(config, preset)).includes(to));
+	const group = [...css && groupOf ? groupOf(config, path) : motionVariantGroupOf(config, path)];
+	const taken = group.filter((preset) => declaredVariants(bodyOf(config, preset)).includes(to));
 	if (taken.length > 0) reject("ALREADY_EXISTS", `"${to}" is already a variant of ${taken.map((preset) => `"${preset}"`).join(", ")}, which animate${taken.length === 1 ? "s" : ""} with "${path}". Renaming "${from}" onto it would make the two one variant.`);
 	let next = config;
 	for (const preset of group) {
-		const body = jsBody(next, preset);
+		const body = bodyOf(next, preset);
 		if (!body || !mentions(body, from)) continue;
 		const inline = inlineMotions(next).valid.find((entry) => entry.id === preset);
 		if (!inline) {
@@ -267,4 +284,4 @@ function orphanedMotionVariants(config) {
 	return out;
 }
 //#endregion
-export { MOTION_VARIANT_STATES, declaredVariants, inlineMotionId, inlineMotions, isInlineMotion, jsMotionBody, motionVariantGroups, orphanedMotionVariants, placedMotions, renameMotionVariant, stateVariantNames };
+export { MOTION_VARIANT_STATES, declaredVariants, inlineMotionId, inlineMotions, isInlineMotion, jsMotionBody, motionVariantGroups, orphanedMotionVariants, placedMotions, renameMotionVariant, stateVariantNames, variantGroupsOf };

package/dist/entities/system/reduced-motion.d.ts

@@ -0,0 +1,20 @@
+import { Config } from "../../framework/Config.js";
+
+//#region src/entities/system/reduced-motion.d.ts
+/** The attribute a layer carries its reduced motion as. */
+declare const REDUCED_MOTION_ATTRIBUTE = "data-uds-reduced-motion";
+/** What a layer's motion does under the viewer's reduced-motion setting. */
+declare const REDUCED_MOTION_VALUES: readonly ["user", "always", "never"];
+type ReducedMotion = (typeof REDUCED_MOTION_VALUES)[number];
+/** A style rule setting a layer's reduced motion. */
+interface ReducedMotionLayer {
+  readonly component: string;
+  /** The rule's key: its condition, `*` for the unconditional rule. */
+  readonly rule: string;
+  readonly layer: string;
+  readonly value: ReducedMotion;
+}
+/** Every style rule that sets a layer's reduced motion. */
+declare function reducedMotionLayers(config: Config): readonly ReducedMotionLayer[];
+//#endregion
+export { REDUCED_MOTION_ATTRIBUTE, REDUCED_MOTION_VALUES, ReducedMotion, ReducedMotionLayer, reducedMotionLayers };

package/dist/entities/system/reduced-motion.js

@@ -0,0 +1,42 @@
+import { isPlainObject } from "../../framework/utils/field-path.js";
+import { createSliceMemo } from "../../framework/memo.js";
+//#region src/entities/system/reduced-motion.ts
+/** The style rule key a layer's reduced motion is set by. */
+const REDUCED_MOTION_KEY = "reducedMotion";
+/** The attribute a layer carries its reduced motion as. */
+const REDUCED_MOTION_ATTRIBUTE = "data-uds-reduced-motion";
+/** What a layer's motion does under the viewer's reduced-motion setting. */
+const REDUCED_MOTION_VALUES = [
+	"user",
+	"always",
+	"never"
+];
+function isReducedMotion(value) {
+	return REDUCED_MOTION_VALUES.includes(value);
+}
+const resolveReducedMotion = createSliceMemo({
+	kinds: ["component"],
+	compute: (config) => {
+		const layers = [];
+		for (const component of config.list("component")) {
+			const { styles = {} } = component.toJSON();
+			for (const [rule, entry] of Object.entries(styles)) for (const [layer, bag] of Object.entries(entry?.layers ?? {})) {
+				if (!isPlainObject(bag) || !(REDUCED_MOTION_KEY in bag)) continue;
+				const value = bag[REDUCED_MOTION_KEY];
+				if (isReducedMotion(value)) layers.push({
+					component: component.path,
+					rule,
+					layer,
+					value
+				});
+			}
+		}
+		return layers;
+	}
+});
+/** Every style rule that sets a layer's reduced motion. */
+function reducedMotionLayers(config) {
+	return resolveReducedMotion(config);
+}
+//#endregion
+export { REDUCED_MOTION_ATTRIBUTE, REDUCED_MOTION_VALUES, isReducedMotion, reducedMotionLayers };

package/dist/framework/Config.d.ts

@@ -9,7 +9,7 @@ import { RefGraph, TraverseOptions } from "./ref-graph.js";
 import { FieldsSchema } from "./utils/field-schema.js";
 import { SubEntityClass } from "./defineSubEntity.js";
 import { LocalOverlay, SourceAnswer, SourceOverlay, SourceResolver, SourceState } from "./sources.js";
-import { EntityKind } from "./registry.js";
+import { EntityKind, LayerKey } from "./registry.js";
 import { AuthoredEntry } from "./utils/group.js";
 import { EntityClass } from "./defineEntity.js";
 import { BreakPlan, LinkPlan, SourceRowState, UnlinkPlan } from "../entities/system/link-plan.js";
@@ -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 = 20261008181849;
+declare const SERIALIZED_CONFIG_VERSION = 20261009181635;
 interface SerializedConfig {
   /** See {@link SERIALIZED_CONFIG_VERSION}. Always written; a stored artifact may lack it. */
   readonly version: number;
@@ -667,6 +667,11 @@ declare class Config {
    *  was registered into this instance. `undefined` for a kind this config doesn't know. The single
    *  accessor every internal read routes through. */
   entityOf(kind: string): EntityKind | undefined;
+  /** Every key a style rule's layer bag takes that a kind owns, with the kind that owns it. See
+   *  {@link LayerKey}. */
+  layerKeys(): ReadonlyMap<string, LayerKey & {
+    readonly kind: string;
+  }>;
   /**
    * The value each of a kind's fields takes when a create leaves it out — `responsive: false` on a
    * style property, say.

package/dist/framework/Config.js

@@ -55,6 +55,9 @@ function nameEdgeReaders(entities) {
 	for (const [kind, entry] of entities) if (entry.nameEdges) readers.set(kind, entry.nameEdges);
 	return readers;
 }
+/** {@link Config.layerKeys}, once per set of registered kinds, which every config built on one
+*  registration shares. */
+const layerKeysByEntities = /* @__PURE__ */ new WeakMap();
 /**
 * The kinds whose items name an external source — what a `@slug` in a ref resolves against.
 *
@@ -812,6 +815,19 @@ var Config = class Config {
 	entityOf(kind) {
 		return this.state.entities.get(kind);
 	}
+	/** Every key a style rule's layer bag takes that a kind owns, with the kind that owns it. See
+	*  {@link LayerKey}. */
+	layerKeys() {
+		const cached = layerKeysByEntities.get(this.state.entities);
+		if (cached) return cached;
+		const out = /* @__PURE__ */ new Map();
+		for (const [kind, entity] of this.state.entities) for (const [key, declared] of Object.entries(entity.layerKeys ?? {})) out.set(key, {
+			...declared,
+			kind
+		});
+		layerKeysByEntities.set(this.state.entities, out);
+		return out;
+	}
 	/**
 	* The value each of a kind's fields takes when a create leaves it out — `responsive: false` on a
 	* style property, say.
@@ -1868,14 +1884,24 @@ var Config = class Config {
 				kind: patch.kind,
 				path: pathOf(extension)
 			}) : void 0;
-			const written = applyPathDelta(current ? extendBody(current.source, current.overlay) : resolved.toJSON(), delta, isField);
+			const written = applyPathDelta(current ? extendBody(rebasedLinkedBody({
+				entry,
+				path: pathOf(extension),
+				body: current.source,
+				extend: current.overlay
+			}), current.overlay) : resolved.toJSON(), delta, isField);
 			const local = { ...current ? current.overlay : extension.extend };
 			for (const field of touched) if (Object.hasOwn(delta, field) && delta[field] === null) delete local[field];
 			else if (Object.hasOwn(written, field)) local[field] = written[field];
 			else delete local[field];
 			const sourceBody = this.configFor(extension)?.resolve(patch.kind, pathOf(extension))?.toJSON();
 			if (!sourceBody) reject("NOT_FOUND", `Cannot edit ${patch.kind} "${patch.path}" — its source "${extension.__ref}" is unavailable`);
-			const candidate = extendBody(sourceBody, local);
+			const candidate = extendBody(rebasedLinkedBody({
+				entry,
+				path: pathOf(extension),
+				body: sourceBody,
+				extend: local
+			}), local);
 			const createSchema = wholeBodySchema(entry, { config: this });
 			let merged = candidate;
 			if (createSchema) {
@@ -2610,12 +2636,19 @@ var Config = class Config {
 		if (!base) return void 0;
 		const slug = sourceOf(extension);
 		const owns = (kindName) => source?.ownedKinds().includes(kindName) ?? false;
-		const merged = extendBody(slug ? qualifyRefs({
+		const inherited = slug ? qualifyRefs({
 			value: base.toJSON(),
 			source: slug,
 			owns,
 			namesItAlready: (target) => this.borrowsExactly(target, slug)
-		}) : base.toJSON(), extension.extend ?? {});
+		}) : base.toJSON();
+		const extend = extension.extend ?? {};
+		const merged = extendBody(rebasedLinkedBody({
+			entry: this.entityOf(kind),
+			path: pathOf(extension),
+			body: inherited,
+			extend
+		}), extend);
 		return this.entityOf(kind)?.prepareLinkedBody?.({
 			path: pathOf(extension),
 			body: merged,
@@ -5425,7 +5458,7 @@ var Config = class Config {
 	*  links from the provided sources. A declared `linkedKind` with no provided source throws. */
 	hydrateFrom(stored, options) {
 		const claimed = schemaVersionOf(stored);
-		if (claimed > 20261008181849) throw new SchemaVersionTooNew(claimed);
+		if (claimed > 20261009181635) throw new SchemaVersionTooNew(claimed);
 		const wire = upgradeSerializedConfig(stored);
 		if (!Array.isArray(wire.ownedKinds) || typeof wire.items !== "object" || wire.items === null) throw new ConfigFormatError(`Config "${stored.name ?? "system-config"}" cannot be hydrated: this is not a serialized config-v2 config (no "ownedKinds"/"items"). A pre-cutover build artifact converts through the registered cutover migration — import the config type's module (e.g. \`configs/system\`) before hydrating, or port the repo once with \`uds migrate\`.`);
 		const leftover = wire.options;
@@ -5590,6 +5623,15 @@ function extendBody(base, delta) {
 * differently, and why the source's body is a parameter. `extend: { values: [Token.ref('surface')] }`
 * means "alongside what they already accept", which has nothing to join without their list.
 */
+/** A source's body as an extension reads it before its `extend` merges in: the kind's
+*  {@link EntityKind.rebaseLinkedBody}, where it declares one. */
+function rebasedLinkedBody({ entry, path, body, extend }) {
+	return entry?.rebaseLinkedBody?.({
+		path,
+		body,
+		extend
+	}) ?? body;
+}
 function overlayBody({ overlay, theirs }) {
 	if (!overlay) return void 0;
 	return layerOverlay({

package/dist/framework/class-names.d.ts

@@ -123,7 +123,8 @@ declare function motionClassName(config: Config, path: string): string;
  * rule declares. Without this the value went nowhere — `motion` names no style property so it isn't
  * a declaration, and it IS a declared prop of the layer's element so it isn't an attribute either.
  *
- * A JS preset is skipped: it animates in the client and has no class to wear.
+ * A JS preset is skipped: it animates in the client and has no class to wear. The classes come in the
+ * order the rules apply, so the last one that applies is the preset the layer plays.
  */
 declare function componentMotionClasses(config: Config, path: string): ComponentRuleClass[];
 /**

package/dist/framework/class-names.js

@@ -277,6 +277,12 @@ function componentCompositeClasses(config, path) {
 	}
 	return out;
 }
+/** The bag keys a kind owns as props of a type, as an element's declared props spell them. */
+function ownedLayerProps(config) {
+	const out = {};
+	for (const [key, owned] of config.layerKeys()) if (owned.propType !== void 0) out[key] = { type: owned.propType };
+	return out;
+}
 /** The class a CSS motion preset is applied by. Namespaced, so it doesn't share a space with the
 *  style-prop utilities; the `@keyframes` it runs keep their own name. */
 function motionClassName(config, path) {
@@ -293,25 +299,30 @@ function motionClassName(config, path) {
 * rule declares. Without this the value went nowhere — `motion` names no style property so it isn't
 * a declaration, and it IS a declared prop of the layer's element so it isn't an attribute either.
 *
-* A JS preset is skipped: it animates in the client and has no class to wear.
+* A JS preset is skipped: it animates in the client and has no class to wear. The classes come in the
+* order the rules apply, so the last one that applies is the preset the layer plays.
 */
 function componentMotionClasses(config, path) {
 	const component = config.resolve("component", path);
 	if (!component) return [];
 	const { layers = {}, styles = {} } = component.toJSON();
 	const out = [];
-	for (const rule of Object.values(styles)) {
+	const rules = Object.values(styles);
+	const unconditional = (rule) => !rule.when || Object.keys(rule.when).length === 0;
+	for (const rule of [...rules.filter(unconditional), ...rules.filter((rule) => !unconditional(rule))]) {
 		const when = Object.fromEntries(Object.entries(rule.when ?? {}).map(([prop, value]) => [prop, refLeaf(value)]));
 		for (const [layer, bag] of Object.entries(rule.layers ?? {})) {
 			const element = layers[layer];
-			if (!isRef(element)) continue;
-			const declared = resolveComponentProps(config, pathOf(element.__ref));
+			if (element === void 0) continue;
+			const declared = {
+				...ownedLayerProps(config),
+				...isRef(element) ? resolveComponentProps(config, pathOf(element.__ref)) : {}
+			};
 			for (const [prop, value] of Object.entries(bag ?? {})) {
 				if (declared[prop]?.type !== "motion") continue;
 				const name = presetNamed(value);
 				if (name === void 0) continue;
-				const preset = config.resolve("motion", name)?.toJSON();
-				if (preset?.runtime !== "css" || !preset.keyframes) continue;
+				if ((config.resolve("motion", name)?.toJSON())?.runtime !== "css") continue;
 				out.push({
 					layer,
 					when,
@@ -530,8 +541,19 @@ function layerRoutedProps(config, path, state = {}) {
 		const declared = isRef(element) ? resolveComponentProps(config, pathOf(element.__ref)) : {};
 		for (const [prop, value] of Object.entries(bag ?? {})) {
 			if (prop.startsWith("_") || isCustomPropertyKey(prop)) continue;
-			if (prop === "motion") {
-				if ((config.resolve("motion", String(authoredValue(config, prop, value)))?.toJSON())?.runtime !== "css" || !isRef(element)) continue;
+			const owned = config.layerKeys().get(prop);
+			if (owned) {
+				const reach = owned.reach({
+					config,
+					value,
+					element
+				});
+				if (reach === "none") continue;
+				if (reach !== "prop") {
+					out[layer] ??= {};
+					out[layer][reach.attribute] = value;
+					continue;
+				}
 			}
 			const styleKey = stylePropertyPathFor({
 				config,
@@ -600,11 +622,7 @@ function styleRuleMotionClasses(config, path, state = {}) {
 		...state
 	};
 	const out = {};
-	for (const rule of componentMotionClasses(config, path)) {
-		if (!ruleApplies(rule.when, resolved)) continue;
-		out[rule.layer] ??= [];
-		if (!out[rule.layer].includes(rule.className)) out[rule.layer].push(rule.className);
-	}
+	for (const rule of componentMotionClasses(config, path)) if (ruleApplies(rule.when, resolved)) out[rule.layer] = [rule.className];
 	return out;
 }
 /**

package/dist/framework/defineEntity.d.ts

@@ -355,7 +355,9 @@ declare function defineEntity<F extends FieldsSchema, G extends FieldsSchema = z
    * an edit to one has nowhere to land.
    */
   bulkOverlayWrite?: (args: BulkOverlayWrite) => Record<string, unknown>; /** Adapt a pinned source body before linked validation. */
-  prepareLinkedBody?: EntityKind['prepareLinkedBody'];
+  prepareLinkedBody?: EntityKind['prepareLinkedBody']; /** See {@link EntityKind.rebaseLinkedBody}. */
+  rebaseLinkedBody?: EntityKind['rebaseLinkedBody']; /** See {@link EntityKind.layerKeys}. */
+  layerKeys?: EntityKind['layerKeys'];
   /**
    * Edges this kind's data implies by name rather than by ref, and how to rewrite one — the pair that
    * makes a record keyed by another kind's item names behave like a reference: reported by

package/dist/framework/defineEntity.js

@@ -124,6 +124,8 @@ function defineEntity(spec) {
 		bulkDirectives: spec.bulkDirectives,
 		bulkOverlayWrite: spec.bulkOverlayWrite,
 		prepareLinkedBody: spec.prepareLinkedBody,
+		rebaseLinkedBody: spec.rebaseLinkedBody,
+		layerKeys: spec.layerKeys,
 		nameEdges: spec.nameEdges,
 		styleBags: spec.styleBags,
 		rewriteName: spec.rewriteName,

package/dist/framework/registered.d.ts

@@ -74,6 +74,13 @@ interface RegisteredEntities {}
  * arguments a locally authored component would.
  */
 interface RegisteredComponentContracts {}
+/**
+ * Qualified linked motion preset → the runtimes a link can read it as: its own, and the other one when
+ * the preset converts (`motion/convert`). The consumer's emitted `uds-env.d.ts` fills it from the
+ * installed source config, so a link that swaps a preset to a runtime it can't convert to is a type
+ * error at the swap. Unaugmented, a swap takes either runtime.
+ */
+interface RegisteredMotionRuntimes {}
 /** The generated contract for one qualified linked component, or an open fallback before build. */
 type ComponentContractOf<P extends string> = P extends keyof RegisteredComponentContracts ? RegisteredComponentContracts[P] : {
   layers: Record<string, unknown>;
@@ -100,4 +107,4 @@ type PathOf<K extends string> = K extends keyof RegisteredPaths ? RegisteredPath
 /** The value type for a style prop — its registered union, else `string`. */
 type ValueOf<P extends string> = P extends keyof RegisteredStyleProps ? RegisteredStyleProps[P] extends string | number ? RegisteredStyleProps[P] : string : string;
 //#endregion
-export { ComponentContractOf, PathOf, RegisteredComponentContracts, RegisteredEntities, RegisteredModifiers, RegisteredPaths, RegisteredStyleProps, ValueOf };
+export { ComponentContractOf, PathOf, RegisteredComponentContracts, RegisteredEntities, RegisteredModifiers, RegisteredMotionRuntimes, RegisteredPaths, RegisteredStyleProps, ValueOf };

package/dist/framework/registry.d.ts

@@ -47,8 +47,45 @@ type AuthoredValueForm = (ctx: {
   readonly target: string; /** The leaves the target offers, which is what the form has to answer with. */
   readonly leaves: readonly string[];
 }) => z.ZodTypeAny | undefined;
+/**
+ * A key a style rule's layer bag takes that a kind owns, rather than a prop the element declares or a
+ * style property: `motion` names a preset, `reducedMotion` says how the layer treats the OS setting.
+ */
+interface LayerKey {
+  /** What the key takes. `declared` is the element's own prop of the same name, where it declares
+   *  one, which the key's value can also be. */
+  readonly schema: (declared: z.ZodTypeAny | undefined) => z.ZodTypeAny;
+  /**
+   * How the value reaches the layer's element: as the element's prop of the key's name (`'prop'`),
+   * as an attribute (`{ attribute }`), or by some other route the build writes, such as a class the
+   * stylesheet emits (`'none'`).
+   */
+  readonly reach: (args: {
+    readonly config: Config; /** The value as the rule stores it. */
+    readonly value: unknown; /** The layer's element: a component ref, or a tag. */
+    readonly element: unknown;
+  }) => 'prop' | 'none' | {
+    readonly attribute: string;
+  };
+  /** The prop type the key stands for on every element, for a reader that finds an element's props by
+   *  type: `motion`'s is `'motion'`, so a layer whose element declares no `motion` prop still plays a
+   *  preset a rule names. */
+  readonly propType?: string;
+}
 interface EntityKind {
   readonly name: string;
+  /**
+   * A source's body as this config reads it under a linked extension, before the extension's `extend`
+   * merges in: for a kind whose extension can change what the rest of the body means, such as a motion
+   * preset whose `runtime` the extension sets.
+   */
+  readonly rebaseLinkedBody?: (args: {
+    readonly path: string;
+    readonly body: Record<string, unknown>;
+    readonly extend: Record<string, unknown>;
+  }) => Record<string, unknown>;
+  /** The keys a style rule's layer bag takes that this kind owns, by key. See {@link LayerKey}. */
+  readonly layerKeys?: Readonly<Record<string, LayerKey>>;
   /** Adapt a pinned source body before this kind validates a linked extension. */
   readonly prepareLinkedBody?: (args: {
     readonly path: string;
@@ -333,4 +370,4 @@ interface EntityKind {
  *  kind def a `Config` holds (`config.entityOf(kind)`); `undefined` → no ops. */
 declare function opsForKind(entry: EntityKind | undefined, config?: Config): DerivedOp[];
 //#endregion
-export { AuthoredValueForm, ComputedFields, ComputedInput, EntityKind, Linkable, opsForKind };
+export { AuthoredValueForm, ComputedFields, ComputedInput, EntityKind, LayerKey, Linkable, opsForKind };

package/dist/framework/registry.js

@@ -32,7 +32,7 @@ function titleCase(kind) {
 /** Derive a kind's immutable metadata from its field schemas — the value a `defineEntity`/
 *  `defineDerivedEntity` attaches to its class and a `Config.register` stores in `#entities`. */
 function buildKind(spec) {
-	const { name, prepareLinkedBody, fields, groupFields, subEntities = {}, computed, label, labelPlural, schemas: userSchemas, derived, sourceIdentity, sourceOrigin, authoredRefs, linkable, localGroupFields, emergentGroups, singleton = false, bareMember, sourceResolution, bulkAdopts, bulkOverlay, bulkDirectives, bulkOverlayWrite, nameEdges, rewriteName, styleBags, uniqueLeaves, authoredValue, mentionFields, invariants } = spec;
+	const { name, prepareLinkedBody, rebaseLinkedBody, layerKeys, fields, groupFields, subEntities = {}, computed, label, labelPlural, schemas: userSchemas, derived, sourceIdentity, sourceOrigin, authoredRefs, linkable, localGroupFields, emergentGroups, singleton = false, bareMember, sourceResolution, bulkAdopts, bulkOverlay, bulkDirectives, bulkOverlayWrite, nameEdges, rewriteName, styleBags, uniqueLeaves, authoredValue, mentionFields, invariants } = spec;
 	const allComputed = {
 		sources: ({ member, config }) => sourceSlugs(member, config),
 		borrowedFrom: ({ config, path }) => config.borrowedFrom(name, path),
@@ -49,6 +49,8 @@ function buildKind(spec) {
 	return {
 		name,
 		...prepareLinkedBody ? { prepareLinkedBody } : {},
+		...rebaseLinkedBody ? { rebaseLinkedBody } : {},
+		...layerKeys ? { layerKeys } : {},
 		label: resolvedLabel,
 		entityName: spec.entityName ?? entityClassName(name),
 		labelPlural: labelPlural ?? `${resolvedLabel}s`,

package/dist/framework/render-spec.js

@@ -5,8 +5,8 @@ import { unconditionalPreviewProps } from "./preview-store.js";
 import { authoredBag, authoredValue, declaredPropDefaults, memberFromLeaf, refListOf, resolveComponentProps, stylePropertyPathFor } from "./projections.js";
 import { slotHostLayer } from "./slot-host.js";
 import { forwardRoutes, forwardedLayers, intoName, isValueSlot, renderBindingsOf, routesContent } from "./prop-surface.js";
-import { inlineMotionProps, jsMotionPresets } from "../entities/system/motion-presets.js";
 import { withRequiredContentHidden } from "../entities/system/required-content-layers.js";
+import { inlineMotionProps, jsMotionPresets } from "../entities/system/motion-presets.js";
 import { graftPreviewElements } from "../spec/preview-elements.js";
 import { componentLayerClass, componentPropClasses, componentRuleClasses, layerJsMotionPresets, layerRoutedProps, splitStyleProps, styleRuleMotionClasses } from "./class-names.js";
 //#region src/framework/render-spec.ts
@@ -1350,7 +1350,7 @@ function expandInstance(sink, path, instanceProps, content, hint, instanceSlots)
 			"data-uds-component": path,
 			"data-uds-layer": layer,
 			...forwarded[layer],
-			...motionPreset !== void 0 ? presetProps[motionPreset] : {},
+			...motionPreset !== void 0 ? withoutKey(presetProps[motionPreset], "reducedMotion") : {},
 			...Object.fromEntries((valueRoutes.get(layer) ?? []).filter(({ from }) => state[from] !== void 0).map(({ from, into }) => [into, state[from]])),
 			...isRoot ? rest : {},
 			...slot && slotValue !== void 0 ? { [intoName(slot.into)]: slotValue } : {},
@@ -1511,5 +1511,10 @@ function sameKeys(a, b) {
 function expandComponent(config, path, props = {}, options = {}) {
 	return expandSpec(config, instanceSpec(path, props), options);
 }
+/** A record without one of its keys. */
+function withoutKey(record, key) {
+	const { [key]: _omitted, ...rest } = record ?? {};
+	return rest;
+}
 //#endregion
 export { ANATOMY_MARKER, MOTION_FACTORY, anatomyElementComponent, anatomyTextProp, andListOf, boundElementType, componentSpec, deriveSpec, entryKeyOf, expandComponent, expandSpec, instanceSpec, isExpression, layerTextProp, liveStateProps, previewSpec, propInto, propsIntoLayer, readStatePointer, resolveValue, resolveVisibility, routeOf, routesOf, slotAnatomyPropOf, slotTargetsOf, specWithResolvedVisibility, spelled, statePointerProp, valueForwardsOf, visibilityStateProps, visibilityTerms, withoutTruthyTerm, wrappedElementKey };

package/dist/framework/schema-version.d.ts

@@ -15,7 +15,7 @@ import { Patch, SerializedConfig } from "./Config.js";
  * sets this constant to its own older timestamp; the merge ref then carries a registered migration
  * newer than the constant, and the assertion fails until the author re-mints.
  */
-declare const CURRENT_SCHEMA_VERSION = 20261008181849;
+declare const CURRENT_SCHEMA_VERSION = 20261009181635;
 /** What the walkers need to see of an envelope — loose on purpose, so a typed `SerializedConfig`
  *  and a raw old-shape record both flow in without casts. */
 interface VersionStamped {

package/dist/framework/schema-version.js

@@ -13,7 +13,7 @@ import { ConfigFormatError } from "./rejection.js";
 * sets this constant to its own older timestamp; the merge ref then carries a registered migration
 * newer than the constant, and the assertion fails until the author re-mints.
 */
-const CURRENT_SCHEMA_VERSION = 20261008181849;
+const CURRENT_SCHEMA_VERSION = 20261009181635;
 /** The mint that moved `options` into the `settings` kind — restated here, rather than imported
 *  from the migration that owns it, because that migration imports this module. */
 const SETTINGS_AS_KIND_VERSION = 20260908171448;
@@ -45,7 +45,7 @@ function registerSchemaMigrations(...migrations) {
 	for (const migration of migrations) {
 		if (migration.version !== 1 && !isMintTimestamp(migration.version)) throw new Error(`Schema migration version ${migration.version} is not a mint timestamp — mint one with \`date +%Y%m%d%H%M%S\`, like a supabase migration.`);
 		if (REGISTERED.has(migration.version)) throw new Error(`A schema migration at version ${migration.version} is already registered.`);
-		if (migration.version > 20261008181849) throw new Error(`Schema migration ${migration.version} is newer than CURRENT_SCHEMA_VERSION (${CURRENT_SCHEMA_VERSION}) — a stale branch merged, or the mint forgot to bump the constant. Re-mint: set CURRENT_SCHEMA_VERSION to the newest migration version.`);
+		if (migration.version > 20261009181635) throw new Error(`Schema migration ${migration.version} is newer than CURRENT_SCHEMA_VERSION (${CURRENT_SCHEMA_VERSION}) — a stale branch merged, or the mint forgot to bump the constant. Re-mint: set CURRENT_SCHEMA_VERSION to the newest migration version.`);
 		REGISTERED.set(migration.version, migration);
 	}
 }
@@ -102,7 +102,7 @@ function pendingFor(version, target, options) {
 * Already-current input passes through untouched — same reference, so hot paths pay nothing.
 */
 function upgradeSerializedConfig(json, options) {
-	const target = options?.target ?? 20261008181849;
+	const target = options?.target ?? 20261009181635;
 	const version = detectedWireVersion(json);
 	if (version > target) throw new SchemaVersionTooNew(version, target);
 	const raw = json;
@@ -160,7 +160,7 @@ function upgradedSources(json, options) {
 * meaning under the current schema and replay skips it — reported by the caller, not swallowed here.
 */
 function upgradePatch(patch, writtenAt, options) {
-	const target = options?.target ?? 20261008181849;
+	const target = options?.target ?? 20261009181635;
 	if (writtenAt > target) throw new SchemaVersionTooNew(writtenAt, target);
 	let current = patch;
 	for (const migration of pendingFor(writtenAt, target, options)) {
@@ -179,7 +179,7 @@ function upgradePatch(patch, writtenAt, options) {
 * stamp would cause.
 */
 function upgradeDraftEntries(draft, options) {
-	const target = options?.target ?? 20261008181849;
+	const target = options?.target ?? 20261009181635;
 	const entries = [];
 	const held = [];
 	const retired = [];