@yahoo/uds-create-config 4.28.3 → 4.29.0

package/dist/configs/CanvasConfig.d.ts

@@ -1631,7 +1631,9 @@ declare const Node: EntityClass<z.ZodObject<{
     }: {
       input: GlyphNamespace;
       body: Readonly<Record<string, unknown>>;
-    }) => void;
+    }) => {
+      items: Record<string, unknown>;
+    };
   }>, EntityClass<z.ZodObject<{
     version: z.ZodOptional<z.ZodString>;
     exports: z.ZodOptional<SubEntityClass<z.ZodObject<{}, z.core.$strict>>>;
@@ -3195,7 +3197,9 @@ declare const CanvasConfig: ConfigClass<{
       }: {
         input: GlyphNamespace;
         body: Readonly<Record<string, unknown>>;
-      }) => void;
+      }) => {
+        items: Record<string, unknown>;
+      };
     }>, EntityClass<z.ZodObject<{
       version: z.ZodOptional<z.ZodString>;
       exports: z.ZodOptional<SubEntityClass<z.ZodObject<{}, z.core.$strict>>>;
@@ -5024,7 +5028,9 @@ declare function createCanvasConfig(system: AnySystemConfig): ConfigInstance<{
       }: {
         input: GlyphNamespace;
         body: Readonly<Record<string, unknown>>;
-      }) => void;
+      }) => {
+        items: Record<string, unknown>;
+      };
     }>, EntityClass<z.ZodObject<{
       version: z.ZodOptional<z.ZodString>;
       exports: z.ZodOptional<SubEntityClass<z.ZodObject<{}, z.core.$strict>>>;

package/dist/configs/react-native-system.d.ts

@@ -1781,7 +1781,9 @@ declare const ReactNativeSystem: ConfigClass<{
     }: {
       input: GlyphNamespace;
       body: Readonly<Record<string, unknown>>;
-    }) => void;
+    }) => {
+      items: Record<string, unknown>;
+    };
   }>;
   packages: EntityClass<_$zod.ZodObject<{
     version: _$zod.ZodOptional<_$zod.ZodString>;
@@ -3988,7 +3990,9 @@ declare const ReactNativeSystem: ConfigClass<{
       }: {
         input: GlyphNamespace;
         body: Readonly<Record<string, unknown>>;
-      }) => void;
+      }) => {
+        items: Record<string, unknown>;
+      };
     }>;
     packages: EntityClass<_$zod.ZodObject<{
       version: _$zod.ZodOptional<_$zod.ZodString>;

package/dist/configs/react-native-system.js

@@ -1,6 +1,6 @@
 import { Font } from "../entities/system/Font.js";
-import { Composite } from "../entities/system/Composite.js";
 import { Package } from "../entities/system/Package.js";
+import { Composite } from "../entities/system/Composite.js";
 import { File } from "../entities/system/File.js";
 import { Component } from "../entities/system/Component.js";
 import { Icon } from "../entities/system/Icon.js";

package/dist/configs/system.d.ts

@@ -1634,7 +1634,9 @@ declare const System: ConfigClass<{
     }: {
       input: GlyphNamespace;
       body: Readonly<Record<string, unknown>>;
-    }) => void;
+    }) => {
+      items: Record<string, unknown>;
+    };
   }>;
   packages: EntityClass<_$zod.ZodObject<{
     version: _$zod.ZodOptional<_$zod.ZodString>;
@@ -3716,7 +3718,9 @@ declare const System: ConfigClass<{
       }: {
         input: GlyphNamespace;
         body: Readonly<Record<string, unknown>>;
-      }) => void;
+      }) => {
+        items: Record<string, unknown>;
+      };
     }>;
     packages: EntityClass<_$zod.ZodObject<{
       version: _$zod.ZodOptional<_$zod.ZodString>;

package/dist/configs/system.js

@@ -1,9 +1,9 @@
 import { Font } from "../entities/system/Font.js";
+import { Package } from "../entities/system/Package.js";
 import { Composite } from "../entities/system/Composite.js";
 import { Modifier } from "../entities/system/Modifier.js";
 import { Settings } from "../entities/system/Settings.js";
 import { StyleProperty } from "../entities/system/StyleProperty.js";
-import { Package } from "../entities/system/Package.js";
 import { File } from "../entities/system/File.js";
 import { Token } from "../entities/system/Token.js";
 import { Component } from "../entities/system/Component.js";

package/dist/entities/system/CanvasRole.js

@@ -1,4 +1,5 @@
 import { defineEntity } from "../../framework/defineEntity.js";
+import { iconDomainInvariants } from "./icon-domain-invariants.js";
 import { Component } from "./Component.js";
 import { z } from "zod";
 //#region src/entities/system/CanvasRole.ts
@@ -40,7 +41,8 @@ const CanvasRole = defineEntity({
 			axes: z.array(z.string()).optional().describe("The props the picker offers as axes (`variant`, `size`), each with the values the prop itself declares.")
 		}).optional().describe("What the tool exposes of the component. Read by the `icon` role: the picker draws every glyph through this component and offers the named props as its axes.")
 	})).describe(`The components a canvas insert tool draws with. The entity's path is the tool: one of ${CANVAS_ROLES.map((role) => `\`${role}\``).join(", ")}. A role with no entity registered has its tool disabled.`) }),
-	schemas: { create: { description: `Register a canvas insert tool for this system. \`path\` is the role, one of ${CANVAS_ROLES.map((role) => `\`${role}\``).join(", ")}; \`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.` } }
+	schemas: { create: { description: `Register a canvas insert tool for this system. \`path\` is the role, one of ${CANVAS_ROLES.map((role) => `\`${role}\``).join(", ")}; \`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.` } },
+	invariants: (config) => iconDomainInvariants(config)
 });
 //#endregion
 export { CANVAS_ROLES, CanvasRole };

package/dist/entities/system/Component.js

@@ -8,6 +8,7 @@ import { derivedColor, gradient } from "./color.js";
 import { childrenPolicy, forwardedPropName } from "./element.js";
 import { listedIn } from "../../framework/utils/enumerated.js";
 import { valueSchemaOf } from "../../framework/value-domain.js";
+import { Package } from "./Package.js";
 import { bindPreviewGlyphs, 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";
@@ -17,7 +18,6 @@ import { slotAnatomyPropOf, slotTargetsOf, withoutTruthyTerm } from "../../frame
 import { listSlots, namedSlots, slotHostedBy, slotOf } from "../../spec/slot.js";
 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 { rootLayerInvariants } from "./root-layer-invariants.js";
@@ -505,7 +505,7 @@ function propSchemaFor(config, owner) {
 			code: "custom",
 			input: decl,
 			path: ["accepts"],
-			message: routed ? `\`accepts\` says what may FILL a content hole — an icon set, so any glyph it registers can be dropped in (\`Button.startIcon\` accepts \`Icon.ref('phosphor')\`), or a component. \`${layer}/${prop}\` is a ${routed.type} prop, so it takes a value rather than content. Remove \`accepts\`, or point \`target\` at a prop declared \`{ type: 'slot' }\`.` : `\`accepts\` says what may FILL a content hole — an icon set, or a component. The \`${layer}\` layer is a plain tag, and \`children\` is the only prop a tag carries content through — so either target \`${layer}/children\`, or remove \`accepts\`.`
+			message: routed ? `\`accepts\` says what may FILL a content hole — an icon set, so any glyph it registers can be dropped in (\`EmptyState.icon\` accepts \`Icon.ref('phosphor')\`), or a component. \`${layer}/${prop}\` is a ${routed.type} prop, so it takes a value rather than content. Remove \`accepts\`, or point \`target\` at a prop declared \`{ type: 'slot' }\`.` : `\`accepts\` says what may FILL a content hole — an icon set, or a component. The \`${layer}\` layer is a plain tag, and \`children\` is the only prop a tag carries content through — so either target \`${layer}/children\`, or remove \`accepts\`.`
 		});
 	});
 }

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

@@ -82,11 +82,13 @@ declare const Icon: EntityClass<z.ZodObject<{
   }: 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.
+   * The package's module namespace. The set's members are its glyph exports, named by the rule
+   * the metadata format declares (`glyphExportRule`), so an alias pair is one member and the
+   * package's infrastructure exports are none; `items` lays facts over members that exist, and a
+   * key naming no member is refused so a typo cannot invent a glyph. Each member's identity is
+   * recorded by reference, so an authored glyph (`name={StarIcon}`) is matched to its member by
+   * the object rather than by anything the component says about itself, and an alias resolves to
+   * the member it is. Read once while the config file is evaluated and never stored.
    */
   readonly glyphs: ({
     input,
@@ -94,7 +96,9 @@ declare const Icon: EntityClass<z.ZodObject<{
   }: {
     input: GlyphNamespace;
     body: Readonly<Record<string, unknown>>;
-  }) => void;
+  }) => {
+    items: Record<string, unknown>;
+  };
 }>;
 //#endregion
 export { Icon, IconVariantAs, iconVariantAs };

package/dist/entities/system/Icon.js

@@ -1,9 +1,10 @@
 import { isRef, pathOf } from "../../framework/utils/refs.js";
 import { defineEntity } from "../../framework/defineEntity.js";
-import { glyphOfLibrary, libraryGlyphFacts, recordGlyphIdentities } from "./glyph-identity.js";
+import { spellValues } from "../../framework/value-domain.js";
 import { Package } from "./Package.js";
+import { iconMemberMetadata, iconMetadataDeclaration, iconMetadataFormat } from "./icon-metadata.js";
+import { glyphMembersOf, glyphOfLibrary, libraryGlyphFacts, recordGlyphIdentities } from "./glyph-identity.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
 /**
@@ -74,19 +75,30 @@ const Icon = defineEntity({
 	},
 	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.
+	* The package's module namespace. The set's members are its glyph exports, named by the rule
+	* the metadata format declares (`glyphExportRule`), so an alias pair is one member and the
+	* package's infrastructure exports are none; `items` lays facts over members that exist, and a
+	* key naming no member is refused so a typo cannot invent a glyph. Each member's identity is
+	* recorded by reference, so an authored glyph (`name={StarIcon}`) is matched to its member by
+	* the object rather than by anything the component says about itself, and an alias resolves to
+	* the member it is. Read once while the config file is evaluated and never stored.
 	*/
 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.");
+		const format = iconMetadataFormat.safeParse(body.metadata?.format);
+		const members = glyphMembersOf({
+			namespace: input,
+			format: format.success ? format.data : void 0
+		});
+		const overlay = body.items ?? {};
+		const unknown = Object.keys(overlay).filter((name) => !members.includes(name));
+		if (unknown.length > 0) throw new Error(`Icon.group: \`items\` names ${spellValues(unknown)}, which ${unknown.length === 1 ? "is not a glyph export" : "are not glyph exports"} of \`glyphs\`${members.length === 0 ? " (the namespace has no glyph components; the package may not be installed)" : ""}. \`items\` lays facts over the members the package exports; it cannot add one.`);
 		recordGlyphIdentities({
 			namespace: input,
-			names: Object.keys(body.items ?? {}),
+			names: members,
 			specifier: pathOf(body.package)
 		});
+		return { items: Object.fromEntries(members.map((name) => [name, overlay[name] ?? {}])) };
 	} },
 	/**
 	* A value bound to a library may be the glyph component itself, or the `package:` export ref the

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

@@ -87,7 +87,7 @@ interface SlotDecl {
   /**
    * What may FILL this hole, as refs. Two shapes, both in this repo:
    *
-   *   - an icon LIBRARY — `Button.startIcon` accepts `Icon.ref('phosphor')`, so any glyph that library
+   *   - an icon LIBRARY — `EmptyState.icon` accepts `Icon.ref('phosphor')`, so any glyph that library
    *     registers can be dropped in
    *   - a COMPONENT — `PanelSegment` accepts `Component.ref('studio/PanelSegment/PanelSegmentCell')`
    *

package/dist/entities/system/glyph-identity.js

@@ -1,5 +1,6 @@
 import { isRef, kindOf, memberOf, pathOf } from "../../framework/utils/refs.js";
 import { spellValues } from "../../framework/value-domain.js";
+import { glyphExportRule } from "./icon-metadata.js";
 import { memberLeaves } from "../../framework/projections.js";
 import { z } from "zod";
 //#region src/entities/system/glyph-identity.ts
@@ -19,6 +20,29 @@ function isComponentType(value) {
 	return typeof value === "object" && value !== null && "$$typeof" in value && !("props" in value);
 }
 /**
+* The members a package namespace stands for: its component exports that the format's rule calls
+* glyphs, each under the name the rule makes canonical, in export order with an alias pair
+* collapsed to one member. A canonical spelling the namespace does not export as a component keeps
+* the export's own name, so a rule reading a `displayName` the package left out still names a
+* member the module has.
+*/
+function glyphMembersOf({ namespace, format }) {
+	const rule = glyphExportRule(format);
+	const members = /* @__PURE__ */ new Set();
+	for (const [name, value] of Object.entries(namespace)) {
+		if (!isComponentType(value) || !rule.isGlyph({
+			name,
+			value
+		})) continue;
+		const canonical = rule.canonical({
+			name,
+			value
+		});
+		members.add(isComponentType(namespace[canonical]) ? canonical : name);
+	}
+	return [...members];
+}
+/**
 * Record which export each of `names` is in `namespace`, for the components among them.
 *
 * Only the listed names are recorded, so an alias the package also exports (Phosphor's deprecated
@@ -195,4 +219,4 @@ function bindPreviewGlyphs({ config, props }) {
 	return bind(props);
 }
 //#endregion
-export { bindPreviewGlyphs, glyphIdentityOf, glyphLeafOf, glyphOfLibrary, glyphPackageRef, glyphPackageRefOf, isComponentType, libraryGlyphFacts, recordGlyphIdentities };
+export { bindPreviewGlyphs, glyphIdentityOf, glyphLeafOf, glyphMembersOf, glyphOfLibrary, glyphPackageRef, glyphPackageRefOf, isComponentType, libraryGlyphFacts, recordGlyphIdentities };

package/dist/entities/system/icon-domain-invariants.d.ts

@@ -1,11 +1,12 @@
 import type { Config } from '../../framework/Config';
 /**
- * A prop whose domain is a list of icon-library refs resolves a value by leaf alone, so one leaf
- * held by two of its libraries would draw whichever the host looked up first. This refuses that
- * state, naming the component, the prop and both libraries.
+ * The rules that hold between icon libraries and the components that draw them: a leaf two bound
+ * libraries both ship ({@link collisions}), a glyph nothing bound ({@link unboundGlyphs}), and a
+ * member's baked style the drawer's `variant` prop does not declare ({@link bakedVariants}).
  *
- * Declared from both `Component` and `Icon`, since `assertInvariants` runs only the patched kind's
- * rules: a component binding two libraries is a component write, and a glyph added to one of them
- * later is an icon write, and either can create the collision.
+ * Declared from `Component`, `Icon` and `CanvasRole`, since `assertInvariants` runs only the patched
+ * kind's rules: a component binding two libraries is a component write, a glyph added to one of them
+ * later or a style baked onto a member is an icon write, and a role entry choosing another drawer is
+ * a canvas-role write, and any of them can create one of these states.
  */
 export declare function iconDomainInvariants(config: Config): string[];

package/dist/entities/system/icon-domain-invariants.js

@@ -1,21 +1,62 @@
 import { isRef, kindOf, memberOf, pathOf } from "../../framework/utils/refs.js";
+import { spellValues } from "../../framework/value-domain.js";
 import { collectBag, isPlainRecord } from "./style-bag.js";
 import { createSliceMemo } from "../../framework/memo.js";
-import { glyphLibrariesOf, memberLeaves, refListOf } from "../../framework/projections.js";
+import { glyphComponentOf, glyphLibrariesOf, memberLeaves, propValueDomain, refListOf, resolveComponentProps } from "../../framework/projections.js";
 //#region src/entities/system/icon-domain-invariants.ts
 /**
-* A prop whose domain is a list of icon-library refs resolves a value by leaf alone, so one leaf
-* held by two of its libraries would draw whichever the host looked up first. This refuses that
-* state, naming the component, the prop and both libraries.
+* The rules that hold between icon libraries and the components that draw them: a leaf two bound
+* libraries both ship ({@link collisions}), a glyph nothing bound ({@link unboundGlyphs}), and a
+* member's baked style the drawer's `variant` prop does not declare ({@link bakedVariants}).
 *
-* Declared from both `Component` and `Icon`, since `assertInvariants` runs only the patched kind's
-* rules: a component binding two libraries is a component write, and a glyph added to one of them
-* later is an icon write, and either can create the collision.
+* Declared from `Component`, `Icon` and `CanvasRole`, since `assertInvariants` runs only the patched
+* kind's rules: a component binding two libraries is a component write, a glyph added to one of them
+* later or a style baked onto a member is an icon write, and a role entry choosing another drawer is
+* a canvas-role write, and any of them can create one of these states.
 */
 function iconDomainInvariants(config) {
-	return [...collisions(config), ...unboundGlyphs(config)];
+	return [
+		...collisions(config),
+		...unboundGlyphs(config),
+		...bakedVariants(config)
+	];
 }
 /**
+* A member that bakes `variants` names the styles it draws in its package's words, and the drawer
+* that places it may declare a `variant` prop of its own. When it does, every baked word has to be
+* one the prop declares, else the panel would narrow to a style the drawer cannot draw. A drawer
+* with no `variant` prop (a set whose styles are separate exports) is never checked, since the
+* member is the style. The bake writes each member through an ordinary icon update, so the rule
+* runs on the build with no wiring of its own.
+*/
+const bakedVariants = createSliceMemo({
+	kinds: [
+		"component",
+		"icon",
+		"canvas-role"
+	],
+	compute: (config) => {
+		const problems = [];
+		for (const group of config.groups("icon")) {
+			const drawer = glyphComponentOf(config, group.path);
+			if (!drawer) continue;
+			const declaration = resolveComponentProps(config, drawer.path).variant;
+			if (declaration?.type !== "variant") continue;
+			const declared = propValueDomain(config, declaration)?.leaves ?? [];
+			const allowed = new Set(declared);
+			for (const member of config.members("icon", group.path)) {
+				const baked = member.body.variants;
+				if (!Array.isArray(baked)) continue;
+				for (const value of baked) {
+					if (typeof value !== "string" || allowed.has(value)) continue;
+					problems.push(`Icon library "${group.path}" member "${member.leaf}" bakes the variant "${value}", which the drawer "${drawer.path}" does not declare on its \`variant\` prop (${declared.length === 0 ? "it declares no values" : spellValues(declared)}); a set's styles have to be words its drawer draws.`);
+				}
+			}
+		}
+		return problems;
+	}
+});
+/**
 * A glyph authored as its component leaves the open-bag pass as a `package:` export ref, and the
 * owner-bound pass binds that to the member when the key's domain is a library drawing from that
 * module. One left in a bag is a glyph nothing bound, and this refuses it by what went wrong: no

package/dist/entities/system/icon-library.d.ts

@@ -94,8 +94,9 @@ declare function resolveIconLibraries({
  * {@link glyphComponentOf}.
  */
 /**
- * The libraries the canvas's icon tool offers: those its component's glyph prop is bound to. Empty
- * when the `icon` canvas role is unregistered, which is also when the tool is disabled.
+ * The libraries the canvas's icon tool offers: the union of every entry's glyph domain, in entry
+ * and then declaration order, each library once. Empty when the `icon` canvas role is unregistered,
+ * which is also when the tool is disabled.
  */
 declare function iconToolLibraries(config: Config | null | undefined): IconLibrary[];
 declare function librariesBoundBy({

package/dist/entities/system/icon-library.js

@@ -1,5 +1,5 @@
 import { createSliceMemo } from "../../framework/memo.js";
-import { glyphComponentOf, glyphLibrariesOf, iconToolOf, resolveComponentProps } from "../../framework/projections.js";
+import { glyphComponentOf, glyphLibrariesOf, iconToolFor, iconToolsOf, resolveComponentProps } from "../../framework/projections.js";
 import { isValueSlot } from "../../framework/prop-surface.js";
 import { Component } from "./Component.js";
 import { parseGlyphType } from "../../spec/glyph-jsx.js";
@@ -162,8 +162,7 @@ function placedGlyphElement(config, glyph, props = {}) {
 		type: glyph,
 		props
 	};
-	const tool = iconToolOf(config);
-	const defaults = tool && tool.component === bound.path ? tool.defaultProps : {};
+	const defaults = iconToolFor(config, parsed.slug)?.defaultProps ?? {};
 	return {
 		type: `component:${bound.path}`,
 		props: {
@@ -207,15 +206,15 @@ function resolveIconLibraries({ config, hints }) {
 * {@link glyphComponentOf}.
 */
 /**
-* The libraries the canvas's icon tool offers: those its component's glyph prop is bound to. Empty
-* when the `icon` canvas role is unregistered, which is also when the tool is disabled.
+* The libraries the canvas's icon tool offers: the union of every entry's glyph domain, in entry
+* and then declaration order, each library once. Empty when the `icon` canvas role is unregistered,
+* which is also when the tool is disabled.
 */
 function iconToolLibraries(config) {
 	if (!config) return NO_LIBRARIES;
-	const tool = iconToolOf(config);
-	if (!tool) return NO_LIBRARIES;
-	const declaration = resolveComponentProps(config, tool.component)[tool.glyph];
-	return glyphLibrariesOf(declaration?.value).map((path) => iconLibrary(config, path)).filter((library) => library !== void 0);
+	const paths = /* @__PURE__ */ new Set();
+	for (const tool of iconToolsOf(config)) for (const path of tool.libraries) paths.add(path);
+	return [...paths].map((path) => iconLibrary(config, path)).filter((library) => library !== void 0);
 }
 function librariesBoundBy({ config, component }) {
 	if (!config) return NO_LIBRARIES;

package/dist/entities/system/icon-metadata.d.ts

@@ -54,6 +54,30 @@ declare const iconMetadataDeclaration: z.ZodObject<{
 type IconMetadataDeclaration = z.infer<typeof iconMetadataDeclaration>;
 /** A format adapter: raw source data in, per-member metadata out. Throws on a shape it can't read. */
 type IconMetadataAdapter = (raw: unknown) => Record<string, IconMemberMetadata>;
+/**
+ * Which of a package's component exports are glyphs, and which name of an alias pair is the member.
+ * A format's rule, beside its adapter, because the package the adapter describes is the one that
+ * decides both: Phosphor exports every glyph as `XIcon` beside a deprecated bare `X`, and Tabler
+ * exports 66 of its glyphs under two `Icon*` names. `Icon.group({ glyphs })` runs the rule over the
+ * namespace's component exports to name the set's members, so the caller has already dropped
+ * anything that is not a component.
+ */
+interface GlyphExportRule {
+  /** Whether a component export of this name is a glyph rather than infrastructure (`IconBase`). */
+  readonly isGlyph: (args: {
+    name: string;
+    value: unknown;
+  }) => boolean;
+  /** The member name an export stands for: itself, or the spelling the alias pair collapses to. */
+  readonly canonical: (args: {
+    name: string;
+    value: unknown;
+  }) => string;
+}
+/** The glyph export rule a set's metadata format declares; a set with no format keeps every
+ *  component export under its own name. */
+declare function glyphExportRule(format: IconMetadataFormat | undefined): GlyphExportRule;
+declare function iconMetadataSourceFile(format: IconMetadataFormat): string | undefined;
 /**
  * The uds format IS this file schema — `{ [memberName]: { categories?, tags?, codepoint?,
  * variants?, knockoutVariants? } }` —
@@ -72,7 +96,15 @@ type IconMetadataFile = z.infer<typeof iconMetadataFile>;
 declare function iconMetadataFileJsonSchema(): Record<string, unknown>;
 /** `brand-4chan` → `IconBrand4chan`: the react package's export for a slug. */
 declare function tablerExportName(slug: string): string;
+/** `IconStar` plus `filled` → `IconStarFilled`: the export a non-outline style is drawn by. */
+declare function tablerStyledExportName({
+  base,
+  style
+}: {
+  base: string;
+  style: string;
+}): string;
 /** Run the named format's adapter. The host resolved and read `raw`; this stays pure. */
 declare function iconMetadata(format: IconMetadataFormat, raw: unknown): Record<string, IconMemberMetadata>;
 //#endregion
-export { ICON_METADATA_FORMATS, IconMemberMetadata, IconMetadataAdapter, IconMetadataDeclaration, IconMetadataFile, IconMetadataFormat, iconMemberMetadata, iconMetadata, iconMetadataDeclaration, iconMetadataFile, iconMetadataFileJsonSchema, iconMetadataFormat, tablerExportName };
+export { GlyphExportRule, ICON_METADATA_FORMATS, IconMemberMetadata, IconMetadataAdapter, IconMetadataDeclaration, IconMetadataFile, IconMetadataFormat, glyphExportRule, iconMemberMetadata, iconMetadata, iconMetadataDeclaration, iconMetadataFile, iconMetadataFileJsonSchema, iconMetadataFormat, iconMetadataSourceFile, tablerExportName, tablerStyledExportName };

package/dist/entities/system/icon-metadata.js

@@ -52,6 +52,40 @@ const iconMetadataDeclaration = z.strictObject({
 	from: Package,
 	format: iconMetadataFormat
 });
+/** Every component export is a glyph under its own name: the rule for `uds` and for a set that
+*  declares no metadata format. */
+const everyComponentExport = {
+	isGlyph: () => true,
+	canonical: ({ name }) => name
+};
+const GLYPH_EXPORT_RULES = {
+	phosphor: {
+		isGlyph: ({ name }) => name.endsWith("Icon"),
+		canonical: ({ name }) => name.endsWith("Icon") ? name : `${name}Icon`
+	},
+	uds: everyComponentExport,
+	tabler: {
+		isGlyph: ({ name }) => name.startsWith("Icon"),
+		canonical: ({ name, value }) => {
+			const displayName = value?.displayName;
+			return typeof displayName === "string" && displayName.length > 0 ? `Icon${displayName}` : name;
+		}
+	}
+};
+/** The glyph export rule a set's metadata format declares; a set with no format keeps every
+*  component export under its own name. */
+function glyphExportRule(format) {
+	return format === void 0 ? everyComponentExport : GLYPH_EXPORT_RULES[format];
+}
+/**
+* The file inside the source package a format's catalogue is, for a package whose manifest names no
+* entry: `@tabler/icons` exports only `./icons/*` and ships `icons.json` at its root. A format
+* without one reads the package's own entry.
+*/
+const SOURCE_FILES = { tabler: "icons.json" };
+function iconMetadataSourceFile(format) {
+	return SOURCE_FILES[format];
+}
 /**
 * The uds format IS this file schema — `{ [memberName]: { categories?, tags?, codepoint?,
 * variants?, knockoutVariants? } }` —
@@ -107,33 +141,58 @@ const uds = (raw) => {
 };
 /**
 * Tabler's catalogue: `@tabler/icons` ships `icons.json`, a record keyed by kebab slug. Each entry
-* carries a singular `category`, `tags` that mix strings and numbers, and a `styles` record whose
-* keys are the variants the glyph draws (`outline` always, `filled` for a subset). Loose for the
+* carries a singular `category`, `tags` that mix strings, numbers and the odd `null` (the four
+* `*-number-0` entries spell one tag as `null`), and a `styles` record whose keys are the styles the
+* glyph draws (`outline` always, `filled` for a subset), each with its own codepoint. Loose for the
 * same reason as Phosphor's.
 */
 const tablerCatalog = z.record(z.string().min(1), z.looseObject({
 	name: z.string().min(1),
 	category: z.string().optional(),
-	tags: z.array(z.union([z.string(), z.number()])).optional(),
+	tags: z.array(z.union([
+		z.string(),
+		z.number(),
+		z.null()
+	])).optional(),
 	styles: z.record(z.string().min(1), z.looseObject({ unicode: z.string().optional() }))
 }));
 /** `brand-4chan` → `IconBrand4chan`: the react package's export for a slug. */
 function tablerExportName(slug) {
 	return `Icon${slug.split("-").map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1)).join("")}`;
 }
+/** `IconStar` plus `filled` → `IconStarFilled`: the export a non-outline style is drawn by. */
+function tablerStyledExportName({ base, style }) {
+	if (style === "outline") return base;
+	return `${base}${style.charAt(0).toUpperCase()}${style.slice(1)}`;
+}
+/** A style's codepoint from its hex `unicode`. Whole-string hex only: `parseInt` would read `ea1z`
+*  as `ea1` and store a wrong glyph. */
+function tablerCodepoint(unicode) {
+	if (unicode === void 0 || !/^[0-9a-fA-F]+$/.test(unicode)) return;
+	return Number.parseInt(unicode, 16);
+}
 const tabler = (raw) => {
 	const parsed = tablerCatalog.safeParse(raw);
 	if (!parsed.success) throw new Error(`tabler metadata source did not match @tabler/icons' icons.json shape — ${describeIssues(parsed.error)}`);
 	const members = {};
 	for (const [slug, entry] of Object.entries(parsed.data)) {
-		const outline = entry.styles.outline?.unicode;
-		const codepoint = outline !== void 0 && /^[0-9a-fA-F]+$/.test(outline) ? Number.parseInt(outline, 16) : void 0;
-		members[tablerExportName(slug)] = {
+		const base = tablerExportName(slug);
+		const tags = (entry.tags ?? []).filter((tag) => tag !== null).map(String);
+		const shared = {
 			...entry.category ? { categories: [entry.category] } : {},
-			...entry.tags && entry.tags.length > 0 ? { tags: entry.tags.map(String) } : {},
-			...codepoint !== void 0 ? { codepoint } : {},
-			variants: Object.keys(entry.styles)
+			...tags.length > 0 ? { tags } : {}
 		};
+		for (const [style, styled] of Object.entries(entry.styles)) {
+			const codepoint = tablerCodepoint(styled.unicode);
+			members[tablerStyledExportName({
+				base,
+				style
+			})] = {
+				...shared,
+				...codepoint !== void 0 ? { codepoint } : {},
+				variants: [style]
+			};
+		}
 	}
 	return members;
 };
@@ -148,4 +207,4 @@ function iconMetadata(format, raw) {
 	return ADAPTERS[format](raw);
 }
 //#endregion
-export { ICON_METADATA_FORMATS, iconMemberMetadata, iconMetadata, iconMetadataDeclaration, iconMetadataFile, iconMetadataFileJsonSchema, iconMetadataFormat, tablerExportName };
+export { ICON_METADATA_FORMATS, glyphExportRule, iconMemberMetadata, iconMetadata, iconMetadataDeclaration, iconMetadataFile, iconMetadataFileJsonSchema, iconMetadataFormat, iconMetadataSourceFile, tablerExportName, tablerStyledExportName };

package/dist/entities/system/runtime-modules.d.ts

@@ -11,6 +11,9 @@ interface DeclaredRuntimeModule {
   readonly exports?: readonly string[];
   /** This module also supplies the members of an icon library. */
   readonly iconLibrary?: true;
+  /** This module is an icon library's metadata catalogue, read by the build and imported by
+   *  nothing a rendered spec reaches. */
+  readonly catalogue?: true;
 }
 /**
  * The npm modules this config itself declares at runtime.

package/dist/entities/system/runtime-modules.js

@@ -23,14 +23,24 @@ function declaredRuntimeModules(config) {
 	for (const group of Icon.groups(config)) {
 		const named = group.meta.package;
 		const specifier = isRef(named) ? pathOf(named) : void 0;
-		if (specifier === void 0) continue;
-		const existing = bySpecifier.get(specifier);
-		bySpecifier.set(specifier, {
-			specifier,
-			...existing?.version ? { version: existing.version } : {},
-			...existing?.exports ? { exports: existing.exports } : {},
-			iconLibrary: true
-		});
+		if (specifier !== void 0) {
+			const existing = bySpecifier.get(specifier);
+			bySpecifier.set(specifier, {
+				...existing,
+				specifier,
+				iconLibrary: true
+			});
+		}
+		const source = group.meta.metadata?.from;
+		const catalogue = isRef(source) ? pathOf(source) : void 0;
+		if (catalogue !== void 0) {
+			const existing = bySpecifier.get(catalogue);
+			bySpecifier.set(catalogue, {
+				...existing,
+				specifier: catalogue,
+				catalogue: true
+			});
+		}
 	}
 	return [...bySpecifier.values()].sort((left, right) => left.specifier.localeCompare(right.specifier));
 }