@yahoo/uds-create-config 4.10.2 → 4.10.4

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

@@ -1,4 +1,5 @@
-import { ExtendedRef, Ref } from "../../framework/utils/refs.js";
+import { Ref } from "../../framework/utils/ref-grammar.js";
+import { ExtendedRef, Ref as Ref$1 } from "../../framework/utils/refs.js";
 import { SubEntityClass } from "../../framework/defineSubEntity.js";
 import { ComputedInput } from "../../framework/registry.js";
 import { ComponentContractOf, PathOf } from "../../framework/registered.js";
@@ -16,7 +17,7 @@ import { z } from "zod";
 /** A component-relative reference to one of the enclosing component's own layers — a slot's
  *  `target`. Relative (no component path) because a slot only ever targets a sibling layer, so a
  *  Component rename can't break it; a layer rename cascades through it. */
-declare function layerRef(layerKey: string): Ref;
+declare function layerRef(layerKey: string): Ref$1;
 /**
  * A component-relative reference to one value of one of the enclosing component's own variant
  * props — what a style rule conditions on.
@@ -27,7 +28,7 @@ declare function layerRef(layerKey: string): Ref;
  * re-key themselves. Without the ref the name sits in a plain string, invisible to that rewrite, and
  * every rule conditioned on the old name silently stops applying.
  */
-declare function valueRef(prop: string, value: string): Ref;
+declare function valueRef(prop: string, value: string): Ref$1;
 /** The prop names one entry exposes — `null` when the config can't say (an unresolved element). */
 declare function forwardedNames(config: Config, element: unknown, entry: unknown): string[] | null;
 /**
@@ -65,7 +66,9 @@ declare const propShape: z.ZodDiscriminatedUnion<[z.ZodObject<{
   type: z.ZodLiteral<"variant">;
   value: z.ZodUnion<readonly [z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<{
     [k: string]: {};
-  }, string[]>>, z.ZodObject<{
+  }, string[]>>, z.ZodArray<z.ZodObject<{
+    __ref: z.ZodString;
+  }, z.core.$strip>>, z.ZodObject<{
     __ref: z.ZodString;
   }, z.core.$strip>, SubEntityClass<z.ZodObject<{
     label: z.ZodOptional<z.ZodString>;
@@ -440,7 +443,7 @@ declare const componentFields: z.ZodObject<{
   layers: SubEntityClass<z.ZodUnion<readonly [z.ZodString, z.ZodLazy<z.ZodType<Ref, unknown, z.core.$ZodTypeInternals<Ref, unknown>>>, EntityClass<z.ZodObject<{
     version: z.ZodOptional<z.ZodString>;
     exports: z.ZodOptional<SubEntityClass<z.ZodObject<{}, z.core.$strict>>>;
-  }, z.core.$strict>, z.ZodObject<Record<never, never>, z.core.$strip>, "package", Record<never, never>, Record<never, never>, false>]>>;
+  }, z.core.$strict>, z.ZodObject<Record<never, never>, z.core.$strip>, "package", Record<never, never>, Record<never, never>, false, Record<never, never>, Record<never, never>>]>>;
   props: z.ZodOptional<SubEntityClass<z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"slot">;
     text: z.ZodOptional<z.ZodBoolean>;
@@ -459,7 +462,9 @@ declare const componentFields: z.ZodObject<{
     type: z.ZodLiteral<"variant">;
     value: z.ZodUnion<readonly [z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<{
       [k: string]: {};
-    }, string[]>>, z.ZodObject<{
+    }, string[]>>, z.ZodArray<z.ZodObject<{
+      __ref: z.ZodString;
+    }, z.core.$strip>>, z.ZodObject<{
       __ref: z.ZodString;
     }, z.core.$strip>, SubEntityClass<z.ZodObject<{
       label: z.ZodOptional<z.ZodString>;
@@ -626,7 +631,7 @@ declare const ComponentEntity: EntityClass<z.ZodObject<{
   layers: SubEntityClass<z.ZodUnion<readonly [z.ZodString, z.ZodLazy<z.ZodType<Ref, unknown, z.core.$ZodTypeInternals<Ref, unknown>>>, EntityClass<z.ZodObject<{
     version: z.ZodOptional<z.ZodString>;
     exports: z.ZodOptional<SubEntityClass<z.ZodObject<{}, z.core.$strict>>>;
-  }, z.core.$strict>, z.ZodObject<Record<never, never>, z.core.$strip>, "package", Record<never, never>, Record<never, never>, false>]>>;
+  }, z.core.$strict>, z.ZodObject<Record<never, never>, z.core.$strip>, "package", Record<never, never>, Record<never, never>, false, Record<never, never>, Record<never, never>>]>>;
   props: z.ZodOptional<SubEntityClass<z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"slot">;
     text: z.ZodOptional<z.ZodBoolean>;
@@ -645,7 +650,9 @@ declare const ComponentEntity: EntityClass<z.ZodObject<{
     type: z.ZodLiteral<"variant">;
     value: z.ZodUnion<readonly [z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<{
       [k: string]: {};
-    }, string[]>>, z.ZodObject<{
+    }, string[]>>, z.ZodArray<z.ZodObject<{
+      __ref: z.ZodString;
+    }, z.core.$strip>>, z.ZodObject<{
       __ref: z.ZodString;
     }, z.core.$strip>, SubEntityClass<z.ZodObject<{
       label: z.ZodOptional<z.ZodString>;
@@ -796,7 +803,7 @@ declare const ComponentEntity: EntityClass<z.ZodObject<{
       layers: SubEntityClass<z.ZodUnion<readonly [z.ZodString, z.ZodLazy<z.ZodType<Ref, unknown, z.core.$ZodTypeInternals<Ref, unknown>>>, EntityClass<z.ZodObject<{
         version: z.ZodOptional<z.ZodString>;
         exports: z.ZodOptional<SubEntityClass<z.ZodObject<{}, z.core.$strict>>>;
-      }, z.core.$strict>, z.ZodObject<Record<never, never>, z.core.$strip>, "package", Record<never, never>, Record<never, never>, false>]>>;
+      }, z.core.$strict>, z.ZodObject<Record<never, never>, z.core.$strip>, "package", Record<never, never>, Record<never, never>, false, Record<never, never>, Record<never, never>>]>>;
       props: z.ZodOptional<SubEntityClass<z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodLiteral<"slot">;
         text: z.ZodOptional<z.ZodBoolean>;
@@ -815,7 +822,9 @@ declare const ComponentEntity: EntityClass<z.ZodObject<{
         type: z.ZodLiteral<"variant">;
         value: z.ZodUnion<readonly [z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<{
           [k: string]: {};
-        }, string[]>>, z.ZodObject<{
+        }, string[]>>, z.ZodArray<z.ZodObject<{
+          __ref: z.ZodString;
+        }, z.core.$strip>>, z.ZodObject<{
           __ref: z.ZodString;
         }, z.core.$strip>, SubEntityClass<z.ZodObject<{
           label: z.ZodOptional<z.ZodString>;
@@ -1717,7 +1726,7 @@ declare const ComponentEntity: EntityClass<z.ZodObject<{
     path,
     member
   }: ComputedInput) => string[];
-}, false>;
+}, false, Record<never, never>, Record<never, never>>;
 type ComponentRefDelta = Parameters<ReturnType<(typeof ComponentEntity)['ref']>['extend']>[0];
 type ExactComponentDelta<Delta> = Delta & { [Key in Exclude<keyof Delta, keyof ComponentRefDelta>]: never };
 type ContractLayers<Contract> = Contract extends {
@@ -1766,7 +1775,8 @@ type ExtendedComponentRef<Contract = ComponentContractOf<string>, Delta extends
    */
   styles(rules: readonly StyleRuleInput<ResolvedLayers<Contract, Delta>>[]): ExtendedComponentRef<Contract, Delta, Extra>;
 };
-type ComponentReference<Contract = ComponentContractOf<string>> = Ref & {
+type ComponentReference<Contract = ComponentContractOf<string>, Path extends string = string> = Ref$1 & {
+  /** The path as a literal, the way every entity's `ref` types its marker. */readonly __ref: `component:${Path}`;
   extend<const Delta extends ComponentRefDelta>(delta: ExactComponentDelta<Delta>): ExtendedComponentRef<Contract, Delta>;
 };
 /**
@@ -1776,7 +1786,7 @@ type ComponentReference<Contract = ComponentContractOf<string>> = Ref & {
  * Only its ref authoring result knows about the source-only `.render()` step.
  */
 declare const Component: Omit<typeof ComponentEntity, "ref"> & {
-  ref<const Path extends PathOf<"component">>(path: Path): ComponentReference<ComponentContractOf<Path>>;
+  ref<const Path extends PathOf<"component">>(path: Path): ComponentReference<ComponentContractOf<Path>, Path>;
   slots: typeof listSlots;
   slot: typeof slotOf;
   slotHostedBy: typeof slotHostedBy;

package/dist/entities/system/Component.js

@@ -8,9 +8,10 @@ import { derivedColor, gradient } from "./color.js";
 import { childrenPolicy } from "./element.js";
 import { listedIn } from "../../framework/utils/enumerated.js";
 import { valueSchemaOf } from "../../framework/value-domain.js";
+import { glyphLeafOf } from "./glyph-identity.js";
 import { Style, addBagKeyIssues, anatomyPropValue, bagNameEdges, bagRewriteName, bindBagTokens, collectBag, isPlainRecord, openBag, styleValue } from "./style-bag.js";
 import { storedPreview } from "../../framework/preview-store.js";
-import { propValueDomain, resolveComponentProps, stylePropValueLeaves, validateComponentProps } from "../../framework/projections.js";
+import { glyphPropsOf, propValueDomain, refListOf, resolveComponentProps, stylePropValueLeaves, validateComponentProps } from "../../framework/projections.js";
 import { intoName, 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";
@@ -18,6 +19,7 @@ import { cellAt } from "../../spec/cell.js";
 import { instanceAt } from "../../spec/instance.js";
 import { Package } from "./Package.js";
 import { File } from "./File.js";
+import { iconDomainInvariants } from "./icon-domain-invariants.js";
 import { z } from "zod";
 //#region src/entities/system/Component.ts
 /**
@@ -311,16 +313,21 @@ const VariantValue = defineSubEntity({
 	orphans: ["styles", "preview"]
 });
 /**
-* A variant's domain: the values it owns, or a ref that delegates to whatever owns them.
+* A variant's domain: the values it owns, a ref that delegates to whatever owns them, or a list of
+* refs whose leaves are unioned (an icon prop drawing from two libraries through one component).
 *
-* The array form is what an author writes (`['solid', 'ghost']`) and is coerced here into the
-* collection it is stored as, so every reader below this line sees one shape. In the schema rather
-* than in the authoring adapter because there are four doors into stored state — `register`, an
-* item create/update, a sub-op, and the artifact loader — and a coercion outside the schema only
+* The string-array form is what an author writes (`['solid', 'ghost']`) and is coerced here into
+* the collection it is stored as, so every reader below this line sees one shape. In the schema
+* rather than in the authoring adapter because there are four doors into stored state — `register`,
+* an item create/update, a sub-op, and the artifact loader — and a coercion outside the schema only
 * covers the one it is written in.
+*
+* The two list arms are disjoint: a string fails `refSchema` and a ref fails `z.string()`. Only the
+* empty list could land on either, and it lands on the string list, which coerces it to `{}`.
 */
 const variantDomain = z.union([
 	z.array(z.string()).transform((names) => Object.fromEntries(names.map((name) => [name, {}]))),
+	z.array(refSchema).min(1),
 	refSchema,
 	VariantValue
 ]);
@@ -526,9 +533,13 @@ function canonicalWhen(when) {
 * the leaf case rather than drop those forms, or the same rule validates or not depending on whether
 * the layer's element happens to resolve — which is a property of the config, not of the rule.
 */
-function styleBagValue(config, declaration, name = "<prop>") {
+function styleBagValue({ config, declaration, name = "<prop>", glyphLibraries }) {
 	const domain = valueSchemaOf(declaration, config);
 	const bound = declaration?.value;
+	if (glyphLibraries && glyphLibraries.length > 0) return z.union([glyphLeafOf({
+		config,
+		libraries: glyphLibraries
+	}), domain]);
 	if (declaration?.type === "slot") return z.union([domain, z.never()], { error: () => `\`${name}\` is a slot, so a rule may set it to a string of content and nothing else. A glyph or a nested element is an anatomy node under the layer's node — \`{ "element": { "__ref": "icon:<library>/<Name>" }, "visible": { "$state": "<prop>", "eq": "<value>" } }\` to show one per variant value — and the instance's own content arrives through the prop.` });
 	if (!isRef(bound) || kindOf(bound.__ref) !== "style-property") return domain;
 	const property = pathOf(bound.__ref);
@@ -583,11 +594,21 @@ function bagFor(config, layerElement) {
 function buildBagFor(config, layerElement) {
 	const shape = { ...stylePropShape(config) };
 	const component = isRef(layerElement) && config.resolveRef(layerElement.__ref) ? pathOf(layerElement.__ref) : void 0;
-	for (const [name, decl] of Object.entries(component ? resolveComponentProps(config, component) : {})) shape[name] = styleBagValue(config, decl, name).optional();
+	const glyphProps = component ? glyphPropsOf(config, component) : {};
+	for (const [name, decl] of Object.entries(component ? resolveComponentProps(config, component) : {})) shape[name] = styleBagValue({
+		config,
+		declaration: decl,
+		name,
+		glyphLibraries: decl?.type === "forward" ? glyphProps[name] : void 0
+	}).optional();
 	const declared = component ? (config.resolve("component", component)?.toJSON())?.props ?? {} : {};
 	for (const [name, decl] of Object.entries(declared)) {
 		if (decl?.type !== "slot" || name in shape) continue;
-		shape[name] = styleBagValue(config, decl, name).optional();
+		shape[name] = styleBagValue({
+			config,
+			declaration: decl,
+			name
+		}).optional();
 	}
 	shape.as ??= z.string().optional();
 	let bag;
@@ -619,10 +640,14 @@ function stylePropShape(config) {
 	const cached = stylePropShapes.get(config);
 	if (cached) return cached;
 	const shape = {};
-	for (const prop of config.list("style-property")) shape[prop.path] = styleBagValue(config, {
-		type: "styleProperty",
-		value: { __ref: `style-property:${prop.path}` }
-	}, prop.path).optional();
+	for (const prop of config.list("style-property")) shape[prop.path] = styleBagValue({
+		config,
+		declaration: {
+			type: "styleProperty",
+			value: { __ref: `style-property:${prop.path}` }
+		},
+		name: prop.path
+	}).optional();
 	stylePropShapes.set(config, shape);
 	return shape;
 }
@@ -637,7 +662,7 @@ function stylePropShape(config) {
 function ownsItsValues(declaration) {
 	const decl = declaration;
 	if (decl?.type !== "variant") return false;
-	return decl.value !== void 0 && !isRef(decl.value);
+	return decl.value !== void 0 && !isRef(decl.value) && refListOf(decl.value) === void 0;
 }
 /** The values a variant prop declares, in order — empty for one that delegates its domain. */
 function ownValues(declaration) {
@@ -2027,7 +2052,8 @@ subtree: z.boolean().default(true) }).optional()
 			}),
 			handler: (input, config) => validateComponentProps(config, String(input.path), input.data.props ?? {})
 		}
-	}
+	},
+	invariants: (config) => iconDomainInvariants(config)
 });
 const baseComponentRef = ComponentEntity.ref.bind(ComponentEntity);
 /** Component refs add the source-only authoring steps to the generic ref-extension value. All of them

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

@@ -7,6 +7,6 @@ import { z } from "zod";
 /** A composite variant (`overlays/elevation/1`) — the style-prop bag it applies. */
 declare const Composite: EntityClass<z.ZodObject<{
   styles: SubEntityClass<z.ZodType<StyleValue, unknown, z.core.$ZodTypeInternals<StyleValue, unknown>>>;
-}, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "composite", Record<never, never>, Record<never, never>, false>;
+}, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "composite", Record<never, never>, Record<never, never>, false, Record<never, never>, Record<never, never>>;
 //#endregion
 export { Composite };

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

@@ -6,6 +6,6 @@ declare const Device: EntityClass<z.ZodObject<{
   width: z.ZodNumber;
   height: z.ZodNumber;
   name: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "device", Record<never, never>, Record<never, never>, false>;
+}, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "device", Record<never, never>, Record<never, never>, false, Record<never, never>, Record<never, never>>;
 //#endregion
 export { Device };

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

@@ -1,4 +1,4 @@
-import { Ref } from "../../framework/utils/refs.js";
+import { Ref } from "../../framework/utils/ref-grammar.js";
 import { SubEntityClass } from "../../framework/defineSubEntity.js";
 import { ComputedInput } from "../../framework/registry.js";
 import { EntityClass } from "../../framework/defineEntity.js";
@@ -68,6 +68,6 @@ declare const File: EntityClass<z.ZodObject<{
   readonly binary: ({
     path
   }: ComputedInput) => boolean;
-}, false>;
+}, false, Record<never, never>, Record<never, never>>;
 //#endregion
 export { File, SCRIPT_EXTENSIONS, isBinaryAsset };

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

@@ -44,7 +44,7 @@ declare const Font: EntityClass<z.ZodObject<{
   isVariableFont: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strict>, z.ZodObject<{
   version: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>, "font", Record<never, never>, Record<never, never>, false>;
+}, z.core.$strict>, "font", Record<never, never>, Record<never, never>, false, Record<never, never>, Record<never, never>>;
 /**
  * The `font-family` value a family stands for: its own name, quoted, then its fallback stack as
  * authored — `"YA Sans VF", Helvetica Neue, Arial, sans-serif`.

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

@@ -12,7 +12,7 @@ type Declared = string | number | {
 declare const GlobalStyle: EntityClass<z.ZodObject<{
   selector: z.ZodString;
   declarations: z.ZodRecord<z.ZodString, z.ZodType<Declared, unknown, z.core.$ZodTypeInternals<Declared, unknown>>>;
-}, z.core.$strict>, z.ZodObject<Record<never, never>, z.core.$strip>, "global-style", Record<never, never>, Record<never, never>, false>;
+}, z.core.$strict>, z.ZodObject<Record<never, never>, z.core.$strip>, "global-style", Record<never, never>, Record<never, never>, false, Record<never, never>, Record<never, never>>;
 /**
  * A stable name for a rule, from its selector — `@keyframes bounce` → `bounce`, `.prompt-editor p`
  * → `promptEditorP`. Suffixed on collision, so two selectors that slug alike both land.

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

@@ -54,7 +54,7 @@ declare const Guidance: EntityClass<z.ZodObject<{
     "paint-style": "paint-style";
     "figma-import": "figma-import";
   }>>>;
-}, z.core.$strict>, "guidance", Record<never, never>, Record<never, never>, false>;
+}, z.core.$strict>, "guidance", Record<never, never>, Record<never, never>, false, Record<never, never>, Record<never, never>>;
 /**
  * A topic's effective reach, and which topic decided it. `appliesTo === undefined` means every
  * lane. `declaredBy` is the topic the answer was read from, so a lane can say "inherited from

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

@@ -9,6 +9,6 @@ declare const guidanceStyleFields: z.ZodObject<{
 type GuidanceStyleBody = z.infer<typeof guidanceStyleFields>;
 declare const GuidanceStyle: EntityClass<z.ZodObject<{
   text: z.ZodString;
-}, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "guidance-style", Record<never, never>, Record<never, never>, false>;
+}, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "guidance-style", Record<never, never>, Record<never, never>, false, Record<never, never>, Record<never, never>>;
 //#endregion
 export { GuidanceStyle, GuidanceStyleBody };

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

@@ -1,13 +1,29 @@
 import { SubEntityClass } from "../../framework/defineSubEntity.js";
-import { EntityClass } from "../../framework/defineEntity.js";
+import { EntityClass, GroupComputedInput } from "../../framework/defineEntity.js";
+import { GlyphNamespace } from "./glyph-identity.js";
 import { z } from "zod";
 
 //#region src/entities/system/Icon.d.ts
+/**
+ * How a set's `variant` reaches the drawing. Closed, like `metadata.format`: an arm exists only
+ * when the shared glyph resolver implements it.
+ *
+ *  - `{ prop: 'weight' }`: the glyph takes the variant as a prop (Phosphor).
+ *  - `{ export: { filled: '{name}Filled' } }`: a variant is another export, named by the template
+ *    with `{name}` replaced by the member's name; a variant not listed draws the bare export (Tabler).
+ */
+declare const iconVariantAs: z.ZodUnion<readonly [z.ZodObject<{
+  prop: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+  export: z.ZodRecord<z.ZodString, z.ZodString>;
+}, z.core.$strict>]>;
+type IconVariantAs = z.infer<typeof iconVariantAs>;
 /**
  * Icon (`icons/AcornIcon`) — one glyph in an icon library. The library (`icons`) is an EMERGENT group
  * from the path, and everything that describes the SET lives on that group node: its version, the
- * sizes and variants it ships, the component a placed icon renders through, and where the members'
- * descriptive facts come from (`metadata`).
+ * sizes and variants it ships, and where the members' descriptive facts come from (`metadata`). A
+ * component that renders a glyph names the library through its own prop's domain (`Icon.ref('phosphor')`),
+ * so the edge runs from the component to the set and the set knows nothing about its renderers.
  *
  * A member's identity is still its name; its fields carry what the name can't say. A group that
  * declares `metadata` gets those fields baked at BUILD time from the declared source, and the bake
@@ -22,25 +38,61 @@ declare const Icon: EntityClass<z.ZodObject<{
   categories: z.ZodOptional<z.ZodArray<z.ZodString>>;
   tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
   codepoint: z.ZodOptional<z.ZodNumber>;
+  variants: z.ZodOptional<z.ZodArray<z.ZodString>>;
   knockoutVariants: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>, z.ZodObject<{
-  module: z.ZodOptional<z.ZodString>;
-  version: z.ZodOptional<z.ZodString>;
+  package: z.ZodOptional<z.ZodObject<{
+    __ref: z.ZodString;
+  }, z.core.$strip>>;
   metadata: z.ZodOptional<z.ZodObject<{
     from: EntityClass<z.ZodObject<{
       version: z.ZodOptional<z.ZodString>;
       exports: z.ZodOptional<SubEntityClass<z.ZodObject<{}, z.core.$strict>>>;
-    }, z.core.$strict>, z.ZodObject<Record<never, never>, z.core.$strip>, "package", Record<never, never>, Record<never, never>, false>;
+    }, z.core.$strict>, z.ZodObject<Record<never, never>, z.core.$strip>, "package", Record<never, never>, Record<never, never>, false, Record<never, never>, Record<never, never>>;
     format: z.ZodEnum<{
       uds: "uds";
       phosphor: "phosphor";
+      tabler: "tabler";
     }>;
   }, z.core.$strict>>;
   sizes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
   variants: z.ZodOptional<z.ZodArray<z.ZodString>>;
-  component: z.ZodOptional<z.ZodObject<{
-    __ref: z.ZodString;
-  }, z.core.$strip>>;
-}, z.core.$strict>, "icon", Record<never, never>, Record<never, never>, false>;
+  variantAs: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+    prop: z.ZodString;
+  }, z.core.$strict>, z.ZodObject<{
+    export: z.ZodRecord<z.ZodString, z.ZodString>;
+  }, z.core.$strict>]>>;
+}, z.core.$strict>, "icon", Record<never, never>, Record<never, never>, false, {
+  /** The glyphs the set ships, by leaf name. */readonly members: ({
+    config,
+    path
+  }: GroupComputedInput) => string[];
+  /** The module the glyphs import from: the named package's path. `pathOf` drops a source
+   *  qualifier, so a borrowed set's module is still the bare specifier. */
+  readonly module: ({
+    meta
+  }: GroupComputedInput) => string | undefined;
+  /** The version the named package pins, resolved through the ref in whichever config holds the
+   *  package row. */
+  readonly version: ({
+    config,
+    meta
+  }: GroupComputedInput) => string | undefined;
+}, {
+  /**
+   * The package's module namespace, so an authored glyph (`name={StarIcon}`) is matched to its
+   * member by reference rather than by anything the component says about itself: Tabler's
+   * `displayName` is not its export name. Read once while the config file is evaluated and never
+   * stored; only the names under `items` are recorded, so a deprecated alias of a listed export
+   * resolves to the listed name.
+   */
+  readonly glyphs: ({
+    input,
+    body
+  }: {
+    input: GlyphNamespace;
+    body: Readonly<Record<string, unknown>>;
+  }) => void;
+}>;
 //#endregion
-export { Icon };
+export { Icon, IconVariantAs, iconVariantAs };

package/dist/entities/system/Icon.js

@@ -1,13 +1,26 @@
+import { isRef, pathOf } from "../../framework/utils/refs.js";
 import { defineEntity } from "../../framework/defineEntity.js";
-import { Component } from "./Component.js";
+import { glyphOfLibrary, recordGlyphIdentities } from "./glyph-identity.js";
+import { Package } from "./Package.js";
+import { iconDomainInvariants } from "./icon-domain-invariants.js";
 import { iconMemberMetadata, iconMetadataDeclaration } from "./icon-metadata.js";
 import { z } from "zod";
 //#region src/entities/system/Icon.ts
 /**
+* How a set's `variant` reaches the drawing. Closed, like `metadata.format`: an arm exists only
+* when the shared glyph resolver implements it.
+*
+*  - `{ prop: 'weight' }`: the glyph takes the variant as a prop (Phosphor).
+*  - `{ export: { filled: '{name}Filled' } }`: a variant is another export, named by the template
+*    with `{name}` replaced by the member's name; a variant not listed draws the bare export (Tabler).
+*/
+const iconVariantAs = z.union([z.strictObject({ prop: z.string().min(1) }), z.strictObject({ export: z.record(z.string().min(1), z.string().min(1)) })]);
+/**
 * Icon (`icons/AcornIcon`) — one glyph in an icon library. The library (`icons`) is an EMERGENT group
 * from the path, and everything that describes the SET lives on that group node: its version, the
-* sizes and variants it ships, the component a placed icon renders through, and where the members'
-* descriptive facts come from (`metadata`).
+* sizes and variants it ships, and where the members' descriptive facts come from (`metadata`). A
+* component that renders a glyph names the library through its own prop's domain (`Icon.ref('phosphor')`),
+* so the edge runs from the component to the set and the set knows nothing about its renderers.
 *
 * A member's identity is still its name; its fields carry what the name can't say. A group that
 * declares `metadata` gets those fields baked at BUILD time from the declared source, and the bake
@@ -24,12 +37,10 @@ const Icon = defineEntity({
 	labelPlural: "Icons",
 	fields: iconMemberMetadata,
 	groupFields: z.strictObject({
-		/** The package the glyphs come from. Declared here rather than recovered by scanning source for
-		*  a namespace import used inside a `.group(…)` call, which is what `assetModules` does today —
-		*  and what a generated module needs, since it has to import the glyph it renders. The same
-		*  field a `Package` group carries, for the same reason. */
-		module: z.string().optional(),
-		version: z.string().optional(),
+		/** The package the glyphs come from — a REF to the `Package` item, which owns the module
+		*  specifier (its path) and the pinned version. A generated module imports the glyphs it renders
+		*  from it, and a render that imports a member of it is placing a glyph of this set. */
+		package: Package.optional(),
 		/** Where member metadata comes from and how to read it — `{ from, format }`. The build resolves
 		*  the source and bakes each member's fields; see `icon-metadata.ts`. */
 		metadata: iconMetadataDeclaration.optional(),
@@ -37,10 +48,55 @@ const Icon = defineEntity({
 		sizes: z.record(z.string(), z.number()).optional(),
 		/** Weights/styles the set ships (`regular`, `fill`). */
 		variants: z.array(z.string()).optional(),
-		/** The component a placed icon renders through — a REF, so the graph sees the edge and a
-		*  rename of that component cascades into this library. */
-		component: Component.optional()
-	})
+		/** How a variant reaches the glyph; see {@link iconVariantAs}. Absent, a variant is dropped at
+		*  render. */
+		variantAs: iconVariantAs.optional()
+	}),
+	groupComputed: {
+		/** The glyphs the set ships, by leaf name. */
+		members: ({ config, path }) => config.members("icon", path).map((member) => member.path.startsWith(`${path}/`) ? member.path.slice(path.length + 1) : member.path),
+		/** The module the glyphs import from: the named package's path. `pathOf` drops a source
+		*  qualifier, so a borrowed set's module is still the bare specifier. */
+		module: ({ meta }) => isRef(meta.package) ? pathOf(meta.package) : void 0,
+		/** The version the named package pins, resolved through the ref in whichever config holds the
+		*  package row. */
+		version: ({ config, meta }) => {
+			if (!isRef(meta.package)) return void 0;
+			const pinned = config.resolveRef(meta.package)?.toJSON();
+			return typeof pinned?.version === "string" ? pinned.version : void 0;
+		}
+	},
+	groupInputs: { 
+	/**
+	* The package's module namespace, so an authored glyph (`name={StarIcon}`) is matched to its
+	* member by reference rather than by anything the component says about itself: Tabler's
+	* `displayName` is not its export name. Read once while the config file is evaluated and never
+	* stored; only the names under `items` are recorded, so a deprecated alias of a listed export
+	* resolves to the listed name.
+	*/
+glyphs: ({ input, body }) => {
+		if (!isRef(body.package)) throw new Error("Icon.group: `glyphs` needs `package` on the same group, since a glyph is identified as an export of that module.");
+		recordGlyphIdentities({
+			namespace: input,
+			names: Object.keys(body.items ?? {}),
+			specifier: pathOf(body.package)
+		});
+	} },
+	/**
+	* A value bound to a library may be the glyph component itself, or the `package:` export ref the
+	* open-bag pass turned it into. Either is answered as the member name when the export is one of
+	* this library's and comes from the module its `package` names.
+	*/
+	authoredValue: ({ config, target, leaves }) => {
+		const meta = config.configFor(target)?.groupMeta("icon", pathOf(target));
+		const module = isRef(meta?.package) ? pathOf(meta.package) : void 0;
+		return glyphOfLibrary({
+			library: pathOf(target),
+			module,
+			leaves
+		});
+	},
+	invariants: (config) => iconDomainInvariants(config)
 });
 //#endregion
-export { Icon };
+export { Icon, iconVariantAs };

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

@@ -329,7 +329,7 @@ declare const LinkedSystem: EntityClass<z.ZodObject<{
     member,
     path
   }: ComputedInput) => string;
-}, false>;
+}, false, Record<never, never>, Record<never, never>>;
 /**
  * What a pin's `options` may say, checked against the config type it is declared in — one record per
  * accessor, keyed by the path the source spells, valued by what this config does to it.

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

@@ -46,7 +46,7 @@ declare const Modifier: EntityClass<z.ZodObject<{
   }>;
   value: z.ZodUnion<readonly [z.ZodString, z.ZodLazy<EntityClass<z.ZodObject<{
     styles: SubEntityClass<z.ZodType<StyleValue, unknown, z.core.$ZodTypeInternals<StyleValue, unknown>>>;
-  }, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "composite", Record<never, never>, Record<never, never>, false>>]>;
+  }, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "composite", Record<never, never>, Record<never, never>, false, Record<never, never>, Record<never, never>>>]>;
 }, z.core.$strip>, z.ZodObject<{
   type: z.ZodOptional<z.ZodEnum<{
     mode: "mode";
@@ -55,7 +55,7 @@ declare const Modifier: EntityClass<z.ZodObject<{
   default: z.ZodOptional<z.ZodObject<{
     __ref: z.ZodString;
   }, z.core.$strip>>;
-}, z.core.$strip>, "modifier", Record<never, never>, Record<never, never>, false>;
+}, z.core.$strip>, "modifier", Record<never, never>, Record<never, never>, false, Record<never, never>, Record<never, never>>;
 /** A path's last segment. */
 declare function modifierLeaf(path: string): string;
 /**

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

@@ -23,6 +23,6 @@ declare const Motion: EntityClass<z.ZodDiscriminatedUnion<[z.ZodObject<{
   drag: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
   dragConstraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
   dragElastic: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strict>], "runtime">, z.ZodObject<Record<never, never>, z.core.$strip>, "motion", Record<never, never>, Record<never, never>, false>;
+}, z.core.$strict>], "runtime">, z.ZodObject<Record<never, never>, z.core.$strip>, "motion", Record<never, never>, Record<never, never>, false, Record<never, never>, Record<never, never>>;
 //#endregion
 export { Motion };

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

@@ -37,6 +37,6 @@ import { z } from "zod";
 declare const Package: EntityClass<z.ZodObject<{
   version: z.ZodOptional<z.ZodString>;
   exports: z.ZodOptional<SubEntityClass<z.ZodObject<{}, z.core.$strict>>>;
-}, z.core.$strict>, z.ZodObject<Record<never, never>, z.core.$strip>, "package", Record<never, never>, Record<never, never>, false>;
+}, z.core.$strict>, z.ZodObject<Record<never, never>, z.core.$strip>, "package", Record<never, never>, Record<never, never>, false, Record<never, never>, Record<never, never>>;
 //#endregion
 export { Package };

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

@@ -89,6 +89,6 @@ declare const Settings: EntityClass<z.ZodObject<{
     pagesDir: z.ZodOptional<z.ZodString>;
     port: z.ZodOptional<z.ZodNumber>;
   }, z.core.$strict>>;
-}, z.core.$strict>, z.ZodObject<Record<never, never>, z.core.$strip>, "settings", Record<never, never>, Record<never, never>, true>;
+}, z.core.$strict>, z.ZodObject<Record<never, never>, z.core.$strip>, "settings", Record<never, never>, Record<never, never>, true, Record<never, never>, Record<never, never>>;
 //#endregion
 export { BuildSection, CSS_DEFAULTS, CssPrefix, CssSection, PLAYGROUND_DEFAULTS, PlaygroundSection, Settings, SystemSection, classPrefixOf, cssPrefixes, varPrefixOf };