aeon-ui-engine 1.0.2 → 1.1.0

package/packages/schemas/dist/index.js

@@ -0,0 +1,701 @@
+// src/schema-builder.ts
+function componentSchema(opts) {
+  const props = opts.props ?? {};
+  return {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    $id: opts.id,
+    title: opts.title,
+    description: opts.description,
+    type: "object",
+    additionalProperties: false,
+    required: ["component", "scope"],
+    properties: {
+      component: { const: opts.title.replace(/\s+/g, "") },
+      scope: { const: opts.scope },
+      parts: {
+        type: "array",
+        description: "Anatomy part keys \u2014 map to data-aeon-part",
+        items: { type: "string", enum: [...opts.parts] },
+        uniqueItems: true
+      },
+      states: {
+        type: "array",
+        description: "Allowed data-aeon-state values (stable states only)",
+        items: { type: "string", enum: [...opts.states] },
+        uniqueItems: true
+      },
+      props: {
+        type: "object",
+        additionalProperties: false,
+        properties: props
+      },
+      slots: {
+        type: "object",
+        description: "Named composition slots / compound parts",
+        additionalProperties: { type: "string" },
+        properties: Object.fromEntries(
+          Object.entries(opts.slots ?? {}).map(([k, v]) => [k, { const: v, description: v }])
+        )
+      },
+      machine: {
+        type: ["string", "null"],
+        description: "XState machine export from @aeon-ui/primitives, or null if prop/React driven",
+        const: opts.machine ?? null
+      },
+      runtime: {
+        type: "string",
+        description: "How headless state is driven at runtime",
+        const: opts.runtime ?? "useAeonMachine"
+      },
+      events: {
+        type: "array",
+        items: { type: "string", enum: [...opts.events ?? []] }
+      },
+      examples: {
+        type: "array",
+        items: { type: "string" },
+        default: opts.examples ?? []
+      }
+    },
+    "x-aeon": {
+      scope: opts.scope,
+      parts: [...opts.parts],
+      states: [...opts.states],
+      machine: opts.machine ?? null,
+      runtime: opts.runtime ?? "useAeonMachine",
+      events: [...opts.events ?? []],
+      slots: opts.slots ?? {},
+      examples: [...opts.examples ?? []]
+    }
+  };
+}
+
+// src/components.ts
+var componentSchemas = {
+  button: componentSchema({
+    id: "https://aeon-ui.com/schemas/button.json",
+    title: "Button",
+    description: "Action control. status is a prop projection (not an in-tree machine). Never invent parallel useState for lifecycle.",
+    scope: "button",
+    parts: ["root", "group", "label", "icon"],
+    states: ["idle", "pending", "success", "failure", "disabled"],
+    machine: "buttonLifecycleMachine",
+    runtime: "status prop",
+    props: {
+      status: {
+        type: "string",
+        enum: ["idle", "pending", "success", "failure", "disabled"],
+        default: "idle"
+      },
+      variant: { type: "string", enum: ["solid", "outline", "ghost", "link"] },
+      size: { type: "string", enum: ["sm", "md", "lg"] },
+      disabled: { type: "boolean" }
+    },
+    slots: { Root: "button.root", Group: "button.group", Label: "button.label", Icon: "button.icon" },
+    examples: [
+      '<Button.Root status="pending" aria-busy>Saving\u2026</Button.Root>',
+      "const [snap, send] = useAeonMachine(buttonLifecycleMachine)\n<Button.Root status={snap.value as ButtonStatus} onClick={() => send({ type: 'PRESS' })} />"
+    ]
+  }),
+  async: componentSchema({
+    id: "https://aeon-ui.com/schemas/async.json",
+    title: "Async",
+    description: "Fetch region with full lifecycle totality: idle \u2192 loading \u2192 success|empty|failure. Always render every stable state in demos.",
+    scope: "async",
+    parts: ["root", "track", "segment", "readout", "readoutRail", "readoutBody", "actions"],
+    states: ["idle", "loading", "success", "empty", "failure"],
+    machine: "createAsyncMachine",
+    runtime: "useAeonMachine",
+    events: ["FETCH", "RESOLVE", "REJECT", "RESET", "STALE", "REFRESH"],
+    slots: {
+      Root: "async.root",
+      Track: "async.track",
+      Segment: "async.segment",
+      Readout: "async.readout",
+      Actions: "async.actions"
+    },
+    examples: [
+      "<Async.Root>\n  {/* Content faces via asyncStatusToContentState \u2014 not Track */}\n  <Async.Actions />\n</Async.Root>"
+    ]
+  }),
+  field: componentSchema({
+    id: "https://aeon-ui.com/schemas/field.json",
+    title: "Field",
+    description: "Parallel regions: interaction \xD7 validation \xD7 submission. Do not collapse into a single error boolean.",
+    scope: "field",
+    parts: ["root", "label", "control", "textarea", "message", "hint"],
+    states: [
+      "pristine",
+      "dirty",
+      "valid",
+      "invalid",
+      "idle",
+      "pending",
+      "interaction.pristine",
+      "interaction.dirty",
+      "validation.valid",
+      "validation.invalid",
+      "submission.idle",
+      "submission.pending"
+    ],
+    machine: "fieldMachine",
+    runtime: "useAeonMachine",
+    events: ["INPUT", "BLUR", "VALIDATE", "SUBMIT", "SUBMIT_DONE", "SUBMIT_FAIL", "RESET"],
+    slots: {
+      Root: "field.root",
+      Label: "field.label",
+      Control: "field.control",
+      Message: "field.message",
+      Hint: "field.hint"
+    }
+  }),
+  dialog: componentSchema({
+    id: "https://aeon-ui.com/schemas/dialog.json",
+    title: "Dialog",
+    description: "Modal open/closed via dialogMachine. Dismissal is a transition, not ad hoc flags.",
+    scope: "dialog",
+    parts: [
+      "root",
+      "trigger",
+      "portal",
+      "backdrop",
+      "positioner",
+      "content",
+      "title",
+      "description",
+      "closeTrigger"
+    ],
+    states: ["open", "closed"],
+    machine: "dialogMachine",
+    runtime: "useAeonMachine",
+    events: ["OPEN", "CLOSE", "TOGGLE"],
+    slots: {
+      Root: "dialog.root",
+      Trigger: "dialog.trigger",
+      Content: "dialog.content",
+      Title: "dialog.title",
+      Description: "dialog.description",
+      CloseTrigger: "dialog.closeTrigger"
+    }
+  }),
+  switch: componentSchema({
+    id: "https://aeon-ui.com/schemas/switch.json",
+    title: "Switch",
+    description: "Binary toggle via toggleMachine.",
+    scope: "switch",
+    parts: ["root", "control", "thumb", "label", "hiddenInput"],
+    states: ["checked", "unchecked"],
+    machine: "toggleMachine",
+    runtime: "useAeonMachine",
+    events: ["TOGGLE", "CHECK", "UNCHECK"],
+    slots: { Root: "switch.root", Control: "switch.control", Thumb: "switch.thumb", Label: "switch.label" }
+  }),
+  checkbox: componentSchema({
+    id: "https://aeon-ui.com/schemas/checkbox.json",
+    title: "Checkbox",
+    description: "Binary toggle via toggleMachine (same chart family as Switch).",
+    scope: "checkbox",
+    parts: ["root", "control", "indicator", "label", "hiddenInput"],
+    states: ["checked", "unchecked"],
+    machine: "toggleMachine",
+    runtime: "useAeonMachine",
+    events: ["TOGGLE", "CHECK", "UNCHECK"],
+    slots: {
+      Root: "checkbox.root",
+      Control: "checkbox.control",
+      Indicator: "checkbox.indicator",
+      Label: "checkbox.label"
+    }
+  }),
+  tabs: componentSchema({
+    id: "https://aeon-ui.com/schemas/tabs.json",
+    title: "Tabs",
+    description: "Selected tab value from tabsMachine.",
+    scope: "tabs",
+    parts: ["root", "list", "trigger", "content", "indicator"],
+    states: ["selected"],
+    machine: "tabsMachine",
+    runtime: "useAeonMachine",
+    events: ["SELECT"],
+    props: {
+      value: { type: "string", description: "Selected tab id \u2014 becomes data-aeon-state" }
+    },
+    slots: { Root: "tabs.root", List: "tabs.list", Trigger: "tabs.trigger", Content: "tabs.content" }
+  }),
+  accordion: componentSchema({
+    id: "https://aeon-ui.com/schemas/accordion.json",
+    title: "Accordion",
+    description: "Per-item open state via accordionMachine.",
+    scope: "accordion",
+    parts: ["root", "item", "itemTrigger", "itemContent", "itemIndicator"],
+    states: ["open", "closed"],
+    machine: "accordionMachine",
+    runtime: "useAeonMachine",
+    events: ["TOGGLE"],
+    slots: {
+      Root: "accordion.root",
+      Item: "accordion.item",
+      ItemTrigger: "accordion.itemTrigger",
+      ItemContent: "accordion.itemContent"
+    }
+  }),
+  popover: componentSchema({
+    id: "https://aeon-ui.com/schemas/popover.json",
+    title: "Popover",
+    description: "Floating surface \u2014 shares popoverMachine. Do not fork a duplicate open/closed chart.",
+    scope: "popover",
+    parts: ["root", "trigger", "positioner", "content", "arrow", "closeTrigger"],
+    states: ["open", "closed"],
+    machine: "popoverMachine",
+    runtime: "useAeonMachine",
+    events: ["OPEN", "CLOSE", "TOGGLE"],
+    slots: { Root: "popover.root", Trigger: "popover.trigger", Content: "popover.content" }
+  }),
+  menu: componentSchema({
+    id: "https://aeon-ui.com/schemas/menu.json",
+    title: "Menu",
+    description: "Shares popoverMachine with Popover/Select open state.",
+    scope: "menu",
+    parts: ["root", "trigger", "positioner", "content", "item", "separator"],
+    states: ["open", "closed"],
+    machine: "popoverMachine",
+    runtime: "useAeonMachine",
+    events: ["OPEN", "CLOSE", "TOGGLE"],
+    slots: { Root: "menu.root", Trigger: "menu.trigger", Content: "menu.content", Item: "menu.item" }
+  }),
+  select: componentSchema({
+    id: "https://aeon-ui.com/schemas/select.json",
+    title: "Select",
+    description: "Open/closed via popoverMachine; highlight may be React-local. Do not invent a new open machine.",
+    scope: "select",
+    parts: ["root", "trigger", "value", "icon", "positioner", "content", "item"],
+    states: ["open", "closed"],
+    machine: "popoverMachine",
+    runtime: "useAeonMachine",
+    events: ["OPEN", "CLOSE", "TOGGLE"],
+    slots: { Root: "select.root", Trigger: "select.trigger", Content: "select.content", Item: "select.item" }
+  }),
+  combobox: componentSchema({
+    id: "https://aeon-ui.com/schemas/combobox.json",
+    title: "Combobox",
+    description: "Typeahead \u2014 React useState for open/query/highlight today. Do not add a duplicate floating machine without COMPONENT_CHECKLIST.",
+    scope: "combobox",
+    parts: ["root", "input", "icon", "content", "item", "empty"],
+    states: ["open", "closed"],
+    machine: null,
+    runtime: "useState",
+    slots: { Root: "combobox.root", Input: "combobox.input", Content: "combobox.content", Item: "combobox.item" }
+  }),
+  tooltip: componentSchema({
+    id: "https://aeon-ui.com/schemas/tooltip.json",
+    title: "Tooltip",
+    description: "Open via React useState. Touch tap toggles.",
+    scope: "tooltip",
+    parts: ["root", "trigger", "positioner", "content", "arrow"],
+    states: ["open", "closed"],
+    machine: null,
+    runtime: "useState",
+    slots: { Root: "tooltip.root", Trigger: "tooltip.trigger", Content: "tooltip.content" }
+  }),
+  toast: componentSchema({
+    id: "https://aeon-ui.com/schemas/toast.json",
+    title: "Toast",
+    description: "Per-item visibility via toastMachine.",
+    scope: "toast",
+    parts: ["viewport", "root", "title", "description", "closeTrigger"],
+    states: ["visible", "hidden"],
+    machine: "toastMachine",
+    runtime: "useAeonMachine",
+    events: ["SHOW", "HIDE", "DISMISS"],
+    slots: {
+      Provider: "toast.provider",
+      Viewport: "toast.viewport",
+      Root: "toast.root",
+      Title: "toast.title",
+      Description: "toast.description"
+    }
+  }),
+  scroll: componentSchema({
+    id: "https://aeon-ui.com/schemas/scroll.json",
+    title: "Scroll",
+    description: "Derived overflow/edge snapshot via getScrollSnapshot() \u2014 no XState machine.",
+    scope: "scroll",
+    parts: ["root", "viewport", "content"],
+    states: ["idle", "start", "middle", "end", "overflow-x", "overflow-y", "overflow-both"],
+    machine: null,
+    runtime: "getScrollSnapshot",
+    slots: { Root: "scroll.root", Viewport: "scroll.viewport", Content: "scroll.content" }
+  }),
+  progress: componentSchema({
+    id: "https://aeon-ui.com/schemas/progress.json",
+    title: "Progress",
+    description: "Prop-driven progress: value + indeterminate \u2192 idle | loading | complete.",
+    scope: "progress",
+    parts: ["root", "track", "range", "label"],
+    states: ["idle", "loading", "complete"],
+    machine: null,
+    runtime: "props",
+    props: {
+      value: { type: "number", minimum: 0, maximum: 100 },
+      indeterminate: { type: "boolean" }
+    },
+    slots: { Root: "progress.root", Track: "progress.track", Range: "progress.range", Label: "progress.label" }
+  })
+};
+var catalog = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://aeon-ui.com/schemas/catalog.json",
+  title: "Aeon UI Component Catalog",
+  description: "Machine-legible index of Aeon UI components. Prefer these schemas over inventing props, states, or boolean UI flags.",
+  version: "0.1.0",
+  principle: "UI = f(state)",
+  attributes: ["data-aeon-scope", "data-aeon-part", "data-aeon-state"],
+  components: Object.keys(componentSchemas),
+  schemas: componentSchemas
+};
+
+// src/prompts.ts
+var AEON_SYSTEM_PROMPT = `# Aeon UI \u2014 agent system prompt
+
+You are building UI with **Aeon UI**, a React component library powered by finite statecharts.
+
+## Order of work (mandatory)
+1. **Build the state machines first** \u2014 name every lifecycle the UX needs (states + events). Prefer machines from \`@aeon-ui/primitives\` (or documented prop projections such as Button \`status\`).
+2. **Then project UI from those machines** \u2014 compound parts, copy, and layout exist only to reflect the chart. Never invent UI for states that are not in a machine.
+3. **UI = f(state)** \u2014 the DOM exposes \`data-aeon-scope\`, \`data-aeon-part\`, \`data-aeon-state\`. Style targets those attributes. Do not drive the same concern with parallel React \`useState\` flags.
+
+## Non-negotiable rules
+1. Do not duplicate open/checked/lifecycle in \`useState\` when a machine exists in \`@aeon-ui/primitives\`.
+2. **Button \`status\` is a prop** (\`idle|pending|success|failure|disabled\`). Optional: drive it from \`buttonLifecycleMachine\` via \`useAeonMachine\` in app code.
+3. **Select / Menu / Popover** share \`popoverMachine\` \u2014 never fork another open/closed chart.
+4. **Combobox** and **Tooltip** use React state today \u2014 do not add floating machines without the component checklist.
+5. **Scroll** uses \`getScrollSnapshot()\` \u2014 no XState machine.
+6. If a machine lists N stable states, the UI must represent all N (totality).
+7. Prefer \`@aeon-ui/react\` (headless) or \`@aeon-ui/ui\` (styled). Relative TS imports use \`.js\` extensions inside the Aeon monorepo only.
+8. Primitives stay **universal** \u2014 never invent niche components (dating, colour-blind test, pong). Compose from generic parts.
+
+## DOM contract
+Every interactive surface sets anatomy via \`partAttrs\` from \`@aeon-ui/core\`:
+- \`data-aeon-scope\` \u2014 family (\`button\`, \`async\`, \`field\`, \u2026)
+- \`data-aeon-part\` \u2014 anatomy key (\`root\`, \`trigger\`, \u2026)
+- \`data-aeon-state\` \u2014 allowed snapshot / prop state only
+
+## Before writing JSX
+1. Enumerate machines (or documented status props) for the flow \u2014 states and events.
+2. Read the component JSON Schema from \`@aeon-ui/schemas\` (or pasted catalog) and match parts to those charts.
+3. Compose with documented compound parts (\`Dialog.Root\`, \`Field.Control\`, \u2026).
+4. Wire events to machine events or documented props \u2014 never invent \`isLoading && !isError && hasData\` spaghetti when a named state exists.
+`;
+var STATECHART_PROMPTS = {
+  async: `## Async region statechart
+States: idle \u2192 loading \u2192 (success | empty | failure); REFRESH from success/empty/failure; STALE flag while success.
+Events: FETCH, RESOLVE{data}, REJECT{error}, RESET, STALE, REFRESH.
+Rule: Render track segments for idle, loading, success, empty, failure. Never hide empty/failure behind a generic spinner.`,
+  field: `## Field parallel statechart
+Regions:
+- interaction: pristine | dirty
+- validation: valid | invalid
+- submission: idle | pending
+Events: INPUT, BLUR, VALIDATE{valid}, SUBMIT, SUBMIT_DONE, SUBMIT_FAIL, RESET.
+Rule: Do not collapse validation + submission into one \`error\` boolean. Message UI follows validation region; pending follows submission.`,
+  button: `## Button lifecycle
+Preferred headless API: \`status\` prop \u2208 idle | pending | success | failure | disabled.
+Optional machine: buttonLifecycleMachine with PRESS / RESOLVE / REJECT / RESET.
+Rule: Pending must set aria-busy. Do not use disabled alone to mean "saving".`,
+  dialog: `## Dialog statechart
+States: open | closed. Events: OPEN, CLOSE, TOGGLE.
+Rule: Backdrop click and Escape are CLOSE transitions. Title/Description are required for a11y when open.`,
+  popoverFamily: `## Popover family (Popover, Menu, Select open state)
+Machine: popoverMachine \u2014 states open | closed.
+Rule: Reuse this chart. Never create selectOpenMachine / menuOpenMachine forks.`,
+  toggle: `## Switch / Checkbox
+Machine: toggleMachine \u2014 checked | unchecked. Events: TOGGLE, CHECK, UNCHECK.
+Rule: Hidden input stays in sync with snapshot for forms.`
+};
+var GENERATIVE_UI_EXAMPLE = {
+  prompt: "Create a multi-step checkout form with error handling.",
+  schemaOutput: {
+    component: "CheckoutFlow",
+    steps: [
+      {
+        id: "shipping",
+        fields: [
+          { component: "Field", name: "email", states: ["interaction", "validation", "submission"] },
+          { component: "Field", name: "address", states: ["interaction", "validation", "submission"] }
+        ]
+      },
+      {
+        id: "payment",
+        fields: [{ component: "Field", name: "card", states: ["interaction", "validation", "submission"] }]
+      }
+    ],
+    submit: {
+      component: "Button",
+      statusMachine: "buttonLifecycleMachine",
+      allowedStatuses: ["idle", "pending", "success", "failure"]
+    },
+    asyncRegion: {
+      component: "Async",
+      allowedStates: ["idle", "loading", "success", "empty", "failure"],
+      onFailure: "show Field.message + Button status=failure"
+    }
+  },
+  renderedHint: "Aeon maps each step to Field (parallel regions) + Button status + Async lifecycle \u2014 named states throughout."
+};
+var CURSOR_RULES_SNIPPET = `${AEON_SYSTEM_PROMPT}
+
+## Schemas
+When generating Aeon UI, constrain props/parts/states to @aeon-ui/schemas catalog.
+Import headless from @aeon-ui/react or styled from @aeon-ui/ui.
+Install: npm install aeon-ui-engine react react-dom xstate @xstate/react
+CSS: import 'aeon-ui-engine/aeon.css'
+Vite: aeonUiVitePlugin() from aeon-ui-engine/vite
+
+${STATECHART_PROMPTS.async}
+
+${STATECHART_PROMPTS.field}
+
+${STATECHART_PROMPTS.button}
+
+${STATECHART_PROMPTS.dialog}
+
+${STATECHART_PROMPTS.popoverFamily}
+`;
+
+// src/aeon-to-schema.ts
+import {
+  createActor,
+  getNextTransitions,
+  getStateNodes,
+  __unsafe_getAllOwnEventDescriptors
+} from "xstate";
+function isPublicEvent(event) {
+  return !event.startsWith("xstate.");
+}
+function filterPublicEvents(events) {
+  return events.filter(isPublicEvent);
+}
+function walkNode(node) {
+  const on = node.config.on ?? {};
+  const transitionEntries = Object.entries(on).filter(([event]) => isPublicEvent(event)).map(([event, def]) => {
+    const targets = [];
+    const list = Array.isArray(def) ? def : [def];
+    let guarded = false;
+    for (const item of list) {
+      if (item == null) continue;
+      if (typeof item === "string") {
+        targets.push(item);
+        continue;
+      }
+      if (typeof item === "object") {
+        const row = item;
+        if (row.guard != null) guarded = true;
+        if (typeof row.target === "string") targets.push(row.target);
+        else if (Array.isArray(row.target)) targets.push(...row.target);
+      }
+    }
+    return { event, target: targets, guarded };
+  });
+  return {
+    key: node.key,
+    id: node.id,
+    type: node.type,
+    events: filterPublicEvents([...node.events ?? []]),
+    transitions: transitionEntries,
+    children: Object.values(node.states ?? {}).map(walkNode)
+  };
+}
+function flattenNodes(node, out) {
+  out[node.id] = {
+    events: filterPublicEvents([...node.events ?? []]),
+    type: node.type
+  };
+  for (const child of Object.values(node.states ?? {})) {
+    flattenNodes(child, out);
+  }
+}
+function aeonToSchema(machine) {
+  const tree = walkNode(machine.root);
+  const flat = {};
+  flattenNodes(machine.root, flat);
+  const initial = typeof machine.config.initial === "string" ? machine.config.initial : void 0;
+  return {
+    id: machine.id,
+    initial,
+    events: filterPublicEvents([...machine.events ?? []]),
+    tree,
+    states: flat
+  };
+}
+function aeonSnapshotSchema(machine, snapshot) {
+  const active = getStateNodes(machine.root, snapshot.value);
+  const next = getNextTransitions(snapshot);
+  return {
+    machineId: machine.id,
+    value: snapshot.value,
+    validEvents: [...__unsafe_getAllOwnEventDescriptors(snapshot)].filter(
+      (e) => !e.startsWith("xstate.")
+    ),
+    nextTransitions: next.filter((t) => !t.eventType.startsWith("xstate.")).map((t) => ({
+      event: t.eventType,
+      target: (t.target ?? []).map((n) => n.id),
+      guarded: Boolean(t.guard)
+    })),
+    activeStateIds: active.map((n) => n.id)
+  };
+}
+function aeonToPrompt(machine, snapshot) {
+  const schema = aeonToSchema(machine);
+  const lines = [
+    `## Aeon statechart: ${schema.id}`,
+    `Initial: ${schema.initial ?? "(none)"}`,
+    `All events: ${schema.events.join(", ") || "(none)"}`,
+    "",
+    "### State tree (JSON)",
+    "```json",
+    JSON.stringify(schema.tree, null, 2),
+    "```",
+    "",
+    "Rules for agents:",
+    "- Only send event types listed under the *active* configuration.",
+    "- Never invent events or targets not present in this tree.",
+    "- Prefer events with guarded:false unless you can satisfy the guard payload."
+  ];
+  if (snapshot) {
+    const live = aeonSnapshotSchema(machine, snapshot);
+    lines.push(
+      "",
+      "### Live snapshot",
+      `- value: ${JSON.stringify(live.value)}`,
+      `- validEvents now: ${live.validEvents.join(", ") || "(none)"}`,
+      `- nextTransitions: ${JSON.stringify(live.nextTransitions)}`
+    );
+  }
+  return lines.join("\n");
+}
+function aeonInitialAgentContext(machine) {
+  const actor = createActor(machine);
+  actor.start();
+  const snap = actor.getSnapshot();
+  actor.stop();
+  return {
+    schema: aeonToSchema(machine),
+    snapshot: aeonSnapshotSchema(machine, snap),
+    prompt: aeonToPrompt(machine, snap)
+  };
+}
+
+// src/agent-bridge.ts
+function createAgentEventBridge(actor, options) {
+  const { map, accept, onIllegal } = options;
+  const resolve = (incoming) => {
+    if (accept && !accept(incoming)) return null;
+    const binding = map[incoming.type];
+    if (binding == null) return null;
+    if (typeof binding === "function") return binding(incoming);
+    return { type: binding };
+  };
+  const push = (incoming) => {
+    const event = resolve(incoming);
+    if (!event) return false;
+    const snap = typeof actor.getSnapshot === "function" ? actor.getSnapshot() : void 0;
+    if (snap && !snap.can(event)) {
+      onIllegal?.(event, `Event ${event.type} is not valid in the current configuration`);
+      return false;
+    }
+    actor.send(event);
+    return true;
+  };
+  return {
+    /** Push one agent/stream event through the map into `machine.send`. */
+    push,
+    /** Map of known agent → machine bindings (for prompts / docs). */
+    map,
+    /** Describe the bridge for system prompts. */
+    toPrompt() {
+      const rows = Object.entries(map).map(([from, to]) => {
+        const dest = typeof to === "string" ? to : "(transform)";
+        return `- ${from} \u2192 ${dest}`;
+      });
+      return [
+        "## Agent event bridge",
+        "Inbound stream events map to machine events:",
+        ...rows,
+        "Illegal events (rejected by snapshot.can) are dropped."
+      ].join("\n");
+    }
+  };
+}
+
+// src/registry.ts
+var REGISTRY_BASE = "https://aeon-ui.com/registry";
+var registryCatalog = {
+  $id: `${REGISTRY_BASE}/catalog.json`,
+  version: "0.1.0",
+  principle: "UI = f(state)",
+  description: "Lightweight runtime registry \u2014 fetch Aeon component schemas and state-tree JSON on demand instead of bundling every primitive.",
+  endpoints: {
+    catalog: `${REGISTRY_BASE}/catalog.json`,
+    component: `${REGISTRY_BASE}/components/{id}.json`,
+    machine: `${REGISTRY_BASE}/machines/{id}.json`
+  },
+  components: [
+    {
+      id: "button",
+      title: "Button",
+      scope: "button",
+      schemaUrl: `${REGISTRY_BASE}/components/button.json`,
+      machineUrl: `${REGISTRY_BASE}/machines/buttonLifecycle.json`,
+      runtime: "status prop",
+      description: "Action control with idle|pending|success|failure|disabled"
+    },
+    {
+      id: "async",
+      title: "Async",
+      scope: "async",
+      schemaUrl: `${REGISTRY_BASE}/components/async.json`,
+      machineUrl: `${REGISTRY_BASE}/machines/async.json`,
+      runtime: "useAeonMachine",
+      description: "Fetch lifecycle region with full totality"
+    },
+    {
+      id: "field",
+      title: "Field",
+      scope: "field",
+      schemaUrl: `${REGISTRY_BASE}/components/field.json`,
+      machineUrl: `${REGISTRY_BASE}/machines/field.json`,
+      runtime: "useAeonMachine",
+      description: "Parallel interaction \xD7 validation \xD7 submission"
+    },
+    {
+      id: "dialog",
+      title: "Dialog",
+      scope: "dialog",
+      schemaUrl: `${REGISTRY_BASE}/components/dialog.json`,
+      machineUrl: `${REGISTRY_BASE}/machines/dialog.json`,
+      runtime: "useAeonMachine",
+      description: "Modal open/closed"
+    }
+  ],
+  client: {
+    fetchCatalog: `fetch('${REGISTRY_BASE}/catalog.json').then(r => r.json())`,
+    fetchComponent: `id => fetch(\`${REGISTRY_BASE}/components/\${id}.json\`).then(r => r.json())`,
+    fetchMachine: `id => fetch(\`${REGISTRY_BASE}/machines/\${id}.json\`).then(r => r.json())`
+  }
+};
+export {
+  AEON_SYSTEM_PROMPT,
+  CURSOR_RULES_SNIPPET,
+  GENERATIVE_UI_EXAMPLE,
+  REGISTRY_BASE,
+  STATECHART_PROMPTS,
+  aeonInitialAgentContext,
+  aeonSnapshotSchema,
+  aeonToPrompt,
+  aeonToSchema,
+  catalog,
+  componentSchema,
+  componentSchemas,
+  createAgentEventBridge,
+  registryCatalog
+};