@yahoo/uds-create-config 4.40.0 → 4.41.0

package/dist/configs/system.js

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

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

@@ -116,10 +116,18 @@ declare const propShapeDefinition: z.ZodDiscriminatedUnion<[z.ZodObject<{
   type: z.ZodLiteral<"forward">;
   target: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
     __ref: z.ZodString;
-  }, z.core.$strip>]>;
+  }, z.core.$strip>, z.ZodArray<z.ZodString>]>;
   into: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
     __ref: z.ZodString;
   }, z.core.$strip>]>>;
+  also: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    target: z.ZodObject<{
+      __ref: z.ZodString;
+    }, z.core.$strip>;
+    into: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+      __ref: z.ZodString;
+    }, z.core.$strip>]>;
+  }, z.core.$strict>>>;
   accepts: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
     __ref: z.ZodString;
   }, z.core.$strip>, z.ZodArray<z.ZodObject<{
@@ -134,12 +142,20 @@ declare const propShapeDefinition: z.ZodDiscriminatedUnion<[z.ZodObject<{
   }, z.core.$strip>]>>]>>>;
 }, z.core.$strict>, z.ZodTransform<{
   type: "forward";
-  target: string | {
+  target: string | string[] | {
     __ref: string;
   };
   into?: string | {
     __ref: string;
   } | undefined;
+  also?: {
+    target: {
+      __ref: string;
+    };
+    into: string | {
+      __ref: string;
+    };
+  }[] | undefined;
   accepts?: {
     __ref: string;
   } | {
@@ -154,12 +170,20 @@ declare const propShapeDefinition: z.ZodDiscriminatedUnion<[z.ZodObject<{
   })[]> | undefined;
 }, {
   type: "forward";
-  target: string | {
+  target: string | string[] | {
     __ref: string;
   };
   into?: string | {
     __ref: string;
   } | undefined;
+  also?: {
+    target: {
+      __ref: string;
+    };
+    into: string | {
+      __ref: string;
+    };
+  }[] | undefined;
   accepts?: {
     __ref: string;
   } | {

package/dist/entities/system/Component.js

@@ -20,6 +20,7 @@ import { listSlots, namedSlots, slotHostedBy, slotOf } from "../../spec/slot.js"
 import { cellAt } from "../../spec/cell.js";
 import { instanceAt } from "../../spec/instance.js";
 import { File } from "./File.js";
+import { forwardRouteInvariants, refusedRoutes } from "./forward-route-invariants.js";
 import { iconDomainInvariants } from "./icon-domain-invariants.js";
 import { rootLayerInvariants } from "./root-layer-invariants.js";
 import { Token } from "./Token.js";
@@ -374,14 +375,35 @@ const layerPath = z.string().regex(/^[^/]+\/[^/]+$/, "expected `<layer>/<prop>`"
 * Patch comes through a different door than one written in a config file, and both mean the same thing.
 */
 function routedTarget(decl) {
-	if (!("target" in decl) || typeof decl.target !== "string") return decl;
-	const separator = decl.target.indexOf("/");
+	if (!("target" in decl)) return decl;
+	const { target } = decl;
+	if (Array.isArray(target)) {
+		const [first, ...rest] = target.map(splitLayerPath);
+		return {
+			...decl,
+			...first,
+			also: [...rest, ...decl.also ?? []]
+		};
+	}
+	if (typeof target !== "string") return decl;
 	return {
 		...decl,
-		target: layerRef(decl.target.slice(0, separator)),
-		into: decl.target.slice(separator + 1)
+		...splitLayerPath(target)
+	};
+}
+/** `<layer>/<prop>` as the pair a route stores. */
+function splitLayerPath(path) {
+	const separator = path.indexOf("/");
+	return {
+		target: layerRef(path.slice(0, separator)),
+		into: path.slice(separator + 1)
 	};
 }
+/** A forward's routes after its first — `also`, as the schema stores it. */
+const alsoRoutes = z.array(z.strictObject({
+	target: refSchema,
+	into: z.union([z.string(), refSchema])
+})).min(1);
 /** A composite prop's authored `layer` name as the layer ref it is stored as — see {@link routedTarget}
 *  for why the coercion lives in the schema. */
 function layerAsRef(decl) {
@@ -430,8 +452,13 @@ function propShapeWith(when) {
 		}),
 		z.strictObject({
 			type: z.literal("forward"),
-			target: z.union([layerPath, refSchema]),
+			target: z.union([
+				layerPath,
+				refSchema,
+				z.array(layerPath).min(2)
+			]),
 			into: z.union([z.string(), refSchema]).optional(),
+			also: alsoRoutes.optional(),
 			accepts: z.union([refSchema, z.array(refSchema)]).optional(),
 			text: z.boolean().optional(),
 			required: z.boolean().optional(),
@@ -526,6 +553,18 @@ function propSchemaFor(config, owner) {
 	const layers = owner.layers;
 	return propShapeWith(ownerCondition(config, owner)).nullable().check((ctx) => {
 		const decl = ctx.value;
+		if (decl !== null && isPlainObject(decl) && decl.type === "forward" && Array.isArray(decl.also) && decl.also.length > 0) {
+			const refused = refusedRoutes(config, layers, decl);
+			if (refused) {
+				ctx.issues.push({
+					code: "custom",
+					input: decl,
+					path: ["target"],
+					message: refused
+				});
+				return;
+			}
+		}
 		if (decl === null || !isPlainObject(decl) || decl.type !== "forward" || decl.accepts === void 0 || routesContent(config, layers, decl)) return;
 		const layer = isRef(decl.target) ? pathOf(decl.target) : String(decl.target ?? "?");
 		const prop = intoName(decl.into);
@@ -551,14 +590,24 @@ function propSchemaFor(config, owner) {
 */
 function declaringInto(config, layers, decl) {
 	if (!isPlainObject(decl) || decl.type !== "forward" || !isRef(decl.target)) return decl;
-	const element = layers?.[pathOf(decl.target)];
-	if (!isRef(element)) return decl;
-	const name = intoName(decl.into);
-	const owner = propOwner(config, pathOf(element), name);
-	if (!owner || isRef(decl.into) && pathOf(decl.into) === owner) return decl;
+	const minted = (route) => {
+		if (!isRef(route.target)) return route;
+		const element = layers?.[pathOf(route.target)];
+		if (!isRef(element)) return route;
+		const name = intoName(route.into);
+		const owner = propOwner(config, pathOf(element), name);
+		if (!owner || isRef(route.into) && pathOf(route.into) === owner) return route;
+		return {
+			...route,
+			into: memberRef("component", owner, "props", name)
+		};
+	};
+	const first = minted(decl);
+	if (!Array.isArray(decl.also) || decl.also.length === 0) return first;
+	const also = decl.also.map((route) => isPlainObject(route) ? minted(route) : route);
 	return {
-		...decl,
-		into: memberRef("component", owner, "props", name)
+		...first,
+		also
 	};
 }
 /**
@@ -2140,7 +2189,11 @@ subtree: z.boolean().default(true) }).optional()
 			handler: (input, config) => validateComponentProps(config, String(input.path), input.data.props ?? {})
 		}
 	},
-	invariants: (config) => [...iconDomainInvariants(config), ...rootLayerInvariants(config)]
+	invariants: (config) => [
+		...iconDomainInvariants(config),
+		...rootLayerInvariants(config),
+		...forwardRouteInvariants(config)
+	]
 });
 const baseComponentRef = ComponentEntity.ref.bind(ComponentEntity);
 /** Style rules as a list, the form `defineComponent.styles` takes, in the stored form: keyed by each

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

@@ -145,11 +145,18 @@ type Forwarded = '*' | readonly string[];
  */
 interface ForwardDecl<Path extends string = string> {
   type: 'forward';
-  /** `<layer>/<prop>` as authored; a `layerRef` once stored, with the prop moved to `into`. */
-  target: Path | Ref$1;
+  /** `<layer>/<prop>` as authored, or several to route the one value to each
+   *  (`['startIcon/variant', 'endIcon/variant']`); a `layerRef` once stored, with the prop moved to
+   *  `into` and any routes after the first to `also`. */
+  target: Path | Ref$1 | readonly Path[];
   /** STORED only — a member ref at the prop on that layer's element
    *  (`component:Input#props/disabled`). Minted at registration, when the layer's element has a path. */
   into?: string | Ref$1;
+  /** STORED only — the routes after the first, each the same pair as `target` + `into`. */
+  also?: readonly {
+    readonly target: Ref$1;
+    readonly into: string | Ref$1;
+  }[];
   /** Only where this route LANDS on a hole — it means exactly what {@link SlotDecl.accepts} means.
    *  That the target is a hole is computed from it (`routesContent`), so the rule is checked rather
    *  than trusted, and a route into a value prop is refused by name. */
@@ -367,7 +374,7 @@ type ValueOfDeclaration<D, Self, K extends PropertyKey, View extends SlotView> =
   text: true;
 } ? string : D extends {
   type: 'forward';
-  target: `${string}/children`;
+  target: `${string}/children` | readonly [`${string}/children`, ...unknown[]];
 } ? ReactNode : unknown;
 /**
  * A prop type's DECLARED props — everything but its index signature.
@@ -394,7 +401,7 @@ type RoutedValueOf<L extends LayerMap, D, Self = unknown, K extends PropertyKey
   text: true;
 } ? string : D extends {
   type: 'forward';
-  target: `${infer Layer}/${infer Prop}`;
+  target: `${infer Layer}/${infer Prop}` | readonly [`${infer Layer}/${infer Prop}`, ...unknown[]];
 } ? Prop extends 'children' ? ReactNode : Layer extends keyof L ? Prop extends keyof ElementPropsOf<L[Layer]> ? ElementPropsOf<L[Layer]>[Prop] : unknown : unknown : ValueOf<D, Self, K, View>;
 /**
  * The props the rendered ELEMENT contributes, `ref` included.

package/dist/entities/system/defineComponent.js

@@ -204,11 +204,12 @@ function storedProp(decl, layers) {
 */
 function isAuthoredForward(decl) {
 	if (typeof decl !== "object" || decl === null || decl.type !== "forward") return false;
-	const { target, into } = decl;
-	return typeof target === "string" || typeof into === "string";
+	const { target, into, also } = decl;
+	return typeof target === "string" || Array.isArray(target) || typeof into === "string" || Array.isArray(also) && also.some((route) => typeof route?.into === "string");
 }
 /**
-* A `bind()` declaration with its `into` resolved to a member ref at the target layer's element.
+* A `bind()` declaration with each route's `into` resolved to a member ref at its layer's element —
+* the first route's as `target` + `into`, the rest as `also`, the shape the schema stores.
 *
 * Left as authored when the layer's element is a tag or an unadopted handle: a tag's props are the
 * DOM's and have no entity to point into, and minting a ref against an empty path would produce
@@ -216,15 +217,34 @@ function isAuthoredForward(decl) {
 * non-ref `into`, so the failure is loud at registration rather than silent in the data.
 */
 function storedForward(decl, layers) {
-	return storedRoutedForward(typeof decl.target === "string" ? {
-		...decl,
-		target: layerRef(decl.target.slice(0, decl.target.indexOf("/"))),
-		into: decl.target.slice(decl.target.indexOf("/") + 1)
-	} : {
-		...decl,
+	const split = (path) => ({
+		target: layerRef(path.slice(0, path.indexOf("/"))),
+		into: path.slice(path.indexOf("/") + 1)
+	});
+	const [first, ...rest] = [...Array.isArray(decl.target) ? decl.target.map(split) : typeof decl.target === "string" ? [split(decl.target)] : [{
 		target: decl.target,
 		into: decl.into ?? "children"
-	}, layers);
+	}], ...decl.also ?? []];
+	if (!first) return decl;
+	const minted = (route) => typeof route.into === "string" ? storedRoutedForward({
+		type: "forward",
+		target: route.target,
+		into: route.into
+	}, layers) : route;
+	const primary = minted(first);
+	const { also: _also, ...body } = decl;
+	return {
+		...body,
+		target: primary.target,
+		into: primary.into,
+		...rest.length > 0 ? { also: rest.map((route) => {
+			const stored = minted(route);
+			return {
+				target: stored.target,
+				into: stored.into
+			};
+		}) } : {}
+	};
 }
 function storedRoutedForward(decl, layers) {
 	const layer = pathOf(decl.target);

package/dist/entities/system/forward-route-invariants.d.ts

@@ -0,0 +1,19 @@
+import type { Config } from '../../framework/Config';
+/**
+ * Why a forward with several routes can't take them, or `undefined` when it can. Every route has to
+ * land on a layer the component has, and all of them on the same kind of prop with the same values:
+ * one value is written to each, so two Icon `variant`s agree and an Icon's `name` beside its
+ * `variant` does not. A route that carries content takes one layer only — the same content can't be
+ * placed twice.
+ */
+export declare function refusedRoutes(config: Config, layers: Readonly<Record<string, unknown>> | undefined, decl: {
+    target?: unknown;
+    into?: unknown;
+    also?: unknown;
+}): string | undefined;
+/**
+ * Every component's forwards that take several routes they can't. Held as an invariant rather than
+ * only in the prop's schema, because the schema's per-owner check runs on a prop op and a component
+ * written whole (`register`, an item create) reaches storage without it.
+ */
+export declare const forwardRouteInvariants: (config: Config) => string[];

package/dist/entities/system/forward-route-invariants.js

@@ -0,0 +1,58 @@
+import { isRef, pathOf } from "../../framework/utils/refs.js";
+import { isPlainRecord } from "./style-bag.js";
+import { createSliceMemo } from "../../framework/memo.js";
+import { forwardRoutes, intoName, routedPropIn, routesContent } from "../../framework/prop-surface.js";
+//#region src/entities/system/forward-route-invariants.ts
+/**
+* Why a forward with several routes can't take them, or `undefined` when it can. Every route has to
+* land on a layer the component has, and all of them on the same kind of prop with the same values:
+* one value is written to each, so two Icon `variant`s agree and an Icon's `name` beside its
+* `variant` does not. A route that carries content takes one layer only — the same content can't be
+* placed twice.
+*/
+function refusedRoutes(config, layers, decl) {
+	const routes = forwardRoutes(decl);
+	const refPath = (value) => isRef(value) ? pathOf(value.__ref) : void 0;
+	const spelled = (route) => `\`${refPath(route.target) ?? "?"}/${intoName(route.into)}\``;
+	for (const route of routes) {
+		const layer = refPath(route.target);
+		if (layers && (!layer || !(layer in layers))) return `${spelled(route)} names a layer this component doesn't have. Every route of a forward lands on one of its own layers.`;
+	}
+	if (routes.some((route) => routesContent(config, layers, route))) return `A forward that carries content takes one route: the same content can't fill ${routes.map(spelled).join(" and ")}. Route a value (a variant, a string) to several layers, or give each layer its own slot.`;
+	const landing = (route) => {
+		const routed = routedPropIn(config, layers, route);
+		return routed ? JSON.stringify({
+			type: routed.type,
+			value: routed.value
+		}) : "attribute";
+	};
+	const [first, ...rest] = routes;
+	if (!first) return void 0;
+	const expected = landing(first);
+	for (const route of rest) if (landing(route) !== expected) return `${spelled(route)} takes different values than ${spelled(first)}, and a forward writes one value to every route. Route it only to props that take the same values, or declare a second prop.`;
+}
+/**
+* Every component's forwards that take several routes they can't. Held as an invariant rather than
+* only in the prop's schema, because the schema's per-owner check runs on a prop op and a component
+* written whole (`register`, an item create) reaches storage without it.
+*/
+const forwardRouteInvariants = createSliceMemo({
+	kinds: ["component"],
+	compute: (config) => {
+		const problems = [];
+		for (const item of config.list("component")) {
+			const body = config.resolve("component", item.path)?.toJSON();
+			if (!body || !isPlainRecord(body.props)) continue;
+			const layers = isPlainRecord(body.layers) ? body.layers : void 0;
+			for (const [name, decl] of Object.entries(body.props)) {
+				if (!isPlainRecord(decl) || decl.type !== "forward") continue;
+				if (!Array.isArray(decl.also) || decl.also.length === 0) continue;
+				const refused = refusedRoutes(config, layers, decl);
+				if (refused) problems.push(`Component "${item.path}" prop "${name}": ${refused}`);
+			}
+		}
+		return problems;
+	}
+});
+//#endregion
+export { forwardRouteInvariants, refusedRoutes };

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

package/dist/framework/Config.js

@@ -5172,7 +5172,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 > 20260929150131) throw new SchemaVersionTooNew(claimed);
+		if (claimed > 20260929161433) 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/prop-surface.d.ts

@@ -126,6 +126,20 @@ declare function propApplies(prop: {
  * graph. Readers want the name either way, and `'children'` is the default a content route means.
  */
 declare function intoName(into: unknown): string;
+/**
+ * Every route a forward takes, the first one first: its own `target` + `into`, then each of `also`
+ * (`iconVariant` into both `startIcon/variant` and `endIcon/variant`). Registration refuses routes
+ * that disagree about what the value is, so the first answers for the prop's type and domain, and
+ * anything that WRITES the value or marks a layer bound walks all of them.
+ */
+declare function forwardRoutes(decl: {
+  target?: unknown;
+  into?: unknown;
+  also?: unknown;
+}): {
+  target: unknown;
+  into: unknown;
+}[];
 /**
  * The prop a route ROUTES INTO — the declaration at `<layer>/<prop>`, reached through the layer's
  * element.
@@ -214,4 +228,4 @@ interface PropRoute {
  */
 declare function renderBindingsOf(config: Config, componentPath: string): PropRoute[];
 //#endregion
-export { BindingKind, CodeSlot, ForwardClaims, PropRoute, SurfaceCompositeProp, SurfaceProp, SurfacePropCondition, SurfacePropKind, SurfaceScalarProp, SurfaceSlotProp, SurfaceStylePropertyProp, SurfaceVariantProp, codeSlotsOf, forwardClaims, forwardedLayers, intoName, isValueSlot, layerPropRoutes, propApplies, propRegistryRef, renderBindingsOf, routedProp, routedPropIn, routesContent, slotCodeForms, standsInForCode, surfaceProp, surfaceProps };
+export { BindingKind, CodeSlot, ForwardClaims, PropRoute, SurfaceCompositeProp, SurfaceProp, SurfacePropCondition, SurfacePropKind, SurfaceScalarProp, SurfaceSlotProp, SurfaceStylePropertyProp, SurfaceVariantProp, codeSlotsOf, forwardClaims, forwardRoutes, forwardedLayers, intoName, isValueSlot, layerPropRoutes, propApplies, propRegistryRef, renderBindingsOf, routedProp, routedPropIn, routesContent, slotCodeForms, standsInForCode, surfaceProp, surfaceProps };

package/dist/framework/prop-surface.js

@@ -130,6 +130,22 @@ function intoName(into) {
 	return member.slice(member.indexOf("/") + 1);
 }
 /**
+* Every route a forward takes, the first one first: its own `target` + `into`, then each of `also`
+* (`iconVariant` into both `startIcon/variant` and `endIcon/variant`). Registration refuses routes
+* that disagree about what the value is, so the first answers for the prop's type and domain, and
+* anything that WRITES the value or marks a layer bound walks all of them.
+*/
+function forwardRoutes(decl) {
+	const also = Array.isArray(decl.also) ? decl.also : [];
+	return [{
+		target: decl.target,
+		into: decl.into
+	}, ...also.map((route) => ({
+		target: route?.target,
+		into: route?.into
+	}))];
+}
+/**
 * The prop a route ROUTES INTO — the declaration at `<layer>/<prop>`, reached through the layer's
 * element.
 *
@@ -455,9 +471,9 @@ function layerPropRoutes(config, componentPath, layer) {
 	if (!body) return routes;
 	const declared = resolveComponentProps(config, componentPath);
 	for (const [name, decl] of Object.entries(declared)) {
-		if (decl.type !== "forward" || refPath(decl.target) !== layer) continue;
+		if (decl.type !== "forward") continue;
 		if (routesContent(config, body.layers, decl)) continue;
-		routes.set(intoName(decl.into), name);
+		for (const route of forwardRoutes(decl)) if (refPath(route.target) === layer) routes.set(intoName(route.into), name);
 	}
 	const { forwarded } = computeForwardClaims(config, componentPath);
 	for (const [name, claimedBy] of forwarded) if (claimedBy === layer && !routes.has(name)) routes.set(name, name);
@@ -502,4 +518,4 @@ function renderBoundProp(value) {
 	return name.length > 0 && !name.includes("/") ? name : void 0;
 }
 //#endregion
-export { carriesContent, codeSlotsOf, forwardClaims, forwardedLayers, intoName, isValueSlot, layerPropRoutes, propApplies, propRegistryRef, renderBindingsOf, renderBoundProp, routedProp, routedPropIn, routesContent, routesIntoText, slotCodeForms, standsInForCode, surfaceProp, surfaceProps };
+export { carriesContent, codeSlotsOf, forwardClaims, forwardRoutes, forwardedLayers, intoName, isValueSlot, layerPropRoutes, propApplies, propRegistryRef, renderBindingsOf, renderBoundProp, routedProp, routedPropIn, routesContent, routesIntoText, slotCodeForms, standsInForCode, surfaceProp, surfaceProps };

package/dist/framework/render-spec.js

@@ -4,7 +4,7 @@ import { createSliceMemo } from "./memo.js";
 import { unconditionalPreviewProps } from "./preview-store.js";
 import { authoredBag, authoredValue, declaredPropDefaults, memberFromLeaf, refListOf, resolveComponentProps, stylePropertyPathFor } from "./projections.js";
 import { slotHostLayer } from "./slot-host.js";
-import { forwardedLayers, intoName, isValueSlot, renderBindingsOf, routesContent } from "./prop-surface.js";
+import { forwardRoutes, forwardedLayers, intoName, isValueSlot, renderBindingsOf, routesContent } from "./prop-surface.js";
 import { graftPreviewElements } from "../spec/preview-elements.js";
 import { componentLayerClass, componentPropClasses, componentRuleClasses, layerRoutedProps, splitStyleProps, styleRuleMotionClasses } from "./class-names.js";
 //#region src/framework/render-spec.ts
@@ -1060,13 +1060,15 @@ function valueForwards(config, body) {
 	for (const [from, decl] of Object.entries(body.props ?? {})) {
 		if (decl?.type !== "forward") continue;
 		if (routesContent(config, body.layers, decl)) continue;
-		const target = refOf(decl.target);
-		if (!target) continue;
-		routes.push({
-			layer: pathOf(target),
-			from,
-			into: intoName(decl.into)
-		});
+		for (const route of forwardRoutes(decl)) {
+			const target = refOf(route.target);
+			if (!target) continue;
+			routes.push({
+				layer: pathOf(target),
+				from,
+				into: intoName(route.into)
+			});
+		}
 	}
 	return routes;
 }

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 = 20260929150131;
+declare const CURRENT_SCHEMA_VERSION = 20260929161433;
 /** 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 = 20260929150131;
+const CURRENT_SCHEMA_VERSION = 20260929161433;
 /** 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 > 20260929150131) 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 > 20260929161433) 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 ?? 20260929150131;
+	const target = options?.target ?? 20260929161433;
 	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 ?? 20260929150131;
+	const target = options?.target ?? 20260929161433;
 	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 ?? 20260929150131;
+	const target = options?.target ?? 20260929161433;
 	const entries = [];
 	const held = [];
 	const retired = [];