@yahoo/uds-create-config 2.44.0 → 3.0.0

package/dist/configs/CanvasConfig.d.ts

@@ -0,0 +1,3237 @@
+import { Ref } from "../framework/utils/refs.js";
+import { DerivedEntityClass } from "../framework/defineDerivedEntity.js";
+import { SubEntityClass } from "../framework/defineSubEntity.js";
+import { ComponentContractOf, PathOf } from "../framework/registered.js";
+import { EntityClass } from "../framework/defineEntity.js";
+import { ConfigClass, ConfigInstance } from "../framework/defineConfig.js";
+import { Config } from "../framework/Config.js";
+import { ComputedInput } from "../framework/registry.js";
+import { ReactNativeSystem } from "./react-native-system.js";
+import { System } from "./system.js";
+import { AnySystemConfig } from "./platform.js";
+import { StyleValue } from "../entities/system/style-bag.js";
+import { ComponentElementBody, ComponentReference, ComponentStyleBody } from "../entities/system/Component.js";
+import { z } from "zod";
+
+//#region src/configs/CanvasConfig.d.ts
+/**
+ * `SystemSource` — this canvas's pointer at the ONE system it belongs to, in full. `LinkedSystem` is
+ * the wrong mechanism here: it exists for a design system partially borrowing PIECES of another
+ * (`link`, per-entity `options`, override/extend), and a canvas never does that — a node's `type`
+ * always resolves against the whole of exactly one system.
+ *
+ * The source is attached under the system config's own `name`, which is `system-config` for a web
+ * system and `react-native-system` for a native one, so a node ref the canvas mints
+ * (`component:actions/Button@system-config`) means "the attached system". The system itself resolves
+ * that ref as its own, through `Config.configFor`'s own-name rule.
+ */
+declare const SystemSource: EntityClass<z.ZodObject<{
+  systemId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "system-source", Record<never, never>, Record<never, never>, false>;
+/**
+ * `Canvas` — a surface in a design file (a design file has one or more). Pages belong to a canvas,
+ * nodes belong to a page (flat, ref-related, matching the real tables' `canvasId`/`pageId` columns).
+ */
+declare const Canvas: EntityClass<z.ZodObject<{
+  name: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "canvas", Record<never, never>, Record<never, never>, false>;
+/**
+ * `Page` — a page within a `Canvas`. Field-for-field the `canvas_pages` table (id → path,
+ * `canvasId` → the ref, timestamps DB-owned).
+ */
+declare const Page: EntityClass<z.ZodObject<{
+  canvas: EntityClass<z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "canvas", Record<never, never>, Record<never, never>, false>;
+  name: z.ZodOptional<z.ZodString>;
+  urlKey: z.ZodOptional<z.ZodString>;
+  sortOrder: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "page", Record<never, never>, Record<never, never>, false>;
+/**
+ * `AiChat` — one conversation. Deliberately minimal: the transcript is the `AiMessage` rows that
+ * ref it (flat rows pointing at their owner, never an embedded array nothing can ref into).
+ */
+declare const AiChat: EntityClass<z.ZodObject<{
+  title: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "ai-chat", Record<never, never>, Record<never, never>, false>;
+/** `AiMessage` — one turn in an `AiChat`. */
+declare const AiMessage: EntityClass<z.ZodObject<{
+  chat: EntityClass<z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "ai-chat", Record<never, never>, Record<never, never>, false>;
+  role: z.ZodEnum<{
+    user: "user";
+    assistant: "assistant";
+  }>;
+  content: z.ZodString;
+  modelId: z.ZodOptional<z.ZodString>;
+  sentAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "ai-message", Record<never, never>, Record<never, never>, false>;
+/**
+ * `AiFlow` — the invocation that produced one or more generations: which surface it started from,
+ * which model ran, how the agents were arranged, and — when it began as a chat turn — the message
+ * that kicked it off. One flow can produce several nodes (a fanout literally does), so it is its
+ * own entity rather than columns repeated per node.
+ */
+declare const aiFlowOrigin: z.ZodEnum<{
+  chat: "chat";
+  comment: "comment";
+  mcp: "mcp";
+  sidebar: "sidebar";
+  paste: "paste";
+  "figma-paste": "figma-paste";
+  duplicate: "duplicate";
+}>;
+type AiFlowOrigin = z.infer<typeof aiFlowOrigin>;
+declare const aiMultiAgentMode: z.ZodEnum<{
+  huddle: "huddle";
+  single: "single";
+  fanout: "fanout";
+}>;
+type AiMultiAgentMode = z.infer<typeof aiMultiAgentMode>;
+declare const AiFlow: EntityClass<z.ZodObject<{
+  origin: z.ZodEnum<{
+    chat: "chat";
+    comment: "comment";
+    mcp: "mcp";
+    sidebar: "sidebar";
+    paste: "paste";
+    "figma-paste": "figma-paste";
+    duplicate: "duplicate";
+  }>;
+  lane: z.ZodOptional<z.ZodEnum<{
+    chat: "chat";
+    comment: "comment";
+    huddle: "huddle";
+    "paint-style": "paint-style";
+    "figma-import": "figma-import";
+    workspace: "workspace";
+    mcp: "mcp";
+  }>>;
+  modelId: z.ZodOptional<z.ZodString>;
+  multiAgentMode: z.ZodOptional<z.ZodEnum<{
+    huddle: "huddle";
+    single: "single";
+    fanout: "fanout";
+  }>>;
+  agentCount: z.ZodOptional<z.ZodNumber>;
+  agentNames: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  message: z.ZodOptional<z.ZodObject<{
+    __ref: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "ai-flow", Record<never, never>, Record<never, never>, false>;
+/**
+ * `AiGeneration` — how one node came to exist: the flow that produced it, and — for an iteration —
+ * the lineage it varied from, as a real graph edge. Replaces the `canvas_nodes` table's
+ * `generation_*` and `iteration_meta` columns, which all describe this one event.
+ */
+declare const AiGeneration: EntityClass<z.ZodObject<{
+  flow: z.ZodOptional<z.ZodObject<{
+    __ref: z.ZodString;
+  }, z.core.$strip>>;
+  parentNode: z.ZodOptional<z.ZodObject<{
+    __ref: z.ZodString;
+  }, z.core.$strip>>;
+  iterationNumber: z.ZodOptional<z.ZodNumber>;
+  description: z.ZodOptional<z.ZodString>;
+  instructions: z.ZodOptional<z.ZodString>;
+  generatedAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "ai-generation", Record<never, never>, Record<never, never>, false>;
+/**
+ * `Node` — the unit of a canvas: one element, one record, one row. FLAT — a subtree node is its own
+ * item nested under its placed root's id (`n1/badge`), and `children`/`slots` hold real node refs,
+ * so `dependents()`, delete-refusal and rename-cascade come from the framework instead of
+ * `reKeySlotRefs` (UDS-3526) / `gcUnreachableElements` (UDS-3557) hand-rolling them per gesture.
+ *
+ * Placement fields are present on a PLACED node (`page` is the discriminant — what the canvas lists
+ * and react-flow wraps) and absent on subtree nodes. `type` is optional for exactly one reason: a
+ * placed node awaiting its first generation (today's skeleton / pending placeholder) exists before
+ * anyone knows what it renders.
+ */
+declare const Node: EntityClass<z.ZodObject<{
+  type: z.ZodOptional<z.ZodUnion<readonly [Omit<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`.";
+    };
+    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;
+    };
+    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;
+    };
+    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[];
+    };
+  }, {
+    readonly slots: ({
+      config,
+      path,
+      member
+    }: ComputedInput) => string[];
+  }, false>, "ref"> & {
+    ref<const Path extends PathOf<"component">>(path: Path): ComponentReference<ComponentContractOf<Path>>;
+  }, EntityClass<z.ZodObject<{
+    categories: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    codepoint: z.ZodOptional<z.ZodNumber>;
+    knockoutVariants: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  }, z.core.$strict>, z.ZodObject<{
+    module: z.ZodOptional<z.ZodString>;
+    version: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodObject<{
+      from: EntityClass<z.ZodObject<{
+        version: z.ZodOptional<z.ZodString>;
+        exports: z.ZodOptional<SubEntityClass<z.ZodObject<{}, z.core.$strict>>>;
+      }, z.core.$strict>, z.ZodObject<Record<never, never>, z.core.$strip>, "package", Record<never, never>, Record<never, never>, false>;
+      format: z.ZodEnum<{
+        uds: "uds";
+        phosphor: "phosphor";
+      }>;
+    }, z.core.$strict>>;
+    sizes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    variants: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    component: z.ZodOptional<z.ZodObject<{
+      __ref: z.ZodString;
+    }, z.core.$strip>>;
+  }, z.core.$strict>, "icon", Record<never, never>, Record<never, never>, false>, 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>, z.ZodObject<{
+    __ref: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    __ref: z.ZodEnum<{
+      "spec:Slot": "spec:Slot";
+      "spec:Fragment": "spec:Fragment";
+    }>;
+  }, z.core.$strip>]>>;
+  props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  children: z.ZodOptional<z.ZodArray<z.ZodType<Ref, unknown, z.core.$ZodTypeInternals<Ref, unknown>>>>;
+  slots: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodType<Ref, unknown, z.core.$ZodTypeInternals<Ref, unknown>>>>>;
+  visible: z.ZodOptional<z.ZodUnknown>;
+  repeat: z.ZodOptional<z.ZodUnknown>;
+  ref: z.ZodOptional<z.ZodUnknown>;
+  locked: z.ZodOptional<z.ZodBoolean>;
+  label: z.ZodOptional<z.ZodString>;
+  page: z.ZodOptional<z.ZodObject<{
+    __ref: z.ZodString;
+  }, z.core.$strip>>;
+  parent: z.ZodOptional<z.ZodType<Ref, unknown, z.core.$ZodTypeInternals<Ref, unknown>>>;
+  size: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"custom">;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"device">;
+    ref: EntityClass<z.ZodObject<{
+      width: z.ZodNumber;
+      height: z.ZodNumber;
+      name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "device", Record<never, never>, Record<never, never>, false>;
+  }, z.core.$strip>], "type">>;
+  x: z.ZodOptional<z.ZodNumber>;
+  y: z.ZodOptional<z.ZodNumber>;
+  collapsed: z.ZodOptional<z.ZodBoolean>;
+  order: z.ZodOptional<z.ZodNumber>;
+  linkedSource: z.ZodOptional<z.ZodUnknown>;
+  state: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  generation: z.ZodOptional<z.ZodObject<{
+    __ref: z.ZodString;
+  }, z.core.$strip>>;
+  duplicatedFrom: z.ZodOptional<z.ZodType<Ref, unknown, z.core.$ZodTypeInternals<Ref, unknown>>>;
+}, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "node", Record<never, never>, {
+  /**
+   * What a layers rail (or any listing) calls this node: its authored
+   * `label`, else what its `type` names — the component's own display label,
+   * resolved through the same path everything else resolves refs by, so a
+   * `kind:` marker never reaches a person. A placeholder awaiting generation
+   * (no `type` yet) and a linked copy (a descriptor, no `type` of its own)
+   * have no name here; the surface falls back to what it can resolve.
+   *
+   * The read type intersects this with the base `Entity.displayLabel`, which
+   * is never `undefined`, so the intersection reads as `string`. The canvas
+   * node view re-types the field optional at its seam.
+   */
+  readonly displayLabel: ({
+    member,
+    config
+  }: ComputedInput) => string | undefined;
+}, false>;
+/**
+ * `CanvasConfig` — the design-file config TYPE. Owns placement, content, and AI provenance (flat,
+ * ref-related), DRAWS ON a system, and derives the same agent-tool catalog (`operation`/`tool`) as
+ * the system so its design-file CRUD tools project from it.
+ *
+ * A source, not a read-through window onto every one of the system's kinds. A node's `type` carries
+ * the source it points into (`component:actions/Button@<slug>`), so one resolution path serves both
+ * and nothing has to know that THIS config borrows a whole kind. Read-only stays read-only: a
+ * source's items resolve through their own config, so there is no local collection to offer CRUD
+ * over.
+ */
+declare const CanvasConfig: ConfigClass<{
+  canvases: EntityClass<z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "canvas", Record<never, never>, Record<never, never>, false>;
+  pages: EntityClass<z.ZodObject<{
+    canvas: EntityClass<z.ZodObject<{
+      name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "canvas", Record<never, never>, Record<never, never>, false>;
+    name: z.ZodOptional<z.ZodString>;
+    urlKey: z.ZodOptional<z.ZodString>;
+    sortOrder: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "page", Record<never, never>, Record<never, never>, false>;
+  nodes: EntityClass<z.ZodObject<{
+    type: z.ZodOptional<z.ZodUnion<readonly [Omit<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`.";
+      };
+      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;
+      };
+      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;
+      };
+      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[];
+      };
+    }, {
+      readonly slots: ({
+        config,
+        path,
+        member
+      }: ComputedInput) => string[];
+    }, false>, "ref"> & {
+      ref<const Path extends PathOf<"component">>(path: Path): ComponentReference<ComponentContractOf<Path>>;
+    }, EntityClass<z.ZodObject<{
+      categories: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      codepoint: z.ZodOptional<z.ZodNumber>;
+      knockoutVariants: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>, z.ZodObject<{
+      module: z.ZodOptional<z.ZodString>;
+      version: z.ZodOptional<z.ZodString>;
+      metadata: z.ZodOptional<z.ZodObject<{
+        from: EntityClass<z.ZodObject<{
+          version: z.ZodOptional<z.ZodString>;
+          exports: z.ZodOptional<SubEntityClass<z.ZodObject<{}, z.core.$strict>>>;
+        }, z.core.$strict>, z.ZodObject<Record<never, never>, z.core.$strip>, "package", Record<never, never>, Record<never, never>, false>;
+        format: z.ZodEnum<{
+          uds: "uds";
+          phosphor: "phosphor";
+        }>;
+      }, z.core.$strict>>;
+      sizes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+      variants: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      component: z.ZodOptional<z.ZodObject<{
+        __ref: z.ZodString;
+      }, z.core.$strip>>;
+    }, z.core.$strict>, "icon", Record<never, never>, Record<never, never>, false>, 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>, z.ZodObject<{
+      __ref: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      __ref: z.ZodEnum<{
+        "spec:Slot": "spec:Slot";
+        "spec:Fragment": "spec:Fragment";
+      }>;
+    }, z.core.$strip>]>>;
+    props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    children: z.ZodOptional<z.ZodArray<z.ZodType<Ref, unknown, z.core.$ZodTypeInternals<Ref, unknown>>>>;
+    slots: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodType<Ref, unknown, z.core.$ZodTypeInternals<Ref, unknown>>>>>;
+    visible: z.ZodOptional<z.ZodUnknown>;
+    repeat: z.ZodOptional<z.ZodUnknown>;
+    ref: z.ZodOptional<z.ZodUnknown>;
+    locked: z.ZodOptional<z.ZodBoolean>;
+    label: z.ZodOptional<z.ZodString>;
+    page: z.ZodOptional<z.ZodObject<{
+      __ref: z.ZodString;
+    }, z.core.$strip>>;
+    parent: z.ZodOptional<z.ZodType<Ref, unknown, z.core.$ZodTypeInternals<Ref, unknown>>>;
+    size: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+      type: z.ZodLiteral<"custom">;
+      width: z.ZodNumber;
+      height: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"device">;
+      ref: EntityClass<z.ZodObject<{
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+        name: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "device", Record<never, never>, Record<never, never>, false>;
+    }, z.core.$strip>], "type">>;
+    x: z.ZodOptional<z.ZodNumber>;
+    y: z.ZodOptional<z.ZodNumber>;
+    collapsed: z.ZodOptional<z.ZodBoolean>;
+    order: z.ZodOptional<z.ZodNumber>;
+    linkedSource: z.ZodOptional<z.ZodUnknown>;
+    state: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    generation: z.ZodOptional<z.ZodObject<{
+      __ref: z.ZodString;
+    }, z.core.$strip>>;
+    duplicatedFrom: z.ZodOptional<z.ZodType<Ref, unknown, z.core.$ZodTypeInternals<Ref, unknown>>>;
+  }, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "node", Record<never, never>, {
+    /**
+     * What a layers rail (or any listing) calls this node: its authored
+     * `label`, else what its `type` names — the component's own display label,
+     * resolved through the same path everything else resolves refs by, so a
+     * `kind:` marker never reaches a person. A placeholder awaiting generation
+     * (no `type` yet) and a linked copy (a descriptor, no `type` of its own)
+     * have no name here; the surface falls back to what it can resolve.
+     *
+     * The read type intersects this with the base `Entity.displayLabel`, which
+     * is never `undefined`, so the intersection reads as `string`. The canvas
+     * node view re-types the field optional at its seam.
+     */
+    readonly displayLabel: ({
+      member,
+      config
+    }: ComputedInput) => string | undefined;
+  }, false>;
+  chats: EntityClass<z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "ai-chat", Record<never, never>, Record<never, never>, false>;
+  messages: EntityClass<z.ZodObject<{
+    chat: EntityClass<z.ZodObject<{
+      title: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "ai-chat", Record<never, never>, Record<never, never>, false>;
+    role: z.ZodEnum<{
+      user: "user";
+      assistant: "assistant";
+    }>;
+    content: z.ZodString;
+    modelId: z.ZodOptional<z.ZodString>;
+    sentAt: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "ai-message", Record<never, never>, Record<never, never>, false>;
+  flows: EntityClass<z.ZodObject<{
+    origin: z.ZodEnum<{
+      chat: "chat";
+      comment: "comment";
+      mcp: "mcp";
+      sidebar: "sidebar";
+      paste: "paste";
+      "figma-paste": "figma-paste";
+      duplicate: "duplicate";
+    }>;
+    lane: z.ZodOptional<z.ZodEnum<{
+      chat: "chat";
+      comment: "comment";
+      huddle: "huddle";
+      "paint-style": "paint-style";
+      "figma-import": "figma-import";
+      workspace: "workspace";
+      mcp: "mcp";
+    }>>;
+    modelId: z.ZodOptional<z.ZodString>;
+    multiAgentMode: z.ZodOptional<z.ZodEnum<{
+      huddle: "huddle";
+      single: "single";
+      fanout: "fanout";
+    }>>;
+    agentCount: z.ZodOptional<z.ZodNumber>;
+    agentNames: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    message: z.ZodOptional<z.ZodObject<{
+      __ref: z.ZodString;
+    }, z.core.$strip>>;
+  }, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "ai-flow", Record<never, never>, Record<never, never>, false>;
+  generations: EntityClass<z.ZodObject<{
+    flow: z.ZodOptional<z.ZodObject<{
+      __ref: z.ZodString;
+    }, z.core.$strip>>;
+    parentNode: z.ZodOptional<z.ZodObject<{
+      __ref: z.ZodString;
+    }, z.core.$strip>>;
+    iterationNumber: z.ZodOptional<z.ZodNumber>;
+    description: z.ZodOptional<z.ZodString>;
+    instructions: z.ZodOptional<z.ZodString>;
+    generatedAt: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "ai-generation", Record<never, never>, Record<never, never>, false>;
+  systems: EntityClass<z.ZodObject<{
+    systemId: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "system-source", Record<never, never>, Record<never, never>, false>;
+}, {
+  operations: DerivedEntityClass<z.ZodObject<{
+    kind: z.ZodString;
+    verb: z.ZodString;
+    readOnly: z.ZodBoolean;
+    label: z.ZodString;
+    description: z.ZodString;
+    scope: z.ZodString;
+    creates: z.ZodBoolean;
+    approval: z.ZodOptional<z.ZodEnum<{
+      destructive: "destructive";
+      "reference-change": "reference-change";
+    }>>;
+  }, z.core.$strip>, {
+    inputSchema: ({
+      member: op,
+      config
+    }: Omit<ComputedInput, "member"> & {
+      member: {
+        kind: string;
+        verb: string;
+        readOnly: boolean;
+        label: string;
+        description: string;
+        scope: string;
+        creates: boolean;
+        approval?: "destructive" | "reference-change" | undefined;
+      };
+    }) => z.ZodTypeAny<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> | undefined;
+    execute: ({
+      member: op,
+      config: declaring
+    }: Omit<ComputedInput, "member"> & {
+      member: {
+        kind: string;
+        verb: string;
+        readOnly: boolean;
+        label: string;
+        description: string;
+        scope: string;
+        creates: boolean;
+        approval?: "destructive" | "reference-change" | undefined;
+      };
+    }) => ((input: Record<string, unknown>, config: Config) => unknown) | undefined;
+    field: ({
+      member: op
+    }: Omit<ComputedInput, "member"> & {
+      member: {
+        kind: string;
+        verb: string;
+        readOnly: boolean;
+        label: string;
+        description: string;
+        scope: string;
+        creates: boolean;
+        approval?: "destructive" | "reference-change" | undefined;
+      };
+    }) => string | undefined;
+    title: ({
+      member: op,
+      config
+    }: Omit<ComputedInput, "member"> & {
+      member: {
+        kind: string;
+        verb: string;
+        readOnly: boolean;
+        label: string;
+        description: string;
+        scope: string;
+        creates: boolean;
+        approval?: "destructive" | "reference-change" | undefined;
+      };
+    }) => ((entity: string) => string) | undefined;
+    example: ({
+      member: op,
+      config
+    }: Omit<ComputedInput, "member"> & {
+      member: {
+        kind: string;
+        verb: string;
+        readOnly: boolean;
+        label: string;
+        description: string;
+        scope: string;
+        creates: boolean;
+        approval?: "destructive" | "reference-change" | undefined;
+      };
+    }) => Record<string, unknown> | undefined;
+  }>;
+  tools: DerivedEntityClass<z.ZodObject<{
+    operation: DerivedEntityClass<z.ZodObject<{
+      kind: z.ZodString;
+      verb: z.ZodString;
+      readOnly: z.ZodBoolean;
+      label: z.ZodString;
+      description: z.ZodString;
+      scope: z.ZodString;
+      creates: z.ZodBoolean;
+      approval: z.ZodOptional<z.ZodEnum<{
+        destructive: "destructive";
+        "reference-change": "reference-change";
+      }>>;
+    }, z.core.$strip>, {
+      inputSchema: ({
+        member: op,
+        config
+      }: Omit<ComputedInput, "member"> & {
+        member: {
+          kind: string;
+          verb: string;
+          readOnly: boolean;
+          label: string;
+          description: string;
+          scope: string;
+          creates: boolean;
+          approval?: "destructive" | "reference-change" | undefined;
+        };
+      }) => z.ZodTypeAny<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> | undefined;
+      execute: ({
+        member: op,
+        config: declaring
+      }: Omit<ComputedInput, "member"> & {
+        member: {
+          kind: string;
+          verb: string;
+          readOnly: boolean;
+          label: string;
+          description: string;
+          scope: string;
+          creates: boolean;
+          approval?: "destructive" | "reference-change" | undefined;
+        };
+      }) => ((input: Record<string, unknown>, config: Config) => unknown) | undefined;
+      field: ({
+        member: op
+      }: Omit<ComputedInput, "member"> & {
+        member: {
+          kind: string;
+          verb: string;
+          readOnly: boolean;
+          label: string;
+          description: string;
+          scope: string;
+          creates: boolean;
+          approval?: "destructive" | "reference-change" | undefined;
+        };
+      }) => string | undefined;
+      title: ({
+        member: op,
+        config
+      }: Omit<ComputedInput, "member"> & {
+        member: {
+          kind: string;
+          verb: string;
+          readOnly: boolean;
+          label: string;
+          description: string;
+          scope: string;
+          creates: boolean;
+          approval?: "destructive" | "reference-change" | undefined;
+        };
+      }) => ((entity: string) => string) | undefined;
+      example: ({
+        member: op,
+        config
+      }: Omit<ComputedInput, "member"> & {
+        member: {
+          kind: string;
+          verb: string;
+          readOnly: boolean;
+          label: string;
+          description: string;
+          scope: string;
+          creates: boolean;
+          approval?: "destructive" | "reference-change" | undefined;
+        };
+      }) => Record<string, unknown> | undefined;
+    }>;
+    name: z.ZodString;
+    description: z.ZodString;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+  }, z.core.$strip>, {
+    kind: (input: ComputedInput) => string | undefined;
+    verb: (input: ComputedInput) => string | undefined;
+    readOnly: ({
+      member,
+      config
+    }: Omit<ComputedInput, "member"> & {
+      member: {
+        operation: {
+          __ref: string;
+        };
+        name: string;
+        description: string;
+        enabled: boolean;
+      };
+    }) => boolean;
+    inputSchema: (input: ComputedInput) => z.ZodTypeAny<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> | undefined;
+    execute: (input: ComputedInput) => ((input: Record<string, unknown>, config: Config) => unknown) | undefined;
+    action: (input: ComputedInput) => string | undefined;
+    field: (input: ComputedInput) => string | undefined;
+    scope: (input: ComputedInput) => string | undefined;
+    approval: (input: ComputedInput) => "destructive" | "reference-change" | undefined;
+    label: (input: ComputedInput) => string | undefined;
+    shortLabel: (input: ComputedInput) => string | undefined;
+    example: (input: ComputedInput) => Record<string, unknown> | undefined;
+  }>;
+}, {
+  systems: () => typeof System | typeof ReactNativeSystem;
+}>;
+/**
+ * Build a plain (in-memory) canvas target: borrows the system read-only, under its own `name` as the
+ * slug, and seeds the canvas + page it starts with. Enough to project tools or run an eval; the
+ * live form is the studio session (`apps/studio/src/configs/canvas/canvas-session.ts`).
+ */
+declare function createCanvasConfig(system: AnySystemConfig): ConfigInstance<{
+  canvases: EntityClass<z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "canvas", Record<never, never>, Record<never, never>, false>;
+  pages: EntityClass<z.ZodObject<{
+    canvas: EntityClass<z.ZodObject<{
+      name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "canvas", Record<never, never>, Record<never, never>, false>;
+    name: z.ZodOptional<z.ZodString>;
+    urlKey: z.ZodOptional<z.ZodString>;
+    sortOrder: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "page", Record<never, never>, Record<never, never>, false>;
+  nodes: EntityClass<z.ZodObject<{
+    type: z.ZodOptional<z.ZodUnion<readonly [Omit<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`.";
+      };
+      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;
+      };
+      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;
+      };
+      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[];
+      };
+    }, {
+      readonly slots: ({
+        config,
+        path,
+        member
+      }: ComputedInput) => string[];
+    }, false>, "ref"> & {
+      ref<const Path extends PathOf<"component">>(path: Path): ComponentReference<ComponentContractOf<Path>>;
+    }, EntityClass<z.ZodObject<{
+      categories: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      codepoint: z.ZodOptional<z.ZodNumber>;
+      knockoutVariants: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>, z.ZodObject<{
+      module: z.ZodOptional<z.ZodString>;
+      version: z.ZodOptional<z.ZodString>;
+      metadata: z.ZodOptional<z.ZodObject<{
+        from: EntityClass<z.ZodObject<{
+          version: z.ZodOptional<z.ZodString>;
+          exports: z.ZodOptional<SubEntityClass<z.ZodObject<{}, z.core.$strict>>>;
+        }, z.core.$strict>, z.ZodObject<Record<never, never>, z.core.$strip>, "package", Record<never, never>, Record<never, never>, false>;
+        format: z.ZodEnum<{
+          uds: "uds";
+          phosphor: "phosphor";
+        }>;
+      }, z.core.$strict>>;
+      sizes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+      variants: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      component: z.ZodOptional<z.ZodObject<{
+        __ref: z.ZodString;
+      }, z.core.$strip>>;
+    }, z.core.$strict>, "icon", Record<never, never>, Record<never, never>, false>, 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>, z.ZodObject<{
+      __ref: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      __ref: z.ZodEnum<{
+        "spec:Slot": "spec:Slot";
+        "spec:Fragment": "spec:Fragment";
+      }>;
+    }, z.core.$strip>]>>;
+    props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    children: z.ZodOptional<z.ZodArray<z.ZodType<Ref, unknown, z.core.$ZodTypeInternals<Ref, unknown>>>>;
+    slots: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodType<Ref, unknown, z.core.$ZodTypeInternals<Ref, unknown>>>>>;
+    visible: z.ZodOptional<z.ZodUnknown>;
+    repeat: z.ZodOptional<z.ZodUnknown>;
+    ref: z.ZodOptional<z.ZodUnknown>;
+    locked: z.ZodOptional<z.ZodBoolean>;
+    label: z.ZodOptional<z.ZodString>;
+    page: z.ZodOptional<z.ZodObject<{
+      __ref: z.ZodString;
+    }, z.core.$strip>>;
+    parent: z.ZodOptional<z.ZodType<Ref, unknown, z.core.$ZodTypeInternals<Ref, unknown>>>;
+    size: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+      type: z.ZodLiteral<"custom">;
+      width: z.ZodNumber;
+      height: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"device">;
+      ref: EntityClass<z.ZodObject<{
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+        name: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "device", Record<never, never>, Record<never, never>, false>;
+    }, z.core.$strip>], "type">>;
+    x: z.ZodOptional<z.ZodNumber>;
+    y: z.ZodOptional<z.ZodNumber>;
+    collapsed: z.ZodOptional<z.ZodBoolean>;
+    order: z.ZodOptional<z.ZodNumber>;
+    linkedSource: z.ZodOptional<z.ZodUnknown>;
+    state: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    generation: z.ZodOptional<z.ZodObject<{
+      __ref: z.ZodString;
+    }, z.core.$strip>>;
+    duplicatedFrom: z.ZodOptional<z.ZodType<Ref, unknown, z.core.$ZodTypeInternals<Ref, unknown>>>;
+  }, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "node", Record<never, never>, {
+    /**
+     * What a layers rail (or any listing) calls this node: its authored
+     * `label`, else what its `type` names — the component's own display label,
+     * resolved through the same path everything else resolves refs by, so a
+     * `kind:` marker never reaches a person. A placeholder awaiting generation
+     * (no `type` yet) and a linked copy (a descriptor, no `type` of its own)
+     * have no name here; the surface falls back to what it can resolve.
+     *
+     * The read type intersects this with the base `Entity.displayLabel`, which
+     * is never `undefined`, so the intersection reads as `string`. The canvas
+     * node view re-types the field optional at its seam.
+     */
+    readonly displayLabel: ({
+      member,
+      config
+    }: ComputedInput) => string | undefined;
+  }, false>;
+  chats: EntityClass<z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "ai-chat", Record<never, never>, Record<never, never>, false>;
+  messages: EntityClass<z.ZodObject<{
+    chat: EntityClass<z.ZodObject<{
+      title: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "ai-chat", Record<never, never>, Record<never, never>, false>;
+    role: z.ZodEnum<{
+      user: "user";
+      assistant: "assistant";
+    }>;
+    content: z.ZodString;
+    modelId: z.ZodOptional<z.ZodString>;
+    sentAt: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "ai-message", Record<never, never>, Record<never, never>, false>;
+  flows: EntityClass<z.ZodObject<{
+    origin: z.ZodEnum<{
+      chat: "chat";
+      comment: "comment";
+      mcp: "mcp";
+      sidebar: "sidebar";
+      paste: "paste";
+      "figma-paste": "figma-paste";
+      duplicate: "duplicate";
+    }>;
+    lane: z.ZodOptional<z.ZodEnum<{
+      chat: "chat";
+      comment: "comment";
+      huddle: "huddle";
+      "paint-style": "paint-style";
+      "figma-import": "figma-import";
+      workspace: "workspace";
+      mcp: "mcp";
+    }>>;
+    modelId: z.ZodOptional<z.ZodString>;
+    multiAgentMode: z.ZodOptional<z.ZodEnum<{
+      huddle: "huddle";
+      single: "single";
+      fanout: "fanout";
+    }>>;
+    agentCount: z.ZodOptional<z.ZodNumber>;
+    agentNames: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    message: z.ZodOptional<z.ZodObject<{
+      __ref: z.ZodString;
+    }, z.core.$strip>>;
+  }, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "ai-flow", Record<never, never>, Record<never, never>, false>;
+  generations: EntityClass<z.ZodObject<{
+    flow: z.ZodOptional<z.ZodObject<{
+      __ref: z.ZodString;
+    }, z.core.$strip>>;
+    parentNode: z.ZodOptional<z.ZodObject<{
+      __ref: z.ZodString;
+    }, z.core.$strip>>;
+    iterationNumber: z.ZodOptional<z.ZodNumber>;
+    description: z.ZodOptional<z.ZodString>;
+    instructions: z.ZodOptional<z.ZodString>;
+    generatedAt: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "ai-generation", Record<never, never>, Record<never, never>, false>;
+  systems: EntityClass<z.ZodObject<{
+    systemId: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "system-source", Record<never, never>, Record<never, never>, false>;
+}, {
+  operations: DerivedEntityClass<z.ZodObject<{
+    kind: z.ZodString;
+    verb: z.ZodString;
+    readOnly: z.ZodBoolean;
+    label: z.ZodString;
+    description: z.ZodString;
+    scope: z.ZodString;
+    creates: z.ZodBoolean;
+    approval: z.ZodOptional<z.ZodEnum<{
+      destructive: "destructive";
+      "reference-change": "reference-change";
+    }>>;
+  }, z.core.$strip>, {
+    inputSchema: ({
+      member: op,
+      config
+    }: Omit<ComputedInput, "member"> & {
+      member: {
+        kind: string;
+        verb: string;
+        readOnly: boolean;
+        label: string;
+        description: string;
+        scope: string;
+        creates: boolean;
+        approval?: "destructive" | "reference-change" | undefined;
+      };
+    }) => z.ZodTypeAny<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> | undefined;
+    execute: ({
+      member: op,
+      config: declaring
+    }: Omit<ComputedInput, "member"> & {
+      member: {
+        kind: string;
+        verb: string;
+        readOnly: boolean;
+        label: string;
+        description: string;
+        scope: string;
+        creates: boolean;
+        approval?: "destructive" | "reference-change" | undefined;
+      };
+    }) => ((input: Record<string, unknown>, config: Config) => unknown) | undefined;
+    field: ({
+      member: op
+    }: Omit<ComputedInput, "member"> & {
+      member: {
+        kind: string;
+        verb: string;
+        readOnly: boolean;
+        label: string;
+        description: string;
+        scope: string;
+        creates: boolean;
+        approval?: "destructive" | "reference-change" | undefined;
+      };
+    }) => string | undefined;
+    title: ({
+      member: op,
+      config
+    }: Omit<ComputedInput, "member"> & {
+      member: {
+        kind: string;
+        verb: string;
+        readOnly: boolean;
+        label: string;
+        description: string;
+        scope: string;
+        creates: boolean;
+        approval?: "destructive" | "reference-change" | undefined;
+      };
+    }) => ((entity: string) => string) | undefined;
+    example: ({
+      member: op,
+      config
+    }: Omit<ComputedInput, "member"> & {
+      member: {
+        kind: string;
+        verb: string;
+        readOnly: boolean;
+        label: string;
+        description: string;
+        scope: string;
+        creates: boolean;
+        approval?: "destructive" | "reference-change" | undefined;
+      };
+    }) => Record<string, unknown> | undefined;
+  }>;
+  tools: DerivedEntityClass<z.ZodObject<{
+    operation: DerivedEntityClass<z.ZodObject<{
+      kind: z.ZodString;
+      verb: z.ZodString;
+      readOnly: z.ZodBoolean;
+      label: z.ZodString;
+      description: z.ZodString;
+      scope: z.ZodString;
+      creates: z.ZodBoolean;
+      approval: z.ZodOptional<z.ZodEnum<{
+        destructive: "destructive";
+        "reference-change": "reference-change";
+      }>>;
+    }, z.core.$strip>, {
+      inputSchema: ({
+        member: op,
+        config
+      }: Omit<ComputedInput, "member"> & {
+        member: {
+          kind: string;
+          verb: string;
+          readOnly: boolean;
+          label: string;
+          description: string;
+          scope: string;
+          creates: boolean;
+          approval?: "destructive" | "reference-change" | undefined;
+        };
+      }) => z.ZodTypeAny<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> | undefined;
+      execute: ({
+        member: op,
+        config: declaring
+      }: Omit<ComputedInput, "member"> & {
+        member: {
+          kind: string;
+          verb: string;
+          readOnly: boolean;
+          label: string;
+          description: string;
+          scope: string;
+          creates: boolean;
+          approval?: "destructive" | "reference-change" | undefined;
+        };
+      }) => ((input: Record<string, unknown>, config: Config) => unknown) | undefined;
+      field: ({
+        member: op
+      }: Omit<ComputedInput, "member"> & {
+        member: {
+          kind: string;
+          verb: string;
+          readOnly: boolean;
+          label: string;
+          description: string;
+          scope: string;
+          creates: boolean;
+          approval?: "destructive" | "reference-change" | undefined;
+        };
+      }) => string | undefined;
+      title: ({
+        member: op,
+        config
+      }: Omit<ComputedInput, "member"> & {
+        member: {
+          kind: string;
+          verb: string;
+          readOnly: boolean;
+          label: string;
+          description: string;
+          scope: string;
+          creates: boolean;
+          approval?: "destructive" | "reference-change" | undefined;
+        };
+      }) => ((entity: string) => string) | undefined;
+      example: ({
+        member: op,
+        config
+      }: Omit<ComputedInput, "member"> & {
+        member: {
+          kind: string;
+          verb: string;
+          readOnly: boolean;
+          label: string;
+          description: string;
+          scope: string;
+          creates: boolean;
+          approval?: "destructive" | "reference-change" | undefined;
+        };
+      }) => Record<string, unknown> | undefined;
+    }>;
+    name: z.ZodString;
+    description: z.ZodString;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+  }, z.core.$strip>, {
+    kind: (input: ComputedInput) => string | undefined;
+    verb: (input: ComputedInput) => string | undefined;
+    readOnly: ({
+      member,
+      config
+    }: Omit<ComputedInput, "member"> & {
+      member: {
+        operation: {
+          __ref: string;
+        };
+        name: string;
+        description: string;
+        enabled: boolean;
+      };
+    }) => boolean;
+    inputSchema: (input: ComputedInput) => z.ZodTypeAny<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> | undefined;
+    execute: (input: ComputedInput) => ((input: Record<string, unknown>, config: Config) => unknown) | undefined;
+    action: (input: ComputedInput) => string | undefined;
+    field: (input: ComputedInput) => string | undefined;
+    scope: (input: ComputedInput) => string | undefined;
+    approval: (input: ComputedInput) => "destructive" | "reference-change" | undefined;
+    label: (input: ComputedInput) => string | undefined;
+    shortLabel: (input: ComputedInput) => string | undefined;
+    example: (input: ComputedInput) => Record<string, unknown> | undefined;
+  }>;
+}>;
+//#endregion
+export { AiChat, AiFlow, AiFlowOrigin, AiGeneration, AiMessage, AiMultiAgentMode, Canvas, CanvasConfig, Node, Page, SystemSource, createCanvasConfig };