@yahoo/uds-create-config 4.52.0 → 4.53.0

package/dist/{capture → entities/canvas}/node-patches.d.ts

@@ -1,7 +1,9 @@
-import { Config, Patch } from "../framework/Config.js";
-import { Spec } from "./capture-to-spec.js";
+import { Config, Patch } from "../../framework/Config.js";
+import { Spec } from "../../capture/capture-to-spec.js";
 
-//#region src/capture/node-patches.d.ts
+//#region src/entities/canvas/node-patches.d.ts
+/** The key a placed node's own element takes when its rows read back as a spec. */
+declare const PLACED_NODE_KEY = "root";
 interface Placement {
   readonly page: string;
   readonly x?: number;
@@ -29,4 +31,4 @@ declare function specToNodePatches({
   readonly placement: Placement;
 }): Patch[];
 //#endregion
-export { specToNodePatches };
+export { PLACED_NODE_KEY, specToNodePatches };

package/dist/{capture → entities/canvas}/node-patches.js

@@ -1,10 +1,23 @@
-import { ref } from "../framework/utils/refs.js";
-//#region src/capture/node-patches.ts
+import { rejectData } from "../../framework/rejection.js";
+import { ref } from "../../framework/utils/refs.js";
+//#region src/entities/canvas/node-patches.ts
 /**
 * A spec as the node rows of one new placed node. A placed node's content is its subtree rows, one
 * per element, at `<node>/<element key>`, each pointing at its children by ref; the root element's
 * content lives on the placed node itself beside its placement.
 */
+/** The system this canvas draws on, with the slug node types are qualified by. */
+function attachedSystem(config) {
+	const [source] = config.list("system-source");
+	const system = source ? config.sourceFor(source.path) : void 0;
+	if (!source || !system) return rejectData("This canvas has no system attached, so there are no components to place on it.");
+	return {
+		slug: source.path,
+		system
+	};
+}
+/** The key a placed node's own element takes when its rows read back as a spec. */
+const PLACED_NODE_KEY = "root";
 const INTRINSIC_TAG = /^[a-z][a-zA-Z0-9-]*$/;
 const SPEC_PRIMITIVES = new Set(["Slot", "Fragment"]);
 /** A spec element's `type` as the ref a node row stores, qualified with the system's slug. */
@@ -96,4 +109,4 @@ function specToNodePatches({ config, nodeId, spec, slug, placement }) {
 	return patches;
 }
 //#endregion
-export { specToNodePatches };
+export { PLACED_NODE_KEY, attachedSystem, elementTypeRef, postOrder, specToNodePatches };

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

@@ -12,9 +12,10 @@ import { TokenClass } from "./Token.js";
 import { StoredPreviewCondition } from "../../framework/preview-store.js";
 import { RepeatSpec } from "../../framework/render-spec.js";
 import { AsInput, DefaultsOf, LayerMap, PhantomCallProps, PhantomReadProps, PropMap, RenderArgs, StyleRuleInput } from "./defineComponent.js";
-import { listSlots, namedSlots, slotHostedBy, slotOf } from "../../spec/slot.js";
+import { listSlots, namedSlots, slotHostedBy, slotOf, slotsFor } from "../../spec/slot.js";
 import { cellAt } from "../../spec/cell.js";
 import { instanceAt } from "../../spec/instance.js";
+import { ForwardOptions, forwardOptions } from "./component-forwards.js";
 import { Config } from "../../framework/Config.js";
 import { z } from "zod";
 
@@ -739,6 +740,26 @@ declare const ComponentEntity: EntityClass<z.ZodObject<{
       }, z.core.$strip>>;
     }, z.core.$strip>;
   };
+  readonly 'element-duplicate': {
+    readonly input: z.ZodObject<{
+      path: z.ZodType<string, string | undefined, z.core.$ZodTypeInternals<string, string | undefined>>;
+      key: z.ZodString;
+      data: z.ZodPrefault<z.ZodObject<{
+        count: z.ZodOptional<z.ZodNumber>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+  };
+  readonly 'layer-forward': {
+    readonly input: z.ZodObject<{
+      path: z.ZodType<string, string | undefined, z.core.$ZodTypeInternals<string, string | undefined>>;
+      key: z.ZodString;
+      data: z.ZodObject<{
+        props: z.ZodUnion<readonly [z.ZodLiteral<"*">, z.ZodArray<z.ZodString>]>;
+        except: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        replace: z.ZodOptional<z.ZodBoolean>;
+      }, z.core.$strip>;
+    }, z.core.$strip>;
+  };
   readonly 'element-delete': {
     readonly input: z.ZodObject<{
       path: z.ZodType<string, string | undefined, z.core.$ZodTypeInternals<string, string | undefined>>;
@@ -768,6 +789,17 @@ declare const ComponentEntity: EntityClass<z.ZodObject<{
     }, z.core.$strip>;
   };
 }, {
+  /**
+   * What each layer can forward, for the layers that render a component with props: every prop its
+   * element exposes, whether the layer forwards it now, and why one is blocked (the component
+   * declares it, or a sibling layer forwards it). Read before writing `forwards`, so "everything
+   * but icon" is a list the caller can spell.
+   */
+  readonly forwardable: ({
+    config,
+    path,
+    member
+  }: ComputedInput) => Record<string, ForwardOptions>;
   /**
    * The prop names an instance may fill through a spec element's `slots` field — every prop that
    * routes content: a `slot`, or a `forward` whose far end takes content. Resolved over the
@@ -874,6 +906,8 @@ interface ComponentClass extends Omit<typeof ComponentEntity, 'ref' | 'item'> {
   slot: typeof slotOf;
   slotHostedBy: typeof slotHostedBy;
   namedSlots: typeof namedSlots;
+  slotsFor: typeof slotsFor;
+  forwardOptions: typeof forwardOptions;
   cell: typeof cellAt;
   instance: typeof instanceAt;
 }

package/dist/entities/system/Component.js

@@ -16,9 +16,10 @@ import { storedPreview } from "../../framework/preview-store.js";
 import { glyphPropsOf, propOwner, propValueDomain, refListOf, resolveComponentProps, stylePropValueLeaves, validateComponentProps } from "../../framework/projections.js";
 import { carriesContent, intoName, isValueSlot, renderBoundProp, routedPropIn, routesContent } from "../../framework/prop-surface.js";
 import { slotAnatomyPropOf, slotTargetsOf, withoutTruthyTerm } from "../../framework/render-spec.js";
-import { listSlots, namedSlots, slotHostedBy, slotOf } from "../../spec/slot.js";
+import { listSlots, namedSlots, slotHostedBy, slotOf, slotsFor } from "../../spec/slot.js";
 import { cellAt } from "../../spec/cell.js";
 import { instanceAt } from "../../spec/instance.js";
+import { forwardOptions, forwardsWrite } from "./component-forwards.js";
 import { File } from "./File.js";
 import { forwardRouteInvariants, refusedRoutes } from "./forward-route-invariants.js";
 import { iconDomainInvariants } from "./icon-domain-invariants.js";
@@ -275,6 +276,11 @@ const ForwardDefinition = defineSubEntity({
 					input: entry,
 					message: `"${name}" is not a prop of layer "${key}"'s element (${pathOf(element.__ref)}).`
 				});
+				if (name && body.props?.[name] != null) ctx.issues.push({
+					code: "custom",
+					input: entry,
+					message: `"${name}" is declared by the component itself, which wins over a forward.`
+				});
 			}
 			const mine = forwardedNames(config, element, ctx.value);
 			if (!mine) return;
@@ -1671,24 +1677,45 @@ const ComponentEntity = defineEntity({
 		anatomy: AnatomyNode,
 		defaultProps: Style
 	},
-	computed: { 
-	/**
-	* The prop names an instance may fill through a spec element's `slots` field — every prop that
-	* routes content: a `slot`, or a `forward` whose far end takes content. Resolved over the
-	* inheritance chain, since an inherited slot is as fillable as a declared one. This is the
-	* `slots: string[]` json-render's catalog metadata declares per component, computed here so the
-	* emitted catalog, the validator, and every picker read one answer.
-	*/
-slots: ({ config, path, member }) => {
-		const layers = member.layers;
-		const names = [];
-		for (const [name, decl] of Object.entries(resolveComponentProps(config, path))) {
-			const body = decl;
-			if (!body) continue;
-			if (carriesContent(config, layers, body)) names.push(name);
+	computed: {
+		/**
+		* What each layer can forward, for the layers that render a component with props: every prop its
+		* element exposes, whether the layer forwards it now, and why one is blocked (the component
+		* declares it, or a sibling layer forwards it). Read before writing `forwards`, so "everything
+		* but icon" is a list the caller can spell.
+		*/
+		forwardable: ({ config, path, member }) => {
+			const out = {};
+			const body = member;
+			for (const layer of Object.keys(body.layers ?? {})) {
+				const options = forwardOptions({
+					config,
+					path,
+					layer,
+					member: body
+				});
+				if (options) out[layer] = options;
+			}
+			return out;
+		},
+		/**
+		* The prop names an instance may fill through a spec element's `slots` field — every prop that
+		* routes content: a `slot`, or a `forward` whose far end takes content. Resolved over the
+		* inheritance chain, since an inherited slot is as fillable as a declared one. This is the
+		* `slots: string[]` json-render's catalog metadata declares per component, computed here so the
+		* emitted catalog, the validator, and every picker read one answer.
+		*/
+		slots: ({ config, path, member }) => {
+			const layers = member.layers;
+			const names = [];
+			for (const [name, decl] of Object.entries(resolveComponentProps(config, path))) {
+				const body = decl;
+				if (!body) continue;
+				if (carriesContent(config, layers, body)) names.push(name);
+			}
+			return names;
 		}
-		return names;
-	} },
+	},
 	nameEdges: bagNameEdges(componentBags),
 	styleBags: componentBags,
 	rewriteName: bagRewriteName(componentBags),
@@ -1956,6 +1983,126 @@ slots: ({ config, path, member }) => {
 			}
 		},
 		/**
+		* Copy an element of a composition, with everything beneath it, right after it: each copy gets
+		* layers of its own, and every style rule that styles a copied layer styles its copy the same.
+		* One op for the reason `element-insert` is one: the layers, the nodes, the parent's edge and the
+		* rule bags are one gesture, and any of them alone is a copy that renders wrong.
+		*/
+		"element-duplicate": {
+			input: z.object({
+				path: pathInput("component"),
+				key: z.string(),
+				data: z.object({ 
+				/** How many copies, each after the last. */
+count: z.number().int().min(1).max(50).optional() }).prefault({})
+			}),
+			readOnly: false,
+			label: "Duplicate element",
+			description: "Copy an element of a component, with its subtree and its styles, right after it: each copy gets its own layers, and every style rule styling a copied layer styles the copy the same.",
+			scope: "item",
+			creates: true,
+			title: (entity) => `Duplicate ${entity} element`,
+			handler: (input, config) => {
+				const path = String(input.path);
+				const source = String(input.key);
+				const count = input.data?.count ?? 1;
+				const body = config.resolve("component", path)?.toJSON();
+				const anatomy = body?.anatomy ?? {};
+				if (!anatomy[source]) return rejectData(`"${source}" is not an element of ${path}.`, ["key"]);
+				const parentEntry = Object.entries(anatomy).find(([, node]) => [...node.children ?? [], ...Object.values(node.slots ?? {}).flat()].includes(source));
+				if (!parentEntry) return rejectData(`"${source}" is the root of ${path}; it has no place to copy into.`, ["key"]);
+				const [parent, parentNode] = parentEntry;
+				const slotProp = Object.entries(parentNode.slots ?? {}).find(([, fills]) => fills.includes(source))?.[0];
+				const subtree = [];
+				const visit = (at) => {
+					subtree.push(at);
+					const node = anatomy[at];
+					for (const kid of [...node?.children ?? [], ...Object.values(node?.slots ?? {}).flat()]) visit(kid);
+				};
+				visit(source);
+				const elements = Object.fromEntries(subtree.map((at) => {
+					const node = anatomy[at] ?? {};
+					return [at, {
+						element: body?.layers?.[at] ?? "div",
+						...node.props ? { props: node.props } : {},
+						...node.children?.length ? { children: node.children } : {},
+						...node.slots ? { slots: node.slots } : {},
+						...node.visible !== void 0 ? { visible: node.visible } : {},
+						...node.text !== void 0 ? { text: node.text } : {}
+					}];
+				}));
+				let next = config;
+				let previous = source;
+				for (let n = 0; n < count; n++) {
+					const key = freeLayerKey(next, path, source);
+					const siblings = (next.resolve("component", path)?.toJSON())?.anatomy?.[parent]?.children ?? [];
+					const index = siblings.indexOf(previous) + 1;
+					next = next.run([{
+						kind: "component",
+						operation: "element-insert",
+						path,
+						key,
+						data: {
+							parent,
+							...slotProp ? { slotProp } : { index: index > 0 ? index : siblings.length },
+							subtree: {
+								root: source,
+								elements
+							}
+						}
+					}]);
+					const writes = {};
+					for (const [rule, entry] of Object.entries(body?.styles ?? {})) for (const at of subtree) {
+						const bag = entry.layers?.[at];
+						if (bag === void 0) continue;
+						const copy = at === source ? key : graftKey(key, at);
+						writes[`styles.${rule}.layers.${copy}`] = bag;
+					}
+					if (Object.keys(writes).length > 0) next = next.apply({
+						kind: "component",
+						operation: "update",
+						path,
+						data: writes
+					});
+					previous = key;
+				}
+				return next;
+			}
+		},
+		/**
+		* Make a layer forward the props a request names. The stored write is the generic `forwards`
+		* `sub-upsert` or `sub-delete`; this op works out which, from what the layer forwards now.
+		*/
+		"layer-forward": {
+			input: z.object({
+				path: pathInput("component"),
+				/** The layer whose element's props are forwarded. */
+				key: z.string(),
+				data: z.object({
+					/** Every prop the layer can forward, or the ones to add to what it forwards now. */
+					props: z.union([z.literal("*"), z.array(z.string().min(1))]),
+					/** Props to leave out of either. */
+					except: z.array(z.string().min(1)).optional(),
+					/** Forward exactly `props`, dropping what the layer forwards now. */
+					replace: z.boolean().optional()
+				})
+			}),
+			readOnly: false,
+			label: "Forward layer props",
+			description: "Expose a layer's props at the component's top level (\"forward everything from the root but icon\", \"also forward width\"): `props` is `\"*\"` for every prop the layer's element takes, or a list added to what the layer forwards now, or that replaces it with `replace`; `except` leaves props out of either. A prop the element lacks, one the component declares itself, and one a sibling layer already forwards are refused. Read `component/get` for what a layer forwards now.",
+			scope: "item",
+			title: (entity) => `Forward ${entity} layer props`,
+			handler: (input, config) => {
+				const patch = forwardsWrite({
+					config,
+					path: String(input.path),
+					layer: String(input.key),
+					request: input.data
+				});
+				return patch ? config.apply(patch) : config;
+			}
+		},
+		/**
 		* Remove an element from a composition — the node, its layer, and everything that named it.
 		*
 		* A custom op for the same reason `element-insert` is: it writes more than one thing and either
@@ -2271,6 +2418,10 @@ const Component = Object.assign(ComponentEntity, {
 	slotHostedBy,
 	/** The named node slots alone, without a positioned `children`. */
 	namedSlots,
+	/** Every component slot whose `accepts` names an element. */
+	slotsFor,
+	/** What one layer can forward, and why a prop is blocked. */
+	forwardOptions,
 	/** The component under one coordinate of its matrix. */
 	cell: cellAt,
 	/** The component a design file's spec element places, with what the file put in its slots. */

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

@@ -3,6 +3,9 @@ import { Named } from "../../framework/named.js";
 import { z } from "zod";
 
 //#region src/entities/system/Motion.d.ts
+/** The fields of a JS preset that `motion.create` reads as props, in schema order. The emitter
+ *  reads this rather than restating the schema, so a field added here reaches every emitted preset. */
+declare const jsMotionPropFields: readonly string[];
 declare const MotionDefinition: EntityClass<z.ZodDiscriminatedUnion<[z.ZodObject<{
   runtime: z.ZodLiteral<"css">;
   keyframes: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -16,6 +19,7 @@ declare const MotionDefinition: EntityClass<z.ZodDiscriminatedUnion<[z.ZodObject
   runtime: z.ZodLiteral<"js">;
   initial: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
   animate: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  exit: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
   transition: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
   whileHover: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
   whileTap: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -28,4 +32,4 @@ declare const MotionDefinition: EntityClass<z.ZodDiscriminatedUnion<[z.ZodObject
 interface MotionClass extends Named<typeof MotionDefinition> {}
 declare const Motion: MotionClass;
 //#endregion
-export { Motion, MotionClass };
+export { Motion, MotionClass, jsMotionPropFields };

package/dist/entities/system/Motion.js

@@ -6,7 +6,8 @@ import { z } from "zod";
 * coupled to how it animates, not loosely optional:
 *  - `css` → `keyframes` REQUIRED (codegen emits `@keyframes` from them); a css preset with
 *    no keyframes — which used to validate and silently emit nothing — is now rejected.
-*  - `js`  → no keyframes; carries the interaction state the client drives.
+*  - `js`  → no keyframes; carries the interaction state the client drives, `exit` included,
+*    which runs under an `AnimatePresence` ancestor when the element unmounts.
 * Illegal cross-runtime mixes (a css preset with `animate`, a js preset with `keyframes`)
 * can't be represented — each member is strict.
 *
@@ -30,6 +31,7 @@ const JsMotion = z.strictObject({
 	runtime: z.literal("js").describe(RUNTIME),
 	initial: gesture.describe("The starting values, as `motion/react` reads them."),
 	animate: gesture.describe("The values to animate to."),
+	exit: gesture.describe("The values to animate to as the element leaves."),
 	transition: gesture.describe("How the animation moves, such as a spring."),
 	whileHover: gesture.describe("Values held while the element is hovered."),
 	whileTap: gesture.describe("Values held while the element is pressed."),
@@ -39,6 +41,9 @@ const JsMotion = z.strictObject({
 	dragConstraints: z.record(z.string(), z.number()).optional().describe("The box a drag stays within."),
 	dragElastic: z.number().optional().describe("How far past its constraints a drag can stretch.")
 });
+/** The fields of a JS preset that `motion.create` reads as props, in schema order. The emitter
+*  reads this rather than restating the schema, so a field added here reaches every emitted preset. */
+const jsMotionPropFields = Object.keys(JsMotion.shape).filter((field) => field !== "runtime");
 const Motion = defineEntity({
 	kind: "motion",
 	label: "Motion",
@@ -46,4 +51,4 @@ const Motion = defineEntity({
 	fields: z.discriminatedUnion("runtime", [CssMotion, JsMotion])
 });
 //#endregion
-export { Motion };
+export { Motion, jsMotionPropFields };

package/dist/entities/system/component-forwards.d.ts

@@ -0,0 +1,46 @@
+import { ComponentBody } from "./Component.js";
+import { Config } from "../../framework/Config.js";
+
+//#region src/entities/system/component-forwards.d.ts
+/** Why a prop can't be forwarded from a layer: the component declares it itself, which always wins
+ *  over a forward, or a sibling layer's entry already delivers it. */
+type ForwardBlockedReason = {
+  readonly by: 'own';
+} | {
+  readonly by: 'layer';
+  readonly layer: string;
+};
+/** One prop a layer's element exposes, as a forward from that layer sees it. */
+interface ForwardOption {
+  readonly name: string;
+  /** Whether the layer's `forwards` entry covers it now. */
+  readonly forwarded: boolean;
+  readonly blocked?: ForwardBlockedReason;
+}
+/** What one layer of a component can forward, and what it forwards now. */
+interface ForwardOptions {
+  /** Every prop the layer's element exposes, in name order. */
+  readonly options: readonly ForwardOption[];
+  /** Whether the layer has a `forwards` entry at all. */
+  readonly forwarded: boolean;
+}
+/**
+ * What `layer` of the component at `path` can forward. An option the component declares itself, or a
+ * sibling layer already delivers, is listed with the reason it's blocked rather than left out. Null
+ * when the layer renders a tag, or its element declares no props.
+ */
+declare function forwardOptions(args: {
+  config: Config;
+  path: string;
+  layer: string;
+  member?: ComponentBody;
+}): ForwardOptions | null;
+/** What a forward asks for: every prop, or a list that joins what the layer forwards now unless it
+ *  replaces it, less `except`. */
+interface ForwardRequest {
+  readonly props: '*' | readonly string[];
+  readonly except?: readonly string[];
+  readonly replace?: boolean;
+}
+//#endregion
+export { ForwardBlockedReason, ForwardOption, ForwardOptions, ForwardRequest, forwardOptions };

package/dist/entities/system/component-forwards.js

@@ -0,0 +1,131 @@
+import { reject } from "../../framework/rejection.js";
+import { isRef, kindOf, memberRef, pathOf } from "../../framework/utils/refs.js";
+import { forwardedPropName } from "./element.js";
+import { propOwner, resolveComponentProps } from "../../framework/projections.js";
+import { forwardClaims } from "../../framework/prop-surface.js";
+//#region src/entities/system/component-forwards.ts
+function siteOf({ config, path, layer, member }) {
+	const body = member ?? config.resolve("component", path)?.toJSON();
+	const element = body?.layers?.[layer];
+	if (!body || !isRef(element) || kindOf(element) !== "component") return null;
+	const elementPath = pathOf(element);
+	const exposes = Object.keys(resolveComponentProps(config, elementPath));
+	if (exposes.length === 0) return null;
+	const own = body.forwards?.[layer];
+	let stored;
+	if (own === "*") stored = exposes;
+	else if (Array.isArray(own)) stored = own.map(forwardedPropName).filter((name) => !!name);
+	else stored = [];
+	const claims = forwardClaims(config, path);
+	return {
+		body,
+		elementPath,
+		options: [...exposes].sort((a, b) => a.localeCompare(b)).map((name) => {
+			let blocked;
+			const claimer = claims.forwarded.get(name);
+			if (claims.own.has(name)) blocked = { by: "own" };
+			else if (claimer !== void 0 && claimer !== layer) blocked = {
+				by: "layer",
+				layer: claimer
+			};
+			return {
+				name,
+				forwarded: stored.includes(name),
+				...blocked ? { blocked } : {}
+			};
+		}),
+		forwarded: own !== void 0
+	};
+}
+/**
+* What `layer` of the component at `path` can forward. An option the component declares itself, or a
+* sibling layer already delivers, is listed with the reason it's blocked rather than left out. Null
+* when the layer renders a tag, or its element declares no props.
+*/
+function forwardOptions(args) {
+	const site = siteOf(args);
+	return site && {
+		options: site.options,
+		forwarded: site.forwarded
+	};
+}
+/** The names a forward ends up exposing: `'*'` is every unblocked prop, and a list joins what the
+*  layer forwards now unless it replaces it. `except` comes off either. */
+function selectionOf({ site, data }) {
+	const names = new Set(site.options.map((option) => option.name));
+	const asked = data.props === "*" ? [] : data.props;
+	for (const name of [...asked, ...data.except ?? []]) if (!names.has(name)) reject("NOT_FOUND", `"${name}" is not a prop of the layer's element (${[...names].join(", ")}).`);
+	for (const name of asked) {
+		const blocked = site.options.find((option) => option.name === name)?.blocked;
+		if (!blocked) continue;
+		reject("ALREADY_EXISTS", blocked.by === "own" ? `"${name}" is declared by the component itself, which wins over a forward.` : `"${name}" is already forwarded from the "${blocked.layer}" layer.`);
+	}
+	const selectable = site.options.filter((option) => !option.blocked);
+	const kept = /* @__PURE__ */ new Set();
+	if (data.props === "*") for (const option of selectable) kept.add(option.name);
+	else {
+		if (!data.replace) {
+			for (const option of selectable) if (option.forwarded) kept.add(option.name);
+		}
+		for (const name of asked) kept.add(name);
+	}
+	for (const name of data.except ?? []) kept.delete(name);
+	return selectable.map((option) => option.name).filter((name) => kept.has(name));
+}
+/**
+* The `forwards` write that makes `next` the layer's forwarded set, or null when it already is. An
+* empty set deletes the entry, the full surface is `'*'` when no sibling layer has an entry of its
+* own, and anything else is a list of member refs.
+*/
+function forwardPatch({ config, path, layer, site, next }) {
+	const current = site.options.filter((option) => option.forwarded && !option.blocked).map((option) => option.name);
+	if (next.length === current.length && next.every((name) => current.includes(name))) return null;
+	const at = {
+		kind: "component",
+		path,
+		field: "forwards",
+		key: layer
+	};
+	if (next.length === 0) return site.forwarded ? {
+		...at,
+		operation: "sub-delete"
+	} : null;
+	const hasSiblings = Object.keys(site.body.forwards ?? {}).some((sibling) => sibling !== layer);
+	const unowned = site.options.filter((option) => option.blocked?.by !== "own");
+	const data = !hasSiblings && unowned.length > 0 && unowned.every((option) => next.includes(option.name)) ? "*" : next.map((name) => memberRef("component", propOwner(config, site.elementPath, name) ?? site.elementPath, "props", name));
+	return {
+		...at,
+		operation: "sub-upsert",
+		data
+	};
+}
+/**
+* The generic `forwards` write that makes `layer` forward what `request` asks for: a `sub-upsert`
+* with the refs minted (compacted to `'*'` where no sibling entry could collide), a `sub-delete`
+* when nothing is left, or null when the layer already forwards exactly that. Refuses a prop the
+* layer's element lacks, one the component declares itself or a sibling layer forwards, and a layer
+* with nothing to forward.
+*/
+function forwardsWrite({ config, path, layer, request }) {
+	const body = config.resolve("component", path)?.toJSON();
+	if (!body) reject("NOT_FOUND", `No component at "${path}".`);
+	if (!(layer in (body.layers ?? {}))) reject("NOT_FOUND", `"${layer}" is not one of this component's layers (${Object.keys(body.layers ?? {}).join(", ")}).`);
+	const site = siteOf({
+		config,
+		path,
+		layer
+	});
+	if (!site) reject("UNSUPPORTED", `The "${layer}" layer doesn't render a component with props, so it has nothing to forward.`);
+	return forwardPatch({
+		config,
+		path,
+		layer,
+		site,
+		next: selectionOf({
+			site,
+			data: request
+		})
+	});
+}
+//#endregion
+export { forwardOptions, forwardsWrite };

package/dist/entities/system/token-values.d.ts

@@ -13,6 +13,14 @@ interface TokenValueEntry {
   readonly px?: number;
   readonly ms?: number;
 }
+/** A resolved token value as its CSS string and the numbers a JS caller reads off it. */
+declare function parseTokenValue({
+  value,
+  rem
+}: {
+  value: string | number; /** The pixels one `rem` is on the page, or `undefined` when the root is fluid and fixes none. */
+  rem: number | undefined;
+}): TokenValueEntry;
 /** What a token resolved to, or why it did not. */
 type TokenValueState = /** One value, the same under every mode and state. */{
   readonly kind: 'value';
@@ -144,4 +152,4 @@ declare function spellTokenRead({
   reader: TokenReader;
 }): string;
 //#endregion
-export { RegisteredTokenValues, TOKEN_READERS, TokenGroupReader, TokenReader, TokenReaders, TokenValueEntry, TokenValueRow, TokenValueState, isTokenReader, rootFontSize, spellTokenRead, tokenExists, tokenValueRow, tokenValueRows };
+export { RegisteredTokenValues, TOKEN_READERS, TokenGroupReader, TokenReader, TokenReaders, TokenValueEntry, TokenValueRow, TokenValueState, isTokenReader, parseTokenValue, rootFontSize, spellTokenRead, tokenExists, tokenValueRow, tokenValueRows };

package/dist/entities/system/token-values.js

@@ -19,7 +19,8 @@ import { cssVar, resolveTokenValue } from "../../framework/projections.js";
 * whatever the viewer's mode or state says on the page, so it is only ever reachable as its `var()`.
 */
 const NUMERIC = /^(-?(?:\d+(?:\.\d*)?|\.\d+))(px|rem|ms|s)?$/;
-function tokenValueEntry({ value, rem }) {
+/** A resolved token value as its CSS string and the numbers a JS caller reads off it. */
+function parseTokenValue({ value, rem }) {
 	if (typeof value === "number") return {
 		css: String(value),
 		px: value
@@ -93,7 +94,7 @@ function stateOf({ config, path, rem }) {
 	if (resolved === void 0) return { kind: "unresolved" };
 	return {
 		kind: "value",
-		value: tokenValueEntry({
+		value: parseTokenValue({
 			value: resolved,
 			rem
 		})
@@ -158,4 +159,4 @@ function spellTokenRead({ path, reader }) {
 	return `Token.ref(${JSON.stringify(path)}).${reader}()`;
 }
 //#endregion
-export { TOKEN_READERS, isTokenReader, rootFontSize, spellTokenRead, tokenExists, tokenValueRow, tokenValueRows };
+export { TOKEN_READERS, isTokenReader, parseTokenValue, rootFontSize, spellTokenRead, tokenExists, tokenValueRow, tokenValueRows };

package/dist/framework/Config.d.ts

@@ -72,7 +72,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 = 20261001112308;
+declare const SERIALIZED_CONFIG_VERSION = 20261001131000;
 interface SerializedConfig {
   /** See {@link SERIALIZED_CONFIG_VERSION}. Always written; a stored artifact may lack it. */
   readonly version: number;

package/dist/framework/Config.js

@@ -5250,7 +5250,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 > 20261001112308) throw new SchemaVersionTooNew(claimed);
+		if (claimed > 20261001131e3) 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;

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 = 20261001112308;
+declare const CURRENT_SCHEMA_VERSION = 20261001131000;
 /** 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 {