@yahoo/uds-create-config 4.10.2 → 4.10.4

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

@@ -1,5 +1,5 @@
-import { Ref } from "../../framework/utils/refs.js";
-import { PathOf } from "../../framework/registered.js";
+import { Ref } from "../../framework/utils/ref-grammar.js";
+import { Ref as Ref$1 } from "../../framework/utils/refs.js";
 import { EntityClass } from "../../framework/defineEntity.js";
 import { Config } from "../../framework/Config.js";
 import { z } from "zod";
@@ -80,9 +80,9 @@ type FormValue<K extends StylePropValueKind> = z.infer<ReturnType<Forms[K]>>;
  * `true` is the bare prop, an empty leaf so the class is its prefix; `false` is its absence and
  * authors nothing. A numeric alias is a leaf once it is a string: `6` names `.uds-grid-cols-6`.
  */
-declare const STYLE_PROP_VALUE_LEAVES: { readonly [K in StylePropValueKind]: (entry: FormValue<K>, members: (target: Ref) => readonly RefMember[]) => StylePropLeaf[] };
+declare const STYLE_PROP_VALUE_LEAVES: { readonly [K in StylePropValueKind]: (entry: FormValue<K>, members: (target: Ref$1) => readonly RefMember[]) => StylePropLeaf[] };
 /** The leaves one stored entry stands for; none for a value no form admits. */
-declare function leavesOfStylePropValue(entry: unknown, members: (target: Ref) => readonly RefMember[]): StylePropLeaf[];
+declare function leavesOfStylePropValue(entry: unknown, members: (target: Ref$1) => readonly RefMember[]): StylePropLeaf[];
 /** The `values` field's member schema against `ctx`: the union of every form. With no context it is
  *  the storage shape; with a config and the owner's properties it is also the judge. */
 declare function stylePropValueSchema(ctx?: StylePropValueCtx): z.ZodType<StylePropValue>;
@@ -97,9 +97,13 @@ declare function classifyStylePropValue({
   config: Config;
   entry: StylePropValue;
 }): StylePropValueKind;
-/** StyleProperty (`flex/direction`) — a prop a component can expose, mapped to a CSS
- *  property with an allowed value set. Grouping (`flex`) is emergent from the path. */
-declare const StylePropertyEntity: EntityClass<z.ZodObject<{
+/**
+ * `StyleProperty.ref('bg')` keeps the path literal in its type, so a component prop declared as the
+ * ref is typed by the property it points at: `bg: StyleProperty.ref('bg')` offers the registered `bg`
+ * values, and `columns: StyleProperty.ref('gridTemplateColumns')` offers the target's rather than
+ * the name's.
+ */
+declare const StyleProperty: EntityClass<z.ZodObject<{
   properties: z.ZodArray<z.ZodString>;
   values: z.ZodOptional<z.ZodArray<z.ZodType<StylePropValue, unknown, z.core.$ZodTypeInternals<StylePropValue, unknown>>>>;
   responsive: z.ZodDefault<z.ZodBoolean>;
@@ -125,18 +129,7 @@ declare const StylePropertyEntity: EntityClass<z.ZodObject<{
       data: Record<string, unknown>;
     } | undefined;
   };
-}, Record<never, never>, false>;
-/**
- * `StyleProperty.ref('bg')` with the path kept literal in its type, so a component prop declared as
- * the ref is typed by the property it points at: `bg: StyleProperty.ref('bg')` offers the registered
- * `bg` values, and `columns: StyleProperty.ref('gridTemplateColumns')` offers the target's rather
- * than the name's. The value is the base ref unchanged; only the type narrows.
- */
-declare const StyleProperty: Omit<typeof StylePropertyEntity, "ref"> & {
-  ref<const Path extends PathOf<"style-property">>(path: Path): ReturnType<typeof StylePropertyEntity.ref> & {
-    readonly __ref: `style-property:${Path}`;
-  };
-};
+}, Record<never, never>, false, Record<never, never>, Record<never, never>>;
 /** `flexDirection` → `flex-direction`. A name already spelled as CSS comes back unchanged. */
 declare function toCssPropertyName(property: string): string;
 /**

package/dist/entities/system/StyleProperty.js

@@ -406,9 +406,13 @@ function freePath(config, path) {
 	for (let n = 2; config.resolve("style-property", candidate); n += 1) candidate = `${path}${n}`;
 	return candidate;
 }
-/** StyleProperty (`flex/direction`) — a prop a component can expose, mapped to a CSS
-*  property with an allowed value set. Grouping (`flex`) is emergent from the path. */
-const StylePropertyEntity = defineEntity({
+/**
+* `StyleProperty.ref('bg')` keeps the path literal in its type, so a component prop declared as the
+* ref is typed by the property it points at: `bg: StyleProperty.ref('bg')` offers the registered `bg`
+* values, and `columns: StyleProperty.ref('gridTemplateColumns')` offers the target's rather than
+* the name's.
+*/
+const StyleProperty = defineEntity({
 	kind: "style-property",
 	label: "Style property",
 	labelPlural: "Style properties",
@@ -429,13 +433,6 @@ const StylePropertyEntity = defineEntity({
 		}
 	}
 });
-/**
-* `StyleProperty.ref('bg')` with the path kept literal in its type, so a component prop declared as
-* the ref is typed by the property it points at: `bg: StyleProperty.ref('bg')` offers the registered
-* `bg` values, and `columns: StyleProperty.ref('gridTemplateColumns')` offers the target's rather
-* than the name's. The value is the base ref unchanged; only the type narrows.
-*/
-const StyleProperty = Object.assign(StylePropertyEntity, {});
 /** `flexDirection` → `flex-direction`. A name already spelled as CSS comes back unchanged. */
 function toCssPropertyName(property) {
 	return property.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);

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

@@ -1,4 +1,5 @@
-import { Ref } from "../../framework/utils/refs.js";
+import { Ref } from "../../framework/utils/ref-grammar.js";
+import { Ref as Ref$1 } from "../../framework/utils/refs.js";
 import { SubEntityClass } from "../../framework/defineSubEntity.js";
 import { EntityClass } from "../../framework/defineEntity.js";
 import { DerivedColor, Gradient } from "./color.js";
@@ -6,7 +7,7 @@ import { z } from "zod";
 
 //#region src/entities/system/Token.d.ts
 /** An override's `on`: a modifier ref, or a list of them that all hold at once. */
-type OverrideCondition = Ref | Ref[];
+type OverrideCondition = Ref$1 | Ref$1[];
 /** The modifier paths an override's `on` names, in the order written. */
 declare function overrideModifiers(on: unknown): string[];
 /**
@@ -62,6 +63,6 @@ declare const Token: EntityClass<z.ZodObject<{
   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>>;
 //#endregion
 export { OverrideCondition, Token, TokenBody, defineOverride, overrideCondition, overrideKey, overrideKeyModifiers, overrideModifiers };

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

@@ -3,7 +3,7 @@ import { RegisteredModifiers, RegisteredPaths, RegisteredStyleProps } from "../.
 import { Authored } from "../../framework/authoring.js";
 import { StyleValue } from "./style-bag.js";
 import { VariantValues } from "./Component.js";
-import { AllHTMLAttributes, ComponentPropsWithRef, ElementType, JSX, ReactNode, Ref } from "react";
+import { AllHTMLAttributes, ComponentPropsWithRef, ComponentType, ElementType, JSX, ReactNode, Ref } from "react";
 
 //#region src/entities/system/defineComponent.d.ts
 /**
@@ -162,7 +162,7 @@ interface ForwardDecl<Path extends string = string> {
  */
 type PropDecl<Path extends string = string> = SlotDecl | ForwardDecl<Path> | {
   type: 'variant';
-  value: readonly string[] | VariantValues | Ref$1;
+  value: readonly string[] | VariantValues | Ref$1 | readonly Ref$1[];
   required?: boolean;
   when?: PropCondition;
 } | {
@@ -231,8 +231,9 @@ interface StyleRuleInput<L extends LayerMap> {
   /** Prop → value, all of which must hold. Absent means unconditional. A value is whatever the prop
    *  it names offers, so a boolean prop's condition is a boolean. */
   readonly when?: Record<string, string | number | boolean>;
-  /** Per layer — and only a layer this component declared. */
-  readonly layers: Partial<Record<keyof L & string, Record<string, StyleValue>>>;
+  /** Per layer — and only a layer this component declared. A glyph prop of a layer component takes
+   *  the glyph component; register stores its member. */
+  readonly layers: Partial<Record<keyof L & string, Record<string, StyleValue | GlyphComponent>>>;
 }
 /** The TS type one prop declaration produces on the rendered component. */
 type ValueOf<D> = D extends readonly (infer Member)[] ? Member : D extends {
@@ -243,6 +244,14 @@ type ValueOf<D> = D extends readonly (infer Member)[] ? Member : D extends {
     __ref: `style-property:${infer Target}`;
   };
 } ? StylePropValue<Target> : ValueOfDeclaration<D>;
+/**
+ * A glyph as a value: the component an icon library exports. Its `displayName` is the member it is,
+ * which is what register stores (`icon:phosphor/XIcon`) and what the renderer resolves back to the
+ * component. Sizing is the placing component's business, so the one prop every glyph takes is `size`.
+ */
+type GlyphComponent = ComponentType<{
+  size?: number;
+}>;
 /**
  * The members a ref-delegated domain offers, read off the registered paths: a variant whose domain
  * is `icon:phosphor` takes every registered `phosphor/<Name>` as `<Name>`, so a misspelled glyph is
@@ -262,7 +271,13 @@ type StylePropValue<Target extends string> = Target extends keyof RegisteredStyl
 type ValueOfDeclaration<D> = D extends {
   type: 'variant';
   value: infer V;
-} ? V extends readonly (infer Member)[] ? Member : V extends VariantValues ? keyof V & string : V extends {
+} ? V extends readonly {
+  __ref: `icon:${string}`;
+}[] ? GlyphComponent : V extends readonly Ref$1[] ? string : V extends readonly (infer Member)[] ? Member : V extends VariantValues ? keyof V & string : V extends {
+  __ref: `${string}#${string}`;
+} ? string : V extends {
+  __ref: `icon:${string}`;
+} ? GlyphComponent : V extends {
   __ref: `${infer Kind}:${infer Path}`;
 } ? RegisteredMembers<Kind, Path> : string : D extends {
   type: 'string';
@@ -690,4 +705,4 @@ interface DefineComponent {
 declare function definePropsFirst<const P extends PropMap<LayerPath>>(props: P & NoInfer<{ [K in keyof P]: Exact<P[K], AuthoredProp<LayerPath>> }>): ComponentBuilder<LayerMap, P>;
 declare const defineComponent: DefineComponent;
 //#endregion
-export { AsInput, AuthoredComponent, AuthoredProp, ComponentBuilder, ComponentPropsOf, LayerElement, LayerMap, PhantomCallProps, PhantomReadProps, PropCondition, PropDecl, PropMap, RegisteredMembers, RenderArgs, StyleRuleInput, defineComponent };
+export { AsInput, AuthoredComponent, AuthoredProp, ComponentBuilder, ComponentPropsOf, GlyphComponent, LayerElement, LayerMap, PhantomCallProps, PhantomReadProps, PropCondition, PropDecl, PropMap, RegisteredMembers, RenderArgs, StyleRuleInput, defineComponent };

package/dist/entities/system/defineComponent.js

@@ -1,4 +1,5 @@
 import { canonicalCondition, isRef, kindOf, memberRef, pathOf } from "../../framework/utils/refs.js";
+import { isComponentType } from "./glyph-identity.js";
 import "../../framework/preview-store.js";
 import { Component, canonicalWhen, layerRef } from "./Component.js";
 //#region src/entities/system/defineComponent.ts
@@ -44,15 +45,14 @@ function build(body) {
 * only one of them runs for any given config: the build reads `.preview()` from source with ts-morph,
 * this runs when a config is registered, and a reader can't tell which made the config it holds.
 *
-* A component handed as a VALUE (`icon: PlusIcon`) stores as the bare ref the registry keys it under,
+* A component handed as a value (`icon: PlusIcon`) stores as the bare ref the registry keys it under,
 * so the receiving component gets the component back rather than a node.
 *
-* What this path CANNOT do is name a component the source could. A tag is its own name and a
-* component handle carries its adopted path, but a foreign function (a Phosphor glyph, say) is just
-* a function at runtime — its `displayName` is a label, not an identity, and two libraries may both
-* export `StarIcon`. Such a prop is DROPPED: an absent default renders nothing, while a guessed ref
-* renders the wrong glyph and reads as authored. The build resolves those from the import specifier,
-* which is why ~a third of the element-valued preview props in a real system only survive a build.
+* OPEN: a foreign component (a Phosphor glyph) is dropped. Its export is known once its library has
+* handed `register` its namespace (`glyphIdentityOf`), but a preview entry's props are stored open
+* (`Preview.fields`) and never re-bound to a member, so a ref written here would reach the build as
+* a package export the package row never lists. An absent default renders nothing; the build fills
+* the prop from the import specifier (`extractPreviewProps`).
 */
 function storableProps(props) {
 	if (props === void 0) return void 0;
@@ -68,11 +68,6 @@ function storableProps(props) {
 function isReactElement(value) {
 	return typeof value === "object" && value !== null && "$$typeof" in value && "props" in value;
 }
-/** A component TYPE handed as a value: a function, or the object `forwardRef` / `memo` return. */
-function isComponentType(value) {
-	if (typeof value === "function") return true;
-	return typeof value === "object" && value !== null && "$$typeof" in value && !("props" in value);
-}
 /** A component handed as a value, as the ref that names it — `undefined` for one this path can't name. */
 function storableComponentRef(value) {
 	return isComponentElement(value) && value.path ? Component.ref(value.path) : void 0;

package/dist/entities/system/glyph-identity.d.ts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+
+//#region src/entities/system/glyph-identity.d.ts
+/** The module namespace an icon library hands `register`: its exports by name. */
+type GlyphNamespace = Readonly<Record<string, unknown>>;
+//#endregion
+export { GlyphNamespace };

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

@@ -0,0 +1,153 @@
+import { isRef, kindOf, memberOf, pathOf } from "../../framework/utils/refs.js";
+import { spellValues } from "../../framework/value-domain.js";
+import { memberLeaves } from "../../framework/projections.js";
+import { z } from "zod";
+//#region src/entities/system/glyph-identity.ts
+const PACKAGE = "package";
+/**
+* Identities by component reference, for the whole process. A component is one object however many
+* configs import it, and which module exports it under which name is a fact about the module, so the
+* map is keyed on the object and not on any config. It is filled while a config file is evaluated
+* (`Icon.group({ glyphs })` runs before `register` does) and read by the open-bag pass, which has no
+* config in hand.
+*/
+const identities = /* @__PURE__ */ new WeakMap();
+/** A component type handed as a value: a function, or the object `forwardRef` / `memo` return. An
+*  element (which also carries `$$typeof`) has `props`; a type does not. */
+function isComponentType(value) {
+	if (typeof value === "function") return true;
+	return typeof value === "object" && value !== null && "$$typeof" in value && !("props" in value);
+}
+/**
+* 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
+* `X` beside `XIcon`, the same function) resolves to the listed name. A name the namespace does not
+* export as a component is skipped: a virtualized package answers a marker object for every key,
+* and a marker is not a component.
+*
+* One object may be listed under several names of one package: Phosphor keeps a renamed glyph's old
+* name as a second `*Icon` export of the same function (`ArchiveBoxIcon` is `BoxArrowDownIcon`).
+* Both are members, and an author writing either holds the same reference, so one of them has to be
+* the stored name. The name the component carries as its `displayName` wins when it is one of the
+* listed names, since that is the one the package calls current; otherwise the first listed stays.
+* The reference decides which names are in question; `displayName` only picks among them, so a
+* library whose display names are not export names (Tabler) is unaffected.
+*
+* Recording one object under a second package is refused. The map is shared by every config in the
+* process, so a stub component two test fixtures reuse under two libraries would otherwise bind to
+* whichever recorded last. Recording the same identity again is a no-op.
+*/
+function recordGlyphIdentities({ namespace, names, specifier }) {
+	for (const name of names) {
+		const value = namespace[name];
+		if (!isComponentType(value)) continue;
+		const prior = identities.get(value);
+		if (prior && prior.specifier !== specifier) throw new Error(`A glyph component is already recorded as \`${prior.name}\` of \`${prior.specifier}\`; it cannot also be \`${name}\` of \`${specifier}\`. Each library's glyphs have to be distinct objects.`);
+		if (prior && prior.name !== name && displayNameOf(value) !== name) continue;
+		identities.set(value, {
+			specifier,
+			name
+		});
+	}
+}
+/** The identity a component was recorded under, or `undefined` for one no library handed over. */
+function glyphIdentityOf(value) {
+	return isComponentType(value) ? identities.get(value) : void 0;
+}
+/** An identity as the ref that spells it: `package:<specifier>#<name>`, the same spelling a
+*  virtualized package's marker carries for a member. */
+function glyphPackageRefOf(identity) {
+	return { __ref: `${PACKAGE}:${identity.specifier}#${identity.name}` };
+}
+/** The identity a `package:<specifier>#<name>` ref spells, or `undefined` for any other value. */
+function glyphIdentityOfRef(value) {
+	if (!isRef(value) || kindOf(value) !== PACKAGE) return void 0;
+	const name = memberOf(value);
+	return name === void 0 ? void 0 : {
+		specifier: pathOf(value),
+		name
+	};
+}
+function displayNameOf(value) {
+	const named = value.displayName;
+	return typeof named === "string" ? named : void 0;
+}
+function spellComponent(value) {
+	const named = displayNameOf(value);
+	return named === void 0 ? "A glyph component" : `\`${named}\``;
+}
+/**
+* The open-bag form of an authored glyph: the imported component, read as the package export it is.
+*
+* The open bag runs before any owner is known, so this cannot bind the glyph to a library; it writes
+* the export as a `package:` ref and the owner-bound pass binds that to the member. A component no
+* library recorded is refused here, since nothing later could name it either: the library did not
+* hand `register` its namespace, the package is not installed (the namespace is then a marker with
+* no components), or the value is a wrapper (`memo(StarIcon)`) rather than the export.
+*/
+const glyphPackageRef = z.custom(isComponentType).transform((value, ctx) => {
+	const identity = glyphIdentityOf(value);
+	if (!identity) {
+		ctx.addIssue({
+			code: "custom",
+			message: `${spellComponent(value)} is not a glyph of any icon library this config declares. Declare the library's exports on its group (\`Icon.group({ glyphs: <Namespace>, … })\`) and check the package is installed; a wrapped glyph (\`memo(StarIcon)\`) is a different object from the export and cannot be bound.`
+		});
+		return z.NEVER;
+	}
+	return glyphPackageRefOf(identity);
+});
+glyphPackageRef._zod.toJSONSchema = () => ({ not: {} });
+/**
+* The owner-bound form of a glyph for one library: a component or its `package:` ref, answered as
+* the member name so the domain binds it like a written leaf. Refused, naming the reason, when the
+* export belongs to another module than the library draws from or is not one of its members.
+*/
+function glyphOfLibrary({ library, module, leaves }) {
+	return z.custom((value) => isComponentType(value) || glyphIdentityOfRef(value) !== void 0, { error: () => `a glyph component of the library (one of ${spellValues(leaves)})` }).transform((value, ctx) => {
+		const identity = isRef(value) ? glyphIdentityOfRef(value) : glyphIdentityOf(value);
+		if (!identity) {
+			ctx.addIssue({
+				code: "custom",
+				message: `${spellComponent(value)} is not a glyph of any icon library this config declares.`
+			});
+			return z.NEVER;
+		}
+		if (identity.specifier !== module) {
+			ctx.addIssue({
+				code: "custom",
+				message: `\`${identity.name}\` is an export of \`${identity.specifier}\`, which the library \`${library}\` does not draw from${module === void 0 ? " (it names no package)" : ` (its package is \`${module}\`)`}.`
+			});
+			return z.NEVER;
+		}
+		if (!leaves.includes(identity.name)) {
+			ctx.addIssue({
+				code: "custom",
+				message: `\`${identity.name}\` is not a member of the library \`${library}\`${leaves.length === 0 ? ", which has no members; the package may not be installed" : ""}.`
+			});
+			return z.NEVER;
+		}
+		return identity.name;
+	});
+}
+/**
+* The glyph form for a key that reaches a library through a forward (`icon` → `icon/name`): the
+* component or its `package:` ref, answered as the bare member name. The forwarded key stores the
+* leaf rather than a member ref, and the emitter and the renderer resolve it through the same
+* libraries (`glyphPropsOf`), taking the first that holds it. Each library's arm refuses by cause,
+* so a glyph of a library the key does not reach says so.
+*/
+function glyphLeafOf({ config, libraries }) {
+	const arms = libraries.map((library) => {
+		const named = config.groupMeta("icon", library)?.package;
+		return glyphOfLibrary({
+			library,
+			module: isRef(named) ? pathOf(named) : void 0,
+			leaves: memberLeaves(config, `icon:${library}`)
+		});
+	});
+	if (arms.length === 1) return arms[0];
+	return z.union(arms);
+}
+//#endregion
+export { glyphLeafOf, glyphOfLibrary, glyphPackageRef, isComponentType, recordGlyphIdentities };

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

@@ -0,0 +1,11 @@
+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.
+ *
+ * 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.
+ */
+export declare function iconDomainInvariants(config: Config): string[];

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

@@ -0,0 +1,178 @@
+import { isRef, kindOf, memberOf, pathOf } from "../../framework/utils/refs.js";
+import { collectBag, isPlainRecord } from "./style-bag.js";
+import { createSliceMemo } from "../../framework/memo.js";
+import { glyphLibrariesOf, memberLeaves, refListOf } 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.
+*
+* 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.
+*/
+function iconDomainInvariants(config) {
+	return [...collisions(config), ...unboundGlyphs(config)];
+}
+/**
+* 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
+* library draws from its module, the library does but does not list the export (a library with no
+* members is usually an uninstalled package), or the library lists it and the key's domain is not
+* that library. Only the open-bag pass writes a `package:` ref into a bag value, so a leftover is
+* always one of these. Without the check the ref reaches the build as a package export the package
+* row never lists, and fails there with the wrong cause.
+*/
+const unboundGlyphs = createSliceMemo({
+	kinds: ["component", "icon"],
+	compute: (config) => {
+		const problems = [];
+		const librariesByModule = librariesByModuleOf(config);
+		const leafSetOf = leafSetsOf(config);
+		for (const item of config.list("component")) {
+			const body = config.resolve("component", item.path)?.toJSON();
+			for (const site of glyphBagSites({
+				config,
+				path: item.path,
+				body
+			})) for (const [key, value] of Object.entries(site.bag)) {
+				const glyph = packageExportOf(value);
+				if (!glyph) continue;
+				const holders = librariesByModule.get(glyph.specifier) ?? [];
+				const at = `Component "${item.path}" key "${key}"`;
+				if (holders.length === 0) {
+					problems.push(`${at} holds the glyph \`${glyph.name}\` of \`${glyph.specifier}\`, and no icon library draws from that package; declare the library, or hand its exports to the one that does (\`Icon.group({ glyphs })\`).`);
+					continue;
+				}
+				const listing = holders.filter((library) => leafSetOf(`icon:${library}`).has(glyph.name));
+				if (listing.length === 0) {
+					const empty = holders.every((library) => leafSetOf(`icon:${library}`).size === 0);
+					problems.push(`${at} holds \`${glyph.name}\`, which is not a member of ${spellLibraries(holders)}${empty ? "; the library has no members, so the package may not be installed" : ""}.`);
+					continue;
+				}
+				problems.push(`${at} holds \`${glyph.name}\`, a glyph of ${spellLibraries(listing)}, which that key does not draw from; a glyph belongs on a prop whose domain names its library, or a forward onto one.`);
+			}
+		}
+		return problems;
+	}
+});
+/**
+* A component's bags with the element each one is props for: a rule's layer bags with the layer's
+* element, an anatomy node's props with the node's element, `defaultProps` with the component itself.
+* A bag whose element is a component ref that resolves to nothing is left out: the owner-bound pass
+* had no declaration to bind against, and the dangling element is the ref graph's complaint, not a
+* glyph on the wrong prop.
+*/
+function glyphBagSites({ config, path, body }) {
+	const owner = body;
+	const sites = [];
+	const keep = () => {};
+	for (const rule of Object.values(owner?.styles ?? {})) {
+		if (!isPlainRecord(rule?.layers)) continue;
+		for (const [layer, bag] of Object.entries(rule.layers)) collectBag(bag, keep, sites, owner?.layers?.[layer]);
+	}
+	for (const node of Object.values(owner?.anatomy ?? {})) {
+		if (!isPlainRecord(node)) continue;
+		collectBag(node.props, keep, sites, node.element);
+	}
+	collectBag(owner?.defaultProps, keep, sites, { __ref: `component:${path}` });
+	return sites.filter((site) => !(isRef(site.element) && kindOf(site.element) === "component" && !config.resolveRef(site.element.__ref)));
+}
+/** The library paths drawing from each package specifier, off every icon group's `package` ref. */
+function librariesByModuleOf(config) {
+	const byModule = /* @__PURE__ */ new Map();
+	for (const group of config.groups("icon")) {
+		const named = group.meta.package;
+		if (!isRef(named)) continue;
+		const specifier = pathOf(named);
+		byModule.set(specifier, [...byModule.get(specifier) ?? [], group.path]);
+	}
+	return byModule;
+}
+/** The export a `package:<specifier>#<name>` ref spells, or `undefined` for any other value. */
+function packageExportOf(value) {
+	if (!isRef(value) || kindOf(value) !== "package") return void 0;
+	const name = memberOf(value);
+	return name === void 0 ? void 0 : {
+		specifier: pathOf(value),
+		name
+	};
+}
+function spellLibraries(libraries) {
+	const named = libraries.map((library) => `"${library}"`);
+	return libraries.length === 1 ? `the library ${named[0]}` : `the libraries ${named.join(", ")}`;
+}
+/**
+* Keyed on the two slices the check reads, so the second kind's run within one registration is a
+* hit, and a write to any other kind never pays for it. A library's leaf set is keyed on the icon
+* slice alone: a component edit re-walks the list-valued props against sets that are already built.
+*/
+const collisions = createSliceMemo({
+	kinds: ["component", "icon"],
+	compute: (config) => {
+		const problems = [];
+		const leafSetOf = leafSetsOf(config);
+		for (const item of config.list("component")) {
+			const body = config.resolve("component", item.path)?.toJSON();
+			for (const [prop, decl] of Object.entries(body?.props ?? {})) {
+				const refs = listedLibraryRefsOf(decl);
+				if (!refs) continue;
+				const heldBy = /* @__PURE__ */ new Map();
+				const shared = /* @__PURE__ */ new Map();
+				for (const target of refs) for (const leaf of leafSetOf(target)) {
+					const other = heldBy.get(leaf);
+					if (other === void 0) {
+						heldBy.set(leaf, target);
+						continue;
+					}
+					if (other === target) continue;
+					const pair = `${other} + ${target}`;
+					shared.set(pair, [...shared.get(pair) ?? [], leaf]);
+				}
+				for (const [pair, leaves] of shared) {
+					const [first, second] = pair.split(" + ");
+					problems.push(`Component "${item.path}" prop "${prop}" binds icon libraries "${first}" and "${second}", which both ship ${spellLeaves(leaves)}; a leaf has to name one glyph.`);
+				}
+			}
+		}
+		return problems;
+	}
+});
+/** One leaf set per referenced library, filled on demand and kept while the icon slice stands. */
+const leafSetsOf = createSliceMemo({
+	kinds: ["icon"],
+	compute: (config) => {
+		const sets = /* @__PURE__ */ new Map();
+		return (target) => {
+			const hit = sets.get(target);
+			if (hit) return hit;
+			const built = new Set(memberLeaves(config, target));
+			sets.set(target, built);
+			return built;
+		};
+	}
+});
+/** The colliding names, capped so two libraries sharing hundreds refuse in one sentence. */
+function spellLeaves(leaves) {
+	const shown = leaves.slice(0, 8).map((leaf) => `"${leaf}"`);
+	const rest = leaves.length - shown.length;
+	const named = rest > 0 ? `${shown.join(", ")} and ${rest} more` : shown.join(", ");
+	return leaves.length === 1 ? `a glyph named ${named}` : `glyphs named ${named}`;
+}
+/**
+* The icon-library refs of a variant prop whose domain is a list of refs, else `undefined`. Each
+* element is put through `glyphLibrariesOf` on its own, so the ref comes back whole: the leaf sets
+* are read at the source the ref names, which a group path alone cannot say. A facet ref
+* (`icon:a#variants`) is not a library, and a ref of another kind is left to that kind's rules.
+*/
+function listedLibraryRefsOf(decl) {
+	if (decl === null || typeof decl !== "object") return void 0;
+	const { type, value } = decl;
+	if (type !== "variant") return void 0;
+	const listed = refListOf(value)?.filter((target) => glyphLibrariesOf({ __ref: target }).length > 0);
+	return listed && listed.length > 0 ? listed : void 0;
+}
+//#endregion
+export { iconDomainInvariants };