@yahoo/uds-create-config 5.19.1 → 5.21.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 = 20261009193004;
 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.
@@ -1323,6 +1328,31 @@ declare class Config {
    * only as a borrow the picker offered and the read then refused.
    */
   private extensionBody;
+  /**
+   * A source's body with a linked extension's `extend` laid over it, the one merge every read and
+   * write of a borrowed row goes through. An `extend` whose `__ref` names another entity of the kind
+   * (a link's `override: Motion.ref('css/scale')`) re-points the path: it reads as that entity, as
+   * this config resolves it, with the rest of the `extend` over it. The kind's
+   * {@link EntityKind.rebaseLinkedBody} then adapts the base before the merge.
+   *
+   * A target that resolves to nothing, names another kind, or leads back to this path through other
+   * re-pointed paths leaves an empty body, which the kind's schema refuses, so the row reads as
+   * nothing. The pin's invariants refuse the last two when they're written, and the build reports a
+   * missing target (`brokenLinkRedirects`).
+   */
+  laidLinkedBody({
+    kind,
+    path,
+    body,
+    extend
+  }: {
+    kind: string;
+    path: string;
+    body: Record<string, unknown>;
+    extend: Record<string, unknown>;
+  }): Record<string, unknown>;
+  /** The body of the entity a re-pointed path names, or `undefined` when there is none to read. */
+  private redirectedBody;
   /**
    * Resolve one locally extended linked item: the pinned source body, shallowly overlaid by the fields
    * authored here, then parsed through this config's kind. Parsing on this side is what lets a React

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.
@@ -1784,7 +1800,12 @@ var Config = class Config {
 					kind: patch.kind,
 					path: pathOf(extension)
 				}) : void 0;
-				const inherited = current ? extendBody(current.source, current.overlay) : resolved.toJSON();
+				const inherited = current ? this.at(snapshot).laidLinkedBody({
+					kind: patch.kind,
+					path: pathOf(extension),
+					body: current.source,
+					extend: current.overlay
+				}) : resolved.toJSON();
 				const materialized = snapshot.withChanges([itemChange(entry, patch.kind, patch.path, inherited)]);
 				const changed = this.applySub(materialized, patch, materialized.get(patch.kind, patch.path) ?? resolved, mode);
 				const body = changed.get(patch.kind, patch.path)?.toJSON();
@@ -1868,14 +1889,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 ? this.at(snapshot).laidLinkedBody({
+				kind: patch.kind,
+				path: pathOf(extension),
+				body: current.source,
+				extend: 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 = this.at(snapshot).laidLinkedBody({
+				kind: patch.kind,
+				path: pathOf(extension),
+				body: sourceBody,
+				extend: local
+			});
 			const createSchema = wholeBodySchema(entry, { config: this });
 			let merged = candidate;
 			if (createSchema) {
@@ -1894,8 +1925,12 @@ var Config = class Config {
 				if (!sourceKind || !write) reject("UNSUPPORTED", `Cannot edit ${patch.kind} "${patch.path}" — "${slug}" has no way to record the change`);
 				const accessor = view.accessorOf(patch.kind) ?? patch.kind;
 				const existing = view.sourceOverlay(slug, patch.kind, patch.path);
+				const { target: redirect, rest } = redirectOf(local);
 				const overlay = {
-					...classifyOverlay(local, sourceBody),
+					...redirect === void 0 ? classifyOverlay(local, sourceBody) : {
+						override: { __ref: redirect },
+						...Object.keys(rest).length > 0 ? { extend: rest } : {}
+					},
 					...existing?.hidden ? { hidden: true } : {}
 				};
 				const data = view.directiveWrite({
@@ -2610,12 +2645,18 @@ 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 merged = this.laidLinkedBody({
+			kind,
+			path: pathOf(extension),
+			body: inherited,
+			extend: extension.extend ?? {}
+		});
 		return this.entityOf(kind)?.prepareLinkedBody?.({
 			path: pathOf(extension),
 			body: merged,
@@ -2624,6 +2665,46 @@ var Config = class Config {
 		}) ?? merged;
 	}
 	/**
+	* A source's body with a linked extension's `extend` laid over it, the one merge every read and
+	* write of a borrowed row goes through. An `extend` whose `__ref` names another entity of the kind
+	* (a link's `override: Motion.ref('css/scale')`) re-points the path: it reads as that entity, as
+	* this config resolves it, with the rest of the `extend` over it. The kind's
+	* {@link EntityKind.rebaseLinkedBody} then adapts the base before the merge.
+	*
+	* A target that resolves to nothing, names another kind, or leads back to this path through other
+	* re-pointed paths leaves an empty body, which the kind's schema refuses, so the row reads as
+	* nothing. The pin's invariants refuse the last two when they're written, and the build reports a
+	* missing target (`brokenLinkRedirects`).
+	*/
+	laidLinkedBody({ kind, path, body, extend }) {
+		const { target, rest } = redirectOf(extend);
+		const base = target === void 0 ? body : this.redirectedBody({
+			kind,
+			path,
+			target
+		}) ?? {};
+		return extendBody(rebasedLinkedBody({
+			entry: this.entityOf(kind),
+			path,
+			body: base,
+			extend: rest
+		}), rest);
+	}
+	/** The body of the entity a re-pointed path names, or `undefined` when there is none to read. */
+	redirectedBody({ kind, path, target }) {
+		if (kindOf(target) !== kind) return void 0;
+		const reading = redirecting.get(this.state) ?? /* @__PURE__ */ new Set();
+		const key = `${kind}:${path}`;
+		if (reading.has(key)) return void 0;
+		reading.add(key);
+		redirecting.set(this.state, reading);
+		try {
+			return this.resolveRef(target)?.toJSON();
+		} finally {
+			reading.delete(key);
+		}
+	}
+	/**
 	* Resolve one locally extended linked item: the pinned source body, shallowly overlaid by the fields
 	* authored here, then parsed through this config's kind. Parsing on this side is what lets a React
 	* Native kind transform or reject a web value rather than trusting the source kind's rules.
@@ -3519,6 +3600,12 @@ var Config = class Config {
 			},
 			theirs
 		});
+		if (laid && redirectOf(laid).target !== void 0) return this.laidLinkedBody({
+			kind,
+			path,
+			body: theirs,
+			extend: laid
+		});
 		return laid ? {
 			...theirs,
 			...laid
@@ -5425,7 +5512,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 > 20261009193004) 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 +5677,29 @@ 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.
 */
+/** The paths each config is reading through a re-pointed link, for {@link Config.laidLinkedBody} to
+*  find a loop by. Keyed on the config's state, which every read of one config shares. */
+const redirecting = /* @__PURE__ */ new WeakMap();
+/**
+* The entity an `extend` re-points its path to, and the rest of it: a link's `override` written as a
+* ref lands in the stored `extend` as its `__ref`, beside whatever the `extend` verb adds.
+*/
+function redirectOf(extend) {
+	const { __ref: target, ...rest } = extend;
+	return typeof target === "string" ? {
+		target,
+		rest
+	} : { rest: extend };
+}
+/** 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 };