@yahoo/uds-create-config 4.10.2 → 4.10.4

package/dist/migrations/2.0.0/v1-artifact.d.ts

@@ -1,11 +1,10 @@
+import { Ref } from "../../framework/utils/ref-grammar.js";
 import { CopyPlan } from "../../entities/system/copy-plan.js";
-import { ExtendableRef, Ref } from "../../framework/utils/refs.js";
-import { CreateInput } from "../../framework/utils/field-schema.js";
 import { SubEntityClass } from "../../framework/defineSubEntity.js";
 import { ComputedInput } from "../../framework/registry.js";
 import { DerivedEntityClass } from "../../framework/defineDerivedEntity.js";
 import { ComponentContractOf, PathOf } from "../../framework/registered.js";
-import { EntityClass } from "../../framework/defineEntity.js";
+import { EntityClass, GroupComputedInput } from "../../framework/defineEntity.js";
 import { ConfigInstance } from "../../framework/defineConfig.js";
 import { PinOptionsField } from "../../entities/system/LinkedSystem.js";
 import { BreakPlan, LinkPlan, SourceRowState, UnlinkPlan } from "../../entities/system/link-plan.js";
@@ -15,6 +14,7 @@ import { StoredPreviewCondition } from "../../framework/preview-store.js";
 import { listSlots, namedSlots, slotHostedBy, slotOf } from "../../spec/slot.js";
 import { cellAt } from "../../spec/cell.js";
 import { instanceAt } from "../../spec/instance.js";
+import { GlyphNamespace } from "../../entities/system/glyph-identity.js";
 import { DerivedColor, Gradient } from "../../entities/system/color.js";
 import { StyleValue } from "../../entities/system/style-bag.js";
 import { ComponentElementBody, ComponentReference, ComponentStyleBody } from "../../entities/system/Component.js";
@@ -228,7 +228,7 @@ declare function loadV1Artifact(studio: V1Artifact, options?: LoadV1Options): Co
       pagesDir: _$zod.ZodOptional<_$zod.ZodString>;
       port: _$zod.ZodOptional<_$zod.ZodNumber>;
     }, _$zod_v4_core0.$strict>>;
-  }, _$zod_v4_core0.$strict>, _$zod.ZodObject<Record<never, never>, _$zod_v4_core0.$strip>, "settings", Record<never, never>, Record<never, never>, true>;
+  }, _$zod_v4_core0.$strict>, _$zod.ZodObject<Record<never, never>, _$zod_v4_core0.$strip>, "settings", Record<never, never>, Record<never, never>, true, Record<never, never>, Record<never, never>>;
   tokens: EntityClass<_$zod.ZodObject<{
     value: _$zod.ZodType<string | number | Ref | DerivedColor | Gradient, unknown, _$zod_v4_core0.$ZodTypeInternals<string | number | Ref | DerivedColor | Gradient, unknown>>;
     type: _$zod.ZodOptional<_$zod.ZodString>;
@@ -242,12 +242,12 @@ declare function loadV1Artifact(studio: V1Artifact, options?: LoadV1Options): Co
     readonly create: {
       readonly description: `Create a token at \`<group>/<name>\` \u2014 \`data.value\` is the CSS value. The first path segment is its group, and a style property takes a whole group as one ref (\`${string}\`), so put the tokens one prop should offer in one group rather than listing values on the prop.`;
     };
-  }, Record<never, never>, false>;
+  }, Record<never, never>, false, Record<never, never>, Record<never, never>>;
   components: Omit<EntityClass<_$zod.ZodObject<{
     layers: SubEntityClass<_$zod.ZodUnion<readonly [_$zod.ZodString, _$zod.ZodLazy<_$zod.ZodType<Ref, unknown, _$zod_v4_core0.$ZodTypeInternals<Ref, unknown>>>, EntityClass<_$zod.ZodObject<{
       version: _$zod.ZodOptional<_$zod.ZodString>;
       exports: _$zod.ZodOptional<SubEntityClass<_$zod.ZodObject<{}, _$zod_v4_core0.$strict>>>;
-    }, _$zod_v4_core0.$strict>, _$zod.ZodObject<Record<never, never>, _$zod_v4_core0.$strip>, "package", Record<never, never>, Record<never, never>, false>]>>;
+    }, _$zod_v4_core0.$strict>, _$zod.ZodObject<Record<never, never>, _$zod_v4_core0.$strip>, "package", Record<never, never>, Record<never, never>, false, Record<never, never>, Record<never, never>>]>>;
     props: _$zod.ZodOptional<SubEntityClass<_$zod.ZodNullable<_$zod.ZodDiscriminatedUnion<[_$zod.ZodObject<{
       type: _$zod.ZodLiteral<"slot">;
       text: _$zod.ZodOptional<_$zod.ZodBoolean>;
@@ -266,7 +266,9 @@ declare function loadV1Artifact(studio: V1Artifact, options?: LoadV1Options): Co
       type: _$zod.ZodLiteral<"variant">;
       value: _$zod.ZodUnion<readonly [_$zod.ZodPipe<_$zod.ZodArray<_$zod.ZodString>, _$zod.ZodTransform<{
         [k: string]: {};
-      }, string[]>>, _$zod.ZodObject<{
+      }, string[]>>, _$zod.ZodArray<_$zod.ZodObject<{
+        __ref: _$zod.ZodString;
+      }, _$zod_v4_core0.$strip>>, _$zod.ZodObject<{
         __ref: _$zod.ZodString;
       }, _$zod_v4_core0.$strip>, SubEntityClass<_$zod.ZodObject<{
         label: _$zod.ZodOptional<_$zod.ZodString>;
@@ -417,7 +419,7 @@ declare function loadV1Artifact(studio: V1Artifact, options?: LoadV1Options): Co
         layers: SubEntityClass<_$zod.ZodUnion<readonly [_$zod.ZodString, _$zod.ZodLazy<_$zod.ZodType<Ref, unknown, _$zod_v4_core0.$ZodTypeInternals<Ref, unknown>>>, EntityClass<_$zod.ZodObject<{
           version: _$zod.ZodOptional<_$zod.ZodString>;
           exports: _$zod.ZodOptional<SubEntityClass<_$zod.ZodObject<{}, _$zod_v4_core0.$strict>>>;
-        }, _$zod_v4_core0.$strict>, _$zod.ZodObject<Record<never, never>, _$zod_v4_core0.$strip>, "package", Record<never, never>, Record<never, never>, false>]>>;
+        }, _$zod_v4_core0.$strict>, _$zod.ZodObject<Record<never, never>, _$zod_v4_core0.$strip>, "package", Record<never, never>, Record<never, never>, false, Record<never, never>, Record<never, never>>]>>;
         props: _$zod.ZodOptional<SubEntityClass<_$zod.ZodNullable<_$zod.ZodDiscriminatedUnion<[_$zod.ZodObject<{
           type: _$zod.ZodLiteral<"slot">;
           text: _$zod.ZodOptional<_$zod.ZodBoolean>;
@@ -436,7 +438,9 @@ declare function loadV1Artifact(studio: V1Artifact, options?: LoadV1Options): Co
           type: _$zod.ZodLiteral<"variant">;
           value: _$zod.ZodUnion<readonly [_$zod.ZodPipe<_$zod.ZodArray<_$zod.ZodString>, _$zod.ZodTransform<{
             [k: string]: {};
-          }, string[]>>, _$zod.ZodObject<{
+          }, string[]>>, _$zod.ZodArray<_$zod.ZodObject<{
+            __ref: _$zod.ZodString;
+          }, _$zod_v4_core0.$strip>>, _$zod.ZodObject<{
             __ref: _$zod.ZodString;
           }, _$zod_v4_core0.$strip>, SubEntityClass<_$zod.ZodObject<{
             label: _$zod.ZodOptional<_$zod.ZodString>;
@@ -1283,8 +1287,8 @@ declare function loadV1Artifact(studio: V1Artifact, options?: LoadV1Options): Co
       path,
       member
     }: ComputedInput) => string[];
-  }, false>, "ref"> & {
-    ref<const Path extends PathOf<"component">>(path: Path): ComponentReference<ComponentContractOf<Path>>;
+  }, false, Record<never, never>, Record<never, never>>, "ref"> & {
+    ref<const Path extends PathOf<"component">>(path: Path): ComponentReference<ComponentContractOf<Path>, Path>;
     slots: typeof listSlots;
     slot: typeof slotOf;
     slotHostedBy: typeof slotHostedBy;
@@ -1300,7 +1304,7 @@ declare function loadV1Artifact(studio: V1Artifact, options?: LoadV1Options): Co
     }>;
     value: _$zod.ZodUnion<readonly [_$zod.ZodString, _$zod.ZodLazy<EntityClass<_$zod.ZodObject<{
       styles: SubEntityClass<_$zod.ZodType<StyleValue, unknown, _$zod_v4_core0.$ZodTypeInternals<StyleValue, unknown>>>;
-    }, _$zod_v4_core0.$strip>, _$zod.ZodObject<Record<never, never>, _$zod_v4_core0.$strip>, "composite", Record<never, never>, Record<never, never>, false>>]>;
+    }, _$zod_v4_core0.$strip>, _$zod.ZodObject<Record<never, never>, _$zod_v4_core0.$strip>, "composite", Record<never, never>, Record<never, never>, false, Record<never, never>, Record<never, never>>>]>;
   }, _$zod_v4_core0.$strip>, _$zod.ZodObject<{
     type: _$zod.ZodOptional<_$zod.ZodEnum<{
       mode: "mode";
@@ -1309,8 +1313,8 @@ declare function loadV1Artifact(studio: V1Artifact, options?: LoadV1Options): Co
     default: _$zod.ZodOptional<_$zod.ZodObject<{
       __ref: _$zod.ZodString;
     }, _$zod_v4_core0.$strip>>;
-  }, _$zod_v4_core0.$strip>, "modifier", Record<never, never>, Record<never, never>, false>;
-  styleProps: Omit<EntityClass<_$zod.ZodObject<{
+  }, _$zod_v4_core0.$strip>, "modifier", Record<never, never>, Record<never, never>, false, Record<never, never>, Record<never, never>>;
+  styleProps: EntityClass<_$zod.ZodObject<{
     properties: _$zod.ZodArray<_$zod.ZodString>;
     values: _$zod.ZodOptional<_$zod.ZodArray<_$zod.ZodType<StylePropValue, unknown, _$zod_v4_core0.$ZodTypeInternals<StylePropValue, unknown>>>>;
     responsive: _$zod.ZodDefault<_$zod.ZodBoolean>;
@@ -1336,22 +1340,10 @@ declare function loadV1Artifact(studio: V1Artifact, options?: LoadV1Options): Co
         data: Record<string, unknown>;
       } | undefined;
     };
-  }, Record<never, never>, false>, "ref"> & {
-    ref<const Path extends PathOf<"style-property">>(path: Path): ReturnType<(path: string) => ExtendableRef<Partial<CreateInput<_$zod.ZodObject<{
-      properties: _$zod.ZodArray<_$zod.ZodString>;
-      values: _$zod.ZodOptional<_$zod.ZodArray<_$zod.ZodType<StylePropValue, unknown, _$zod_v4_core0.$ZodTypeInternals<StylePropValue, unknown>>>>;
-      responsive: _$zod.ZodDefault<_$zod.ZodBoolean>;
-      classPrefix: _$zod.ZodOptional<_$zod.ZodString>;
-      arbitrary: _$zod.ZodDefault<_$zod.ZodBoolean>;
-      negates: _$zod.ZodDefault<_$zod.ZodBoolean>;
-      opacityOf: _$zod.ZodOptional<_$zod.ZodLazy<_$zod.ZodType<Ref, unknown, _$zod_v4_core0.$ZodTypeInternals<Ref, unknown>>>>;
-    }, _$zod_v4_core0.$strip>>>>> & {
-      readonly __ref: `style-property:${Path}`;
-    };
-  };
+  }, Record<never, never>, false, Record<never, never>, Record<never, never>>;
   composites: EntityClass<_$zod.ZodObject<{
     styles: SubEntityClass<_$zod.ZodType<StyleValue, unknown, _$zod_v4_core0.$ZodTypeInternals<StyleValue, unknown>>>;
-  }, _$zod_v4_core0.$strip>, _$zod.ZodObject<Record<never, never>, _$zod_v4_core0.$strip>, "composite", Record<never, never>, Record<never, never>, false>;
+  }, _$zod_v4_core0.$strip>, _$zod.ZodObject<Record<never, never>, _$zod_v4_core0.$strip>, "composite", Record<never, never>, Record<never, never>, false, Record<never, never>, Record<never, never>>;
   motion: EntityClass<_$zod.ZodDiscriminatedUnion<[_$zod.ZodObject<{
     runtime: _$zod.ZodLiteral<"css">;
     keyframes: _$zod.ZodRecord<_$zod.ZodString, _$zod.ZodRecord<_$zod.ZodString, _$zod.ZodUnknown>>;
@@ -1373,7 +1365,7 @@ declare function loadV1Artifact(studio: V1Artifact, options?: LoadV1Options): Co
     drag: _$zod.ZodOptional<_$zod.ZodUnion<readonly [_$zod.ZodBoolean, _$zod.ZodString]>>;
     dragConstraints: _$zod.ZodOptional<_$zod.ZodRecord<_$zod.ZodString, _$zod.ZodNumber>>;
     dragElastic: _$zod.ZodOptional<_$zod.ZodNumber>;
-  }, _$zod_v4_core0.$strict>], "runtime">, _$zod.ZodObject<Record<never, never>, _$zod_v4_core0.$strip>, "motion", Record<never, never>, Record<never, never>, false>;
+  }, _$zod_v4_core0.$strict>], "runtime">, _$zod.ZodObject<Record<never, never>, _$zod_v4_core0.$strip>, "motion", Record<never, never>, Record<never, never>, false, Record<never, never>, Record<never, never>>;
   fonts: EntityClass<_$zod.ZodObject<{
     fontFamily: _$zod.ZodString;
     files: _$zod.ZodOptional<SubEntityClass<_$zod.ZodObject<{
@@ -1388,35 +1380,60 @@ declare function loadV1Artifact(studio: V1Artifact, options?: LoadV1Options): Co
     isVariableFont: _$zod.ZodOptional<_$zod.ZodBoolean>;
   }, _$zod_v4_core0.$strict>, _$zod.ZodObject<{
     version: _$zod.ZodOptional<_$zod.ZodString>;
-  }, _$zod_v4_core0.$strict>, "font", Record<never, never>, Record<never, never>, false>;
+  }, _$zod_v4_core0.$strict>, "font", Record<never, never>, Record<never, never>, false, Record<never, never>, Record<never, never>>;
   icons: EntityClass<_$zod.ZodObject<{
     categories: _$zod.ZodOptional<_$zod.ZodArray<_$zod.ZodString>>;
     tags: _$zod.ZodOptional<_$zod.ZodArray<_$zod.ZodString>>;
     codepoint: _$zod.ZodOptional<_$zod.ZodNumber>;
+    variants: _$zod.ZodOptional<_$zod.ZodArray<_$zod.ZodString>>;
     knockoutVariants: _$zod.ZodOptional<_$zod.ZodArray<_$zod.ZodString>>;
   }, _$zod_v4_core0.$strict>, _$zod.ZodObject<{
-    module: _$zod.ZodOptional<_$zod.ZodString>;
-    version: _$zod.ZodOptional<_$zod.ZodString>;
+    package: _$zod.ZodOptional<_$zod.ZodObject<{
+      __ref: _$zod.ZodString;
+    }, _$zod_v4_core0.$strip>>;
     metadata: _$zod.ZodOptional<_$zod.ZodObject<{
       from: EntityClass<_$zod.ZodObject<{
         version: _$zod.ZodOptional<_$zod.ZodString>;
         exports: _$zod.ZodOptional<SubEntityClass<_$zod.ZodObject<{}, _$zod_v4_core0.$strict>>>;
-      }, _$zod_v4_core0.$strict>, _$zod.ZodObject<Record<never, never>, _$zod_v4_core0.$strip>, "package", Record<never, never>, Record<never, never>, false>;
+      }, _$zod_v4_core0.$strict>, _$zod.ZodObject<Record<never, never>, _$zod_v4_core0.$strip>, "package", Record<never, never>, Record<never, never>, false, Record<never, never>, Record<never, never>>;
       format: _$zod.ZodEnum<{
         uds: "uds";
         phosphor: "phosphor";
+        tabler: "tabler";
       }>;
     }, _$zod_v4_core0.$strict>>;
     sizes: _$zod.ZodOptional<_$zod.ZodRecord<_$zod.ZodString, _$zod.ZodNumber>>;
     variants: _$zod.ZodOptional<_$zod.ZodArray<_$zod.ZodString>>;
-    component: _$zod.ZodOptional<_$zod.ZodObject<{
-      __ref: _$zod.ZodString;
-    }, _$zod_v4_core0.$strip>>;
-  }, _$zod_v4_core0.$strict>, "icon", Record<never, never>, Record<never, never>, false>;
+    variantAs: _$zod.ZodOptional<_$zod.ZodUnion<readonly [_$zod.ZodObject<{
+      prop: _$zod.ZodString;
+    }, _$zod_v4_core0.$strict>, _$zod.ZodObject<{
+      export: _$zod.ZodRecord<_$zod.ZodString, _$zod.ZodString>;
+    }, _$zod_v4_core0.$strict>]>>;
+  }, _$zod_v4_core0.$strict>, "icon", Record<never, never>, Record<never, never>, false, {
+    readonly members: ({
+      config,
+      path
+    }: GroupComputedInput) => string[];
+    readonly module: ({
+      meta
+    }: GroupComputedInput) => string | undefined;
+    readonly version: ({
+      config,
+      meta
+    }: GroupComputedInput) => string | undefined;
+  }, {
+    readonly glyphs: ({
+      input,
+      body
+    }: {
+      input: GlyphNamespace;
+      body: Readonly<Record<string, unknown>>;
+    }) => void;
+  }>;
   packages: EntityClass<_$zod.ZodObject<{
     version: _$zod.ZodOptional<_$zod.ZodString>;
     exports: _$zod.ZodOptional<SubEntityClass<_$zod.ZodObject<{}, _$zod_v4_core0.$strict>>>;
-  }, _$zod_v4_core0.$strict>, _$zod.ZodObject<Record<never, never>, _$zod_v4_core0.$strip>, "package", Record<never, never>, Record<never, never>, false>;
+  }, _$zod_v4_core0.$strict>, _$zod.ZodObject<Record<never, never>, _$zod_v4_core0.$strip>, "package", Record<never, never>, Record<never, never>, false, Record<never, never>, Record<never, never>>;
   files: EntityClass<_$zod.ZodObject<{
     hash: _$zod.ZodString;
     imports: _$zod.ZodOptional<SubEntityClass<_$zod.ZodObject<{
@@ -1428,7 +1445,7 @@ declare function loadV1Artifact(studio: V1Artifact, options?: LoadV1Options): Co
     readonly binary: ({
       path
     }: ComputedInput) => boolean;
-  }, false>;
+  }, false, Record<never, never>, Record<never, never>>;
   guidance: EntityClass<_$zod.ZodObject<{
     text: _$zod.ZodArray<_$zod.ZodUnion<readonly [_$zod.ZodString, _$zod.ZodObject<{
       __ref: _$zod.ZodString;
@@ -1442,10 +1459,10 @@ declare function loadV1Artifact(studio: V1Artifact, options?: LoadV1Options): Co
       "paint-style": "paint-style";
       "figma-import": "figma-import";
     }>>>;
-  }, _$zod_v4_core0.$strict>, "guidance", Record<never, never>, Record<never, never>, false>;
+  }, _$zod_v4_core0.$strict>, "guidance", Record<never, never>, Record<never, never>, false, Record<never, never>, Record<never, never>>;
   guidanceStyles: EntityClass<_$zod.ZodObject<{
     text: _$zod.ZodString;
-  }, _$zod_v4_core0.$strip>, _$zod.ZodObject<Record<never, never>, _$zod_v4_core0.$strip>, "guidance-style", Record<never, never>, Record<never, never>, false>;
+  }, _$zod_v4_core0.$strip>, _$zod.ZodObject<Record<never, never>, _$zod_v4_core0.$strip>, "guidance-style", Record<never, never>, Record<never, never>, false, Record<never, never>, Record<never, never>>;
   canvasRoles: EntityClass<_$zod.ZodObject<{
     entries: _$zod.ZodArray<_$zod.ZodObject<{
       component: _$zod.ZodObject<{
@@ -1458,7 +1475,7 @@ declare function loadV1Artifact(studio: V1Artifact, options?: LoadV1Options): Co
     readonly create: {
       readonly description: `Register a canvas insert tool for this system. \`path\` is the role, one of ${string}; \`data.entries\` names the components that tool inserts, one marked \`default\`. A system whose roles are unregistered has those canvas tools disabled, so register \`frame\` and \`text\` once a layout primitive and a text primitive exist.`;
     };
-  }, Record<never, never>, false>;
+  }, Record<never, never>, false, Record<never, never>, Record<never, never>>;
   globalStyles: EntityClass<_$zod.ZodObject<{
     selector: _$zod.ZodString;
     declarations: _$zod.ZodRecord<_$zod.ZodString, _$zod.ZodType<string | number | {
@@ -1474,12 +1491,12 @@ declare function loadV1Artifact(studio: V1Artifact, options?: LoadV1Options): Co
         __ref: string;
       } | /*elided*/any;
     }, unknown>>>;
-  }, _$zod_v4_core0.$strict>, _$zod.ZodObject<Record<never, never>, _$zod_v4_core0.$strip>, "global-style", Record<never, never>, Record<never, never>, false>;
+  }, _$zod_v4_core0.$strict>, _$zod.ZodObject<Record<never, never>, _$zod_v4_core0.$strip>, "global-style", Record<never, never>, Record<never, never>, false, Record<never, never>, Record<never, never>>;
   devices: EntityClass<_$zod.ZodObject<{
     width: _$zod.ZodNumber;
     height: _$zod.ZodNumber;
     name: _$zod.ZodOptional<_$zod.ZodString>;
-  }, _$zod_v4_core0.$strip>, _$zod.ZodObject<Record<never, never>, _$zod_v4_core0.$strip>, "device", Record<never, never>, Record<never, never>, false>;
+  }, _$zod_v4_core0.$strip>, _$zod.ZodObject<Record<never, never>, _$zod_v4_core0.$strip>, "device", Record<never, never>, Record<never, never>, false, Record<never, never>, Record<never, never>>;
   linkedSystems: EntityClass<_$zod.ZodObject<{
     configPath: _$zod.ZodOptional<_$zod.ZodString>;
     link: _$zod.ZodOptional<_$zod.ZodUnion<readonly [_$zod.ZodLiteral<"*">, _$zod.ZodRecord<_$zod.ZodString, _$zod.ZodUnion<readonly [_$zod.ZodLiteral<"*">, _$zod.ZodArray<_$zod.ZodString>]>>]>>;
@@ -1677,7 +1694,7 @@ declare function loadV1Artifact(studio: V1Artifact, options?: LoadV1Options): Co
       member,
       path
     }: ComputedInput) => string;
-  }, false>;
+  }, false, Record<never, never>, Record<never, never>>;
 }, {
   operations: DerivedEntityClass<_$zod.ZodObject<{
     kind: _$zod.ZodString;

package/dist/migrations/2.0.0/v1-artifact.js

@@ -82,7 +82,7 @@ const REF_KIND = {
 	tokenGroup: "token",
 	styleProperty: "style-property",
 	composite: "composite",
-	assetGroup: "font",
+	glyphLibrary: "font",
 	component: "component",
 	mode: "mode"
 };
@@ -97,7 +97,7 @@ const isMarker = (v) => typeof v === "object" && v !== null && "__kind" in v;
 *
 * Module-scoped because `convertValue` is called from a dozen places and threading a resolver
 * through all of them would obscure them; a load is synchronous, so the map is only ever the one in
-* flight. Without it every `assetGroup('icons')` marker resolved to `font:icons` — a slot that
+* flight. Without it every `glyphLibrary('icons')` marker resolved to `font:icons` — a slot that
 * accepts an ICON library, typed as a font.
 */
 let assetKinds = {};
@@ -149,7 +149,7 @@ function report(code, path, detail) {
 /**
 * The config-v2 kind an asset marker fronts, or `undefined` when it isn't one.
 *
-* v1 had two spellings for the same split-in-two model: `assetGroup` names a whole LIBRARY (its ref
+* v1 had two spellings for the same split-in-two model: `glyphLibrary` names a whole LIBRARY (its ref
 * IS the library), `asset` names one MEMBER of one (`fonts/yas`), and neither says which class it
 * holds — that lived on the group's `assetKind`. So both resolve through the same lookup, differing
 * only in where the library name sits in the ref.
@@ -161,10 +161,10 @@ function report(code, path, detail) {
 */
 function assetLibraryKind(value) {
 	if (!value.ref) return void 0;
-	if (value.__kind === "assetGroup") return assetKinds[value.ref] ?? REF_KIND.assetGroup;
+	if (value.__kind === "glyphLibrary") return assetKinds[value.ref] ?? REF_KIND.glyphLibrary;
 	if (value.__kind === "asset") {
 		const library = value.ref.slice(0, value.ref.indexOf("/"));
-		return assetKinds[library] ?? REF_KIND.assetGroup;
+		return assetKinds[library] ?? REF_KIND.glyphLibrary;
 	}
 }
 /**
@@ -868,10 +868,8 @@ function convert(studio, options) {
 			label: meta.label
 		});
 		else iconRecord[group] = Icon.group({
-			version: meta.version,
 			sizes: meta.sizes,
 			variants: meta.variants,
-			...meta.component ? { component: Component.ref(meta.component) } : {},
 			label: meta.label
 		});
 		const members = meta.members;

package/dist/migrations/20260921044042_icon_library_without_component.d.ts

@@ -0,0 +1,19 @@
+/**
+ * An icon library names its package and nothing about its renderers.
+ *
+ * Before, the group node carried `module` and `version` of its own and a `component` ref to the
+ * component a placed glyph rendered through. Now `package` is a ref to the `Package` item, which
+ * owns the module specifier (its path) and the pinned version, and no renderer is named: a
+ * component that draws glyphs points at the library through its own prop's domain
+ * (`Icon.ref('phosphor')`), so the edge runs from the component to the set.
+ *
+ * `up` moves `module`/`version` onto the package item (minted when the config has none) and drops
+ * `component`. Stored draft patches are `group-update` writes of whole metas, so `upPatch` reshapes
+ * their `data` the same way.
+ *
+ * Deletable once no stored artifact predates it.
+ */
+import type { RawWireConfig, SchemaMigration } from '../framework/schema-version';
+export declare const ICON_LIBRARY_WITHOUT_COMPONENT_VERSION = 20260921044042;
+export declare function iconLibrariesNamePackages(json: RawWireConfig): RawWireConfig;
+export declare const iconLibraryWithoutComponentMigration: SchemaMigration;

package/dist/migrations/20260921044042_icon_library_without_component.js

@@ -0,0 +1,86 @@
+import { isPlainObject } from "../framework/utils/field-path.js";
+import { z } from "zod";
+//#region src/migrations/20260921044042_icon_library_without_component.ts
+/**
+* An icon library names its package and nothing about its renderers.
+*
+* Before, the group node carried `module` and `version` of its own and a `component` ref to the
+* component a placed glyph rendered through. Now `package` is a ref to the `Package` item, which
+* owns the module specifier (its path) and the pinned version, and no renderer is named: a
+* component that draws glyphs points at the library through its own prop's domain
+* (`Icon.ref('phosphor')`), so the edge runs from the component to the set.
+*
+* `up` moves `module`/`version` onto the package item (minted when the config has none) and drops
+* `component`. Stored draft patches are `group-update` writes of whole metas, so `upPatch` reshapes
+* their `data` the same way.
+*
+* Deletable once no stored artifact predates it.
+*/
+const ICON_LIBRARY_WITHOUT_COMPONENT_VERSION = 20260921044042;
+/** An icon group's meta as stored before: module, version and component of its own. */
+const iconMetaBefore = z.looseObject({
+	module: z.string().optional(),
+	version: z.string().optional(),
+	component: z.unknown().optional()
+});
+/** An icon group's meta as stored now: the package it names, and no renderer. */
+const iconMetaAfter = z.looseObject({ package: z.object({ __ref: z.string() }).optional() }).refine((meta) => !("module" in meta) && !("version" in meta) && !("component" in meta), { message: "an icon library names its package; module, version and component are gone" });
+/** The envelope, loose but for the icon groups this migration touches. */
+const before = z.looseObject({ groups: z.looseObject({ icon: z.record(z.string(), iconMetaBefore).optional() }).optional() });
+const after = z.looseObject({ groups: z.looseObject({ icon: z.record(z.string(), iconMetaAfter).optional() }).optional() });
+/** One icon group's meta, reshaped; the package item the module needs, when the config lacks it. */
+function reshapeIconGroup(meta, packages) {
+	const { module, version, component: _component, ...kept } = meta;
+	if (typeof module !== "string") return kept;
+	const existing = packages[module];
+	if (!isPlainObject(existing)) packages[module] = typeof version === "string" ? { version } : {};
+	else if (typeof version === "string" && existing.version === void 0) packages[module] = {
+		...existing,
+		version
+	};
+	return {
+		...kept,
+		package: { __ref: `package:${module}` }
+	};
+}
+function iconLibrariesNamePackages(json) {
+	const groups = json.groups;
+	if (!isPlainObject(groups) || !isPlainObject(groups.icon)) return json;
+	if (!Object.values(groups.icon).some((meta) => isPlainObject(meta) && ("module" in meta || "version" in meta || "component" in meta))) return json;
+	const items = isPlainObject(json.items) ? json.items : {};
+	const packages = isPlainObject(items.package) ? { ...items.package } : {};
+	const icon = {};
+	for (const [path, meta] of Object.entries(groups.icon)) icon[path] = isPlainObject(meta) ? reshapeIconGroup(meta, packages) : meta;
+	return {
+		...json,
+		items: {
+			...items,
+			...Object.keys(packages).length ? { package: packages } : {}
+		},
+		groups: {
+			...groups,
+			icon
+		}
+	};
+}
+const iconLibraryWithoutComponentMigration = {
+	version: ICON_LIBRARY_WITHOUT_COMPONENT_VERSION,
+	up: iconLibrariesNamePackages,
+	upPatch(patch) {
+		const op = patch;
+		if (op.kind !== "icon" || op.operation !== "group-update" || !isPlainObject(op.data)) return patch;
+		const { module, version: _version, component: _component, ...kept } = op.data;
+		const data = typeof module === "string" ? {
+			...kept,
+			package: { __ref: `package:${module}` }
+		} : kept;
+		return {
+			...patch,
+			data
+		};
+	},
+	fromSchema: before,
+	toSchema: after
+};
+//#endregion
+export { ICON_LIBRARY_WITHOUT_COMPONENT_VERSION, iconLibraryWithoutComponentMigration };

package/dist/migrations/20260922013625_icon_libraries.d.ts

@@ -0,0 +1,18 @@
+/**
+ * An additive fence: one component draws the glyphs of several icon libraries. Three schema
+ * changes, none of which moves a stored byte.
+ *
+ * - A component's `variant` prop may bind a list of refs (`[icon:phosphor, icon:tabler]`), whose
+ *   leaves are unioned. A single ref and an enumerated list read as before.
+ * - An icon group gains an optional `variantAs`, how a `variant` reaches the glyph (`{ prop }` or
+ *   `{ export }`), and `metadata.format` admits `tabler`.
+ * - An icon member gains an optional `variants` list, the subset of the set's variants it ships.
+ *
+ * Identity, so a stamp below this version means "may lack these fields" and one at it means they
+ * are understood, which is what lets the pull gate keep an older client from stripping them.
+ *
+ * Deletable once no stored config artifact is below this version.
+ */
+import type { SchemaMigration } from '../framework/schema-version';
+export declare const ICON_LIBRARIES_VERSION = 20260922013625;
+export declare const iconLibrariesMigration: SchemaMigration;

package/dist/migrations/20260922013625_icon_libraries.js

@@ -0,0 +1,8 @@
+//#region src/migrations/20260922013625_icon_libraries.ts
+const ICON_LIBRARIES_VERSION = 20260922013625;
+const iconLibrariesMigration = {
+	version: ICON_LIBRARIES_VERSION,
+	up: (json) => json
+};
+//#endregion
+export { ICON_LIBRARIES_VERSION, iconLibrariesMigration };

package/dist/renderer/UdsRenderer.d.ts

@@ -1,6 +1,7 @@
+import { GlyphMembers } from "./glyphEntries.js";
 import { RegistryDescriptor } from "./wrapRegistry.js";
-import * as _$react_jsx_runtime0 from "react/jsx-runtime";
 import { ReactNode } from "react";
+import * as _$react_jsx_runtime0 from "react/jsx-runtime";
 import { ComponentRegistry, JSONUIProviderProps } from "@json-render/react";
 import { Spec } from "@json-render/core";
 
@@ -48,6 +49,11 @@ interface UdsRendererProps {
    * normalisation.
    */
   registryDescriptor?: RegistryDescriptor;
+  /**
+   * The icon libraries' members, by library and name, for the descriptor's glyph props to resolve
+   * through. The emitted bundle exports them beside its registry.
+   */
+  iconMembers?: GlyphMembers;
   /**
    * @deprecated Ignored here. The bundle's own renderer shell (`.uds/react-renderer.tsx`) takes
    * this prop and routes it to the system's `motion/react`; this package carries no motion.
@@ -80,6 +86,7 @@ declare function UdsRenderer({
   directives,
   fallback,
   registryDescriptor,
+  iconMembers,
   children
 }: UdsRendererProps): _$react_jsx_runtime0.JSX.Element;
 //#endregion

package/dist/renderer/UdsRenderer.js

@@ -1,7 +1,7 @@
 "use client";
 import { wrapRegistry } from "./wrapRegistry.js";
-import { jsx, jsxs } from "react/jsx-runtime";
 import { useMemo } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
 import { JSONUIProvider, Renderer } from "@json-render/react";
 //#region src/renderer/UdsRenderer.tsx
 /**
@@ -9,8 +9,12 @@ import { JSONUIProvider, Renderer } from "@json-render/react";
 * a `JSONUIProvider` + the standard wrapper stack on top of the
 * supplied registry.
 */
-function UdsRenderer({ spec, loading, registry, handlers, initialState, onStateChange, store, navigate, validationFunctions, functions, directives, fallback, registryDescriptor, children }) {
-	const wrapped = useMemo(() => wrapRegistry(registry, registryDescriptor), [registry, registryDescriptor]);
+function UdsRenderer({ spec, loading, registry, handlers, initialState, onStateChange, store, navigate, validationFunctions, functions, directives, fallback, registryDescriptor, iconMembers, children }) {
+	const wrapped = useMemo(() => wrapRegistry(registry, registryDescriptor, iconMembers), [
+		registry,
+		registryDescriptor,
+		iconMembers
+	]);
 	return /* @__PURE__ */ jsxs(JSONUIProvider, {
 		registry: wrapped,
 		handlers,

package/dist/renderer/glyphEntries.d.ts

@@ -0,0 +1,32 @@
+import { ComponentEntry } from "./componentEntry.js";
+import { IconLibrary } from "./icon-library.js";
+import { GlyphRenderProps } from "./glyphRenderable.js";
+import React from "react";
+
+//#region src/renderer/glyphEntries.d.ts
+/** Library name → member name → the member as a renderable. What resolves a stored glyph ref. */
+type GlyphMembers = ReadonlyMap<string, ReadonlyMap<string, React.ComponentType<GlyphRenderProps>>>;
+interface GlyphEntriesResult {
+  /** One ctx-shaped registry entry per placed glyph type (`icon:<library>/<Member>`). */
+  entries: Record<string, ComponentEntry>;
+  /** Each member as the glyph itself, by library and name: what a drawer's glyph prop receives. */
+  glyphMembers: GlyphMembers;
+  /** Each member the way a placed glyph paints, through the set's drawer when the registry holds
+   *  one: what a browsing surface shows for it. */
+  drawnMembers: GlyphMembers;
+}
+/**
+ * The registry entries an icon library contributes: every member the set ships, keyed by the type a
+ * placed glyph node carries, and the same renderables by library and name for a prop that holds a
+ * glyph ref to resolve through. `components` holds the registry's raw components by key, where a
+ * library's drawing component is looked up.
+ */
+declare function glyphRegistryEntries({
+  libraries,
+  components
+}: {
+  libraries: Iterable<IconLibrary>;
+  components?: Readonly<Record<string, React.ComponentType<Record<string, unknown>> | undefined>>;
+}): GlyphEntriesResult;
+//#endregion
+export { GlyphEntriesResult, GlyphMembers, glyphRegistryEntries };

package/dist/renderer/glyphEntries.js

@@ -0,0 +1,48 @@
+import { makeComponentEntry } from "./componentEntry.js";
+import { makeGlyphRenderable } from "./glyphRenderable.js";
+//#region src/renderer/glyphEntries.ts
+/**
+* The registry entries an icon library contributes: every member the set ships, keyed by the type a
+* placed glyph node carries, and the same renderables by library and name for a prop that holds a
+* glyph ref to resolve through. `components` holds the registry's raw components by key, where a
+* library's drawing component is looked up.
+*/
+function glyphRegistryEntries({ libraries, components = {} }) {
+	const entries = {};
+	const glyphMembers = /* @__PURE__ */ new Map();
+	const drawnMembers = /* @__PURE__ */ new Map();
+	for (const group of libraries) {
+		const members = group.members;
+		if (!members) continue;
+		const Drawer = group.component ? components[group.component] : void 0;
+		const bySlug = /* @__PURE__ */ new Map();
+		const drawnBySlug = /* @__PURE__ */ new Map();
+		for (const name of group.glyphNames) {
+			const member = members[name];
+			if (member === void 0) continue;
+			const drawn = makeGlyphRenderable({
+				member,
+				library: group,
+				Drawer
+			});
+			entries[group.glyphType(name)] = makeComponentEntry({
+				component: drawn,
+				name: group.glyphType(name)
+			});
+			bySlug.set(name, makeGlyphRenderable({
+				member,
+				library: group
+			}));
+			drawnBySlug.set(name, drawn);
+		}
+		glyphMembers.set(group.name, bySlug);
+		drawnMembers.set(group.name, drawnBySlug);
+	}
+	return {
+		entries,
+		glyphMembers,
+		drawnMembers
+	};
+}
+//#endregion
+export { glyphRegistryEntries };

package/dist/renderer/glyphRenderable.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+
+//#region src/renderer/glyphRenderable.d.ts
+/** What a placed glyph node carries: the set's own axes. */
+type GlyphRenderProps = {
+  variant?: string;
+  size?: string | number;
+};
+//#endregion
+export { GlyphRenderProps };

package/dist/renderer/glyphRenderable.js

@@ -0,0 +1,40 @@
+import { resolveGlyph } from "./resolveGlyph.js";
+import { jsx } from "react/jsx-runtime";
+//#region src/renderer/glyphRenderable.tsx
+/**
+* A library member as a registry renderable.
+*
+* Through the set's drawing component when the registry has one: the member lands on the
+* component's glyph prop and `size`/`variant` stay the component's own props, so a placed glyph
+* paints exactly as the component would. Otherwise the member draws itself through `resolveGlyph`,
+* which turns the set's `sizes` and `variantAs` into the props the glyph takes.
+*/
+function makeGlyphRenderable({ member, library, Drawer }) {
+	const Member = member;
+	const { members, sizes, variantAs, glyphProp } = library;
+	if (Drawer && glyphProp) return function DrawnGlyph(props) {
+		return /* @__PURE__ */ jsx(Drawer, {
+			...props,
+			[glyphProp]: Member
+		});
+	};
+	const facts = {
+		glyphs: members ?? {},
+		sizes,
+		variantAs
+	};
+	return function RawGlyph({ size, variant, ...props }) {
+		const { Glyph, props: glyphProps } = resolveGlyph({
+			library: facts,
+			glyph: Member,
+			size,
+			variant
+		});
+		return /* @__PURE__ */ jsx(Glyph, {
+			...props,
+			...glyphProps
+		});
+	};
+}
+//#endregion
+export { makeGlyphRenderable };