@conscia-labs/design-system 0.4.0 → 1.0.0

package/dist/chunk-3UTRMJLB.js

@@ -0,0 +1,3754 @@
+import {
+  BASE_UI_SWIPE_IGNORE_SELECTOR,
+  BasePopupHandle,
+  Button,
+  CLICK_TRIGGER_IDENTIFIER,
+  COMPOSITE_KEYS,
+  Card,
+  CardContent,
+  CardDescription,
+  CardFooter,
+  CardHeader,
+  CardTitle,
+  Checkbox,
+  EMPTY_OBJECT,
+  FOCUSABLE_POPUP_PROPS,
+  FloatingFocusManager,
+  FloatingNode,
+  FloatingPortal,
+  FloatingPortalLite,
+  FloatingTree,
+  FocusGuard,
+  IconButton,
+  Input,
+  InternalBackdrop,
+  LEGACY_SWIPE_IGNORE_SELECTOR,
+  NOOP,
+  NullStore,
+  PATIENT_CLICK_THRESHOLD,
+  POPUP_COLLISION_AVOIDANCE,
+  PopupHandleAttachment,
+  PopupTriggerMap,
+  ReactStore,
+  Select,
+  SelectContent,
+  SelectGroup,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+  Table,
+  TableBody,
+  TableCell,
+  TableHead,
+  TableHeader,
+  TableRow,
+  Timeout,
+  activeElement,
+  addEventListener,
+  attachPreventUnmountOnClose,
+  contains,
+  createChangeEventDetails,
+  createDefaultInitialFocus,
+  createInitialPopupStoreState,
+  createPopupFloatingRootContext,
+  dispatchClickWithModifiers,
+  fieldValidityMapping,
+  getDisabledMountTransitionStyles,
+  getDisplacement,
+  getElementTransform,
+  getTarget,
+  getWindow,
+  index_parts_exports,
+  inertValue,
+  isElement,
+  isHTMLElement,
+  matchesFocusVisible,
+  mergeCleanups,
+  ownerDocument,
+  popupStateMapping,
+  popupStoreSelectors,
+  popupTransitionStateMapping,
+  popupViewportStateMapping,
+  pressableTriggerOpenStateMapping,
+  reason_parts_exports,
+  safePolygon,
+  setPopupOpenState,
+  transitionStatusMapping,
+  triggerOpenStateMapping,
+  useAnchorPositioning,
+  useAnchoredPopupScrollLock,
+  useAnimationsFinished,
+  useAriaLabelledBy,
+  useBaseUiId,
+  useButton,
+  useClick,
+  useControlled,
+  useDismiss,
+  useFieldRootContext,
+  useFloatingNodeId,
+  useFloatingRootContext,
+  useFormContext,
+  useHoverFloatingInteraction,
+  useHoverReferenceInteraction,
+  useId,
+  useImplicitActiveTrigger,
+  useIsoLayoutEffect,
+  useLabelableContext,
+  useLabelableId,
+  useMergedRefs,
+  useOnMount,
+  useOpenChangeComplete,
+  useOpenMethodTriggerProps,
+  useOpenStateTransitions,
+  usePopupHandleStore,
+  usePopupInteractionProps,
+  usePopupRootStore,
+  usePopupRootSync,
+  usePopupViewport,
+  usePositioner,
+  useRefWithInit,
+  useRegisterFieldControl,
+  useRenderElement,
+  useStableCallback,
+  useTimeout,
+  useToolbarRootContext,
+  useTriggerDataForwarding,
+  useTriggerFocusGuards,
+  useValueChanged,
+  visuallyHidden,
+  visuallyHiddenInput
+} from "./chunk-YAJUTCGD.js";
+import {
+  cn
+} from "./chunk-JU5DQXFC.js";
+import {
+  __export,
+  __publicField
+} from "./chunk-UVKRO5ER.js";
+
+// src/primitives/alert.tsx
+import * as React from "react";
+import { cva } from "class-variance-authority";
+import { jsx } from "react/jsx-runtime";
+var AlertContext = React.createContext(null);
+var alertVariants = cva(
+  "relative grid w-full grid-cols-[auto_1fr] items-start gap-x-3 rounded-[var(--ds-radius-surface)] border px-4 py-3.5 text-sm [&>svg]:mt-0.5 [&>svg]:size-5",
+  {
+    variants: {
+      variant: {
+        default: "border-border-default bg-surface text-text-primary",
+        information: "border-information-border bg-information-background text-information-foreground",
+        success: "border-success-border bg-success-background text-success-foreground",
+        warning: "border-warning-border bg-warning-background text-warning-foreground",
+        danger: "border-danger-border bg-danger-background text-danger-foreground"
+      }
+    },
+    defaultVariants: {
+      variant: "default"
+    }
+  }
+);
+function Alert({
+  children,
+  className,
+  variant,
+  role = "group",
+  "aria-labelledby": ariaLabelledby,
+  "aria-describedby": ariaDescribedby,
+  ...props
+}) {
+  const baseId = React.useId();
+  const titleId = `${baseId}-title`;
+  const descriptionId = `${baseId}-description`;
+  const [registeredTitleId, setRegisteredTitleId] = React.useState();
+  const [registeredDescriptionId, setRegisteredDescriptionId] = React.useState();
+  const registerTitle = React.useCallback((id) => setRegisteredTitleId(id), []);
+  const registerDescription = React.useCallback((id) => setRegisteredDescriptionId(id), []);
+  return /* @__PURE__ */ jsx(AlertContext.Provider, { value: { titleId, descriptionId, hasTitle: Boolean(registeredTitleId), hasDescription: Boolean(registeredDescriptionId), registerTitle, registerDescription }, children: /* @__PURE__ */ jsx(
+    "div",
+    {
+      "data-slot": "alert",
+      role,
+      "aria-labelledby": ariaLabelledby ?? registeredTitleId,
+      "aria-describedby": ariaDescribedby ?? registeredDescriptionId,
+      className: cn(alertVariants({ variant }), className),
+      ...props,
+      children
+    }
+  ) });
+}
+function AlertTitle({ className, ...props }) {
+  const context = React.useContext(AlertContext);
+  const id = props.id ?? context?.titleId;
+  React.useEffect(() => {
+    if (id) context?.registerTitle(id);
+  }, [context, id]);
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      "data-slot": "alert-title",
+      id,
+      className: cn("font-medium leading-5", className),
+      ...props
+    }
+  );
+}
+function AlertDescription({ className, ...props }) {
+  const context = React.useContext(AlertContext);
+  const id = props.id ?? context?.descriptionId;
+  React.useEffect(() => {
+    if (id) context?.registerDescription(id);
+  }, [context, id]);
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      "data-slot": "alert-description",
+      id,
+      className: cn("col-start-2 mt-0.5 text-sm leading-5 opacity-80", className),
+      ...props
+    }
+  );
+}
+
+// src/primitives/avatar.tsx
+import * as React2 from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var useAvatarEffect = typeof window === "undefined" ? React2.useEffect : React2.useLayoutEffect;
+var AvatarContext = React2.createContext(null);
+function useAvatarContext() {
+  const context = React2.useContext(AvatarContext);
+  if (!context) {
+    throw new Error("AvatarImage and AvatarFallback must be used inside Avatar.");
+  }
+  return context;
+}
+function Avatar({
+  children,
+  className,
+  ...props
+}) {
+  const [status, setStatus] = React2.useState("idle");
+  return /* @__PURE__ */ jsx2(AvatarContext.Provider, { value: { status, setStatus }, children: /* @__PURE__ */ jsx2("div", { "data-slot": "avatar", className: cn("relative flex size-8 shrink-0 overflow-hidden rounded-full", className), ...props, children }) });
+}
+function AvatarImage({
+  alt = "",
+  className,
+  onError,
+  onLoad,
+  src,
+  ...props
+}) {
+  const { status, setStatus } = useAvatarContext();
+  useAvatarEffect(() => {
+    setStatus(src ? "loading" : "error");
+  }, [src, setStatus]);
+  return (
+    // The library must use a framework-neutral image element rather than Next's Image component.
+    // eslint-disable-next-line @next/next/no-img-element
+    /* @__PURE__ */ jsx2(
+      "img",
+      {
+        "data-slot": "avatar-image",
+        className: cn("aspect-square size-full", status === "loaded" ? "" : "hidden", className),
+        alt,
+        src,
+        ...props,
+        onLoad: (event) => {
+          setStatus("loaded");
+          onLoad?.(event);
+        },
+        onError: (event) => {
+          setStatus("error");
+          onError?.(event);
+        }
+      }
+    )
+  );
+}
+function AvatarFallback({
+  className,
+  ...props
+}) {
+  const { status } = useAvatarContext();
+  return /* @__PURE__ */ jsx2("div", { "data-slot": "avatar-fallback", className: cn("flex size-full items-center justify-center rounded-full bg-surface-muted text-xs font-medium text-text-supporting", status === "loaded" ? "hidden" : "", className), ...props });
+}
+
+// src/primitives/avatar-group.tsx
+import * as React3 from "react";
+import { jsxs } from "react/jsx-runtime";
+function AvatarGroup({
+  children,
+  className,
+  max,
+  size = "default",
+  total,
+  ...props
+}) {
+  const avatars = React3.Children.toArray(children);
+  const visibleCount = max === void 0 ? avatars.length : Math.max(0, Math.floor(max));
+  const visibleAvatars = avatars.slice(0, visibleCount);
+  const totalCount = Math.max(avatars.length, total ?? avatars.length);
+  const overflowCount = Math.max(0, totalCount - visibleAvatars.length);
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      "data-slot": "avatar-group",
+      "data-size": size,
+      className: cn(
+        "flex items-center [&>[data-slot=avatar]]:relative [&>[data-slot=avatar]]:z-0 [&>[data-slot=avatar]]:shrink-0 [&>[data-slot=avatar]]:ring-2 [&>[data-slot=avatar]]:ring-canvas [&>[data-slot=avatar]]:transition-[margin,z-index] hover:[&>[data-slot=avatar]]:z-10 data-[size=default]:gap-0 data-[size=default]:[&>[data-slot=avatar]]:-ml-2 data-[size=default]:[&>[data-slot=avatar]]:size-8 data-[size=lg]:gap-0 data-[size=lg]:[&>[data-slot=avatar]]:-ml-2.5 data-[size=lg]:[&>[data-slot=avatar]]:size-10 data-[size=sm]:gap-0 data-[size=sm]:[&>[data-slot=avatar]]:-ml-1.5 data-[size=sm]:[&>[data-slot=avatar]]:size-6 [&>[data-slot=avatar]:first-child]:ml-0",
+        className
+      ),
+      role: "group",
+      ...props,
+      children: [
+        visibleAvatars,
+        overflowCount > 0 ? /* @__PURE__ */ jsxs(
+          "span",
+          {
+            "data-slot": "avatar-group-overflow",
+            className: "relative z-0 inline-flex shrink-0 items-center justify-center rounded-full border-2 border-canvas bg-surface-muted font-medium text-text-supporting data-[size=default]:-ml-2 data-[size=default]:size-8 data-[size=default]:text-xs data-[size=lg]:-ml-2.5 data-[size=lg]:size-10 data-[size=lg]:text-sm data-[size=sm]:-ml-1.5 data-[size=sm]:size-6 data-[size=sm]:text-[0.625rem]",
+            "aria-label": `${overflowCount} more ${overflowCount === 1 ? "avatar" : "avatars"}`,
+            title: `${overflowCount} more ${overflowCount === 1 ? "avatar" : "avatars"}`,
+            children: [
+              "+",
+              overflowCount
+            ]
+          }
+        ) : null
+      ]
+    }
+  );
+}
+
+// src/primitives/badge.tsx
+import { cva as cva2 } from "class-variance-authority";
+import { jsx as jsx3 } from "react/jsx-runtime";
+var badgeVariants = cva2(
+  "inline-flex items-center rounded-md border px-1.5 py-0.5 text-[var(--ds-metadata)] font-medium leading-4 transition-colors",
+  {
+    variants: {
+      variant: {
+        default: "border-action bg-action text-action-foreground",
+        accent: "border-selection-border bg-selection-background text-selection-foreground",
+        secondary: "border-neutral-border bg-neutral-background text-neutral-foreground",
+        neutral: "border-neutral-border bg-neutral-background text-neutral-foreground",
+        outline: "border-border-default text-text-primary",
+        information: "border-information-border bg-information-background text-information-foreground",
+        info: "border-information-border bg-information-background text-information-foreground",
+        success: "border-success-border bg-success-background text-success-foreground",
+        warning: "border-warning-border bg-warning-background text-warning-foreground",
+        danger: "border-danger-border bg-danger-background text-danger-foreground",
+        destructive: "border-danger-border bg-danger-background text-danger-foreground"
+      }
+    },
+    defaultVariants: {
+      variant: "neutral"
+    }
+  }
+);
+function Badge({
+  className,
+  variant,
+  ...props
+}) {
+  return /* @__PURE__ */ jsx3("span", { "data-slot": "badge", className: cn(badgeVariants({ variant, className })), ...props });
+}
+
+// src/primitives/brand-icon.tsx
+import { jsx as jsx4 } from "react/jsx-runtime";
+var CONSCIA_SYMBOL_PATH = [
+  "M171.225 63.8139L173.637 66.1116L203.794 34.4551L201.382 32.1575L171.225 63.8139Z",
+  "M184.012 78.9693L185.769 81.8487L223.091 59.076L221.334 56.1966L184.012 78.9693Z",
+  "M192.436 96.8858L193.417 100.222L235.362 87.8847L234.381 84.5488L192.436 96.8858Z",
+  "M195.949 116.334L196.037 119.987L239.746 118.926L239.657 115.273L195.949 116.334Z",
+  "M194.341 135.989L193.42 139.796L235.913 150.084L236.835 146.277L194.341 135.989Z",
+  "M187.759 154.526L185.708 158.285L224.091 179.221L226.142 175.461L187.759 154.526Z",
+  "M176.683 170.712L173.394 174.165L205.05 204.322L208.34 200.868L176.683 170.712Z",
+  "M161.899 183.49L157.288 186.304L180.06 223.626L184.672 220.812L161.899 183.49Z",
+  "M144.425 192.058L138.472 193.809L150.809 235.754L156.762 234.003L144.425 192.058Z",
+  "M125.438 195.913L118.244 196.088L119.305 239.796L126.499 239.622L125.438 195.913Z",
+  "M106.176 194.873L98.0421 192.903L87.754 235.397L95.8882 237.366L106.176 194.873Z",
+  "M87.8408 189.056L79.3505 184.425L58.4147 222.808L66.905 227.439L87.8408 189.056Z",
+  "M71.5444 178.838L63.5819 171.253L33.4252 202.91L41.3878 210.495L71.5444 178.838Z",
+  "M58.2896 164.821L51.9185 154.379L14.5961 177.152L20.9672 187.593L58.2896 164.821Z",
+  "M48.9443 147.836L45.1912 135.075L3.24659 147.412L6.99972 160.173L48.9443 147.836Z",
+  "M44.1724 128.938L43.8283 114.759L0.119827 115.82L0.463868 129.998L44.1724 128.938Z",
+  "M44.3613 109.352L47.8648 94.8809L5.37116 84.5928L1.86766 99.0635L44.3613 109.352Z",
+  "M49.563 90.3812L56.9571 76.825L18.5742 55.8893L11.18 69.4455L49.563 90.3812Z",
+  "M59.4839 73.314L70.4267 61.8269L38.7702 31.6703L27.8274 43.1574L59.4839 73.314Z",
+  "M73.4951 59.3251L87.307 50.8976L64.5343 13.5752L50.7224 22.0027L73.4951 59.3251Z",
+  "M90.6772 49.3891L106.414 44.7604L94.0775 2.81575L78.3402 7.44453L90.6772 49.3891Z",
+  "M109.88 44.2086L126.426 43.8071L125.366 0.098614L108.82 0.500089L109.88 44.2086Z",
+  "M129.802 44.1632L145.967 48.0768L156.255 5.58318L140.09 1.66954L129.802 44.1632Z",
+  "M149.087 49.2798L163.709 57.2553L184.645 18.8723L170.023 10.8969L149.087 49.2798Z",
+  "M152.448 160.384L141.06 167.332L154.089 188.685L165.477 181.736L152.448 160.384Z",
+  "M140.881 167.41L128.103 171.168L135.161 195.165L147.939 191.407L140.881 167.41Z",
+  "M127.834 171.202L114.653 171.522L115.26 196.528L128.441 196.209L127.834 171.202Z",
+  "M114.192 171.456L101.624 168.413L95.738 192.724L108.306 195.767L114.192 171.456Z",
+  "M100.907 168.109L89.889 162.1L77.9114 184.059L88.9296 190.069L100.907 168.109Z",
+  "M88.9224 161.353L80.2035 153.047L62.9505 171.158L71.6694 179.464L88.9224 161.353Z",
+  "M79.1143 151.631L73.1721 141.893L51.8195 154.921L57.7617 164.66L79.1143 151.631Z",
+  "M72.2163 139.615L69.2075 129.385L45.2105 136.444L48.2193 146.673L72.2163 139.615Z",
+  "M68.7593 126.163L68.5209 116.339L43.5147 116.946L43.7531 126.77L68.7593 126.163Z",
+  "M69.0161 112.256L71.1176 103.576L46.8064 97.6899L44.7049 106.37L69.0161 112.256Z",
+  "M72.979 98.9209L76.8146 91.8888L54.8552 79.9112L51.0196 86.9432L72.979 98.9209Z",
+  "M80.3506 87.1414L85.2494 81.999L67.1383 64.746L62.2395 69.8884L80.3506 87.1414Z",
+  "M90.5762 77.7753L95.9023 74.5255L82.8738 53.1729L77.5476 56.4227L90.5762 77.7753Z",
+  "M102.889 71.4875L108.114 69.9508L101.056 45.9537L95.831 47.4905L102.889 71.4875Z",
+  "M116.381 68.7043L121.119 68.5894L120.513 43.5832L115.775 43.6981L116.381 68.7043Z",
+  "M130.08 69.5886L134.092 70.56L139.978 46.2488L135.966 45.2775L130.08 69.5886Z",
+  "M143.01 74.0389L146.183 75.7697L158.161 53.8103L154.988 52.0795L143.01 74.0389Z",
+  "M154.273 81.705L156.588 83.9108L173.841 65.7997L171.526 63.5939L154.273 81.705Z",
+  "M163.102 92.0197L164.599 94.4735L185.952 81.445L184.455 78.9911L163.102 92.0197Z",
+  "M168.91 104.243L169.655 106.775L193.652 99.7164L192.907 97.1844L168.91 104.243Z",
+  "M171.325 117.515L171.386 120.001L196.392 119.394L196.331 116.909L171.325 117.515Z",
+  "M170.21 130.922L169.644 133.264L193.955 139.15L194.522 136.808L170.21 130.922Z",
+  "M165.673 143.549L164.523 145.658L186.482 157.636L187.633 155.527L165.673 143.549Z",
+  "M158.032 154.558L156.355 156.318L174.467 173.571L176.143 171.811L158.032 154.558Z"
+].join(" ");
+function BrandIcon({
+  "aria-label": ariaLabel,
+  className,
+  ...props
+}) {
+  return /* @__PURE__ */ jsx4(
+    "svg",
+    {
+      "data-slot": "brand-icon",
+      xmlns: "http://www.w3.org/2000/svg",
+      width: "240",
+      height: "240",
+      viewBox: "0 0 240 240",
+      fill: "none",
+      focusable: "false",
+      role: ariaLabel ? "img" : void 0,
+      "aria-hidden": ariaLabel ? void 0 : true,
+      "aria-label": ariaLabel,
+      className: cn("size-6 shrink-0 text-text-primary dark:text-white", className),
+      ...props,
+      children: /* @__PURE__ */ jsx4("path", { d: CONSCIA_SYMBOL_PATH, fill: "currentColor" })
+    }
+  );
+}
+
+// src/primitives/brand-wordmark.tsx
+import { jsx as jsx5 } from "react/jsx-runtime";
+var CONSCIA_WORDMARK_PATH = [
+  "M485.154 47.9722V40.929H495.867V90.529H485.154V83.3866C481.086 89.041 475.333 91.8186 467.794 91.8186C460.949 91.8186 455.195 89.3386 450.334 84.2794C445.474 79.2202 443.093 72.9706 443.093 65.729C443.093 58.3882 445.474 52.2378 450.334 47.1786C455.195 42.1194 460.949 39.6394 467.794 39.6394C475.333 39.6394 481.086 42.417 485.154 47.9722ZM458.27 77.137C461.246 80.113 465.016 81.601 469.48 81.601C473.944 81.601 477.714 80.113 480.69 77.137C483.666 74.0618 485.154 70.2922 485.154 65.729C485.154 61.1658 483.666 57.3962 480.69 54.4202C477.714 51.345 473.944 49.857 469.48 49.857C465.016 49.857 461.246 51.345 458.27 54.4202C455.294 57.3962 453.806 61.1658 453.806 65.729C453.806 70.2922 455.294 74.0618 458.27 77.137Z",
+  "M436.308 31.5049C433.63 34.1833 429.463 34.1833 426.686 31.5049C424.007 28.7273 424.007 24.5609 426.686 21.8825C429.364 19.1049 433.729 19.1049 436.407 21.8825C439.086 24.5609 439.086 28.7273 436.308 31.5049ZM436.903 90.5288H426.19V40.9289H436.903V90.5288Z",
+  "M399.598 91.8186C392.158 91.8186 385.909 89.3386 380.85 84.2794C375.89 79.2202 373.41 73.0698 373.41 65.729C373.41 58.289 375.89 52.1386 380.85 47.1786C385.909 42.1194 392.158 39.6394 399.598 39.6394C409.221 39.6394 417.752 44.5994 421.72 52.4362L412.494 57.793C410.213 53.0314 405.451 50.1546 399.499 50.1546C395.134 50.1546 391.464 51.6426 388.488 54.6186C385.611 57.5946 384.123 61.265 384.123 65.729C384.123 70.193 385.611 73.8634 388.488 76.8394C391.464 79.8154 395.134 81.3034 399.499 81.3034C405.352 81.3034 410.312 78.3274 412.693 73.665L421.918 78.9226C417.653 86.8586 409.221 91.8186 399.598 91.8186Z",
+  "M344.816 54.6186C344.816 57.8922 348.982 59.5786 354.141 61.0666C361.779 62.753 371.699 65.9274 371.501 76.5418C371.501 81.3034 369.616 85.073 365.945 87.7514C362.275 90.4298 357.712 91.8186 352.157 91.8186C342.336 91.8186 335.094 87.4538 331.92 80.2122L341.146 74.8554C342.832 79.617 346.502 81.9978 352.157 81.9978C357.811 81.9978 360.589 80.113 360.589 76.4426C360.589 73.2682 356.422 71.3834 351.165 70.0938C343.725 68.209 333.706 65.233 333.904 54.817C333.904 50.2538 335.59 46.5834 339.062 43.8058C342.534 41.0282 346.899 39.6394 352.058 39.6394C360.291 39.6394 366.937 43.5082 370.409 49.9562L361.382 55.0154C359.696 51.2458 356.522 49.361 352.058 49.361C347.99 49.361 344.816 51.1466 344.816 54.6186Z",
+  "M308.082 39.6394C319.49 39.6394 327.129 47.377 327.129 60.0746V90.529H316.415V61.1658C316.415 53.7258 312.149 49.6586 305.305 49.6586C297.765 49.6586 292.706 54.321 292.706 63.9434V90.529H281.993V40.929H292.706V47.2778C295.98 42.2186 301.039 39.6394 308.082 39.6394Z",
+  "M249.588 91.8186C242.347 91.8186 236.097 89.3386 231.038 84.2794C225.979 79.2202 223.399 73.0698 223.399 65.729C223.399 58.3882 225.979 52.2378 231.038 47.1786C236.097 42.1194 242.347 39.6394 249.588 39.6394C256.929 39.6394 263.079 42.1194 268.139 47.1786C273.198 52.2378 275.777 58.3882 275.777 65.729C275.777 73.0698 273.198 79.2202 268.139 84.2794C263.079 89.3386 256.929 91.8186 249.588 91.8186ZM238.577 76.9386C241.553 79.9146 245.223 81.4026 249.588 81.4026C253.953 81.4026 257.623 79.9146 260.599 76.9386C263.575 73.9626 265.063 70.193 265.063 65.729C265.063 61.265 263.575 57.4954 260.599 54.5194C257.623 51.5434 253.953 50.0554 249.588 50.0554C245.223 50.0554 241.553 51.5434 238.577 54.5194C235.601 57.4954 234.113 61.265 234.113 65.729C234.113 70.193 235.601 73.9626 238.577 76.9386Z",
+  "M191.106 91.8184C180.69 91.8184 171.96 88.3464 165.116 81.5017C158.271 74.5577 154.799 66.0265 154.799 55.8089C154.799 45.5913 158.271 37.0601 165.116 30.2153C171.96 23.2713 180.69 19.7993 191.106 19.7993C203.704 19.7993 215.013 26.1481 220.965 36.3657L211.045 42.1193C207.375 35.2745 199.836 30.9097 191.106 30.9097C183.666 30.9097 177.714 33.2905 173.052 37.9529C168.488 42.6153 166.207 48.5673 166.207 55.8089C166.207 63.0505 168.488 69.0025 173.052 73.6649C177.714 78.3273 183.666 80.7081 191.106 80.7081C199.836 80.7081 207.474 76.3433 211.045 69.4985L220.965 75.1529C218.088 80.2121 213.922 84.2793 208.565 87.3544C203.308 90.3304 197.455 91.8184 191.106 91.8184Z",
+  "M80.3374 30.1243L81.463 31.1965L95.536 16.4235L94.4105 15.3512L80.3374 30.1243Z",
+  "M86.3032 37.1965L87.1231 38.5402L104.54 27.913L103.72 26.5693L86.3032 37.1965Z",
+  "M90.2339 45.5579L90.6918 47.1146L110.266 41.3573L109.808 39.8006L90.2339 45.5579Z",
+  "M91.8765 54.6333L91.9179 56.3381L112.315 55.8431L112.274 54.1384L91.8765 54.6333Z",
+  "M91.1245 63.8054L90.6944 65.582L110.525 70.3832L110.955 68.6065L91.1245 63.8054Z",
+  "M88.0532 72.4561L87.0963 74.2104L105.008 83.9804L105.965 82.2261L88.0532 72.4561Z",
+  "M82.8853 80.0098L81.3501 81.6213L96.1232 95.6944L97.6583 94.0829L82.8853 80.0098Z",
+  "M75.9854 85.9727L73.8334 87.2857L84.4606 104.703L86.6126 103.39L75.9854 85.9727Z",
+  "M67.8301 89.9714L65.0521 90.7885L70.8094 110.363L73.5873 109.546L67.8301 89.9714Z",
+  "M58.9707 91.7705L55.6136 91.852L56.1085 112.249L59.4656 112.168L58.9707 91.7705Z",
+  "M49.9814 91.2849L46.1855 90.3659L41.3844 110.196L45.1803 111.115L49.9814 91.2849Z",
+  "M41.4253 88.5703L37.4631 86.4092L27.6931 104.321L31.6553 106.482L41.4253 88.5703Z",
+  "M33.8188 83.8022L30.103 80.2624L16.0299 95.0355L19.7458 98.5753L33.8188 83.8022Z",
+  "M27.6348 77.2605L24.6616 72.3878L7.24451 83.015L10.2177 87.8878L27.6348 77.2605Z",
+  "M23.271 69.334L21.5195 63.3792L1.94538 69.1364L3.69684 75.0912L23.271 69.334Z",
+  "M21.0474 60.5151L20.8868 53.8985L0.489511 54.3934L0.650063 61.0101L21.0474 60.5151Z",
+  "M21.1338 51.3752L22.7688 44.6222L2.93837 39.8211L1.30341 46.5741L21.1338 51.3752Z",
+  "M23.5605 42.522L27.0111 36.1957L9.09909 26.4258L5.6485 32.752L23.5605 42.522Z",
+  "M28.1909 34.5574L33.2976 29.1967L18.5246 15.1236L13.4179 20.4843L28.1909 34.5574Z",
+  "M34.7305 28.0295L41.176 24.0967L30.5488 6.67961L24.1032 10.6124L34.7305 28.0295Z",
+  "M42.749 23.3923L50.0931 21.2323L44.3358 1.65808L36.9918 3.81818L42.749 23.3923Z",
+  "M51.7109 20.9749L59.4323 20.7875L58.9373 0.390197L51.216 0.577552L51.7109 20.9749Z",
+  "M61.0078 20.9536L68.5512 22.78L73.3523 2.9496L65.8089 1.12323L61.0078 20.9536Z",
+  "M70.0063 23.3413L76.83 27.0632L86.6 9.15115L79.7764 5.42926L70.0063 23.3413Z",
+  "M71.5737 75.1902L66.2594 78.4328L72.3393 88.3974L77.6537 85.1547L71.5737 75.1902Z",
+  "M66.1782 78.4688L60.2153 80.2226L63.5091 91.4212L69.472 89.6674L66.1782 78.4688Z",
+  "M60.0874 80.2388L53.9362 80.388L54.2193 92.0576L60.3706 91.9083L60.0874 80.2388Z",
+  "M53.7231 80.3569L47.8581 78.937L45.1113 90.2822L50.9764 91.7021L53.7231 80.3569Z",
+  "M47.5229 78.7954L42.3811 75.9908L36.7916 86.2386L41.9334 89.0431L47.5229 78.7954Z",
+  "M41.9287 75.6421L37.8599 71.7661L29.8085 80.2179L33.8773 84.0939L41.9287 75.6421Z",
+  "M37.3511 71.1057L34.578 66.561L24.6135 72.641L27.3865 77.1857L37.3511 71.1057Z",
+  "M34.1333 65.498L32.7292 60.7242L21.5306 64.0181L22.9347 68.7918L34.1333 65.498Z",
+  "M32.52 59.2202L32.4088 54.6358L20.7392 54.9189L20.8505 59.5034L32.52 59.2202Z",
+  "M32.6411 52.7302L33.6218 48.6797L22.2766 45.9329L21.2959 49.9834L32.6411 52.7302Z",
+  "M34.4888 46.5073L36.2787 43.2257L26.031 37.6361L24.241 40.9178L34.4888 46.5073Z",
+  "M37.9297 41.0103L40.2158 38.6105L31.7639 30.5591L29.4779 32.9589L37.9297 41.0103Z",
+  "M42.7012 36.6394L45.1867 35.1228L39.1067 25.1583L36.6212 26.6749L42.7012 36.6394Z",
+  "M48.4478 33.7051L50.8861 32.9879L47.5923 21.7893L45.1539 22.5064L48.4478 33.7051Z",
+  "M54.7437 32.4062L56.9548 32.3526L56.6716 20.683L54.4605 20.7367L54.7437 32.4062Z",
+  "M61.1377 32.8188L63.01 33.2721L65.7568 21.9269L63.8845 21.4736L61.1377 32.8188Z",
+  "M67.1694 34.8958L68.6503 35.7035L74.2398 25.4557L72.759 24.648L67.1694 34.8958Z",
+  "M72.4282 38.4731L73.5088 39.5025L81.5602 31.0507L80.4796 30.0213L72.4282 38.4731Z",
+  "M76.5459 43.2869L77.2446 44.432L87.2092 38.352L86.5104 37.2069L76.5459 43.2869Z",
+  "M79.2554 48.9905L79.6029 50.1721L90.8015 46.8783L90.454 45.6967L79.2554 48.9905Z",
+  "M80.3833 55.1848L80.4114 56.3446L92.081 56.0615L92.0528 54.9017L80.3833 55.1848Z",
+  "M79.8657 61.4412L79.6012 62.5339L90.9464 65.2807L91.2109 64.188L79.8657 61.4412Z",
+  "M77.7466 67.3337L77.2096 68.3182L87.4573 73.9077L87.9943 72.9233L77.7466 67.3337Z",
+  "M74.1807 72.4714L73.3984 73.2926L81.8502 81.344L82.6325 80.5228L74.1807 72.4714Z"
+].join(" ");
+function BrandWordmark({
+  "aria-label": ariaLabel,
+  className,
+  ...props
+}) {
+  return /* @__PURE__ */ jsx5(
+    "svg",
+    {
+      "data-slot": "brand-wordmark",
+      xmlns: "http://www.w3.org/2000/svg",
+      width: "496",
+      height: "113",
+      viewBox: "0 0 496 113",
+      fill: "none",
+      focusable: "false",
+      role: ariaLabel ? "img" : void 0,
+      "aria-hidden": ariaLabel ? void 0 : true,
+      "aria-label": ariaLabel,
+      className: cn(
+        "h-auto w-36 shrink-0 text-text-primary dark:text-white",
+        className
+      ),
+      ...props,
+      children: /* @__PURE__ */ jsx5("path", { d: CONSCIA_WORDMARK_PATH, fill: "currentColor" })
+    }
+  );
+}
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/switch/index.parts.mjs
+var index_parts_exports2 = {};
+__export(index_parts_exports2, {
+  Root: () => SwitchRoot,
+  Thumb: () => SwitchThumb
+});
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/switch/root/SwitchRoot.mjs
+import * as React5 from "react";
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/switch/root/SwitchRootContext.mjs
+import * as React4 from "react";
+var SwitchRootContext = /* @__PURE__ */ React4.createContext(void 0);
+if (true) SwitchRootContext.displayName = "SwitchRootContext";
+function useSwitchRootContext() {
+  const context = React4.useContext(SwitchRootContext);
+  if (context === void 0) {
+    throw new Error(true ? "Base UI: SwitchRootContext is missing. Switch parts must be placed within <Switch.Root>." : formatErrorMessage_default(63));
+  }
+  return context;
+}
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/switch/stateAttributesMapping.mjs
+var stateAttributesMapping = {
+  ...fieldValidityMapping,
+  checked(value) {
+    if (value) {
+      return {
+        "data-checked": ""
+      };
+    }
+    return {
+      "data-unchecked": ""
+    };
+  }
+};
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/switch/root/SwitchRoot.mjs
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+var SwitchRoot = /* @__PURE__ */ React5.forwardRef(function SwitchRoot2(componentProps, forwardedRef) {
+  const {
+    checked: checkedProp,
+    className,
+    defaultChecked,
+    "aria-labelledby": ariaLabelledByProp,
+    form,
+    id: idProp,
+    inputRef: externalInputRef,
+    name: nameProp,
+    nativeButton = false,
+    onCheckedChange,
+    readOnly = false,
+    required = false,
+    disabled: disabledProp = false,
+    render,
+    uncheckedValue,
+    value,
+    style,
+    ...elementProps
+  } = componentProps;
+  const {
+    clearErrors
+  } = useFormContext();
+  const {
+    state: fieldState,
+    setTouched,
+    setDirty,
+    validityData,
+    setFilled,
+    setFocused,
+    validationMode,
+    disabled: fieldDisabled,
+    name: fieldName,
+    validation
+  } = useFieldRootContext();
+  const {
+    labelId
+  } = useLabelableContext();
+  const disabled = fieldDisabled || disabledProp;
+  const name = fieldName ?? nameProp;
+  const inputRef = React5.useRef(null);
+  const handleInputRef = useMergedRefs(inputRef, externalInputRef, validation.inputRef);
+  const switchRef = React5.useRef(null);
+  const id = useBaseUiId();
+  const controlId = useLabelableId({
+    id: idProp,
+    implicit: false,
+    controlRef: switchRef
+  });
+  const hiddenInputId = nativeButton ? void 0 : controlId;
+  const [checked, setCheckedState] = useControlled({
+    controlled: checkedProp,
+    default: Boolean(defaultChecked),
+    name: "Switch",
+    state: "checked"
+  });
+  useRegisterFieldControl(switchRef, id, checked, void 0, !disabled, nameProp);
+  useIsoLayoutEffect(() => {
+    if (inputRef.current) {
+      setFilled(inputRef.current.checked);
+    }
+  }, [setFilled]);
+  useValueChanged(checked, () => {
+    clearErrors(name);
+    setDirty(checked !== validityData.initialValue);
+    setFilled(checked);
+    validation.change(checked);
+  });
+  const {
+    getButtonProps,
+    buttonRef
+  } = useButton({
+    disabled,
+    native: nativeButton
+  });
+  const ariaLabelledBy = useAriaLabelledBy(ariaLabelledByProp, labelId, inputRef, !nativeButton, hiddenInputId);
+  const rootProps = {
+    id: nativeButton ? controlId : id,
+    role: "switch",
+    "aria-checked": checked,
+    "aria-readonly": readOnly || void 0,
+    "aria-required": required || void 0,
+    "aria-labelledby": ariaLabelledBy,
+    onFocus() {
+      if (!disabled) {
+        setFocused(true);
+      }
+    },
+    onBlur() {
+      const element2 = inputRef.current;
+      if (!element2 || disabled) {
+        return;
+      }
+      setTouched(true);
+      setFocused(false);
+      if (validationMode === "onBlur") {
+        validation.commit(element2.checked);
+      }
+    },
+    onClick(event) {
+      if (readOnly || disabled) {
+        return;
+      }
+      event.preventDefault();
+      const input = inputRef.current;
+      if (!input) {
+        return;
+      }
+      dispatchClickWithModifiers(input, event);
+    }
+  };
+  const inputProps = {
+    ...validation.getValidationProps(disabled),
+    checked,
+    disabled,
+    form,
+    id: hiddenInputId,
+    name,
+    required,
+    style: name ? visuallyHiddenInput : visuallyHidden,
+    tabIndex: -1,
+    type: "checkbox",
+    "aria-hidden": true,
+    ref: handleInputRef,
+    onChange(event) {
+      if (event.nativeEvent.defaultPrevented) {
+        return;
+      }
+      if (readOnly) {
+        event.preventDefault();
+        return;
+      }
+      const nextChecked = event.currentTarget.checked;
+      const eventDetails = createChangeEventDetails(reason_parts_exports.none, event.nativeEvent);
+      onCheckedChange?.(nextChecked, eventDetails);
+      if (eventDetails.isCanceled) {
+        return;
+      }
+      setCheckedState(nextChecked);
+    },
+    onClick(event) {
+      event.stopPropagation();
+    },
+    onFocus() {
+      switchRef.current?.focus();
+    },
+    // React <19 sets an empty value if `undefined` is passed explicitly
+    // To avoid this, we only set the value if it's defined
+    ...value !== void 0 ? {
+      value
+    } : EMPTY_OBJECT
+  };
+  const state = React5.useMemo(() => ({
+    ...fieldState,
+    checked,
+    disabled,
+    readOnly,
+    required
+  }), [fieldState, checked, disabled, readOnly, required]);
+  const element = useRenderElement("span", componentProps, {
+    state,
+    ref: [forwardedRef, switchRef, buttonRef],
+    props: [rootProps, elementProps, getButtonProps, (props) => validation.getValidationProps(disabled, props)],
+    stateAttributesMapping
+  });
+  return /* @__PURE__ */ _jsxs(SwitchRootContext.Provider, {
+    value: state,
+    children: [element, !checked && name && uncheckedValue !== void 0 && /* @__PURE__ */ _jsx("input", {
+      type: "hidden",
+      form,
+      name,
+      value: uncheckedValue,
+      disabled
+    }), /* @__PURE__ */ _jsx("input", {
+      ...inputProps,
+      suppressHydrationWarning: true
+    })]
+  });
+});
+if (true) SwitchRoot.displayName = "SwitchRoot";
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/switch/thumb/SwitchThumb.mjs
+import * as React6 from "react";
+var SwitchThumb = /* @__PURE__ */ React6.forwardRef(function SwitchThumb2(componentProps, forwardedRef) {
+  const {
+    render,
+    className,
+    style,
+    ...elementProps
+  } = componentProps;
+  const state = useSwitchRootContext();
+  return useRenderElement("span", componentProps, {
+    state,
+    ref: forwardedRef,
+    stateAttributesMapping,
+    props: elementProps
+  });
+});
+if (true) SwitchThumb.displayName = "SwitchThumb";
+
+// src/primitives/switch.tsx
+import { jsx as jsx6 } from "react/jsx-runtime";
+function Switch({ className, size = "default", ...props }) {
+  return /* @__PURE__ */ jsx6(index_parts_exports2.Root, { "data-slot": "switch", "data-size": size, className: cn("peer group/switch inline-flex shrink-0 items-center rounded-full border border-transparent shadow-xs transition-all outline-none focus-visible:border-focus focus-visible:ring-[3px] focus-visible:ring-focus/50 disabled:cursor-not-allowed disabled:opacity-50 data-[size=default]:h-[1.15rem] data-[size=default]:w-8 data-[size=sm]:h-3.5 data-[size=sm]:w-6 data-checked:bg-action data-unchecked:bg-control-border", className), ...props, children: /* @__PURE__ */ jsx6(index_parts_exports2.Thumb, { "data-slot": "switch-thumb", className: "pointer-events-none block rounded-full bg-canvas transition-transform group-data-[size=default]/switch:size-4 group-data-[size=sm]/switch:size-3 data-checked:translate-x-[calc(100%-2px)] data-unchecked:translate-x-0" }) });
+}
+
+// src/primitives/textarea.tsx
+import { jsx as jsx7 } from "react/jsx-runtime";
+function Textarea({ className, ...props }) {
+  return /* @__PURE__ */ jsx7(
+    "textarea",
+    {
+      "data-slot": "textarea",
+      className: cn("ds-type-control min-h-28 w-full rounded-[var(--ds-field-control-radius)] border border-control-border bg-surface-control px-[var(--ds-field-control-padding-x)] py-3 outline-none transition-colors placeholder:text-text-supporting focus-visible:border-focus focus-visible:ring-[3px] focus-visible:ring-focus/50 aria-invalid:border-danger aria-invalid:ring-danger/20 dark:aria-invalid:ring-danger/40 disabled:cursor-not-allowed disabled:opacity-50", className),
+      ...props
+    }
+  );
+}
+
+// src/primitives/compat.tsx
+import { jsx as jsx8, jsxs as jsxs2 } from "react/jsx-runtime";
+var ConsciaButton = Button;
+var ConsciaIconButton = IconButton;
+var ConsciaCard = Card;
+var ConsciaCardContent = CardContent;
+var ConsciaCardDescription = CardDescription;
+function ConsciaCardHeader({
+  actionRight,
+  className,
+  children,
+  ...props
+}) {
+  if (!actionRight) {
+    return /* @__PURE__ */ jsx8(CardHeader, { className, ...props, children });
+  }
+  return /* @__PURE__ */ jsxs2(
+    CardHeader,
+    {
+      className: cn(
+        "grid grid-cols-[minmax(0,1fr)_auto] items-start gap-4",
+        className
+      ),
+      ...props,
+      children: [
+        /* @__PURE__ */ jsx8("div", { className: "grid gap-2", children }),
+        /* @__PURE__ */ jsx8("div", { className: "justify-self-end", children: actionRight })
+      ]
+    }
+  );
+}
+var ConsciaCardTitle = CardTitle;
+var ConsciaCardFooter = CardFooter;
+var ConsciaCheckbox = Checkbox;
+var ConsciaInput = Input;
+var ConsciaSwitch = Switch;
+var ConsciaTextarea = Textarea;
+var ConsciaSelect = Select;
+var ConsciaSelectContent = SelectContent;
+var ConsciaSelectGroup = SelectGroup;
+var ConsciaSelectItem = SelectItem;
+var ConsciaSelectTrigger = SelectTrigger;
+var ConsciaSelectValue = SelectValue;
+var ConsciaTable = Table;
+var ConsciaTableBody = TableBody;
+var ConsciaTableCell = TableCell;
+var ConsciaTableHeader = TableHeader;
+var ConsciaTableHead = TableHead;
+var ConsciaTableRow = TableRow;
+
+// src/primitives/field.tsx
+import { jsx as jsx9 } from "react/jsx-runtime";
+function Field({
+  className,
+  ...props
+}) {
+  return /* @__PURE__ */ jsx9(
+    "div",
+    {
+      "data-slot": "field",
+      className: cn("grid gap-[var(--ds-field-label-gap)]", className),
+      ...props
+    }
+  );
+}
+function FieldGroup({
+  className,
+  ...props
+}) {
+  return /* @__PURE__ */ jsx9(
+    "div",
+    {
+      "data-slot": "field-group",
+      className: cn("grid gap-[var(--ds-field-gap)]", className),
+      ...props
+    }
+  );
+}
+function FieldLabel({
+  className,
+  ...props
+}) {
+  return /* @__PURE__ */ jsx9(
+    "label",
+    {
+      "data-slot": "field-label",
+      className: cn("ds-type-label text-text-primary", className),
+      ...props
+    }
+  );
+}
+function FieldDescription({
+  className,
+  ...props
+}) {
+  return /* @__PURE__ */ jsx9(
+    "p",
+    {
+      "data-slot": "field-description",
+      className: cn("ds-type-metadata mt-[var(--ds-field-message-gap)] text-text-supporting", className),
+      ...props
+    }
+  );
+}
+function FieldError({
+  className,
+  ...props
+}) {
+  return /* @__PURE__ */ jsx9(
+    "p",
+    {
+      "data-slot": "field-error",
+      className: cn("ds-type-metadata mt-[var(--ds-field-message-gap)] font-medium text-danger-foreground", className),
+      ...props
+    }
+  );
+}
+
+// src/primitives/filter-chip.tsx
+import { XIcon } from "lucide-react";
+import { jsx as jsx10, jsxs as jsxs3 } from "react/jsx-runtime";
+function FilterChip({
+  className,
+  label,
+  onRemove,
+  removeLabel,
+  value,
+  ...props
+}) {
+  const fallbackRemoveLabel = typeof label === "string" ? `Remove ${label} filter` : "Remove filter";
+  return /* @__PURE__ */ jsxs3(
+    "div",
+    {
+      "data-slot": "filter-chip",
+      className: cn(
+        "inline-flex min-w-0 max-w-full items-center gap-1 rounded-full border border-border-default bg-surface-muted px-2 py-1 text-sm text-text-primary",
+        className
+      ),
+      ...props,
+      children: [
+        /* @__PURE__ */ jsx10("span", { className: "shrink-0 text-text-supporting", children: label }),
+        value !== void 0 ? /* @__PURE__ */ jsx10("span", { className: "min-w-0 truncate font-medium", children: value }) : null,
+        onRemove ? /* @__PURE__ */ jsx10(
+          IconButton,
+          {
+            type: "button",
+            size: "sm",
+            variant: "ghost",
+            "aria-label": removeLabel ?? fallbackRemoveLabel,
+            onClick: onRemove,
+            className: "-mr-1 size-5 rounded-full text-text-supporting hover:bg-surface-control-hover hover:text-text-primary",
+            children: /* @__PURE__ */ jsx10(XIcon, { "aria-hidden": "true", className: "size-3" })
+          }
+        ) : null
+      ]
+    }
+  );
+}
+
+// src/primitives/form-select.tsx
+import * as React7 from "react";
+import { jsx as jsx11, jsxs as jsxs4 } from "react/jsx-runtime";
+var emptyValue = "__conscia_empty_select_value__";
+function toSelectValue(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  return value === "" ? emptyValue : value;
+}
+function fromSelectValue(value) {
+  return value === emptyValue ? "" : value;
+}
+function FormSelect({
+  name,
+  id,
+  value,
+  defaultValue,
+  required,
+  disabled,
+  placeholder,
+  options,
+  className,
+  triggerClassName,
+  contentClassName,
+  onValueChange,
+  onClick,
+  "aria-label": ariaLabel
+}) {
+  const [internalValue, setInternalValue] = React7.useState(defaultValue ?? "");
+  const currentValue = value ?? internalValue;
+  function handleValueChange(nextValue) {
+    const actualValue = fromSelectValue(nextValue);
+    if (value === void 0) {
+      setInternalValue(actualValue);
+    }
+    onValueChange?.(actualValue);
+  }
+  return /* @__PURE__ */ jsx11("div", { className: cn("min-w-0", className), onClick, children: /* @__PURE__ */ jsxs4(
+    Select,
+    {
+      name,
+      value: toSelectValue(currentValue),
+      required,
+      disabled,
+      onValueChange: handleValueChange,
+      children: [
+        /* @__PURE__ */ jsx11(SelectTrigger, { id, "aria-label": ariaLabel, className: triggerClassName, children: /* @__PURE__ */ jsx11(SelectValue, { placeholder }) }),
+        /* @__PURE__ */ jsx11(SelectContent, { className: contentClassName, children: /* @__PURE__ */ jsx11(SelectGroup, { children: options.map((option) => /* @__PURE__ */ jsx11(
+          SelectItem,
+          {
+            value: toSelectValue(option.value) ?? emptyValue,
+            disabled: option.disabled,
+            children: option.label
+          },
+          option.value
+        )) }) })
+      ]
+    }
+  ) });
+}
+var ConsciaFormSelect = FormSelect;
+
+// src/primitives/label.tsx
+import { jsx as jsx12 } from "react/jsx-runtime";
+function Label({
+  className,
+  ...props
+}) {
+  return /* @__PURE__ */ jsx12("label", { "data-slot": "label", className: cn("ds-type-label flex items-center gap-2 text-text-primary select-none group-data-[disabled=true]:pointer-events-none group-data-[disabled=true]:opacity-50 peer-disabled:cursor-not-allowed peer-disabled:opacity-50", className), ...props });
+}
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/popover/index.parts.mjs
+var index_parts_exports3 = {};
+__export(index_parts_exports3, {
+  Arrow: () => PopoverArrow,
+  Backdrop: () => PopoverBackdrop,
+  Close: () => PopoverClose,
+  Description: () => PopoverDescription,
+  Handle: () => PopoverHandle,
+  Popup: () => PopoverPopup,
+  Portal: () => PopoverPortal,
+  Positioner: () => PopoverPositioner,
+  Root: () => PopoverRoot,
+  Title: () => PopoverTitle,
+  Trigger: () => PopoverTrigger,
+  Viewport: () => PopoverViewport,
+  createHandle: () => createPopoverHandle
+});
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/popover/root/PopoverRoot.mjs
+import * as React10 from "react";
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/popover/root/PopoverRootContext.mjs
+import * as React8 from "react";
+var PopoverRootContext = /* @__PURE__ */ React8.createContext(void 0);
+if (true) PopoverRootContext.displayName = "PopoverRootContext";
+function usePopoverRootContext(optional) {
+  const context = React8.useContext(PopoverRootContext);
+  if (context === void 0 && !optional) {
+    throw new Error(true ? "Base UI: PopoverRootContext is missing. Popover parts must be placed within <Popover.Root>." : formatErrorMessage_default(47));
+  }
+  return context;
+}
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/popover/store/PopoverStore.mjs
+import * as React9 from "react";
+import * as ReactDOM from "react-dom";
+var selectors = {
+  ...popupStoreSelectors,
+  disabled: (state) => state.disabled,
+  instantType: (state) => state.instantType,
+  openMethod: (state) => state.openMethod,
+  openChangeReason: (state) => state.openChangeReason,
+  modal: (state) => state.modal,
+  focusManagerModal: (state) => state.focusManagerModal,
+  stickIfOpen: (state) => state.stickIfOpen,
+  titleElementId: (state) => state.titleElementId,
+  descriptionElementId: (state) => state.descriptionElementId,
+  openOnHover: (state) => state.openOnHover,
+  closeDelay: (state) => state.closeDelay,
+  adaptiveOrigin: (state) => state.adaptiveOrigin
+};
+var PopoverStore = class extends ReactStore {
+  constructor(initialState, floatingId, nested) {
+    const triggerElements = new PopupTriggerMap();
+    super(createInitialState(initialState, triggerElements, floatingId, nested), createInitialContext(triggerElements), selectors);
+    __publicField(this, "setOpen", (nextOpen, eventDetails) => {
+      const isHover = eventDetails.reason === reason_parts_exports.triggerHover;
+      const isKeyboardClick = eventDetails.reason === reason_parts_exports.triggerPress && eventDetails.event.detail === 0;
+      const isDismissClose = !nextOpen && (eventDetails.reason === reason_parts_exports.escapeKey || eventDetails.reason == null);
+      const shouldPreventUnmountOnClose = attachPreventUnmountOnClose(eventDetails);
+      const activeTriggerId = this.select("activeTriggerId");
+      if (!nextOpen && eventDetails.reason === reason_parts_exports.closePress && eventDetails.trigger == null && activeTriggerId != null) {
+        eventDetails.trigger = this.context.triggerElements.getById(activeTriggerId) ?? this.select("activeTriggerElement") ?? void 0;
+      }
+      this.context.onOpenChange?.(nextOpen, eventDetails);
+      if (eventDetails.isCanceled) {
+        return;
+      }
+      this.state.floatingRootContext.dispatchOpenChange(nextOpen, eventDetails);
+      const changeState = () => {
+        const updatedState = {
+          open: nextOpen,
+          openChangeReason: eventDetails.reason
+        };
+        setPopupOpenState(updatedState, nextOpen, eventDetails.trigger, shouldPreventUnmountOnClose());
+        this.update(updatedState);
+      };
+      if (isHover) {
+        this.set("stickIfOpen", true);
+        this.context.stickIfOpenTimeout.start(PATIENT_CLICK_THRESHOLD, () => {
+          this.set("stickIfOpen", false);
+        });
+        ReactDOM.flushSync(changeState);
+      } else {
+        changeState();
+      }
+      let instantType;
+      if (isKeyboardClick) {
+        instantType = "click";
+      } else if (isDismissClose) {
+        instantType = "dismiss";
+      } else if (eventDetails.reason === reason_parts_exports.focusOut) {
+        instantType = "focus";
+      }
+      this.set("instantType", instantType);
+    });
+  }
+};
+function createNullPopoverStore() {
+  const triggerElements = new PopupTriggerMap();
+  const store = new NullStore(Object.freeze(createInitialState(void 0, triggerElements)), Object.freeze(createInitialContext(triggerElements)), selectors);
+  return Object.assign(store, {
+    setOpen: NOOP
+  });
+}
+function createInitialState(initialState, triggerElements, floatingId, nested = false) {
+  const state = {
+    ...createInitialPopupStoreState(),
+    disabled: false,
+    modal: false,
+    focusManagerModal: false,
+    instantType: void 0,
+    openMethod: null,
+    openChangeReason: null,
+    titleElementId: void 0,
+    descriptionElementId: void 0,
+    stickIfOpen: true,
+    openOnHover: false,
+    closeDelay: 0,
+    adaptiveOrigin: void 0,
+    ...initialState
+  };
+  if (state.open && initialState?.mounted === void 0) {
+    state.mounted = true;
+  }
+  state.floatingRootContext = createPopupFloatingRootContext(triggerElements, floatingId, nested);
+  return state;
+}
+function createInitialContext(triggerElements) {
+  return {
+    popupRef: /* @__PURE__ */ React9.createRef(),
+    onOpenChange: void 0,
+    onOpenChangeComplete: void 0,
+    triggerFocusTargetRef: /* @__PURE__ */ React9.createRef(),
+    beforeContentFocusGuardRef: /* @__PURE__ */ React9.createRef(),
+    stickIfOpenTimeout: new Timeout(),
+    triggerElements
+  };
+}
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/popover/root/PopoverRoot.mjs
+import { jsx as _jsx2, jsxs as _jsxs2 } from "react/jsx-runtime";
+function PopoverRootComponent({
+  props
+}) {
+  const {
+    children,
+    open: openProp,
+    defaultOpen = false,
+    onOpenChange,
+    onOpenChangeComplete,
+    modal = false,
+    handle,
+    triggerId: triggerIdProp,
+    defaultTriggerId: defaultTriggerIdProp = null
+  } = props;
+  const store = usePopoverRootStore(handle, {
+    modal,
+    open: defaultOpen,
+    openProp,
+    activeTriggerId: defaultTriggerIdProp,
+    triggerIdProp
+  });
+  store.useControlledProp("openProp", openProp);
+  store.useControlledProp("triggerIdProp", triggerIdProp);
+  const open = store.useState("open");
+  const mounted = store.useState("mounted");
+  const payload = store.useState("payload");
+  store.useContextCallback("onOpenChange", onOpenChange);
+  store.useContextCallback("onOpenChangeComplete", onOpenChangeComplete);
+  usePopupRootSync(store, open);
+  useImplicitActiveTrigger(store);
+  const {
+    forceUnmount
+  } = useOpenStateTransitions(open, store, () => {
+    store.update({
+      stickIfOpen: true,
+      openChangeReason: null
+    });
+  });
+  store.useSyncedValues({
+    modal
+  });
+  React10.useEffect(() => {
+    if (!open) {
+      store.context.stickIfOpenTimeout.clear();
+    }
+  }, [store, open]);
+  React10.useImperativeHandle(props.actionsRef, () => ({
+    unmount: forceUnmount,
+    close: () => store.setOpen(false, createChangeEventDetails(reason_parts_exports.imperativeAction))
+  }), [forceUnmount, store]);
+  const shouldRenderInteractions = open || mounted;
+  return /* @__PURE__ */ _jsxs2(PopoverRootContext.Provider, {
+    value: store,
+    children: [handle && /* @__PURE__ */ _jsx2(PopupHandleAttachment, {
+      handle,
+      store
+    }), shouldRenderInteractions && /* @__PURE__ */ _jsx2(PopoverInteractions, {
+      store,
+      modal
+    }), typeof children === "function" ? children({
+      payload
+    }) : children]
+  });
+}
+function PopoverRoot(props) {
+  if (usePopoverRootContext(true)) {
+    return /* @__PURE__ */ _jsx2(PopoverRootComponent, {
+      props
+    });
+  }
+  return /* @__PURE__ */ _jsx2(FloatingTree, {
+    children: /* @__PURE__ */ _jsx2(PopoverRootComponent, {
+      props
+    })
+  });
+}
+function usePopoverRootStore(handle, initialState) {
+  const store = usePopupRootStore((floatingId, nested) => new PopoverStore(initialState, floatingId, nested));
+  React10.useEffect(() => store.context.stickIfOpenTimeout.disposeEffect(), [store]);
+  return store;
+}
+function PopoverInteractions({
+  store,
+  modal
+}) {
+  const floatingRootContext = store.useState("floatingRootContext");
+  const dismiss = useDismiss(floatingRootContext, {
+    outsidePressEvent: {
+      // Ensure `aria-hidden` on outside elements is removed immediately
+      // on outside press when trapping focus.
+      mouse: modal === "trap-focus" ? "sloppy" : "intentional",
+      touch: "sloppy"
+    }
+  });
+  const triggerProps = dismiss.reference;
+  const popupProps = dismiss.floating;
+  usePopupInteractionProps(store, {
+    activeTriggerProps: triggerProps,
+    inactiveTriggerProps: triggerProps,
+    popupProps
+  });
+  return null;
+}
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/popover/trigger/PopoverTrigger.mjs
+import * as React11 from "react";
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/popover/utils/constants.mjs
+var OPEN_DELAY = 300;
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/popover/trigger/PopoverTrigger.mjs
+import { jsx as _jsx3, jsxs as _jsxs3 } from "react/jsx-runtime";
+var PopoverTrigger = /* @__PURE__ */ React11.forwardRef(function PopoverTrigger2(componentProps, forwardedRef) {
+  const {
+    render,
+    className,
+    style,
+    disabled = false,
+    nativeButton = true,
+    handle,
+    payload,
+    openOnHover = false,
+    delay = OPEN_DELAY,
+    closeDelay = 0,
+    id: idProp,
+    ...elementProps
+  } = componentProps;
+  const rootStore = usePopoverRootContext(true);
+  const handleStore = usePopupHandleStore(handle);
+  const store = handleStore ?? rootStore;
+  if (!store) {
+    throw new Error(true ? "Base UI: <Popover.Trigger> must be either used within a <Popover.Root> component or provided with a handle." : formatErrorMessage_default(74));
+  }
+  const thisTriggerId = useBaseUiId(idProp);
+  const isTriggerActive = store.useState("isTriggerActive", thisTriggerId);
+  const floatingContext = store.useState("floatingRootContext");
+  const isOpenedByThisTrigger = store.useState("isOpenedByTrigger", thisTriggerId);
+  const popupId = store.useState("triggerPopupId", thisTriggerId);
+  const triggerElementRef = React11.useRef(null);
+  const {
+    registerTrigger,
+    isMountedByThisTrigger
+  } = useTriggerDataForwarding(thisTriggerId, triggerElementRef, store, {
+    payload,
+    disabled,
+    openOnHover,
+    closeDelay
+  });
+  const openReason = store.useState("openChangeReason");
+  const stickIfOpen = store.useState("stickIfOpen");
+  const openMethod = store.useState("openMethod");
+  const focusManagerModal = store.useState("focusManagerModal");
+  const hoverProps = useHoverReferenceInteraction(floatingContext, {
+    enabled: !disabled && openOnHover && (openMethod !== "touch" || openReason !== reason_parts_exports.triggerPress),
+    mouseOnly: true,
+    move: false,
+    handleClose: safePolygon(),
+    restMs: delay,
+    delay: {
+      close: closeDelay
+    },
+    triggerElementRef,
+    isActiveTrigger: isTriggerActive,
+    isClosing: () => store.select("transitionStatus") === "ending"
+  });
+  const click = useClick(floatingContext, {
+    stickIfOpen
+  });
+  const interactionTypeProps = useOpenMethodTriggerProps(() => store.select("open"), (interactionType) => {
+    store.set("openMethod", interactionType);
+  });
+  const rootTriggerProps = store.useState("triggerProps", isMountedByThisTrigger);
+  const {
+    getButtonProps,
+    buttonRef
+  } = useButton({
+    disabled,
+    native: nativeButton
+  });
+  const stateAttributesMapping2 = {
+    open(value) {
+      if (value && openReason === reason_parts_exports.triggerPress) {
+        return pressableTriggerOpenStateMapping.open(value);
+      }
+      return triggerOpenStateMapping.open(value);
+    }
+  };
+  const {
+    preFocusGuardRef,
+    handlePreFocusGuardFocus,
+    handleFocusTargetFocus
+  } = useTriggerFocusGuards(store, triggerElementRef);
+  const state = {
+    disabled,
+    open: isOpenedByThisTrigger
+  };
+  const element = useRenderElement("button", componentProps, {
+    state,
+    ref: [buttonRef, forwardedRef, registerTrigger, triggerElementRef],
+    props: [click.reference, hoverProps, rootTriggerProps, interactionTypeProps, {
+      [CLICK_TRIGGER_IDENTIFIER]: "",
+      id: thisTriggerId,
+      "aria-haspopup": "dialog",
+      "aria-expanded": isOpenedByThisTrigger,
+      "aria-controls": popupId
+    }, elementProps, getButtonProps],
+    stateAttributesMapping: stateAttributesMapping2
+  });
+  const keyedElement = /* @__PURE__ */ _jsx3(React11.Fragment, {
+    children: element
+  }, thisTriggerId);
+  if (isMountedByThisTrigger && !focusManagerModal) {
+    return /* @__PURE__ */ _jsxs3(React11.Fragment, {
+      children: [/* @__PURE__ */ _jsx3(FocusGuard, {
+        ref: preFocusGuardRef,
+        onFocus: handlePreFocusGuardFocus
+      }), keyedElement, /* @__PURE__ */ _jsx3(FocusGuard, {
+        ref: store.context.triggerFocusTargetRef,
+        onFocus: handleFocusTargetFocus
+      })]
+    });
+  }
+  return keyedElement;
+});
+if (true) PopoverTrigger.displayName = "PopoverTrigger";
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/popover/portal/PopoverPortal.mjs
+import * as React13 from "react";
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/popover/portal/PopoverPortalContext.mjs
+import * as React12 from "react";
+var PopoverPortalContext = /* @__PURE__ */ React12.createContext(void 0);
+if (true) PopoverPortalContext.displayName = "PopoverPortalContext";
+function usePopoverPortalContext() {
+  const value = React12.useContext(PopoverPortalContext);
+  if (value === void 0) {
+    throw new Error(true ? "Base UI: <Popover.Portal> is missing." : formatErrorMessage_default(45));
+  }
+  return value;
+}
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/popover/portal/PopoverPortal.mjs
+import { jsx as _jsx4 } from "react/jsx-runtime";
+var PopoverPortal = /* @__PURE__ */ React13.forwardRef(function PopoverPortal2(props, forwardedRef) {
+  const {
+    keepMounted = false,
+    ...portalProps
+  } = props;
+  const store = usePopoverRootContext();
+  const mounted = store.useState("mounted");
+  const shouldRender = mounted || keepMounted;
+  if (!shouldRender) {
+    return null;
+  }
+  return /* @__PURE__ */ _jsx4(PopoverPortalContext.Provider, {
+    value: keepMounted,
+    children: /* @__PURE__ */ _jsx4(FloatingPortal, {
+      ref: forwardedRef,
+      ...portalProps
+    })
+  });
+});
+if (true) PopoverPortal.displayName = "PopoverPortal";
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/popover/positioner/PopoverPositioner.mjs
+import * as React15 from "react";
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/popover/positioner/PopoverPositionerContext.mjs
+import * as React14 from "react";
+var PopoverPositionerContext = /* @__PURE__ */ React14.createContext(void 0);
+if (true) PopoverPositionerContext.displayName = "PopoverPositionerContext";
+function usePopoverPositionerContext() {
+  const context = React14.useContext(PopoverPositionerContext);
+  if (!context) {
+    throw new Error(true ? "Base UI: PopoverPositionerContext is missing. PopoverPositioner parts must be placed within <Popover.Positioner>." : formatErrorMessage_default(46));
+  }
+  return context;
+}
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/popover/positioner/PopoverPositioner.mjs
+import { jsx as _jsx5, jsxs as _jsxs4 } from "react/jsx-runtime";
+var PopoverPositioner = /* @__PURE__ */ React15.forwardRef(function PopoverPositioner2(componentProps, forwardedRef) {
+  const {
+    render,
+    className,
+    style,
+    anchor,
+    // `useAnchorPositioning` applies the same defaults to the undefined values; the names
+    // remain destructured to exclude the props from `elementProps`.
+    positionMethod,
+    side,
+    align,
+    sideOffset,
+    alignOffset,
+    collisionBoundary = "clipping-ancestors",
+    collisionPadding,
+    arrowPadding,
+    sticky,
+    disableAnchorTracking = false,
+    collisionAvoidance = POPUP_COLLISION_AVOIDANCE,
+    ...elementProps
+  } = componentProps;
+  const store = usePopoverRootContext();
+  const keepMounted = usePopoverPortalContext();
+  const nodeId = useFloatingNodeId();
+  const floatingRootContext = store.useState("floatingRootContext");
+  const mounted = store.useState("mounted");
+  const open = store.useState("open");
+  const openReason = store.useState("openChangeReason");
+  const triggerElement = store.useState("activeTriggerElement");
+  const modal = store.useState("modal");
+  const openMethod = store.useState("openMethod");
+  const positionerElement = store.useState("positionerElement");
+  const instantType = store.useState("instantType");
+  const transitionStatus = store.useState("transitionStatus");
+  const adaptiveOrigin = store.useState("adaptiveOrigin");
+  const prevTriggerElementRef = React15.useRef(null);
+  const runOnceAnimationsFinish = useAnimationsFinished(positionerElement);
+  const positioning = useAnchorPositioning({
+    anchor,
+    floatingRootContext,
+    positionMethod,
+    mounted,
+    side,
+    sideOffset,
+    align,
+    alignOffset,
+    arrowPadding,
+    collisionBoundary,
+    collisionPadding,
+    sticky,
+    disableAnchorTracking,
+    keepMounted,
+    nodeId,
+    collisionAvoidance,
+    adaptiveOrigin
+  });
+  const domReference = floatingRootContext.useState("domReferenceElement");
+  useIsoLayoutEffect(() => {
+    const currentTriggerElement = domReference;
+    const prevTriggerElement = prevTriggerElementRef.current;
+    if (currentTriggerElement) {
+      prevTriggerElementRef.current = currentTriggerElement;
+    }
+    if (prevTriggerElement && currentTriggerElement && currentTriggerElement !== prevTriggerElement) {
+      store.set("instantType", void 0);
+      const ac = new AbortController();
+      runOnceAnimationsFinish(() => {
+        store.set("instantType", "trigger-change");
+      }, ac.signal);
+      return () => {
+        ac.abort();
+      };
+    }
+    return void 0;
+  }, [domReference, runOnceAnimationsFinish, store]);
+  const trueModalNonHover = modal === true && openReason !== reason_parts_exports.triggerHover;
+  useAnchoredPopupScrollLock(open && trueModalNonHover, openMethod === "touch", positionerElement, triggerElement);
+  const setPositionerElement = store.useStateSetter("positionerElement");
+  const state = {
+    open,
+    side: positioning.side,
+    align: positioning.align,
+    anchorHidden: positioning.anchorHidden,
+    instant: instantType
+  };
+  const element = usePositioner(componentProps, state, {
+    styles: positioning.positionerStyles,
+    transitionStatus,
+    props: elementProps,
+    refs: [forwardedRef, setPositionerElement],
+    hidden: !mounted,
+    inert: !open
+  });
+  return /* @__PURE__ */ _jsxs4(PopoverPositionerContext.Provider, {
+    value: positioning,
+    children: [mounted && trueModalNonHover && /* @__PURE__ */ _jsx5(InternalBackdrop, {
+      inert: inertValue(!open),
+      cutout: triggerElement
+    }), /* @__PURE__ */ _jsx5(FloatingNode, {
+      id: nodeId,
+      children: element
+    })]
+  });
+});
+if (true) PopoverPositioner.displayName = "PopoverPositioner";
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/popover/popup/PopoverPopup.mjs
+import * as React17 from "react";
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/utils/closePart.mjs
+import * as React16 from "react";
+var ClosePartContext = /* @__PURE__ */ React16.createContext(void 0);
+if (true) ClosePartContext.displayName = "ClosePartContext";
+function useClosePartCount() {
+  const [closePartCount, setClosePartCount] = React16.useState(0);
+  const register = useStableCallback(() => {
+    setClosePartCount((count) => count + 1);
+    return () => {
+      setClosePartCount((count) => Math.max(0, count - 1));
+    };
+  });
+  const context = React16.useMemo(() => ({
+    register
+  }), [register]);
+  return {
+    context,
+    hasClosePart: closePartCount > 0
+  };
+}
+function useClosePartRegistration() {
+  const context = React16.useContext(ClosePartContext);
+  useIsoLayoutEffect(() => {
+    return context?.register();
+  }, [context]);
+}
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/popover/popup/PopoverPopup.mjs
+import { jsx as _jsx6 } from "react/jsx-runtime";
+var PopoverPopup = /* @__PURE__ */ React17.forwardRef(function PopoverPopup2(componentProps, forwardedRef) {
+  const {
+    render,
+    className,
+    style,
+    initialFocus,
+    finalFocus,
+    ...elementProps
+  } = componentProps;
+  const store = usePopoverRootContext();
+  const positioner = usePopoverPositionerContext();
+  const insideToolbar = useToolbarRootContext(true) != null;
+  const {
+    context: closePartContext,
+    hasClosePart
+  } = useClosePartCount();
+  const open = store.useState("open");
+  const openMethod = store.useState("openMethod");
+  const instantType = store.useState("instantType");
+  const transitionStatus = store.useState("transitionStatus");
+  const popupProps = store.useState("popupProps");
+  const titleId = store.useState("titleElementId");
+  const descriptionId = store.useState("descriptionElementId");
+  const modal = store.useState("modal");
+  const mounted = store.useState("mounted");
+  const openReason = store.useState("openChangeReason");
+  const activeTriggerElement = store.useState("activeTriggerElement");
+  const floatingContext = store.useState("floatingRootContext");
+  const floatingId = floatingContext.useState("floatingId");
+  const disabled = store.useState("disabled");
+  const openOnHover = store.useState("openOnHover");
+  const closeDelay = store.useState("closeDelay");
+  useOpenChangeComplete({
+    open,
+    ref: store.context.popupRef,
+    onComplete() {
+      if (open) {
+        store.context.onOpenChangeComplete?.(true);
+      }
+    }
+  });
+  useHoverFloatingInteraction(floatingContext, {
+    enabled: openOnHover && !disabled,
+    closeDelay
+  });
+  const resolvedInitialFocus = initialFocus === void 0 ? createDefaultInitialFocus(store.context.popupRef) : initialFocus;
+  const focusManagerModal = modal !== false && hasClosePart;
+  store.useSyncedValue("focusManagerModal", focusManagerModal);
+  const setPopupElement = store.useStateSetter("popupElement");
+  const state = {
+    open,
+    side: positioner.side,
+    align: positioner.align,
+    instant: instantType,
+    transitionStatus
+  };
+  const element = useRenderElement("div", componentProps, {
+    state,
+    ref: [forwardedRef, store.context.popupRef, setPopupElement],
+    props: [popupProps, {
+      id: floatingId,
+      role: "dialog",
+      ...FOCUSABLE_POPUP_PROPS,
+      "aria-labelledby": titleId,
+      "aria-describedby": descriptionId,
+      onKeyDown(event) {
+        if (insideToolbar && COMPOSITE_KEYS.has(event.key)) {
+          event.stopPropagation();
+        }
+      }
+    }, getDisabledMountTransitionStyles(transitionStatus), elementProps],
+    stateAttributesMapping: popupTransitionStateMapping
+  });
+  return /* @__PURE__ */ _jsx6(FloatingFocusManager, {
+    context: floatingContext,
+    openInteractionType: openMethod,
+    modal: focusManagerModal,
+    disabled: !mounted || openReason === reason_parts_exports.triggerHover,
+    initialFocus: resolvedInitialFocus,
+    returnFocus: finalFocus,
+    restoreFocus: "popup",
+    previousFocusableElement: isHTMLElement(activeTriggerElement) ? activeTriggerElement : void 0,
+    nextFocusableElement: store.context.triggerFocusTargetRef,
+    beforeContentFocusGuardRef: store.context.beforeContentFocusGuardRef,
+    children: /* @__PURE__ */ _jsx6(ClosePartContext.Provider, {
+      value: closePartContext,
+      children: element
+    })
+  });
+});
+if (true) PopoverPopup.displayName = "PopoverPopup";
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/popover/arrow/PopoverArrow.mjs
+import * as React18 from "react";
+var PopoverArrow = /* @__PURE__ */ React18.forwardRef(function PopoverArrow2(componentProps, forwardedRef) {
+  const {
+    render,
+    className,
+    style,
+    ...elementProps
+  } = componentProps;
+  const store = usePopoverRootContext();
+  const open = store.useState("open");
+  const {
+    arrowRef,
+    side,
+    align,
+    arrowUncentered,
+    arrowStyles
+  } = usePopoverPositionerContext();
+  const state = {
+    open,
+    side,
+    align,
+    uncentered: arrowUncentered
+  };
+  const element = useRenderElement("div", componentProps, {
+    state,
+    ref: [forwardedRef, arrowRef],
+    props: [{
+      style: arrowStyles,
+      "aria-hidden": true
+    }, elementProps],
+    stateAttributesMapping: popupStateMapping
+  });
+  return element;
+});
+if (true) PopoverArrow.displayName = "PopoverArrow";
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/popover/backdrop/PopoverBackdrop.mjs
+import * as React19 from "react";
+var PopoverBackdrop = /* @__PURE__ */ React19.forwardRef(function PopoverBackdrop2(props, forwardedRef) {
+  const {
+    render,
+    className,
+    style,
+    ...elementProps
+  } = props;
+  const store = usePopoverRootContext();
+  const open = store.useState("open");
+  const mounted = store.useState("mounted");
+  const transitionStatus = store.useState("transitionStatus");
+  const openReason = store.useState("openChangeReason");
+  const state = {
+    open,
+    transitionStatus
+  };
+  const element = useRenderElement("div", props, {
+    state,
+    ref: forwardedRef,
+    props: [{
+      role: "presentation",
+      hidden: !mounted,
+      style: {
+        pointerEvents: openReason === reason_parts_exports.triggerHover ? "none" : void 0,
+        userSelect: "none",
+        WebkitUserSelect: "none"
+      }
+    }, elementProps],
+    stateAttributesMapping: popupTransitionStateMapping
+  });
+  return element;
+});
+if (true) PopoverBackdrop.displayName = "PopoverBackdrop";
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/popover/title/PopoverTitle.mjs
+import * as React20 from "react";
+var PopoverTitle = /* @__PURE__ */ React20.forwardRef(function PopoverTitle2(componentProps, forwardedRef) {
+  const {
+    render,
+    className,
+    style,
+    ...elementProps
+  } = componentProps;
+  const store = usePopoverRootContext();
+  const id = useBaseUiId(elementProps.id);
+  store.useSyncedValueWithCleanup("titleElementId", id);
+  const element = useRenderElement("h2", componentProps, {
+    ref: forwardedRef,
+    props: [{
+      id
+    }, elementProps]
+  });
+  return element;
+});
+if (true) PopoverTitle.displayName = "PopoverTitle";
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/popover/description/PopoverDescription.mjs
+import * as React21 from "react";
+var PopoverDescription = /* @__PURE__ */ React21.forwardRef(function PopoverDescription2(componentProps, forwardedRef) {
+  const {
+    render,
+    className,
+    style,
+    ...elementProps
+  } = componentProps;
+  const store = usePopoverRootContext();
+  const id = useBaseUiId(elementProps.id);
+  store.useSyncedValueWithCleanup("descriptionElementId", id);
+  const element = useRenderElement("p", componentProps, {
+    ref: forwardedRef,
+    props: [{
+      id
+    }, elementProps]
+  });
+  return element;
+});
+if (true) PopoverDescription.displayName = "PopoverDescription";
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/popover/close/PopoverClose.mjs
+import * as React22 from "react";
+var PopoverClose = /* @__PURE__ */ React22.forwardRef(function PopoverClose2(componentProps, forwardedRef) {
+  const {
+    render,
+    className,
+    style,
+    disabled = false,
+    nativeButton = true,
+    ...elementProps
+  } = componentProps;
+  const {
+    buttonRef,
+    getButtonProps
+  } = useButton({
+    disabled,
+    focusableWhenDisabled: false,
+    native: nativeButton
+  });
+  const store = usePopoverRootContext();
+  useClosePartRegistration();
+  const element = useRenderElement("button", componentProps, {
+    ref: [forwardedRef, buttonRef],
+    props: [{
+      onClick(event) {
+        store.setOpen(false, createChangeEventDetails(reason_parts_exports.closePress, event.nativeEvent));
+      }
+    }, elementProps, getButtonProps]
+  });
+  return element;
+});
+if (true) PopoverClose.displayName = "PopoverClose";
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/popover/viewport/PopoverViewport.mjs
+import * as React23 from "react";
+var PopoverViewport = /* @__PURE__ */ React23.forwardRef(function PopoverViewport2(componentProps, forwardedRef) {
+  const {
+    render,
+    className,
+    style,
+    children,
+    ...elementProps
+  } = componentProps;
+  const store = usePopoverRootContext();
+  const {
+    side
+  } = usePopoverPositionerContext();
+  const instantType = store.useState("instantType");
+  const {
+    children: childrenToRender,
+    state: viewportState
+  } = usePopupViewport({
+    store,
+    side,
+    children
+  });
+  const state = {
+    activationDirection: viewportState.activationDirection,
+    transitioning: viewportState.transitioning,
+    instant: instantType
+  };
+  return useRenderElement("div", componentProps, {
+    state,
+    ref: forwardedRef,
+    props: [elementProps, {
+      children: childrenToRender
+    }],
+    stateAttributesMapping: popupViewportStateMapping
+  });
+});
+if (true) PopoverViewport.displayName = "PopoverViewport";
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/popover/store/PopoverHandle.mjs
+var PopoverHandle = class extends BasePopupHandle {
+  constructor() {
+    super(createNullPopoverStore(), "Popover");
+  }
+  /**
+   * Opens the popover and associates it with the trigger with the given id.
+   *
+   * This method should only be called in an event handler or an effect (not during rendering).
+   *
+   * @param triggerId ID of the trigger to associate with the popover. The trigger must be a matching
+   * `Popover.Trigger` with this handle passed as a prop.
+   */
+  open(triggerId) {
+    this.openByTrigger(triggerId);
+  }
+  /**
+   * Closes the popover.
+   *
+   * This method should only be called in an event handler or an effect (not during rendering).
+   */
+  close() {
+    this.closePopup();
+  }
+  /**
+   * Whether the popover is currently open. Returns `false` while no root is attached to the handle.
+   */
+  get isOpen() {
+    return this.attachedStore?.select("open") ?? false;
+  }
+};
+function createPopoverHandle() {
+  return new PopoverHandle();
+}
+
+// src/primitives/popover.tsx
+import { jsx as jsx13 } from "react/jsx-runtime";
+function Popover({ ...props }) {
+  return /* @__PURE__ */ jsx13(index_parts_exports3.Root, { "data-slot": "popover", ...props });
+}
+function PopoverTrigger3({ ...props }) {
+  return /* @__PURE__ */ jsx13(index_parts_exports3.Trigger, { "data-slot": "popover-trigger", ...props });
+}
+function PopoverPortal3({ ...props }) {
+  return /* @__PURE__ */ jsx13(index_parts_exports3.Portal, { "data-slot": "popover-portal", ...props });
+}
+function PopoverPositioner3({ className, ...props }) {
+  return /* @__PURE__ */ jsx13(index_parts_exports3.Positioner, { "data-slot": "popover-positioner", className, ...props });
+}
+function PopoverContent({ className, children, ...props }) {
+  return /* @__PURE__ */ jsx13(PopoverPortal3, { children: /* @__PURE__ */ jsx13(PopoverPositioner3, { children: /* @__PURE__ */ jsx13(index_parts_exports3.Popup, { "data-slot": "popover-content", className: cn("z-50 w-72 rounded-md border bg-surface-floating p-4 text-text-primary shadow-[var(--ds-shadow-floating)] outline-none data-open:animate-in data-closed:animate-out", className), ...props, children }) }) });
+}
+function PopoverArrow3({ ...props }) {
+  return /* @__PURE__ */ jsx13(index_parts_exports3.Arrow, { "data-slot": "popover-arrow", ...props });
+}
+function PopoverTitle3({ className, ...props }) {
+  return /* @__PURE__ */ jsx13(index_parts_exports3.Title, { "data-slot": "popover-title", className: cn("font-semibold", className), ...props });
+}
+function PopoverDescription3({ className, ...props }) {
+  return /* @__PURE__ */ jsx13(index_parts_exports3.Description, { "data-slot": "popover-description", className: cn("text-sm text-text-supporting", className), ...props });
+}
+function PopoverClose3({ ...props }) {
+  return /* @__PURE__ */ jsx13(index_parts_exports3.Close, { "data-slot": "popover-close", ...props });
+}
+
+// src/primitives/searchable-select.tsx
+import * as React24 from "react";
+import { Check, ChevronsUpDown, X } from "lucide-react";
+import { jsx as jsx14, jsxs as jsxs5 } from "react/jsx-runtime";
+function SearchableSelect({ id, name, value = "", options, onValueChange, placeholder = "Select an option", searchPlaceholder = "Search...", emptyMessage = "No matching options.", disabled = false, clearable = false, clearLabel = "Clear selection", optionsLabel, className, "aria-label": ariaLabel }) {
+  const selected = options.find((option) => option.value === value) ?? null;
+  const items = React24.useMemo(() => options.map((option) => option.value), [options]);
+  const [open, setOpen] = React24.useState(false);
+  const [inputValue, setInputValue] = React24.useState(selected?.label ?? "");
+  const inputRef = React24.useRef(null);
+  React24.useLayoutEffect(() => {
+    if (!open && inputRef.current) inputRef.current.value = selected?.label ?? "";
+  }, [open, selected?.label]);
+  return /* @__PURE__ */ jsx14("div", { "data-slot": "searchable-select", className: cn("relative min-w-0", className), children: /* @__PURE__ */ jsxs5(index_parts_exports.Root, { items, autoHighlight: true, open, onOpenChange: (nextOpen) => {
+    setOpen(nextOpen);
+    if (!nextOpen) setInputValue(selected?.label ?? "");
+  }, value, inputValue: open ? inputValue : selected?.label ?? "", onInputValueChange: setInputValue, onValueChange: (next) => {
+    const nextOption = options.find((option) => option.value === next);
+    setInputValue(nextOption?.label ?? "");
+    onValueChange(next ?? "");
+  }, itemToStringLabel: (item) => options.find((option) => option.value === item)?.label ?? "", itemToStringValue: (item) => item ?? "", name, disabled, children: [
+    /* @__PURE__ */ jsxs5(index_parts_exports.InputGroup, { className: "relative flex items-center", children: [
+      /* @__PURE__ */ jsx14(index_parts_exports.Input, { ref: inputRef, id, "aria-label": ariaLabel, placeholder: searchPlaceholder, onKeyDown: (event) => {
+        if (event.key === "Enter" && open) {
+          const matches = options.filter((option) => !option.disabled && option.label.toLowerCase().includes(inputValue.toLowerCase()));
+          const match = matches.at(-1);
+          if (match && match.value !== value) {
+            event.preventDefault();
+            setOpen(false);
+            onValueChange(match.value);
+          }
+        }
+      }, className: "ds-type-control h-[var(--ds-field-control-height)] w-full rounded-[var(--ds-field-control-radius)] border border-control-border bg-surface-control px-3 pr-16 outline-none focus-visible:border-focus focus-visible:ring-[3px] focus-visible:ring-focus/50 disabled:cursor-not-allowed disabled:opacity-50" }),
+      clearable && selected ? /* @__PURE__ */ jsx14(IconButton, { type: "button", size: "sm", variant: "ghost", "aria-label": clearLabel, onClick: () => onValueChange(""), className: "absolute right-7", children: /* @__PURE__ */ jsx14(X, { className: "size-4" }) }) : null,
+      /* @__PURE__ */ jsx14(index_parts_exports.Trigger, { "aria-label": ariaLabel ?? placeholder, className: "absolute right-1 inline-flex size-8 items-center justify-center rounded-sm text-text-supporting outline-none focus-visible:ring-2 focus-visible:ring-focus", children: /* @__PURE__ */ jsx14(ChevronsUpDown, { className: "size-4" }) })
+    ] }),
+    /* @__PURE__ */ jsx14(index_parts_exports.Portal, { children: /* @__PURE__ */ jsx14(index_parts_exports.Positioner, { className: "z-50 w-[var(--anchor-width)]", children: /* @__PURE__ */ jsxs5(index_parts_exports.Popup, { className: "mt-1 max-h-72 overflow-auto rounded-md border bg-surface-floating p-1 text-text-primary shadow-[var(--ds-shadow-floating)] outline-none", children: [
+      /* @__PURE__ */ jsx14(index_parts_exports.Empty, { className: "px-2 py-3 text-sm text-text-supporting", children: emptyMessage }),
+      /* @__PURE__ */ jsx14(index_parts_exports.List, { "aria-label": optionsLabel ?? "Options", children: (optionValue) => {
+        const option = options.find((candidate) => candidate.value === optionValue);
+        if (!option) return null;
+        return /* @__PURE__ */ jsxs5(index_parts_exports.Item, { value: option.value, disabled: option.disabled, className: "ds-type-menu-item data-highlighted:bg-surface-muted relative flex cursor-default items-start gap-2 rounded-sm px-2 py-2 pr-8 outline-none data-disabled:pointer-events-none data-disabled:opacity-50", children: [
+          /* @__PURE__ */ jsx14("span", { className: "mt-0.5 flex size-4 shrink-0 items-center justify-center", children: /* @__PURE__ */ jsx14(index_parts_exports.ItemIndicator, { children: /* @__PURE__ */ jsx14(Check, { className: "size-4" }) }) }),
+          /* @__PURE__ */ jsxs5("span", { className: "min-w-0", children: [
+            /* @__PURE__ */ jsx14("span", { className: "block truncate text-sm", children: option.label }),
+            option.description ? /* @__PURE__ */ jsx14("span", { className: "block truncate text-xs text-text-supporting", children: option.description }) : null
+          ] })
+        ] }, option.value);
+      } })
+    ] }) }) })
+  ] }) });
+}
+
+// src/primitives/spinner.tsx
+import { LoaderCircle } from "lucide-react";
+import { jsx as jsx15 } from "react/jsx-runtime";
+function Spinner({
+  "aria-label": ariaLabel,
+  className,
+  label,
+  size = "default",
+  ...props
+}) {
+  const accessibleLabel = ariaLabel ?? label;
+  return /* @__PURE__ */ jsx15(
+    "span",
+    {
+      "data-slot": "spinner",
+      "data-size": size,
+      className: cn(
+        "inline-flex shrink-0 animate-spin items-center justify-center text-current motion-reduce:animate-none data-[size=default]:size-4 data-[size=lg]:size-5 data-[size=sm]:size-3.5",
+        className
+      ),
+      role: accessibleLabel ? "status" : void 0,
+      "aria-hidden": accessibleLabel ? void 0 : true,
+      "aria-label": accessibleLabel,
+      ...props,
+      children: /* @__PURE__ */ jsx15(LoaderCircle, { "aria-hidden": "true", className: "size-full" })
+    }
+  );
+}
+
+// src/primitives/toast.tsx
+import * as React41 from "react";
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/toast/index.parts.mjs
+var index_parts_exports4 = {};
+__export(index_parts_exports4, {
+  Action: () => ToastAction,
+  Arrow: () => ToastArrow,
+  Close: () => ToastClose,
+  Content: () => ToastContent,
+  Description: () => ToastDescription,
+  Portal: () => ToastPortal,
+  Positioner: () => ToastPositioner,
+  Provider: () => ToastProvider,
+  Root: () => ToastRoot,
+  Title: () => ToastTitle,
+  Viewport: () => ToastViewport,
+  createToastManager: () => createToastManager,
+  useToastManager: () => useToastManager
+});
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/toast/provider/ToastProvider.mjs
+import * as React26 from "react";
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/toast/provider/ToastProviderContext.mjs
+import * as React25 from "react";
+var ToastContext = /* @__PURE__ */ React25.createContext(void 0);
+if (true) ToastContext.displayName = "ToastContext";
+function useToastProviderContext() {
+  const context = React25.useContext(ToastContext);
+  if (!context) {
+    throw new Error(true ? "Base UI: useToastManager must be used within <Toast.Provider>." : formatErrorMessage_default(73));
+  }
+  return context;
+}
+
+// node_modules/.pnpm/@base-ui+utils@0.3.2_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/utils/generateId.mjs
+var counter = 0;
+function generateId(prefix) {
+  counter += 1;
+  return `${prefix}-${Math.random().toString(36).slice(2, 6)}-${counter}`;
+}
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/toast/utils/resolvePromiseOptions.mjs
+function resolvePromiseOptions(options, result) {
+  if (typeof options === "string") {
+    return {
+      description: options
+    };
+  }
+  if (typeof options === "function") {
+    const resolvedOptions = options(result);
+    return typeof resolvedOptions === "string" ? {
+      description: resolvedOptions
+    } : resolvedOptions;
+  }
+  return options;
+}
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/toast/store.mjs
+function createToastMetadata(toasts) {
+  const metadata = /* @__PURE__ */ new Map();
+  let visibleIndex = 0;
+  let offsetY = 0;
+  toasts.forEach((toast, toastIndex) => {
+    const isEnding = toast.transitionStatus === "ending";
+    metadata.set(toast.id, {
+      value: toast,
+      domIndex: toastIndex,
+      visibleIndex: isEnding ? -1 : visibleIndex,
+      offsetY
+    });
+    offsetY += toast.height || 0;
+    if (!isEnding) {
+      visibleIndex += 1;
+    }
+  });
+  return metadata;
+}
+function applyLimited(toasts, limit) {
+  let activeIndex = 0;
+  return toasts.map((toast) => {
+    if (toast.transitionStatus === "ending") {
+      return toast;
+    }
+    const limited = activeIndex >= limit;
+    activeIndex += 1;
+    return toast.limited === limited ? toast : {
+      ...toast,
+      limited
+    };
+  });
+}
+var selectors2 = {
+  toasts: (state) => state.toasts,
+  isEmpty: (state) => state.toasts.length === 0,
+  toast: (state, id) => state.toastMetadata.get(id)?.value,
+  toastIndex: (state, id) => state.toastMetadata.get(id)?.domIndex ?? -1,
+  toastOffsetY: (state, id) => state.toastMetadata.get(id)?.offsetY ?? 0,
+  toastVisibleIndex: (state, id) => state.toastMetadata.get(id)?.visibleIndex ?? -1,
+  focused: (state) => state.focused,
+  expanded: (state) => state.hovering || state.focused,
+  expandedOrOutOfFocus: (state) => state.hovering || state.focused || !state.isWindowFocused,
+  prevFocusElement: (state) => state.prevFocusElement
+};
+var ToastStore = class extends ReactStore {
+  constructor(initialState) {
+    super({
+      ...initialState,
+      toastMetadata: createToastMetadata(initialState.toasts)
+    }, {}, selectors2);
+    __publicField(this, "timers", /* @__PURE__ */ new Map());
+    __publicField(this, "areTimersPaused", false);
+    __publicField(this, "setViewport", (viewport) => {
+      this.set("viewport", viewport);
+    });
+    __publicField(this, "disposeEffect", () => {
+      return () => {
+        this.timers.forEach((timer) => {
+          timer.timeout?.clear();
+        });
+        this.timers.clear();
+      };
+    });
+    __publicField(this, "addToast", (toast) => {
+      const {
+        timeout,
+        limit
+      } = this.state;
+      const id = toast.id || generateId("toast");
+      if (toast.id) {
+        const existingToast = selectors2.toast(this.state, toast.id);
+        if (existingToast) {
+          if (existingToast.transitionStatus === "ending") {
+            this.removeToast(toast.id, true);
+          } else {
+            const {
+              id: ignoredId,
+              transitionStatus: ignoredTransitionStatus,
+              ...updates
+            } = toast;
+            this.updateToastInternal(toast.id, updates, true, true);
+            return toast.id;
+          }
+        }
+      }
+      const toastToAdd = {
+        ...toast,
+        id,
+        updateKey: 0,
+        transitionStatus: "starting"
+      };
+      const updatedToasts = [toastToAdd, ...this.state.toasts];
+      this.setToasts(applyLimited(updatedToasts, limit));
+      const duration = toastToAdd.timeout ?? timeout;
+      if (toastToAdd.type !== "loading" && duration > 0) {
+        this.scheduleTimer(id, duration, () => this.closeToast(id));
+      }
+      if (selectors2.expandedOrOutOfFocus(this.state)) {
+        this.pauseTimers();
+      }
+      return id;
+    });
+    __publicField(this, "updateToast", (id, updates) => {
+      this.updateToastInternal(id, updates, false, true);
+    });
+    __publicField(this, "updateToastInternal", (id, updates, resetTimer = false, markUpdated = false) => {
+      const {
+        timeout,
+        toasts
+      } = this.state;
+      const prevToast = selectors2.toast(this.state, id);
+      if (!prevToast) {
+        return;
+      }
+      if (prevToast.transitionStatus === "ending") {
+        return;
+      }
+      const nextToast = {
+        ...prevToast,
+        ...updates,
+        ...markUpdated && {
+          updateKey: prevToast.updateKey + 1
+        }
+      };
+      this.setToasts(toasts.map((toast) => toast.id === id ? nextToast : toast));
+      const nextTimeout = nextToast.timeout ?? timeout;
+      const prevTimeout = prevToast.timeout ?? timeout;
+      const timeoutUpdated = Object.hasOwn(updates, "timeout");
+      const shouldHaveTimer = nextToast.transitionStatus !== "ending" && nextToast.type !== "loading" && nextTimeout > 0;
+      const hasTimer = this.timers.has(id);
+      const timeoutChanged = prevTimeout !== nextTimeout;
+      const wasLoading = prevToast.type === "loading";
+      if (!shouldHaveTimer && hasTimer) {
+        this.clearTimer(id);
+        return;
+      }
+      if (shouldHaveTimer && (!hasTimer || timeoutChanged || timeoutUpdated || wasLoading || resetTimer)) {
+        this.clearTimer(id);
+        this.scheduleTimer(id, nextTimeout, () => this.closeToast(id));
+        if (selectors2.expandedOrOutOfFocus(this.state)) {
+          this.pauseTimers();
+        }
+      }
+    });
+    __publicField(this, "closeToast", (toastId) => {
+      const closeAll = toastId === void 0;
+      const {
+        limit,
+        toasts
+      } = this.state;
+      let toastsToClose;
+      if (closeAll) {
+        toastsToClose = toasts;
+        this.clearTimers();
+      } else {
+        const toast = selectors2.toast(this.state, toastId);
+        if (!toast) {
+          return;
+        }
+        toastsToClose = [toast];
+        this.clearTimer(toastId);
+      }
+      const endingToasts = toasts.map((item) => closeAll || item.id === toastId ? {
+        ...item,
+        transitionStatus: "ending",
+        height: 0
+      } : item);
+      const newToasts = applyLimited(endingToasts, limit);
+      this.setToasts(newToasts, !newToasts.some((toast) => toast.transitionStatus !== "ending"));
+      toastsToClose.forEach((toast) => {
+        if (toast.transitionStatus !== "ending") {
+          toast.onClose?.();
+        }
+      });
+      this.handleFocusManagement(toastId);
+    });
+    __publicField(this, "promiseToast", (promiseValue, options) => {
+      const loadingOptions = resolvePromiseOptions(options.loading);
+      const id = this.addToast({
+        ...loadingOptions,
+        type: "loading"
+      });
+      const handledPromise = promiseValue.then((result) => {
+        const successOptions = resolvePromiseOptions(options.success, result);
+        this.updateToast(id, {
+          ...successOptions,
+          type: "success",
+          timeout: successOptions.timeout
+        });
+        return result;
+      }).catch((error) => {
+        const errorOptions = resolvePromiseOptions(options.error, error);
+        this.updateToast(id, {
+          ...errorOptions,
+          type: "error",
+          timeout: errorOptions.timeout
+        });
+        return Promise.reject(error);
+      });
+      if ({}.hasOwnProperty.call(options, "setPromise")) {
+        options.setPromise(handledPromise);
+      }
+      return handledPromise;
+    });
+    __publicField(this, "handleDocumentPointerDown", (event) => {
+      if (event.pointerType !== "touch") {
+        return;
+      }
+      const target = getTarget(event);
+      if (contains(this.state.viewport, target)) {
+        return;
+      }
+      this.resumeTimers();
+      this.update({
+        hovering: false,
+        focused: false
+      });
+    });
+  }
+  syncProviderProps(timeout, limit) {
+    const limitChanged = this.state.limit !== limit;
+    if (this.state.timeout === timeout && !limitChanged) {
+      return;
+    }
+    const updates = {
+      timeout,
+      limit
+    };
+    if (limitChanged) {
+      const newToasts = applyLimited(this.state.toasts, limit);
+      updates.toasts = newToasts;
+      updates.toastMetadata = createToastMetadata(newToasts);
+    }
+    this.update(updates);
+  }
+  removeToast(toastId, skipOnRemove = false) {
+    const index = selectors2.toastIndex(this.state, toastId);
+    if (index === -1) {
+      return;
+    }
+    const toast = this.state.toasts[index];
+    if (!skipOnRemove) {
+      toast?.onRemove?.();
+    }
+    const newToasts = [...this.state.toasts];
+    newToasts.splice(index, 1);
+    this.setToasts(newToasts);
+  }
+  pauseTimers() {
+    if (this.areTimersPaused) {
+      return;
+    }
+    this.areTimersPaused = true;
+    this.timers.forEach((timer) => {
+      if (timer.timeout) {
+        timer.timeout.clear();
+        timer.remaining = Math.max(timer.remaining - (Date.now() - timer.start), 0);
+      }
+    });
+  }
+  resumeTimers() {
+    if (!this.areTimersPaused) {
+      return;
+    }
+    this.areTimersPaused = false;
+    this.timers.forEach((timer, id) => {
+      timer.remaining = timer.remaining > 0 ? timer.remaining : timer.delay;
+      timer.timeout ?? (timer.timeout = Timeout.create());
+      timer.timeout.start(timer.remaining, () => {
+        this.handleTimerFired(id);
+        timer.callback();
+      });
+      timer.start = Date.now();
+    });
+  }
+  restoreFocusToPrevElement() {
+    this.state.prevFocusElement?.focus({
+      preventScroll: true
+    });
+  }
+  scheduleTimer(id, delay, callback) {
+    const start = Date.now();
+    const shouldStartActive = !selectors2.expandedOrOutOfFocus(this.state);
+    const currentTimeout = shouldStartActive ? Timeout.create() : void 0;
+    currentTimeout?.start(delay, () => {
+      this.handleTimerFired(id);
+      callback();
+    });
+    this.timers.set(id, {
+      timeout: currentTimeout,
+      start,
+      delay,
+      remaining: delay,
+      callback
+    });
+  }
+  clearTimers() {
+    this.timers.forEach((timer) => {
+      timer.timeout?.clear();
+    });
+    this.timers.clear();
+    this.areTimersPaused = false;
+  }
+  clearTimer(id) {
+    const timer = this.timers.get(id);
+    timer?.timeout?.clear();
+    this.timers.delete(id);
+    this.resetPausedStateIfNoTimersRemain();
+  }
+  handleTimerFired(id) {
+    this.timers.delete(id);
+    this.resetPausedStateIfNoTimersRemain();
+  }
+  resetPausedStateIfNoTimersRemain() {
+    if (this.timers.size === 0) {
+      this.areTimersPaused = false;
+    }
+  }
+  setToasts(newToasts, clearInteraction = newToasts.length === 0) {
+    const updates = {
+      toasts: newToasts,
+      toastMetadata: createToastMetadata(newToasts)
+    };
+    if (clearInteraction) {
+      updates.hovering = false;
+      updates.focused = false;
+    }
+    this.update(updates);
+  }
+  handleFocusManagement(toastId) {
+    const activeEl = activeElement(ownerDocument(this.state.viewport));
+    if (!this.state.viewport || !contains(this.state.viewport, activeEl) || !matchesFocusVisible(activeEl)) {
+      return;
+    }
+    if (toastId === void 0) {
+      this.restoreFocusToPrevElement();
+      return;
+    }
+    const toasts = selectors2.toasts(this.state);
+    const currentIndex = selectors2.toastIndex(this.state, toastId);
+    const scan = (from, step) => {
+      for (let index = from; index >= 0 && index < toasts.length; index += step) {
+        if (toasts[index].transitionStatus !== "ending") {
+          return toasts[index];
+        }
+      }
+      return null;
+    };
+    const nextToast = scan(currentIndex + 1, 1) ?? scan(currentIndex - 1, -1);
+    if (nextToast) {
+      nextToast.ref?.current?.focus();
+    } else {
+      this.restoreFocusToPrevElement();
+    }
+  }
+};
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/toast/provider/ToastProvider.mjs
+import { jsx as _jsx7, jsxs as _jsxs5 } from "react/jsx-runtime";
+var ToastProvider = function ToastProvider2(props) {
+  const {
+    children,
+    timeout = 5e3,
+    limit = 3,
+    toastManager
+  } = props;
+  const store = useRefWithInit(() => new ToastStore({
+    timeout,
+    limit,
+    viewport: null,
+    toasts: [],
+    hovering: false,
+    focused: false,
+    isWindowFocused: true,
+    prevFocusElement: null
+  })).current;
+  useOnMount(store.disposeEffect);
+  React26.useEffect(function subscribeToToastManager() {
+    if (!toastManager) {
+      return void 0;
+    }
+    const unsubscribe = toastManager[" subscribe"](({
+      action,
+      options
+    }) => {
+      const id = options.id;
+      if (action === "promise" && options.promise) {
+        store.promiseToast(options.promise, options);
+      } else if (action === "update" && id) {
+        store.updateToast(id, options);
+      } else if (action === "close") {
+        store.closeToast(id);
+      } else {
+        store.addToast(options);
+      }
+    });
+    return unsubscribe;
+  }, [store, toastManager]);
+  return /* @__PURE__ */ _jsxs5(ToastContext.Provider, {
+    value: store,
+    children: [/* @__PURE__ */ _jsx7(ToastProviderPropsSynchronizer, {
+      store,
+      timeout,
+      limit
+    }), children]
+  });
+};
+if (true) ToastProvider.displayName = "ToastProvider";
+function ToastProviderPropsSynchronizer(props) {
+  const {
+    store,
+    timeout,
+    limit
+  } = props;
+  useIsoLayoutEffect(() => {
+    store.syncProviderProps(timeout, limit);
+  }, [store, timeout, limit]);
+  return null;
+}
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/toast/viewport/ToastViewport.mjs
+import * as React27 from "react";
+import { jsx as _jsx8, jsxs as _jsxs6 } from "react/jsx-runtime";
+var ToastViewport = /* @__PURE__ */ React27.forwardRef(function ToastViewport2(componentProps, forwardedRef) {
+  const {
+    render,
+    className,
+    style,
+    children,
+    ...elementProps
+  } = componentProps;
+  const store = useToastProviderContext();
+  const windowFocusTimeout = useTimeout();
+  const handlingFocusGuardRef = React27.useRef(false);
+  const markedReadyForMouseLeaveRef = React27.useRef(false);
+  const touchActiveRef = React27.useRef(false);
+  const isEmpty = store.useState("isEmpty");
+  const toasts = store.useState("toasts");
+  const focused = store.useState("focused");
+  const expanded = store.useState("expanded");
+  const prevFocusElement = store.useState("prevFocusElement");
+  const frontmostHeight = toasts[0]?.height;
+  const hasTransitioningToasts = toasts.some((toast) => toast.transitionStatus === "ending");
+  const highPriorityToasts = toasts.filter((toast) => toast.priority === "high");
+  React27.useEffect(() => {
+    const viewport = store.state.viewport;
+    if (!viewport || isEmpty) {
+      return void 0;
+    }
+    const win = getWindow(viewport);
+    const doc = ownerDocument(viewport);
+    function handleGlobalKeyDown(event) {
+      if (event.key === "F6" && getTarget(event) !== viewport) {
+        event.preventDefault();
+        store.set("prevFocusElement", activeElement(doc));
+        viewport?.focus({
+          preventScroll: true
+        });
+        store.pauseTimers();
+        store.set("focused", true);
+      }
+    }
+    function handleWindowBlur(event) {
+      if (getTarget(event) !== win) {
+        return;
+      }
+      store.set("isWindowFocused", false);
+      store.pauseTimers();
+    }
+    function handleWindowFocus(event) {
+      if (event.relatedTarget) {
+        return;
+      }
+      const target = getTarget(event);
+      const activeEl = activeElement(ownerDocument(viewport));
+      if (target === win || !contains(viewport, target) || !matchesFocusVisible(activeEl)) {
+        store.resumeTimers();
+      }
+      windowFocusTimeout.start(0, () => store.set("isWindowFocused", true));
+    }
+    return mergeCleanups(addEventListener(win, "keydown", handleGlobalKeyDown), addEventListener(win, "blur", handleWindowBlur, true), addEventListener(win, "focus", handleWindowFocus, true), addEventListener(doc, "pointerdown", store.handleDocumentPointerDown, true));
+  }, [store, windowFocusTimeout, isEmpty]);
+  function handleFocusGuard(event) {
+    handlingFocusGuardRef.current = true;
+    const firstFocusableToast = event.relatedTarget === store.state.viewport ? toasts.find((toast) => toast.transitionStatus !== "ending" && !toast.limited) : void 0;
+    if (firstFocusableToast) {
+      firstFocusableToast.ref?.current?.focus();
+    } else {
+      store.restoreFocusToPrevElement();
+    }
+  }
+  function handleKeyDown(event) {
+    if (event.key === "Tab" && event.shiftKey && getTarget(event.nativeEvent) === store.state.viewport) {
+      event.preventDefault();
+      store.restoreFocusToPrevElement();
+    }
+  }
+  function flushMouseLeave() {
+    const hasEndingToasts = store.state.toasts.some((toast) => toast.transitionStatus === "ending");
+    if (hasEndingToasts || touchActiveRef.current || !markedReadyForMouseLeaveRef.current) {
+      return;
+    }
+    if (store.state.isWindowFocused) {
+      store.resumeTimers();
+    }
+    store.set("hovering", false);
+    markedReadyForMouseLeaveRef.current = false;
+  }
+  React27.useEffect(flushMouseLeave, [hasTransitioningToasts, store]);
+  function handleMouseEnter() {
+    store.pauseTimers();
+    store.set("hovering", true);
+    markedReadyForMouseLeaveRef.current = false;
+  }
+  function resumeTimersIfWindowFocused() {
+    if (store.state.isWindowFocused) {
+      store.resumeTimers();
+    }
+  }
+  function handleMouseLeave() {
+    markedReadyForMouseLeaveRef.current = true;
+    flushMouseLeave();
+  }
+  function handlePointerDown(event) {
+    if (event.pointerType === "touch") {
+      touchActiveRef.current = true;
+    }
+  }
+  function handlePointerEnd(event) {
+    if (event.pointerType !== "touch") {
+      return;
+    }
+    touchActiveRef.current = false;
+    flushMouseLeave();
+  }
+  function handleFocus() {
+    if (handlingFocusGuardRef.current) {
+      handlingFocusGuardRef.current = false;
+      return;
+    }
+    if (focused) {
+      return;
+    }
+    if (matchesFocusVisible(activeElement(ownerDocument(store.state.viewport)))) {
+      store.set("focused", true);
+      store.pauseTimers();
+    }
+  }
+  function handleBlur(event) {
+    if (!focused || contains(store.state.viewport, event.relatedTarget)) {
+      return;
+    }
+    store.set("focused", false);
+    resumeTimersIfWindowFocused();
+  }
+  const defaultProps = {
+    tabIndex: -1,
+    role: "region",
+    "aria-live": "polite",
+    "aria-atomic": false,
+    "aria-relevant": "additions text",
+    "aria-label": "Notifications",
+    onMouseEnter: handleMouseEnter,
+    onMouseMove: handleMouseEnter,
+    onMouseLeave: handleMouseLeave,
+    onFocus: handleFocus,
+    onBlur: handleBlur,
+    onKeyDown: handleKeyDown,
+    onClick: handleFocus,
+    onPointerDown: handlePointerDown,
+    onPointerUp: handlePointerEnd,
+    onPointerCancel: handlePointerEnd,
+    style: {
+      ["--toast-frontmost-height"]: frontmostHeight ? `${frontmostHeight}px` : void 0
+    }
+  };
+  const state = {
+    expanded
+  };
+  const focusGuard = !isEmpty && prevFocusElement && /* @__PURE__ */ _jsx8(FocusGuard, {
+    onFocus: handleFocusGuard
+  });
+  const element = useRenderElement("div", componentProps, {
+    ref: [forwardedRef, store.setViewport],
+    state,
+    props: [defaultProps, elementProps, {
+      children: /* @__PURE__ */ _jsxs6(React27.Fragment, {
+        children: [focusGuard, children, focusGuard]
+      })
+    }]
+  });
+  return /* @__PURE__ */ _jsxs6(React27.Fragment, {
+    children: [focusGuard, element, !focused && highPriorityToasts.length > 0 && /* @__PURE__ */ _jsx8("div", {
+      style: visuallyHidden,
+      children: highPriorityToasts.map((toast) => /* @__PURE__ */ _jsxs6("div", {
+        role: "alert",
+        "aria-atomic": true,
+        children: [/* @__PURE__ */ _jsx8("div", {
+          children: toast.title
+        }), /* @__PURE__ */ _jsx8("div", {
+          children: toast.description
+        })]
+      }, toast.id))
+    })]
+  });
+});
+if (true) ToastViewport.displayName = "ToastViewport";
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/toast/root/ToastRoot.mjs
+import * as React29 from "react";
+import * as ReactDOM2 from "react-dom";
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/toast/root/ToastRootContext.mjs
+import * as React28 from "react";
+var ToastRootContext = /* @__PURE__ */ React28.createContext(void 0);
+if (true) ToastRootContext.displayName = "ToastRootContext";
+function useToastRootContext() {
+  const context = React28.useContext(ToastRootContext);
+  if (!context) {
+    throw new Error(true ? "Base UI: ToastRootContext is missing. Toast parts must be used within <Toast.Root>." : formatErrorMessage_default(66));
+  }
+  return context;
+}
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/toast/root/ToastRoot.mjs
+import { jsx as _jsx9 } from "react/jsx-runtime";
+var toastRootStateAttributesMapping = {
+  ...transitionStatusMapping,
+  swipeDirection(value) {
+    return value ? {
+      "data-swipe-direction": value
+    } : null;
+  }
+};
+var SWIPE_THRESHOLD = 40;
+var REVERSE_CANCEL_THRESHOLD = 10;
+var OPPOSITE_DIRECTION_DAMPING_FACTOR = 0.5;
+var MIN_DRAG_THRESHOLD = 1;
+var TOAST_SWIPE_IGNORE_SELECTOR = `${BASE_UI_SWIPE_IGNORE_SELECTOR},${LEGACY_SWIPE_IGNORE_SELECTOR}`;
+var ToastRoot = /* @__PURE__ */ React29.forwardRef(function ToastRoot2(componentProps, forwardedRef) {
+  const {
+    toast,
+    render,
+    className,
+    swipeDirection = ["down", "right"],
+    style,
+    ...elementProps
+  } = componentProps;
+  const isAnchored = toast.positionerProps?.anchor !== void 0;
+  let swipeDirections = [];
+  if (!isAnchored) {
+    swipeDirections = Array.isArray(swipeDirection) ? swipeDirection : [swipeDirection];
+  }
+  const swipeEnabled = swipeDirections.length > 0;
+  const store = useToastProviderContext();
+  const [currentSwipeDirection, setCurrentSwipeDirection] = React29.useState(void 0);
+  const [isSwiping, setIsSwiping] = React29.useState(false);
+  const [isRealSwipe, setIsRealSwipe] = React29.useState(false);
+  const [dragOffset, setDragOffset] = React29.useState({
+    x: 0,
+    y: 0
+  });
+  const [initialTransform, setInitialTransform] = React29.useState({
+    x: 0,
+    y: 0,
+    scale: 1
+  });
+  const [titleId, setTitleId] = React29.useState();
+  const [descriptionId, setDescriptionId] = React29.useState();
+  const [lockedDirection, setLockedDirection] = React29.useState(null);
+  const rootRef = React29.useRef(null);
+  const lastToastIdRef = React29.useRef(void 0);
+  const dragStartPosRef = React29.useRef({
+    x: 0,
+    y: 0
+  });
+  const initialTransformRef = React29.useRef({
+    x: 0,
+    y: 0,
+    scale: 1
+  });
+  const intendedSwipeDirectionRef = React29.useRef(void 0);
+  const maxSwipeDisplacementRef = React29.useRef(0);
+  const cancelledSwipeRef = React29.useRef(false);
+  const swipeCancelBaselineRef = React29.useRef({
+    x: 0,
+    y: 0
+  });
+  const isFirstPointerMoveRef = React29.useRef(false);
+  const dragOffsetRef = React29.useRef({
+    x: 0,
+    y: 0
+  });
+  const activePointerIdRef = React29.useRef(null);
+  const dragAbortControllerRef = React29.useRef(null);
+  const domIndex = store.useState("toastIndex", toast.id);
+  const visibleIndex = store.useState("toastVisibleIndex", toast.id);
+  const offsetY = store.useState("toastOffsetY", toast.id);
+  const focused = store.useState("focused");
+  const expanded = store.useState("expanded");
+  useOpenChangeComplete({
+    open: toast.transitionStatus !== "ending",
+    ref: rootRef,
+    onComplete() {
+      if (toast.transitionStatus === "ending") {
+        store.removeToast(toast.id);
+      }
+    }
+  });
+  const recalculateHeight = useStableCallback((flushSync3 = false) => {
+    const element2 = rootRef.current;
+    if (!element2) {
+      return;
+    }
+    const previousHeight = element2.style.height;
+    element2.style.height = "auto";
+    const height = element2.offsetHeight;
+    element2.style.height = previousHeight;
+    function update() {
+      store.updateToastInternal(toast.id, {
+        ref: rootRef,
+        height,
+        transitionStatus: void 0
+      });
+    }
+    if (flushSync3) {
+      ReactDOM2.flushSync(update);
+    } else {
+      update();
+    }
+  });
+  useIsoLayoutEffect(() => {
+    const previousToastId = lastToastIdRef.current;
+    if (toast.transitionStatus !== "starting" && previousToastId === toast.id) {
+      return;
+    }
+    if (previousToastId !== void 0) {
+      setCurrentSwipeDirection(void 0);
+      setInitialTransform({
+        x: 0,
+        y: 0,
+        scale: 1
+      });
+      setResolvedDragOffset({
+        x: 0,
+        y: 0
+      });
+    }
+    lastToastIdRef.current = toast.id;
+    recalculateHeight();
+  }, [recalculateHeight, toast.id, toast.transitionStatus]);
+  function setResolvedDragOffset(nextDragOffset) {
+    dragOffsetRef.current = nextDragOffset;
+    setDragOffset(nextDragOffset);
+  }
+  useIsoLayoutEffect(() => {
+    return () => {
+      dragAbortControllerRef.current?.abort();
+    };
+  }, []);
+  function applyDirectionalDamping(deltaX, deltaY) {
+    const damp = (delta) => delta > 0 ? delta ** OPPOSITE_DIRECTION_DAMPING_FACTOR : -(Math.abs(delta) ** OPPOSITE_DIRECTION_DAMPING_FACTOR);
+    const dampX = deltaX > 0 && !swipeDirections.includes("right") || deltaX < 0 && !swipeDirections.includes("left");
+    const dampY = deltaY > 0 && !swipeDirections.includes("down") || deltaY < 0 && !swipeDirections.includes("up");
+    return {
+      x: dampX ? damp(deltaX) : deltaX,
+      y: dampY ? damp(deltaY) : deltaY
+    };
+  }
+  const handleSwipeEnd = useStableCallback((event) => {
+    if (event.pointerId !== activePointerIdRef.current) {
+      return;
+    }
+    activePointerIdRef.current = null;
+    dragAbortControllerRef.current?.abort();
+    dragAbortControllerRef.current = null;
+    setIsSwiping(false);
+    setIsRealSwipe(false);
+    setLockedDirection(null);
+    const resolvedInitialTransform = initialTransformRef.current;
+    if (event.type === "pointercancel" || cancelledSwipeRef.current) {
+      setResolvedDragOffset({
+        x: resolvedInitialTransform.x,
+        y: resolvedInitialTransform.y
+      });
+      setCurrentSwipeDirection(void 0);
+      return;
+    }
+    const resolvedDragOffset = dragOffsetRef.current;
+    const deltaX = resolvedDragOffset.x - resolvedInitialTransform.x;
+    const deltaY = resolvedDragOffset.y - resolvedInitialTransform.y;
+    let dismissDirection;
+    for (const direction of swipeDirections) {
+      if (getDisplacement(direction, deltaX, deltaY) > SWIPE_THRESHOLD) {
+        dismissDirection = direction;
+        break;
+      }
+    }
+    if (dismissDirection) {
+      setCurrentSwipeDirection(dismissDirection);
+      store.closeToast(toast.id);
+    } else {
+      setResolvedDragOffset({
+        x: resolvedInitialTransform.x,
+        y: resolvedInitialTransform.y
+      });
+      setCurrentSwipeDirection(void 0);
+    }
+  });
+  function handlePointerDown(event) {
+    if (event.button !== 0) {
+      return;
+    }
+    if (event.pointerType === "touch") {
+      store.pauseTimers();
+    }
+    const target = getTarget(event.nativeEvent);
+    const isInteractiveElement = target?.closest(`button,a,input,textarea,[role="button"],${TOAST_SWIPE_IGNORE_SELECTOR}`);
+    if (isInteractiveElement) {
+      return;
+    }
+    cancelledSwipeRef.current = false;
+    intendedSwipeDirectionRef.current = void 0;
+    maxSwipeDisplacementRef.current = 0;
+    activePointerIdRef.current = event.pointerId;
+    dragStartPosRef.current = {
+      x: event.clientX,
+      y: event.clientY
+    };
+    swipeCancelBaselineRef.current = dragStartPosRef.current;
+    const element2 = event.currentTarget;
+    const transform = getElementTransform(element2);
+    initialTransformRef.current = transform;
+    setInitialTransform(transform);
+    setResolvedDragOffset({
+      x: transform.x,
+      y: transform.y
+    });
+    store.set("hovering", true);
+    setIsSwiping(true);
+    setIsRealSwipe(false);
+    setLockedDirection(null);
+    isFirstPointerMoveRef.current = true;
+    dragAbortControllerRef.current?.abort();
+    const dragAbortController = new AbortController();
+    dragAbortControllerRef.current = dragAbortController;
+    const doc = ownerDocument(element2);
+    doc.addEventListener("pointerup", handleSwipeEnd, {
+      signal: dragAbortController.signal
+    });
+    doc.addEventListener("pointercancel", handleSwipeEnd, {
+      signal: dragAbortController.signal
+    });
+    element2.setPointerCapture?.(event.pointerId);
+  }
+  function handlePointerMove(event) {
+    if (event.pointerId !== activePointerIdRef.current) {
+      return;
+    }
+    event.preventDefault();
+    if (isFirstPointerMoveRef.current) {
+      dragStartPosRef.current = {
+        x: event.clientX,
+        y: event.clientY
+      };
+      isFirstPointerMoveRef.current = false;
+    }
+    const {
+      clientY,
+      clientX,
+      movementX,
+      movementY
+    } = event;
+    if (movementY < 0 && clientY > swipeCancelBaselineRef.current.y || movementY > 0 && clientY < swipeCancelBaselineRef.current.y) {
+      swipeCancelBaselineRef.current = {
+        x: swipeCancelBaselineRef.current.x,
+        y: clientY
+      };
+    }
+    if (movementX < 0 && clientX > swipeCancelBaselineRef.current.x || movementX > 0 && clientX < swipeCancelBaselineRef.current.x) {
+      swipeCancelBaselineRef.current = {
+        x: clientX,
+        y: swipeCancelBaselineRef.current.y
+      };
+    }
+    const deltaX = clientX - dragStartPosRef.current.x;
+    const deltaY = clientY - dragStartPosRef.current.y;
+    const cancelDeltaY = clientY - swipeCancelBaselineRef.current.y;
+    const cancelDeltaX = clientX - swipeCancelBaselineRef.current.x;
+    let resolvedLockedDirection = lockedDirection;
+    if (!isRealSwipe) {
+      const movementDistance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
+      if (movementDistance >= MIN_DRAG_THRESHOLD) {
+        setIsRealSwipe(true);
+        const hasHorizontal = swipeDirections.includes("left") || swipeDirections.includes("right");
+        const hasVertical = swipeDirections.includes("up") || swipeDirections.includes("down");
+        if (hasHorizontal && hasVertical) {
+          const absX = Math.abs(deltaX);
+          const absY = Math.abs(deltaY);
+          resolvedLockedDirection = absX > absY ? "horizontal" : "vertical";
+          setLockedDirection(resolvedLockedDirection);
+        }
+      }
+    }
+    let candidate;
+    if (!intendedSwipeDirectionRef.current) {
+      if (resolvedLockedDirection === "vertical") {
+        if (deltaY > 0) {
+          candidate = "down";
+        } else if (deltaY < 0) {
+          candidate = "up";
+        }
+      } else if (resolvedLockedDirection === "horizontal") {
+        if (deltaX > 0) {
+          candidate = "right";
+        } else if (deltaX < 0) {
+          candidate = "left";
+        }
+      } else if (Math.abs(deltaX) >= Math.abs(deltaY)) {
+        candidate = deltaX > 0 ? "right" : "left";
+      } else {
+        candidate = deltaY > 0 ? "down" : "up";
+      }
+      if (candidate && swipeDirections.includes(candidate)) {
+        intendedSwipeDirectionRef.current = candidate;
+        maxSwipeDisplacementRef.current = getDisplacement(candidate, deltaX, deltaY);
+        setCurrentSwipeDirection(candidate);
+      }
+    } else {
+      const direction = intendedSwipeDirectionRef.current;
+      const currentDisplacement = getDisplacement(direction, cancelDeltaX, cancelDeltaY);
+      if (currentDisplacement > SWIPE_THRESHOLD) {
+        cancelledSwipeRef.current = false;
+        setCurrentSwipeDirection(direction);
+      } else if (!(swipeDirections.includes("left") && swipeDirections.includes("right")) && !(swipeDirections.includes("up") && swipeDirections.includes("down")) && maxSwipeDisplacementRef.current - currentDisplacement >= REVERSE_CANCEL_THRESHOLD) {
+        cancelledSwipeRef.current = true;
+      }
+    }
+    const dampedDelta = applyDirectionalDamping(deltaX, deltaY);
+    let newOffsetX = initialTransformRef.current.x;
+    let newOffsetY = initialTransformRef.current.y;
+    const hasHorizontalDir = swipeDirections.includes("left") || swipeDirections.includes("right");
+    const hasVerticalDir = swipeDirections.includes("up") || swipeDirections.includes("down");
+    if (resolvedLockedDirection !== "vertical" && hasHorizontalDir) {
+      newOffsetX += dampedDelta.x;
+    }
+    if (resolvedLockedDirection !== "horizontal" && hasVerticalDir) {
+      newOffsetY += dampedDelta.y;
+    }
+    setResolvedDragOffset({
+      x: newOffsetX,
+      y: newOffsetY
+    });
+  }
+  function handleKeyDown(event) {
+    if (event.key === "Escape") {
+      if (!rootRef.current || !contains(rootRef.current, activeElement(ownerDocument(rootRef.current)))) {
+        return;
+      }
+      store.closeToast(toast.id);
+    }
+  }
+  React29.useEffect(() => {
+    const element2 = rootRef.current;
+    if (!swipeEnabled || !element2) {
+      return void 0;
+    }
+    function preventDefaultTouchStart(event) {
+      if (activePointerIdRef.current === null || !contains(element2, getTarget(event))) {
+        return;
+      }
+      event.preventDefault();
+    }
+    return addEventListener(element2, "touchmove", preventDefaultTouchStart, {
+      passive: false
+    });
+  }, [swipeEnabled]);
+  function getDragStyles() {
+    const deltaX = dragOffset.x - initialTransform.x;
+    const deltaY = dragOffset.y - initialTransform.y;
+    return {
+      transition: isSwiping ? "none" : void 0,
+      // While swiping, freeze the element at its current visual transform so it doesn't snap to the
+      // end position.
+      transform: isSwiping ? `translateX(${dragOffset.x}px) translateY(${dragOffset.y}px) scale(${initialTransform.scale})` : void 0,
+      ["--toast-swipe-movement-x"]: `${deltaX}px`,
+      ["--toast-swipe-movement-y"]: `${deltaY}px`
+    };
+  }
+  const isHighPriority = toast.priority === "high";
+  const defaultProps = {
+    role: isHighPriority ? "alertdialog" : "dialog",
+    tabIndex: 0,
+    "aria-modal": false,
+    "aria-labelledby": titleId,
+    "aria-describedby": descriptionId,
+    "aria-hidden": isHighPriority && !focused ? true : void 0,
+    onPointerDown: swipeEnabled ? handlePointerDown : void 0,
+    onPointerMove: swipeEnabled ? handlePointerMove : void 0,
+    onPointerUp: swipeEnabled ? handleSwipeEnd : void 0,
+    onPointerCancel: swipeEnabled ? handleSwipeEnd : void 0,
+    onKeyDown: handleKeyDown,
+    inert: inertValue(toast.limited),
+    style: {
+      ...getDragStyles(),
+      ["--toast-index"]: toast.transitionStatus === "ending" ? domIndex : visibleIndex,
+      ["--toast-offset-y"]: `${offsetY}px`,
+      ["--toast-height"]: toast.height ? `${toast.height}px` : void 0
+    }
+  };
+  const toastRoot = React29.useMemo(() => ({
+    toast,
+    setTitleId,
+    setDescriptionId,
+    recalculateHeight,
+    visibleIndex,
+    expanded
+  }), [toast, setTitleId, setDescriptionId, recalculateHeight, visibleIndex, expanded]);
+  const state = {
+    transitionStatus: toast.transitionStatus,
+    expanded,
+    limited: toast.limited || false,
+    type: toast.type,
+    swiping: isSwiping,
+    swipeDirection: currentSwipeDirection
+  };
+  const element = useRenderElement("div", componentProps, {
+    ref: [forwardedRef, rootRef],
+    state,
+    stateAttributesMapping: toastRootStateAttributesMapping,
+    props: [defaultProps, elementProps]
+  });
+  return /* @__PURE__ */ _jsx9(ToastRootContext.Provider, {
+    value: toastRoot,
+    children: element
+  });
+});
+if (true) ToastRoot.displayName = "ToastRoot";
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/toast/content/ToastContent.mjs
+import * as React30 from "react";
+var ToastContent = /* @__PURE__ */ React30.forwardRef(function ToastContent2(componentProps, forwardedRef) {
+  const {
+    render,
+    className,
+    style,
+    ...elementProps
+  } = componentProps;
+  const {
+    visibleIndex,
+    expanded,
+    recalculateHeight
+  } = useToastRootContext();
+  const contentRef = React30.useRef(null);
+  useIsoLayoutEffect(() => {
+    recalculateHeight();
+    const node = contentRef.current;
+    if (!node || typeof ResizeObserver !== "function" || typeof MutationObserver !== "function") {
+      return void 0;
+    }
+    const resizeObserver = new ResizeObserver(() => recalculateHeight(true));
+    const mutationObserver = new MutationObserver(() => recalculateHeight(true));
+    resizeObserver.observe(node);
+    mutationObserver.observe(node, {
+      childList: true,
+      subtree: true,
+      characterData: true
+    });
+    return () => {
+      resizeObserver.disconnect();
+      mutationObserver.disconnect();
+    };
+  }, [recalculateHeight]);
+  const behind = visibleIndex > 0;
+  const state = {
+    expanded,
+    behind
+  };
+  return useRenderElement("div", componentProps, {
+    ref: [forwardedRef, contentRef],
+    state,
+    props: elementProps
+  });
+});
+if (true) ToastContent.displayName = "ToastContent";
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/toast/description/ToastDescription.mjs
+import * as React32 from "react";
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/toast/utils/isRenderableNode.mjs
+import * as React31 from "react";
+function isRenderableNode(node) {
+  if (node == null || typeof node === "boolean" || node === "") {
+    return false;
+  }
+  if (Array.isArray(node)) {
+    return node.some(isRenderableNode);
+  }
+  return true;
+}
+function hasRenderableChildren(element) {
+  return /* @__PURE__ */ React31.isValidElement(element) && isRenderableNode(element.props.children);
+}
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/toast/utils/useToastLabelPart.mjs
+function useToastLabelPart(idProp, childrenProp, part) {
+  const {
+    toast,
+    setTitleId,
+    setDescriptionId
+  } = useToastRootContext();
+  const setId = part === "title" ? setTitleId : setDescriptionId;
+  const children = childrenProp ?? (part === "title" ? toast.title : toast.description);
+  const id = useId(idProp);
+  return {
+    id,
+    children,
+    type: toast.type,
+    setId
+  };
+}
+function useToastLabelElement(element, id, setId) {
+  const shouldRender = hasRenderableChildren(element);
+  useIsoLayoutEffect(() => {
+    if (!shouldRender) {
+      return void 0;
+    }
+    setId(id);
+    return () => {
+      setId((currentId) => currentId === id ? void 0 : currentId);
+    };
+  }, [shouldRender, id, setId]);
+  return shouldRender ? element : null;
+}
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/toast/description/ToastDescription.mjs
+var ToastDescription = /* @__PURE__ */ React32.forwardRef(function ToastDescription2(componentProps, forwardedRef) {
+  const {
+    render,
+    className,
+    style,
+    id: idProp,
+    children: childrenProp,
+    ...elementProps
+  } = componentProps;
+  const {
+    id,
+    children,
+    type,
+    setId
+  } = useToastLabelPart(idProp, childrenProp, "description");
+  const state = {
+    type
+  };
+  const element = useRenderElement("p", componentProps, {
+    ref: forwardedRef,
+    state,
+    props: {
+      ...elementProps,
+      id,
+      children
+    }
+  });
+  return useToastLabelElement(element, id, setId);
+});
+if (true) ToastDescription.displayName = "ToastDescription";
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/toast/title/ToastTitle.mjs
+import * as React33 from "react";
+var ToastTitle = /* @__PURE__ */ React33.forwardRef(function ToastTitle2(componentProps, forwardedRef) {
+  const {
+    render,
+    className,
+    style,
+    id: idProp,
+    children: childrenProp,
+    ...elementProps
+  } = componentProps;
+  const {
+    id,
+    children,
+    type,
+    setId
+  } = useToastLabelPart(idProp, childrenProp, "title");
+  const state = {
+    type
+  };
+  const element = useRenderElement("h2", componentProps, {
+    ref: forwardedRef,
+    state,
+    props: {
+      ...elementProps,
+      id,
+      children
+    }
+  });
+  return useToastLabelElement(element, id, setId);
+});
+if (true) ToastTitle.displayName = "ToastTitle";
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/toast/close/ToastClose.mjs
+import * as React34 from "react";
+var ToastClose = /* @__PURE__ */ React34.forwardRef(function ToastClose2(componentProps, forwardedRef) {
+  const {
+    render,
+    className,
+    style,
+    disabled,
+    nativeButton = true,
+    ...elementProps
+  } = componentProps;
+  const store = useToastProviderContext();
+  const {
+    toast,
+    expanded
+  } = useToastRootContext();
+  const [hasFocus, setHasFocus] = React34.useState(false);
+  const {
+    getButtonProps,
+    buttonRef
+  } = useButton({
+    disabled,
+    native: nativeButton
+  });
+  const state = {
+    type: toast.type
+  };
+  return useRenderElement("button", componentProps, {
+    ref: [forwardedRef, buttonRef],
+    state,
+    props: [{
+      "aria-hidden": !expanded && !hasFocus,
+      onClick() {
+        store.closeToast(toast.id);
+      },
+      onFocus() {
+        setHasFocus(true);
+      },
+      onBlur() {
+        setHasFocus(false);
+      }
+    }, elementProps, getButtonProps]
+  });
+});
+if (true) ToastClose.displayName = "ToastClose";
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/toast/action/ToastAction.mjs
+import * as React35 from "react";
+var ToastAction = /* @__PURE__ */ React35.forwardRef(function ToastAction2(componentProps, forwardedRef) {
+  const {
+    render,
+    className,
+    style,
+    disabled,
+    nativeButton = true,
+    ...elementProps
+  } = componentProps;
+  const {
+    toast
+  } = useToastRootContext();
+  const computedChildren = toast.actionProps?.children ?? elementProps.children;
+  const {
+    getButtonProps,
+    buttonRef
+  } = useButton({
+    disabled,
+    native: nativeButton
+  });
+  const state = {
+    type: toast.type
+  };
+  const element = useRenderElement("button", componentProps, {
+    ref: [forwardedRef, buttonRef],
+    state,
+    props: [elementProps, toast.actionProps, getButtonProps, {
+      children: computedChildren
+    }]
+  });
+  return hasRenderableChildren(element) ? element : null;
+});
+if (true) ToastAction.displayName = "ToastAction";
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/toast/portal/ToastPortal.mjs
+import * as React36 from "react";
+import { jsx as _jsx10 } from "react/jsx-runtime";
+var ToastPortal = /* @__PURE__ */ React36.forwardRef(function ToastPortal2(props, forwardedRef) {
+  return /* @__PURE__ */ _jsx10(FloatingPortalLite, {
+    ref: forwardedRef,
+    ...props
+  });
+});
+if (true) ToastPortal.displayName = "ToastPortal";
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/toast/positioner/ToastPositioner.mjs
+import * as React38 from "react";
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/toast/positioner/ToastPositionerContext.mjs
+import * as React37 from "react";
+var ToastPositionerContext = /* @__PURE__ */ React37.createContext(void 0);
+if (true) ToastPositionerContext.displayName = "ToastPositionerContext";
+function useToastPositionerContext() {
+  const context = React37.useContext(ToastPositionerContext);
+  if (context === void 0) {
+    throw new Error(true ? "Base UI: ToastPositionerContext is missing. ToastPositioner parts must be placed within <Toast.Positioner>." : formatErrorMessage_default(84));
+  }
+  return context;
+}
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/toast/positioner/ToastPositioner.mjs
+import { jsx as _jsx11 } from "react/jsx-runtime";
+var ToastPositioner = /* @__PURE__ */ React38.forwardRef(function ToastPositioner2(componentProps, forwardedRef) {
+  const {
+    toast,
+    ...props
+  } = componentProps;
+  const store = useToastProviderContext();
+  const positionerProps = toast.positionerProps ?? EMPTY_OBJECT;
+  const {
+    render,
+    className,
+    anchor: anchorProp = positionerProps.anchor,
+    positionMethod = positionerProps.positionMethod ?? "absolute",
+    side = positionerProps.side ?? "top",
+    align = positionerProps.align ?? "center",
+    sideOffset = positionerProps.sideOffset ?? 0,
+    alignOffset = positionerProps.alignOffset ?? 0,
+    collisionBoundary = positionerProps.collisionBoundary ?? "clipping-ancestors",
+    collisionPadding = positionerProps.collisionPadding ?? 5,
+    arrowPadding = positionerProps.arrowPadding ?? 5,
+    sticky = positionerProps.sticky ?? false,
+    disableAnchorTracking = positionerProps.disableAnchorTracking ?? false,
+    collisionAvoidance = positionerProps.collisionAvoidance ?? POPUP_COLLISION_AVOIDANCE,
+    style,
+    ...elementProps
+  } = props;
+  const [positionerElement, setPositionerElement] = React38.useState(null);
+  const domIndex = store.useState("toastIndex", toast.id);
+  const visibleIndex = store.useState("toastVisibleIndex", toast.id);
+  const anchor = isElement(anchorProp) ? anchorProp : null;
+  const floatingRootContext = useFloatingRootContext({
+    open: true,
+    onOpenChange: NOOP,
+    elements: {
+      floating: positionerElement,
+      reference: anchor
+    }
+  });
+  const positioning = useAnchorPositioning({
+    anchor,
+    positionMethod,
+    floatingRootContext,
+    mounted: true,
+    side,
+    sideOffset,
+    align,
+    alignOffset,
+    collisionBoundary,
+    collisionPadding,
+    sticky,
+    arrowPadding,
+    disableAnchorTracking,
+    keepMounted: true,
+    collisionAvoidance
+  });
+  const state = {
+    side: positioning.side,
+    align: positioning.align,
+    anchorHidden: positioning.anchorHidden
+  };
+  const element = usePositioner(componentProps, state, {
+    styles: {
+      ...positioning.positionerStyles,
+      ["--toast-index"]: toast.transitionStatus === "ending" ? domIndex : visibleIndex
+    },
+    transitionStatus: toast.transitionStatus,
+    props: elementProps,
+    refs: [forwardedRef, setPositionerElement]
+  });
+  return /* @__PURE__ */ _jsx11(ToastPositionerContext.Provider, {
+    value: positioning,
+    children: element
+  });
+});
+if (true) ToastPositioner.displayName = "ToastPositioner";
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/toast/arrow/ToastArrow.mjs
+import * as React39 from "react";
+var ToastArrow = /* @__PURE__ */ React39.forwardRef(function ToastArrow2(componentProps, forwardedRef) {
+  const {
+    className,
+    render,
+    style,
+    ...elementProps
+  } = componentProps;
+  const {
+    arrowRef,
+    side,
+    align,
+    arrowUncentered,
+    arrowStyles
+  } = useToastPositionerContext();
+  const state = {
+    side,
+    align,
+    uncentered: arrowUncentered
+  };
+  return useRenderElement("div", componentProps, {
+    state,
+    ref: [forwardedRef, arrowRef],
+    props: [{
+      style: arrowStyles,
+      "aria-hidden": true
+    }, elementProps]
+  });
+});
+if (true) ToastArrow.displayName = "ToastArrow";
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/toast/useToastManager.mjs
+import * as React40 from "react";
+function useToastManager() {
+  const store = useToastProviderContext();
+  const toasts = store.useState("toasts");
+  return React40.useMemo(() => ({
+    toasts,
+    add: store.addToast,
+    close: store.closeToast,
+    update: store.updateToast,
+    promise: store.promiseToast
+  }), [toasts, store]);
+}
+
+// node_modules/.pnpm/@base-ui+react@1.7.0_@types+react@19.2.17_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@base-ui/react/toast/createToastManager.mjs
+function createToastManager() {
+  const listeners = /* @__PURE__ */ new Set();
+  function emit(data) {
+    listeners.forEach((listener) => listener(data));
+  }
+  return {
+    // This should be private aside from ToastProvider needing to access it.
+    // https://x.com/drosenwasser/status/1816947740032872664
+    " subscribe": function subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    add(options) {
+      const id = options.id || generateId("toast");
+      const toastToAdd = {
+        ...options,
+        id,
+        transitionStatus: "starting"
+      };
+      emit({
+        action: "add",
+        options: toastToAdd
+      });
+      return id;
+    },
+    close(id) {
+      emit({
+        action: "close",
+        options: {
+          id
+        }
+      });
+    },
+    update(id, updates) {
+      emit({
+        action: "update",
+        options: {
+          ...updates,
+          id
+        }
+      });
+    },
+    promise(promiseValue, options) {
+      let handledPromise = promiseValue;
+      emit({
+        action: "promise",
+        options: {
+          ...options,
+          promise: promiseValue,
+          setPromise(promise) {
+            handledPromise = promise;
+          }
+        }
+      });
+      return handledPromise;
+    }
+  };
+}
+
+// src/primitives/toast.tsx
+import { XIcon as XIcon2 } from "lucide-react";
+import { jsx as jsx16, jsxs as jsxs6 } from "react/jsx-runtime";
+function toBaseToastOptions(options) {
+  const { action, variant, ...rest } = options;
+  return {
+    ...rest,
+    ...variant !== void 0 ? { type: variant, data: { variant } } : {},
+    ...action !== void 0 ? {
+      actionProps: {
+        children: action.label,
+        onClick: action.onClick
+      }
+    } : {}
+  };
+}
+function toBasePromiseOption(option) {
+  return typeof option === "string" ? option : toBaseToastOptions(option);
+}
+function ToastProvider3({ children, limit = 3, timeout = 5e3 }) {
+  return /* @__PURE__ */ jsx16(index_parts_exports4.Provider, { limit, timeout, children });
+}
+function useToast() {
+  const manager = index_parts_exports4.useToastManager();
+  return React41.useMemo(
+    () => ({
+      add(options) {
+        const variant = options.variant ?? "default";
+        return manager.add({
+          ...toBaseToastOptions({ ...options, variant }),
+          id: options.id
+        });
+      },
+      close(id) {
+        manager.close(id);
+      },
+      update(id, options) {
+        manager.update(id, toBaseToastOptions(options));
+      },
+      promise(promise, options) {
+        return manager.promise(promise, {
+          loading: toBasePromiseOption(options.loading),
+          success: (result) => {
+            const next = typeof options.success === "function" ? options.success(result) : options.success;
+            return toBasePromiseOption(next);
+          },
+          error: (error) => {
+            const next = typeof options.error === "function" ? options.error(error) : options.error;
+            return toBasePromiseOption(next);
+          }
+        });
+      }
+    }),
+    [manager]
+  );
+}
+function ToastViewport3({ className, placement = "bottom-end", ...props }) {
+  const { toasts } = index_parts_exports4.useToastManager();
+  return /* @__PURE__ */ jsx16(index_parts_exports4.Portal, { children: /* @__PURE__ */ jsx16(
+    index_parts_exports4.Viewport,
+    {
+      "data-slot": "toast-viewport",
+      className: cn(
+        "pointer-events-none fixed z-[100] flex w-[min(24rem,calc(100vw-2rem))] max-w-[calc(100vw-2rem)] flex-col gap-2 p-4 outline-none",
+        placement === "bottom-end" && "right-0 bottom-0 items-end",
+        placement === "bottom-start" && "bottom-0 left-0 items-start",
+        placement === "top-end" && "top-0 right-0 items-end",
+        placement === "top-start" && "top-0 left-0 items-start",
+        className
+      ),
+      ...props,
+      children: toasts.map((toast) => /* @__PURE__ */ jsx16(Toast, { toast }, toast.id))
+    }
+  ) });
+}
+function Toast({
+  children,
+  className,
+  toast,
+  ...props
+}) {
+  const variant = toast.data?.variant ?? toast.type ?? "default";
+  return /* @__PURE__ */ jsx16(
+    index_parts_exports4.Root,
+    {
+      toast,
+      "data-slot": "toast",
+      "data-variant": variant,
+      className: cn(
+        "pointer-events-auto relative grid w-full grid-cols-[minmax(0,1fr)_auto] gap-3 rounded-[var(--ds-radius-surface)] border bg-surface p-4 text-sm text-text-primary shadow-[var(--ds-shadow-floating)] outline-none data-ending:animate-out data-starting:animate-in data-[variant=error]:border-danger-border data-[variant=error]:bg-danger-background data-[variant=error]:text-danger-foreground data-[variant=information]:border-information-border data-[variant=information]:bg-information-background data-[variant=information]:text-information-foreground data-[variant=success]:border-success-border data-[variant=success]:bg-success-background data-[variant=success]:text-success-foreground data-[variant=warning]:border-warning-border data-[variant=warning]:bg-warning-background data-[variant=warning]:text-warning-foreground",
+        className
+      ),
+      ...props,
+      children: children ?? /* @__PURE__ */ jsxs6(ToastContent3, { children: [
+        /* @__PURE__ */ jsxs6("div", { className: "min-w-0", children: [
+          /* @__PURE__ */ jsx16(ToastTitle3, {}),
+          /* @__PURE__ */ jsx16(ToastDescription3, {})
+        ] }),
+        /* @__PURE__ */ jsxs6("div", { className: "flex items-start gap-1", children: [
+          /* @__PURE__ */ jsx16(ToastAction3, {}),
+          /* @__PURE__ */ jsx16(ToastClose3, {})
+        ] })
+      ] })
+    }
+  );
+}
+function ToastContent3({ className, ...props }) {
+  return /* @__PURE__ */ jsx16(index_parts_exports4.Content, { "data-slot": "toast-content", className: cn("contents", className), ...props });
+}
+function ToastTitle3({ className, ...props }) {
+  return /* @__PURE__ */ jsx16(index_parts_exports4.Title, { "data-slot": "toast-title", className: cn("font-semibold", className), ...props });
+}
+function ToastDescription3({ className, ...props }) {
+  return /* @__PURE__ */ jsx16(index_parts_exports4.Description, { "data-slot": "toast-description", className: cn("mt-1 text-text-supporting", className), ...props });
+}
+function ToastAction3({ className, ...props }) {
+  return /* @__PURE__ */ jsx16(index_parts_exports4.Action, { "data-slot": "toast-action", className: cn("rounded px-2 py-1 text-xs font-medium text-text-link outline-none hover:bg-surface-muted focus-visible:ring-2 focus-visible:ring-focus", className), ...props });
+}
+function ToastClose3({ "aria-label": ariaLabel = "Dismiss notification", children, className, ...props }) {
+  return /* @__PURE__ */ jsx16(
+    index_parts_exports4.Close,
+    {
+      "data-slot": "toast-close",
+      "aria-label": ariaLabel,
+      className: cn("rounded p-1 text-text-supporting outline-none hover:bg-surface-muted hover:text-text-primary focus-visible:ring-2 focus-visible:ring-focus", className),
+      ...props,
+      children: children ?? /* @__PURE__ */ jsx16(XIcon2, { "aria-hidden": "true", className: "size-4" })
+    }
+  );
+}
+
+export {
+  alertVariants,
+  Alert,
+  AlertTitle,
+  AlertDescription,
+  Avatar,
+  AvatarImage,
+  AvatarFallback,
+  AvatarGroup,
+  badgeVariants,
+  Badge,
+  BrandIcon,
+  BrandWordmark,
+  Switch,
+  Textarea,
+  ConsciaButton,
+  ConsciaIconButton,
+  ConsciaCard,
+  ConsciaCardContent,
+  ConsciaCardDescription,
+  ConsciaCardHeader,
+  ConsciaCardTitle,
+  ConsciaCardFooter,
+  ConsciaCheckbox,
+  ConsciaInput,
+  ConsciaSwitch,
+  ConsciaTextarea,
+  ConsciaSelect,
+  ConsciaSelectContent,
+  ConsciaSelectGroup,
+  ConsciaSelectItem,
+  ConsciaSelectTrigger,
+  ConsciaSelectValue,
+  ConsciaTable,
+  ConsciaTableBody,
+  ConsciaTableCell,
+  ConsciaTableHeader,
+  ConsciaTableHead,
+  ConsciaTableRow,
+  Field,
+  FieldGroup,
+  FieldLabel,
+  FieldDescription,
+  FieldError,
+  FilterChip,
+  FormSelect,
+  ConsciaFormSelect,
+  Label,
+  Popover,
+  PopoverTrigger3 as PopoverTrigger,
+  PopoverPortal3 as PopoverPortal,
+  PopoverPositioner3 as PopoverPositioner,
+  PopoverContent,
+  PopoverArrow3 as PopoverArrow,
+  PopoverTitle3 as PopoverTitle,
+  PopoverDescription3 as PopoverDescription,
+  PopoverClose3 as PopoverClose,
+  SearchableSelect,
+  Spinner,
+  ToastProvider3 as ToastProvider,
+  useToast,
+  ToastViewport3 as ToastViewport,
+  Toast,
+  ToastContent3 as ToastContent,
+  ToastTitle3 as ToastTitle,
+  ToastDescription3 as ToastDescription,
+  ToastAction3 as ToastAction,
+  ToastClose3 as ToastClose
+};
+//# sourceMappingURL=chunk-3UTRMJLB.js.map