aeon-ui-engine 1.0.2 → 1.0.3

package/packages/react/dist/index.js

@@ -0,0 +1,3461 @@
+// src/button/index.tsx
+import { buttonAnatomy, partAttrs } from "@aeon-ui/core";
+import { forwardRef } from "react";
+
+// src/utils/merge-props.ts
+function mergeProps(...parts) {
+  const result = {};
+  for (const props of parts) {
+    if (!props) continue;
+    for (const [key, value] of Object.entries(props)) {
+      if (key === "className") {
+        result.className = [result.className, value].filter(Boolean).join(" ");
+      } else if (key.startsWith("on") && typeof value === "function" && typeof result[key] === "function") {
+        const prev = result[key];
+        result[key] = (...args) => {
+          prev(...args);
+          value(...args);
+        };
+      } else {
+        result[key] = value;
+      }
+    }
+  }
+  return result;
+}
+
+// src/button/index.tsx
+import { jsx } from "react/jsx-runtime";
+var Root = forwardRef(function ButtonRoot({ variant = "solid", size = "md", disabled, status = "idle", children, className, ...rest }, ref) {
+  const resolvedStatus = disabled ? "disabled" : status;
+  const isBusy = resolvedStatus === "pending";
+  return /* @__PURE__ */ jsx(
+    "button",
+    {
+      ref,
+      type: "button",
+      disabled: disabled || isBusy || resolvedStatus === "disabled",
+      "aria-busy": isBusy || void 0,
+      className,
+      "data-aeon-variant": variant,
+      "data-aeon-size": size,
+      ...mergeProps(
+        partAttrs(buttonAnatomy.scope, buttonAnatomy.root, {
+          state: resolvedStatus,
+          disabled: Boolean(disabled || resolvedStatus === "disabled")
+        }),
+        rest
+      ),
+      children
+    }
+  );
+});
+var Label = forwardRef(function ButtonLabel(props, ref) {
+  return /* @__PURE__ */ jsx("span", { ref, ...partAttrs(buttonAnatomy.scope, buttonAnatomy.label), ...props });
+});
+var Icon = forwardRef(function ButtonIcon(props, ref) {
+  return /* @__PURE__ */ jsx("span", { ref, ...partAttrs(buttonAnatomy.scope, buttonAnatomy.icon), ...props });
+});
+var Group = forwardRef(function ButtonGroup({ children, ...rest }, ref) {
+  return /* @__PURE__ */ jsx("div", { ref, ...partAttrs(buttonAnatomy.scope, buttonAnatomy.group), ...rest, children });
+});
+var Button = { Root, Label, Icon, Group };
+
+// src/switch/index.tsx
+import { partAttrs as partAttrs2, switchAnatomy } from "@aeon-ui/core";
+import { toggleMachine } from "@aeon-ui/primitives";
+import {
+  createContext,
+  forwardRef as forwardRef2,
+  useContext,
+  useEffect,
+  useMemo
+} from "react";
+
+// src/hooks/use-aeon-machine.ts
+import { useMachine } from "@xstate/react";
+function useAeonMachine(machine, options) {
+  return useMachine(machine, options);
+}
+
+// src/switch/index.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+var SwitchCtx = createContext(null);
+function useSwitchCtx() {
+  const ctx = useContext(SwitchCtx);
+  if (!ctx) throw new Error("Switch parts must be used within Switch.Root");
+  return ctx;
+}
+var Root2 = forwardRef2(function SwitchRoot({ checked, defaultChecked = false, disabled = false, onCheckedChange, children, className, ...rest }, ref) {
+  const [snapshot, send] = useAeonMachine(toggleMachine, {
+    input: { checked: defaultChecked, disabled }
+  });
+  const controlled = checked !== void 0;
+  const resolvedChecked = checked ?? snapshot.context.checked;
+  const pressState = snapshot.matches({ interaction: "pressed" }) ? "pressed" : "idle";
+  useEffect(() => {
+    if (checked === void 0) onCheckedChange?.(resolvedChecked);
+  }, [resolvedChecked, onCheckedChange, checked]);
+  useEffect(() => {
+    if (checked !== void 0) send({ type: "SET_CHECKED", checked });
+  }, [checked, send]);
+  const value = useMemo(
+    () => ({
+      checked: resolvedChecked,
+      disabled,
+      controlled,
+      onCheckedChange,
+      send,
+      pressState
+    }),
+    [resolvedChecked, disabled, controlled, onCheckedChange, send, pressState]
+  );
+  const toggle = () => {
+    if (disabled) return;
+    const next = !resolvedChecked;
+    if (controlled) onCheckedChange?.(next);
+    else send({ type: "TOGGLE" });
+  };
+  return /* @__PURE__ */ jsx2(SwitchCtx.Provider, { value, children: /* @__PURE__ */ jsx2(
+    "label",
+    {
+      ref,
+      className,
+      ...mergeProps(
+        partAttrs2(switchAnatomy.scope, switchAnatomy.root, {
+          state: `${resolvedChecked ? "checked" : "unchecked"} ${pressState}`,
+          disabled
+        }),
+        {
+          onClick: (e) => {
+            const target = e.target;
+            if (target.closest(`[data-aeon-part="${switchAnatomy.control}"]`)) return;
+            toggle();
+          }
+        },
+        rest
+      ),
+      children
+    }
+  ) });
+});
+var Control = forwardRef2(function SwitchControl({ className, onClick, onPointerDown, onPointerUp, onPointerLeave, ...rest }, ref) {
+  const { checked, disabled, controlled, onCheckedChange, send, pressState } = useSwitchCtx();
+  const toggle = () => {
+    if (disabled) return;
+    const next = !checked;
+    if (controlled) onCheckedChange?.(next);
+    else send({ type: "TOGGLE" });
+  };
+  return /* @__PURE__ */ jsx2(
+    "span",
+    {
+      ref,
+      role: "switch",
+      "aria-checked": checked,
+      tabIndex: disabled ? -1 : 0,
+      className,
+      ...mergeProps(
+        partAttrs2(switchAnatomy.scope, switchAnatomy.control, {
+          state: `${checked ? "checked" : "unchecked"} ${pressState}`,
+          disabled
+        }),
+        {
+          onClick: (e) => {
+            onClick?.(e);
+            toggle();
+            e.stopPropagation();
+          },
+          onPointerDown: (e) => {
+            onPointerDown?.(e);
+            if (!disabled) send({ type: "POINTER_DOWN" });
+          },
+          onPointerUp: (e) => {
+            onPointerUp?.(e);
+            send({ type: "POINTER_UP" });
+          },
+          onPointerLeave: (e) => {
+            onPointerLeave?.(e);
+            send({ type: "POINTER_LEAVE" });
+          },
+          onKeyDown: (e) => {
+            if (e.key === " " || e.key === "Enter") {
+              e.preventDefault();
+              toggle();
+            }
+          }
+        },
+        rest
+      )
+    }
+  );
+});
+var Thumb = forwardRef2(function SwitchThumb({ className, ...rest }, ref) {
+  const { checked, pressState } = useSwitchCtx();
+  return /* @__PURE__ */ jsx2(
+    "span",
+    {
+      ref,
+      className,
+      ...mergeProps(
+        partAttrs2(switchAnatomy.scope, switchAnatomy.thumb, {
+          state: `${checked ? "checked" : "unchecked"} ${pressState}`
+        }),
+        rest
+      )
+    }
+  );
+});
+var Label2 = forwardRef2(function SwitchLabel(props, ref) {
+  return /* @__PURE__ */ jsx2(
+    "span",
+    {
+      ref,
+      ...mergeProps(partAttrs2(switchAnatomy.scope, switchAnatomy.label), props)
+    }
+  );
+});
+var HiddenInput = forwardRef2(function SwitchHiddenInput(props, ref) {
+  const { checked } = useSwitchCtx();
+  return /* @__PURE__ */ jsx2(
+    "input",
+    {
+      ref,
+      type: "checkbox",
+      checked,
+      readOnly: true,
+      tabIndex: -1,
+      "aria-hidden": true,
+      ...mergeProps(partAttrs2(switchAnatomy.scope, switchAnatomy.hiddenInput), props)
+    }
+  );
+});
+var Switch = { Root: Root2, Control, Thumb, Label: Label2, HiddenInput };
+
+// src/checkbox/index.tsx
+import { checkboxAnatomy, partAttrs as partAttrs3 } from "@aeon-ui/core";
+import { toggleMachine as toggleMachine2 } from "@aeon-ui/primitives";
+import {
+  createContext as createContext2,
+  forwardRef as forwardRef3,
+  useContext as useContext2,
+  useEffect as useEffect2,
+  useMemo as useMemo2
+} from "react";
+import { jsx as jsx3 } from "react/jsx-runtime";
+var CheckboxCtx = createContext2(null);
+function useCheckboxCtx() {
+  const ctx = useContext2(CheckboxCtx);
+  if (!ctx) throw new Error("Checkbox parts must be used within Checkbox.Root");
+  return ctx;
+}
+var Root3 = forwardRef3(function CheckboxRoot({ checked, defaultChecked = false, disabled = false, onCheckedChange, children, className, ...rest }, ref) {
+  const [snapshot, send] = useAeonMachine(toggleMachine2, {
+    input: { checked: defaultChecked, disabled }
+  });
+  const resolvedChecked = checked ?? snapshot.context.checked;
+  useEffect2(() => {
+    if (checked === void 0) onCheckedChange?.(resolvedChecked);
+  }, [resolvedChecked, onCheckedChange, checked]);
+  useEffect2(() => {
+    if (checked !== void 0) send({ type: "SET_CHECKED", checked });
+  }, [checked, send]);
+  const value = useMemo2(
+    () => ({
+      checked: resolvedChecked,
+      disabled,
+      controlled: checked !== void 0,
+      onCheckedChange,
+      send
+    }),
+    [resolvedChecked, disabled, checked, onCheckedChange, send]
+  );
+  const toggle = () => {
+    if (disabled) return;
+    const next = !resolvedChecked;
+    if (checked !== void 0) onCheckedChange?.(next);
+    else send({ type: "TOGGLE" });
+  };
+  return /* @__PURE__ */ jsx3(CheckboxCtx.Provider, { value, children: /* @__PURE__ */ jsx3(
+    "label",
+    {
+      ref,
+      className,
+      ...mergeProps(
+        partAttrs3(checkboxAnatomy.scope, checkboxAnatomy.root, {
+          state: resolvedChecked ? "checked" : "unchecked",
+          disabled
+        }),
+        {
+          onClick: (e) => {
+            const target = e.target;
+            if (target.closest(`[data-aeon-part="${checkboxAnatomy.control}"]`)) return;
+            toggle();
+          }
+        },
+        rest
+      ),
+      children
+    }
+  ) });
+});
+var Control2 = forwardRef3(function CheckboxControl({ className, onClick, ...rest }, ref) {
+  const { checked, disabled, controlled, onCheckedChange, send } = useCheckboxCtx();
+  return /* @__PURE__ */ jsx3(
+    "span",
+    {
+      ref,
+      role: "checkbox",
+      "aria-checked": checked,
+      "aria-disabled": disabled || void 0,
+      tabIndex: disabled ? -1 : 0,
+      className,
+      ...mergeProps(
+        partAttrs3(checkboxAnatomy.scope, checkboxAnatomy.control, {
+          state: checked ? "checked" : "unchecked",
+          disabled
+        }),
+        {
+          onClick: (e) => {
+            onClick?.(e);
+            if (!disabled) {
+              const next = !checked;
+              if (controlled) onCheckedChange?.(next);
+              else send({ type: "TOGGLE" });
+            }
+          },
+          onKeyDown: (e) => {
+            if (e.key === " " || e.key === "Enter") {
+              e.preventDefault();
+              if (!disabled) {
+                const next = !checked;
+                if (controlled) onCheckedChange?.(next);
+                else send({ type: "TOGGLE" });
+              }
+            }
+          }
+        },
+        rest
+      )
+    }
+  );
+});
+var Indicator = forwardRef3(function CheckboxIndicator(props, ref) {
+  const { checked } = useCheckboxCtx();
+  if (!checked) return null;
+  return /* @__PURE__ */ jsx3(
+    "span",
+    {
+      ref,
+      ...mergeProps(
+        partAttrs3(checkboxAnatomy.scope, checkboxAnatomy.indicator, { state: "checked" }),
+        props
+      )
+    }
+  );
+});
+var Label3 = forwardRef3(function CheckboxLabel(props, ref) {
+  return /* @__PURE__ */ jsx3("span", { ref, ...mergeProps(partAttrs3(checkboxAnatomy.scope, checkboxAnatomy.label), props) });
+});
+var HiddenInput2 = forwardRef3(function CheckboxHiddenInput(props, ref) {
+  const { checked } = useCheckboxCtx();
+  return /* @__PURE__ */ jsx3(
+    "input",
+    {
+      ref,
+      type: "checkbox",
+      checked,
+      readOnly: true,
+      tabIndex: -1,
+      "aria-hidden": true,
+      ...mergeProps(partAttrs3(checkboxAnatomy.scope, checkboxAnatomy.hiddenInput), props)
+    }
+  );
+});
+var Checkbox = { Root: Root3, Control: Control2, Indicator, Label: Label3, HiddenInput: HiddenInput2 };
+
+// src/dialog/index.tsx
+import { dialogAnatomy, partAttrs as partAttrs4 } from "@aeon-ui/core";
+import { dialogMachine } from "@aeon-ui/primitives";
+import {
+  createContext as createContext3,
+  forwardRef as forwardRef4,
+  useContext as useContext3,
+  useEffect as useEffect6,
+  useId,
+  useMemo as useMemo3,
+  useRef
+} from "react";
+
+// src/hooks/use-focus-trap.ts
+import { useEffect as useEffect3 } from "react";
+var FOCUSABLE = 'a[href], button:not([disabled]), textarea:not([disabled]), input:not([disabled]), select:not([disabled]), [tabindex]:not([tabindex="-1"])';
+function getFocusable(container) {
+  return Array.from(container.querySelectorAll(FOCUSABLE)).filter(
+    (el) => !el.hasAttribute("disabled") && el.tabIndex !== -1
+  );
+}
+function useFocusTrap(containerRef, active) {
+  useEffect3(() => {
+    if (!active || !containerRef.current) return;
+    const container = containerRef.current;
+    const previous = document.activeElement;
+    const focusables = getFocusable(container);
+    focusables[0]?.focus();
+    const onKeyDown = (e) => {
+      if (e.key !== "Tab") return;
+      const nodes = getFocusable(container);
+      if (nodes.length === 0) return;
+      const first = nodes[0];
+      const last = nodes[nodes.length - 1];
+      const current = document.activeElement;
+      if (e.shiftKey) {
+        if (current === first || !container.contains(current)) {
+          e.preventDefault();
+          last.focus();
+        }
+      } else if (current === last || !container.contains(current)) {
+        e.preventDefault();
+        first.focus();
+      }
+    };
+    document.addEventListener("keydown", onKeyDown);
+    return () => {
+      document.removeEventListener("keydown", onKeyDown);
+      if (previous instanceof HTMLElement && document.contains(previous)) {
+        previous.focus();
+      }
+    };
+  }, [active, containerRef]);
+}
+
+// src/hooks/use-portalled.ts
+import { useEffect as useEffect4, useState } from "react";
+import { createPortal } from "react-dom";
+function usePortalledMount() {
+  const [mounted, setMounted] = useState(false);
+  useEffect4(() => {
+    setMounted(true);
+  }, []);
+  return mounted;
+}
+function renderPortalled(node, portalled, mounted) {
+  if (!portalled || !mounted) return node;
+  return createPortal(node, document.body);
+}
+
+// src/hooks/use-scroll-lock.ts
+import { useEffect as useEffect5 } from "react";
+function useScrollLock(active) {
+  useEffect5(() => {
+    if (!active) return;
+    const prev = document.body.style.overflow;
+    document.body.style.overflow = "hidden";
+    return () => {
+      document.body.style.overflow = prev;
+    };
+  }, [active]);
+}
+
+// src/dialog/index.tsx
+import { jsx as jsx4 } from "react/jsx-runtime";
+var DialogCtx = createContext3(null);
+function useDialogCtx() {
+  const ctx = useContext3(DialogCtx);
+  if (!ctx) throw new Error("Dialog parts must be used within Dialog.Root");
+  return ctx;
+}
+var Root4 = forwardRef4(function DialogRoot({ open, defaultOpen = false, onOpenChange, children, className, ...rest }, ref) {
+  const [snapshot, send] = useAeonMachine(dialogMachine, {
+    input: { open: defaultOpen }
+  });
+  const resolvedOpen = open ?? snapshot.context.open;
+  const contentRef = useRef(null);
+  useEffect6(() => {
+    onOpenChange?.(resolvedOpen);
+  }, [resolvedOpen, onOpenChange]);
+  useEffect6(() => {
+    if (open !== void 0) {
+      send({ type: "SET_OPEN", open });
+    }
+  }, [open, send]);
+  const titleId = useId();
+  const descriptionId = useId();
+  const value = useMemo3(
+    () => ({ open: resolvedOpen, send, titleId, descriptionId, contentRef }),
+    [resolvedOpen, send, titleId, descriptionId]
+  );
+  return /* @__PURE__ */ jsx4(DialogCtx.Provider, { value, children: /* @__PURE__ */ jsx4(
+    "div",
+    {
+      ref,
+      className,
+      ...mergeProps(
+        partAttrs4(dialogAnatomy.scope, dialogAnatomy.root, {
+          state: resolvedOpen ? "open" : "closed"
+        }),
+        rest
+      ),
+      children
+    }
+  ) });
+});
+var Trigger = forwardRef4(function DialogTrigger({ onClick, ...rest }, ref) {
+  const { send } = useDialogCtx();
+  return /* @__PURE__ */ jsx4(
+    "button",
+    {
+      ref,
+      type: "button",
+      ...mergeProps(
+        partAttrs4(dialogAnatomy.scope, dialogAnatomy.trigger),
+        {
+          onClick: (e) => {
+            onClick?.(e);
+            send({ type: "OPEN" });
+          }
+        },
+        rest
+      )
+    }
+  );
+});
+var Portal = forwardRef4(function DialogPortal({ portalled = true, children, className, ...rest }, ref) {
+  const { open } = useDialogCtx();
+  const mounted = usePortalledMount();
+  useScrollLock(open);
+  if (!open) return null;
+  const node = /* @__PURE__ */ jsx4(
+    "div",
+    {
+      ref,
+      className,
+      ...mergeProps(partAttrs4(dialogAnatomy.scope, dialogAnatomy.portal, { state: "open" }), rest),
+      children
+    }
+  );
+  return renderPortalled(node, portalled, mounted);
+});
+var Backdrop = forwardRef4(function DialogBackdrop(props, ref) {
+  const { open, send } = useDialogCtx();
+  if (!open) return null;
+  return /* @__PURE__ */ jsx4(
+    "div",
+    {
+      ref,
+      ...mergeProps(
+        partAttrs4(dialogAnatomy.scope, dialogAnatomy.backdrop, { state: "open" }),
+        {
+          onClick: () => send({ type: "POINTER_DOWN_OUTSIDE" })
+        },
+        props
+      )
+    }
+  );
+});
+var Positioner = forwardRef4(function DialogPositioner(props, ref) {
+  const { open } = useDialogCtx();
+  if (!open) return null;
+  return /* @__PURE__ */ jsx4(
+    "div",
+    {
+      ref,
+      ...mergeProps(partAttrs4(dialogAnatomy.scope, dialogAnatomy.positioner, { state: "open" }), props)
+    }
+  );
+});
+var Content = forwardRef4(function DialogContent({ onKeyDown, ...rest }, ref) {
+  const { open, send, titleId, descriptionId, contentRef } = useDialogCtx();
+  useFocusTrap(contentRef, open);
+  useEffect6(() => {
+    if (open) contentRef.current?.focus();
+  }, [open, contentRef]);
+  if (!open) return null;
+  return /* @__PURE__ */ jsx4(
+    "div",
+    {
+      ref: (node) => {
+        contentRef.current = node;
+        if (typeof ref === "function") ref(node);
+        else if (ref) ref.current = node;
+      },
+      role: "dialog",
+      "aria-modal": "true",
+      "aria-labelledby": titleId,
+      "aria-describedby": descriptionId,
+      tabIndex: -1,
+      ...mergeProps(
+        partAttrs4(dialogAnatomy.scope, dialogAnatomy.content, { state: "open" }),
+        {
+          onKeyDown: (e) => {
+            onKeyDown?.(e);
+            if (e.key === "Escape") send({ type: "ESCAPE" });
+          }
+        },
+        rest
+      )
+    }
+  );
+});
+var Title = forwardRef4(function DialogTitle(props, ref) {
+  const { titleId } = useDialogCtx();
+  return /* @__PURE__ */ jsx4("h2", { ref, id: titleId, ...mergeProps(partAttrs4(dialogAnatomy.scope, dialogAnatomy.title), props) });
+});
+var Description = forwardRef4(
+  function DialogDescription(props, ref) {
+    const { descriptionId } = useDialogCtx();
+    return /* @__PURE__ */ jsx4(
+      "p",
+      {
+        ref,
+        id: descriptionId,
+        ...mergeProps(partAttrs4(dialogAnatomy.scope, dialogAnatomy.description), props)
+      }
+    );
+  }
+);
+var CloseTrigger = forwardRef4(
+  function DialogCloseTrigger({ onClick, ...rest }, ref) {
+    const { send } = useDialogCtx();
+    return /* @__PURE__ */ jsx4(
+      "button",
+      {
+        ref,
+        type: "button",
+        ...mergeProps(
+          partAttrs4(dialogAnatomy.scope, dialogAnatomy.closeTrigger),
+          {
+            "aria-label": "Close dialog",
+            onClick: (e) => {
+              onClick?.(e);
+              send({ type: "CLOSE" });
+            }
+          },
+          rest
+        )
+      }
+    );
+  }
+);
+var Dialog = {
+  Root: Root4,
+  Trigger,
+  Portal,
+  Backdrop,
+  Positioner,
+  Content,
+  Title,
+  Description,
+  CloseTrigger
+};
+
+// src/tabs/index.tsx
+import { partAttrs as partAttrs5, tabsAnatomy } from "@aeon-ui/core";
+import { tabsMachine } from "@aeon-ui/primitives";
+import {
+  createContext as createContext4,
+  forwardRef as forwardRef5,
+  useContext as useContext4,
+  useEffect as useEffect7,
+  useMemo as useMemo4
+} from "react";
+import { jsx as jsx5 } from "react/jsx-runtime";
+var TabsCtx = createContext4(null);
+function useTabsCtx() {
+  const ctx = useContext4(TabsCtx);
+  if (!ctx) throw new Error("Tabs parts must be used within Tabs.Root");
+  return ctx;
+}
+var Root5 = forwardRef5(function TabsRoot({ value, defaultValue = "", onValueChange, children, className, ...rest }, ref) {
+  const [snapshot, send] = useAeonMachine(tabsMachine, {
+    input: { value: defaultValue, disabled: false }
+  });
+  const resolvedValue = value ?? snapshot.context.value;
+  useEffect7(() => {
+    onValueChange?.(resolvedValue);
+  }, [resolvedValue, onValueChange]);
+  useEffect7(() => {
+    if (value !== void 0) send({ type: "SET_VALUE", value });
+  }, [value, send]);
+  const ctx = useMemo4(() => ({ value: resolvedValue, send }), [resolvedValue, send]);
+  return /* @__PURE__ */ jsx5(TabsCtx.Provider, { value: ctx, children: /* @__PURE__ */ jsx5(
+    "div",
+    {
+      ref,
+      className,
+      ...mergeProps(partAttrs5(tabsAnatomy.scope, tabsAnatomy.root), rest),
+      children
+    }
+  ) });
+});
+var List = forwardRef5(function TabsList(props, ref) {
+  return /* @__PURE__ */ jsx5("div", { ref, role: "tablist", ...mergeProps(partAttrs5(tabsAnatomy.scope, tabsAnatomy.list), props) });
+});
+var Trigger2 = forwardRef5(function TabsTrigger({ value: triggerValue, onClick, ...rest }, ref) {
+  const { value, send } = useTabsCtx();
+  const selected = value === triggerValue;
+  return /* @__PURE__ */ jsx5(
+    "button",
+    {
+      ref,
+      type: "button",
+      role: "tab",
+      "aria-selected": selected,
+      "data-selected": selected ? "" : void 0,
+      ...mergeProps(
+        partAttrs5(tabsAnatomy.scope, tabsAnatomy.trigger, {
+          state: selected ? "selected" : "unselected",
+          highlighted: selected
+        }),
+        {
+          onClick: (e) => {
+            onClick?.(e);
+            send({ type: "SELECT", value: triggerValue });
+          }
+        },
+        rest
+      )
+    }
+  );
+});
+var Content2 = forwardRef5(function TabsContent({ value: contentValue, ...rest }, ref) {
+  const { value } = useTabsCtx();
+  if (value !== contentValue) return null;
+  return /* @__PURE__ */ jsx5(
+    "div",
+    {
+      ref,
+      role: "tabpanel",
+      ...mergeProps(
+        partAttrs5(tabsAnatomy.scope, tabsAnatomy.content, { state: "active" }),
+        rest
+      )
+    }
+  );
+});
+var Indicator2 = forwardRef5(function TabsIndicator(props, ref) {
+  return /* @__PURE__ */ jsx5("div", { ref, ...mergeProps(partAttrs5(tabsAnatomy.scope, tabsAnatomy.indicator), props) });
+});
+var Tabs = { Root: Root5, List, Trigger: Trigger2, Content: Content2, Indicator: Indicator2 };
+
+// src/separator/index.tsx
+import { partAttrs as partAttrs6, separatorAnatomy } from "@aeon-ui/core";
+import { forwardRef as forwardRef6 } from "react";
+import { jsx as jsx6 } from "react/jsx-runtime";
+var Root6 = forwardRef6(function SeparatorRoot({ orientation = "horizontal", ...rest }, ref) {
+  return /* @__PURE__ */ jsx6(
+    "div",
+    {
+      ref,
+      role: "separator",
+      "aria-orientation": orientation,
+      ...mergeProps(partAttrs6(separatorAnatomy.scope, separatorAnatomy.root), rest)
+    }
+  );
+});
+var Separator = { Root: Root6 };
+
+// src/progress/index.tsx
+import { partAttrs as partAttrs7, partOnlyAttrs, progressAnatomy } from "@aeon-ui/core";
+import {
+  createContext as createContext5,
+  forwardRef as forwardRef7,
+  useContext as useContext5,
+  useMemo as useMemo5
+} from "react";
+import { jsx as jsx7 } from "react/jsx-runtime";
+var ProgressCtx = createContext5(null);
+function useProgressCtx() {
+  const ctx = useContext5(ProgressCtx);
+  if (!ctx) throw new Error("Progress parts must be used within Progress.Root");
+  return ctx;
+}
+function resolveProgressState(value, max, indeterminate) {
+  if (indeterminate) return "loading";
+  if (value >= max) return "complete";
+  return "idle";
+}
+var Root7 = forwardRef7(function ProgressRoot({ value = 0, max = 100, indeterminate = false, children, className, ...rest }, ref) {
+  const clampedValue = Math.min(Math.max(value, 0), max);
+  const state = resolveProgressState(clampedValue, max, indeterminate);
+  const ctx = useMemo5(
+    () => ({ value: clampedValue, max, indeterminate, state }),
+    [clampedValue, max, indeterminate, state]
+  );
+  return /* @__PURE__ */ jsx7(ProgressCtx.Provider, { value: ctx, children: /* @__PURE__ */ jsx7(
+    "div",
+    {
+      ref,
+      className,
+      role: "progressbar",
+      "aria-valuemin": 0,
+      "aria-valuemax": max,
+      "aria-valuenow": indeterminate ? void 0 : clampedValue,
+      "aria-busy": indeterminate || void 0,
+      ...mergeProps(
+        partAttrs7(progressAnatomy.scope, progressAnatomy.root, { state }),
+        rest
+      ),
+      children
+    }
+  ) });
+});
+var Track = forwardRef7(function ProgressTrack(props, ref) {
+  return /* @__PURE__ */ jsx7("div", { ref, ...mergeProps(partOnlyAttrs(progressAnatomy.track), props) });
+});
+var Range = forwardRef7(function ProgressRange({ style, ...rest }, ref) {
+  const { value, max, indeterminate } = useProgressCtx();
+  const width = indeterminate ? void 0 : `${value / max * 100}%`;
+  return /* @__PURE__ */ jsx7(
+    "div",
+    {
+      ref,
+      ...mergeProps(partOnlyAttrs(progressAnatomy.range), rest, {
+        style: { ...style, width }
+      })
+    }
+  );
+});
+var Label4 = forwardRef7(function ProgressLabel(props, ref) {
+  return /* @__PURE__ */ jsx7("span", { ref, ...mergeProps(partOnlyAttrs(progressAnatomy.label), props) });
+});
+var Progress = { Root: Root7, Track, Range, Label: Label4 };
+
+// src/radio-group/index.tsx
+import { partAttrs as partAttrs8, partOnlyAttrs as partOnlyAttrs2, radioGroupAnatomy } from "@aeon-ui/core";
+import { tabsMachine as tabsMachine2 } from "@aeon-ui/primitives";
+import {
+  createContext as createContext6,
+  forwardRef as forwardRef8,
+  useContext as useContext6,
+  useEffect as useEffect8,
+  useMemo as useMemo6
+} from "react";
+import { jsx as jsx8 } from "react/jsx-runtime";
+var RadioGroupCtx = createContext6(null);
+function useRadioGroupCtx() {
+  const ctx = useContext6(RadioGroupCtx);
+  if (!ctx) throw new Error("RadioGroup parts must be used within RadioGroup.Root");
+  return ctx;
+}
+var RadioGroupItemCtx = createContext6(null);
+function useRadioGroupItemCtx() {
+  const ctx = useContext6(RadioGroupItemCtx);
+  if (!ctx) throw new Error("RadioGroup item parts must be used within RadioGroup.Item");
+  return ctx;
+}
+var Root8 = forwardRef8(function RadioGroupRoot({ value, defaultValue = "", onValueChange, children, className, ...rest }, ref) {
+  const [snapshot, send] = useAeonMachine(tabsMachine2, {
+    input: { value: defaultValue, disabled: false }
+  });
+  const resolvedValue = value ?? snapshot.context.value;
+  useEffect8(() => {
+    onValueChange?.(resolvedValue);
+  }, [resolvedValue, onValueChange]);
+  useEffect8(() => {
+    if (value !== void 0) send({ type: "SET_VALUE", value });
+  }, [value, send]);
+  const ctx = useMemo6(() => ({ value: resolvedValue, send }), [resolvedValue, send]);
+  return /* @__PURE__ */ jsx8(RadioGroupCtx.Provider, { value: ctx, children: /* @__PURE__ */ jsx8(
+    "div",
+    {
+      ref,
+      role: "radiogroup",
+      className,
+      ...mergeProps(
+        partAttrs8(radioGroupAnatomy.scope, radioGroupAnatomy.root),
+        rest
+      ),
+      children
+    }
+  ) });
+});
+var Item = forwardRef8(function RadioGroupItem({ value: itemValue, children, ...rest }, ref) {
+  const { value } = useRadioGroupCtx();
+  const selected = value === itemValue;
+  const itemCtx = useMemo6(() => ({ value: itemValue, selected }), [itemValue, selected]);
+  return /* @__PURE__ */ jsx8(RadioGroupItemCtx.Provider, { value: itemCtx, children: /* @__PURE__ */ jsx8(
+    "div",
+    {
+      ref,
+      ...mergeProps(
+        partOnlyAttrs2(radioGroupAnatomy.item, {
+          state: selected ? "selected" : "unselected"
+        }),
+        rest
+      ),
+      children
+    }
+  ) });
+});
+var ItemControl = forwardRef8(function RadioGroupItemControl({ onClick, onKeyDown, ...rest }, ref) {
+  const { send } = useRadioGroupCtx();
+  const { value: itemValue, selected } = useRadioGroupItemCtx();
+  const select = () => send({ type: "SELECT", value: itemValue });
+  return /* @__PURE__ */ jsx8(
+    "span",
+    {
+      ref,
+      role: "radio",
+      "aria-checked": selected,
+      tabIndex: selected ? 0 : -1,
+      ...mergeProps(
+        partOnlyAttrs2(radioGroupAnatomy.itemControl, {
+          state: selected ? "selected" : "unselected",
+          highlighted: selected
+        }),
+        {
+          onClick: (e) => {
+            onClick?.(e);
+            select();
+          },
+          onKeyDown: (e) => {
+            onKeyDown?.(e);
+            if (e.key === " " || e.key === "Enter") {
+              e.preventDefault();
+              select();
+            }
+          }
+        },
+        rest
+      )
+    }
+  );
+});
+var ItemIndicator = forwardRef8(function RadioGroupItemIndicator(props, ref) {
+  const { selected } = useRadioGroupItemCtx();
+  if (!selected) return null;
+  return /* @__PURE__ */ jsx8(
+    "span",
+    {
+      ref,
+      ...mergeProps(
+        partOnlyAttrs2(radioGroupAnatomy.itemIndicator, { state: "selected" }),
+        props
+      )
+    }
+  );
+});
+var ItemLabel = forwardRef8(function RadioGroupItemLabel({ onClick, ...rest }, ref) {
+  const { send } = useRadioGroupCtx();
+  const { value: itemValue } = useRadioGroupItemCtx();
+  return /* @__PURE__ */ jsx8(
+    "span",
+    {
+      ref,
+      ...mergeProps(
+        partOnlyAttrs2(radioGroupAnatomy.itemLabel),
+        {
+          onClick: (e) => {
+            onClick?.(e);
+            send({ type: "SELECT", value: itemValue });
+          }
+        },
+        rest
+      )
+    }
+  );
+});
+var RadioGroup = { Root: Root8, Item, ItemControl, ItemIndicator, ItemLabel };
+
+// src/slider/index.tsx
+import { partAttrs as partAttrs9, partOnlyAttrs as partOnlyAttrs3, sliderAnatomy } from "@aeon-ui/core";
+import { sliderMachine, snapSliderValue } from "@aeon-ui/primitives";
+import {
+  createContext as createContext7,
+  forwardRef as forwardRef9,
+  useCallback,
+  useContext as useContext7,
+  useEffect as useEffect9,
+  useMemo as useMemo7,
+  useRef as useRef2
+} from "react";
+import { jsx as jsx9 } from "react/jsx-runtime";
+var SliderCtx = createContext7(null);
+function useSliderCtx() {
+  const ctx = useContext7(SliderCtx);
+  if (!ctx) throw new Error("Slider parts must be used within Slider.Root");
+  return ctx;
+}
+function percent(value, min, max) {
+  if (max <= min) return 0;
+  return (value - min) / (max - min) * 100;
+}
+var Root9 = forwardRef9(function SliderRoot({
+  value,
+  defaultValue,
+  min = 0,
+  max = 100,
+  step = 1,
+  disabled = false,
+  onValueChange,
+  children,
+  className,
+  ...rest
+}, ref) {
+  const trackRef = useRef2(null);
+  const [snapshot, send] = useAeonMachine(sliderMachine, {
+    input: {
+      value: defaultValue ?? min,
+      min,
+      max,
+      step,
+      disabled
+    }
+  });
+  const resolvedValue = value ?? snapshot.context.value;
+  const dragging = snapshot.matches({ interaction: "dragging" });
+  useEffect9(() => {
+    onValueChange?.(resolvedValue);
+  }, [resolvedValue, onValueChange]);
+  useEffect9(() => {
+    if (value !== void 0) send({ type: "SET_VALUE", value });
+  }, [value, send]);
+  const setValueFromClientX = useCallback(
+    (clientX) => {
+      const track = trackRef.current;
+      if (!track || disabled) return;
+      const rect = track.getBoundingClientRect();
+      if (rect.width <= 0) return;
+      const ratio = Math.min(1, Math.max(0, (clientX - rect.left) / rect.width));
+      const next = snapSliderValue(min + ratio * (max - min), min, max, step);
+      send({ type: "SET_VALUE", value: next });
+      if (value === void 0) onValueChange?.(next);
+    },
+    [disabled, min, max, step, send, value, onValueChange]
+  );
+  useEffect9(() => {
+    if (!dragging) return;
+    const onMove = (e) => setValueFromClientX(e.clientX);
+    const onUp = () => send({ type: "POINTER_UP" });
+    window.addEventListener("pointermove", onMove);
+    window.addEventListener("pointerup", onUp);
+    return () => {
+      window.removeEventListener("pointermove", onMove);
+      window.removeEventListener("pointerup", onUp);
+    };
+  }, [dragging, setValueFromClientX, send]);
+  const ctx = useMemo7(
+    () => ({
+      value: resolvedValue,
+      min,
+      max,
+      step,
+      disabled,
+      dragging,
+      send,
+      onValueChange,
+      setValueFromClientX,
+      trackRef
+    }),
+    [resolvedValue, min, max, step, disabled, dragging, send, onValueChange, setValueFromClientX]
+  );
+  return /* @__PURE__ */ jsx9(SliderCtx.Provider, { value: ctx, children: /* @__PURE__ */ jsx9(
+    "div",
+    {
+      ref,
+      className,
+      ...mergeProps(
+        partAttrs9(sliderAnatomy.scope, sliderAnatomy.root, {
+          state: dragging ? "dragging" : "idle",
+          disabled
+        }),
+        rest
+      ),
+      children
+    }
+  ) });
+});
+var Track2 = forwardRef9(function SliderTrack({ onPointerDown, ...rest }, ref) {
+  const { disabled, send, setValueFromClientX, trackRef } = useSliderCtx();
+  return /* @__PURE__ */ jsx9(
+    "div",
+    {
+      ref: (node) => {
+        trackRef.current = node;
+        if (typeof ref === "function") ref(node);
+        else if (ref) ref.current = node;
+      },
+      ...mergeProps(
+        partOnlyAttrs3(sliderAnatomy.track),
+        {
+          onPointerDown: (e) => {
+            onPointerDown?.(e);
+            if (disabled || e.button !== 0) return;
+            e.currentTarget.setPointerCapture(e.pointerId);
+            send({ type: "POINTER_DOWN" });
+            setValueFromClientX(e.clientX);
+          }
+        },
+        rest
+      )
+    }
+  );
+});
+var Range2 = forwardRef9(function SliderRange({ style, ...rest }, ref) {
+  const { value, min, max } = useSliderCtx();
+  return /* @__PURE__ */ jsx9(
+    "div",
+    {
+      ref,
+      ...mergeProps(partOnlyAttrs3(sliderAnatomy.range), rest, {
+        style: { ...style, width: `${percent(value, min, max)}%` }
+      })
+    }
+  );
+});
+var Thumb2 = forwardRef9(function SliderThumb({ onKeyDown, onPointerDown, style, ...rest }, ref) {
+  const { value, min, max, step, disabled, dragging, send } = useSliderCtx();
+  return /* @__PURE__ */ jsx9(
+    "span",
+    {
+      ref,
+      role: "slider",
+      tabIndex: disabled ? -1 : 0,
+      "aria-valuemin": min,
+      "aria-valuemax": max,
+      "aria-valuenow": value,
+      "aria-disabled": disabled || void 0,
+      ...mergeProps(
+        partOnlyAttrs3(sliderAnatomy.thumb, { state: dragging ? "dragging" : disabled ? "disabled" : "idle" }),
+        {
+          style: { ...style, left: `${percent(value, min, max)}%` },
+          onPointerDown: (e) => {
+            onPointerDown?.(e);
+            if (disabled || e.button !== 0) return;
+            e.stopPropagation();
+            send({ type: "POINTER_DOWN" });
+          },
+          onKeyDown: (e) => {
+            onKeyDown?.(e);
+            if (disabled || e.defaultPrevented) return;
+            if (e.key === "ArrowRight" || e.key === "ArrowUp") {
+              e.preventDefault();
+              send({ type: "STEP", delta: step });
+            }
+            if (e.key === "ArrowLeft" || e.key === "ArrowDown") {
+              e.preventDefault();
+              send({ type: "STEP", delta: -step });
+            }
+            if (e.key === "Home") {
+              e.preventDefault();
+              send({ type: "HOME" });
+            }
+            if (e.key === "End") {
+              e.preventDefault();
+              send({ type: "END" });
+            }
+          }
+        },
+        rest
+      )
+    }
+  );
+});
+var ValueText = forwardRef9(function SliderValueText(props, ref) {
+  const { value } = useSliderCtx();
+  return /* @__PURE__ */ jsx9("span", { ref, ...mergeProps(partOnlyAttrs3(sliderAnatomy.valueText), props), children: props.children ?? value });
+});
+var Slider = { Root: Root9, Track: Track2, Range: Range2, Thumb: Thumb2, ValueText };
+
+// src/pin-input/index.tsx
+import { partAttrs as partAttrs10, partOnlyAttrs as partOnlyAttrs4, pinInputAnatomy } from "@aeon-ui/core";
+import {
+  createContext as createContext8,
+  forwardRef as forwardRef10,
+  useCallback as useCallback2,
+  useContext as useContext8,
+  useEffect as useEffect10,
+  useMemo as useMemo8,
+  useRef as useRef3,
+  useState as useState2
+} from "react";
+import { jsx as jsx10 } from "react/jsx-runtime";
+var PinInputCtx = createContext8(null);
+function usePinInputCtx() {
+  const ctx = useContext8(PinInputCtx);
+  if (!ctx) throw new Error("PinInput parts must be used within PinInput.Root");
+  return ctx;
+}
+function normalizePinValue(raw, length) {
+  return raw.replace(/\s/g, "").slice(0, length).split("");
+}
+var Root10 = forwardRef10(function PinInputRoot({
+  length = 4,
+  value,
+  defaultValue = "",
+  disabled = false,
+  onValueChange,
+  onComplete,
+  type = "numeric",
+  children,
+  className,
+  ...rest
+}, ref) {
+  const [uncontrolled, setUncontrolled] = useState2(() => normalizePinValue(defaultValue, length));
+  const inputRefs = useRef3([]);
+  const controlled = value !== void 0;
+  const chars = controlled ? normalizePinValue(value, length) : uncontrolled;
+  while (chars.length < length) chars.push("");
+  const resolved = chars.slice(0, length).join("");
+  useEffect10(() => {
+    onValueChange?.(resolved);
+    if (resolved.length === length && !resolved.includes("")) onComplete?.(resolved);
+  }, [resolved, length, onValueChange, onComplete]);
+  const setChars = useCallback2(
+    (next) => {
+      const joined = next.slice(0, length).join("");
+      if (!controlled) setUncontrolled(next.slice(0, length));
+      onValueChange?.(joined);
+      if (joined.length === length && !joined.includes("")) onComplete?.(joined);
+    },
+    [controlled, length, onValueChange, onComplete]
+  );
+  const setChar = useCallback2(
+    (index, char) => {
+      const next = [...chars.slice(0, length)];
+      while (next.length < length) next.push("");
+      next[index] = char;
+      setChars(next);
+    },
+    [chars, length, setChars]
+  );
+  const focusInput = useCallback2((index) => {
+    const el = inputRefs.current[index];
+    el?.focus();
+    el?.select();
+  }, []);
+  const registerInput = useCallback2((index, el) => {
+    inputRefs.current[index] = el;
+  }, []);
+  const ctx = useMemo8(
+    () => ({ length, values: chars.slice(0, length), disabled, type, setChar, focusInput, registerInput }),
+    [length, chars, disabled, type, setChar, focusInput, registerInput]
+  );
+  return /* @__PURE__ */ jsx10(PinInputCtx.Provider, { value: ctx, children: /* @__PURE__ */ jsx10(
+    "div",
+    {
+      ref,
+      className,
+      ...mergeProps(
+        partAttrs10(pinInputAnatomy.scope, pinInputAnatomy.root, {
+          state: resolved.length === length && !resolved.includes("") ? "complete" : "idle",
+          disabled
+        }),
+        rest
+      ),
+      children
+    }
+  ) });
+});
+var Input = forwardRef10(function PinInputInput({ index, onKeyDown, onChange, onPaste, ...rest }, ref) {
+  const { length, values, disabled, type, setChar, focusInput, registerInput } = usePinInputCtx();
+  const value = values[index] ?? "";
+  const pattern = type === "numeric" ? /^[0-9]$/ : /^[0-9a-zA-Z]$/;
+  const acceptChar = (raw) => {
+    if (!raw) return "";
+    const char = raw.slice(-1);
+    return pattern.test(char) ? char : "";
+  };
+  return /* @__PURE__ */ jsx10(
+    "input",
+    {
+      ref: (node) => {
+        registerInput(index, node);
+        if (typeof ref === "function") ref(node);
+        else if (ref) ref.current = node;
+      },
+      type: "text",
+      inputMode: type === "numeric" ? "numeric" : "text",
+      autoComplete: rest.autoComplete ?? "one-time-code",
+      maxLength: 1,
+      value,
+      disabled,
+      "aria-label": `Character ${index + 1} of ${length}`,
+      ...mergeProps(partOnlyAttrs4(pinInputAnatomy.input, { state: value ? "filled" : "empty" }), rest, {
+        onChange: (e) => {
+          onChange?.(e);
+          const char = acceptChar(e.target.value);
+          setChar(index, char);
+          if (char && index < length - 1) focusInput(index + 1);
+        },
+        onKeyDown: (e) => {
+          onKeyDown?.(e);
+          if (e.key === "Backspace" && !value && index > 0) {
+            e.preventDefault();
+            setChar(index - 1, "");
+            focusInput(index - 1);
+          }
+          if (e.key === "ArrowLeft" && index > 0) {
+            e.preventDefault();
+            focusInput(index - 1);
+          }
+          if (e.key === "ArrowRight" && index < length - 1) {
+            e.preventDefault();
+            focusInput(index + 1);
+          }
+        },
+        onPaste: (e) => {
+          onPaste?.(e);
+          e.preventDefault();
+          const text = e.clipboardData.getData("text").replace(/\s/g, "").slice(0, length - index);
+          if (!text) return;
+          for (let i = 0; i < text.length && index + i < length; i++) {
+            const char = acceptChar(text[i]);
+            if (char) setChar(index + i, char);
+          }
+          focusInput(Math.min(index + text.length, length - 1));
+        }
+      })
+    }
+  );
+});
+var Group2 = forwardRef10(
+  function PinInputGroup({ inputClassName, className, ...rest }, ref) {
+    const { length } = usePinInputCtx();
+    return /* @__PURE__ */ jsx10("div", { ref, className, ...rest, children: Array.from({ length }, (_, index) => /* @__PURE__ */ jsx10(Input, { index, className: inputClassName }, index)) });
+  }
+);
+var PinInput = { Root: Root10, Input, Group: Group2 };
+
+// src/accordion/index.tsx
+import { accordionAnatomy, partOnlyAttrs as partOnlyAttrs5, scopeAttrs } from "@aeon-ui/core";
+import { accordionMachine } from "@aeon-ui/primitives";
+import {
+  createContext as createContext9,
+  forwardRef as forwardRef11,
+  useContext as useContext9,
+  useEffect as useEffect11,
+  useMemo as useMemo9
+} from "react";
+import { jsx as jsx11 } from "react/jsx-runtime";
+var AccordionCtx = createContext9(null);
+function useAccordionCtx() {
+  const ctx = useContext9(AccordionCtx);
+  if (!ctx) throw new Error("Accordion parts must be used within Accordion.Root");
+  return ctx;
+}
+var Root11 = forwardRef11(function AccordionRoot({
+  value,
+  defaultValue = [],
+  multiple = false,
+  collapsible = true,
+  onValueChange,
+  children,
+  className,
+  ...rest
+}, ref) {
+  const [snapshot, send] = useAeonMachine(accordionMachine, {
+    input: { value: defaultValue, multiple, collapsible }
+  });
+  const resolvedValue = value ?? snapshot.context.value;
+  useEffect11(() => {
+    onValueChange?.(resolvedValue);
+  }, [resolvedValue, onValueChange]);
+  useEffect11(() => {
+    if (value !== void 0) send({ type: "SET_VALUE", value });
+  }, [value, send]);
+  const ctx = useMemo9(() => ({ value: resolvedValue, send }), [resolvedValue, send]);
+  return /* @__PURE__ */ jsx11(AccordionCtx.Provider, { value: ctx, children: /* @__PURE__ */ jsx11(
+    "div",
+    {
+      ref,
+      className,
+      ...mergeProps(
+        scopeAttrs(accordionAnatomy.scope, accordionAnatomy.root),
+        rest
+      ),
+      children
+    }
+  ) });
+});
+var Item2 = forwardRef11(function AccordionItem({ value: itemValue, children, ...rest }, ref) {
+  const { value } = useAccordionCtx();
+  const open = value.includes(itemValue);
+  return /* @__PURE__ */ jsx11(
+    "div",
+    {
+      ref,
+      ...mergeProps(
+        partOnlyAttrs5(accordionAnatomy.item, {
+          state: open ? "open" : "closed"
+        }),
+        rest
+      ),
+      children
+    }
+  );
+});
+var ItemTrigger = forwardRef11(function AccordionItemTrigger({ value: itemValue, onClick, ...rest }, ref) {
+  const { value, send } = useAccordionCtx();
+  const open = value.includes(itemValue);
+  return /* @__PURE__ */ jsx11(
+    "button",
+    {
+      ref,
+      type: "button",
+      "aria-expanded": open,
+      ...mergeProps(
+        partOnlyAttrs5(accordionAnatomy.itemTrigger, {
+          state: open ? "open" : "closed"
+        }),
+        {
+          onClick: (e) => {
+            onClick?.(e);
+            send({ type: "TOGGLE", item: itemValue });
+          }
+        },
+        rest
+      )
+    }
+  );
+});
+var ItemContent = forwardRef11(function AccordionItemContent({ value: itemValue, children, ...rest }, ref) {
+  const { value } = useAccordionCtx();
+  if (!value.includes(itemValue)) return null;
+  return /* @__PURE__ */ jsx11(
+    "div",
+    {
+      ref,
+      ...mergeProps(
+        partOnlyAttrs5(accordionAnatomy.itemContent, { state: "open" }),
+        rest
+      ),
+      children
+    }
+  );
+});
+var ItemIndicator2 = forwardRef11(function AccordionItemIndicator(props, ref) {
+  return /* @__PURE__ */ jsx11(
+    "span",
+    {
+      ref,
+      ...mergeProps(partOnlyAttrs5(accordionAnatomy.itemIndicator), props)
+    }
+  );
+});
+var Accordion = { Root: Root11, Item: Item2, ItemTrigger, ItemContent, ItemIndicator: ItemIndicator2 };
+
+// src/async/actions.tsx
+import { asyncAnatomy, partOnlyAttrs as partOnlyAttrs6 } from "@aeon-ui/core";
+import { forwardRef as forwardRef12 } from "react";
+import { jsx as jsx12 } from "react/jsx-runtime";
+var AsyncActions = forwardRef12(function AsyncActions2({ children, className, ...rest }, ref) {
+  return /* @__PURE__ */ jsx12(
+    "div",
+    {
+      ref,
+      className,
+      ...mergeProps(partOnlyAttrs6(asyncAnatomy.actions), rest),
+      children
+    }
+  );
+});
+
+// src/async/context.tsx
+import { createAsyncMachine } from "@aeon-ui/primitives";
+import { createContext as createContext10, useContext as useContext10, useMemo as useMemo10 } from "react";
+import { jsx as jsx13 } from "react/jsx-runtime";
+var defaultMachine = createAsyncMachine();
+var AsyncCtx = createContext10(null);
+function useAsyncContext() {
+  const ctx = useContext10(AsyncCtx);
+  if (!ctx) {
+    throw new Error("Async compound components must be used within <Async.Root>");
+  }
+  return ctx;
+}
+function AsyncProvider({ children, machine }) {
+  const resolvedMachine = machine ?? defaultMachine;
+  const [snapshot, send] = useAeonMachine(resolvedMachine);
+  const status = String(snapshot.value);
+  const { data, error, stale } = snapshot.context;
+  const stateAttr = stale && status === "success" ? `${status} stale` : status;
+  const value = useMemo10(
+    () => ({
+      send,
+      status,
+      data,
+      error,
+      stale: Boolean(stale),
+      stateAttr
+    }),
+    [send, status, data, error, stale, stateAttr]
+  );
+  return /* @__PURE__ */ jsx13(AsyncCtx.Provider, { value, children });
+}
+
+// src/async/readout.tsx
+import { asyncAnatomy as asyncAnatomy2, partAttrs as partAttrs11, partOnlyAttrs as partOnlyAttrs7 } from "@aeon-ui/core";
+import { forwardRef as forwardRef13 } from "react";
+import { jsx as jsx14, jsxs } from "react/jsx-runtime";
+var AsyncReadout = forwardRef13(function AsyncReadout2({ children, className, ...rest }, ref) {
+  const { stateAttr } = useAsyncContext();
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      ref,
+      role: "status",
+      "aria-live": "polite",
+      className,
+      ...mergeProps(partAttrs11(asyncAnatomy2.scope, asyncAnatomy2.readout, { state: stateAttr }), rest),
+      children: [
+        /* @__PURE__ */ jsx14(
+          "span",
+          {
+            className: "aeon-async-readout__rail",
+            "aria-hidden": true,
+            ...partOnlyAttrs7(asyncAnatomy2.readoutRail)
+          }
+        ),
+        /* @__PURE__ */ jsx14("div", { className: "aeon-async-readout__body", ...partOnlyAttrs7(asyncAnatomy2.readoutBody), children })
+      ]
+    }
+  );
+});
+
+// src/async/root.tsx
+import { asyncAnatomy as asyncAnatomy3, partAttrs as partAttrs12 } from "@aeon-ui/core";
+import { forwardRef as forwardRef14 } from "react";
+import { jsx as jsx15 } from "react/jsx-runtime";
+var AsyncRootInner = forwardRef14(function AsyncRootInner2({ children, className, ...rest }, ref) {
+  const { stateAttr } = useAsyncContext();
+  return /* @__PURE__ */ jsx15(
+    "div",
+    {
+      ref,
+      className,
+      ...mergeProps(partAttrs12(asyncAnatomy3.scope, asyncAnatomy3.root, { state: stateAttr }), rest),
+      children
+    }
+  );
+});
+var AsyncRoot = forwardRef14(function AsyncRoot2({ children, className, ...rest }, ref) {
+  return /* @__PURE__ */ jsx15(AsyncProvider, { children: /* @__PURE__ */ jsx15(AsyncRootInner, { ref, className, ...rest, children }) });
+});
+
+// src/async/track.tsx
+import { asyncAnatomy as asyncAnatomy4, partOnlyAttrs as partOnlyAttrs8 } from "@aeon-ui/core";
+import { ASYNC_LIFECYCLE_STATES } from "@aeon-ui/primitives";
+import { forwardRef as forwardRef15 } from "react";
+import { jsx as jsx16 } from "react/jsx-runtime";
+function segmentPhase(index, activeIndex) {
+  if (activeIndex === -1) return "future";
+  if (index === activeIndex) return "active";
+  if (index < activeIndex) return "past";
+  return "future";
+}
+var AsyncTrack = forwardRef15(function AsyncTrack2({ states = ASYNC_LIFECYCLE_STATES, className, ...rest }, ref) {
+  const { status } = useAsyncContext();
+  const activeIndex = states.indexOf(status);
+  const { style, ...restWithoutStyle } = rest;
+  return /* @__PURE__ */ jsx16(
+    "div",
+    {
+      ref,
+      role: "list",
+      "aria-label": "Async lifecycle states",
+      className,
+      style: {
+        ...style,
+        ["--aeon-state-track-count"]: states.length
+      },
+      ...mergeProps(partOnlyAttrs8(asyncAnatomy4.track), restWithoutStyle),
+      children: states.map((id, index) => {
+        const phase = segmentPhase(index, activeIndex);
+        return /* @__PURE__ */ jsx16(
+          "span",
+          {
+            role: "listitem",
+            "aria-current": phase === "active" ? "step" : void 0,
+            title: id,
+            className: `state-track__seg state-track__seg--${id} state-track__seg--${phase}`,
+            ...partOnlyAttrs8(asyncAnatomy4.segment, { state: `${id} ${phase}` }),
+            children: id
+          },
+          id
+        );
+      })
+    }
+  );
+});
+
+// src/async/legacy-region.tsx
+import { partAttrs as partAttrs13 } from "@aeon-ui/core";
+import { createAsyncMachine as createAsyncMachine2 } from "@aeon-ui/primitives";
+import { useMemo as useMemo11 } from "react";
+import { Fragment, jsx as jsx17, jsxs as jsxs2 } from "react/jsx-runtime";
+function AsyncRegion({ children, className }) {
+  const machine = useMemo11(() => createAsyncMachine2(), []);
+  const [snapshot] = useAeonMachine(machine);
+  const status = snapshot.value;
+  const { data, error } = snapshot.context;
+  const content = typeof children === "function" ? children({ status, data, error }) : children;
+  return /* @__PURE__ */ jsx17(
+    "div",
+    {
+      className,
+      ...mergeProps(partAttrs13("async", "root", { state: status })),
+      children: content ?? /* @__PURE__ */ jsxs2(Fragment, { children: [
+        status === "idle" && /* @__PURE__ */ jsx17("span", { "data-aeon-part": "idle", children: "Ready" }),
+        status === "loading" && /* @__PURE__ */ jsx17("span", { "data-aeon-part": "loading", children: "Loading\u2026" }),
+        status === "success" && /* @__PURE__ */ jsx17("span", { "data-aeon-part": "success", children: String(data) }),
+        status === "failure" && /* @__PURE__ */ jsx17("span", { "data-aeon-part": "failure", children: error }),
+        status === "empty" && /* @__PURE__ */ jsx17("span", { "data-aeon-part": "empty", children: "No results" })
+      ] })
+    }
+  );
+}
+
+// src/async/index.tsx
+import { createAsyncMachine as createAsyncMachine3 } from "@aeon-ui/primitives";
+var Async = {
+  Root: AsyncRoot,
+  Provider: AsyncProvider,
+  Track: AsyncTrack,
+  Readout: AsyncReadout,
+  Actions: AsyncActions
+};
+
+// src/field/index.tsx
+import { fieldAnatomy, partAttrs as partAttrs14, partOnlyAttrs as partOnlyAttrs9, stateToAttr } from "@aeon-ui/core";
+import { fieldMachine } from "@aeon-ui/primitives";
+import {
+  createContext as createContext11,
+  forwardRef as forwardRef16,
+  useContext as useContext11,
+  useMemo as useMemo12
+} from "react";
+import { jsx as jsx18 } from "react/jsx-runtime";
+var FieldCtx = createContext11(null);
+function useFieldContext() {
+  const ctx = useContext11(FieldCtx);
+  if (!ctx) throw new Error("Field parts must be used within <Field.Root>");
+  return ctx;
+}
+var Root12 = forwardRef16(function FieldRoot({ children, className, id }, ref) {
+  const [snapshot, send] = useAeonMachine(fieldMachine);
+  const stateAttr = stateToAttr(snapshot.value);
+  const invalid = typeof snapshot.value === "object" && snapshot.value !== null && "validation" in snapshot.value && snapshot.value.validation === "invalid";
+  const pending = typeof snapshot.value === "object" && snapshot.value !== null && "submission" in snapshot.value && snapshot.value.submission === "pending";
+  const value = useMemo12(
+    () => ({ stateAttr, send, invalid, pending }),
+    [stateAttr, send, invalid, pending]
+  );
+  return /* @__PURE__ */ jsx18(FieldCtx.Provider, { value, children: /* @__PURE__ */ jsx18(
+    "div",
+    {
+      ref,
+      id,
+      className,
+      ...partAttrs14(fieldAnatomy.scope, fieldAnatomy.root, { state: stateAttr }),
+      children
+    }
+  ) });
+});
+var Label5 = forwardRef16(function FieldLabel(props, ref) {
+  return /* @__PURE__ */ jsx18("label", { ref, ...partOnlyAttrs9(fieldAnatomy.label), ...props });
+});
+var Control3 = forwardRef16(function FieldControl({ validate, onChange, onBlur, ...rest }, ref) {
+  const { send, invalid } = useFieldContext();
+  return /* @__PURE__ */ jsx18(
+    "input",
+    {
+      ref,
+      "aria-invalid": invalid || void 0,
+      ...partOnlyAttrs9(fieldAnatomy.control),
+      ...mergeProps(
+        {
+          onChange: (e) => {
+            send({ type: "INPUT" });
+            const ok = validate?.(e.target.value) ?? true;
+            send({ type: "VALIDATE", valid: ok });
+            onChange?.(e);
+          },
+          onBlur: (e) => {
+            send({ type: "BLUR" });
+            onBlur?.(e);
+          }
+        },
+        rest
+      )
+    }
+  );
+});
+var Textarea = forwardRef16(function FieldTextarea({ validate, onChange, onBlur, ...rest }, ref) {
+  const { send, invalid } = useFieldContext();
+  return /* @__PURE__ */ jsx18(
+    "textarea",
+    {
+      ref,
+      "aria-invalid": invalid || void 0,
+      ...partOnlyAttrs9(fieldAnatomy.textarea),
+      ...mergeProps(
+        {
+          onChange: (e) => {
+            send({ type: "INPUT" });
+            const ok = validate?.(e.target.value) ?? true;
+            send({ type: "VALIDATE", valid: ok });
+            onChange?.(e);
+          },
+          onBlur: (e) => {
+            send({ type: "BLUR" });
+            onBlur?.(e);
+          }
+        },
+        rest
+      )
+    }
+  );
+});
+var Message = forwardRef16(
+  function FieldMessage(props, ref) {
+    const { invalid } = useFieldContext();
+    if (!invalid) return null;
+    return /* @__PURE__ */ jsx18(
+      "p",
+      {
+        ref,
+        role: "alert",
+        ...partOnlyAttrs9(fieldAnatomy.message, { state: "invalid" }),
+        ...props
+      }
+    );
+  }
+);
+var Hint = forwardRef16(
+  function FieldHint(props, ref) {
+    return /* @__PURE__ */ jsx18("p", { ref, ...partOnlyAttrs9(fieldAnatomy.hint), ...props });
+  }
+);
+var Field = { Root: Root12, Label: Label5, Control: Control3, Textarea, Message, Hint };
+
+// src/scroll/index.tsx
+import { scrollAnatomy, partAttrs as partAttrs15, partOnlyAttrs as partOnlyAttrs10 } from "@aeon-ui/core";
+import {
+  createContext as createContext12,
+  forwardRef as forwardRef17,
+  useContext as useContext12,
+  useMemo as useMemo13,
+  useRef as useRef4
+} from "react";
+
+// src/scroll/use-scroll-state.ts
+import { getScrollSnapshot } from "@aeon-ui/core";
+import { useLayoutEffect, useState as useState3 } from "react";
+function useScrollState(ref) {
+  const [stateAttr, setStateAttr] = useState3("idle");
+  useLayoutEffect(() => {
+    const el = ref.current;
+    if (!el) return;
+    const update = () => {
+      setStateAttr(getScrollSnapshot(el).stateAttr);
+    };
+    update();
+    el.addEventListener("scroll", update, { passive: true });
+    const ro = new ResizeObserver(update);
+    ro.observe(el);
+    const content = el.firstElementChild;
+    if (content instanceof HTMLElement) ro.observe(content);
+    return () => {
+      el.removeEventListener("scroll", update);
+      ro.disconnect();
+    };
+  }, [ref]);
+  return stateAttr;
+}
+
+// src/scroll/index.tsx
+import { jsx as jsx19 } from "react/jsx-runtime";
+var ScrollCtx = createContext12(null);
+function useScrollContext() {
+  const ctx = useContext12(ScrollCtx);
+  if (!ctx) throw new Error("Scroll parts must be used within <Scroll.Root>");
+  return ctx;
+}
+var Root13 = forwardRef17(function ScrollRoot({ children, className, ...rest }, ref) {
+  const viewportRef = useRef4(null);
+  const stateAttr = useScrollState(viewportRef);
+  const value = useMemo13(() => ({ stateAttr }), [stateAttr]);
+  return /* @__PURE__ */ jsx19(ScrollCtx.Provider, { value, children: /* @__PURE__ */ jsx19(
+    "div",
+    {
+      ref,
+      className,
+      ...partAttrs15(scrollAnatomy.scope, scrollAnatomy.root),
+      ...rest,
+      children: /* @__PURE__ */ jsx19(ScrollViewportRefContext.Provider, { value: viewportRef, children })
+    }
+  ) });
+});
+var ScrollViewportRefContext = createContext12(
+  null
+);
+var Viewport = forwardRef17(function ScrollViewport({ children, className, ...rest }, forwardedRef) {
+  const ctxRef = useContext12(ScrollViewportRefContext);
+  const { stateAttr } = useScrollContext();
+  return /* @__PURE__ */ jsx19(
+    "div",
+    {
+      ref: (node) => {
+        if (ctxRef) ctxRef.current = node;
+        if (typeof forwardedRef === "function") forwardedRef(node);
+        else if (forwardedRef) forwardedRef.current = node;
+      },
+      className,
+      "data-aeon-scroll": "",
+      ...partAttrs15(scrollAnatomy.scope, scrollAnatomy.viewport, { state: stateAttr }),
+      ...rest,
+      children
+    }
+  );
+});
+var Content3 = forwardRef17(function ScrollContent(props, ref) {
+  return /* @__PURE__ */ jsx19("div", { ref, ...partOnlyAttrs10(scrollAnatomy.content), ...props });
+});
+var Scroll = {
+  Root: Root13,
+  Viewport,
+  Content: Content3
+};
+
+// src/select/index.tsx
+import { selectAnatomy, partAttrs as partAttrs17, partOnlyAttrs as partOnlyAttrs11 } from "@aeon-ui/core";
+import { popoverMachine } from "@aeon-ui/primitives";
+import {
+  createContext as createContext13,
+  forwardRef as forwardRef19,
+  useCallback as useCallback3,
+  useContext as useContext13,
+  useId as useId2,
+  useMemo as useMemo14,
+  useRef as useRef5,
+  useState as useState4
+} from "react";
+
+// src/floating/FloatingPositioner.tsx
+import { partAttrs as partAttrs16 } from "@aeon-ui/core";
+import { forwardRef as forwardRef18 } from "react";
+
+// src/hooks/use-anchor-position.ts
+import { useEffect as useEffect12 } from "react";
+function useAnchorPosition(anchorRef, floatingRef, active, placement = "bottom-start", options = {}) {
+  const { matchWidth = false } = options;
+  useEffect12(() => {
+    if (!active || !anchorRef.current || !floatingRef.current) return;
+    const update = () => {
+      const anchor = anchorRef.current;
+      const floating = floatingRef.current;
+      if (!anchor || !floating) return;
+      const rect = anchor.getBoundingClientRect();
+      floating.style.position = "fixed";
+      floating.style.left = `${rect.left}px`;
+      floating.style.bottom = "";
+      floating.style.right = "";
+      floating.style.zIndex = "50";
+      if (matchWidth) {
+        floating.style.width = `${rect.width}px`;
+        floating.style.minWidth = `${rect.width}px`;
+      } else {
+        floating.style.width = "";
+        floating.style.minWidth = "";
+      }
+      if (placement === "top-start") {
+        const height = floating.offsetHeight || floating.getBoundingClientRect().height;
+        floating.style.top = `${rect.top - height - 4}px`;
+      } else {
+        floating.style.top = `${rect.bottom + 4}px`;
+      }
+    };
+    update();
+    requestAnimationFrame(update);
+    window.addEventListener("resize", update);
+    window.addEventListener("scroll", update, true);
+    return () => {
+      window.removeEventListener("resize", update);
+      window.removeEventListener("scroll", update, true);
+    };
+  }, [active, anchorRef, floatingRef, placement, matchWidth]);
+}
+
+// src/floating/FloatingPositioner.tsx
+import { jsx as jsx20 } from "react/jsx-runtime";
+var FloatingPositioner = forwardRef18(
+  function FloatingPositioner2({
+    open,
+    scope,
+    part,
+    triggerRef,
+    positionerRef,
+    portalled = true,
+    placement = "bottom-start",
+    matchAnchorWidth = false,
+    children,
+    className,
+    ...rest
+  }, ref) {
+    const mounted = usePortalledMount();
+    useAnchorPosition(triggerRef, positionerRef, open && portalled, placement, {
+      matchWidth: matchAnchorWidth
+    });
+    if (!open) return null;
+    const node = /* @__PURE__ */ jsx20(
+      "div",
+      {
+        ref: (el) => {
+          positionerRef.current = el;
+          if (typeof ref === "function") ref(el);
+          else if (ref) ref.current = el;
+        },
+        className,
+        ...mergeProps(partAttrs16(scope, part, { state: "open" }), rest),
+        children
+      }
+    );
+    return renderPortalled(node, portalled, mounted);
+  }
+);
+
+// src/hooks/use-outside-click.ts
+import { useEffect as useEffect13 } from "react";
+function useOutsideClick(refs, enabled, onOutside) {
+  useEffect13(() => {
+    if (!enabled) return;
+    const onDown = (e) => {
+      const target = e.target;
+      if (refs.some((r) => r.current?.contains(target))) return;
+      onOutside();
+    };
+    document.addEventListener("mousedown", onDown);
+    return () => document.removeEventListener("mousedown", onDown);
+  }, [refs, enabled, onOutside]);
+}
+
+// src/select/index.tsx
+import { jsx as jsx21, jsxs as jsxs3 } from "react/jsx-runtime";
+var SelectCtx = createContext13(null);
+var SelectPositionerCtx = createContext13(false);
+function useSelectCtx() {
+  const ctx = useContext13(SelectCtx);
+  if (!ctx) throw new Error("Select parts must be used within <Select.Root>");
+  return ctx;
+}
+function optionValuesFromDom(listboxId, content) {
+  if (!content) return [];
+  const prefix = `${listboxId}-option-`;
+  return Array.from(content.querySelectorAll('button[role="option"]:not(:disabled)')).map((el) => el.id.startsWith(prefix) ? el.id.slice(prefix.length) : "").filter(Boolean);
+}
+var Root14 = forwardRef19(function SelectRoot({ value, onValueChange, children, className, disabled }, ref) {
+  const [snapshot, send] = useAeonMachine(popoverMachine, { input: { open: false } });
+  const [highlightedValue, setHighlightedValue] = useState4(null);
+  const triggerRef = useRef5(null);
+  const positionerRef = useRef5(null);
+  const contentRef = useRef5(null);
+  const rootRef = useRef5(null);
+  const listboxId = useId2();
+  const open = disabled ? false : snapshot.matches("open");
+  const close = useCallback3(() => {
+    send({ type: "CLOSE" });
+    setHighlightedValue(null);
+  }, [send]);
+  useOutsideClick([rootRef, positionerRef], open, () => send({ type: "POINTER_DOWN_OUTSIDE" }));
+  const getOptionValues = useCallback3(
+    () => optionValuesFromDom(listboxId, contentRef.current),
+    [listboxId, open]
+  );
+  const selectValue = useCallback3(
+    (next) => {
+      onValueChange?.(next);
+      close();
+    },
+    [onValueChange, close]
+  );
+  const highlightValue = useCallback3((next) => {
+    setHighlightedValue(next);
+  }, []);
+  const moveHighlight = useCallback3(
+    (delta) => {
+      const options = getOptionValues();
+      if (options.length === 0) {
+        setHighlightedValue(null);
+        return;
+      }
+      const idx = highlightedValue ? options.indexOf(highlightedValue) : -1;
+      let next = idx + delta;
+      if (next < 0) next = options.length - 1;
+      if (next >= options.length) next = 0;
+      setHighlightedValue(options[next]);
+    },
+    [getOptionValues, highlightedValue]
+  );
+  const onListboxKeyDown = useCallback3(
+    (e) => {
+      if (e.defaultPrevented) return;
+      if ((e.key === "Enter" || e.key === " ") && !open) {
+        e.preventDefault();
+        send({ type: "OPEN" });
+        return;
+      }
+      if (e.key === "ArrowDown") {
+        e.preventDefault();
+        if (!open) send({ type: "OPEN" });
+        else moveHighlight(1);
+        return;
+      }
+      if (e.key === "ArrowUp") {
+        e.preventDefault();
+        if (!open) send({ type: "OPEN" });
+        else moveHighlight(-1);
+        return;
+      }
+      if (e.key === "Home" && open) {
+        e.preventDefault();
+        const first = getOptionValues()[0];
+        if (first) highlightValue(first);
+        return;
+      }
+      if (e.key === "End" && open) {
+        e.preventDefault();
+        const options = getOptionValues();
+        const last = options[options.length - 1];
+        if (last) highlightValue(last);
+        return;
+      }
+      if ((e.key === "Enter" || e.key === " ") && open) {
+        e.preventDefault();
+        const pick = highlightedValue ?? getOptionValues()[0];
+        if (pick) selectValue(pick);
+        return;
+      }
+      if (e.key === "Escape") send({ type: "ESCAPE" });
+    },
+    [open, send, moveHighlight, getOptionValues, highlightValue, highlightedValue, selectValue]
+  );
+  const ctx = useMemo14(
+    () => ({
+      value,
+      open,
+      listboxId,
+      highlightedValue,
+      send,
+      triggerRef,
+      positionerRef,
+      contentRef,
+      onValueChange,
+      moveHighlight,
+      highlightValue,
+      selectValue,
+      onListboxKeyDown
+    }),
+    [
+      value,
+      open,
+      listboxId,
+      highlightedValue,
+      send,
+      onValueChange,
+      moveHighlight,
+      highlightValue,
+      selectValue,
+      onListboxKeyDown
+    ]
+  );
+  return /* @__PURE__ */ jsx21(SelectCtx.Provider, { value: ctx, children: /* @__PURE__ */ jsx21(
+    "div",
+    {
+      ref: (node) => {
+        rootRef.current = node;
+        if (typeof ref === "function") ref(node);
+        else if (ref) ref.current = node;
+      },
+      className,
+      ...partAttrs17(selectAnatomy.scope, selectAnatomy.root, {
+        state: open ? "open" : "closed"
+      }),
+      children
+    }
+  ) });
+});
+var ValueText2 = forwardRef19(function SelectValueText(props, ref) {
+  return /* @__PURE__ */ jsx21("span", { ref, ...partOnlyAttrs11(selectAnatomy.value), ...props });
+});
+var Trigger3 = forwardRef19(function SelectTrigger({ children, onClick, onKeyDown, ...rest }, ref) {
+  const { open, send, listboxId, triggerRef, onListboxKeyDown } = useSelectCtx();
+  return /* @__PURE__ */ jsxs3(
+    "button",
+    {
+      ref: (node) => {
+        triggerRef.current = node;
+        if (typeof ref === "function") ref(node);
+        else if (ref) ref.current = node;
+      },
+      type: "button",
+      "aria-haspopup": "listbox",
+      "aria-expanded": open,
+      "aria-controls": open ? listboxId : void 0,
+      ...partAttrs17(selectAnatomy.scope, selectAnatomy.trigger, { state: open ? "open" : "closed" }),
+      ...mergeProps(rest, {
+        onClick: (e) => {
+          onClick?.(e);
+          if (!e.defaultPrevented) send({ type: "TOGGLE" });
+        },
+        onKeyDown: (e) => {
+          onKeyDown?.(e);
+          onListboxKeyDown(e);
+        }
+      }),
+      children: [
+        children,
+        /* @__PURE__ */ jsx21("span", { ...partOnlyAttrs11(selectAnatomy.icon), "aria-hidden": true })
+      ]
+    }
+  );
+});
+var Positioner2 = forwardRef19(function SelectPositioner({ portalled = true, children, className, ...rest }, ref) {
+  const { open, triggerRef, positionerRef } = useSelectCtx();
+  return /* @__PURE__ */ jsx21(SelectPositionerCtx.Provider, { value: true, children: /* @__PURE__ */ jsx21(
+    FloatingPositioner,
+    {
+      ref,
+      open,
+      scope: selectAnatomy.scope,
+      part: selectAnatomy.positioner,
+      triggerRef,
+      positionerRef,
+      portalled,
+      matchAnchorWidth: true,
+      className,
+      ...rest,
+      children
+    }
+  ) });
+});
+var Content4 = forwardRef19(function SelectContent({ portalled = true, onKeyDown, children, className, ...rest }, ref) {
+  const inPositioner = useContext13(SelectPositionerCtx);
+  const { open, listboxId, contentRef, highlightedValue, onListboxKeyDown, triggerRef, positionerRef } = useSelectCtx();
+  if (!open) return null;
+  const activeId = highlightedValue && open ? `${listboxId}-option-${highlightedValue}` : void 0;
+  const listbox = /* @__PURE__ */ jsx21(
+    "div",
+    {
+      ref: (node) => {
+        contentRef.current = node;
+        if (typeof ref === "function") ref(node);
+        else if (ref) ref.current = node;
+      },
+      id: listboxId,
+      role: "listbox",
+      "aria-activedescendant": activeId,
+      className,
+      "data-aeon-scroll": "",
+      ...partAttrs17(selectAnatomy.scope, selectAnatomy.content, { state: "open" }),
+      ...mergeProps(rest, {
+        onKeyDown: (e) => {
+          onKeyDown?.(e);
+          onListboxKeyDown(e);
+        }
+      }),
+      children
+    }
+  );
+  if (inPositioner) return listbox;
+  return /* @__PURE__ */ jsx21(
+    FloatingPositioner,
+    {
+      open,
+      scope: selectAnatomy.scope,
+      part: selectAnatomy.positioner,
+      triggerRef,
+      positionerRef,
+      portalled,
+      matchAnchorWidth: true,
+      children: listbox
+    }
+  );
+});
+var Item3 = forwardRef19(function SelectItem({ value, disabled = false, children, onClick, ...rest }, ref) {
+  const { value: selected, listboxId, highlightedValue, selectValue } = useSelectCtx();
+  const selectedState = value === selected;
+  const highlighted = value === highlightedValue;
+  return /* @__PURE__ */ jsx21(
+    "button",
+    {
+      ref,
+      type: "button",
+      role: "option",
+      id: `${listboxId}-option-${value}`,
+      "aria-selected": selectedState,
+      disabled,
+      ...partAttrs17(selectAnatomy.scope, selectAnatomy.item, {
+        state: selectedState ? "selected" : highlighted ? "highlighted" : "idle",
+        highlighted
+      }),
+      ...mergeProps(rest, {
+        onClick: (e) => {
+          onClick?.(e);
+          if (!e.defaultPrevented && !disabled) selectValue(value);
+        }
+      }),
+      children
+    }
+  );
+});
+var Select = {
+  Root: Root14,
+  Trigger: Trigger3,
+  ValueText: ValueText2,
+  Positioner: Positioner2,
+  Content: Content4,
+  Item: Item3
+};
+
+// src/combobox/index.tsx
+import { comboboxAnatomy, partAttrs as partAttrs18, partOnlyAttrs as partOnlyAttrs12 } from "@aeon-ui/core";
+import {
+  createContext as createContext14,
+  forwardRef as forwardRef20,
+  useCallback as useCallback4,
+  useContext as useContext14,
+  useEffect as useEffect14,
+  useId as useId3,
+  useMemo as useMemo15,
+  useRef as useRef6,
+  useState as useState5
+} from "react";
+import { Fragment as Fragment2, jsx as jsx22, jsxs as jsxs4 } from "react/jsx-runtime";
+var ComboboxCtx = createContext14(null);
+function useComboboxCtx() {
+  const ctx = useContext14(ComboboxCtx);
+  if (!ctx) throw new Error("Combobox parts must be used within <Combobox.Root>");
+  return ctx;
+}
+function normalizeLabel(label, children) {
+  if (label) return label;
+  if (typeof children === "string") return children;
+  return "";
+}
+function matchesQuery(label, query) {
+  const q = query.trim().toLowerCase();
+  if (!q) return true;
+  return label.toLowerCase().includes(q);
+}
+var Root15 = forwardRef20(function ComboboxRoot({ value, onValueChange, children, className, disabled }, ref) {
+  const [open, setOpenState] = useState5(false);
+  const [query, setQuery] = useState5("");
+  const [highlightedValue, setHighlightedValue] = useState5(null);
+  const [itemsVersion, setItemsVersion] = useState5(0);
+  const itemsRef = useRef6([]);
+  const listboxId = useId3();
+  const setOpen = useCallback4(
+    (next) => {
+      if (disabled) return;
+      setOpenState(next);
+      if (!next) {
+        setQuery("");
+        setHighlightedValue(null);
+      }
+    },
+    [disabled]
+  );
+  const registerItem = useCallback4((item) => {
+    itemsRef.current = [...itemsRef.current.filter((i) => i.value !== item.value), item];
+    setItemsVersion((v) => v + 1);
+  }, []);
+  const unregisterItem = useCallback4((valueKey) => {
+    itemsRef.current = itemsRef.current.filter((i) => i.value !== valueKey);
+    setItemsVersion((v) => v + 1);
+  }, []);
+  const getItems = useCallback4(() => itemsRef.current, []);
+  const ctx = useMemo15(
+    () => ({
+      value,
+      open: disabled ? false : open,
+      query,
+      listboxId,
+      highlightedValue,
+      itemsVersion,
+      setOpen,
+      setQuery,
+      setHighlightedValue,
+      onValueChange,
+      registerItem,
+      unregisterItem,
+      getItems
+    }),
+    [
+      value,
+      open,
+      query,
+      listboxId,
+      highlightedValue,
+      itemsVersion,
+      setOpen,
+      onValueChange,
+      registerItem,
+      unregisterItem,
+      getItems,
+      disabled
+    ]
+  );
+  return /* @__PURE__ */ jsx22(ComboboxCtx.Provider, { value: ctx, children: /* @__PURE__ */ jsx22(
+    "div",
+    {
+      ref,
+      className,
+      ...partAttrs18(comboboxAnatomy.scope, comboboxAnatomy.root, {
+        state: open ? "open" : "closed"
+      }),
+      children
+    }
+  ) });
+});
+function useVisibleItems() {
+  const { query, getItems, itemsVersion } = useComboboxCtx();
+  return useMemo15(() => {
+    void itemsVersion;
+    return getItems().filter((i) => matchesQuery(i.label, query));
+  }, [query, getItems, itemsVersion]);
+}
+var Input2 = forwardRef20(function ComboboxInput({ onChange, onKeyDown, onFocus, onClick, value: valueProp, ...rest }, ref) {
+  const {
+    value: selected,
+    open,
+    query,
+    listboxId,
+    highlightedValue,
+    itemsVersion,
+    setOpen,
+    setQuery,
+    setHighlightedValue,
+    onValueChange,
+    getItems
+  } = useComboboxCtx();
+  const inputRef = useRef6(null);
+  const visible = useVisibleItems();
+  const selectedLabel = useMemo15(() => {
+    void itemsVersion;
+    return getItems().find((i) => i.value === selected)?.label ?? "";
+  }, [getItems, selected, itemsVersion]);
+  const displayValue = open ? query : selectedLabel;
+  const selectValue = useCallback4(
+    (next) => {
+      onValueChange?.(next);
+      setOpen(false);
+      setQuery("");
+      setHighlightedValue(null);
+    },
+    [onValueChange, setOpen, setQuery, setHighlightedValue]
+  );
+  const moveHighlight = useCallback4(
+    (delta) => {
+      if (visible.length === 0) {
+        setHighlightedValue(null);
+        return;
+      }
+      const idx = highlightedValue ? visible.findIndex((i) => i.value === highlightedValue) : -1;
+      let next = idx + delta;
+      if (next < 0) next = visible.length - 1;
+      if (next >= visible.length) next = 0;
+      setHighlightedValue(visible[next].value);
+    },
+    [visible, highlightedValue, setHighlightedValue]
+  );
+  const setRefs = useCallback4(
+    (node) => {
+      inputRef.current = node;
+      if (typeof ref === "function") ref(node);
+      else if (ref) ref.current = node;
+    },
+    [ref]
+  );
+  useEffect14(() => {
+    if (!open) return;
+    const onPointerDown = (e) => {
+      const root = inputRef.current?.closest('[data-aeon-scope="combobox"]');
+      if (root && !root.contains(e.target)) setOpen(false);
+    };
+    const onKey = (e) => {
+      if (e.key === "Escape") setOpen(false);
+    };
+    document.addEventListener("pointerdown", onPointerDown);
+    document.addEventListener("keydown", onKey);
+    return () => {
+      document.removeEventListener("pointerdown", onPointerDown);
+      document.removeEventListener("keydown", onKey);
+    };
+  }, [open, setOpen]);
+  const activeDescendant = highlightedValue && open ? `${listboxId}-option-${highlightedValue}` : void 0;
+  return /* @__PURE__ */ jsxs4(Fragment2, { children: [
+    /* @__PURE__ */ jsx22(
+      "input",
+      {
+        ref: setRefs,
+        type: "text",
+        role: "combobox",
+        "aria-autocomplete": "list",
+        "aria-expanded": open,
+        "aria-controls": open ? listboxId : void 0,
+        "aria-activedescendant": activeDescendant,
+        autoComplete: "off",
+        value: valueProp ?? displayValue,
+        ...partAttrs18(comboboxAnatomy.scope, comboboxAnatomy.input, { state: open ? "open" : "closed" }),
+        ...mergeProps(rest, {
+          onFocus: (e) => {
+            onFocus?.(e);
+            setOpen(true);
+          },
+          onClick: (e) => {
+            onClick?.(e);
+            setOpen(true);
+          },
+          onChange: (e) => {
+            onChange?.(e);
+            if (!e.defaultPrevented) {
+              setOpen(true);
+              setQuery(e.target.value);
+              setHighlightedValue(null);
+            }
+          },
+          onKeyDown: (e) => {
+            onKeyDown?.(e);
+            if (e.defaultPrevented) return;
+            if (e.key === "ArrowDown") {
+              e.preventDefault();
+              if (!open) setOpen(true);
+              else moveHighlight(1);
+            }
+            if (e.key === "ArrowUp") {
+              e.preventDefault();
+              if (!open) setOpen(true);
+              else moveHighlight(-1);
+            }
+            if (e.key === "Home" && open) {
+              e.preventDefault();
+              if (visible[0]) setHighlightedValue(visible[0].value);
+            }
+            if (e.key === "End" && open) {
+              e.preventDefault();
+              if (visible[visible.length - 1]) setHighlightedValue(visible[visible.length - 1].value);
+            }
+            if (e.key === "Enter") {
+              e.preventDefault();
+              const pick = highlightedValue ?? visible[0]?.value;
+              if (pick) selectValue(pick);
+            }
+            if (e.key === "Escape") setOpen(false);
+          }
+        })
+      }
+    ),
+    /* @__PURE__ */ jsx22(
+      "span",
+      {
+        ...partOnlyAttrs12(comboboxAnatomy.icon, { state: open ? "open" : "closed" }),
+        "aria-hidden": true,
+        style: open ? { transform: "rotate(-135deg) translateY(2px)" } : void 0
+      }
+    )
+  ] });
+});
+var Content5 = forwardRef20(function ComboboxContent({ children, className, ...rest }, ref) {
+  const { open, listboxId } = useComboboxCtx();
+  if (!open) return null;
+  return /* @__PURE__ */ jsx22(
+    "div",
+    {
+      ref,
+      id: listboxId,
+      role: "listbox",
+      className,
+      "data-aeon-scroll": "",
+      ...partAttrs18(comboboxAnatomy.scope, comboboxAnatomy.content),
+      ...rest,
+      children
+    }
+  );
+});
+var Item4 = forwardRef20(function ComboboxItem({ value, textValue, children, onClick, ...rest }, ref) {
+  const {
+    value: selected,
+    query,
+    highlightedValue,
+    listboxId,
+    onValueChange,
+    setOpen,
+    setHighlightedValue,
+    registerItem,
+    unregisterItem
+  } = useComboboxCtx();
+  const label = normalizeLabel(textValue, children);
+  const resolvedOptionId = `${listboxId}-option-${value}`;
+  useEffect14(() => {
+    registerItem({ value, label });
+    return () => unregisterItem(value);
+  }, [value, label, registerItem, unregisterItem]);
+  if (!matchesQuery(label, query)) return null;
+  const selectedState = value === selected;
+  const highlighted = value === highlightedValue;
+  return /* @__PURE__ */ jsx22(
+    "button",
+    {
+      ref,
+      type: "button",
+      role: "option",
+      id: resolvedOptionId,
+      "aria-selected": selectedState,
+      "data-highlighted": highlighted ? "" : void 0,
+      ...partAttrs18(comboboxAnatomy.scope, comboboxAnatomy.item, {
+        state: selectedState ? "selected" : "idle",
+        highlighted
+      }),
+      ...mergeProps(rest, {
+        onClick: (e) => {
+          onClick?.(e);
+          if (!e.defaultPrevented) {
+            onValueChange?.(value);
+            setOpen(false);
+          }
+        },
+        onMouseEnter: () => setHighlightedValue(value)
+      }),
+      children
+    }
+  );
+});
+var Empty = forwardRef20(function ComboboxEmpty({ children, className, ...rest }, ref) {
+  const { open, query } = useComboboxCtx();
+  const visible = useVisibleItems();
+  if (!open || !query.trim() || visible.length > 0) return null;
+  return /* @__PURE__ */ jsx22(
+    "div",
+    {
+      ref,
+      className,
+      ...partAttrs18(comboboxAnatomy.scope, comboboxAnatomy.empty),
+      ...rest,
+      children: children ?? "No results"
+    }
+  );
+});
+var Combobox = {
+  Root: Root15,
+  Input: Input2,
+  Content: Content5,
+  Item: Item4,
+  Empty
+};
+
+// src/popover/index.tsx
+import { popoverAnatomy, partAttrs as partAttrs19 } from "@aeon-ui/core";
+import { popoverMachine as popoverMachine2 } from "@aeon-ui/primitives";
+import {
+  createContext as createContext15,
+  forwardRef as forwardRef21,
+  useCallback as useCallback5,
+  useContext as useContext15,
+  useEffect as useEffect15,
+  useId as useId4,
+  useMemo as useMemo16,
+  useRef as useRef7
+} from "react";
+import { jsx as jsx23 } from "react/jsx-runtime";
+var PopoverCtx = createContext15(null);
+function usePopoverCtx() {
+  const ctx = useContext15(PopoverCtx);
+  if (!ctx) throw new Error("Popover parts must be used within Popover.Root");
+  return ctx;
+}
+var Root16 = forwardRef21(function PopoverRoot({ open, defaultOpen = false, onOpenChange, children, className, ...rest }, ref) {
+  const [snapshot, send] = useAeonMachine(popoverMachine2, {
+    input: { open: defaultOpen }
+  });
+  const resolvedOpen = open ?? snapshot.context.open;
+  const rootRef = useRef7(null);
+  const triggerRef = useRef7(null);
+  const positionerRef = useRef7(null);
+  const triggerId = useId4();
+  const contentId = useId4();
+  useEffect15(() => {
+    onOpenChange?.(resolvedOpen);
+  }, [resolvedOpen, onOpenChange]);
+  useEffect15(() => {
+    if (open !== void 0) send({ type: "SET_OPEN", open });
+  }, [open, send]);
+  const close = useCallback5(() => send({ type: "CLOSE" }), [send]);
+  useOutsideClick([rootRef, positionerRef], resolvedOpen, close);
+  const value = useMemo16(
+    () => ({ open: resolvedOpen, send, triggerId, contentId, triggerRef, positionerRef }),
+    [resolvedOpen, send, triggerId, contentId]
+  );
+  return /* @__PURE__ */ jsx23(PopoverCtx.Provider, { value, children: /* @__PURE__ */ jsx23(
+    "div",
+    {
+      ref: (node) => {
+        rootRef.current = node;
+        if (typeof ref === "function") ref(node);
+        else if (ref) ref.current = node;
+      },
+      className,
+      ...mergeProps(
+        partAttrs19(popoverAnatomy.scope, popoverAnatomy.root, {
+          state: resolvedOpen ? "open" : "closed"
+        }),
+        rest
+      ),
+      children
+    }
+  ) });
+});
+var Trigger4 = forwardRef21(function PopoverTrigger({ onClick, ...rest }, ref) {
+  const { open, send, triggerId, contentId, triggerRef } = usePopoverCtx();
+  return /* @__PURE__ */ jsx23(
+    "button",
+    {
+      ref: (node) => {
+        triggerRef.current = node;
+        if (typeof ref === "function") ref(node);
+        else if (ref) ref.current = node;
+      },
+      type: "button",
+      id: triggerId,
+      "aria-expanded": open,
+      "aria-controls": open ? contentId : void 0,
+      ...mergeProps(
+        partAttrs19(popoverAnatomy.scope, popoverAnatomy.trigger, { state: open ? "open" : "closed" }),
+        {
+          onClick: (e) => {
+            onClick?.(e);
+            if (!e.defaultPrevented) send({ type: "TOGGLE" });
+          }
+        },
+        rest
+      )
+    }
+  );
+});
+var Positioner3 = forwardRef21(function PopoverPositioner({ portalled = true, placement = "bottom-start", children, className, ...rest }, ref) {
+  const { open, triggerRef, positionerRef } = usePopoverCtx();
+  return /* @__PURE__ */ jsx23(
+    FloatingPositioner,
+    {
+      ref,
+      open,
+      scope: popoverAnatomy.scope,
+      part: popoverAnatomy.positioner,
+      triggerRef,
+      positionerRef,
+      portalled,
+      placement,
+      className,
+      ...rest,
+      children
+    }
+  );
+});
+var Content6 = forwardRef21(function PopoverContent({ onKeyDown, ...rest }, ref) {
+  const { open, send, triggerId, contentId } = usePopoverCtx();
+  if (!open) return null;
+  return /* @__PURE__ */ jsx23(
+    "div",
+    {
+      ref,
+      id: contentId,
+      role: "dialog",
+      "aria-modal": false,
+      "aria-labelledby": triggerId,
+      ...mergeProps(
+        partAttrs19(popoverAnatomy.scope, popoverAnatomy.content, { state: "open" }),
+        {
+          onKeyDown: (e) => {
+            onKeyDown?.(e);
+            if (e.key === "Escape") send({ type: "ESCAPE" });
+          }
+        },
+        rest
+      )
+    }
+  );
+});
+var Arrow = forwardRef21(function PopoverArrow(props, ref) {
+  const { open } = usePopoverCtx();
+  if (!open) return null;
+  return /* @__PURE__ */ jsx23("div", { ref, ...mergeProps(partAttrs19(popoverAnatomy.scope, popoverAnatomy.arrow), props) });
+});
+var CloseTrigger2 = forwardRef21(
+  function PopoverCloseTrigger({ onClick, ...rest }, ref) {
+    const { send } = usePopoverCtx();
+    return /* @__PURE__ */ jsx23(
+      "button",
+      {
+        ref,
+        type: "button",
+        "aria-label": "Close",
+        ...mergeProps(
+          partAttrs19(popoverAnatomy.scope, popoverAnatomy.closeTrigger),
+          {
+            onClick: (e) => {
+              onClick?.(e);
+              send({ type: "CLOSE" });
+            }
+          },
+          rest
+        )
+      }
+    );
+  }
+);
+var Popover = { Root: Root16, Trigger: Trigger4, Positioner: Positioner3, Content: Content6, Arrow, CloseTrigger: CloseTrigger2 };
+
+// src/menu/index.tsx
+import { menuAnatomy, partAttrs as partAttrs20 } from "@aeon-ui/core";
+import { popoverMachine as popoverMachine3 } from "@aeon-ui/primitives";
+import {
+  createContext as createContext16,
+  forwardRef as forwardRef22,
+  useCallback as useCallback6,
+  useContext as useContext16,
+  useEffect as useEffect16,
+  useId as useId5,
+  useMemo as useMemo17,
+  useRef as useRef8
+} from "react";
+import { jsx as jsx24 } from "react/jsx-runtime";
+var MenuCtx = createContext16(null);
+function useMenuCtx() {
+  const ctx = useContext16(MenuCtx);
+  if (!ctx) throw new Error("Menu parts must be used within Menu.Root");
+  return ctx;
+}
+var Root17 = forwardRef22(function MenuRoot({ open, defaultOpen = false, onOpenChange, children, className, ...rest }, ref) {
+  const [snapshot, send] = useAeonMachine(popoverMachine3, { input: { open: defaultOpen } });
+  const resolvedOpen = open ?? snapshot.context.open;
+  const rootRef = useRef8(null);
+  const triggerRef = useRef8(null);
+  const positionerRef = useRef8(null);
+  const triggerId = useId5();
+  const menuId = useId5();
+  useEffect16(() => {
+    onOpenChange?.(resolvedOpen);
+  }, [resolvedOpen, onOpenChange]);
+  useEffect16(() => {
+    if (open !== void 0) send({ type: "SET_OPEN", open });
+  }, [open, send]);
+  const close = useCallback6(() => send({ type: "CLOSE" }), [send]);
+  useOutsideClick([rootRef, positionerRef], resolvedOpen, close);
+  const value = useMemo17(
+    () => ({ open: resolvedOpen, send, triggerId, menuId, triggerRef, positionerRef }),
+    [resolvedOpen, send, triggerId, menuId]
+  );
+  return /* @__PURE__ */ jsx24(MenuCtx.Provider, { value, children: /* @__PURE__ */ jsx24(
+    "div",
+    {
+      ref: (node) => {
+        rootRef.current = node;
+        if (typeof ref === "function") ref(node);
+        else if (ref) ref.current = node;
+      },
+      className,
+      ...mergeProps(
+        partAttrs20(menuAnatomy.scope, menuAnatomy.root, { state: resolvedOpen ? "open" : "closed" }),
+        rest
+      ),
+      children
+    }
+  ) });
+});
+var Trigger5 = forwardRef22(function MenuTrigger({ onClick, ...rest }, ref) {
+  const { open, send, triggerId, menuId, triggerRef } = useMenuCtx();
+  return /* @__PURE__ */ jsx24(
+    "button",
+    {
+      ref: (node) => {
+        triggerRef.current = node;
+        if (typeof ref === "function") ref(node);
+        else if (ref) ref.current = node;
+      },
+      type: "button",
+      id: triggerId,
+      "aria-haspopup": "menu",
+      "aria-expanded": open,
+      "aria-controls": open ? menuId : void 0,
+      ...mergeProps(
+        partAttrs20(menuAnatomy.scope, menuAnatomy.trigger, { state: open ? "open" : "closed" }),
+        {
+          onClick: (e) => {
+            onClick?.(e);
+            if (!e.defaultPrevented) send({ type: "TOGGLE" });
+          }
+        },
+        rest
+      )
+    }
+  );
+});
+var Positioner4 = forwardRef22(function MenuPositioner({ portalled = true, placement = "bottom-start", children, className, ...rest }, ref) {
+  const { open, triggerRef, positionerRef } = useMenuCtx();
+  return /* @__PURE__ */ jsx24(
+    FloatingPositioner,
+    {
+      ref,
+      open,
+      scope: menuAnatomy.scope,
+      part: menuAnatomy.positioner,
+      triggerRef,
+      positionerRef,
+      portalled,
+      placement,
+      className,
+      ...rest,
+      children
+    }
+  );
+});
+var Content7 = forwardRef22(function MenuContent({ onKeyDown, ...rest }, ref) {
+  const { open, send, menuId } = useMenuCtx();
+  if (!open) return null;
+  return /* @__PURE__ */ jsx24(
+    "div",
+    {
+      ref,
+      id: menuId,
+      role: "menu",
+      ...mergeProps(
+        partAttrs20(menuAnatomy.scope, menuAnatomy.content, { state: "open" }),
+        {
+          onKeyDown: (e) => {
+            onKeyDown?.(e);
+            if (e.key === "Escape") send({ type: "ESCAPE" });
+          }
+        },
+        rest
+      )
+    }
+  );
+});
+var Item5 = forwardRef22(function MenuItem({ closeOnSelect = true, onClick, ...rest }, ref) {
+  const { send } = useMenuCtx();
+  return /* @__PURE__ */ jsx24(
+    "button",
+    {
+      ref,
+      type: "button",
+      role: "menuitem",
+      ...mergeProps(
+        partAttrs20(menuAnatomy.scope, menuAnatomy.item),
+        {
+          onClick: (e) => {
+            onClick?.(e);
+            if (closeOnSelect && !e.defaultPrevented) send({ type: "CLOSE" });
+          }
+        },
+        rest
+      )
+    }
+  );
+});
+var Separator2 = forwardRef22(function MenuSeparator(props, ref) {
+  return /* @__PURE__ */ jsx24("div", { ref, role: "separator", ...mergeProps(partAttrs20(menuAnatomy.scope, menuAnatomy.separator), props) });
+});
+var Menu = { Root: Root17, Trigger: Trigger5, Positioner: Positioner4, Content: Content7, Item: Item5, Separator: Separator2 };
+
+// src/tooltip/index.tsx
+import { tooltipAnatomy, partAttrs as partAttrs21 } from "@aeon-ui/core";
+import {
+  createContext as createContext17,
+  forwardRef as forwardRef23,
+  useContext as useContext17,
+  useEffect as useEffect18,
+  useId as useId6,
+  useMemo as useMemo18,
+  useRef as useRef9,
+  useState as useState7
+} from "react";
+
+// src/hooks/use-prefers-hover.ts
+import { useEffect as useEffect17, useState as useState6 } from "react";
+function usePrefersHover() {
+  const [prefersHover, setPrefersHover] = useState6(true);
+  useEffect17(() => {
+    const mq = window.matchMedia("(hover: hover) and (pointer: fine)");
+    const update = () => setPrefersHover(mq.matches);
+    update();
+    mq.addEventListener("change", update);
+    return () => mq.removeEventListener("change", update);
+  }, []);
+  return prefersHover;
+}
+
+// src/tooltip/index.tsx
+import { jsx as jsx25 } from "react/jsx-runtime";
+var TooltipCtx = createContext17(null);
+function useTooltipCtx() {
+  const ctx = useContext17(TooltipCtx);
+  if (!ctx) throw new Error("Tooltip parts must be used within Tooltip.Root");
+  return ctx;
+}
+var Root18 = forwardRef23(function TooltipRoot({
+  open,
+  defaultOpen = false,
+  onOpenChange,
+  openDelay = 400,
+  closeDelay = 100,
+  touchDurationMs = 5e3,
+  touchOutsideGraceMs = 400,
+  showOnFocus = true,
+  children,
+  className,
+  ...rest
+}, ref) {
+  const [uncontrolled, setUncontrolled] = useState7(defaultOpen);
+  const resolvedOpen = open ?? uncontrolled;
+  const showTimer = useRef9(void 0);
+  const hideTimer = useRef9(void 0);
+  const triggerRef = useRef9(null);
+  const positionerRef = useRef9(null);
+  const triggerId = useId6();
+  const contentId = useId6();
+  const prefersHover = usePrefersHover();
+  const [outsideClickEnabled, setOutsideClickEnabled] = useState7(false);
+  useEffect18(() => {
+    if (!resolvedOpen || prefersHover) {
+      setOutsideClickEnabled(false);
+      return;
+    }
+    setOutsideClickEnabled(false);
+    const id = window.setTimeout(() => setOutsideClickEnabled(true), touchOutsideGraceMs);
+    return () => window.clearTimeout(id);
+  }, [resolvedOpen, prefersHover, touchOutsideGraceMs]);
+  const setOpen = (next) => {
+    if (open === void 0) setUncontrolled(next);
+    onOpenChange?.(next);
+  };
+  useEffect18(() => {
+    onOpenChange?.(resolvedOpen);
+  }, [resolvedOpen, onOpenChange]);
+  const hideNow = () => {
+    if (showTimer.current !== void 0) clearTimeout(showTimer.current);
+    if (hideTimer.current !== void 0) clearTimeout(hideTimer.current);
+    setOpen(false);
+  };
+  const showImmediately = () => {
+    if (showTimer.current !== void 0) clearTimeout(showTimer.current);
+    if (hideTimer.current !== void 0) clearTimeout(hideTimer.current);
+    setOpen(true);
+    if (!prefersHover) {
+      if (touchDurationMs > 0) {
+        hideTimer.current = setTimeout(() => hideNow(), touchDurationMs);
+      }
+    }
+  };
+  const scheduleShow = () => {
+    if (hideTimer.current !== void 0) clearTimeout(hideTimer.current);
+    showTimer.current = setTimeout(() => setOpen(true), openDelay);
+  };
+  const scheduleHide = () => {
+    if (showTimer.current !== void 0) clearTimeout(showTimer.current);
+    if (closeDelay <= 0) {
+      setOpen(false);
+      return;
+    }
+    hideTimer.current = setTimeout(() => setOpen(false), closeDelay);
+  };
+  const toggleTouch = () => {
+    if (resolvedOpen) hideNow();
+    else showImmediately();
+  };
+  useOutsideClick([triggerRef, positionerRef], resolvedOpen && !prefersHover && outsideClickEnabled, hideNow);
+  const value = useMemo18(
+    () => ({
+      open: resolvedOpen,
+      setOpen,
+      triggerId,
+      contentId,
+      triggerRef,
+      positionerRef,
+      scheduleShow,
+      scheduleHide,
+      showImmediately,
+      hideNow,
+      toggleTouch,
+      showOnFocus,
+      prefersHover
+    }),
+    [resolvedOpen, triggerId, contentId, openDelay, closeDelay, touchDurationMs, touchOutsideGraceMs, showOnFocus, prefersHover]
+  );
+  return /* @__PURE__ */ jsx25(TooltipCtx.Provider, { value, children: /* @__PURE__ */ jsx25(
+    "div",
+    {
+      ref,
+      className,
+      ...mergeProps(
+        partAttrs21(tooltipAnatomy.scope, tooltipAnatomy.root, {
+          state: resolvedOpen ? "open" : "closed"
+        }),
+        rest
+      ),
+      children
+    }
+  ) });
+});
+var Trigger6 = forwardRef23(function TooltipTrigger({ onClick, onMouseEnter, onMouseLeave, onFocus, onBlur, onPointerDown, ...rest }, ref) {
+  const {
+    open,
+    triggerId,
+    contentId,
+    triggerRef,
+    scheduleShow,
+    scheduleHide,
+    hideNow,
+    toggleTouch,
+    showOnFocus,
+    prefersHover
+  } = useTooltipCtx();
+  return /* @__PURE__ */ jsx25(
+    "span",
+    {
+      ref: (node) => {
+        triggerRef.current = node;
+        if (typeof ref === "function") ref(node);
+        else if (ref) ref.current = node;
+      },
+      id: triggerId,
+      tabIndex: 0,
+      "aria-describedby": open ? contentId : void 0,
+      ...mergeProps(
+        partAttrs21(tooltipAnatomy.scope, tooltipAnatomy.trigger, { state: open ? "open" : "closed" }),
+        {
+          onMouseEnter: (e) => {
+            onMouseEnter?.(e);
+            if (prefersHover) scheduleShow();
+          },
+          onMouseLeave: (e) => {
+            onMouseLeave?.(e);
+            if (prefersHover) scheduleHide();
+          },
+          onFocus: (e) => {
+            onFocus?.(e);
+            if (showOnFocus && prefersHover) scheduleShow();
+          },
+          onBlur: (e) => {
+            onBlur?.(e);
+            if (showOnFocus && prefersHover) scheduleHide();
+          },
+          onClick: (e) => {
+            onClick?.(e);
+            if (!e.defaultPrevented && !prefersHover) toggleTouch();
+          },
+          onPointerDown: (e) => {
+            onPointerDown?.(e);
+            if (showOnFocus && prefersHover && e.pointerType === "mouse") hideNow();
+          }
+        },
+        rest
+      )
+    }
+  );
+});
+var Positioner5 = forwardRef23(function TooltipPositioner({ portalled = true, placement = "top-start", children, className, ...rest }, ref) {
+  const { open, triggerRef, positionerRef } = useTooltipCtx();
+  return /* @__PURE__ */ jsx25(
+    FloatingPositioner,
+    {
+      ref,
+      open,
+      scope: tooltipAnatomy.scope,
+      part: tooltipAnatomy.positioner,
+      triggerRef,
+      positionerRef,
+      portalled,
+      placement,
+      className,
+      ...rest,
+      children
+    }
+  );
+});
+var Content8 = forwardRef23(function TooltipContent(props, ref) {
+  const { open, contentId } = useTooltipCtx();
+  if (!open) return null;
+  return /* @__PURE__ */ jsx25(
+    "div",
+    {
+      ref,
+      id: contentId,
+      role: "tooltip",
+      ...mergeProps(partAttrs21(tooltipAnatomy.scope, tooltipAnatomy.content, { state: "open" }), props)
+    }
+  );
+});
+var Arrow2 = forwardRef23(function TooltipArrow(props, ref) {
+  const { open } = useTooltipCtx();
+  if (!open) return null;
+  return /* @__PURE__ */ jsx25("div", { ref, ...mergeProps(partAttrs21(tooltipAnatomy.scope, tooltipAnatomy.arrow), props) });
+});
+var Tooltip = { Root: Root18, Trigger: Trigger6, Positioner: Positioner5, Content: Content8, Arrow: Arrow2 };
+
+// src/toast/primitives.tsx
+import { toastAnatomy, partAttrs as partAttrs22 } from "@aeon-ui/core";
+import { toastMachine } from "@aeon-ui/primitives";
+import {
+  createContext as createContext18,
+  forwardRef as forwardRef24,
+  useContext as useContext18,
+  useEffect as useEffect19,
+  useId as useId7,
+  useMemo as useMemo19,
+  useRef as useRef10
+} from "react";
+import { jsx as jsx26 } from "react/jsx-runtime";
+var ToastCtx = createContext18(null);
+function useToastCtx() {
+  const ctx = useContext18(ToastCtx);
+  if (!ctx) throw new Error("Toast parts must be used within Toast.Root");
+  return ctx;
+}
+var Root19 = forwardRef24(function ToastRoot({ durationMs = 5e3, defaultVisible = false, onVisibleChange, children, className, ...rest }, ref) {
+  const [snapshot, send] = useAeonMachine(toastMachine, { input: { durationMs } });
+  const visible = snapshot.matches("visible");
+  const titleId = useId7();
+  const hasBeenVisible = useRef10(false);
+  useEffect19(() => {
+    if (defaultVisible) send({ type: "SHOW" });
+  }, [defaultVisible, send]);
+  useEffect19(() => {
+    if (visible) {
+      hasBeenVisible.current = true;
+      onVisibleChange?.(true);
+      return;
+    }
+    if (hasBeenVisible.current) onVisibleChange?.(false);
+  }, [visible, onVisibleChange]);
+  const value = useMemo19(() => ({ visible, send, titleId }), [visible, send, titleId]);
+  return /* @__PURE__ */ jsx26(ToastCtx.Provider, { value, children: /* @__PURE__ */ jsx26(
+    "div",
+    {
+      ref,
+      role: "status",
+      "aria-live": "polite",
+      "aria-atomic": "true",
+      ...mergeProps(
+        partAttrs22(toastAnatomy.scope, toastAnatomy.root, { state: visible ? "visible" : "hidden" }),
+        rest
+      ),
+      className,
+      hidden: !visible,
+      children: visible ? children : null
+    }
+  ) });
+});
+var Title2 = forwardRef24(function ToastTitle(props, ref) {
+  const { titleId } = useToastCtx();
+  return /* @__PURE__ */ jsx26("p", { ref, id: titleId, ...mergeProps(partAttrs22(toastAnatomy.scope, toastAnatomy.title), props) });
+});
+var Description2 = forwardRef24(
+  function ToastDescription(props, ref) {
+    return /* @__PURE__ */ jsx26("p", { ref, ...mergeProps(partAttrs22(toastAnatomy.scope, toastAnatomy.description), props) });
+  }
+);
+var CloseTrigger3 = forwardRef24(
+  function ToastCloseTrigger({ onClick, children, ...rest }, ref) {
+    const { send } = useToastCtx();
+    return /* @__PURE__ */ jsx26(
+      "button",
+      {
+        ref,
+        type: "button",
+        "aria-label": typeof children === "string" ? void 0 : "Dismiss",
+        ...mergeProps(
+          partAttrs22(toastAnatomy.scope, toastAnatomy.closeTrigger),
+          {
+            onClick: (e) => {
+              onClick?.(e);
+              send({ type: "DISMISS" });
+            }
+          },
+          rest
+        ),
+        children: children ?? "Dismiss"
+      }
+    );
+  }
+);
+function Show({ durationMs }) {
+  const { send } = useToastCtx();
+  useEffect19(() => {
+    send({ type: "SHOW" });
+    if (durationMs !== void 0) {
+      return () => send({ type: "DISMISS" });
+    }
+  }, [send, durationMs]);
+  return null;
+}
+
+// src/toast/provider.tsx
+import { toastAnatomy as toastAnatomy2, partAttrs as partAttrs23 } from "@aeon-ui/core";
+import {
+  useCallback as useCallback7,
+  useEffect as useEffect20,
+  useMemo as useMemo20,
+  useState as useState8
+} from "react";
+import { createPortal as createPortal2 } from "react-dom";
+
+// src/toast/context.tsx
+import { createContext as createContext19, useContext as useContext19 } from "react";
+var ToastStoreCtx = createContext19(null);
+function useToastStore() {
+  const ctx = useContext19(ToastStoreCtx);
+  if (!ctx) {
+    throw new Error("useToast must be used within Toast.Provider");
+  }
+  return ctx;
+}
+
+// src/toast/toast-item.tsx
+import { forwardRef as forwardRef25 } from "react";
+import { jsx as jsx27, jsxs as jsxs5 } from "react/jsx-runtime";
+var ToastItem = forwardRef25(function ToastItem2({ item, onExited, className, ...rest }, ref) {
+  const { id, title, description, durationMs } = item;
+  return /* @__PURE__ */ jsxs5(
+    Root19,
+    {
+      ref,
+      className,
+      defaultVisible: true,
+      durationMs: durationMs ?? 5e3,
+      onVisibleChange: (visible) => {
+        if (!visible) onExited(id);
+      },
+      ...rest,
+      children: [
+        title ? /* @__PURE__ */ jsx27(Title2, { children: title }) : null,
+        description ? /* @__PURE__ */ jsx27(Description2, { children: description }) : null,
+        /* @__PURE__ */ jsx27(CloseTrigger3, {})
+      ]
+    }
+  );
+});
+
+// src/toast/provider.tsx
+import { jsx as jsx28 } from "react/jsx-runtime";
+var PLACEMENT_ATTR = {
+  "top-start": "top-start",
+  "top-end": "top-end",
+  "bottom-start": "bottom-start",
+  "bottom-end": "bottom-end"
+};
+function nextToastId() {
+  return `toast-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+}
+function ToastProvider({ children, limit = 5 }) {
+  const [items, setItems] = useState8([]);
+  const dismiss = useCallback7((id) => {
+    setItems((prev) => prev.filter((t) => t.id !== id));
+  }, []);
+  const dismissAll = useCallback7(() => {
+    setItems([]);
+  }, []);
+  const publish = useCallback7(
+    (options) => {
+      const id = options.id ?? nextToastId();
+      const record = { ...options, id };
+      setItems((prev) => {
+        const without = prev.filter((t) => t.id !== id);
+        const next = [...without, record];
+        return next.length > limit ? next.slice(-limit) : next;
+      });
+      return id;
+    },
+    [limit]
+  );
+  const value = useMemo20(
+    () => ({ items, publish, dismiss, dismissAll }),
+    [items, publish, dismiss, dismissAll]
+  );
+  return /* @__PURE__ */ jsx28(ToastStoreCtx.Provider, { value, children });
+}
+function ToastViewport({ placement = "bottom-end", className, ...rest }) {
+  const { items, dismiss } = useToastStore();
+  const [mounted, setMounted] = useState8(false);
+  useEffect20(() => {
+    setMounted(true);
+  }, []);
+  if (!mounted) return null;
+  return createPortal2(
+    /* @__PURE__ */ jsx28(
+      "div",
+      {
+        ...mergeProps(
+          partAttrs23(toastAnatomy2.scope, toastAnatomy2.viewport, {
+            state: items.length > 0 ? "active" : "idle"
+          }),
+          {
+            "data-placement": PLACEMENT_ATTR[placement]
+          },
+          rest
+        ),
+        className,
+        children: items.map((item) => /* @__PURE__ */ jsx28(ToastItem, { item, onExited: dismiss }, item.id))
+      }
+    ),
+    document.body
+  );
+}
+function useToast() {
+  const { publish, dismiss, dismissAll } = useToastStore();
+  return { publish, dismiss, dismissAll };
+}
+
+// src/toast/index.tsx
+var Toast = {
+  Provider: ToastProvider,
+  Viewport: ToastViewport,
+  Root: Root19,
+  Title: Title2,
+  Description: Description2,
+  CloseTrigger: CloseTrigger3,
+  Show
+};
+
+// src/avatar/index.tsx
+import { avatarAnatomy, partAttrs as partAttrs24 } from "@aeon-ui/core";
+import {
+  createContext as createContext20,
+  forwardRef as forwardRef26,
+  useCallback as useCallback8,
+  useContext as useContext20,
+  useEffect as useEffect21,
+  useMemo as useMemo21,
+  useState as useState9
+} from "react";
+import { jsx as jsx29 } from "react/jsx-runtime";
+var AvatarCtx = createContext20(null);
+function useAvatarCtx() {
+  const ctx = useContext20(AvatarCtx);
+  if (!ctx) throw new Error("Avatar parts must be used within Avatar.Root");
+  return ctx;
+}
+var Root20 = forwardRef26(function AvatarRoot({ children, className, ...rest }, ref) {
+  const [status, setStatus] = useState9("idle");
+  const value = useMemo21(() => ({ status, setStatus }), [status]);
+  return /* @__PURE__ */ jsx29(AvatarCtx.Provider, { value, children: /* @__PURE__ */ jsx29(
+    "span",
+    {
+      ref,
+      className,
+      ...mergeProps(
+        partAttrs24(avatarAnatomy.scope, avatarAnatomy.root, { state: status }),
+        rest
+      ),
+      children
+    }
+  ) });
+});
+var Image = forwardRef26(function AvatarImage({ src, alt, onLoad, onError, className, ...rest }, ref) {
+  const { status, setStatus } = useAvatarCtx();
+  useEffect21(() => {
+    if (!src) setStatus("idle");
+    else setStatus("loading");
+  }, [src, setStatus]);
+  const handleLoad = useCallback8(
+    (e) => {
+      onLoad?.(e);
+      setStatus("loaded");
+    },
+    [onLoad, setStatus]
+  );
+  const handleError = useCallback8(
+    (e) => {
+      onError?.(e);
+      setStatus("error");
+    },
+    [onError, setStatus]
+  );
+  return /* @__PURE__ */ jsx29(
+    "img",
+    {
+      ref,
+      src,
+      alt,
+      hidden: status !== "loaded",
+      ...partAttrs24(avatarAnatomy.scope, avatarAnatomy.image, { state: status }),
+      className,
+      ...mergeProps(rest, { onLoad: handleLoad, onError: handleError })
+    }
+  );
+});
+var Fallback = forwardRef26(function AvatarFallback({ className, ...rest }, ref) {
+  const { status } = useAvatarCtx();
+  const show = status !== "loaded";
+  return /* @__PURE__ */ jsx29(
+    "span",
+    {
+      ref,
+      hidden: !show,
+      ...partAttrs24(avatarAnatomy.scope, avatarAnatomy.fallback, { state: status }),
+      className,
+      ...rest
+    }
+  );
+});
+var Avatar = {
+  Root: Root20,
+  Image,
+  Fallback
+};
+
+// src/hooks/use-layout-mode.ts
+import { getCompactMq, layoutCompositionForMode, matchLayoutMode } from "@aeon-ui/core";
+import { useEffect as useEffect22, useMemo as useMemo22, useState as useState10 } from "react";
+function useLayoutMode(spec) {
+  const mq = useMemo22(() => getCompactMq(spec), [spec.compactMq]);
+  const [mode, setMode] = useState10(() => matchLayoutMode(spec, mq));
+  useEffect22(() => {
+    const sync = () => setMode(matchLayoutMode(spec, mq));
+    sync();
+    mq.addEventListener("change", sync);
+    return () => mq.removeEventListener("change", sync);
+  }, [spec, mq]);
+  const composition = useMemo22(() => layoutCompositionForMode(spec, mode), [spec, mode]);
+  return { mode, composition };
+}
+export {
+  Accordion,
+  Async,
+  AsyncActions,
+  AsyncProvider,
+  AsyncReadout,
+  AsyncRegion,
+  AsyncRoot,
+  AsyncTrack,
+  Avatar,
+  Button,
+  Checkbox,
+  Combobox,
+  Dialog,
+  Field,
+  Menu,
+  PinInput,
+  Popover,
+  Progress,
+  RadioGroup,
+  Scroll,
+  Select,
+  Separator,
+  Slider,
+  Switch,
+  Tabs,
+  Toast,
+  ToastItem,
+  Tooltip,
+  createAsyncMachine3 as createAsyncMachine,
+  fieldMachine,
+  useAeonMachine,
+  useAsyncContext,
+  useFieldContext,
+  useLayoutMode,
+  useScrollContext,
+  useScrollState,
+  useToast,
+  useToastStore
+};