@yahoo/uds-create-config 4.35.3 → 4.36.1

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

@@ -1,10 +1,9 @@
-import { CopyPlan } from "./copy-plan.js";
 import { SourceResolver, SourceState } from "../../framework/sources.js";
 import { ComputedInput } from "../../framework/registry.js";
 import { RegisteredEntities } from "../../framework/registered.js";
 import { EntityClass, ItemOf } from "../../framework/defineEntity.js";
 import { PartialBodyOf } from "../../framework/defineConfig.js";
-import { BreakPlan, LinkPlan, SourceRowState, UnlinkPlan } from "./link-plan.js";
+import { Named } from "../../framework/named.js";
 import { Config } from "../../framework/Config.js";
 import { z } from "zod";
 
@@ -86,38 +85,6 @@ declare const sourceUnavailable: z.ZodDiscriminatedUnion<[z.ZodObject<{
   code: z.ZodLiteral<"unreachable">;
 }, z.core.$strip>], "code">;
 type SourceUnavailable = z.infer<typeof sourceUnavailable>;
-/** A `link` or `unlink` example: one entity the source offers, under the accessor this config files it by. */
-declare function linkExample({
-  config,
-  path
-}: {
-  config: Config;
-  path: string;
-}): Record<string, unknown> | undefined;
-/** An example for an op that takes the pin alone, shown once the pin has a source to read. */
-declare function pinExample({
-  config,
-  path
-}: {
-  config: Config;
-  path: string;
-}): Record<string, unknown> | undefined;
-/** A break's example, shown once the pin has a source to read. */
-declare function breakExample({
-  config,
-  path
-}: {
-  config: Config;
-  path: string;
-}): Record<string, unknown> | undefined;
-/** A copy's example: one entity the source offers, under the accessor this config files it by. */
-declare function copyExample({
-  config,
-  path
-}: {
-  config: Config;
-  path: string;
-}): Record<string, unknown> | undefined;
 /**
  * The bridging cast, and the annotation that survives declaration emit.
  *
@@ -127,7 +94,7 @@ declare function copyExample({
  * would then change nothing.
  */
 type PinOptionsField = z.ZodOptional<z.ZodType<PinOptions, PinOptions>>;
-declare const LinkedSystem: EntityClass<z.ZodObject<{
+declare const LinkedSystemDefinition: EntityClass<z.ZodObject<{
   configPath: z.ZodOptional<z.ZodString>;
   link: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"*">, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<"*">, z.ZodArray<z.ZodString>]>>]>>;
   options: PinOptionsField;
@@ -136,87 +103,35 @@ declare const LinkedSystem: EntityClass<z.ZodObject<{
   name: z.ZodOptional<z.ZodString>;
   version: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>, z.ZodObject<Record<never, never>, z.core.$strip>, "linked-system", {
-  /**
-   * Draw entities from a linked system: the pin's `link` declaration grows to cover them and the
-   * build mints a pointer row per entity, in this one op. A row of this config's own at a covered
-   * path is deleted so theirs shows through; a row held through another pin becomes an extension
-   * through this one. `link-plan` says what that replaces before anything is written.
-   */
   readonly link: {
     readonly input: z.ZodObject<{
       path: z.ZodType<string, string | undefined, z.core.$ZodTypeInternals<string, string | undefined>>;
       data: z.ZodUnion<readonly [z.ZodLiteral<"*">, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<"*">, z.ZodArray<z.ZodString>]>>]>;
     }, z.core.$strip>;
-    readonly readOnly: false;
-    readonly label: "Link from";
-    readonly description: "Draw entities from a linked system, following the source: `data` names them by accessor — `{ tokens: ['color/brand', 'color'] }` takes an entity and a folder's members, `{ tokens: '*' }` every token, and `'*'` the whole system. What this config already holds at those paths is replaced by theirs, so run `linked-system/link-plan` with the same input first to see what that is. To hold their values as your own instead, `copy`.";
-    readonly scope: "item";
-    readonly approval: "reference-change";
-    readonly title: (entity: string) => string;
-    readonly example: typeof linkExample;
-    readonly handler: (input: Record<string, unknown>, config: Config) => Config;
   };
   readonly 'link-plan': {
     readonly input: z.ZodObject<{
       path: z.ZodType<string, string | undefined, z.core.$ZodTypeInternals<string, string | undefined>>;
       data: z.ZodUnion<readonly [z.ZodLiteral<"*">, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<"*">, z.ZodArray<z.ZodString>]>>]>;
     }, z.core.$strip>;
-    readonly readOnly: true;
-    readonly label: "Plan a link";
-    readonly description: "What `link` with the same input replaces — rows of yours deleted so the source shows through, rows held through another pin turned into extensions, and members left alone because they are already here from the same origin. Writes nothing.";
-    readonly scope: "item";
-    readonly title: (entity: string) => string;
-    readonly example: typeof linkExample;
-    readonly handler: (input: Record<string, unknown>, config: Config) => Omit<LinkPlan, "patches">;
   };
-  /**
-   * Stop drawing from a linked system, whole or in part. The declaration narrows and the rows it
-   * minted retire in the same op; the pin stays, so it can be linked again.
-   */
   readonly unlink: {
     readonly input: z.ZodObject<{
       path: z.ZodType<string, string | undefined, z.core.$ZodTypeInternals<string, string | undefined>>;
       data: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"*">, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<"*">, z.ZodArray<z.ZodString>]>>]>>;
     }, z.core.$strip>;
-    readonly readOnly: false;
-    readonly label: "Unlink from";
-    readonly description: "Stop following a linked system's entities, in `link`'s shape or everything when `data` is omitted. The rows the declaration minted go with it, and so do the linked rows that point at them, since left linked they would bring them back; nothing of yours moves. A row of yours pointing at one of theirs refuses this — `copy` what is used first, or `break` with `keep: true`. `unlink-plan` names everything that goes.";
-    readonly scope: "item";
-    readonly approval: "reference-change";
-    readonly title: (entity: string) => string;
-    readonly example: typeof pinExample;
-    readonly handler: (input: Record<string, unknown>, config: Config) => Config;
   };
   readonly 'unlink-plan': {
     readonly input: z.ZodObject<{
       path: z.ZodType<string, string | undefined, z.core.$ZodTypeInternals<string, string | undefined>>;
       data: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"*">, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<"*">, z.ZodArray<z.ZodString>]>>]>>;
     }, z.core.$strip>;
-    readonly readOnly: true;
-    readonly label: "Plan an unlink";
-    readonly description: "What `unlink` with the same input removes — the minted rows the narrower declaration no longer reaches, with the linked rows taken along because they point at them named in `cascade` — and why the config would refuse it. Writes nothing.";
-    readonly scope: "item";
-    readonly title: (entity: string) => string;
-    readonly example: typeof pinExample;
-    readonly handler: (input: Record<string, unknown>, config: Config) => Omit<UnlinkPlan, "patches">;
   };
-  /**
-   * Break the link: the pin goes, and everything drawn through it either becomes this config's own
-   * or goes with it.
-   */
   readonly break: {
     readonly input: z.ZodObject<{
       path: z.ZodType<string, string | undefined, z.core.$ZodTypeInternals<string, string | undefined>>;
       keep: z.ZodBoolean;
     }, z.core.$strip>;
-    readonly readOnly: false;
-    readonly label: "Break link";
-    readonly description: "Remove a linked system. With `keep: true` every value drawn through it is copied in as your own first, and a row of yours that pointed through the pin points at the copies; with `keep: false` the rows it minted go, and a row of yours still pointing through it refuses the break. Run `linked-system/break-plan` first to see every row it reaches.";
-    readonly scope: "item";
-    readonly approval: "destructive";
-    readonly title: (entity: string) => string;
-    readonly example: typeof breakExample;
-    readonly handler: (input: Record<string, unknown>, config: Config) => Config;
   };
   readonly 'break-plan': {
     readonly input: z.ZodObject<{
@@ -224,57 +139,12 @@ declare const LinkedSystem: EntityClass<z.ZodObject<{
       keep: z.ZodOptional<z.ZodBoolean>;
       data: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"*">, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<"*">, z.ZodArray<z.ZodString>]>>]>>;
     }, z.core.$strip>;
-    readonly readOnly: true;
-    readonly label: "Plan a break";
-    readonly description: "Every row a break reaches, and why the config would refuse it. `keep` plans `break` with the same input; `data` in `copy`'s shape plans detaching those entities alone — the rows the copy lands, the rows of yours it points at the copies, and the rows still linked that reference what moves. Writes nothing.";
-    readonly scope: "item";
-    readonly title: (entity: string) => string;
-    readonly example: typeof breakExample;
-    readonly handler: (input: Record<string, unknown>, config: Config) => Omit<BreakPlan, "patches">;
   };
-  /**
-   * The source's catalogue read against this config: one row per top-level folder or item the
-   * source offers, saying whether it is linked here and what linking it would replace.
-   */
   readonly rows: {
     readonly input: z.ZodObject<{
       path: z.ZodType<string, string | undefined, z.core.$ZodTypeInternals<string, string | undefined>>;
     }, z.core.$strip>;
-    readonly readOnly: true;
-    readonly label: "Source rows";
-    readonly description: "Every top-level folder and item the linked system offers, read against this config: whether every member is linked through this pin, how many rows of yours a `link` would replace, and how many members are already here from the source's own origin. Needs the source attached; empty otherwise.";
-    readonly scope: "item";
-    readonly title: (entity: string) => string;
-    readonly example: typeof pinExample;
-    readonly handler: (input: Record<string, unknown>, config: Config) => SourceRowState[];
   };
-  /**
-   * Take entities from a linked system as this config's own — the source's bodies, written once.
-   * A pin puts a system within reach and its `link` mints pointers; `copy` stores the value. A copied
-   * row is an ordinary authored row from the moment it lands: the source's later versions never reach
-   * it, and it renames and deletes like anything else here.
-   *
-   * A copy stands on its own. What a copied row points at comes with it — a component brings the
-   * style properties and tokens it names, a style property brings the token folder its values
-   * range over, a code component brings the files its module reaches — and every one of those refs
-   * lands bare, on the local copy. A path this config already holds as its own is reused rather
-   * than copied, and refs bind to it. Only a ref to a kind this config can't hold stays qualified,
-   * and the pin survives to answer it. Someone who wants theirs by reference writes `Button@slug`
-   * instead.
-   *
-   * A pointer at the path, minted through this pin, becomes the literal it stood for with its
-   * `extend` laid over the source's body. A folder's meta comes with its members, so a label the
-   * folder was inheriting becomes its own.
-   *
-   * `data` is keyed the way the pin's `link` is: by accessor, then `'*'` for every entry of the kind
-   * or the source's paths — an item, or a folder, which takes its members. `'*'` alone takes every
-   * kind the source offers and this config can hold. Kinds taken in one edit are copied together,
-   * which is what lets a copied component point at the copied tokens rather than back through the
-   * pin.
-   *
-   * Every row lands in one derive (`Config.applyAll`), and each is its own `create` or `replace`
-   * patch carrying the literal body, so a draft replays a copy onto a base with nothing attached.
-   */
   readonly copy: {
     readonly input: z.ZodObject<{
       path: z.ZodType<string, string | undefined, z.core.$ZodTypeInternals<string, string | undefined>>;
@@ -284,22 +154,7 @@ declare const LinkedSystem: EntityClass<z.ZodObject<{
         skip: "skip";
       }>>;
     }, z.core.$strip>;
-    readonly readOnly: false;
-    readonly label: "Copy from";
-    readonly description: "Take entities from a linked system as your own, holding the values the source has now and no longer following it. `data` names them by accessor: `{ tokens: ['color/brand', 'color'] }` takes an entity and a folder's members, `{ tokens: '*' }` every token, and `'*'` the whole system. What a copied entity points at comes with it, so run `linked-system/copy-plan` with the same input first and see everything that lands. To use theirs without owning it, declare it in the pin's `link` instead. A whole-system copy is thousands of rows, and on a repo-backed system each one is written into `uds.config.ts`.";
-    readonly scope: "item";
-    readonly approval: "reference-change";
-    readonly title: (entity: string) => string;
-    readonly example: typeof copyExample;
-    readonly handler: (input: Record<string, unknown>, config: Config) => Config;
   };
-  /**
-   * What that same `copy` call would do, without doing it — the rows that land, what comes along
-   * because something named points at it, and the rows of yours a copied ref binds to instead.
-   *
-   * A read, taking `copy`'s own input verbatim, so a surface plans the invocation it is about to
-   * send. The op is this plan applied, so the two cannot disagree.
-   */
   readonly 'copy-plan': {
     readonly input: z.ZodObject<{
       path: z.ZodType<string, string | undefined, z.core.$ZodTypeInternals<string, string | undefined>>;
@@ -309,13 +164,6 @@ declare const LinkedSystem: EntityClass<z.ZodObject<{
         skip: "skip";
       }>>;
     }, z.core.$strip>;
-    readonly readOnly: true;
-    readonly label: "Plan a copy";
-    readonly description: "See what copying would bring before you do it — what lands as yours, what comes along because it is pointed at, and what you already hold that the copies will point at. Takes exactly the same input as `copy` and writes nothing. Run it before `copy`, and always before a `'*'` copy.";
-    readonly scope: "item";
-    readonly title: (entity: string) => string;
-    readonly example: typeof copyExample;
-    readonly handler: (input: Record<string, unknown>, config: Config) => Omit<CopyPlan, "patches">;
   };
 }, {
   /**
@@ -330,6 +178,8 @@ declare const LinkedSystem: EntityClass<z.ZodObject<{
     path
   }: ComputedInput) => string;
 }, false, Record<never, never>, Record<never, never>>;
+interface LinkedSystemClass extends Named<typeof LinkedSystemDefinition> {}
+declare const LinkedSystem: LinkedSystemClass;
 /**
  * What a pin's `options` may say, checked against the config type it is declared in — one record per
  * accessor, keyed by the path the source spells, valued by what this config does to it.
@@ -501,4 +351,4 @@ declare function suggestLinkSlug({
   taken: ReadonlySet<string>;
 }): string;
 //#endregion
-export { LINK_SLUG, LINK_SLUG_MESSAGE, LinkDeclaration, LinkedSystem, LinkedSystemResolver, LinkedSystemState, PinDirective, PinOptions, PinOptionsField, ResolvedSource, Source, SourceUnavailable, borrowedGroup, borrowedItem, isLinkSlug, resolvedSource, sourceOfGroup, sourceOfItem, sourceSlugFor, sourceUnavailable, suggestLinkSlug };
+export { LINK_SLUG, LINK_SLUG_MESSAGE, LinkDeclaration, LinkedSystem, LinkedSystemClass, LinkedSystemResolver, LinkedSystemState, PinDirective, PinOptions, PinOptionsField, ResolvedSource, Source, SourceUnavailable, borrowedGroup, borrowedItem, isLinkSlug, resolvedSource, sourceOfGroup, sourceOfItem, sourceSlugFor, sourceUnavailable, suggestLinkSlug };

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

@@ -1,7 +1,7 @@
-import { SubEntityClass } from "../../framework/defineSubEntity.js";
 import { EntityClass } from "../../framework/defineEntity.js";
+import { Named } from "../../framework/named.js";
 import { Config } from "../../framework/Config.js";
-import { StyleValue } from "./style-bag.js";
+import { CompositeClass } from "./Composite.js";
 import { z } from "zod";
 
 //#region src/entities/system/Modifier.d.ts
@@ -38,15 +38,13 @@ type ModifierGroupMeta = z.infer<typeof modifierGroupFields> & {
   label?: string;
   description?: string;
 };
-declare const Modifier: EntityClass<z.ZodObject<{
+declare const ModifierDefinition: EntityClass<z.ZodObject<{
   type: z.ZodEnum<{
     composite: "composite";
     selector: "selector";
     "media-query": "media-query";
   }>;
-  value: z.ZodUnion<readonly [z.ZodString, z.ZodLazy<EntityClass<z.ZodObject<{
-    styles: SubEntityClass<z.ZodType<StyleValue, unknown, z.core.$ZodTypeInternals<StyleValue, unknown>>>;
-  }, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "composite", Record<never, never>, Record<never, never>, false, Record<never, never>, Record<never, never>>>]>;
+  value: z.ZodUnion<readonly [z.ZodString, z.ZodLazy<CompositeClass>]>;
 }, z.core.$strip>, z.ZodObject<{
   type: z.ZodOptional<z.ZodEnum<{
     mode: "mode";
@@ -55,7 +53,9 @@ declare const Modifier: EntityClass<z.ZodObject<{
   default: z.ZodOptional<z.ZodObject<{
     __ref: z.ZodString;
   }, z.core.$strip>>;
-}, z.core.$strip>, "modifier", Record<never, never>, Record<never, never>, false, Record<never, never>, Record<never, never>>;
+}, z.core.$strip>, "modifier", {}, Record<never, never>, false, Record<never, never>, Record<never, never>>;
+interface ModifierClass extends Named<typeof ModifierDefinition> {}
+declare const Modifier: ModifierClass;
 /** A path's last segment. */
 declare function modifierLeaf(path: string): string;
 /**
@@ -89,4 +89,4 @@ declare function modeAxes(config: Config): {
  */
 declare function modifierInvariants(config: Config): string[];
 //#endregion
-export { MODIFIER_CATEGORIES, Modifier, ModifierCategory, ModifierGroupMeta, WEB_ACTIVATIONS, WebActivation, modeAxes, modifierAxes, modifierAxis, modifierCategory, modifierGroupFields, modifierInvariants, modifierLeaf };
+export { MODIFIER_CATEGORIES, Modifier, ModifierCategory, ModifierClass, ModifierGroupMeta, WEB_ACTIVATIONS, WebActivation, modeAxes, modifierAxes, modifierAxis, modifierCategory, modifierGroupFields, modifierInvariants, modifierLeaf };

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

@@ -1,8 +1,9 @@
 import { EntityClass } from "../../framework/defineEntity.js";
+import { Named } from "../../framework/named.js";
 import { z } from "zod";
 
 //#region src/entities/system/Motion.d.ts
-declare const Motion: EntityClass<z.ZodDiscriminatedUnion<[z.ZodObject<{
+declare const MotionDefinition: EntityClass<z.ZodDiscriminatedUnion<[z.ZodObject<{
   runtime: z.ZodLiteral<"css">;
   keyframes: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>;
   duration: z.ZodOptional<z.ZodString>;
@@ -23,6 +24,8 @@ declare const Motion: EntityClass<z.ZodDiscriminatedUnion<[z.ZodObject<{
   drag: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
   dragConstraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
   dragElastic: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strict>], "runtime">, z.ZodObject<Record<never, never>, z.core.$strip>, "motion", Record<never, never>, Record<never, never>, false, Record<never, never>, Record<never, never>>;
+}, z.core.$strict>], "runtime">, z.ZodObject<Record<never, never>, z.core.$strip>, "motion", {}, Record<never, never>, false, Record<never, never>, Record<never, never>>;
+interface MotionClass extends Named<typeof MotionDefinition> {}
+declare const Motion: MotionClass;
 //#endregion
-export { Motion };
+export { Motion, MotionClass };

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

@@ -1,10 +1,11 @@
 import { ComputedInput } from "../../framework/registry.js";
 import { DerivedEntityClass } from "../../framework/defineDerivedEntity.js";
+import { Named } from "../../framework/named.js";
 import { Config } from "../../framework/Config.js";
 import { z } from "zod";
 
 //#region src/entities/system/Operation.d.ts
-declare const Operation: DerivedEntityClass<z.ZodObject<{
+declare const OperationDefinition: DerivedEntityClass<z.ZodObject<{
   kind: z.ZodString;
   verb: z.ZodString;
   readOnly: z.ZodBoolean;
@@ -96,5 +97,7 @@ declare const Operation: DerivedEntityClass<z.ZodObject<{
     };
   }) => Record<string, unknown> | undefined;
 }>;
+interface OperationClass extends Named<typeof OperationDefinition> {}
+declare const Operation: OperationClass;
 //#endregion
-export { Operation };
+export { Operation, OperationClass };

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

@@ -1,8 +1,26 @@
 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/Package.d.ts
+/**
+ * One export a system renders through — `package:react-native#Pressable`.
+ *
+ * A member rather than an entity of its own, because a `/` cannot separate the module from the export
+ * and nothing else can either. `react-native/Pressable` reads as a module and an export only by the
+ * CONVENTION that the last segment is the export, and that convention has cases it gets wrong:
+ * `motion/react` is a module (`import { motion } from 'motion/react'`) but parses as `motion` plus an
+ * export called `react`, and `@phosphor-icons/core` — a catalogue named by an icon library's
+ * `metadata` and imported by nobody — parsed as a `core` export of `@phosphor-icons`. The grammar
+ * already has the separator that says which is which, so it is used.
+ *
+ * A member's fields are empty because its identity IS its name: there is nothing else this system
+ * knows to be true about somebody else's export. `default` for a default import, `Animated.View` for
+ * a dotted one — the name as the TARGET spells it, which is what an emitted import has to write.
+ */
+declare const PackageExportDefinition: SubEntityClass<z.ZodObject<{}, z.core.$strict>>;
+interface PackageExportClass extends Named<typeof PackageExportDefinition> {}
 /**
  * Package (`react-native`, `@ariakit/react`, `motion/react`) — one MODULE a system renders through.
  *
@@ -34,9 +52,11 @@ import { z } from "zod";
  * and build collection updates rather than replaces it, so that metadata survives. What authoring
  * cannot do is choose the path.
  */
-declare const Package: EntityClass<z.ZodObject<{
+declare const PackageDefinition: 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>>;
+  exports: z.ZodOptional<PackageExportClass>;
+}, z.core.$strict>, z.ZodObject<Record<never, never>, z.core.$strip>, "package", {}, Record<never, never>, false, Record<never, never>, Record<never, never>>;
+interface PackageClass extends Named<typeof PackageDefinition> {}
+declare const Package: PackageClass;
 //#endregion
-export { Package };
+export { Package, PackageClass };

package/dist/entities/system/Package.js

@@ -2,58 +2,12 @@ import { defineEntity } from "../../framework/defineEntity.js";
 import { defineSubEntity } from "../../framework/defineSubEntity.js";
 import { z } from "zod";
 //#region src/entities/system/Package.ts
-/**
-* One export a system renders through — `package:react-native#Pressable`.
-*
-* A member rather than an entity of its own, because a `/` cannot separate the module from the export
-* and nothing else can either. `react-native/Pressable` reads as a module and an export only by the
-* CONVENTION that the last segment is the export, and that convention has cases it gets wrong:
-* `motion/react` is a module (`import { motion } from 'motion/react'`) but parses as `motion` plus an
-* export called `react`, and `@phosphor-icons/core` — a catalogue named by an icon library's
-* `metadata` and imported by nobody — parsed as a `core` export of `@phosphor-icons`. The grammar
-* already has the separator that says which is which, so it is used.
-*
-* A member's fields are empty because its identity IS its name: there is nothing else this system
-* knows to be true about somebody else's export. `default` for a default import, `Animated.View` for
-* a dotted one — the name as the TARGET spells it, which is what an emitted import has to write.
-*/
 const PackageExport = defineSubEntity({
 	name: "exports",
 	label: "Export",
 	labelPlural: "Exports",
 	fields: z.strictObject({})
 });
-/**
-* Package (`react-native`, `@ariakit/react`, `motion/react`) — one MODULE a system renders through.
-*
-* **The path IS the specifier**, verbatim, subpath and all — the same choice `File` makes for its src.
-* So there is no `module` field: a second copy of the path could disagree with it, which is the
-* reason a `File` computes its `binary` rather than storing one.
-*
-* Verbatim matters because the stored form has to regenerate the import an author wrote. `motion` and
-* `motion/react` are ONE npm package and TWO modules; emitting `from 'motion'` for a source that
-* wrote `from 'motion/react'` names a different entry point that resolves to a different file. That
-* the two are one thing to INSTALL is a separate question, and the seal is the only place it is asked
-* — `packageName` collapses them there.
-*
-* A key derived from the module — a slug like `ariakit` — is what this replaced. The slug was
-* resolved over the whole import SET so two specifiers sharing a scope could both qualify away from
-* it, which made a key depend on what else happened to be imported: `@phosphor-icons/core` arriving
-* beside `@phosphor-icons/react` renamed the latter and stranded every ref that named it. npm has
-* already made a module name unique; nothing here has to.
-*
-* The same shape `Icon` uses for a glyph library, with one difference in where membership comes from.
-* An icon group lists every glyph the package exports, because a person picks one from a picker and
-* all of them are candidates. A package's exports are only what a render actually placed in JSX,
-* because nobody browses a component library's exports; the build registers them from JSX usage. The
-* MODULE set is broader: it records every external module the render closure needs, which is what
-* makes the portable config the source of truth for consumer install requirements.
-*
-* Ordinary component authoring does not maintain this graph: the build derives modules and exports
-* from the source it walked. A human may still author one — to carry a label, or to pin a `version` —
-* and build collection updates rather than replaces it, so that metadata survives. What authoring
-* cannot do is choose the path.
-*/
 const Package = defineEntity({
 	kind: "package",
 	label: "Package",

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

@@ -1,21 +1,26 @@
 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 { Config } from "../../framework/Config.js";
 import { z } from "zod";
 
 //#region src/entities/system/Settings.d.ts
 /** The `system` section — what this config is in Create. */
-declare const SystemSection: SubEntityClass<z.ZodObject<{
+declare const SystemSectionDefinition: SubEntityClass<z.ZodObject<{
   id: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>>;
+interface SystemSectionClass extends Named<typeof SystemSectionDefinition> {}
+declare const SystemSection: SystemSectionClass;
 /** The `build` section — where a repo keeps this system's sources, where `uds build` writes, and
  *  where linked systems are materialised. */
-declare const BuildSection: SubEntityClass<z.ZodObject<{
+declare const BuildSectionDefinition: SubEntityClass<z.ZodObject<{
   inputDir: z.ZodOptional<z.ZodString>;
   outDir: z.ZodOptional<z.ZodString>;
   registryDir: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>>;
+interface BuildSectionClass extends Named<typeof BuildSectionDefinition> {}
+declare const BuildSection: BuildSectionClass;
 /**
  * One prefix for both namespaces, or one each. A string names classes and variables alike; the object
  * names them apart, for a host page that already owns one of the two. Either form may be `''`, which
@@ -34,7 +39,7 @@ declare const CSS_DEFAULTS: {
 };
 /** The `css` section — how a web system names what it emits and where its stylesheet applies. A
  *  native system declares no such section, so a native config setting one is refused. */
-declare const CssSection: SubEntityClass<z.ZodObject<{
+declare const CssSectionDefinition: SubEntityClass<z.ZodObject<{
   prefix: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
     classNames: z.ZodString;
     variables: z.ZodString;
@@ -44,6 +49,8 @@ declare const CssSection: SubEntityClass<z.ZodObject<{
   rem: z.ZodOptional<z.ZodString>;
   safelist: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>>;
+interface CssSectionClass extends Named<typeof CssSectionDefinition> {}
+declare const CssSection: CssSectionClass;
 /** The two namespaces a prefix names, whichever form it was written in, defaulted when unset. */
 declare function cssPrefixes(value: CssPrefix | undefined): {
   classNames: string;
@@ -66,11 +73,13 @@ declare const PLAYGROUND_DEFAULTS: {
   readonly port: 4321;
 };
 /** The `playground` section — dev-server settings for `uds dev --playground`. */
-declare const PlaygroundSection: SubEntityClass<z.ZodObject<{
+declare const PlaygroundSectionDefinition: SubEntityClass<z.ZodObject<{
   pagesDir: z.ZodOptional<z.ZodString>;
   port: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>>;
-declare const Settings: EntityClass<z.ZodObject<{
+interface PlaygroundSectionClass extends Named<typeof PlaygroundSectionDefinition> {}
+declare const PlaygroundSection: PlaygroundSectionClass;
+declare const SettingsDefinition: EntityClass<z.ZodObject<{
   system: z.ZodOptional<z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
   }, z.core.$strict>>;
@@ -93,7 +102,7 @@ declare const Settings: EntityClass<z.ZodObject<{
     pagesDir: z.ZodOptional<z.ZodString>;
     port: z.ZodOptional<z.ZodNumber>;
   }, z.core.$strict>>;
-}, z.core.$strict>, z.ZodObject<Record<never, never>, z.core.$strip>, "settings", Record<never, never>, {
+}, z.core.$strict>, z.ZodObject<Record<never, never>, z.core.$strip>, "settings", {}, {
   /**
    * The directory this system's component files are laid out beneath, always defined:
    * `build.inputDir` when authored, else derived from where the files live. Every reader of the
@@ -104,5 +113,7 @@ declare const Settings: EntityClass<z.ZodObject<{
     config
   }: ComputedInput) => string;
 }, true, Record<never, never>, Record<never, never>>;
+interface SettingsClass extends Named<typeof SettingsDefinition> {}
+declare const Settings: SettingsClass;
 //#endregion
-export { BuildSection, CSS_DEFAULTS, CssPrefix, CssSection, PLAYGROUND_DEFAULTS, PlaygroundSection, Settings, SystemSection, classPrefixOf, cssPrefixes, varPrefixOf };
+export { BuildSection, BuildSectionClass, CSS_DEFAULTS, CssPrefix, CssSection, CssSectionClass, PLAYGROUND_DEFAULTS, PlaygroundSection, PlaygroundSectionClass, Settings, SettingsClass, SystemSection, SystemSectionClass, classPrefixOf, cssPrefixes, varPrefixOf };

package/dist/entities/system/Settings.js

@@ -38,15 +38,12 @@ id: z.string().uuid().meta({
 	title: "System ID",
 	description: "This system's id in Create. The default target for `uds push` and remote agent edits, and what lets a build refuse a link back to itself. `uds connect` records the repo binding on the server; this is the copy the repo carries."
 }).optional() });
-/** The `system` section — what this config is in Create. */
 const SystemSection = defineSubEntity({
 	name: "system",
 	label: "System",
 	singleton: true,
 	fields: systemFields
 });
-/** The `build` section — where a repo keeps this system's sources, where `uds build` writes, and
-*  where linked systems are materialised. */
 const BuildSection = defineSubEntity({
 	name: "build",
 	label: "Build",
@@ -102,8 +99,6 @@ const cssFields = z.strictObject({
 		description: "Classes the stylesheet always keeps, whether or not a scanned file names them, as in `uds-bg-brand`. For a class assembled at runtime, or one used by a file the build does not scan."
 	}).optional()
 });
-/** The `css` section — how a web system names what it emits and where its stylesheet applies. A
-*  native system declares no such section, so a native config setting one is refused. */
 const CssSection = defineSubEntity({
 	name: "css",
 	label: "CSS",
@@ -149,7 +144,6 @@ const playgroundFields = z.strictObject({
 		default: PLAYGROUND_DEFAULTS.port
 	}).optional()
 });
-/** The `playground` section — dev-server settings for `uds dev --playground`. */
 const PlaygroundSection = defineSubEntity({
 	name: "playground",
 	label: "Playground",

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

@@ -1,6 +1,7 @@
 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 { Named } from "../../framework/named.js";
 import { Config } from "../../framework/Config.js";
 import { z } from "zod";
 
@@ -97,13 +98,9 @@ declare function classifyStylePropValue({
   config: Config;
   entry: StylePropValue;
 }): StylePropValueKind;
-/**
- * `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<{
+/** 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<{
   properties: z.ZodArray<z.ZodString>;
   values: z.ZodOptional<z.ZodArray<z.ZodType<StylePropValue, unknown, z.core.$ZodTypeInternals<StylePropValue, unknown>>>>;
   responsive: z.ZodDefault<z.ZodBoolean>;
@@ -111,25 +108,15 @@ declare const StyleProperty: EntityClass<z.ZodObject<{
   arbitrary: z.ZodDefault<z.ZodBoolean>;
   negates: z.ZodDefault<z.ZodBoolean>;
   opacityOf: z.ZodOptional<z.ZodLazy<z.ZodType<Ref, unknown, z.core.$ZodTypeInternals<Ref, unknown>>>>;
-}, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "style-property", {
-  readonly rename: {
-    readonly to: z.ZodString;
-  };
-  readonly create: {
-    readonly path: z.ZodString;
-    readonly description: `Create a style property \u2014 the prop a component exposes for one CSS effect. \`path\` is the prop's JSX name, camelCase (\`borderRadius\`), never a CSS name; the CSS goes in \`properties\`. \`values\` is a ref to a token GROUP (\`${string}\`), which offers every token in it and keeps the prop in step with modes and edits; \`{ "alias": "brand", "value": ${string} }\` offers one token under a name of the prop's own; a literal (\`"row"\`, \`{ "alias": "full", "value": "9999px" }\`) is for a keyword the system has no token for. Restating a token's value as a literal instead of referencing it is refused.`;
-    readonly example: ({
-      config
-    }: {
-      config: Config;
-      kind: string;
-      path: string;
-    }) => {
-      path: string;
-      data: Record<string, unknown>;
-    } | undefined;
-  };
-}, Record<never, never>, false, Record<never, never>, Record<never, never>>;
+}, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "style-property", {}, Record<never, never>, false, Record<never, never>, Record<never, never>>;
+/**
+ * `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.
+ */
+interface StylePropertyClass extends Named<typeof StylePropertyEntity> {}
+declare const StyleProperty: StylePropertyClass;
 /** `flexDirection` → `flex-direction`. A name already spelled as CSS comes back unchanged. */
 declare function toCssPropertyName(property: string): string;
 /**
@@ -145,4 +132,4 @@ declare function cssPropertyNames(styleProp: {
   readonly properties: readonly string[];
 }): string[];
 //#endregion
-export { RefMember, STYLE_PROP_VALUE_FORMS, STYLE_PROP_VALUE_LEAVES, StylePropLeaf, StylePropValue, StylePropValueCtx, StylePropValueKind, StyleProperty, classifyStylePropValue, cssPropertyNames, leavesOfStylePropValue, stylePropValueFormOf, stylePropValueSchema, toCssPropertyName };
+export { RefMember, STYLE_PROP_VALUE_FORMS, STYLE_PROP_VALUE_LEAVES, StylePropLeaf, StylePropValue, StylePropValueCtx, StylePropValueKind, StyleProperty, StylePropertyClass, classifyStylePropValue, cssPropertyNames, leavesOfStylePropValue, stylePropValueFormOf, stylePropValueSchema, toCssPropertyName };

package/dist/entities/system/StyleProperty.js

@@ -417,12 +417,6 @@ function freePath(config, path) {
 	for (let n = 2; config.resolve("style-property", candidate); n += 1) candidate = `${path}${n}`;
 	return candidate;
 }
-/**
-* `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",