aeon-ui-engine 1.0.2 → 1.1.0

package/packages/react/dist/index.js

@@ -0,0 +1,4739 @@
+// 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";
+  const isLocked = resolvedStatus === "success";
+  return /* @__PURE__ */ jsx(
+    "button",
+    {
+      ref,
+      type: "button",
+      disabled: disabled || isBusy || isLocked || 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" || isLocked)
+        }),
+        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 { Fragment, 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: children ?? /* @__PURE__ */ jsx2(Fragment, { children: /* @__PURE__ */ jsx2(Control, { children: /* @__PURE__ */ jsx2(Thumb, {}) }) })
+    }
+  ) });
+});
+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,
+  useCallback,
+  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;
+  const controlled = value !== void 0;
+  const selectValue = useCallback(
+    (next) => {
+      if (controlled) onValueChange?.(next);
+      else send({ type: "SELECT", value: next });
+    },
+    [controlled, onValueChange, send]
+  );
+  useEffect8(() => {
+    if (controlled) return;
+    onValueChange?.(snapshot.context.value);
+  }, [snapshot.context.value, controlled, onValueChange]);
+  useEffect8(() => {
+    if (value !== void 0) send({ type: "SET_VALUE", value });
+  }, [value, send]);
+  const ctx = useMemo6(() => ({ value: resolvedValue, send, selectValue }), [resolvedValue, send, selectValue]);
+  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 { selectValue } = useRadioGroupCtx();
+  const { value: itemValue, selected } = useRadioGroupItemCtx();
+  const select = () => selectValue(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 { selectValue } = useRadioGroupCtx();
+  const { value: itemValue } = useRadioGroupItemCtx();
+  return /* @__PURE__ */ jsx8(
+    "span",
+    {
+      ref,
+      ...mergeProps(
+        partOnlyAttrs2(radioGroupAnatomy.itemLabel),
+        {
+          onClick: (e) => {
+            onClick?.(e);
+            selectValue(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 as useCallback2,
+  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 = useCallback2(
+    (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, setValueFromClientX } = 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();
+            e.currentTarget.setPointerCapture(e.pointerId);
+            send({ type: "POINTER_DOWN" });
+            setValueFromClientX(e.clientX);
+          },
+          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 useCallback3,
+  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 = useCallback3(
+    (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 = useCallback3(
+    (index, char) => {
+      const next = [...chars.slice(0, length)];
+      while (next.length < length) next.push("");
+      next[index] = char;
+      setChars(next);
+    },
+    [chars, length, setChars]
+  );
+  const focusInput = useCallback3((index) => {
+    const el = inputRefs.current[index];
+    el?.focus();
+    el?.select();
+  }, []);
+  const registerInput = useCallback3((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/map-content-state.ts
+function asyncStatusToContentState(status) {
+  switch (status) {
+    case "loading":
+      return "pending";
+    case "empty":
+      return "empty";
+    case "failure":
+      return "error";
+    case "success":
+      return "success";
+    case "idle":
+    default:
+      return "idle";
+  }
+}
+
+// src/async/index.tsx
+import { createAsyncMachine as createAsyncMachine2 } from "@aeon-ui/primitives";
+var Async = {
+  Root: AsyncRoot,
+  Provider: AsyncProvider,
+  Track: AsyncTrack,
+  Readout: AsyncReadout,
+  Actions: AsyncActions
+};
+
+// src/field/index.tsx
+import { fieldAnatomy, fieldFace, fieldRegions, partAttrs as partAttrs13, partOnlyAttrs as partOnlyAttrs9 } from "@aeon-ui/core";
+import { fieldMachine } from "@aeon-ui/primitives";
+import {
+  createContext as createContext11,
+  forwardRef as forwardRef16,
+  useContext as useContext11,
+  useMemo as useMemo11
+} from "react";
+import { jsx as jsx17 } 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 face = fieldFace(snapshot.value);
+  const regions = fieldRegions(snapshot.value);
+  const invalid = regions.validation === "invalid";
+  const pending = regions.submission === "pending";
+  const value = useMemo11(
+    () => ({
+      face,
+      stateAttr: face,
+      interaction: regions.interaction,
+      validation: regions.validation,
+      submission: regions.submission,
+      send,
+      invalid,
+      pending
+    }),
+    [face, regions.interaction, regions.validation, regions.submission, send, invalid, pending]
+  );
+  return /* @__PURE__ */ jsx17(FieldCtx.Provider, { value, children: /* @__PURE__ */ jsx17(
+    "div",
+    {
+      ref,
+      id,
+      className,
+      "data-aeon-interaction": regions.interaction,
+      "data-aeon-validation": regions.validation,
+      "data-aeon-submission": regions.submission,
+      ...partAttrs13(fieldAnatomy.scope, fieldAnatomy.root, { state: face }),
+      children
+    }
+  ) });
+});
+var Label5 = forwardRef16(function FieldLabel(props, ref) {
+  return /* @__PURE__ */ jsx17("label", { ref, ...partOnlyAttrs9(fieldAnatomy.label), ...props });
+});
+var Control3 = forwardRef16(function FieldControl({ validate, onChange, onBlur, ...rest }, ref) {
+  const { send, invalid } = useFieldContext();
+  return /* @__PURE__ */ jsx17(
+    "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__ */ jsx17(
+    "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({ children, ...props }, ref) {
+    const { invalid } = useFieldContext();
+    if (!invalid) return null;
+    return /* @__PURE__ */ jsx17(
+      "p",
+      {
+        ref,
+        role: "alert",
+        ...partOnlyAttrs9(fieldAnatomy.message, { state: "invalid" }),
+        ...props,
+        children: children ?? "Check this field."
+      }
+    );
+  }
+);
+var Hint = forwardRef16(
+  function FieldHint(props, ref) {
+    return /* @__PURE__ */ jsx17("p", { ref, ...partOnlyAttrs9(fieldAnatomy.hint), ...props });
+  }
+);
+var Field = { Root: Root12, Label: Label5, Control: Control3, Input: Control3, Textarea, Message, Hint };
+
+// src/scroll/index.tsx
+import { scrollAnatomy, partAttrs as partAttrs14, partOnlyAttrs as partOnlyAttrs10 } from "@aeon-ui/core";
+import {
+  createContext as createContext12,
+  forwardRef as forwardRef17,
+  useContext as useContext12,
+  useMemo as useMemo12,
+  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 jsx18 } 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 = useMemo12(() => ({ stateAttr }), [stateAttr]);
+  return /* @__PURE__ */ jsx18(ScrollCtx.Provider, { value, children: /* @__PURE__ */ jsx18(
+    "div",
+    {
+      ref,
+      className,
+      ...partAttrs14(scrollAnatomy.scope, scrollAnatomy.root),
+      ...rest,
+      children: /* @__PURE__ */ jsx18(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__ */ jsx18(
+    "div",
+    {
+      ref: (node) => {
+        if (ctxRef) ctxRef.current = node;
+        if (typeof forwardedRef === "function") forwardedRef(node);
+        else if (forwardedRef) forwardedRef.current = node;
+      },
+      className,
+      "data-aeon-scroll": "",
+      ...partAttrs14(scrollAnatomy.scope, scrollAnatomy.viewport, { state: stateAttr }),
+      ...rest,
+      children
+    }
+  );
+});
+var Content3 = forwardRef17(function ScrollContent(props, ref) {
+  return /* @__PURE__ */ jsx18("div", { ref, ...partOnlyAttrs10(scrollAnatomy.content), ...props });
+});
+var Scroll = {
+  Root: Root13,
+  Viewport,
+  Content: Content3
+};
+
+// src/select/index.tsx
+import { selectAnatomy, partAttrs as partAttrs16, partOnlyAttrs as partOnlyAttrs11 } from "@aeon-ui/core";
+import { popoverMachine } from "@aeon-ui/primitives";
+import {
+  createContext as createContext13,
+  forwardRef as forwardRef19,
+  useCallback as useCallback4,
+  useContext as useContext13,
+  useId as useId2,
+  useMemo as useMemo13,
+  useRef as useRef5,
+  useState as useState4
+} from "react";
+
+// src/floating/FloatingPositioner.tsx
+import { partAttrs as partAttrs15 } 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 jsx19 } 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__ */ jsx19(
+      "div",
+      {
+        ref: (el) => {
+          positionerRef.current = el;
+          if (typeof ref === "function") ref(el);
+          else if (ref) ref.current = el;
+        },
+        className,
+        ...mergeProps(partAttrs15(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 jsx20, jsxs as jsxs2 } 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 = useCallback4(() => {
+    send({ type: "CLOSE" });
+    setHighlightedValue(null);
+  }, [send]);
+  useOutsideClick([rootRef, positionerRef], open, () => send({ type: "POINTER_DOWN_OUTSIDE" }));
+  const getOptionValues = useCallback4(
+    () => optionValuesFromDom(listboxId, contentRef.current),
+    [listboxId, open]
+  );
+  const selectValue = useCallback4(
+    (next) => {
+      onValueChange?.(next);
+      close();
+    },
+    [onValueChange, close]
+  );
+  const highlightValue = useCallback4((next) => {
+    setHighlightedValue(next);
+  }, []);
+  const moveHighlight = useCallback4(
+    (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 = useCallback4(
+    (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 = useMemo13(
+    () => ({
+      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__ */ jsx20(SelectCtx.Provider, { value: ctx, children: /* @__PURE__ */ jsx20(
+    "div",
+    {
+      ref: (node) => {
+        rootRef.current = node;
+        if (typeof ref === "function") ref(node);
+        else if (ref) ref.current = node;
+      },
+      className,
+      ...partAttrs16(selectAnatomy.scope, selectAnatomy.root, {
+        state: open ? "open" : "closed"
+      }),
+      children
+    }
+  ) });
+});
+var ValueText2 = forwardRef19(function SelectValueText(props, ref) {
+  return /* @__PURE__ */ jsx20("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__ */ jsxs2(
+    "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,
+      ...partAttrs16(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__ */ jsx20("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__ */ jsx20(SelectPositionerCtx.Provider, { value: true, children: /* @__PURE__ */ jsx20(
+    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__ */ jsx20(
+    "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": "",
+      ...partAttrs16(selectAnatomy.scope, selectAnatomy.content, { state: "open" }),
+      ...mergeProps(rest, {
+        onKeyDown: (e) => {
+          onKeyDown?.(e);
+          onListboxKeyDown(e);
+        }
+      }),
+      children
+    }
+  );
+  if (inPositioner) return listbox;
+  return /* @__PURE__ */ jsx20(
+    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__ */ jsx20(
+    "button",
+    {
+      ref,
+      type: "button",
+      role: "option",
+      id: `${listboxId}-option-${value}`,
+      "aria-selected": selectedState,
+      disabled,
+      ...partAttrs16(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 partAttrs17, partOnlyAttrs as partOnlyAttrs12 } from "@aeon-ui/core";
+import {
+  createContext as createContext14,
+  forwardRef as forwardRef20,
+  useCallback as useCallback5,
+  useContext as useContext14,
+  useEffect as useEffect14,
+  useId as useId3,
+  useMemo as useMemo14,
+  useRef as useRef6,
+  useState as useState5
+} from "react";
+import { Fragment as Fragment2, jsx as jsx21, jsxs as jsxs3 } 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 = useCallback5(
+    (next) => {
+      if (disabled) return;
+      setOpenState(next);
+      if (!next) {
+        setQuery("");
+        setHighlightedValue(null);
+      }
+    },
+    [disabled]
+  );
+  const registerItem = useCallback5((item) => {
+    itemsRef.current = [...itemsRef.current.filter((i) => i.value !== item.value), item];
+    setItemsVersion((v) => v + 1);
+  }, []);
+  const unregisterItem = useCallback5((valueKey) => {
+    itemsRef.current = itemsRef.current.filter((i) => i.value !== valueKey);
+    setItemsVersion((v) => v + 1);
+  }, []);
+  const getItems = useCallback5(() => itemsRef.current, []);
+  const ctx = useMemo14(
+    () => ({
+      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__ */ jsx21(ComboboxCtx.Provider, { value: ctx, children: /* @__PURE__ */ jsx21(
+    "div",
+    {
+      ref,
+      className,
+      ...partAttrs17(comboboxAnatomy.scope, comboboxAnatomy.root, {
+        state: open ? "open" : "closed"
+      }),
+      children
+    }
+  ) });
+});
+function useVisibleItems() {
+  const { query, getItems, itemsVersion } = useComboboxCtx();
+  return useMemo14(() => {
+    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 = useMemo14(() => {
+    void itemsVersion;
+    return getItems().find((i) => i.value === selected)?.label ?? "";
+  }, [getItems, selected, itemsVersion]);
+  const displayValue = open ? query : selectedLabel;
+  const selectValue = useCallback5(
+    (next) => {
+      onValueChange?.(next);
+      setOpen(false);
+      setQuery("");
+      setHighlightedValue(null);
+    },
+    [onValueChange, setOpen, setQuery, setHighlightedValue]
+  );
+  const moveHighlight = useCallback5(
+    (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 = useCallback5(
+    (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__ */ jsxs3(Fragment2, { children: [
+    /* @__PURE__ */ jsx21(
+      "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,
+        ...partAttrs17(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__ */ jsx21(
+      "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__ */ jsx21(
+    "div",
+    {
+      ref,
+      id: listboxId,
+      role: "listbox",
+      className,
+      "data-aeon-scroll": "",
+      ...partAttrs17(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__ */ jsx21(
+    "button",
+    {
+      ref,
+      type: "button",
+      role: "option",
+      id: resolvedOptionId,
+      "aria-selected": selectedState,
+      "data-highlighted": highlighted ? "" : void 0,
+      ...partAttrs17(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__ */ jsx21(
+    "div",
+    {
+      ref,
+      className,
+      ...partAttrs17(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 partAttrs18 } from "@aeon-ui/core";
+import { popoverMachine as popoverMachine2 } from "@aeon-ui/primitives";
+import {
+  createContext as createContext15,
+  forwardRef as forwardRef21,
+  useCallback as useCallback6,
+  useContext as useContext15,
+  useEffect as useEffect15,
+  useId as useId4,
+  useMemo as useMemo15,
+  useRef as useRef7
+} from "react";
+import { jsx as jsx22 } 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 = useCallback6(() => send({ type: "CLOSE" }), [send]);
+  useOutsideClick([rootRef, positionerRef], resolvedOpen, close);
+  const value = useMemo15(
+    () => ({ open: resolvedOpen, send, triggerId, contentId, triggerRef, positionerRef }),
+    [resolvedOpen, send, triggerId, contentId]
+  );
+  return /* @__PURE__ */ jsx22(PopoverCtx.Provider, { value, children: /* @__PURE__ */ jsx22(
+    "div",
+    {
+      ref: (node) => {
+        rootRef.current = node;
+        if (typeof ref === "function") ref(node);
+        else if (ref) ref.current = node;
+      },
+      className,
+      ...mergeProps(
+        partAttrs18(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__ */ jsx22(
+    "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(
+        partAttrs18(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__ */ jsx22(
+    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__ */ jsx22(
+    "div",
+    {
+      ref,
+      id: contentId,
+      role: "dialog",
+      "aria-modal": false,
+      "aria-labelledby": triggerId,
+      ...mergeProps(
+        partAttrs18(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__ */ jsx22("div", { ref, ...mergeProps(partAttrs18(popoverAnatomy.scope, popoverAnatomy.arrow), props) });
+});
+var CloseTrigger2 = forwardRef21(
+  function PopoverCloseTrigger({ onClick, ...rest }, ref) {
+    const { send } = usePopoverCtx();
+    return /* @__PURE__ */ jsx22(
+      "button",
+      {
+        ref,
+        type: "button",
+        "aria-label": "Close",
+        ...mergeProps(
+          partAttrs18(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 partAttrs19 } from "@aeon-ui/core";
+import { popoverMachine as popoverMachine3 } from "@aeon-ui/primitives";
+import {
+  createContext as createContext16,
+  forwardRef as forwardRef22,
+  useCallback as useCallback7,
+  useContext as useContext16,
+  useEffect as useEffect16,
+  useId as useId5,
+  useMemo as useMemo16,
+  useRef as useRef8
+} from "react";
+import { jsx as jsx23 } 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 = useCallback7(() => send({ type: "CLOSE" }), [send]);
+  useOutsideClick([rootRef, positionerRef], resolvedOpen, close);
+  const value = useMemo16(
+    () => ({ open: resolvedOpen, send, triggerId, menuId, triggerRef, positionerRef }),
+    [resolvedOpen, send, triggerId, menuId]
+  );
+  return /* @__PURE__ */ jsx23(MenuCtx.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(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__ */ jsx23(
+    "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(
+        partAttrs19(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__ */ jsx23(
+    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__ */ jsx23(
+    "div",
+    {
+      ref,
+      id: menuId,
+      role: "menu",
+      ...mergeProps(
+        partAttrs19(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__ */ jsx23(
+    "button",
+    {
+      ref,
+      type: "button",
+      role: "menuitem",
+      ...mergeProps(
+        partAttrs19(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__ */ jsx23("div", { ref, role: "separator", ...mergeProps(partAttrs19(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 partAttrs20 } from "@aeon-ui/core";
+import {
+  createContext as createContext17,
+  forwardRef as forwardRef23,
+  useContext as useContext17,
+  useEffect as useEffect18,
+  useId as useId6,
+  useMemo as useMemo17,
+  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 jsx24 } 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 = useMemo17(
+    () => ({
+      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__ */ jsx24(TooltipCtx.Provider, { value, children: /* @__PURE__ */ jsx24(
+    "div",
+    {
+      ref,
+      className,
+      ...mergeProps(
+        partAttrs20(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__ */ jsx24(
+    "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(
+        partAttrs20(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__ */ jsx24(
+    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__ */ jsx24(
+    "div",
+    {
+      ref,
+      id: contentId,
+      role: "tooltip",
+      ...mergeProps(partAttrs20(tooltipAnatomy.scope, tooltipAnatomy.content, { state: "open" }), props)
+    }
+  );
+});
+var Arrow2 = forwardRef23(function TooltipArrow(props, ref) {
+  const { open } = useTooltipCtx();
+  if (!open) return null;
+  return /* @__PURE__ */ jsx24("div", { ref, ...mergeProps(partAttrs20(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 partAttrs21 } 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 useMemo18,
+  useRef as useRef10
+} from "react";
+import { jsx as jsx25 } 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 = useMemo18(() => ({ visible, send, titleId }), [visible, send, titleId]);
+  return /* @__PURE__ */ jsx25(ToastCtx.Provider, { value, children: /* @__PURE__ */ jsx25(
+    "div",
+    {
+      ref,
+      role: "status",
+      "aria-live": "polite",
+      "aria-atomic": "true",
+      ...mergeProps(
+        partAttrs21(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__ */ jsx25("p", { ref, id: titleId, ...mergeProps(partAttrs21(toastAnatomy.scope, toastAnatomy.title), props) });
+});
+var Description2 = forwardRef24(
+  function ToastDescription(props, ref) {
+    return /* @__PURE__ */ jsx25("p", { ref, ...mergeProps(partAttrs21(toastAnatomy.scope, toastAnatomy.description), props) });
+  }
+);
+var CloseTrigger3 = forwardRef24(
+  function ToastCloseTrigger({ onClick, children, ...rest }, ref) {
+    const { send } = useToastCtx();
+    return /* @__PURE__ */ jsx25(
+      "button",
+      {
+        ref,
+        type: "button",
+        "aria-label": "Dismiss",
+        ...mergeProps(
+          partAttrs21(toastAnatomy.scope, toastAnatomy.closeTrigger),
+          {
+            onClick: (e) => {
+              onClick?.(e);
+              send({ type: "DISMISS" });
+            }
+          },
+          rest
+        ),
+        children: children ?? "\xD7"
+      }
+    );
+  }
+);
+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 partAttrs22 } from "@aeon-ui/core";
+import {
+  useCallback as useCallback8,
+  useEffect as useEffect20,
+  useMemo as useMemo19,
+  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 jsx26, jsxs as jsxs4 } from "react/jsx-runtime";
+var ToastItem = forwardRef25(function ToastItem2({ item, onExited, className, ...rest }, ref) {
+  const { id, title, description, durationMs } = item;
+  return /* @__PURE__ */ jsxs4(
+    Root19,
+    {
+      ref,
+      className,
+      defaultVisible: true,
+      durationMs: durationMs ?? 5e3,
+      onVisibleChange: (visible) => {
+        if (!visible) onExited(id);
+      },
+      ...rest,
+      children: [
+        title ? /* @__PURE__ */ jsx26(Title2, { children: title }) : null,
+        description ? /* @__PURE__ */ jsx26(Description2, { children: description }) : null,
+        /* @__PURE__ */ jsx26(CloseTrigger3, {})
+      ]
+    }
+  );
+});
+
+// src/toast/provider.tsx
+import { jsx as jsx27 } 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 = useCallback8((id) => {
+    setItems((prev) => prev.filter((t) => t.id !== id));
+  }, []);
+  const dismissAll = useCallback8(() => {
+    setItems([]);
+  }, []);
+  const publish = useCallback8(
+    (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 = useMemo19(
+    () => ({ items, publish, dismiss, dismissAll }),
+    [items, publish, dismiss, dismissAll]
+  );
+  return /* @__PURE__ */ jsx27(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__ */ jsx27(
+      "div",
+      {
+        ...mergeProps(
+          partAttrs22(toastAnatomy2.scope, toastAnatomy2.viewport, {
+            state: items.length > 0 ? "active" : "idle"
+          }),
+          {
+            "data-placement": PLACEMENT_ATTR[placement]
+          },
+          rest
+        ),
+        className,
+        children: items.map((item) => /* @__PURE__ */ jsx27(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/theme-switcher/index.tsx
+import { partAttrs as partAttrs23, scopeAttrs as scopeAttrs2, themeSwitcherAnatomy } from "@aeon-ui/core";
+import {
+  applyAeonTheme,
+  initAeonTheme
+} from "@aeon-ui/core";
+import {
+  createContext as createContext20,
+  forwardRef as forwardRef26,
+  useContext as useContext20,
+  useLayoutEffect as useLayoutEffect2,
+  useState as useState9
+} from "react";
+import { jsx as jsx28 } from "react/jsx-runtime";
+var Root20 = forwardRef26(
+  function ThemeSwitcherRoot({ defaultTheme, defaultMode, onThemeChange, children, ...rest }, ref) {
+    const [themeId, setThemeId] = useState9(defaultTheme ?? "default");
+    const [mode, setMode] = useState9(defaultMode ?? "dark");
+    useLayoutEffect2(() => {
+      const { themeId: t, mode: m } = initAeonTheme();
+      setThemeId(t);
+      setMode(m);
+    }, []);
+    const handleThemeChange = (next) => {
+      setThemeId(next);
+      applyAeonTheme(next, mode);
+      onThemeChange?.(next, mode);
+    };
+    const handleModeChange = (next) => {
+      setMode(next);
+      applyAeonTheme(themeId, next);
+      onThemeChange?.(themeId, next);
+    };
+    return /* @__PURE__ */ jsx28(
+      "div",
+      {
+        ref,
+        ...mergeProps(
+          scopeAttrs2(themeSwitcherAnatomy.scope, themeSwitcherAnatomy.root),
+          rest
+        ),
+        children: /* @__PURE__ */ jsx28(
+          ThemeSwitcherContext.Provider,
+          {
+            value: { themeId, mode, handleThemeChange, handleModeChange },
+            children
+          }
+        )
+      }
+    );
+  }
+);
+var ThemeSwitcherContext = createContext20(null);
+function useThemeSwitcher() {
+  const ctx = useContext20(ThemeSwitcherContext);
+  if (!ctx) throw new Error("ThemeSwitcher parts must be used inside <ThemeSwitcher.Root>");
+  return ctx;
+}
+var Modes = forwardRef26(
+  function ThemeSwitcherModes(props, ref) {
+    return /* @__PURE__ */ jsx28(
+      "div",
+      {
+        ref,
+        role: "group",
+        "aria-label": "Color mode",
+        ...mergeProps(
+          partAttrs23(themeSwitcherAnatomy.scope, themeSwitcherAnatomy.modes),
+          props
+        )
+      }
+    );
+  }
+);
+var ModeBtn = forwardRef26(
+  function ThemeSwitcherModeBtn({ mode, active, ...rest }, ref) {
+    const { handleModeChange } = useThemeSwitcher();
+    return /* @__PURE__ */ jsx28(
+      "button",
+      {
+        ref,
+        type: "button",
+        "aria-pressed": active,
+        "data-active": active ? "true" : void 0,
+        ...mergeProps(
+          partAttrs23(themeSwitcherAnatomy.scope, themeSwitcherAnatomy.modeBtn),
+          rest
+        ),
+        onClick: (e) => {
+          handleModeChange(mode);
+          rest.onClick?.(e);
+        },
+        children: rest.children ?? (mode === "light" ? "Light" : "Dark")
+      }
+    );
+  }
+);
+var ThemeSelect = forwardRef26(
+  function ThemeSwitcherThemeSelect({ children, ...rest }, ref) {
+    return /* @__PURE__ */ jsx28(
+      "div",
+      {
+        ref,
+        ...mergeProps(
+          partAttrs23(themeSwitcherAnatomy.scope, themeSwitcherAnatomy.themeSelect),
+          rest
+        ),
+        children
+      }
+    );
+  }
+);
+var ThemeTrigger = forwardRef26(
+  function ThemeSwitcherThemeTrigger(props, ref) {
+    const { themeId } = useThemeSwitcher();
+    return /* @__PURE__ */ jsx28(
+      "button",
+      {
+        ref,
+        type: "button",
+        "aria-label": `Theme preset: ${themeId}`,
+        ...mergeProps(
+          partAttrs23(themeSwitcherAnatomy.scope, themeSwitcherAnatomy.themeTrigger),
+          props
+        ),
+        children: props.children ?? themeId
+      }
+    );
+  }
+);
+var ThemeSwitcher = {
+  Root: Root20,
+  Modes,
+  ModeBtn,
+  ThemeSelect,
+  ThemeTrigger
+};
+
+// src/avatar/index.tsx
+import { avatarAnatomy, partAttrs as partAttrs24 } from "@aeon-ui/core";
+import {
+  createContext as createContext21,
+  forwardRef as forwardRef27,
+  useCallback as useCallback9,
+  useContext as useContext21,
+  useEffect as useEffect21,
+  useMemo as useMemo20,
+  useState as useState10
+} from "react";
+import { jsx as jsx29 } from "react/jsx-runtime";
+var AvatarCtx = createContext21(null);
+function useAvatarCtx() {
+  const ctx = useContext21(AvatarCtx);
+  if (!ctx) throw new Error("Avatar parts must be used within Avatar.Root");
+  return ctx;
+}
+var Root21 = forwardRef27(function AvatarRoot({ children, className, ...rest }, ref) {
+  const [status, setStatus] = useState10("idle");
+  const value = useMemo20(() => ({ 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 = forwardRef27(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 = useCallback9(
+    (e) => {
+      onLoad?.(e);
+      setStatus("loaded");
+    },
+    [onLoad, setStatus]
+  );
+  const handleError = useCallback9(
+    (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 = forwardRef27(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 Badge = forwardRef27(function AvatarBadge({ presence = "idle", className, ...rest }, ref) {
+  useAvatarCtx();
+  return /* @__PURE__ */ jsx29(
+    "span",
+    {
+      ref,
+      "data-aeon-presence": presence,
+      ...partAttrs24(avatarAnatomy.scope, avatarAnatomy.badge, { state: presence }),
+      className,
+      ...rest
+    }
+  );
+});
+var Avatar = {
+  Root: Root21,
+  Image,
+  Fallback,
+  Badge
+};
+
+// src/identity/index.tsx
+import { identityAnatomy, partAttrs as partAttrs25, scopeAttrs as scopeAttrs3 } from "@aeon-ui/core";
+import { createContext as createContext22, forwardRef as forwardRef28, useContext as useContext22 } from "react";
+import { jsx as jsx30 } from "react/jsx-runtime";
+var IdentityCtx = createContext22(null);
+function useIdentityCtx() {
+  const ctx = useContext22(IdentityCtx);
+  if (!ctx) throw new Error("Identity parts must be used within Identity.Root");
+  return ctx;
+}
+var Root22 = forwardRef28(function IdentityRoot({ as: Tag = "div", size = "md", children, ...rest }, ref) {
+  return /* @__PURE__ */ jsx30(IdentityCtx.Provider, { value: { size }, children: /* @__PURE__ */ jsx30(
+    Tag,
+    {
+      ref,
+      "data-aeon-size": size,
+      ...mergeProps(scopeAttrs3(identityAnatomy.scope, identityAnatomy.root), rest),
+      children
+    }
+  ) });
+});
+var AvatarSlot = forwardRef28(
+  function IdentityAvatar(props, ref) {
+    useIdentityCtx();
+    return /* @__PURE__ */ jsx30(
+      "span",
+      {
+        ref,
+        ...mergeProps(partAttrs25(identityAnatomy.scope, identityAnatomy.avatar), props)
+      }
+    );
+  }
+);
+var Title3 = forwardRef28(function IdentityTitle(props, ref) {
+  useIdentityCtx();
+  return /* @__PURE__ */ jsx30(
+    "span",
+    {
+      ref,
+      ...mergeProps(partAttrs25(identityAnatomy.scope, identityAnatomy.title), props)
+    }
+  );
+});
+var Subtitle = forwardRef28(
+  function IdentitySubtitle(props, ref) {
+    useIdentityCtx();
+    return /* @__PURE__ */ jsx30(
+      "span",
+      {
+        ref,
+        ...mergeProps(partAttrs25(identityAnatomy.scope, identityAnatomy.subtitle), props)
+      }
+    );
+  }
+);
+var Meta = forwardRef28(function IdentityMeta(props, ref) {
+  useIdentityCtx();
+  return /* @__PURE__ */ jsx30("span", { ref, ...mergeProps(partAttrs25(identityAnatomy.scope, identityAnatomy.meta), props) });
+});
+var Trailing = forwardRef28(
+  function IdentityTrailing(props, ref) {
+    useIdentityCtx();
+    return /* @__PURE__ */ jsx30(
+      "span",
+      {
+        ref,
+        ...mergeProps(partAttrs25(identityAnatomy.scope, identityAnatomy.trailing), props)
+      }
+    );
+  }
+);
+var Identity = {
+  Root: Root22,
+  Avatar: AvatarSlot,
+  Title: Title3,
+  Subtitle,
+  Meta,
+  Trailing
+};
+
+// src/metric-strip/index.tsx
+import { metricStripAnatomy, partAttrs as partAttrs26, scopeAttrs as scopeAttrs4 } from "@aeon-ui/core";
+import { createContext as createContext23, forwardRef as forwardRef29, useContext as useContext23 } from "react";
+import { jsx as jsx31 } from "react/jsx-runtime";
+var MetricCtx = createContext23(null);
+function useMetricCtx() {
+  const ctx = useContext23(MetricCtx);
+  if (!ctx) throw new Error("MetricStrip parts must be used within MetricStrip.Root");
+  return ctx;
+}
+var Root23 = forwardRef29(function MetricStripRoot({ density = "cluster", children, ...rest }, ref) {
+  return /* @__PURE__ */ jsx31(MetricCtx.Provider, { value: { density }, children: /* @__PURE__ */ jsx31(
+    "div",
+    {
+      ref,
+      "data-aeon-density": density,
+      role: "group",
+      ...mergeProps(scopeAttrs4(metricStripAnatomy.scope, metricStripAnatomy.root), rest),
+      children
+    }
+  ) });
+});
+var Chip = forwardRef29(function MetricChip(props, ref) {
+  useMetricCtx();
+  return /* @__PURE__ */ jsx31(
+    "span",
+    {
+      ref,
+      ...mergeProps(partAttrs26(metricStripAnatomy.scope, metricStripAnatomy.chip), props)
+    }
+  );
+});
+var Value = forwardRef29(function MetricValue(props, ref) {
+  useMetricCtx();
+  return /* @__PURE__ */ jsx31(
+    "span",
+    {
+      ref,
+      ...mergeProps(partAttrs26(metricStripAnatomy.scope, metricStripAnatomy.value), props)
+    }
+  );
+});
+var Label6 = forwardRef29(function MetricLabel(props, ref) {
+  useMetricCtx();
+  return /* @__PURE__ */ jsx31(
+    "span",
+    {
+      ref,
+      ...mergeProps(partAttrs26(metricStripAnatomy.scope, metricStripAnatomy.label), props)
+    }
+  );
+});
+var MetricStrip = {
+  Root: Root23,
+  Chip,
+  Value,
+  Label: Label6
+};
+
+// src/list-row/index.tsx
+import { listRowAnatomy, partAttrs as partAttrs27, scopeAttrs as scopeAttrs5 } from "@aeon-ui/core";
+import { forwardRef as forwardRef30 } from "react";
+import { jsx as jsx32 } from "react/jsx-runtime";
+var Root24 = forwardRef30(function ListRowRoot({ as: Tag = "button", type, children, ...rest }, ref) {
+  const buttonType = Tag === "button" ? type ?? "button" : void 0;
+  return /* @__PURE__ */ jsx32(
+    Tag,
+    {
+      ref,
+      type: buttonType,
+      ...mergeProps(scopeAttrs5(listRowAnatomy.scope, listRowAnatomy.root), rest),
+      children
+    }
+  );
+});
+var Leading = forwardRef30(function ListRowLeading(props, ref) {
+  return /* @__PURE__ */ jsx32(
+    "span",
+    {
+      ref,
+      ...mergeProps(partAttrs27(listRowAnatomy.scope, listRowAnatomy.leading), props)
+    }
+  );
+});
+var Label7 = forwardRef30(function ListRowLabel(props, ref) {
+  return /* @__PURE__ */ jsx32("span", { ref, ...mergeProps(partAttrs27(listRowAnatomy.scope, listRowAnatomy.label), props) });
+});
+var Description3 = forwardRef30(
+  function ListRowDescription(props, ref) {
+    return /* @__PURE__ */ jsx32(
+      "span",
+      {
+        ref,
+        ...mergeProps(partAttrs27(listRowAnatomy.scope, listRowAnatomy.description), props)
+      }
+    );
+  }
+);
+var Trailing2 = forwardRef30(
+  function ListRowTrailing(props, ref) {
+    return /* @__PURE__ */ jsx32(
+      "span",
+      {
+        ref,
+        ...mergeProps(partAttrs27(listRowAnatomy.scope, listRowAnatomy.trailing), props)
+      }
+    );
+  }
+);
+var ListRow = {
+  Root: Root24,
+  Leading,
+  Label: Label7,
+  Description: Description3,
+  Trailing: Trailing2
+};
+
+// src/entry/index.tsx
+import { entryAnatomy, partAttrs as partAttrs28, scopeAttrs as scopeAttrs6 } from "@aeon-ui/core";
+import { forwardRef as forwardRef31 } from "react";
+import { jsx as jsx33 } from "react/jsx-runtime";
+var List2 = forwardRef31(function EntryList({ children, ...rest }, ref) {
+  return /* @__PURE__ */ jsx33(
+    "div",
+    {
+      ref,
+      ...mergeProps(scopeAttrs6(entryAnatomy.scope, entryAnatomy.list), rest),
+      children
+    }
+  );
+});
+var Root25 = forwardRef31(function EntryRoot({ as: Tag = "article", state = "idle", children, ...rest }, ref) {
+  return /* @__PURE__ */ jsx33(
+    Tag,
+    {
+      ref,
+      ...mergeProps(scopeAttrs6(entryAnatomy.scope, entryAnatomy.root, { state }), rest),
+      children
+    }
+  );
+});
+function Part(part, displayName, defaultTag = "div") {
+  const Comp = forwardRef31(
+    function EntryPart({ as: Tag = defaultTag, ...props }, ref) {
+      return /* @__PURE__ */ jsx33(
+        Tag,
+        {
+          ref,
+          ...mergeProps(partAttrs28(entryAnatomy.scope, part), props)
+        }
+      );
+    }
+  );
+  Comp.displayName = displayName;
+  return Comp;
+}
+var Entry = {
+  List: List2,
+  Root: Root25,
+  Header: Part(entryAnatomy.header, "Entry.Header", "header"),
+  Leading: Part(entryAnatomy.leading, "Entry.Leading", "div"),
+  Heading: Part(entryAnatomy.heading, "Entry.Heading", "div"),
+  Title: Part(entryAnatomy.title, "Entry.Title", "div"),
+  Subtitle: Part(entryAnatomy.subtitle, "Entry.Subtitle", "div"),
+  Meta: Part(entryAnatomy.meta, "Entry.Meta", "span"),
+  Media: Part(entryAnatomy.media, "Entry.Media", "div"),
+  Body: Part(entryAnatomy.body, "Entry.Body", "div"),
+  Values: Part(entryAnatomy.values, "Entry.Values", "div"),
+  Value: Part(entryAnatomy.value, "Entry.Value", "span"),
+  Actions: Part(entryAnatomy.actions, "Entry.Actions", "div"),
+  Footer: Part(entryAnatomy.footer, "Entry.Footer", "footer")
+};
+
+// src/conversation/index.tsx
+import { conversationAnatomy, partAttrs as partAttrs29, scopeAttrs as scopeAttrs7 } from "@aeon-ui/core";
+import { forwardRef as forwardRef32 } from "react";
+import { jsx as jsx34 } from "react/jsx-runtime";
+var Root26 = forwardRef32(function ConversationRoot({ children, ...rest }, ref) {
+  return /* @__PURE__ */ jsx34(
+    "div",
+    {
+      ref,
+      ...mergeProps(scopeAttrs7(conversationAnatomy.scope, conversationAnatomy.root), rest),
+      children
+    }
+  );
+});
+var Item6 = forwardRef32(function ConversationItem({ state = "idle", as: Tag = "button", type, children, ...rest }, ref) {
+  const buttonType = Tag === "button" ? type ?? "button" : void 0;
+  return /* @__PURE__ */ jsx34(
+    Tag,
+    {
+      ref,
+      type: buttonType,
+      ...mergeProps(
+        partAttrs29(conversationAnatomy.scope, conversationAnatomy.item, { state }),
+        rest
+      ),
+      children
+    }
+  );
+});
+function Part2(part, displayName) {
+  const Comp = forwardRef32(function ConversationPart(props, ref) {
+    return /* @__PURE__ */ jsx34(
+      "span",
+      {
+        ref,
+        ...mergeProps(partAttrs29(conversationAnatomy.scope, part), props)
+      }
+    );
+  });
+  Comp.displayName = displayName;
+  return Comp;
+}
+var Conversation = {
+  Root: Root26,
+  Item: Item6,
+  Leading: Part2(conversationAnatomy.leading, "Conversation.Leading"),
+  Body: Part2(conversationAnatomy.body, "Conversation.Body"),
+  Title: Part2(conversationAnatomy.title, "Conversation.Title"),
+  Preview: Part2(conversationAnatomy.preview, "Conversation.Preview"),
+  Meta: Part2(conversationAnatomy.meta, "Conversation.Meta"),
+  Badge: Part2(conversationAnatomy.badge, "Conversation.Badge")
+};
+
+// src/thread/index.tsx
+import { partAttrs as partAttrs30, scopeAttrs as scopeAttrs8, threadAnatomy } from "@aeon-ui/core";
+import { forwardRef as forwardRef33 } from "react";
+import { jsx as jsx35 } from "react/jsx-runtime";
+var Root27 = forwardRef33(function ThreadRoot({ children, ...rest }, ref) {
+  return /* @__PURE__ */ jsx35(
+    "div",
+    {
+      ref,
+      ...mergeProps(scopeAttrs8(threadAnatomy.scope, threadAnatomy.root), rest),
+      children
+    }
+  );
+});
+var List3 = forwardRef33(function ThreadList(props, ref) {
+  return /* @__PURE__ */ jsx35(
+    "div",
+    {
+      ref,
+      role: "log",
+      "aria-live": "polite",
+      ...mergeProps(partAttrs30(threadAnatomy.scope, threadAnatomy.list), props)
+    }
+  );
+});
+var Item7 = forwardRef33(function ThreadItem({ state = "theirs", ...rest }, ref) {
+  return /* @__PURE__ */ jsx35(
+    "div",
+    {
+      ref,
+      ...mergeProps(partAttrs30(threadAnatomy.scope, threadAnatomy.item, { state }), rest)
+    }
+  );
+});
+var Bubble = forwardRef33(function ThreadBubble(props, ref) {
+  return /* @__PURE__ */ jsx35(
+    "div",
+    {
+      ref,
+      ...mergeProps(partAttrs30(threadAnatomy.scope, threadAnatomy.bubble), props)
+    }
+  );
+});
+var Meta2 = forwardRef33(function ThreadMeta(props, ref) {
+  return /* @__PURE__ */ jsx35("span", { ref, ...mergeProps(partAttrs30(threadAnatomy.scope, threadAnatomy.meta), props) });
+});
+var Day = forwardRef33(function ThreadDay(props, ref) {
+  return /* @__PURE__ */ jsx35("div", { ref, ...mergeProps(partAttrs30(threadAnatomy.scope, threadAnatomy.day), props) });
+});
+var Thread = {
+  Root: Root27,
+  List: List3,
+  Item: Item7,
+  Bubble,
+  Meta: Meta2,
+  Day
+};
+
+// src/composer/index.tsx
+import { composerAnatomy, partAttrs as partAttrs31, scopeAttrs as scopeAttrs9 } from "@aeon-ui/core";
+import {
+  forwardRef as forwardRef34
+} from "react";
+import { jsx as jsx36 } from "react/jsx-runtime";
+var Root28 = forwardRef34(function ComposerRoot({ state = "idle", children, ...rest }, ref) {
+  return /* @__PURE__ */ jsx36(
+    "form",
+    {
+      ref,
+      ...mergeProps(scopeAttrs9(composerAnatomy.scope, composerAnatomy.root, { state }), rest),
+      children
+    }
+  );
+});
+var Input3 = forwardRef34(
+  function ComposerInput(props, ref) {
+    return /* @__PURE__ */ jsx36(
+      "textarea",
+      {
+        ref,
+        rows: 1,
+        ...mergeProps(partAttrs31(composerAnatomy.scope, composerAnatomy.input), props)
+      }
+    );
+  }
+);
+var Actions = forwardRef34(
+  function ComposerActions(props, ref) {
+    return /* @__PURE__ */ jsx36(
+      "div",
+      {
+        ref,
+        ...mergeProps(partAttrs31(composerAnatomy.scope, composerAnatomy.actions), props)
+      }
+    );
+  }
+);
+var Send = forwardRef34(
+  function ComposerSend(props, ref) {
+    return /* @__PURE__ */ jsx36(
+      "span",
+      {
+        ref,
+        ...mergeProps(partAttrs31(composerAnatomy.scope, composerAnatomy.send), props)
+      }
+    );
+  }
+);
+var Composer = {
+  Root: Root28,
+  Input: Input3,
+  Actions,
+  Send
+};
+
+// src/profile-header/index.tsx
+import { profileHeaderAnatomy, partAttrs as partAttrs32, scopeAttrs as scopeAttrs10 } from "@aeon-ui/core";
+import { forwardRef as forwardRef35 } from "react";
+import { jsx as jsx37 } from "react/jsx-runtime";
+var Root29 = forwardRef35(function ProfileHeaderRoot({ children, ...rest }, ref) {
+  return /* @__PURE__ */ jsx37(
+    "header",
+    {
+      ref,
+      ...mergeProps(scopeAttrs10(profileHeaderAnatomy.scope, profileHeaderAnatomy.root), rest),
+      children
+    }
+  );
+});
+var Media = forwardRef35(function ProfileHeaderMedia(props, ref) {
+  return /* @__PURE__ */ jsx37(
+    "div",
+    {
+      ref,
+      ...mergeProps(partAttrs32(profileHeaderAnatomy.scope, profileHeaderAnatomy.media), props)
+    }
+  );
+});
+var IdentitySlot = forwardRef35(
+  function ProfileHeaderIdentity(props, ref) {
+    return /* @__PURE__ */ jsx37(
+      "div",
+      {
+        ref,
+        ...mergeProps(partAttrs32(profileHeaderAnatomy.scope, profileHeaderAnatomy.identity), props)
+      }
+    );
+  }
+);
+var Metrics = forwardRef35(
+  function ProfileHeaderMetrics(props, ref) {
+    return /* @__PURE__ */ jsx37(
+      "div",
+      {
+        ref,
+        ...mergeProps(partAttrs32(profileHeaderAnatomy.scope, profileHeaderAnatomy.metrics), props)
+      }
+    );
+  }
+);
+var Actions2 = forwardRef35(
+  function ProfileHeaderActions(props, ref) {
+    return /* @__PURE__ */ jsx37(
+      "div",
+      {
+        ref,
+        ...mergeProps(partAttrs32(profileHeaderAnatomy.scope, profileHeaderAnatomy.actions), props)
+      }
+    );
+  }
+);
+var Body = forwardRef35(function ProfileHeaderBody(props, ref) {
+  return /* @__PURE__ */ jsx37(
+    "div",
+    {
+      ref,
+      ...mergeProps(partAttrs32(profileHeaderAnatomy.scope, profileHeaderAnatomy.body), props)
+    }
+  );
+});
+var ProfileHeader = {
+  Root: Root29,
+  Media,
+  Identity: IdentitySlot,
+  Metrics,
+  Actions: Actions2,
+  Body
+};
+
+// src/bar/index.tsx
+import { barAnatomy, partAttrs as partAttrs33, scopeAttrs as scopeAttrs11 } from "@aeon-ui/core";
+import { createContext as createContext24, forwardRef as forwardRef36 } from "react";
+import { jsx as jsx38 } from "react/jsx-runtime";
+var BarContext = createContext24({});
+var Root30 = forwardRef36(function BarRoot({ as: Tag = "header", gap, children, ...rest }, ref) {
+  return /* @__PURE__ */ jsx38(BarContext.Provider, { value: { gap }, children: /* @__PURE__ */ jsx38(
+    Tag,
+    {
+      ref,
+      ...mergeProps(scopeAttrs11(barAnatomy.scope, barAnatomy.root), rest),
+      children
+    }
+  ) });
+});
+var Zone = forwardRef36(function BarZone({ zone, children, ...rest }, ref) {
+  return /* @__PURE__ */ jsx38(
+    "div",
+    {
+      ref,
+      ...mergeProps(partAttrs33(barAnatomy.scope, zone), rest),
+      children
+    }
+  );
+});
+var Bar = {
+  Root: Root30,
+  Leading: forwardRef36(
+    function BarLeading(props, ref) {
+      return /* @__PURE__ */ jsx38(Zone, { ref, zone: "leading", ...props });
+    }
+  ),
+  Center: forwardRef36(
+    function BarCenter(props, ref) {
+      return /* @__PURE__ */ jsx38(Zone, { ref, zone: "center", ...props });
+    }
+  ),
+  Trailing: forwardRef36(
+    function BarTrailing(props, ref) {
+      return /* @__PURE__ */ jsx38(Zone, { ref, zone: "trailing", ...props });
+    }
+  )
+};
+
+// src/panel/index.tsx
+import { panelAnatomy, partAttrs as partAttrs34, scopeAttrs as scopeAttrs12 } from "@aeon-ui/core";
+import { panelMachine } from "@aeon-ui/primitives";
+import {
+  createContext as createContext25,
+  forwardRef as forwardRef37,
+  useContext as useContext24,
+  useEffect as useEffect22,
+  useId as useId8,
+  useMemo as useMemo21
+} from "react";
+import { jsx as jsx39 } from "react/jsx-runtime";
+var PanelCtx = createContext25(null);
+function usePanelCtx() {
+  const ctx = useContext24(PanelCtx);
+  if (!ctx) throw new Error("Panel parts must be used within Panel.Root");
+  return ctx;
+}
+var Group3 = forwardRef37(function PanelGroup({ orientation = "horizontal", children, className, ...rest }, ref) {
+  return /* @__PURE__ */ jsx39(
+    "div",
+    {
+      ref,
+      className,
+      "data-aeon-orientation": orientation,
+      ...mergeProps(partAttrs34(panelAnatomy.scope, panelAnatomy.group), rest),
+      children
+    }
+  );
+});
+var Root31 = forwardRef37(function PanelRoot({
+  label,
+  defaultExpanded = true,
+  expanded: expandedProp,
+  collapsible = true,
+  onExpandedChange,
+  children,
+  className,
+  ...rest
+}, ref) {
+  const contentId = useId8().replace(/:/g, "");
+  const [snapshot, send] = useAeonMachine(panelMachine, {
+    input: { expanded: defaultExpanded }
+  });
+  const machineExpanded = snapshot.value === "expanded";
+  const expanded = expandedProp ?? machineExpanded;
+  const state = expanded ? "expanded" : "collapsed";
+  useEffect22(() => {
+    onExpandedChange?.(expanded);
+  }, [expanded, onExpandedChange]);
+  useEffect22(() => {
+    if (expandedProp === void 0) return;
+    send({ type: "SET_EXPANDED", expanded: expandedProp });
+  }, [expandedProp, send]);
+  const ctx = useMemo21(
+    () => ({
+      state,
+      expanded,
+      collapsible,
+      label,
+      contentId: `aeon-panel-${contentId}`,
+      send
+    }),
+    [state, expanded, collapsible, label, contentId, send]
+  );
+  return /* @__PURE__ */ jsx39(PanelCtx.Provider, { value: ctx, children: /* @__PURE__ */ jsx39(
+    "div",
+    {
+      ref,
+      className,
+      ...mergeProps(
+        scopeAttrs12(panelAnatomy.scope, panelAnatomy.root, { state }),
+        {
+          "data-aeon-collapsible": collapsible ? "true" : void 0
+        },
+        rest
+      ),
+      children
+    }
+  ) });
+});
+var Trigger7 = forwardRef37(function PanelTrigger({ children, onClick, ...rest }, ref) {
+  const { expanded, collapsible, contentId, send, label } = usePanelCtx();
+  return /* @__PURE__ */ jsx39(
+    "button",
+    {
+      ref,
+      type: "button",
+      "aria-expanded": expanded,
+      "aria-controls": contentId,
+      disabled: !collapsible,
+      ...mergeProps(
+        partAttrs34(panelAnatomy.scope, panelAnatomy.trigger, {
+          state: expanded ? "expanded" : "collapsed"
+        }),
+        rest
+      ),
+      onClick: (e) => {
+        onClick?.(e);
+        if (!e.defaultPrevented && collapsible) send({ type: "TOGGLE" });
+      },
+      children: children ?? (expanded ? "Collapse" : `Expand ${label}`)
+    }
+  );
+});
+var Label8 = forwardRef37(function PanelLabel({ children, onClick, ...rest }, ref) {
+  const { label, state, collapsible, send, expanded, contentId } = usePanelCtx();
+  const text = typeof children === "string" || children == null ? String(children ?? label) : null;
+  return /* @__PURE__ */ jsx39(
+    "span",
+    {
+      ref,
+      role: collapsible ? "button" : void 0,
+      tabIndex: collapsible ? 0 : void 0,
+      "aria-expanded": collapsible ? expanded : void 0,
+      "aria-controls": collapsible ? contentId : void 0,
+      ...mergeProps(partAttrs34(panelAnatomy.scope, panelAnatomy.label, { state }), rest),
+      onClick: (e) => {
+        onClick?.(e);
+        if (!e.defaultPrevented && collapsible) send({ type: "TOGGLE" });
+      },
+      onKeyDown: (e) => {
+        if (!collapsible) return;
+        if (e.key === "Enter" || e.key === " ") {
+          e.preventDefault();
+          send({ type: "TOGGLE" });
+        }
+      },
+      children: text != null ? state === "collapsed" ? text.split("").map(
+        (ch, i) => ch === " " ? /* @__PURE__ */ jsx39("span", { "data-aeon-part": "label-gap", "aria-hidden": true, children: " " }, `sp-${i}`) : /* @__PURE__ */ jsx39("span", { "data-aeon-part": "label-char", children: ch }, `${ch}-${i}`)
+      ) : text : children
+    }
+  );
+});
+var Content9 = forwardRef37(function PanelContent({ children, ...rest }, ref) {
+  const { expanded, contentId, state } = usePanelCtx();
+  return /* @__PURE__ */ jsx39(
+    "div",
+    {
+      ref,
+      id: contentId,
+      hidden: !expanded,
+      ...mergeProps(partAttrs34(panelAnatomy.scope, panelAnatomy.content, { state }), rest),
+      children
+    }
+  );
+});
+var Panel = {
+  Group: Group3,
+  Root: Root31,
+  Trigger: Trigger7,
+  Label: Label8,
+  Content: Content9
+};
+
+// src/app-shell/index.tsx
+import { appShellAnatomy, partAttrs as partAttrs35, scopeAttrs as scopeAttrs13 } from "@aeon-ui/core";
+import { appShellMachine } from "@aeon-ui/primitives";
+import {
+  createContext as createContext26,
+  forwardRef as forwardRef38,
+  useContext as useContext25,
+  useEffect as useEffect23,
+  useMemo as useMemo22
+} from "react";
+import { jsx as jsx40 } from "react/jsx-runtime";
+var AppShellCtx = createContext26(null);
+function useAppShellContext() {
+  const ctx = useContext25(AppShellCtx);
+  if (!ctx) throw new Error("AppShell parts must be used within AppShell.Root");
+  return ctx;
+}
+var Root32 = forwardRef38(function AppShellRoot({ defaultDockVisible = true, dockVisible: dockVisibleProp, children, ...rest }, ref) {
+  const [snapshot, send] = useAeonMachine(appShellMachine, {
+    input: { dockVisible: dockVisibleProp ?? defaultDockVisible }
+  });
+  const chrome = snapshot.value;
+  const dockVisible = dockVisibleProp ?? snapshot.context.dockVisible;
+  useEffect23(() => {
+    if (dockVisibleProp === void 0) return;
+    if (snapshot.context.dockVisible !== dockVisibleProp) {
+      send({ type: "SET_DOCK", visible: dockVisibleProp });
+    }
+  }, [dockVisibleProp, snapshot.context.dockVisible, send]);
+  const value = useMemo22(
+    () => ({
+      chrome,
+      dockVisible,
+      overlayOpen: chrome === "overlayOpen",
+      send
+    }),
+    [chrome, dockVisible, send]
+  );
+  return /* @__PURE__ */ jsx40(AppShellCtx.Provider, { value, children: /* @__PURE__ */ jsx40(
+    "div",
+    {
+      ref,
+      "data-aeon-dock": dockVisible ? "visible" : "hidden",
+      ...mergeProps(
+        scopeAttrs13(appShellAnatomy.scope, appShellAnatomy.root, { state: chrome }),
+        rest
+      ),
+      children
+    }
+  ) });
+});
+function ShellPart(part, displayName, defaultTag = "div") {
+  const Comp = forwardRef38(
+    function AeonShellPart({ as: Tag = defaultTag, ...rest }, ref) {
+      const { chrome } = useAppShellContext();
+      return /* @__PURE__ */ jsx40(
+        Tag,
+        {
+          ref,
+          ...mergeProps(partAttrs35(appShellAnatomy.scope, part, { state: chrome }), rest)
+        }
+      );
+    }
+  );
+  Comp.displayName = displayName;
+  return Comp;
+}
+var Header = ShellPart(appShellAnatomy.header, "AppShell.Header", "header");
+var Subheader = ShellPart(appShellAnatomy.subheader, "AppShell.Subheader");
+var Content10 = ShellPart(appShellAnatomy.content, "AppShell.Content", "main");
+var Aside = ShellPart(appShellAnatomy.aside, "AppShell.Aside", "aside");
+var Footer = ShellPart(appShellAnatomy.footer, "AppShell.Footer", "footer");
+var Dock = forwardRef38(function AppShellDock({ hidden, ...rest }, ref) {
+  const { chrome, dockVisible } = useAppShellContext();
+  if (!dockVisible) return null;
+  return /* @__PURE__ */ jsx40(
+    "div",
+    {
+      ref,
+      hidden,
+      ...mergeProps(partAttrs35(appShellAnatomy.scope, appShellAnatomy.dock, { state: chrome }), rest)
+    }
+  );
+});
+var Scrim = forwardRef38(function AppShellScrim(props, ref) {
+  const { chrome, overlayOpen, send } = useAppShellContext();
+  if (!overlayOpen) return null;
+  return /* @__PURE__ */ jsx40(
+    "div",
+    {
+      ref,
+      role: "presentation",
+      onClick: () => send({ type: "CLOSE_OVERLAY" }),
+      ...mergeProps(partAttrs35(appShellAnatomy.scope, appShellAnatomy.scrim, { state: chrome }), props)
+    }
+  );
+});
+var AppShell = {
+  Root: Root32,
+  Header,
+  Subheader,
+  Content: Content10,
+  Aside,
+  Footer,
+  Dock,
+  Scrim
+};
+
+// src/content/index.tsx
+import { contentAnatomy, partAttrs as partAttrs36, scopeAttrs as scopeAttrs14 } from "@aeon-ui/core";
+import { contentRegionMachine } from "@aeon-ui/primitives";
+import {
+  createContext as createContext27,
+  forwardRef as forwardRef39,
+  useContext as useContext26,
+  useMemo as useMemo23
+} from "react";
+import { jsx as jsx41 } from "react/jsx-runtime";
+var ContentCtx = createContext27(null);
+function useContentContext() {
+  const ctx = useContext26(ContentCtx);
+  if (!ctx) throw new Error("Content parts must be used within Content.Root");
+  return ctx;
+}
+var Root33 = forwardRef39(function ContentRoot({ state: stateProp, children, ...rest }, ref) {
+  const [snapshot, send] = useAeonMachine(contentRegionMachine);
+  const machineState = snapshot.value;
+  const state = stateProp ?? machineState;
+  const value = useMemo23(
+    () => ({ state, error: snapshot.context.error, send }),
+    [state, snapshot.context.error, send]
+  );
+  return /* @__PURE__ */ jsx41(ContentCtx.Provider, { value, children: /* @__PURE__ */ jsx41(
+    "div",
+    {
+      ref,
+      ...mergeProps(scopeAttrs14(contentAnatomy.scope, contentAnatomy.root, { state }), rest),
+      children
+    }
+  ) });
+});
+var Toolbar = forwardRef39(function ContentToolbar(props, ref) {
+  const { state } = useContentContext();
+  return /* @__PURE__ */ jsx41(
+    "div",
+    {
+      ref,
+      ...mergeProps(partAttrs36(contentAnatomy.scope, contentAnatomy.toolbar, { state }), props)
+    }
+  );
+});
+var Body2 = forwardRef39(function ContentBody({ hidden, ...rest }, ref) {
+  const { state } = useContentContext();
+  const show = state === "ready" || state === "loadingMore" || state === "success" || state === "idle";
+  if (!show) return null;
+  return /* @__PURE__ */ jsx41(
+    "div",
+    {
+      ref,
+      hidden,
+      ...mergeProps(partAttrs36(contentAnatomy.scope, contentAnatomy.body, { state }), rest)
+    }
+  );
+});
+function StatusSlot(part, match, displayName) {
+  const matches = Array.isArray(match) ? match : [match];
+  const Comp = forwardRef39(function ContentStatusSlot(props, ref) {
+    const { state } = useContentContext();
+    if (!matches.includes(state)) return null;
+    return /* @__PURE__ */ jsx41(
+      "div",
+      {
+        ref,
+        role: "status",
+        ...mergeProps(partAttrs36(contentAnatomy.scope, part, { state }), props)
+      }
+    );
+  });
+  Comp.displayName = displayName;
+  return Comp;
+}
+var Pending = StatusSlot(contentAnatomy.pending, "pending", "Content.Pending");
+var Empty2 = StatusSlot(contentAnatomy.empty, "empty", "Content.Empty");
+var ErrorSlot = StatusSlot(contentAnatomy.error, "error", "Content.Error");
+var Success = StatusSlot(contentAnatomy.success, "success", "Content.Success");
+var Sentinel = forwardRef39(function ContentSentinel(props, ref) {
+  const { state } = useContentContext();
+  if (state !== "ready" && state !== "loadingMore") return null;
+  return /* @__PURE__ */ jsx41(
+    "div",
+    {
+      ref,
+      ...mergeProps(partAttrs36(contentAnatomy.scope, contentAnatomy.sentinel, { state }), props)
+    }
+  );
+});
+var Content11 = {
+  Root: Root33,
+  Toolbar,
+  Body: Body2,
+  Pending,
+  Empty: Empty2,
+  Error: ErrorSlot,
+  Success,
+  Sentinel
+};
+
+// src/nav/index.tsx
+import { navAnatomy, partAttrs as partAttrs37, scopeAttrs as scopeAttrs15 } from "@aeon-ui/core";
+import { tabsMachine as tabsMachine3 } from "@aeon-ui/primitives";
+import {
+  createContext as createContext28,
+  forwardRef as forwardRef40,
+  useContext as useContext27,
+  useEffect as useEffect24,
+  useMemo as useMemo24
+} from "react";
+import { jsx as jsx42 } from "react/jsx-runtime";
+var NavCtx = createContext28(null);
+function useNavCtx() {
+  const ctx = useContext27(NavCtx);
+  if (!ctx) throw new Error("Nav parts must be used within Nav.Root");
+  return ctx;
+}
+var Root34 = forwardRef40(function NavRoot({
+  defaultValue = "",
+  value,
+  onValueChange,
+  as: Tag = "nav",
+  orientation = "horizontal",
+  children,
+  ...rest
+}, ref) {
+  const [snapshot, send] = useAeonMachine(tabsMachine3, {
+    input: { value: defaultValue, disabled: false }
+  });
+  const resolvedValue = value ?? snapshot.context.value;
+  useEffect24(() => {
+    if (value !== void 0) send({ type: "SET_VALUE", value });
+  }, [value, send]);
+  const ctx = useMemo24(
+    () => ({ value: resolvedValue, send, onValueChange }),
+    [resolvedValue, send, onValueChange]
+  );
+  return /* @__PURE__ */ jsx42(NavCtx.Provider, { value: ctx, children: /* @__PURE__ */ jsx42(
+    Tag,
+    {
+      ref,
+      "data-aeon-orientation": orientation,
+      ...mergeProps(scopeAttrs15(navAnatomy.scope, navAnatomy.root), rest),
+      children
+    }
+  ) });
+});
+var Item8 = forwardRef40(function NavItem({ value, disabled, onClick, children, ...rest }, ref) {
+  const { value: selected, send, onValueChange } = useNavCtx();
+  const active = selected === value;
+  const state = disabled ? "disabled" : active ? "active" : "inactive";
+  return /* @__PURE__ */ jsx42(
+    "button",
+    {
+      ref,
+      type: "button",
+      disabled,
+      "aria-current": active ? "page" : void 0,
+      "data-aeon-value": value,
+      onClick: (e) => {
+        onClick?.(e);
+        if (disabled || e.defaultPrevented) return;
+        send({ type: "SELECT", value });
+        onValueChange?.(value);
+      },
+      ...mergeProps(partAttrs37(navAnatomy.scope, navAnatomy.item, { state, disabled }), rest),
+      children
+    }
+  );
+});
+var Indicator3 = forwardRef40(function NavIndicator(props, ref) {
+  return /* @__PURE__ */ jsx42(
+    "span",
+    {
+      ref,
+      "aria-hidden": true,
+      ...mergeProps(partAttrs37(navAnatomy.scope, navAnatomy.indicator), props)
+    }
+  );
+});
+var Label9 = forwardRef40(function NavLabel(props, ref) {
+  return /* @__PURE__ */ jsx42("span", { ref, ...mergeProps(partAttrs37(navAnatomy.scope, navAnatomy.label), props) });
+});
+var Icon2 = forwardRef40(function NavIcon(props, ref) {
+  return /* @__PURE__ */ jsx42("span", { ref, ...mergeProps(partAttrs37(navAnatomy.scope, navAnatomy.icon), props) });
+});
+var Badge2 = forwardRef40(function NavBadge(props, ref) {
+  return /* @__PURE__ */ jsx42("span", { ref, ...mergeProps(partAttrs37(navAnatomy.scope, navAnatomy.badge), props) });
+});
+var Nav = {
+  Root: Root34,
+  Item: Item8,
+  Indicator: Indicator3,
+  Label: Label9,
+  Icon: Icon2,
+  Badge: Badge2
+};
+
+// src/sticky-bar/index.tsx
+import { barAnatomy as barAnatomy2, partAttrs as partAttrs38, scopeAttrs as scopeAttrs16 } from "@aeon-ui/core";
+import { stickyBarMachine } from "@aeon-ui/primitives";
+import {
+  createContext as createContext29,
+  forwardRef as forwardRef41,
+  useContext as useContext28,
+  useMemo as useMemo25
+} from "react";
+import { jsx as jsx43 } from "react/jsx-runtime";
+var StickyBarCtx = createContext29(null);
+function useStickyBarContext() {
+  const ctx = useContext28(StickyBarCtx);
+  if (!ctx) throw new Error("StickyBar parts must be used within StickyBar.Root");
+  return ctx;
+}
+var Root35 = forwardRef41(function StickyBarRoot({
+  /* Default div — AppShell.Header is already the landmark; nested <header> is invalid
+     HTML and browsers auto-close the outer header (0-height), so the bar covers content. */
+  as: Tag = "div",
+  placement = "top",
+  defaultState = "floating",
+  children,
+  style,
+  ...rest
+}, ref) {
+  const [snapshot, send] = useAeonMachine(stickyBarMachine, {
+    input: { initial: defaultState }
+  });
+  const state = snapshot.value;
+  const offsetPx = snapshot.context.offsetPx;
+  const value = useMemo25(() => ({ state, offsetPx, send }), [state, offsetPx, send]);
+  if (state === "hidden") return null;
+  const stickyStyle = {
+    ...typeof style === "object" && style ? style : {},
+    ...offsetPx > 0 ? { ["--aeon-bar-offset"]: `${offsetPx}px` } : {}
+  };
+  return /* @__PURE__ */ jsx43(StickyBarCtx.Provider, { value, children: /* @__PURE__ */ jsx43(
+    Tag,
+    {
+      ref,
+      "data-aeon-placement": placement,
+      style: stickyStyle,
+      ...mergeProps(scopeAttrs16(barAnatomy2.scope, barAnatomy2.root, { state }), rest),
+      children
+    }
+  ) });
+});
+var Zone2 = forwardRef41(function StickyBarZone({ zone, ...rest }, ref) {
+  const { state } = useStickyBarContext();
+  return /* @__PURE__ */ jsx43(
+    "div",
+    {
+      ref,
+      ...mergeProps(partAttrs38(barAnatomy2.scope, zone, { state }), rest)
+    }
+  );
+});
+var Leading2 = forwardRef41(
+  function StickyBarLeading(props, ref) {
+    return /* @__PURE__ */ jsx43(Zone2, { ref, zone: "leading", ...props });
+  }
+);
+var Center = forwardRef41(
+  function StickyBarCenter(props, ref) {
+    return /* @__PURE__ */ jsx43(Zone2, { ref, zone: "center", ...props });
+  }
+);
+var Trailing3 = forwardRef41(
+  function StickyBarTrailing(props, ref) {
+    return /* @__PURE__ */ jsx43(Zone2, { ref, zone: "trailing", ...props });
+  }
+);
+var Seam = forwardRef41(function StickyBarSeam(props, ref) {
+  const { state } = useStickyBarContext();
+  return /* @__PURE__ */ jsx43(
+    "div",
+    {
+      ref,
+      "aria-hidden": true,
+      ...mergeProps(partAttrs38(barAnatomy2.scope, barAnatomy2.seam, { state }), props)
+    }
+  );
+});
+var StickyBar = {
+  Root: Root35,
+  Leading: Leading2,
+  Center,
+  Trailing: Trailing3,
+  Seam
+};
+
+// src/hooks/use-layout-mode.ts
+import { getCompactMq, layoutCompositionForMode, matchLayoutMode } from "@aeon-ui/core";
+import { useEffect as useEffect25, useMemo as useMemo26, useState as useState11 } from "react";
+function useLayoutMode(spec) {
+  const mq = useMemo26(() => getCompactMq(spec), [spec.compactMq]);
+  const [mode, setMode] = useState11(() => matchLayoutMode(spec, mq));
+  useEffect25(() => {
+    const sync = () => setMode(matchLayoutMode(spec, mq));
+    sync();
+    mq.addEventListener("change", sync);
+    return () => mq.removeEventListener("change", sync);
+  }, [spec, mq]);
+  const composition = useMemo26(() => layoutCompositionForMode(spec, mode), [spec, mode]);
+  return { mode, composition };
+}
+export {
+  Accordion,
+  AppShell,
+  Async,
+  AsyncActions,
+  AsyncProvider,
+  AsyncReadout,
+  AsyncRoot,
+  AsyncTrack,
+  Avatar,
+  Bar,
+  Button,
+  Checkbox,
+  Combobox,
+  Composer,
+  Content11 as Content,
+  Conversation,
+  Dialog,
+  Entry,
+  Field,
+  Identity,
+  ListRow,
+  Menu,
+  MetricStrip,
+  Nav,
+  Panel,
+  PinInput,
+  Popover,
+  ProfileHeader,
+  Progress,
+  RadioGroup,
+  Scroll,
+  Select,
+  Separator,
+  Slider,
+  StickyBar,
+  Switch,
+  Tabs,
+  ThemeSwitcher,
+  Thread,
+  Toast,
+  ToastItem,
+  Tooltip,
+  asyncStatusToContentState,
+  createAsyncMachine2 as createAsyncMachine,
+  fieldMachine,
+  useAeonMachine,
+  useAppShellContext,
+  useAsyncContext,
+  useContentContext,
+  useFieldContext,
+  useLayoutMode,
+  useScrollContext,
+  useScrollState,
+  useStickyBarContext,
+  useToast,
+  useToastStore
+};