@yahoo/uds-create-config 2.45.0 → 3.0.0

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

@@ -0,0 +1,1287 @@
+import { ExtendedRef, Ref } from "../../framework/utils/refs.js";
+import { SubEntityClass } from "../../framework/defineSubEntity.js";
+import { ComponentContractOf, PathOf } from "../../framework/registered.js";
+import { EntityClass } from "../../framework/defineEntity.js";
+import { Config } from "../../framework/Config.js";
+import { ComputedInput } from "../../framework/registry.js";
+import { StyleValue } from "./style-bag.js";
+import { ComponentPropsOf, LayerMap, PropMap, RenderArgs, StyleRuleInput } from "./defineComponent.js";
+import { z } from "zod";
+
+//#region src/entities/system/Component.d.ts
+/** A component-relative reference to one of the enclosing component's own layers — a slot's
+ *  `target`. Relative (no component path) because a slot only ever targets a sibling layer, so a
+ *  Component rename can't break it; a layer rename cascades through it. */
+declare function layerRef(layerKey: string): Ref;
+/**
+ * A component-relative reference to one value of one of the enclosing component's own variant
+ * props — what a style rule conditions on.
+ *
+ * Relative for the same reason {@link layerRef} is: a value only ever belongs to a sibling prop, so
+ * a component rename can't break it. What it buys is the other direction — a value rename is an
+ * ordinary ref rewrite, and because a rule's key is derived from its condition, the rules holding it
+ * re-key themselves. Without the ref the name sits in a plain string, invisible to that rewrite, and
+ * every rule conditioned on the old name silently stops applying.
+ */
+declare function valueRef(prop: string, value: string): Ref;
+/** The prop names one entry exposes — `null` when the config can't say (an unresolved element). */
+declare function forwardedNames(config: Config, element: unknown, entry: unknown): string[] | null;
+/**
+ * One value a variant prop offers — the keyed collection under its `value`.
+ *
+ * Keyed rather than a list of names, for the three things a bare string can't be: it can't be
+ * reordered without rewriting every other value beside it, it can't carry what to call it in a
+ * picker, and it can't be renamed by the ordinary cascade — which is what a keyed collection gets
+ * from the framework, the same one `layers` and `props` are.
+ */
+declare const variantValueFields: z.ZodObject<{
+  label: z.ZodOptional<z.ZodString>;
+  description: z.ZodOptional<z.ZodString>;
+  deprecated: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+/** One variant value's body, as stored. */
+type VariantValueBody = z.infer<typeof variantValueFields>;
+/** A variant prop's own values — name → body, in the order they were declared. */
+type VariantValues = Record<string, VariantValueBody>;
+declare const propShape: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  type: z.ZodLiteral<"slot">;
+  text: z.ZodOptional<z.ZodBoolean>;
+  accepts: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+    __ref: z.ZodString;
+  }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+    __ref: z.ZodString;
+  }, z.core.$strip>>]>>;
+  required: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>, z.ZodObject<{
+  type: z.ZodLiteral<"variant">;
+  value: z.ZodUnion<readonly [z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<{
+    [k: string]: {};
+  }, string[]>>, z.ZodObject<{
+    __ref: z.ZodString;
+  }, z.core.$strip>, SubEntityClass<z.ZodObject<{
+    label: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strict>>]>;
+  required: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>, z.ZodPipe<z.ZodObject<{
+  type: z.ZodLiteral<"forward">;
+  target: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    __ref: z.ZodString;
+  }, z.core.$strip>]>;
+  into: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    __ref: z.ZodString;
+  }, z.core.$strip>]>>;
+  accepts: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+    __ref: z.ZodString;
+  }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+    __ref: z.ZodString;
+  }, z.core.$strip>>]>>;
+  text: z.ZodOptional<z.ZodBoolean>;
+  required: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>, z.ZodTransform<{
+  type: "forward";
+  target: string | {
+    __ref: string;
+  };
+  into?: string | {
+    __ref: string;
+  } | undefined;
+  accepts?: {
+    __ref: string;
+  } | {
+    __ref: string;
+  }[] | undefined;
+  text?: boolean | undefined;
+  required?: boolean | undefined;
+}, {
+  type: "forward";
+  target: string | {
+    __ref: string;
+  };
+  into?: string | {
+    __ref: string;
+  } | undefined;
+  accepts?: {
+    __ref: string;
+  } | {
+    __ref: string;
+  }[] | undefined;
+  text?: boolean | undefined;
+  required?: boolean | undefined;
+}>>, z.ZodObject<{
+  type: z.ZodLiteral<"styleProperty">;
+  value: z.ZodObject<{
+    __ref: z.ZodString;
+  }, z.core.$strip>;
+}, z.core.$strict>, z.ZodObject<{
+  type: z.ZodLiteral<"composite">;
+  value: z.ZodObject<{
+    __ref: z.ZodString;
+  }, z.core.$strip>;
+}, z.core.$strict>, z.ZodObject<{
+  type: z.ZodLiteral<"motion">;
+  value: z.ZodDefault<z.ZodObject<{
+    __ref: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strict>, z.ZodObject<{
+  type: z.ZodLiteral<"string">;
+  value: z.ZodOptional<z.ZodString>;
+  required: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>, z.ZodObject<{
+  type: z.ZodLiteral<"number">;
+  value: z.ZodOptional<z.ZodNumber>;
+  required: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>, z.ZodObject<{
+  type: z.ZodLiteral<"boolean">;
+  value: z.ZodOptional<z.ZodBoolean>;
+  required: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>], "type">;
+/** 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. */
+/** One prop as stored — the discriminated declaration, or `null` (the omit tombstone). */
+type ComponentPropBody = z.infer<typeof propShape> | null;
+/** One prop as accepted — what may be written, before the schema's coercions. The two differ by
+ *  design (a variant's values are authored as a list and stored as a collection), which is why the
+ *  authoring types name this one rather than restating either. */
+type AuthoredPropBody = z.input<typeof propShape>;
+/** A rule's identity is its condition, as a canonical query string (`*`, `size=xs`,
+ *  `size=xs&variant=tertiary`) — sorted, so the same condition always yields the same key however
+ *  the editor collected it. */
+declare function canonicalWhen(when: unknown): string;
+/**
+ * Whether a prop's values belong to this component — an enumerated variant, whose values exist
+ * nowhere else and so have no identity until one is given here.
+ *
+ * A variant that delegates its domain to a ref (an icon prop drawing on the icon library) names
+ * values another entity already owns; those rename through their owner's own cascade, and minting a
+ * Component-relative identity for them would be a second name for the same thing.
+ */
+declare function ownsItsValues(declaration: unknown): boolean;
+/** The values a variant prop declares, in order — empty for one that delegates its domain. */
+declare function ownValues(declaration: unknown): string[];
+/** One style rule as stored: the condition it applies under (`null` = unconditional), and the bag
+ *  it applies to each layer. The per-owner factory below narrows both far past this — which props
+ *  may be named, which layers may be targeted — but every reader sees these two fields, so they're
+ *  what the collection's member type states. */
+interface ComponentStyleBody {
+  when?: Record<string, unknown> | null;
+  /** Layer name → its bag. Each bag's keys are narrowed per owner (only props that layer's element
+   *  exposes), which no single static type can state — so the bag stays open here. */
+  layers?: Record<string, Record<string, unknown> | undefined>;
+}
+declare const visibility: z.ZodUnion<readonly [z.ZodPipe<z.ZodObject<{
+  not: z.ZodOptional<z.ZodLiteral<true>>;
+  eq: z.ZodOptional<z.ZodUnknown>;
+  neq: z.ZodOptional<z.ZodUnknown>;
+  gt: z.ZodOptional<z.ZodNumber>;
+  gte: z.ZodOptional<z.ZodNumber>;
+  lt: z.ZodOptional<z.ZodNumber>;
+  lte: z.ZodOptional<z.ZodNumber>;
+  $state: z.ZodString;
+}, z.core.$strict>, z.ZodTransform<{
+  $state: string;
+  not?: true | undefined;
+  eq?: unknown;
+  neq?: unknown;
+  gt?: number | undefined;
+  gte?: number | undefined;
+  lt?: number | undefined;
+  lte?: number | undefined;
+}, {
+  $state: string;
+  not?: true | undefined;
+  eq?: unknown;
+  neq?: unknown;
+  gt?: number | undefined;
+  gte?: number | undefined;
+  lt?: number | undefined;
+  lte?: number | undefined;
+}>>, z.ZodObject<{
+  $or: z.ZodArray<z.ZodPipe<z.ZodObject<{
+    not: z.ZodOptional<z.ZodLiteral<true>>;
+    eq: z.ZodOptional<z.ZodUnknown>;
+    neq: z.ZodOptional<z.ZodUnknown>;
+    gt: z.ZodOptional<z.ZodNumber>;
+    gte: z.ZodOptional<z.ZodNumber>;
+    lt: z.ZodOptional<z.ZodNumber>;
+    lte: z.ZodOptional<z.ZodNumber>;
+    $state: z.ZodString;
+  }, z.core.$strict>, z.ZodTransform<{
+    $state: string;
+    not?: true | undefined;
+    eq?: unknown;
+    neq?: unknown;
+    gt?: number | undefined;
+    gte?: number | undefined;
+    lt?: number | undefined;
+    lte?: number | undefined;
+  }, {
+    $state: string;
+    not?: true | undefined;
+    eq?: unknown;
+    neq?: unknown;
+    gt?: number | undefined;
+    gte?: number | undefined;
+    lt?: number | undefined;
+    lte?: number | undefined;
+  }>>>;
+}, z.core.$strict>, z.ZodArray<z.ZodUnion<readonly [z.ZodPipe<z.ZodObject<{
+  not: z.ZodOptional<z.ZodLiteral<true>>;
+  eq: z.ZodOptional<z.ZodUnknown>;
+  neq: z.ZodOptional<z.ZodUnknown>;
+  gt: z.ZodOptional<z.ZodNumber>;
+  gte: z.ZodOptional<z.ZodNumber>;
+  lt: z.ZodOptional<z.ZodNumber>;
+  lte: z.ZodOptional<z.ZodNumber>;
+  $state: z.ZodString;
+}, z.core.$strict>, z.ZodTransform<{
+  $state: string;
+  not?: true | undefined;
+  eq?: unknown;
+  neq?: unknown;
+  gt?: number | undefined;
+  gte?: number | undefined;
+  lt?: number | undefined;
+  lte?: number | undefined;
+}, {
+  $state: string;
+  not?: true | undefined;
+  eq?: unknown;
+  neq?: unknown;
+  gt?: number | undefined;
+  gte?: number | undefined;
+  lt?: number | undefined;
+  lte?: number | undefined;
+}>>, z.ZodObject<{
+  $or: z.ZodArray<z.ZodPipe<z.ZodObject<{
+    not: z.ZodOptional<z.ZodLiteral<true>>;
+    eq: z.ZodOptional<z.ZodUnknown>;
+    neq: z.ZodOptional<z.ZodUnknown>;
+    gt: z.ZodOptional<z.ZodNumber>;
+    gte: z.ZodOptional<z.ZodNumber>;
+    lt: z.ZodOptional<z.ZodNumber>;
+    lte: z.ZodOptional<z.ZodNumber>;
+    $state: z.ZodString;
+  }, z.core.$strict>, z.ZodTransform<{
+    $state: string;
+    not?: true | undefined;
+    eq?: unknown;
+    neq?: unknown;
+    gt?: number | undefined;
+    gte?: number | undefined;
+    lt?: number | undefined;
+    lte?: number | undefined;
+  }, {
+    $state: string;
+    not?: true | undefined;
+    eq?: unknown;
+    neq?: unknown;
+    gt?: number | undefined;
+    gte?: number | undefined;
+    lt?: number | undefined;
+    lte?: number | undefined;
+  }>>>;
+}, z.core.$strict>]>>, z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{
+  __ref: z.ZodString;
+}, z.core.$strip>]>>, z.ZodTransform<{
+  $state: string;
+  eq?: unknown;
+} | {
+  $state: string;
+  eq?: unknown;
+}[], Record<string, string | number | boolean | {
+  __ref: string;
+}>>>]>;
+/** A stored `visible` condition — json-render's grammar as the entity narrows it, with a flat
+ *  `{ prop: value }` already compiled to its `$state` form and every `$state` a JSON pointer. */
+type ElementVisibility = z.infer<typeof visibility>;
+/** A `visible` condition as a surface writes it: the flat `{ prop: value }` form included, and
+ *  `$state` accepted with or without its slash. */
+type ElementVisibilityInput = z.input<typeof visibility>;
+/** A `visible` condition on a projected element: the stored condition, or the boolean
+ *  `specWithResolvedVisibility` bakes it to once a coordinate settles it. */
+type ProjectedVisibility = ElementVisibility | boolean;
+/** One anatomy node as stored: what it renders, what nests inside it, and the props/text baked
+ *  onto it. The per-owner factory narrows `children` to this component's own node names and checks
+ *  the target's children policy; these are the fields every reader sees. */
+interface ComponentElementBody {
+  element?: unknown;
+  children?: string[];
+  /** Slot fills, in json-render's native grammar: slot prop name → the node keys that fill it.
+   *  A slotted node nests in render without a `children` edge, exactly like the spec form. */
+  slots?: Record<string, string[]>;
+  visible?: ElementVisibility;
+  props?: Record<string, unknown>;
+  text?: string;
+}
+declare const componentFields: z.ZodObject<{
+  layers: SubEntityClass<z.ZodUnion<readonly [z.ZodString, z.ZodLazy<z.ZodType<Ref, unknown, z.core.$ZodTypeInternals<Ref, unknown>>>, 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>]>>;
+  props: z.ZodOptional<SubEntityClass<z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"slot">;
+    text: z.ZodOptional<z.ZodBoolean>;
+    accepts: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+      __ref: z.ZodString;
+    }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+      __ref: z.ZodString;
+    }, z.core.$strip>>]>>;
+    required: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"variant">;
+    value: z.ZodUnion<readonly [z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<{
+      [k: string]: {};
+    }, string[]>>, z.ZodObject<{
+      __ref: z.ZodString;
+    }, z.core.$strip>, SubEntityClass<z.ZodObject<{
+      label: z.ZodOptional<z.ZodString>;
+      description: z.ZodOptional<z.ZodString>;
+      deprecated: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>]>;
+    required: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strict>, z.ZodPipe<z.ZodObject<{
+    type: z.ZodLiteral<"forward">;
+    target: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+      __ref: z.ZodString;
+    }, z.core.$strip>]>;
+    into: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+      __ref: z.ZodString;
+    }, z.core.$strip>]>>;
+    accepts: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+      __ref: z.ZodString;
+    }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+      __ref: z.ZodString;
+    }, z.core.$strip>>]>>;
+    text: z.ZodOptional<z.ZodBoolean>;
+    required: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strict>, z.ZodTransform<{
+    type: "forward";
+    target: string | {
+      __ref: string;
+    };
+    into?: string | {
+      __ref: string;
+    } | undefined;
+    accepts?: {
+      __ref: string;
+    } | {
+      __ref: string;
+    }[] | undefined;
+    text?: boolean | undefined;
+    required?: boolean | undefined;
+  }, {
+    type: "forward";
+    target: string | {
+      __ref: string;
+    };
+    into?: string | {
+      __ref: string;
+    } | undefined;
+    accepts?: {
+      __ref: string;
+    } | {
+      __ref: string;
+    }[] | undefined;
+    text?: boolean | undefined;
+    required?: boolean | undefined;
+  }>>, z.ZodObject<{
+    type: z.ZodLiteral<"styleProperty">;
+    value: z.ZodObject<{
+      __ref: z.ZodString;
+    }, z.core.$strip>;
+  }, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"composite">;
+    value: z.ZodObject<{
+      __ref: z.ZodString;
+    }, z.core.$strip>;
+  }, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"motion">;
+    value: z.ZodDefault<z.ZodObject<{
+      __ref: z.ZodString;
+    }, z.core.$strip>>;
+  }, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"string">;
+    value: z.ZodOptional<z.ZodString>;
+    required: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"number">;
+    value: z.ZodOptional<z.ZodNumber>;
+    required: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"boolean">;
+    value: z.ZodOptional<z.ZodBoolean>;
+    required: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strict>], "type">>>>;
+  forwards: z.ZodOptional<SubEntityClass<z.ZodUnion<readonly [z.ZodLiteral<"*">, z.ZodArray<z.ZodObject<{
+    __ref: z.ZodString;
+  }, z.core.$strip>>]>>>;
+  styles: z.ZodOptional<SubEntityClass<z.ZodType<ComponentStyleBody, unknown, z.core.$ZodTypeInternals<ComponentStyleBody, unknown>>>>;
+  anatomy: z.ZodOptional<SubEntityClass<z.ZodType<ComponentElementBody, unknown, z.core.$ZodTypeInternals<ComponentElementBody, unknown>>>>;
+  defaultProps: z.ZodOptional<SubEntityClass<z.ZodType<StyleValue, unknown, z.core.$ZodTypeInternals<StyleValue, unknown>>>>;
+  previewProps: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  file: z.ZodOptional<z.ZodObject<{
+    __ref: z.ZodString;
+  }, z.core.$strip>>;
+  export: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * A component's stored body — every field, typed off the schema above.
+ *
+ * The type a reader names when it holds a component's fields (`Component.get(config, path)` returns
+ * an `Entity &` this). Inferred rather than restated so it can't drift from what the entity accepts:
+ * a surface that needs a field the schema doesn't declare is a gap in the schema, not a cast.
+ */
+type ComponentBody = z.infer<typeof componentFields>;
+declare const ComponentEntity: EntityClass<z.ZodObject<{
+  layers: SubEntityClass<z.ZodUnion<readonly [z.ZodString, z.ZodLazy<z.ZodType<Ref, unknown, z.core.$ZodTypeInternals<Ref, unknown>>>, 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>]>>;
+  props: z.ZodOptional<SubEntityClass<z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"slot">;
+    text: z.ZodOptional<z.ZodBoolean>;
+    accepts: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+      __ref: z.ZodString;
+    }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+      __ref: z.ZodString;
+    }, z.core.$strip>>]>>;
+    required: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"variant">;
+    value: z.ZodUnion<readonly [z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<{
+      [k: string]: {};
+    }, string[]>>, z.ZodObject<{
+      __ref: z.ZodString;
+    }, z.core.$strip>, SubEntityClass<z.ZodObject<{
+      label: z.ZodOptional<z.ZodString>;
+      description: z.ZodOptional<z.ZodString>;
+      deprecated: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>]>;
+    required: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strict>, z.ZodPipe<z.ZodObject<{
+    type: z.ZodLiteral<"forward">;
+    target: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+      __ref: z.ZodString;
+    }, z.core.$strip>]>;
+    into: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+      __ref: z.ZodString;
+    }, z.core.$strip>]>>;
+    accepts: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+      __ref: z.ZodString;
+    }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+      __ref: z.ZodString;
+    }, z.core.$strip>>]>>;
+    text: z.ZodOptional<z.ZodBoolean>;
+    required: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strict>, z.ZodTransform<{
+    type: "forward";
+    target: string | {
+      __ref: string;
+    };
+    into?: string | {
+      __ref: string;
+    } | undefined;
+    accepts?: {
+      __ref: string;
+    } | {
+      __ref: string;
+    }[] | undefined;
+    text?: boolean | undefined;
+    required?: boolean | undefined;
+  }, {
+    type: "forward";
+    target: string | {
+      __ref: string;
+    };
+    into?: string | {
+      __ref: string;
+    } | undefined;
+    accepts?: {
+      __ref: string;
+    } | {
+      __ref: string;
+    }[] | undefined;
+    text?: boolean | undefined;
+    required?: boolean | undefined;
+  }>>, z.ZodObject<{
+    type: z.ZodLiteral<"styleProperty">;
+    value: z.ZodObject<{
+      __ref: z.ZodString;
+    }, z.core.$strip>;
+  }, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"composite">;
+    value: z.ZodObject<{
+      __ref: z.ZodString;
+    }, z.core.$strip>;
+  }, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"motion">;
+    value: z.ZodDefault<z.ZodObject<{
+      __ref: z.ZodString;
+    }, z.core.$strip>>;
+  }, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"string">;
+    value: z.ZodOptional<z.ZodString>;
+    required: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"number">;
+    value: z.ZodOptional<z.ZodNumber>;
+    required: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"boolean">;
+    value: z.ZodOptional<z.ZodBoolean>;
+    required: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strict>], "type">>>>;
+  forwards: z.ZodOptional<SubEntityClass<z.ZodUnion<readonly [z.ZodLiteral<"*">, z.ZodArray<z.ZodObject<{
+    __ref: z.ZodString;
+  }, z.core.$strip>>]>>>;
+  styles: z.ZodOptional<SubEntityClass<z.ZodType<ComponentStyleBody, unknown, z.core.$ZodTypeInternals<ComponentStyleBody, unknown>>>>;
+  anatomy: z.ZodOptional<SubEntityClass<z.ZodType<ComponentElementBody, unknown, z.core.$ZodTypeInternals<ComponentElementBody, unknown>>>>;
+  defaultProps: z.ZodOptional<SubEntityClass<z.ZodType<StyleValue, unknown, z.core.$ZodTypeInternals<StyleValue, unknown>>>>;
+  previewProps: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  file: z.ZodOptional<z.ZodObject<{
+    __ref: z.ZodString;
+  }, z.core.$strip>>;
+  export: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+  icon: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, "component", {
+  readonly create: {
+    readonly data: z.ZodObject<{
+      layers: SubEntityClass<z.ZodUnion<readonly [z.ZodString, z.ZodLazy<z.ZodType<Ref, unknown, z.core.$ZodTypeInternals<Ref, unknown>>>, 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>]>>;
+      props: z.ZodOptional<SubEntityClass<z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"slot">;
+        text: z.ZodOptional<z.ZodBoolean>;
+        accepts: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+          __ref: z.ZodString;
+        }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+          __ref: z.ZodString;
+        }, z.core.$strip>>]>>;
+        required: z.ZodOptional<z.ZodBoolean>;
+      }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"variant">;
+        value: z.ZodUnion<readonly [z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<{
+          [k: string]: {};
+        }, string[]>>, z.ZodObject<{
+          __ref: z.ZodString;
+        }, z.core.$strip>, SubEntityClass<z.ZodObject<{
+          label: z.ZodOptional<z.ZodString>;
+          description: z.ZodOptional<z.ZodString>;
+          deprecated: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>]>;
+        required: z.ZodOptional<z.ZodBoolean>;
+      }, z.core.$strict>, z.ZodPipe<z.ZodObject<{
+        type: z.ZodLiteral<"forward">;
+        target: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+          __ref: z.ZodString;
+        }, z.core.$strip>]>;
+        into: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+          __ref: z.ZodString;
+        }, z.core.$strip>]>>;
+        accepts: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+          __ref: z.ZodString;
+        }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+          __ref: z.ZodString;
+        }, z.core.$strip>>]>>;
+        text: z.ZodOptional<z.ZodBoolean>;
+        required: z.ZodOptional<z.ZodBoolean>;
+      }, z.core.$strict>, z.ZodTransform<{
+        type: "forward";
+        target: string | {
+          __ref: string;
+        };
+        into?: string | {
+          __ref: string;
+        } | undefined;
+        accepts?: {
+          __ref: string;
+        } | {
+          __ref: string;
+        }[] | undefined;
+        text?: boolean | undefined;
+        required?: boolean | undefined;
+      }, {
+        type: "forward";
+        target: string | {
+          __ref: string;
+        };
+        into?: string | {
+          __ref: string;
+        } | undefined;
+        accepts?: {
+          __ref: string;
+        } | {
+          __ref: string;
+        }[] | undefined;
+        text?: boolean | undefined;
+        required?: boolean | undefined;
+      }>>, z.ZodObject<{
+        type: z.ZodLiteral<"styleProperty">;
+        value: z.ZodObject<{
+          __ref: z.ZodString;
+        }, z.core.$strip>;
+      }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"composite">;
+        value: z.ZodObject<{
+          __ref: z.ZodString;
+        }, z.core.$strip>;
+      }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"motion">;
+        value: z.ZodDefault<z.ZodObject<{
+          __ref: z.ZodString;
+        }, z.core.$strip>>;
+      }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"string">;
+        value: z.ZodOptional<z.ZodString>;
+        required: z.ZodOptional<z.ZodBoolean>;
+      }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"number">;
+        value: z.ZodOptional<z.ZodNumber>;
+        required: z.ZodOptional<z.ZodBoolean>;
+      }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"boolean">;
+        value: z.ZodOptional<z.ZodBoolean>;
+        required: z.ZodOptional<z.ZodBoolean>;
+      }, z.core.$strict>], "type">>>>;
+      forwards: z.ZodOptional<SubEntityClass<z.ZodUnion<readonly [z.ZodLiteral<"*">, z.ZodArray<z.ZodObject<{
+        __ref: z.ZodString;
+      }, z.core.$strip>>]>>>;
+      styles: z.ZodOptional<SubEntityClass<z.ZodType<ComponentStyleBody, unknown, z.core.$ZodTypeInternals<ComponentStyleBody, unknown>>>>;
+      anatomy: z.ZodOptional<SubEntityClass<z.ZodType<ComponentElementBody, unknown, z.core.$ZodTypeInternals<ComponentElementBody, unknown>>>>;
+      defaultProps: z.ZodOptional<SubEntityClass<z.ZodType<StyleValue, unknown, z.core.$ZodTypeInternals<StyleValue, unknown>>>>;
+      previewProps: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+      file: z.ZodOptional<z.ZodObject<{
+        __ref: z.ZodString;
+      }, z.core.$strip>>;
+      export: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    readonly description: "Create a component at a new qualified `path`. When its complete body is known, include all layers, anatomy, props, defaults, and styles in this one operation. `data.layers` maps each stable layer name to the element it renders and must include `root` — a tag for a primitive (`{ \"layers\": { \"root\": \"div\" } }`), and for anything built on top, a ref to a primitive (`{ \"root\": { \"__ref\": \"component:Box\" }, \"label\": { \"__ref\": \"component:Text\" } }`), which is what lets the layer take that primitive's style props. A primitive exposes style props as `{ \"type\": \"styleProperty\", \"value\": { \"__ref\": \"style-property:bg\" } }` and declares `children: { \"type\": \"slot\", \"text\": true }` when it holds content — without the slot, nothing nested inside it renders. A composed component exposes a layer's props at its own top level through `forwards`, keyed by layer: `{ \"forwards\": { \"root\": \"*\" } }` passes every prop the root's element takes (so `<Button width=\"full\">` reaches the root's `width`), and a list of member refs (`[{ \"__ref\": \"component:Box#props/width\" }]`, each naming the component that declares the prop) passes only those. A prop a layer already exposes is forwarded, never redeclared in `props`; a `props` entry of `{ \"type\": \"forward\" }` is the reverse route, one of this component's props into a layer's. `anatomy` is the tree the build would read off a render: each node renders a layer (`{ \"__ref\": \"layer:<name>\" }`), an intrinsic tag, or `Slot` (`{ \"element\": \"Slot\", \"props\": { \"name\": \"children\" } }`, where a slot prop's content lands — but a declared slot fills `root` by default, so a primitive still declares its `children` slot prop yet needs no `Slot` node or `children` entry for it, and a `Slot` node is only for landing that content in a nested layer); `children` lists sibling node keys from the `root` node, never a prop name; `text` is a fixed string; `visible` is a condition on a prop (`{ \"$state\": \"<prop>\" }`, or with `eq`); content shown in a nested layer is a route, `children: { \"type\": \"forward\", \"target\": \"label/children\" }`. `$state` appears only in `visible` and in an `element` a prop chooses, never as a prop value. A glyph is a node of its own, `{ \"element\": { \"__ref\": \"icon:<library>/<Name>\" } }`, listed in the `children` of the layer node that holds it, never a prop value. Text a prop supplies to a text layer is never a node either: declare the prop `{ \"type\": \"forward\", \"target\": \"<layer>/children\" }` and the layer shows it; a `Slot` node goes only under a layer that takes nodes. A style rule is `\"styles\": { \"*\": { \"when\": null, \"layers\": { \"root\": { \"bg\": \"surface\" } } } }`, keyed by a name, with each layer's bag under `layers`. A composed component carries its own styles: give it an unconditional (`\"*\"`) rule that lays out and surfaces it through the system's style properties — spacing, alignment and gap on the container, a background and color where it has one — rather than leaning on the bare primitives, which paint flat. Style a layer only with the style props the primitive it renders exposes, set to the values those props accept: `component/get` on the primitive lists both, so read it and choose from that rather than reaching for a CSS name or value the system has no style property for. Set `previewProps` (or `defaultProps`) so the component previews with content; a root that takes children renders empty otherwise. A style rule's layer bag is keyed by style-prop name (`fontWeight`, `color`), never by CSS property name, and each value is one of that prop's values.";
+    readonly example: ({
+      config
+    }: {
+      config: Config;
+      kind: string;
+      path: string;
+    }) => {
+      path: string;
+      data: Record<string, unknown>;
+    };
+  };
+  readonly 'sub-create/anatomy': {
+    readonly description: "Add one anatomy node (`key` + `data`) to a component. In a batch, create child nodes before a parent whose `children` or `slots` names them; each referenced node must already exist when this operation runs.";
+  };
+  readonly 'sub-create/props': {
+    readonly description: "Declare a prop this component owns (`key` + `data`): a `variant`, a `slot`, a `styleProperty` or `composite` on a primitive, a `forward` routing this prop into a layer's (`{ \"type\": \"forward\", \"target\": \"<layer>/<prop>\" }`), or `null` to drop a forwarded prop from the surface. A prop one of its layers already exposes — `width` on a root that renders `Box` — is not declared here; `sub-create/forwards` exposes it at the top level.";
+  };
+  readonly 'sub-create/forwards': {
+    readonly description: "Expose a layer's props at this component's top level. `key` is one of the component's own layer names; `data` is `\"*\"` for every prop that layer's element takes, or a list of component prop member refs (`[{ \"__ref\": \"component:Box#props/width\" }]`) for a selection, each naming the component that declares the prop — `Button` forwarding `width` from a `Pressable` root names `Box`, where `Pressable` takes it from. This is how `<Button width=\"full\">` reaches the root's `width` with no `width` entry in `props`; a prop the layer already exposes is forwarded, never redeclared. Two entries may not offer the same prop, and removing one forwarded prop is a `null` tombstone under `props`.";
+    readonly example: ({
+      config
+    }: {
+      config: Config;
+      kind: string;
+      path: string;
+    }) => {
+      path: string;
+      key: string;
+      data: "*";
+    } | undefined;
+  };
+  readonly 'sub-upsert/forwards': {
+    readonly description: "Set what one layer forwards, added when absent and replaced whole when present. Expose a layer's props at this component's top level. `key` is one of the component's own layer names; `data` is `\"*\"` for every prop that layer's element takes, or a list of component prop member refs (`[{ \"__ref\": \"component:Box#props/width\" }]`) for a selection, each naming the component that declares the prop — `Button` forwarding `width` from a `Pressable` root names `Box`, where `Pressable` takes it from. This is how `<Button width=\"full\">` reaches the root's `width` with no `width` entry in `props`; a prop the layer already exposes is forwarded, never redeclared. Two entries may not offer the same prop, and removing one forwarded prop is a `null` tombstone under `props`.";
+  };
+  readonly 'sub-update/forwards': {
+    readonly description: "Replace what one layer forwards: the member is `'*'` or a list, so `data` is the whole new value. Expose a layer's props at this component's top level. `key` is one of the component's own layer names; `data` is `\"*\"` for every prop that layer's element takes, or a list of component prop member refs (`[{ \"__ref\": \"component:Box#props/width\" }]`) for a selection, each naming the component that declares the prop — `Button` forwarding `width` from a `Pressable` root names `Box`, where `Pressable` takes it from. This is how `<Button width=\"full\">` reaches the root's `width` with no `width` entry in `props`; a prop the layer already exposes is forwarded, never redeclared. Two entries may not offer the same prop, and removing one forwarded prop is a `null` tombstone under `props`.";
+  };
+  /**
+   * Add an element to a composition — a layer and the node that targets it, together.
+   *
+   * Two writes, one op, because either alone is broken: a node whose element is a component ref
+   * directly can never be styled (`styles` keys on layer names, and it has none), and a layer no
+   * node places renders nowhere. Making it one op is also what keeps the parent's `children` from
+   * being left dangling between two patches.
+   *
+   * That the new element gets a layer is the whole difference between a read component and an
+   * authored one. A render's inline glyph stays unnamed because the source never named it; a thing
+   * a person adds is added in order to be styled.
+   *
+   * The layer name is what makes this survive a second platform: native replaces `layers` (a `div`
+   * becomes a `View`) and inherits the styles and the structure, because both address the name
+   * rather than the element.
+   */
+  readonly 'element-insert': {
+    readonly input: z.ZodObject<{
+      path: z.ZodType<string, string | undefined, z.core.$ZodTypeInternals<string, string | undefined>>;
+      key: z.ZodOptional<z.ZodString>;
+      data: z.ZodPrefault<z.ZodObject<{
+        element: z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+          __ref: z.ZodString;
+        }, z.core.$strip>]>>;
+        parent: z.ZodOptional<z.ZodString>;
+        index: z.ZodOptional<z.ZodNumber>;
+        props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        slotProp: z.ZodOptional<z.ZodString>;
+        visible: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodObject<{
+          not: z.ZodOptional<z.ZodLiteral<true>>;
+          eq: z.ZodOptional<z.ZodUnknown>;
+          neq: z.ZodOptional<z.ZodUnknown>;
+          gt: z.ZodOptional<z.ZodNumber>;
+          gte: z.ZodOptional<z.ZodNumber>;
+          lt: z.ZodOptional<z.ZodNumber>;
+          lte: z.ZodOptional<z.ZodNumber>;
+          $state: z.ZodString;
+        }, z.core.$strict>, z.ZodTransform<{
+          $state: string;
+          not?: true | undefined;
+          eq?: unknown;
+          neq?: unknown;
+          gt?: number | undefined;
+          gte?: number | undefined;
+          lt?: number | undefined;
+          lte?: number | undefined;
+        }, {
+          $state: string;
+          not?: true | undefined;
+          eq?: unknown;
+          neq?: unknown;
+          gt?: number | undefined;
+          gte?: number | undefined;
+          lt?: number | undefined;
+          lte?: number | undefined;
+        }>>, z.ZodObject<{
+          $or: z.ZodArray<z.ZodPipe<z.ZodObject<{
+            not: z.ZodOptional<z.ZodLiteral<true>>;
+            eq: z.ZodOptional<z.ZodUnknown>;
+            neq: z.ZodOptional<z.ZodUnknown>;
+            gt: z.ZodOptional<z.ZodNumber>;
+            gte: z.ZodOptional<z.ZodNumber>;
+            lt: z.ZodOptional<z.ZodNumber>;
+            lte: z.ZodOptional<z.ZodNumber>;
+            $state: z.ZodString;
+          }, z.core.$strict>, z.ZodTransform<{
+            $state: string;
+            not?: true | undefined;
+            eq?: unknown;
+            neq?: unknown;
+            gt?: number | undefined;
+            gte?: number | undefined;
+            lt?: number | undefined;
+            lte?: number | undefined;
+          }, {
+            $state: string;
+            not?: true | undefined;
+            eq?: unknown;
+            neq?: unknown;
+            gt?: number | undefined;
+            gte?: number | undefined;
+            lt?: number | undefined;
+            lte?: number | undefined;
+          }>>>;
+        }, z.core.$strict>, z.ZodArray<z.ZodUnion<readonly [z.ZodPipe<z.ZodObject<{
+          not: z.ZodOptional<z.ZodLiteral<true>>;
+          eq: z.ZodOptional<z.ZodUnknown>;
+          neq: z.ZodOptional<z.ZodUnknown>;
+          gt: z.ZodOptional<z.ZodNumber>;
+          gte: z.ZodOptional<z.ZodNumber>;
+          lt: z.ZodOptional<z.ZodNumber>;
+          lte: z.ZodOptional<z.ZodNumber>;
+          $state: z.ZodString;
+        }, z.core.$strict>, z.ZodTransform<{
+          $state: string;
+          not?: true | undefined;
+          eq?: unknown;
+          neq?: unknown;
+          gt?: number | undefined;
+          gte?: number | undefined;
+          lt?: number | undefined;
+          lte?: number | undefined;
+        }, {
+          $state: string;
+          not?: true | undefined;
+          eq?: unknown;
+          neq?: unknown;
+          gt?: number | undefined;
+          gte?: number | undefined;
+          lt?: number | undefined;
+          lte?: number | undefined;
+        }>>, z.ZodObject<{
+          $or: z.ZodArray<z.ZodPipe<z.ZodObject<{
+            not: z.ZodOptional<z.ZodLiteral<true>>;
+            eq: z.ZodOptional<z.ZodUnknown>;
+            neq: z.ZodOptional<z.ZodUnknown>;
+            gt: z.ZodOptional<z.ZodNumber>;
+            gte: z.ZodOptional<z.ZodNumber>;
+            lt: z.ZodOptional<z.ZodNumber>;
+            lte: z.ZodOptional<z.ZodNumber>;
+            $state: z.ZodString;
+          }, z.core.$strict>, z.ZodTransform<{
+            $state: string;
+            not?: true | undefined;
+            eq?: unknown;
+            neq?: unknown;
+            gt?: number | undefined;
+            gte?: number | undefined;
+            lt?: number | undefined;
+            lte?: number | undefined;
+          }, {
+            $state: string;
+            not?: true | undefined;
+            eq?: unknown;
+            neq?: unknown;
+            gt?: number | undefined;
+            gte?: number | undefined;
+            lt?: number | undefined;
+            lte?: number | undefined;
+          }>>>;
+        }, z.core.$strict>]>>, z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{
+          __ref: z.ZodString;
+        }, z.core.$strip>]>>, z.ZodTransform<{
+          $state: string;
+          eq?: unknown;
+        } | {
+          $state: string;
+          eq?: unknown;
+        }[], Record<string, string | number | boolean | {
+          __ref: string;
+        }>>>]>>;
+        text: z.ZodOptional<z.ZodString>;
+        children: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        slots: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+        nodes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+          element: z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            __ref: z.ZodString;
+          }, z.core.$strip>]>>;
+          props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+          children: z.ZodOptional<z.ZodArray<z.ZodString>>;
+          slots: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+          visible: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodObject<{
+            not: z.ZodOptional<z.ZodLiteral<true>>;
+            eq: z.ZodOptional<z.ZodUnknown>;
+            neq: z.ZodOptional<z.ZodUnknown>;
+            gt: z.ZodOptional<z.ZodNumber>;
+            gte: z.ZodOptional<z.ZodNumber>;
+            lt: z.ZodOptional<z.ZodNumber>;
+            lte: z.ZodOptional<z.ZodNumber>;
+            $state: z.ZodString;
+          }, z.core.$strict>, z.ZodTransform<{
+            $state: string;
+            not?: true | undefined;
+            eq?: unknown;
+            neq?: unknown;
+            gt?: number | undefined;
+            gte?: number | undefined;
+            lt?: number | undefined;
+            lte?: number | undefined;
+          }, {
+            $state: string;
+            not?: true | undefined;
+            eq?: unknown;
+            neq?: unknown;
+            gt?: number | undefined;
+            gte?: number | undefined;
+            lt?: number | undefined;
+            lte?: number | undefined;
+          }>>, z.ZodObject<{
+            $or: z.ZodArray<z.ZodPipe<z.ZodObject<{
+              not: z.ZodOptional<z.ZodLiteral<true>>;
+              eq: z.ZodOptional<z.ZodUnknown>;
+              neq: z.ZodOptional<z.ZodUnknown>;
+              gt: z.ZodOptional<z.ZodNumber>;
+              gte: z.ZodOptional<z.ZodNumber>;
+              lt: z.ZodOptional<z.ZodNumber>;
+              lte: z.ZodOptional<z.ZodNumber>;
+              $state: z.ZodString;
+            }, z.core.$strict>, z.ZodTransform<{
+              $state: string;
+              not?: true | undefined;
+              eq?: unknown;
+              neq?: unknown;
+              gt?: number | undefined;
+              gte?: number | undefined;
+              lt?: number | undefined;
+              lte?: number | undefined;
+            }, {
+              $state: string;
+              not?: true | undefined;
+              eq?: unknown;
+              neq?: unknown;
+              gt?: number | undefined;
+              gte?: number | undefined;
+              lt?: number | undefined;
+              lte?: number | undefined;
+            }>>>;
+          }, z.core.$strict>, z.ZodArray<z.ZodUnion<readonly [z.ZodPipe<z.ZodObject<{
+            not: z.ZodOptional<z.ZodLiteral<true>>;
+            eq: z.ZodOptional<z.ZodUnknown>;
+            neq: z.ZodOptional<z.ZodUnknown>;
+            gt: z.ZodOptional<z.ZodNumber>;
+            gte: z.ZodOptional<z.ZodNumber>;
+            lt: z.ZodOptional<z.ZodNumber>;
+            lte: z.ZodOptional<z.ZodNumber>;
+            $state: z.ZodString;
+          }, z.core.$strict>, z.ZodTransform<{
+            $state: string;
+            not?: true | undefined;
+            eq?: unknown;
+            neq?: unknown;
+            gt?: number | undefined;
+            gte?: number | undefined;
+            lt?: number | undefined;
+            lte?: number | undefined;
+          }, {
+            $state: string;
+            not?: true | undefined;
+            eq?: unknown;
+            neq?: unknown;
+            gt?: number | undefined;
+            gte?: number | undefined;
+            lt?: number | undefined;
+            lte?: number | undefined;
+          }>>, z.ZodObject<{
+            $or: z.ZodArray<z.ZodPipe<z.ZodObject<{
+              not: z.ZodOptional<z.ZodLiteral<true>>;
+              eq: z.ZodOptional<z.ZodUnknown>;
+              neq: z.ZodOptional<z.ZodUnknown>;
+              gt: z.ZodOptional<z.ZodNumber>;
+              gte: z.ZodOptional<z.ZodNumber>;
+              lt: z.ZodOptional<z.ZodNumber>;
+              lte: z.ZodOptional<z.ZodNumber>;
+              $state: z.ZodString;
+            }, z.core.$strict>, z.ZodTransform<{
+              $state: string;
+              not?: true | undefined;
+              eq?: unknown;
+              neq?: unknown;
+              gt?: number | undefined;
+              gte?: number | undefined;
+              lt?: number | undefined;
+              lte?: number | undefined;
+            }, {
+              $state: string;
+              not?: true | undefined;
+              eq?: unknown;
+              neq?: unknown;
+              gt?: number | undefined;
+              gte?: number | undefined;
+              lt?: number | undefined;
+              lte?: number | undefined;
+            }>>>;
+          }, z.core.$strict>]>>, z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{
+            __ref: z.ZodString;
+          }, z.core.$strip>]>>, z.ZodTransform<{
+            $state: string;
+            eq?: unknown;
+          } | {
+            $state: string;
+            eq?: unknown;
+          }[], Record<string, string | number | boolean | {
+            __ref: string;
+          }>>>]>>;
+          text: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        subtree: z.ZodOptional<z.ZodObject<{
+          root: z.ZodString;
+          elements: z.ZodRecord<z.ZodString, z.ZodObject<{
+            element: z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+              __ref: z.ZodString;
+            }, z.core.$strip>]>>;
+            props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            children: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            slots: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+            visible: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodObject<{
+              not: z.ZodOptional<z.ZodLiteral<true>>;
+              eq: z.ZodOptional<z.ZodUnknown>;
+              neq: z.ZodOptional<z.ZodUnknown>;
+              gt: z.ZodOptional<z.ZodNumber>;
+              gte: z.ZodOptional<z.ZodNumber>;
+              lt: z.ZodOptional<z.ZodNumber>;
+              lte: z.ZodOptional<z.ZodNumber>;
+              $state: z.ZodString;
+            }, z.core.$strict>, z.ZodTransform<{
+              $state: string;
+              not?: true | undefined;
+              eq?: unknown;
+              neq?: unknown;
+              gt?: number | undefined;
+              gte?: number | undefined;
+              lt?: number | undefined;
+              lte?: number | undefined;
+            }, {
+              $state: string;
+              not?: true | undefined;
+              eq?: unknown;
+              neq?: unknown;
+              gt?: number | undefined;
+              gte?: number | undefined;
+              lt?: number | undefined;
+              lte?: number | undefined;
+            }>>, z.ZodObject<{
+              $or: z.ZodArray<z.ZodPipe<z.ZodObject<{
+                not: z.ZodOptional<z.ZodLiteral<true>>;
+                eq: z.ZodOptional<z.ZodUnknown>;
+                neq: z.ZodOptional<z.ZodUnknown>;
+                gt: z.ZodOptional<z.ZodNumber>;
+                gte: z.ZodOptional<z.ZodNumber>;
+                lt: z.ZodOptional<z.ZodNumber>;
+                lte: z.ZodOptional<z.ZodNumber>;
+                $state: z.ZodString;
+              }, z.core.$strict>, z.ZodTransform<{
+                $state: string;
+                not?: true | undefined;
+                eq?: unknown;
+                neq?: unknown;
+                gt?: number | undefined;
+                gte?: number | undefined;
+                lt?: number | undefined;
+                lte?: number | undefined;
+              }, {
+                $state: string;
+                not?: true | undefined;
+                eq?: unknown;
+                neq?: unknown;
+                gt?: number | undefined;
+                gte?: number | undefined;
+                lt?: number | undefined;
+                lte?: number | undefined;
+              }>>>;
+            }, z.core.$strict>, z.ZodArray<z.ZodUnion<readonly [z.ZodPipe<z.ZodObject<{
+              not: z.ZodOptional<z.ZodLiteral<true>>;
+              eq: z.ZodOptional<z.ZodUnknown>;
+              neq: z.ZodOptional<z.ZodUnknown>;
+              gt: z.ZodOptional<z.ZodNumber>;
+              gte: z.ZodOptional<z.ZodNumber>;
+              lt: z.ZodOptional<z.ZodNumber>;
+              lte: z.ZodOptional<z.ZodNumber>;
+              $state: z.ZodString;
+            }, z.core.$strict>, z.ZodTransform<{
+              $state: string;
+              not?: true | undefined;
+              eq?: unknown;
+              neq?: unknown;
+              gt?: number | undefined;
+              gte?: number | undefined;
+              lt?: number | undefined;
+              lte?: number | undefined;
+            }, {
+              $state: string;
+              not?: true | undefined;
+              eq?: unknown;
+              neq?: unknown;
+              gt?: number | undefined;
+              gte?: number | undefined;
+              lt?: number | undefined;
+              lte?: number | undefined;
+            }>>, z.ZodObject<{
+              $or: z.ZodArray<z.ZodPipe<z.ZodObject<{
+                not: z.ZodOptional<z.ZodLiteral<true>>;
+                eq: z.ZodOptional<z.ZodUnknown>;
+                neq: z.ZodOptional<z.ZodUnknown>;
+                gt: z.ZodOptional<z.ZodNumber>;
+                gte: z.ZodOptional<z.ZodNumber>;
+                lt: z.ZodOptional<z.ZodNumber>;
+                lte: z.ZodOptional<z.ZodNumber>;
+                $state: z.ZodString;
+              }, z.core.$strict>, z.ZodTransform<{
+                $state: string;
+                not?: true | undefined;
+                eq?: unknown;
+                neq?: unknown;
+                gt?: number | undefined;
+                gte?: number | undefined;
+                lt?: number | undefined;
+                lte?: number | undefined;
+              }, {
+                $state: string;
+                not?: true | undefined;
+                eq?: unknown;
+                neq?: unknown;
+                gt?: number | undefined;
+                gte?: number | undefined;
+                lt?: number | undefined;
+                lte?: number | undefined;
+              }>>>;
+            }, z.core.$strict>]>>, z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{
+              __ref: z.ZodString;
+            }, z.core.$strip>]>>, z.ZodTransform<{
+              $state: string;
+              eq?: unknown;
+            } | {
+              $state: string;
+              eq?: unknown;
+            }[], Record<string, string | number | boolean | {
+              __ref: string;
+            }>>>]>>;
+            text: z.ZodOptional<z.ZodString>;
+          }, z.core.$strict>>;
+        }, z.core.$strip>>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+    readonly readOnly: false;
+    readonly label: "Add element";
+    readonly description: "Add an element to a component: creates the LAYER it is styled through and the anatomy node that places it, under `parent`.";
+    readonly scope: "item";
+    readonly creates: true;
+    readonly title: (entity: string) => string;
+    readonly handler: (input: Record<string, unknown>, config: Config) => Config;
+  };
+  /**
+   * Remove an element from a composition — the node, its layer, and everything that named it.
+   *
+   * A custom op for the same reason `element-insert` is: it writes more than one thing and either
+   * half alone is broken. `sub-delete/layers` drops the layer and leaves the anatomy node holding
+   * a dangling `layer:<key>` ref, its parent's `children` still naming it, and every style rule
+   * still carrying a bag for a layer that no longer exists. `sub-delete/anatomy` leaves the parent
+   * edge — a value the stored `children` enum would now refuse on the next write to that node.
+   *
+   * The rule bags are the part `orphans` cannot express: a rule targeting a deleted layer is not
+   * itself orphaned (it has other layers to style), so what has to go is the layer's entry inside
+   * each rule. That is a delta, which is what the merge verb is for — the rule is left alone when
+   * it still styles something and pruned by the caller's own `sub-delete` when it doesn't.
+   */
+  readonly 'element-delete': {
+    readonly input: z.ZodObject<{
+      path: z.ZodType<string, string | undefined, z.core.$ZodTypeInternals<string, string | undefined>>;
+      key: z.ZodString;
+      data: z.ZodOptional<z.ZodObject<{
+        subtree: z.ZodDefault<z.ZodBoolean>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+    readonly readOnly: false;
+    readonly label: "Remove element";
+    readonly description: "Remove an element from a component: its anatomy node, the layer it is styled through, its subtree, every parent edge naming it, and its entry in every style rule.";
+    readonly scope: "item";
+    readonly approval: "destructive";
+    readonly title: (entity: string) => string;
+    readonly handler: (input: Record<string, unknown>, config: Config) => Config;
+  };
+  /**
+   * Move a node to a different parent, or to a different place under the same one.
+   *
+   * Sibling order lives in a parent's `children`, so a move is two updates — one per parent — and
+   * both have to land or the node is in neither list or in both.
+   *
+   * A node can also be held by a slot rather than a child edge (`slots: { icon: [key] }`),
+   * and a move treats both as the home being left: every child edge naming the key is detached,
+   * and every stale slot entry naming it is cleared, whichever new home the move names. With
+   * `slotProp` the new home is the parent's slot instead of its `children` — the same statement
+   * `element-insert` makes about a new node, made about one that already exists, so the moved
+   * element keeps its key, props, styles and subtree.
+   */
+  readonly 'element-move': {
+    readonly input: z.ZodObject<{
+      path: z.ZodType<string, string | undefined, z.core.$ZodTypeInternals<string, string | undefined>>;
+      key: z.ZodString;
+      data: z.ZodPrefault<z.ZodObject<{
+        parent: z.ZodDefault<z.ZodString>;
+        index: z.ZodOptional<z.ZodNumber>;
+        slotProp: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+    readonly readOnly: false;
+    readonly label: "Move element";
+    readonly description: "Move a component's anatomy node under a different parent, to a different position under the same one, or — with `slotProp` — into a parent's slot.";
+    readonly scope: "item";
+    readonly approval: "reference-change";
+    readonly title: (entity: string) => string;
+    readonly handler: (input: Record<string, unknown>, config: Config) => Config;
+  };
+  readonly validate: {
+    readonly input: z.ZodObject<{
+      path: z.ZodType<string, string | undefined, z.core.$ZodTypeInternals<string, string | undefined>>;
+      data: z.ZodObject<{
+        props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+      }, z.core.$strip>;
+    }, z.core.$strip>;
+    readonly readOnly: true;
+    readonly label: "Validate props";
+    readonly description: "Check a bag of prop VALUES against a component — rejects unknown props and out-of-domain values.";
+    readonly scope: "item";
+    readonly title: (entity: string) => string;
+    readonly example: ({
+      config,
+      path
+    }: {
+      config: Config;
+      kind: string;
+      path: string;
+    }) => {
+      path: string;
+      data: {
+        props: Record<string, unknown>;
+      };
+    };
+    readonly handler: (input: Record<string, unknown>, config: Config) => string[];
+  };
+}, {
+  /**
+   * The prop names an instance may fill through a spec element's `slots` field — every prop that
+   * routes content: a `slot`, or a `forward` whose far end takes content. Resolved over the
+   * inheritance chain, since an inherited slot is as fillable as a declared one. This is the
+   * `slots: string[]` json-render's catalog metadata declares per component, computed here so the
+   * emitted catalog, the validator, and every picker read one answer.
+   */
+  readonly slots: ({
+    config,
+    path,
+    member
+  }: ComputedInput) => string[];
+}, false>;
+type ComponentRefDelta = Parameters<ReturnType<(typeof ComponentEntity)['ref']>['extend']>[0];
+type ExactComponentDelta<Delta> = Delta & { [Key in Exclude<keyof Delta, keyof ComponentRefDelta>]: never };
+type ContractLayers<Contract> = Contract extends {
+  layers: infer Layers;
+} ? Layers extends LayerMap ? Layers : LayerMap : LayerMap;
+type ContractProps<Contract> = Contract extends {
+  props: infer Props;
+} ? Props extends PropMap ? Props : PropMap : PropMap;
+type ResolvedLayers<Contract, Delta> = Delta extends {
+  readonly layers: infer Layers;
+} ? Layers extends LayerMap ? Layers : ContractLayers<Contract> : ContractLayers<Contract>;
+type ResolvedProps<Contract, Delta> = Delta extends {
+  readonly props: infer Props;
+} ? Props extends PropMap ? Props : ContractProps<Contract> : ContractProps<Contract>;
+type ResolvedDefaults<Contract, Delta> = Delta extends {
+  readonly defaultProps: infer Defaults;
+} ? Defaults : Contract extends {
+  defaultProps: infer Defaults;
+} ? Defaults : Record<never, never>;
+type ResolvedForwards<Contract, Delta> = Delta extends {
+  readonly forwards: infer Forwards;
+} ? Forwards : Contract extends {
+  forwards: infer Forwards;
+} ? Forwards : Record<never, never>;
+type ForwardedLayerNames<Contract, Delta> = ResolvedForwards<Contract, Delta> extends Record<string, unknown> ? keyof ResolvedForwards<Contract, Delta> & string : never;
+/** The source-only half of a linked component extension. The callback is deliberately absent from
+ * {@link ExtendedRef}: it is code, so ts-morph reads it from the authoring file while Config stores
+ * only `{ __ref, extend }`. */
+type ExtendedComponentRef<Contract = ComponentContractOf<string>, Delta extends ComponentRefDelta = ComponentRefDelta, Extra = Record<never, never>> = ExtendedRef<Delta> & {
+  /** Phantom component signature: codegen replaces the authoring value before it is rendered, but
+   * this lets `ComponentProps<typeof Button>` see the inherited and locally replaced contract. */
+  (props: ComponentPropsOf<ResolvedLayers<Contract, Delta>, ResolvedProps<Contract, Delta>, ResolvedDefaults<Contract, Delta>, Extra, ForwardedLayerNames<Contract, Delta>>): null;
+  render<E = Extra>(fn: (args: RenderArgs<ResolvedLayers<Contract, Delta>, ResolvedProps<Contract, Delta>> & E) => unknown): ExtendedComponentRef<Contract, Delta, E>;
+  /**
+   * Style rules for the extension, typed against the layers it ends up with — the linked contract's,
+   * with the delta's replacing them when it declares its own.
+   *
+   * Chained rather than a `styles` key inside `extend`, and that is the whole point: a key in the same
+   * object literal is checked against the same wide type as everything else there, so a rule naming a
+   * layer that does not exist typechecked. `extend` has already fixed `Delta` by the time this is
+   * called, so `ResolvedLayers` is known and a bad layer name is an error — the same reason
+   * `defineComponent` is a chain instead of one object argument.
+   */
+  styles(rules: readonly StyleRuleInput<ResolvedLayers<Contract, Delta>>[]): ExtendedComponentRef<Contract, Delta, Extra>;
+};
+type ComponentReference<Contract = ComponentContractOf<string>> = Ref & {
+  extend<const Delta extends ComponentRefDelta>(delta: ExactComponentDelta<Delta>): ExtendedComponentRef<Contract, Delta>;
+};
+/** Component keeps the generic entity surface; only its ref authoring result knows about the
+ * source-only `.render()` step. */
+declare const Component: Omit<typeof ComponentEntity, "ref"> & {
+  ref<const Path extends PathOf<"component">>(path: Path): ComponentReference<ComponentContractOf<Path>>;
+};
+//#endregion
+export { AuthoredPropBody, Component, ComponentBody, ComponentElementBody, ComponentPropBody, ComponentReference, ComponentStyleBody, ElementVisibility, ElementVisibilityInput, ExtendedComponentRef, ProjectedVisibility, VariantValueBody, VariantValues, canonicalWhen, forwardedNames, layerRef, ownValues, ownsItsValues, valueRef };