@yahoo/uds-create-config 4.36.0 → 4.36.1

package/dist/configs/system.js

@@ -42,15 +42,6 @@ import { renderTokenRefsMigration } from "../migrations/20260923160425_render_to
 import { globalStyleDerivedColorsMigration } from "../migrations/20260923163604_global_style_derived_colors.js";
 import { slotCodeFormsMigration } from "../migrations/20260924044539_slot_code_forms.js";
 import { canvasRoleSlotMigration } from "../migrations/20260925143319_canvas_role_slot.js";
-//#region src/configs/system.ts
-/**
-* `System` — the design-system config TYPE. Declares the exact kinds a design system owns (tokens,
-* components, …) plus its derived agent-tool catalog (`operation`/`tool`). `new System()` seeds a
-* config with those kinds; `System.fromJSON(json)` rehydrates one — it declares no borrowed KINDS, so nothing is required, though a
-* caller holding a linked system's config attaches it here (`{ sources: { linkedSystems: { ds } } }`). This is the
-* config every CLI / pipeline / studio consumer reads. Studio's design-file config type lives in
-* studio (`apps/studio/src/configs/design-file.ts`) — a studio-only document type.
-*/
 const System = defineConfig({
 	name: WEB_CONFIG_NAME,
 	description: "A design system: the values, primitives and compositions an app is built from. A ref is written `{ \"__ref\": \"<kind>:<path>\" }`, so a token is `{ \"__ref\": \"token:<group>/<name>\" }` and a token group is `{ \"__ref\": \"token:<group>\" }`. Build it in this order. Tokens first, in groups by purpose (colors, spacing, radii, type sizes), since everything else names them. Then style properties, each with `values` holding one ref to the token group whose members it accepts (`{ \"__ref\": \"token:color\" }`), so a prop takes token names rather than raw CSS; add a string keyword only for a value no token holds. A style rule's bag holds a prop's values (`\"padding\": \"4\"`, `\"bg\": \"brand\"`), never raw CSS. Then a few primitive components, one layer each, whose props are style properties (a box for layout and surface, a text for type, a pressable for interaction). Then every other component composed from those primitives: its layers name a primitive or an element, its anatomy places them (a node renders a layer, a tag or `Slot` where a slot prop's content lands; `children` is the edge list; `visible` is `{ \"$state\": \"<prop>\" }`; a prop shown in a nested layer is a `forward` route, and `$state` never sits in a node's props), and its style rules set style-property values per layer, keyed by prop values when a variant changes them. Modes (a dark mode is `{ type: \"selector\", value: \".dark\" }`) change token values through a token's `overrides`, so a component never restyles for a mode; modifiers (hover, focus, disabled) name a state, and a style rule applies under one as a `_hover` block inside a layer bag. Composites bundle style values that recur. Last, register canvas roles: the canvas draws with them, one entity per tool (`frame` for the layout primitive, `text` for the text primitive, `image`) whose entries name the components that tool inserts, and a tool whose role is unregistered is disabled. Give each component a `preview` entry under `*` so it shows content, and never write a CSS property name where a style-property name belongs.",

package/dist/entities/documentation/Documentation.d.ts

@@ -1,10 +1,10 @@
 import { EntityClass } from "../../framework/defineEntity.js";
-import { Config } from "../../framework/Config.js";
+import { Named } from "../../framework/named.js";
 import { z } from "zod";
 
 //#region src/entities/documentation/Documentation.d.ts
 /** Knowledge Base articles are shared independently of a user's system. */
-declare const Documentation: EntityClass<z.ZodObject<{
+declare const DocumentationDefinition: EntityClass<z.ZodObject<{
   title: z.ZodString;
   summary: z.ZodOptional<z.ZodString>;
   markdown: z.ZodString;
@@ -23,22 +23,9 @@ declare const Documentation: EntityClass<z.ZodObject<{
     readonly input: z.ZodObject<{
       query: z.ZodDefault<z.ZodString>;
     }, z.core.$strip>;
-    readonly readOnly: true;
-    readonly label: "Search";
-    readonly description: "Find articles by text in their path, title, summary, or Markdown. An empty query browses all articles. Returns metadata without article bodies; use get to read an article.";
-    readonly scope: "collection";
-    readonly example: () => {
-      query: string;
-    };
-    readonly handler: (input: Record<string, unknown>, config: Config) => {
-      path: string;
-      title: string;
-      summary: string | undefined;
-      category: string;
-      products: ("create" | "uds")[];
-      platform: "mobile" | "web" | undefined;
-    }[];
   };
 }, Record<never, never>, false, Record<never, never>, Record<never, never>>;
+interface DocumentationClass extends Named<typeof DocumentationDefinition> {}
+declare const Documentation: DocumentationClass;
 //#endregion
-export { Documentation };
+export { Documentation, DocumentationClass };

package/dist/entities/documentation/Documentation.js

@@ -10,7 +10,6 @@ const documentationFields = z.strictObject({
 	products: z.array(z.enum(["uds", "create"])).min(1).describe("The products this article explains."),
 	platform: z.enum(["web", "mobile"]).optional()
 });
-/** Knowledge Base articles are shared independently of a user's system. */
 const Documentation = defineEntity({
 	kind: "documentation",
 	label: "Documentation",

package/dist/entities/native/NativeModifier.d.ts

@@ -1,10 +1,11 @@
 import { EntityClass } from "../../framework/defineEntity.js";
+import { Named } from "../../framework/named.js";
 import { z } from "zod";
 
 //#region src/entities/native/NativeModifier.d.ts
 declare const NATIVE_ACTIVATIONS: readonly ["appearance", "min-width", "operating-system", "state"];
 type NativeActivation = (typeof NATIVE_ACTIVATIONS)[number];
-declare const NativeModifier: EntityClass<z.ZodObject<{
+declare const NativeModifierDefinition: EntityClass<z.ZodObject<{
   type: z.ZodEnum<{
     appearance: "appearance";
     "min-width": "min-width";
@@ -20,6 +21,8 @@ declare const NativeModifier: 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 NativeModifierClass extends Named<typeof NativeModifierDefinition> {}
+declare const NativeModifier: NativeModifierClass;
 //#endregion
-export { NATIVE_ACTIVATIONS, NativeActivation, NativeModifier };
+export { NATIVE_ACTIVATIONS, NativeActivation, NativeModifier, NativeModifierClass };

package/dist/entities/native/NativeSettings.d.ts

@@ -1,13 +1,16 @@
 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/native/NativeSettings.d.ts
 /** The `canvas` section — how the browser canvas renders a native system. */
-declare const CanvasSection: SubEntityClass<z.ZodObject<{
+declare const CanvasSectionDefinition: SubEntityClass<z.ZodObject<{
   packageAliases: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
 }, z.core.$strict>>;
+interface CanvasSectionClass extends Named<typeof CanvasSectionDefinition> {}
+declare const CanvasSection: CanvasSectionClass;
 /**
  * `NativeSettings` — the settings of a `ReactNativeSystem`. The same kind as `Settings`, so a reader
  * asks `Settings.get(config)` on either; the shape differs: no `css` and no `playground`, since a
@@ -41,11 +44,11 @@ declare const NativeSettings: EntityClass<z.ZodObject<Omit<{
   canvas: z.ZodOptional<z.ZodObject<{
     packageAliases: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
   }, z.core.$strict>>;
-}, z.core.$strip>, z.ZodObject<Omit<Record<never, never>, never> & {}, z.core.$strip>, "settings", Record<never, never>, {
+}, z.core.$strip>, z.ZodObject<Omit<Record<never, never>, never> & {}, z.core.$strip>, "settings", {}, {
   readonly inputDir: ({
     member,
     config
   }: ComputedInput) => string;
 }, true, Record<never, never>, Record<never, never>>;
 //#endregion
-export { CanvasSection, NativeSettings };
+export { CanvasSection, CanvasSectionClass, NativeSettings };

package/dist/entities/native/NativeSettings.js

@@ -9,7 +9,6 @@ packageAliases: z.record(z.string(), z.string()).meta({
 	title: "Package aliases",
 	description: "Packages the browser canvas swaps for a local module, by package name. Paths resolve from the config directory. Phone and app builds keep the real package."
 }).optional() });
-/** The `canvas` section — how the browser canvas renders a native system. */
 const CanvasSection = defineSubEntity({
 	name: "canvas",
 	label: "Canvas",

package/dist/entities/native/NativeStyleProperty.d.ts

@@ -1,6 +1,5 @@
 import { Ref } from "../../framework/utils/ref-grammar.js";
 import { EntityClass } from "../../framework/defineEntity.js";
-import { Config } from "../../framework/Config.js";
 import { StylePropValue } from "../system/StyleProperty.js";
 import { z } from "zod";
 
@@ -332,24 +331,6 @@ declare const NativeStyleProperty: EntityClass<z.ZodObject<Omit<{
     zIndex: "zIndex";
   }>>>;
   values: z.ZodOptional<z.ZodArray<z.ZodType<StylePropValue, unknown, z.core.$ZodTypeInternals<StylePropValue, unknown>>>>;
-}, z.core.$strip>, z.ZodObject<Omit<Record<never, 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<Omit<Record<never, never>, never> & {}, z.core.$strip>, "style-property", {}, Record<never, never>, false, Record<never, never>, Record<never, never>>;
 //#endregion
 export { NativeStyleProperty, rnStyleKey };

package/dist/entities/native/NativeToken.d.ts

@@ -2,8 +2,8 @@ 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 } from "../system/color.js";
 import { ComposedValue } from "../system/composed-values.js";
+import { DerivedColor } from "../system/color.js";
 import { OverrideCondition } from "../system/Token.js";
 import { z } from "zod";
 
@@ -24,10 +24,6 @@ declare const NativeToken: EntityClass<z.ZodObject<Omit<{
   }, z.core.$strip>>>;
 }, z.core.$strip>, z.ZodObject<Omit<{
   cssPrefix: z.ZodOptional<z.ZodString>;
-}, "cssPrefix"> & {}, z.core.$strip>, "token", {
-  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>, Record<never, never>>;
+}, "cssPrefix"> & {}, z.core.$strip>, "token", {}, Record<never, never>, false, Record<never, never>, Record<never, never>>;
 //#endregion
 export { NativeToken, nativeTokenValue };

package/dist/entities/system/CanvasRole.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/CanvasRole.d.ts
@@ -12,7 +13,7 @@ import { z } from "zod";
  */
 declare const CANVAS_ROLES: readonly ["frame", "text", "image", "icon", "slot"];
 type CanvasRoleName = (typeof CANVAS_ROLES)[number];
-declare const CanvasRole: EntityClass<z.ZodObject<{
+declare const CanvasRoleDefinition: EntityClass<z.ZodObject<{
   entries: z.ZodArray<z.ZodObject<{
     component: z.ZodObject<{
       __ref: z.ZodString;
@@ -24,10 +25,8 @@ declare const CanvasRole: EntityClass<z.ZodObject<{
       axes: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>;
   }, z.core.$strip>>;
-}, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "canvas-role", {
-  readonly create: {
-    readonly description: `Register a canvas insert tool for this system. \`path\` is the role, one of ${string}; \`data.entries\` names the components that tool inserts, one marked \`default\`. A system whose roles are unregistered has those canvas tools disabled, so register \`frame\` and \`text\` once a layout primitive and a text primitive exist.`;
-  };
-}, Record<never, never>, false, Record<never, never>, Record<never, never>>;
+}, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "canvas-role", {}, Record<never, never>, false, Record<never, never>, Record<never, never>>;
+interface CanvasRoleClass extends Named<typeof CanvasRoleDefinition> {}
+declare const CanvasRole: CanvasRoleClass;
 //#endregion
-export { CANVAS_ROLES, CanvasRole, CanvasRoleName };
+export { CANVAS_ROLES, CanvasRole, CanvasRoleClass, CanvasRoleName };