@yahoo/uds-create-config 4.36.0 → 4.37.0

package/dist/entities/system/Component.js

@@ -462,8 +462,6 @@ const PROP_TYPES = [
 	"boolean"
 ];
 const PROP_DESCRIPTION = "What the prop is. A style property the component exposes, `{ \"type\": \"styleProperty\", \"value\": { \"__ref\": \"style-property:<name>\" } }`, which is what a primitive's props mostly are and what makes a style rule's bag key valid on it; a closed set of names a style rule keys on, `{ \"type\": \"variant\", \"value\": [\"sm\", \"lg\"] }`; content, `{ \"type\": \"slot\", \"text\": true }`, or a slot whose own value is a library member, `{ \"type\": \"slot\", \"value\": { \"__ref\": \"icon:<library>\" } }`, which code may also fill with the forms it lists under `code` (`[\"node\", \"element\", \"render\"]`); or a plain `string`, `number` or `boolean`. `null` hides a prop an inherited layer would expose. A prop that applies only under a condition on a sibling carries `when`, the record a style rule uses: `{ \"type\": \"string\", \"when\": { \"type\": \"color\" } }` shows it for one value, `{ \"when\": { \"type\": [\"default\", \"header\"] } }` for several.";
-/** Nullable because `null` is the omit tombstone: a component that `inherits` its element's props
-*  drops one by declaring it `null`, rather than needing a second "don't expose" mechanism. */
 const Prop = defineSubEntity({
 	name: "prop",
 	label: "Prop",
@@ -958,13 +956,6 @@ function previewShowsNothing(entry) {
 	const props = entry?.props;
 	return !props || Object.keys(props).length === 0;
 }
-/**
-* The props a cell previews with, keyed by the condition they hold under the way a style rule is:
-* `*` for every cell, a condition on the component's own props for some. `when` names those props,
-* so a prop rename moves it and a value rename moves the ref it stores; `props` is keyed by prop
-* too, which `Prop.keyedByNameIn` and `VariantValue.namedValuesIn` reach through `preview/*\/props`.
-* Deleting a prop or a value drops the entries conditioned on it.
-*/
 const Preview = defineSubEntity({
 	name: "preview",
 	label: "Preview",

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

@@ -1,12 +1,14 @@
-import { SubEntityClass } from "../../framework/defineSubEntity.js";
 import { EntityClass } from "../../framework/defineEntity.js";
-import { StyleValue } from "./style-bag.js";
+import { Named } from "../../framework/named.js";
+import { AuthoredStyleField } from "./style-bag.js";
 import { z } from "zod";
 
 //#region src/entities/system/Composite.d.ts
 /** A composite variant (`overlays/elevation/1`) — the style-prop bag it applies. */
-declare const Composite: EntityClass<z.ZodObject<{
-  styles: SubEntityClass<z.ZodType<StyleValue, unknown, z.core.$ZodTypeInternals<StyleValue, unknown>>>;
-}, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "composite", Record<never, never>, Record<never, never>, false, Record<never, never>, Record<never, never>>;
+declare const CompositeDefinition: EntityClass<z.ZodObject<{
+  styles: AuthoredStyleField;
+}, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "composite", {}, Record<never, never>, false, Record<never, never>, Record<never, never>>;
+interface CompositeClass extends Named<typeof CompositeDefinition> {}
+declare const Composite: CompositeClass;
 //#endregion
-export { Composite };
+export { Composite, CompositeClass };

package/dist/entities/system/Composite.js

@@ -11,7 +11,6 @@ const compositeBags = (data) => {
 	}, out);
 	return out;
 };
-/** A composite variant (`overlays/elevation/1`) — the style-prop bag it applies. */
 const Composite = defineEntity({
 	kind: "composite",
 	label: "Composite style",

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

@@ -1,11 +1,14 @@
 import { EntityClass } from "../../framework/defineEntity.js";
+import { Named } from "../../framework/named.js";
 import { z } from "zod";
 
 //#region src/entities/system/Device.d.ts
-declare const Device: EntityClass<z.ZodObject<{
+declare const DeviceDefinition: EntityClass<z.ZodObject<{
   width: z.ZodNumber;
   height: z.ZodNumber;
   name: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "device", Record<never, never>, Record<never, never>, false, Record<never, never>, Record<never, never>>;
+}, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "device", {}, Record<never, never>, false, Record<never, never>, Record<never, never>>;
+interface DeviceClass extends Named<typeof DeviceDefinition> {}
+declare const Device: DeviceClass;
 //#endregion
-export { Device };
+export { Device, DeviceClass };

package/dist/entities/system/Device.js

@@ -1,11 +1,5 @@
 import { defineEntity } from "../../framework/defineEntity.js";
 import { z } from "zod";
-//#region src/entities/system/Device.ts
-/**
-* `Device` — a named viewport size (mobile / tablet / desktop / …). A SYSTEM entity, so devices
-* are configurable design-system DATA, not a hardcoded constant. A design-file node's `size` can
-* be `{ type: 'device', ref: Device.ref('mobile') }` to be powered by one of these.
-*/
 const Device = defineEntity({
 	kind: "device",
 	fields: z.object({

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

@@ -2,6 +2,7 @@ import { Ref } from "../../framework/utils/ref-grammar.js";
 import { SubEntityClass } from "../../framework/defineSubEntity.js";
 import { ComputedInput } from "../../framework/registry.js";
 import { EntityClass } from "../../framework/defineEntity.js";
+import { Named } from "../../framework/named.js";
 import { z } from "zod";
 
 //#region src/entities/system/File.d.ts
@@ -24,6 +25,41 @@ declare const SCRIPT_EXTENSIONS: ReadonlySet<string>;
  * and a leading dot is a dotfile (`.gitignore`) rather than an extension.
  */
 declare function isBinaryAsset(filePath: string): boolean;
+/**
+ * One import — keyed by the specifier as authored (`'./tone'`, `'@/uds/hooks/use-tone'`,
+ * `'motion/react'`), holding what that specifier resolved to.
+ *
+ * **Both halves, because they come apart.** The specifier decides whether the target relocates when
+ * a module is emitted into `.uds` — a relative import has to be mirrored beside the generated
+ * module, an aliased one resolves through the consumer's own `paths` from anywhere — and
+ * `file:components/tone.ts` does not say which of the two the render wrote. The specifier is the key
+ * rather than a field beside one because it is the import's identity: a module imported twice is one
+ * edge, and storing it in both places would be one string with two homes and no rule for which wins.
+ *
+ * **One list, not two.** An import is an import; splitting it by what it happens to resolve to gives
+ * two lists that must be kept in step and throws away source order, which decides evaluation for a
+ * side-effect import. `kindOf(ref)` is the discriminator, the same one that tells every other union
+ * in the config apart.
+ */
+declare const FileImportDefinition: SubEntityClass<z.ZodObject<{
+  target: z.ZodType<Ref, unknown, z.core.$ZodTypeInternals<Ref, unknown>>;
+  names: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>>;
+interface FileImportClass extends Named<typeof FileImportDefinition> {}
+/**
+ * One export of a sealed source file that a render places in JSX — `file:components/pagination.tsx#PaginationProvider`.
+ *
+ * A component file exports more than its components: a context provider the composite wraps its
+ * root in, a plain function component two renders share. When a render puts one in the tree, the
+ * anatomy has to name it — the same way it names a package's export — and the registry has to
+ * import it from the module the file emits to. The member is that name, with the same empty body a
+ * `Package` export has: its identity is its name, and the module it lives in is the owning file.
+ *
+ * Only what a render placed in JSX, for the reason a `Package` lists only that: nobody browses a
+ * file's exports, and a hook or a helper no JSX mentions is not a render surface.
+ */
+declare const FileExportDefinition: SubEntityClass<z.ZodObject<{}, z.core.$strict>>;
+interface FileExportClass extends Named<typeof FileExportDefinition> {}
 /**
  * File (`file:components/card.tsx`) — one artifact the seal owns.
  *
@@ -47,14 +83,11 @@ declare function isBinaryAsset(filePath: string): boolean;
  * walked, the way it derives `Package` groups from the same walk. Nobody picks a file out of a
  * picker, so the kind has no group metadata and its groups stay emergent from the path.
  */
-declare const File: EntityClass<z.ZodObject<{
+declare const FileDefinition: EntityClass<z.ZodObject<{
   hash: z.ZodString;
-  imports: z.ZodOptional<SubEntityClass<z.ZodObject<{
-    target: z.ZodType<Ref, unknown, z.core.$ZodTypeInternals<Ref, unknown>>;
-    names: z.ZodOptional<z.ZodArray<z.ZodString>>;
-  }, z.core.$strip>>>;
-  exports: z.ZodOptional<SubEntityClass<z.ZodObject<{}, z.core.$strict>>>;
-}, z.core.$strict>, z.ZodObject<Record<never, never>, z.core.$strip>, "file", Record<never, never>, {
+  imports: z.ZodOptional<FileImportClass>;
+  exports: z.ZodOptional<FileExportClass>;
+}, z.core.$strict>, z.ZodObject<Record<never, never>, z.core.$strip>, "file", {}, {
   /**
    * Bytes rather than text, so a restore knows how to write it — derived from the path, because
    * the path is the only thing that decides it.
@@ -69,5 +102,7 @@ declare const File: EntityClass<z.ZodObject<{
     path
   }: ComputedInput) => boolean;
 }, false, Record<never, never>, Record<never, never>>;
+interface FileClass extends Named<typeof FileDefinition> {}
+declare const File: FileClass;
 //#endregion
-export { File, SCRIPT_EXTENSIONS, isBinaryAsset };
+export { File, FileClass, SCRIPT_EXTENSIONS, isBinaryAsset };

package/dist/entities/system/File.js

@@ -40,22 +40,6 @@ function isBinaryAsset(filePath) {
 *  `File` because it is a self-reference through the collection `File` declares; the explicit
 *  annotation breaks the circular type inference, the same way a token's value schema does. */
 const importTarget = z.union([z.lazy(() => File), Package]);
-/**
-* One import — keyed by the specifier as authored (`'./tone'`, `'@/uds/hooks/use-tone'`,
-* `'motion/react'`), holding what that specifier resolved to.
-*
-* **Both halves, because they come apart.** The specifier decides whether the target relocates when
-* a module is emitted into `.uds` — a relative import has to be mirrored beside the generated
-* module, an aliased one resolves through the consumer's own `paths` from anywhere — and
-* `file:components/tone.ts` does not say which of the two the render wrote. The specifier is the key
-* rather than a field beside one because it is the import's identity: a module imported twice is one
-* edge, and storing it in both places would be one string with two homes and no rule for which wins.
-*
-* **One list, not two.** An import is an import; splitting it by what it happens to resolve to gives
-* two lists that must be kept in step and throws away source order, which decides evaluation for a
-* side-effect import. `kindOf(ref)` is the discriminator, the same one that tells every other union
-* in the config apart.
-*/
 const FileImport = defineSubEntity({
 	name: "import",
 	label: "Import",
@@ -81,47 +65,12 @@ const FileImport = defineSubEntity({
 		names: z.array(z.string()).optional()
 	})
 });
-/**
-* One export of a sealed source file that a render places in JSX — `file:components/pagination.tsx#PaginationProvider`.
-*
-* A component file exports more than its components: a context provider the composite wraps its
-* root in, a plain function component two renders share. When a render puts one in the tree, the
-* anatomy has to name it — the same way it names a package's export — and the registry has to
-* import it from the module the file emits to. The member is that name, with the same empty body a
-* `Package` export has: its identity is its name, and the module it lives in is the owning file.
-*
-* Only what a render placed in JSX, for the reason a `Package` lists only that: nobody browses a
-* file's exports, and a hook or a helper no JSX mentions is not a render surface.
-*/
 const FileExport = defineSubEntity({
 	name: "exports",
 	label: "Export",
 	labelPlural: "Exports",
 	fields: z.strictObject({})
 });
-/**
-* File (`file:components/card.tsx`) — one artifact the seal owns.
-*
-* A component is a definition plus the React that renders it, and `config.json` cannot hold JSX, so
-* some of what a system publishes travels as bytes. `uds push` bounds the source graph to the Git
-* checkout and the config directory, hashes those files, and uploads them; a consumer pulls them
-* down and verifies the hash. That whole lifecycle — hashed, uploaded, restored, verified — is one
-* thing, and it is what this kind is for.
-*
-* **Sealed repo source is a `File`; anything remote stays a URL.** A `FontFile`'s `src` is something
-* somebody uploaded to a cdn: there is no hash to check, no seal that owns it, and no build that
-* produced it. Folding both into one kind would put two provenance models and two trust models
-* behind one name.
-*
-* **The path is the src**, so there is no `src` field. Config-relative is the same key space the seal
-* converts to, so an entry and a sealed file name the same thing with no translation and nothing to
-* keep in step. The extension is part of the path deliberately: a helper authored as `.ts` is not
-* JSX, and a bundler resolving `./tone` looks for what the closure actually holds.
-*
-* Ordinary authoring does not maintain this graph — the build derives it from the source it just
-* walked, the way it derives `Package` groups from the same walk. Nobody picks a file out of a
-* picker, so the kind has no group metadata and its groups stay emergent from the path.
-*/
 const File = defineEntity({
 	kind: "file",
 	label: "File",

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

@@ -1,5 +1,6 @@
 import { SubEntityClass } from "../../framework/defineSubEntity.js";
 import { EntityClass } from "../../framework/defineEntity.js";
+import { Named } from "../../framework/named.js";
 import { z } from "zod";
 
 //#region src/entities/system/Font.d.ts
@@ -14,13 +15,15 @@ import { z } from "zod";
  * a file directly, and it can't be derived from the family name. Optional because nothing that feeds
  * a config records one today; it's author/upload-supplied.
  */
-declare const FontFile: SubEntityClass<z.ZodObject<{
+declare const FontFileDefinition: SubEntityClass<z.ZodObject<{
   src: z.ZodString;
   format: z.ZodOptional<z.ZodString>;
   weight: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
   style: z.ZodOptional<z.ZodString>;
   postscriptName: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>>;
+interface FontFileClass extends Named<typeof FontFileDefinition> {}
+declare const FontFile: FontFileClass;
 /**
  * Font (`fonts/yas`) — one family in a font library. The library (`fonts`) is an EMERGENT group from
  * the path, carrying only its version; a family carries its own CSS-facing name, its files, and the
@@ -30,21 +33,17 @@ declare const FontFile: SubEntityClass<z.ZodObject<{
  * only a font can be referenced where a family is expected, which is what the old config could
  * only enforce by throwing at resolve time ("only font groups can be referenced as a token value").
  */
-declare const Font: EntityClass<z.ZodObject<{
+declare const FontDefinition: EntityClass<z.ZodObject<{
   fontFamily: z.ZodString;
-  files: z.ZodOptional<SubEntityClass<z.ZodObject<{
-    src: z.ZodString;
-    format: z.ZodOptional<z.ZodString>;
-    weight: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
-    style: z.ZodOptional<z.ZodString>;
-    postscriptName: z.ZodOptional<z.ZodString>;
-  }, z.core.$strip>>>;
+  files: z.ZodOptional<FontFileClass>;
   fallbackStack: z.ZodOptional<z.ZodArray<z.ZodString>>;
   variable: z.ZodOptional<z.ZodString>;
   isVariableFont: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strict>, z.ZodObject<{
   version: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>, "font", Record<never, never>, Record<never, never>, false, Record<never, never>, Record<never, never>>;
+}, z.core.$strict>, "font", {}, Record<never, never>, false, Record<never, never>, Record<never, never>>;
+interface FontClass extends Named<typeof FontDefinition> {}
+declare const Font: FontClass;
 /**
  * `value` as a double-quoted CSS string. A quote, backslash, line break or `<` inside it is written as
  * a CSS escape, so the value reads back exactly and can neither end the string nor close an HTML
@@ -75,4 +74,4 @@ declare function fontFamilyStack(font: {
   readonly variable?: string | undefined;
 }): string;
 //#endregion
-export { Font, FontFile, cssString, fontFamilyStack };
+export { Font, FontClass, FontFile, FontFileClass, cssString, fontFamilyStack };

package/dist/entities/system/Font.js

@@ -1,18 +1,6 @@
 import { defineEntity } from "../../framework/defineEntity.js";
 import { defineSubEntity } from "../../framework/defineSubEntity.js";
 import { z } from "zod";
-//#region src/entities/system/Font.ts
-/**
-* One FILE of a font family — the unit `@font-face` needs a rule for. Named `files` rather than
-* `weights` because the two don't line up: a roman and an italic at 400 are two files sharing one
-* weight, and a variable font is one file covering many (`weight: '100 900'`). `weightCount` is the
-* derivation over these, not their count.
-*
-* `postscriptName` names this exact file (`YahooSans-BoldItalic`). CSS never needs it — a stylesheet
-* addresses the FAMILY and lets the browser pick by weight/style — but a native platform references
-* a file directly, and it can't be derived from the family name. Optional because nothing that feeds
-* a config records one today; it's author/upload-supplied.
-*/
 const FontFile = defineSubEntity({
 	name: "file",
 	label: "Font file",
@@ -26,15 +14,6 @@ const FontFile = defineSubEntity({
 		postscriptName: z.string().optional()
 	})
 });
-/**
-* Font (`fonts/yas`) — one family in a font library. The library (`fonts`) is an EMERGENT group from
-* the path, carrying only its version; a family carries its own CSS-facing name, its files, and the
-* governance/rendering flags a picker and `@font-face` emission need.
-*
-* A font is its own kind rather than a variant of a generic `asset` so that a `font:` ref is typed:
-* only a font can be referenced where a family is expected, which is what the old config could
-* only enforce by throwing at resolve time ("only font groups can be referenced as a token value").
-*/
 const Font = defineEntity({
 	kind: "font",
 	label: "Font",

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

@@ -1,4 +1,5 @@
 import { EntityClass } from "../../framework/defineEntity.js";
+import { Named } from "../../framework/named.js";
 import { DerivedColor } from "./color.js";
 import { z } from "zod";
 
@@ -12,11 +13,13 @@ type Declared = string | number | {
 } | DerivedColor | {
   [key: string]: Declared;
 };
-declare const GlobalStyle: EntityClass<z.ZodObject<{
+declare const GlobalStyleDefinition: EntityClass<z.ZodObject<{
   selector: z.ZodString;
   declarations: z.ZodRecord<z.ZodString, z.ZodType<Declared, unknown, z.core.$ZodTypeInternals<Declared, unknown>>>;
   important: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strict>, z.ZodObject<Record<never, never>, z.core.$strip>, "global-style", Record<never, never>, Record<never, never>, false, Record<never, never>, Record<never, never>>;
+}, z.core.$strict>, z.ZodObject<Record<never, never>, z.core.$strip>, "global-style", {}, Record<never, never>, false, Record<never, never>, Record<never, never>>;
+interface GlobalStyleClass extends Named<typeof GlobalStyleDefinition> {}
+declare const GlobalStyle: GlobalStyleClass;
 /**
  * A stable name for a rule, from its selector — `@keyframes bounce` → `bounce`, `.prompt-editor p`
  * → `promptEditorP`. Suffixed on collision, so two selectors that slug alike both land.
@@ -27,4 +30,4 @@ declare const GlobalStyle: EntityClass<z.ZodObject<{
  */
 declare function globalStyleName(selector: string, taken?: ReadonlySet<string>): string;
 //#endregion
-export { GlobalStyle, globalStyleName };
+export { GlobalStyle, GlobalStyleClass, globalStyleName };

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

@@ -1,6 +1,7 @@
 import { GuidanceLane } from "../../ai-lanes.js";
 import { Ref } from "../../framework/utils/refs.js";
 import { EntityClass } from "../../framework/defineEntity.js";
+import { Named } from "../../framework/named.js";
 import { Config } from "../../framework/Config.js";
 import { z } from "zod";
 
@@ -41,7 +42,7 @@ type GuidanceSegment = string | Ref;
  * whose target is missing (a source no longer attached) prints the ref's last-known path.
  */
 declare function guidanceTextOf(config: Config, text: readonly GuidanceSegment[]): string;
-declare const Guidance: EntityClass<z.ZodObject<{
+declare const GuidanceDefinition: EntityClass<z.ZodObject<{
   text: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
     __ref: z.ZodString;
   }, z.core.$strip>]>>;
@@ -54,7 +55,9 @@ declare const Guidance: EntityClass<z.ZodObject<{
     "paint-style": "paint-style";
     "figma-import": "figma-import";
   }>>>;
-}, z.core.$strict>, "guidance", Record<never, never>, Record<never, never>, false, Record<never, never>, Record<never, never>>;
+}, z.core.$strict>, "guidance", {}, Record<never, never>, false, Record<never, never>, Record<never, never>>;
+interface GuidanceClass extends Named<typeof GuidanceDefinition> {}
+declare const Guidance: GuidanceClass;
 /**
  * A topic's effective reach, and which topic decided it. `appliesTo === undefined` means every
  * lane. `declaredBy` is the topic the answer was read from, so a lane can say "inherited from
@@ -82,4 +85,4 @@ declare function guidanceReaches({
   lane: GuidanceLane;
 }): boolean;
 //#endregion
-export { Guidance, GuidanceScope, GuidanceSegment, guidanceReaches, guidanceScopeOf, guidanceTextOf };
+export { Guidance, GuidanceClass, GuidanceScope, GuidanceSegment, guidanceReaches, guidanceScopeOf, guidanceTextOf };

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

@@ -1,4 +1,5 @@
 import { EntityClass } from "../../framework/defineEntity.js";
+import { Named } from "../../framework/named.js";
 import { z } from "zod";
 
 //#region src/entities/system/GuidanceStyle.d.ts
@@ -7,8 +8,10 @@ declare const guidanceStyleFields: z.ZodObject<{
 }, z.core.$strip>;
 /** A style guide's stored body. */
 type GuidanceStyleBody = z.infer<typeof guidanceStyleFields>;
-declare const GuidanceStyle: EntityClass<z.ZodObject<{
+declare const GuidanceStyleDefinition: EntityClass<z.ZodObject<{
   text: z.ZodString;
-}, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "guidance-style", Record<never, never>, Record<never, never>, false, Record<never, never>, Record<never, never>>;
+}, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "guidance-style", {}, Record<never, never>, false, Record<never, never>, Record<never, never>>;
+interface GuidanceStyleClass extends Named<typeof GuidanceStyleDefinition> {}
+declare const GuidanceStyle: GuidanceStyleClass;
 //#endregion
-export { GuidanceStyle, GuidanceStyleBody };
+export { GuidanceStyle, GuidanceStyleBody, GuidanceStyleClass };

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

@@ -1,5 +1,6 @@
-import { SubEntityClass } from "../../framework/defineSubEntity.js";
 import { EntityClass, GroupComputedInput } from "../../framework/defineEntity.js";
+import { Named } from "../../framework/named.js";
+import { PackageClass } from "./Package.js";
 import { GlyphNamespace } from "./glyph-identity.js";
 import { z } from "zod";
 
@@ -36,7 +37,7 @@ type IconVariantAs = z.infer<typeof iconVariantAs>;
  *
  * (A per-icon type/variant is config-v2 model gap 8; this is where it lands.)
  */
-declare const Icon: EntityClass<z.ZodObject<{
+declare const IconDefinition: EntityClass<z.ZodObject<{
   categories: z.ZodOptional<z.ZodArray<z.ZodString>>;
   tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
   codepoint: z.ZodOptional<z.ZodNumber>;
@@ -47,10 +48,7 @@ declare const Icon: EntityClass<z.ZodObject<{
     __ref: z.ZodString;
   }, z.core.$strip>>;
   metadata: z.ZodOptional<z.ZodObject<{
-    from: EntityClass<z.ZodObject<{
-      version: z.ZodOptional<z.ZodString>;
-      exports: z.ZodOptional<SubEntityClass<z.ZodObject<{}, z.core.$strict>>>;
-    }, z.core.$strict>, z.ZodObject<Record<never, never>, z.core.$strip>, "package", Record<never, never>, Record<never, never>, false, Record<never, never>, Record<never, never>>;
+    from: PackageClass;
     format: z.ZodEnum<{
       uds: "uds";
       phosphor: "phosphor";
@@ -64,7 +62,7 @@ declare const Icon: EntityClass<z.ZodObject<{
   }, z.core.$strict>, z.ZodObject<{
     export: z.ZodRecord<z.ZodString, z.ZodString>;
   }, z.core.$strict>]>>;
-}, z.core.$strict>, "icon", Record<never, never>, Record<never, never>, false, {
+}, z.core.$strict>, "icon", {}, Record<never, never>, false, {
   /** The glyphs the set ships, by leaf name. */readonly members: ({
     config,
     path
@@ -100,5 +98,7 @@ declare const Icon: EntityClass<z.ZodObject<{
     items: Record<string, unknown>;
   };
 }>;
+interface IconClass extends Named<typeof IconDefinition> {}
+declare const Icon: IconClass;
 //#endregion
-export { Icon, IconVariantAs, iconVariantAs };
+export { Icon, IconClass, IconVariantAs, iconVariantAs };

package/dist/entities/system/Icon.js

@@ -17,22 +17,6 @@ import { z } from "zod";
 */
 /** @deprecated With the group's `variantAs`; see there. */
 const iconVariantAs = z.union([z.strictObject({ prop: z.string().min(1) }), z.strictObject({ export: z.record(z.string().min(1), z.string().min(1)) })]);
-/**
-* Icon (`icons/AcornIcon`) — one glyph in an icon library. The library (`icons`) is an EMERGENT group
-* from the path, and everything that describes the SET lives on that group node: its version, the
-* sizes and variants it ships, and where the members' descriptive facts come from (`metadata`). A
-* component that renders a glyph names the library through its own prop's domain (`Icon.ref('phosphor')`),
-* so the edge runs from the component to the set and the set knows nothing about its renderers.
-*
-* A member's identity is still its name; its fields carry what the name can't say. A group that
-* declares `metadata` gets those fields baked at BUILD time from the declared source, and the bake
-* fills only fields with no stored value — an author's hand-written value is never overwritten
-* (every such skip is logged by the build), and a curator's Studio edit is a patch that replays on
-* top of the base regardless. Fields are re-derived every build, so a source removing facts flows
-* through at the next dependency bump rather than lingering.
-*
-* (A per-icon type/variant is config-v2 model gap 8; this is where it lands.)
-*/
 const Icon = defineEntity({
 	kind: "icon",
 	label: "Icon",