@petrarca/sonnet-ui 0.1.0

package/dist/index.js

@@ -0,0 +1,5016 @@
+// src/alert.tsx
+import * as React from "react";
+import { cva } from "class-variance-authority";
+import { cn } from "@petrarca/sonnet-core";
+import { jsx } from "react/jsx-runtime";
+var alertVariants = cva(
+  "relative w-full rounded-lg border p-4 [&>svg~*]:pl-7 [&>svg+div]:translate-y-[-3px] [&>svg]:absolute [&>svg]:left-4 [&>svg]:top-4 [&>svg]:text-foreground",
+  {
+    variants: {
+      variant: {
+        default: "bg-background text-foreground",
+        destructive: "border-destructive/50 text-destructive dark:border-destructive [&>svg]:text-destructive"
+      }
+    },
+    defaultVariants: {
+      variant: "default"
+    }
+  }
+);
+var Alert = React.forwardRef(({ className, variant, ...props }, ref) => /* @__PURE__ */ jsx(
+  "div",
+  {
+    ref,
+    role: "alert",
+    className: cn(alertVariants({ variant }), className),
+    ...props
+  }
+));
+Alert.displayName = "Alert";
+var AlertTitle = React.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+  "h5",
+  {
+    ref,
+    className: cn("mb-1 font-medium leading-none tracking-tight", className),
+    ...props
+  }
+));
+AlertTitle.displayName = "AlertTitle";
+var AlertDescription = React.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+  "div",
+  {
+    ref,
+    className: cn("text-sm [&_p]:leading-relaxed", className),
+    ...props
+  }
+));
+AlertDescription.displayName = "AlertDescription";
+
+// src/avatar.tsx
+import * as React2 from "react";
+import * as AvatarPrimitive from "@radix-ui/react-avatar";
+import { cn as cn2 } from "@petrarca/sonnet-core";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var Avatar = React2.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx2(
+  AvatarPrimitive.Root,
+  {
+    ref,
+    className: cn2(
+      "relative flex h-10 w-10 shrink-0 overflow-hidden rounded-full",
+      className
+    ),
+    ...props
+  }
+));
+Avatar.displayName = AvatarPrimitive.Root.displayName;
+var AvatarImage = React2.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx2(
+  AvatarPrimitive.Image,
+  {
+    ref,
+    className: cn2("aspect-square h-full w-full", className),
+    ...props
+  }
+));
+AvatarImage.displayName = AvatarPrimitive.Image.displayName;
+var AvatarFallback = React2.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx2(
+  AvatarPrimitive.Fallback,
+  {
+    ref,
+    className: cn2(
+      "flex h-full w-full items-center justify-center rounded-full bg-muted",
+      className
+    ),
+    ...props
+  }
+));
+AvatarFallback.displayName = AvatarPrimitive.Fallback.displayName;
+
+// src/badge.tsx
+import { cva as cva2 } from "class-variance-authority";
+import { cn as cn3 } from "@petrarca/sonnet-core";
+import { jsx as jsx3 } from "react/jsx-runtime";
+var badgeVariants = cva2(
+  "inline-flex items-center rounded-full border px-2.5 py-0.5 text-xs font-semibold transition-colors focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2",
+  {
+    variants: {
+      variant: {
+        default: "border-transparent bg-primary text-primary-foreground hover:bg-primary/80",
+        secondary: "border-transparent bg-secondary text-secondary-foreground hover:bg-secondary/80",
+        destructive: "border-transparent bg-destructive text-destructive-foreground hover:bg-destructive/80",
+        outline: "text-foreground"
+      },
+      badgeColor: {
+        grape: "border-transparent bg-purple-100 text-purple-800 hover:bg-purple-200 dark:bg-purple-900 dark:text-purple-200 dark:hover:bg-purple-800",
+        blue: "border-transparent bg-blue-100 text-blue-800 hover:bg-blue-200 dark:bg-blue-900 dark:text-blue-200 dark:hover:bg-blue-800",
+        green: "border-transparent bg-green-100 text-green-800 hover:bg-green-200 dark:bg-green-900 dark:text-green-200 dark:hover:bg-green-800",
+        red: "border-transparent bg-red-100 text-red-800 hover:bg-red-200 dark:bg-red-900 dark:text-red-200 dark:hover:bg-red-800",
+        orange: "border-transparent bg-orange-100 text-orange-800 hover:bg-orange-200 dark:bg-orange-900 dark:text-orange-200 dark:hover:bg-orange-800",
+        yellow: "border-transparent bg-yellow-100 text-yellow-800 hover:bg-yellow-200 dark:bg-yellow-900 dark:text-yellow-200 dark:hover:bg-yellow-800",
+        teal: "border-transparent bg-teal-100 text-teal-800 hover:bg-teal-200 dark:bg-teal-900 dark:text-teal-200 dark:hover:bg-teal-800",
+        cyan: "border-transparent bg-cyan-100 text-cyan-800 hover:bg-cyan-200 dark:bg-cyan-900 dark:text-cyan-200 dark:hover:bg-cyan-800",
+        pink: "border-transparent bg-pink-100 text-pink-800 hover:bg-pink-200 dark:bg-pink-900 dark:text-pink-200 dark:hover:bg-pink-800",
+        indigo: "border-transparent bg-indigo-100 text-indigo-800 hover:bg-indigo-200 dark:bg-indigo-900 dark:text-indigo-200 dark:hover:bg-indigo-800",
+        violet: "border-transparent bg-violet-100 text-violet-800 hover:bg-violet-200 dark:bg-violet-900 dark:text-violet-200 dark:hover:bg-violet-800"
+      }
+    },
+    defaultVariants: {
+      variant: "default"
+    }
+  }
+);
+function Badge({ className, variant, badgeColor, ...props }) {
+  return /* @__PURE__ */ jsx3(
+    "div",
+    {
+      className: cn3(badgeVariants({ variant, badgeColor }), className),
+      ...props
+    }
+  );
+}
+
+// src/button.tsx
+import * as React3 from "react";
+import { Slot } from "@radix-ui/react-slot";
+import { cva as cva3 } from "class-variance-authority";
+import { cn as cn4 } from "@petrarca/sonnet-core";
+import { jsx as jsx4 } from "react/jsx-runtime";
+var buttonVariants = cva3(
+  "inline-flex items-center justify-center gap-2 whitespace-nowrap rounded-md text-sm font-medium ring-offset-background transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:size-4 [&_svg]:shrink-0",
+  {
+    variants: {
+      variant: {
+        default: "bg-primary text-primary-foreground hover:bg-primary/90",
+        destructive: "bg-destructive text-destructive-foreground hover:bg-destructive/90",
+        outline: "border border-input bg-background hover:bg-accent hover:text-accent-foreground",
+        secondary: "bg-secondary text-secondary-foreground hover:bg-secondary/80",
+        ghost: "hover:bg-accent hover:text-accent-foreground",
+        link: "text-primary underline-offset-4 hover:underline"
+      },
+      size: {
+        default: "h-10 px-4 py-2",
+        sm: "h-9 rounded-md px-3",
+        lg: "h-11 rounded-md px-8",
+        icon: "h-10 w-10",
+        compact: "h-7 w-7 p-0"
+      }
+    },
+    defaultVariants: {
+      variant: "default",
+      size: "default"
+    }
+  }
+);
+var Button = React3.forwardRef(
+  ({ className, variant, size, asChild = false, ...props }, ref) => {
+    const Comp = asChild ? Slot : "button";
+    return /* @__PURE__ */ jsx4(
+      Comp,
+      {
+        className: cn4(buttonVariants({ variant, size, className })),
+        ref,
+        ...props
+      }
+    );
+  }
+);
+Button.displayName = "Button";
+
+// src/card.tsx
+import * as React4 from "react";
+import { cn as cn5 } from "@petrarca/sonnet-core";
+import { jsx as jsx5 } from "react/jsx-runtime";
+var Card = React4.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx5(
+  "div",
+  {
+    ref,
+    className: cn5(
+      "rounded-lg border bg-card text-card-foreground shadow-sm",
+      className
+    ),
+    ...props
+  }
+));
+Card.displayName = "Card";
+var CardHeader = React4.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx5(
+  "div",
+  {
+    ref,
+    className: cn5("flex flex-col space-y-1.5 p-6", className),
+    ...props
+  }
+));
+CardHeader.displayName = "CardHeader";
+var CardTitle = React4.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx5(
+  "div",
+  {
+    ref,
+    className: cn5(
+      "text-2xl font-semibold leading-none tracking-tight",
+      className
+    ),
+    ...props
+  }
+));
+CardTitle.displayName = "CardTitle";
+var CardDescription = React4.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx5(
+  "div",
+  {
+    ref,
+    className: cn5("text-sm text-muted-foreground", className),
+    ...props
+  }
+));
+CardDescription.displayName = "CardDescription";
+var CardContent = React4.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx5("div", { ref, className: cn5("p-6 pt-0", className), ...props }));
+CardContent.displayName = "CardContent";
+var CardFooter = React4.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx5(
+  "div",
+  {
+    ref,
+    className: cn5("flex items-center p-6 pt-0", className),
+    ...props
+  }
+));
+CardFooter.displayName = "CardFooter";
+
+// src/checkbox.tsx
+import * as React5 from "react";
+import * as CheckboxPrimitive from "@radix-ui/react-checkbox";
+import { Check } from "lucide-react";
+import { cn as cn6 } from "@petrarca/sonnet-core";
+import { jsx as jsx6 } from "react/jsx-runtime";
+var Checkbox = React5.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx6(
+  CheckboxPrimitive.Root,
+  {
+    ref,
+    className: cn6(
+      "grid place-content-center peer h-4 w-4 shrink-0 rounded-sm border border-primary ring-offset-background focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50 data-[state=checked]:bg-primary data-[state=checked]:text-primary-foreground",
+      className
+    ),
+    ...props,
+    children: /* @__PURE__ */ jsx6(
+      CheckboxPrimitive.Indicator,
+      {
+        className: cn6("grid place-content-center text-current"),
+        children: /* @__PURE__ */ jsx6(Check, { className: "h-4 w-4" })
+      }
+    )
+  }
+));
+Checkbox.displayName = CheckboxPrimitive.Root.displayName;
+
+// src/collapsible.tsx
+import * as CollapsiblePrimitive from "@radix-ui/react-collapsible";
+var Collapsible = CollapsiblePrimitive.Root;
+var CollapsibleTrigger2 = CollapsiblePrimitive.CollapsibleTrigger;
+var CollapsibleContent2 = CollapsiblePrimitive.CollapsibleContent;
+
+// src/command.tsx
+import * as React7 from "react";
+import { Command as CommandPrimitive } from "cmdk";
+import { Search } from "lucide-react";
+import { cn as cn8 } from "@petrarca/sonnet-core";
+
+// src/dialog.tsx
+import * as React6 from "react";
+import * as DialogPrimitive from "@radix-ui/react-dialog";
+import { X } from "lucide-react";
+import { cn as cn7 } from "@petrarca/sonnet-core";
+import { jsx as jsx7, jsxs } from "react/jsx-runtime";
+var Dialog = DialogPrimitive.Root;
+var DialogTrigger = DialogPrimitive.Trigger;
+var DialogPortal = DialogPrimitive.Portal;
+var DialogClose = DialogPrimitive.Close;
+var DialogOverlay = React6.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx7(
+  DialogPrimitive.Overlay,
+  {
+    ref,
+    className: cn7(
+      "fixed inset-0 z-50 bg-black/80 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0",
+      className
+    ),
+    ...props
+  }
+));
+DialogOverlay.displayName = DialogPrimitive.Overlay.displayName;
+var DialogContent = React6.forwardRef(({ className, children, ...props }, ref) => /* @__PURE__ */ jsxs(DialogPortal, { children: [
+  /* @__PURE__ */ jsx7(DialogOverlay, {}),
+  /* @__PURE__ */ jsxs(
+    DialogPrimitive.Content,
+    {
+      ref,
+      className: cn7(
+        "fixed left-[50%] top-[50%] z-50 grid w-full max-w-lg translate-x-[-50%] translate-y-[-50%] gap-4 border bg-background p-6 shadow-lg duration-200 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[state=closed]:slide-out-to-left-1/2 data-[state=closed]:slide-out-to-top-[48%] data-[state=open]:slide-in-from-left-1/2 data-[state=open]:slide-in-from-top-[48%] sm:rounded-lg",
+        className
+      ),
+      ...props,
+      children: [
+        children,
+        /* @__PURE__ */ jsxs(DialogPrimitive.Close, { className: "absolute right-4 top-4 rounded-sm opacity-70 ring-offset-background transition-opacity hover:opacity-100 focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2 disabled:pointer-events-none data-[state=open]:bg-accent data-[state=open]:text-muted-foreground", children: [
+          /* @__PURE__ */ jsx7(X, { className: "h-4 w-4" }),
+          /* @__PURE__ */ jsx7("span", { className: "sr-only", children: "Close" })
+        ] })
+      ]
+    }
+  )
+] }));
+DialogContent.displayName = DialogPrimitive.Content.displayName;
+var DialogHeader = ({
+  className,
+  ...props
+}) => /* @__PURE__ */ jsx7(
+  "div",
+  {
+    className: cn7(
+      "flex flex-col space-y-1.5 text-center sm:text-left",
+      className
+    ),
+    ...props
+  }
+);
+DialogHeader.displayName = "DialogHeader";
+var DialogFooter = ({
+  className,
+  ...props
+}) => /* @__PURE__ */ jsx7(
+  "div",
+  {
+    className: cn7(
+      "flex flex-col-reverse sm:flex-row sm:justify-end sm:space-x-2",
+      className
+    ),
+    ...props
+  }
+);
+DialogFooter.displayName = "DialogFooter";
+var DialogTitle = React6.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx7(
+  DialogPrimitive.Title,
+  {
+    ref,
+    className: cn7(
+      "text-lg font-semibold leading-none tracking-tight",
+      className
+    ),
+    ...props
+  }
+));
+DialogTitle.displayName = DialogPrimitive.Title.displayName;
+var DialogDescription = React6.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx7(
+  DialogPrimitive.Description,
+  {
+    ref,
+    className: cn7("text-sm text-muted-foreground", className),
+    ...props
+  }
+));
+DialogDescription.displayName = DialogPrimitive.Description.displayName;
+
+// src/command.tsx
+import { jsx as jsx8, jsxs as jsxs2 } from "react/jsx-runtime";
+var Command = React7.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx8(
+  CommandPrimitive,
+  {
+    ref,
+    className: cn8(
+      "flex h-full w-full flex-col overflow-hidden rounded-md bg-popover text-popover-foreground",
+      className
+    ),
+    ...props
+  }
+));
+Command.displayName = CommandPrimitive.displayName;
+var CommandDialog = ({ children, ...props }) => {
+  return /* @__PURE__ */ jsx8(Dialog, { ...props, children: /* @__PURE__ */ jsx8(DialogContent, { className: "overflow-hidden p-0 shadow-lg", children: /* @__PURE__ */ jsx8(Command, { className: "[&_[cmdk-group-heading]]:px-2 [&_[cmdk-group-heading]]:font-medium [&_[cmdk-group-heading]]:text-muted-foreground [&_[cmdk-group]:not([hidden])_~[cmdk-group]]:pt-0 [&_[cmdk-group]]:px-2 [&_[cmdk-input-wrapper]_svg]:h-5 [&_[cmdk-input-wrapper]_svg]:w-5 [&_[cmdk-input]]:h-12 [&_[cmdk-item]]:px-2 [&_[cmdk-item]]:py-3 [&_[cmdk-item]_svg]:h-5 [&_[cmdk-item]_svg]:w-5", children }) }) });
+};
+var CommandInput = React7.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxs2("div", { className: "flex items-center border-b px-3", "cmdk-input-wrapper": "", children: [
+  /* @__PURE__ */ jsx8(Search, { className: "mr-2 h-4 w-4 shrink-0 opacity-50" }),
+  /* @__PURE__ */ jsx8(
+    CommandPrimitive.Input,
+    {
+      ref,
+      className: cn8(
+        "flex h-11 w-full rounded-md bg-transparent py-3 text-sm outline-none placeholder:text-muted-foreground disabled:cursor-not-allowed disabled:opacity-50",
+        className
+      ),
+      ...props
+    }
+  )
+] }));
+CommandInput.displayName = CommandPrimitive.Input.displayName;
+var CommandList = React7.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx8(
+  CommandPrimitive.List,
+  {
+    ref,
+    className: cn8("max-h-[300px] overflow-y-auto overflow-x-hidden", className),
+    ...props
+  }
+));
+CommandList.displayName = CommandPrimitive.List.displayName;
+var CommandEmpty = React7.forwardRef((props, ref) => /* @__PURE__ */ jsx8(
+  CommandPrimitive.Empty,
+  {
+    ref,
+    className: "py-6 text-center text-sm",
+    ...props
+  }
+));
+CommandEmpty.displayName = CommandPrimitive.Empty.displayName;
+var CommandGroup = React7.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx8(
+  CommandPrimitive.Group,
+  {
+    ref,
+    className: cn8(
+      "overflow-hidden p-1 text-foreground [&_[cmdk-group-heading]]:px-2 [&_[cmdk-group-heading]]:py-1.5 [&_[cmdk-group-heading]]:text-xs [&_[cmdk-group-heading]]:font-medium [&_[cmdk-group-heading]]:text-muted-foreground",
+      className
+    ),
+    ...props
+  }
+));
+CommandGroup.displayName = CommandPrimitive.Group.displayName;
+var CommandSeparator = React7.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx8(
+  CommandPrimitive.Separator,
+  {
+    ref,
+    className: cn8("-mx-1 h-px bg-border", className),
+    ...props
+  }
+));
+CommandSeparator.displayName = CommandPrimitive.Separator.displayName;
+var CommandItem = React7.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx8(
+  CommandPrimitive.Item,
+  {
+    ref,
+    className: cn8(
+      "relative flex cursor-default gap-2 select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none data-[disabled=true]:pointer-events-none data-[selected='true']:bg-accent data-[selected=true]:text-accent-foreground data-[disabled=true]:opacity-50 [&_svg]:pointer-events-none [&_svg]:size-4 [&_svg]:shrink-0",
+      className
+    ),
+    ...props
+  }
+));
+CommandItem.displayName = CommandPrimitive.Item.displayName;
+var CommandShortcut = ({
+  className,
+  ...props
+}) => {
+  return /* @__PURE__ */ jsx8(
+    "span",
+    {
+      className: cn8(
+        "ml-auto text-xs tracking-widest text-muted-foreground",
+        className
+      ),
+      ...props
+    }
+  );
+};
+CommandShortcut.displayName = "CommandShortcut";
+
+// src/dropdown-menu.tsx
+import * as React8 from "react";
+import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
+import { Check as Check2, ChevronRight, Circle } from "lucide-react";
+import { cn as cn9 } from "@petrarca/sonnet-core";
+import { jsx as jsx9, jsxs as jsxs3 } from "react/jsx-runtime";
+var DropdownMenu = DropdownMenuPrimitive.Root;
+var DropdownMenuTrigger = DropdownMenuPrimitive.Trigger;
+var DropdownMenuGroup = DropdownMenuPrimitive.Group;
+var DropdownMenuPortal = DropdownMenuPrimitive.Portal;
+var DropdownMenuSub = DropdownMenuPrimitive.Sub;
+var DropdownMenuRadioGroup = DropdownMenuPrimitive.RadioGroup;
+var DropdownMenuSubTrigger = React8.forwardRef(({ className, inset, children, ...props }, ref) => /* @__PURE__ */ jsxs3(
+  DropdownMenuPrimitive.SubTrigger,
+  {
+    ref,
+    className: cn9(
+      "flex cursor-default select-none items-center gap-2 rounded-sm px-2 py-1.5 text-sm outline-none focus:bg-accent data-[state=open]:bg-accent [&_svg]:pointer-events-none [&_svg]:size-4 [&_svg]:shrink-0",
+      inset && "pl-8",
+      className
+    ),
+    ...props,
+    children: [
+      children,
+      /* @__PURE__ */ jsx9(ChevronRight, { className: "ml-auto" })
+    ]
+  }
+));
+DropdownMenuSubTrigger.displayName = DropdownMenuPrimitive.SubTrigger.displayName;
+var DropdownMenuSubContent = React8.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx9(
+  DropdownMenuPrimitive.SubContent,
+  {
+    ref,
+    className: cn9(
+      "z-50 min-w-[8rem] overflow-hidden rounded-md border bg-popover p-1 text-popover-foreground shadow-lg data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 origin-[--radix-dropdown-menu-content-transform-origin]",
+      className
+    ),
+    ...props
+  }
+));
+DropdownMenuSubContent.displayName = DropdownMenuPrimitive.SubContent.displayName;
+var DropdownMenuContent = React8.forwardRef(({ className, sideOffset = 4, ...props }, ref) => /* @__PURE__ */ jsx9(DropdownMenuPrimitive.Portal, { children: /* @__PURE__ */ jsx9(
+  DropdownMenuPrimitive.Content,
+  {
+    ref,
+    sideOffset,
+    className: cn9(
+      "z-50 max-h-[var(--radix-dropdown-menu-content-available-height)] min-w-[8rem] overflow-y-auto overflow-x-hidden rounded-md border bg-popover p-1 text-popover-foreground shadow-md data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 origin-[--radix-dropdown-menu-content-transform-origin]",
+      className
+    ),
+    ...props
+  }
+) }));
+DropdownMenuContent.displayName = DropdownMenuPrimitive.Content.displayName;
+var DropdownMenuItem = React8.forwardRef(({ className, inset, ...props }, ref) => /* @__PURE__ */ jsx9(
+  DropdownMenuPrimitive.Item,
+  {
+    ref,
+    className: cn9(
+      "relative flex cursor-default select-none items-center gap-2 rounded-sm px-2 py-1.5 text-sm outline-none transition-colors focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50 [&_svg]:pointer-events-none [&_svg]:size-4 [&_svg]:shrink-0",
+      inset && "pl-8",
+      className
+    ),
+    ...props
+  }
+));
+DropdownMenuItem.displayName = DropdownMenuPrimitive.Item.displayName;
+var DropdownMenuCheckboxItem = React8.forwardRef(({ className, children, checked, ...props }, ref) => /* @__PURE__ */ jsxs3(
+  DropdownMenuPrimitive.CheckboxItem,
+  {
+    ref,
+    className: cn9(
+      "relative flex cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none transition-colors focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50",
+      className
+    ),
+    checked,
+    ...props,
+    children: [
+      /* @__PURE__ */ jsx9("span", { className: "absolute left-2 flex h-3.5 w-3.5 items-center justify-center", children: /* @__PURE__ */ jsx9(DropdownMenuPrimitive.ItemIndicator, { children: /* @__PURE__ */ jsx9(Check2, { className: "h-4 w-4" }) }) }),
+      children
+    ]
+  }
+));
+DropdownMenuCheckboxItem.displayName = DropdownMenuPrimitive.CheckboxItem.displayName;
+var DropdownMenuRadioItem = React8.forwardRef(({ className, children, ...props }, ref) => /* @__PURE__ */ jsxs3(
+  DropdownMenuPrimitive.RadioItem,
+  {
+    ref,
+    className: cn9(
+      "relative flex cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none transition-colors focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50",
+      className
+    ),
+    ...props,
+    children: [
+      /* @__PURE__ */ jsx9("span", { className: "absolute left-2 flex h-3.5 w-3.5 items-center justify-center", children: /* @__PURE__ */ jsx9(DropdownMenuPrimitive.ItemIndicator, { children: /* @__PURE__ */ jsx9(Circle, { className: "h-2 w-2 fill-current" }) }) }),
+      children
+    ]
+  }
+));
+DropdownMenuRadioItem.displayName = DropdownMenuPrimitive.RadioItem.displayName;
+var DropdownMenuLabel = React8.forwardRef(({ className, inset, ...props }, ref) => /* @__PURE__ */ jsx9(
+  DropdownMenuPrimitive.Label,
+  {
+    ref,
+    className: cn9(
+      "px-2 py-1.5 text-sm font-semibold",
+      inset && "pl-8",
+      className
+    ),
+    ...props
+  }
+));
+DropdownMenuLabel.displayName = DropdownMenuPrimitive.Label.displayName;
+var DropdownMenuSeparator = React8.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx9(
+  DropdownMenuPrimitive.Separator,
+  {
+    ref,
+    className: cn9("-mx-1 my-1 h-px bg-muted", className),
+    ...props
+  }
+));
+DropdownMenuSeparator.displayName = DropdownMenuPrimitive.Separator.displayName;
+var DropdownMenuShortcut = ({
+  className,
+  ...props
+}) => {
+  return /* @__PURE__ */ jsx9(
+    "span",
+    {
+      className: cn9("ml-auto text-xs tracking-widest opacity-60", className),
+      ...props
+    }
+  );
+};
+DropdownMenuShortcut.displayName = "DropdownMenuShortcut";
+
+// src/input.tsx
+import * as React9 from "react";
+import { cn as cn10 } from "@petrarca/sonnet-core";
+import { jsx as jsx10 } from "react/jsx-runtime";
+var Input = React9.forwardRef(
+  ({ className, type, ...props }, ref) => {
+    return /* @__PURE__ */ jsx10(
+      "input",
+      {
+        type,
+        className: cn10(
+          "flex h-10 w-full rounded-md border border-input bg-background px-3 py-2 text-base file:border-0 file:bg-transparent file:text-sm file:font-medium file:text-foreground placeholder:text-muted-foreground focus-visible:outline-none disabled:cursor-not-allowed disabled:opacity-50 md:text-sm",
+          className
+        ),
+        ref,
+        ...props
+      }
+    );
+  }
+);
+Input.displayName = "Input";
+
+// src/input-group.tsx
+import { cva as cva4 } from "class-variance-authority";
+import { cn as cn12 } from "@petrarca/sonnet-core";
+
+// src/textarea.tsx
+import * as React10 from "react";
+import { cn as cn11 } from "@petrarca/sonnet-core";
+import { jsx as jsx11 } from "react/jsx-runtime";
+var Textarea = React10.forwardRef(({ className, ...props }, ref) => {
+  return /* @__PURE__ */ jsx11(
+    "textarea",
+    {
+      className: cn11(
+        "flex min-h-[80px] w-full rounded-md border border-input bg-background px-3 py-2 text-base placeholder:text-muted-foreground focus-visible:outline-none disabled:cursor-not-allowed disabled:opacity-50 md:text-sm",
+        className
+      ),
+      ref,
+      ...props
+    }
+  );
+});
+Textarea.displayName = "Textarea";
+
+// src/input-group.tsx
+import { jsx as jsx12 } from "react/jsx-runtime";
+function InputGroup({ className, ...props }) {
+  return /* @__PURE__ */ jsx12(
+    "div",
+    {
+      "data-slot": "input-group",
+      role: "group",
+      className: cn12(
+        "group/input-group border-input dark:bg-input/30 shadow-xs relative flex w-full items-center rounded-md border outline-none transition-[color,box-shadow]",
+        "h-9 has-[>textarea]:h-auto",
+        // Variants based on alignment.
+        "has-[>[data-align=inline-start]]:[&>input]:pl-2",
+        "has-[>[data-align=inline-end]]:[&>input]:pr-2",
+        "has-[>[data-align=block-start]]:h-auto has-[>[data-align=block-start]]:flex-col has-[>[data-align=block-start]]:[&>input]:pb-3",
+        "has-[>[data-align=block-end]]:h-auto has-[>[data-align=block-end]]:flex-col has-[>[data-align=block-end]]:[&>input]:pt-3",
+        // Focus state.
+        "has-[[data-slot=input-group-control]:focus-visible]:ring-ring has-[[data-slot=input-group-control]:focus-visible]:ring-1",
+        // Error state.
+        "has-[[data-slot][aria-invalid=true]]:ring-destructive/20 has-[[data-slot][aria-invalid=true]]:border-destructive dark:has-[[data-slot][aria-invalid=true]]:ring-destructive/40",
+        className
+      ),
+      ...props
+    }
+  );
+}
+var inputGroupAddonVariants = cva4(
+  "text-muted-foreground flex h-auto cursor-text select-none items-center justify-center gap-2 py-1.5 text-sm font-medium group-data-[disabled=true]/input-group:opacity-50 [&>kbd]:rounded-[calc(var(--radius)-5px)] [&>svg:not([class*='size-'])]:size-4",
+  {
+    variants: {
+      align: {
+        "inline-start": "order-first pl-3 has-[>button]:ml-[-0.45rem] has-[>kbd]:ml-[-0.35rem]",
+        "inline-end": "order-last pr-3 has-[>button]:mr-[-0.4rem] has-[>kbd]:mr-[-0.35rem]",
+        "block-start": "[.border-b]:pb-3 order-first w-full justify-start px-3 pt-3 group-has-[>input]/input-group:pt-2.5",
+        "block-end": "[.border-t]:pt-3 order-last w-full justify-start px-3 pb-3 group-has-[>input]/input-group:pb-2.5"
+      }
+    },
+    defaultVariants: {
+      align: "inline-start"
+    }
+  }
+);
+function InputGroupAddon({
+  className,
+  align = "inline-start",
+  ...props
+}) {
+  return /* @__PURE__ */ jsx12(
+    "div",
+    {
+      role: "group",
+      "data-slot": "input-group-addon",
+      "data-align": align,
+      className: cn12(inputGroupAddonVariants({ align }), className),
+      onClick: (e) => {
+        if (e.target.closest("button")) {
+          return;
+        }
+        e.currentTarget.parentElement?.querySelector("input")?.focus();
+      },
+      ...props
+    }
+  );
+}
+var inputGroupButtonVariants = cva4(
+  "flex items-center gap-2 text-sm shadow-none",
+  {
+    variants: {
+      size: {
+        xs: "h-6 gap-1 rounded-[calc(var(--radius)-5px)] px-2 has-[>svg]:px-2 [&>svg:not([class*='size-'])]:size-3.5",
+        sm: "h-8 gap-1.5 rounded-md px-2.5 has-[>svg]:px-2.5",
+        "icon-xs": "size-6 rounded-[calc(var(--radius)-5px)] p-0 has-[>svg]:p-0",
+        "icon-sm": "size-8 p-0 has-[>svg]:p-0"
+      }
+    },
+    defaultVariants: {
+      size: "xs"
+    }
+  }
+);
+function InputGroupText({ className, ...props }) {
+  return /* @__PURE__ */ jsx12(
+    "span",
+    {
+      className: cn12(
+        "text-muted-foreground flex items-center gap-2 text-sm [&_svg:not([class*='size-'])]:size-4 [&_svg]:pointer-events-none",
+        className
+      ),
+      ...props
+    }
+  );
+}
+function InputGroupInput({
+  className,
+  ...props
+}) {
+  return /* @__PURE__ */ jsx12(
+    Input,
+    {
+      "data-slot": "input-group-control",
+      className: cn12(
+        "flex-1 rounded-none border-0 bg-transparent shadow-none focus-visible:ring-0 dark:bg-transparent",
+        className
+      ),
+      ...props
+    }
+  );
+}
+function InputGroupTextarea({
+  className,
+  ...props
+}) {
+  return /* @__PURE__ */ jsx12(
+    Textarea,
+    {
+      "data-slot": "input-group-control",
+      className: cn12(
+        "flex-1 resize-none rounded-none border-0 bg-transparent py-3 shadow-none focus-visible:ring-0 dark:bg-transparent",
+        className
+      ),
+      ...props
+    }
+  );
+}
+
+// src/label.tsx
+import * as React11 from "react";
+import * as LabelPrimitive from "@radix-ui/react-label";
+import { cva as cva5 } from "class-variance-authority";
+import { cn as cn13 } from "@petrarca/sonnet-core";
+import { jsx as jsx13 } from "react/jsx-runtime";
+var labelVariants = cva5(
+  "text-sm font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70"
+);
+var Label2 = React11.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx13(
+  LabelPrimitive.Root,
+  {
+    ref,
+    className: cn13(labelVariants(), className),
+    ...props
+  }
+));
+Label2.displayName = LabelPrimitive.Root.displayName;
+
+// src/popover.tsx
+import * as React12 from "react";
+import * as PopoverPrimitive from "@radix-ui/react-popover";
+import { cn as cn14 } from "@petrarca/sonnet-core";
+import { jsx as jsx14 } from "react/jsx-runtime";
+var Popover = PopoverPrimitive.Root;
+var PopoverTrigger = PopoverPrimitive.Trigger;
+var PopoverContent = React12.forwardRef(({ className, align = "center", sideOffset = 4, ...props }, ref) => /* @__PURE__ */ jsx14(PopoverPrimitive.Portal, { children: /* @__PURE__ */ jsx14(
+  PopoverPrimitive.Content,
+  {
+    ref,
+    align,
+    sideOffset,
+    className: cn14(
+      "z-50 w-72 rounded-md border bg-popover p-4 text-popover-foreground shadow-md outline-none data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 origin-[--radix-popover-content-transform-origin]",
+      className
+    ),
+    ...props
+  }
+) }));
+PopoverContent.displayName = PopoverPrimitive.Content.displayName;
+
+// src/scroll-area.tsx
+import * as React13 from "react";
+import * as ScrollAreaPrimitive from "@radix-ui/react-scroll-area";
+import { cn as cn15 } from "@petrarca/sonnet-core";
+import { jsx as jsx15, jsxs as jsxs4 } from "react/jsx-runtime";
+var ScrollArea = React13.forwardRef(({ className, children, ...props }, ref) => /* @__PURE__ */ jsxs4(
+  ScrollAreaPrimitive.Root,
+  {
+    ref,
+    className: cn15("relative overflow-hidden", className),
+    ...props,
+    children: [
+      /* @__PURE__ */ jsx15(ScrollAreaPrimitive.Viewport, { className: "h-full w-full rounded-[inherit]", children }),
+      /* @__PURE__ */ jsx15(ScrollBar, {}),
+      /* @__PURE__ */ jsx15(ScrollAreaPrimitive.Corner, {})
+    ]
+  }
+));
+ScrollArea.displayName = ScrollAreaPrimitive.Root.displayName;
+var ScrollBar = React13.forwardRef(({ className, orientation = "vertical", ...props }, ref) => /* @__PURE__ */ jsx15(
+  ScrollAreaPrimitive.ScrollAreaScrollbar,
+  {
+    ref,
+    orientation,
+    className: cn15(
+      "flex touch-none select-none transition-colors",
+      orientation === "vertical" && "h-full w-2.5 border-l border-l-transparent p-[1px]",
+      orientation === "horizontal" && "h-2.5 flex-col border-t border-t-transparent p-[1px]",
+      className
+    ),
+    ...props,
+    children: /* @__PURE__ */ jsx15(ScrollAreaPrimitive.ScrollAreaThumb, { className: "relative flex-1 rounded-full bg-border" })
+  }
+));
+ScrollBar.displayName = ScrollAreaPrimitive.ScrollAreaScrollbar.displayName;
+
+// src/separator.tsx
+import * as React14 from "react";
+import * as SeparatorPrimitive from "@radix-ui/react-separator";
+import { cn as cn16 } from "@petrarca/sonnet-core";
+import { jsx as jsx16 } from "react/jsx-runtime";
+var Separator2 = React14.forwardRef(
+  ({ className, orientation = "horizontal", decorative = true, ...props }, ref) => /* @__PURE__ */ jsx16(
+    SeparatorPrimitive.Root,
+    {
+      ref,
+      decorative,
+      orientation,
+      className: cn16(
+        "shrink-0 bg-border",
+        orientation === "horizontal" ? "h-[1px] w-full" : "h-full w-[1px]",
+        className
+      ),
+      ...props
+    }
+  )
+);
+Separator2.displayName = SeparatorPrimitive.Root.displayName;
+
+// src/sheet.tsx
+import * as React15 from "react";
+import * as DialogPrimitive2 from "@radix-ui/react-dialog";
+import { X as X2 } from "lucide-react";
+import { cn as cn17 } from "@petrarca/sonnet-core";
+import { jsx as jsx17, jsxs as jsxs5 } from "react/jsx-runtime";
+var Sheet = DialogPrimitive2.Root;
+var SheetTrigger = DialogPrimitive2.Trigger;
+var SheetClose = DialogPrimitive2.Close;
+var SheetPortal = DialogPrimitive2.Portal;
+var SheetOverlay = React15.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx17(
+  DialogPrimitive2.Overlay,
+  {
+    ref,
+    className: cn17(
+      "fixed inset-0 z-50 bg-black/50 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0",
+      className
+    ),
+    ...props
+  }
+));
+SheetOverlay.displayName = "SheetOverlay";
+var SheetContent = React15.forwardRef(
+  ({ className, children, side = "right", offsetTop = "0px", ...props }, ref) => /* @__PURE__ */ jsxs5(SheetPortal, { children: [
+    /* @__PURE__ */ jsx17(SheetOverlay, {}),
+    /* @__PURE__ */ jsxs5(
+      DialogPrimitive2.Content,
+      {
+        ref,
+        className: cn17(
+          "fixed z-50 flex flex-col bg-background shadow-xl transition-transform duration-300 ease-in-out",
+          "bottom-0 w-[480px] max-w-[90vw] border-l",
+          side === "right" && "right-0 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:slide-out-to-right data-[state=open]:slide-in-from-right",
+          side === "left" && "left-0 border-l-0 border-r data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:slide-out-to-left data-[state=open]:slide-in-from-left",
+          className
+        ),
+        style: { top: offsetTop },
+        ...props,
+        children: [
+          children,
+          /* @__PURE__ */ jsxs5(DialogPrimitive2.Close, { className: "absolute right-4 top-4 rounded-sm opacity-70 ring-offset-background transition-opacity hover:opacity-100 focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2", children: [
+            /* @__PURE__ */ jsx17(X2, { className: "h-4 w-4" }),
+            /* @__PURE__ */ jsx17("span", { className: "sr-only", children: "Close" })
+          ] })
+        ]
+      }
+    )
+  ] })
+);
+SheetContent.displayName = "SheetContent";
+var SheetHeader = ({
+  className,
+  ...props
+}) => /* @__PURE__ */ jsx17("div", { className: cn17("shrink-0 border-b px-6 py-4", className), ...props });
+var SheetTitle = React15.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx17(
+  DialogPrimitive2.Title,
+  {
+    ref,
+    className: cn17("text-lg font-semibold", className),
+    ...props
+  }
+));
+SheetTitle.displayName = "SheetTitle";
+var SheetDescription = React15.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx17(
+  DialogPrimitive2.Description,
+  {
+    ref,
+    className: cn17("text-sm text-muted-foreground mt-1", className),
+    ...props
+  }
+));
+SheetDescription.displayName = "SheetDescription";
+var SheetBody = ({
+  className,
+  ...props
+}) => /* @__PURE__ */ jsx17(
+  "div",
+  {
+    className: cn17("flex-1 overflow-y-auto px-6 py-4", className),
+    ...props
+  }
+);
+var SheetFooter = ({
+  className,
+  ...props
+}) => /* @__PURE__ */ jsx17(
+  "div",
+  {
+    className: cn17(
+      "shrink-0 border-t px-6 py-4 flex justify-end gap-2",
+      className
+    ),
+    ...props
+  }
+);
+
+// src/simple-group.tsx
+import { cn as cn18 } from "@petrarca/sonnet-core";
+import { jsx as jsx18 } from "react/jsx-runtime";
+var gapMap = {
+  0: "gap-0",
+  xs: "gap-1",
+  sm: "gap-2",
+  md: "gap-4",
+  lg: "gap-6",
+  xl: "gap-8",
+  2: "gap-0.5",
+  4: "gap-1",
+  6: "gap-1.5",
+  8: "gap-2",
+  24: "gap-6"
+};
+var alignMap = {
+  start: "items-start",
+  center: "items-center",
+  end: "items-end",
+  stretch: "items-stretch",
+  "flex-start": "items-start",
+  "flex-end": "items-end"
+};
+var justifyMap = {
+  start: "justify-start",
+  center: "justify-center",
+  end: "justify-end",
+  between: "justify-between",
+  around: "justify-around",
+  "space-between": "justify-between",
+  "flex-start": "justify-start",
+  "flex-end": "justify-end"
+};
+var wrapMap = {
+  wrap: "flex-wrap",
+  nowrap: "flex-nowrap",
+  "wrap-reverse": "flex-wrap-reverse"
+};
+var mtMap = {
+  xs: "mt-1",
+  sm: "mt-2",
+  md: "mt-4",
+  lg: "mt-6",
+  xl: "mt-8"
+};
+function SimpleGroup({
+  children,
+  gap = "md",
+  align,
+  justify,
+  wrap,
+  grow = false,
+  className,
+  style,
+  mt,
+  onClick
+}) {
+  const gapClass = gapMap[gap] || gapMap.md;
+  const alignClass = align ? alignMap[align] : void 0;
+  const justifyClass = justify ? justifyMap[justify] : void 0;
+  const wrapClass = wrap ? wrapMap[wrap] : void 0;
+  const growClass = grow ? "[&>*]:flex-1" : void 0;
+  const mtClass = mt ? mtMap[mt] : void 0;
+  return /* @__PURE__ */ jsx18(
+    "div",
+    {
+      className: cn18(
+        "flex flex-row",
+        gapClass,
+        alignClass,
+        justifyClass,
+        wrapClass,
+        growClass,
+        mtClass,
+        className
+      ),
+      style,
+      onClick,
+      children
+    }
+  );
+}
+
+// src/simple-stack.tsx
+import { cn as cn19 } from "@petrarca/sonnet-core";
+import { jsx as jsx19 } from "react/jsx-runtime";
+var gapMap2 = {
+  0: "gap-0",
+  xs: "gap-1",
+  sm: "gap-2",
+  md: "gap-4",
+  lg: "gap-6",
+  xl: "gap-8",
+  2: "gap-0.5",
+  4: "gap-1",
+  6: "gap-1.5",
+  8: "gap-2",
+  24: "gap-6"
+};
+var alignMap2 = {
+  start: "items-start",
+  center: "items-center",
+  end: "items-end",
+  stretch: "items-stretch"
+};
+var justifyMap2 = {
+  start: "justify-start",
+  center: "justify-center",
+  end: "justify-end",
+  between: "justify-between",
+  around: "justify-around"
+};
+function SimpleStack({
+  children,
+  gap = "md",
+  align,
+  justify,
+  className,
+  style,
+  h
+}) {
+  const gapClass = gapMap2[gap] || gapMap2.md;
+  const alignClass = align ? alignMap2[align] : void 0;
+  const justifyClass = justify ? justifyMap2[justify] : void 0;
+  const heightStyle = h !== void 0 ? { height: typeof h === "number" ? `${h}px` : h } : void 0;
+  return /* @__PURE__ */ jsx19(
+    "div",
+    {
+      className: cn19(
+        "flex flex-col",
+        gapClass,
+        alignClass,
+        justifyClass,
+        className
+      ),
+      style: { ...heightStyle, ...style },
+      children
+    }
+  );
+}
+
+// src/tooltip.tsx
+import * as React16 from "react";
+import * as TooltipPrimitive from "@radix-ui/react-tooltip";
+import { cn as cn20 } from "@petrarca/sonnet-core";
+import { jsx as jsx20 } from "react/jsx-runtime";
+var TooltipProvider = TooltipPrimitive.Provider;
+var Tooltip = TooltipPrimitive.Root;
+var TooltipTrigger = TooltipPrimitive.Trigger;
+var TooltipContent = React16.forwardRef(({ className, sideOffset = 4, ...props }, ref) => /* @__PURE__ */ jsx20(
+  TooltipPrimitive.Content,
+  {
+    ref,
+    sideOffset,
+    className: cn20(
+      "z-50 overflow-hidden rounded-md border bg-popover px-3 py-1.5 text-sm text-popover-foreground shadow-md animate-in fade-in-0 zoom-in-95 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 origin-[--radix-tooltip-content-transform-origin]",
+      className
+    ),
+    ...props
+  }
+));
+TooltipContent.displayName = TooltipPrimitive.Content.displayName;
+
+// src/simple-tooltip.tsx
+import { jsx as jsx21, jsxs as jsxs6 } from "react/jsx-runtime";
+function SimpleTooltip({
+  label,
+  children,
+  side,
+  align,
+  delayDuration = 700,
+  sideOffset
+}) {
+  return /* @__PURE__ */ jsx21(TooltipProvider, { delayDuration, children: /* @__PURE__ */ jsxs6(Tooltip, { children: [
+    /* @__PURE__ */ jsx21(TooltipTrigger, { asChild: true, children }),
+    /* @__PURE__ */ jsx21(TooltipContent, { side, align, sideOffset, children: label })
+  ] }) });
+}
+
+// src/skeleton.tsx
+import { cn as cn21 } from "@petrarca/sonnet-core";
+import { jsx as jsx22 } from "react/jsx-runtime";
+function Skeleton({
+  className,
+  ...props
+}) {
+  return /* @__PURE__ */ jsx22(
+    "div",
+    {
+      className: cn21("animate-pulse rounded-md bg-muted", className),
+      ...props
+    }
+  );
+}
+
+// src/spinner.tsx
+import { cn as cn22 } from "@petrarca/sonnet-core";
+import { jsx as jsx23 } from "react/jsx-runtime";
+var sizeClasses = {
+  sm: "h-4 w-4 border-2",
+  md: "h-8 w-8 border-2",
+  lg: "h-12 w-12 border-3"
+};
+function Spinner({ className, size = "md" }) {
+  return /* @__PURE__ */ jsx23(
+    "div",
+    {
+      className: cn22(
+        "inline-block animate-spin rounded-full border-solid border-current border-r-transparent align-[-0.125em] motion-reduce:animate-[spin_1.5s_linear_infinite]",
+        sizeClasses[size],
+        className
+      ),
+      role: "status",
+      children: /* @__PURE__ */ jsx23("span", { className: "!absolute !-m-px !h-px !w-px !overflow-hidden !whitespace-nowrap !border-0 !p-0 ![clip:rect(0,0,0,0)]", children: "Loading..." })
+    }
+  );
+}
+
+// src/tabs.tsx
+import * as React17 from "react";
+import * as TabsPrimitive from "@radix-ui/react-tabs";
+import { cn as cn23 } from "@petrarca/sonnet-core";
+import { jsx as jsx24 } from "react/jsx-runtime";
+var Tabs = TabsPrimitive.Root;
+var TabsList = React17.forwardRef(({ className, align = "start", ...props }, ref) => {
+  const alignClass = align === "center" ? "justify-center" : align === "end" ? "justify-end" : "justify-start";
+  return /* @__PURE__ */ jsx24(
+    TabsPrimitive.List,
+    {
+      ref,
+      className: cn23(
+        "inline-flex h-10 items-center rounded-md bg-muted p-1 text-muted-foreground",
+        alignClass,
+        className
+      ),
+      ...props
+    }
+  );
+});
+TabsList.displayName = TabsPrimitive.List.displayName;
+var TabsTrigger = React17.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx24(
+  TabsPrimitive.Trigger,
+  {
+    ref,
+    className: cn23(
+      "inline-flex items-center justify-center whitespace-nowrap rounded-sm px-3 py-1.5 text-sm font-medium ring-offset-background transition-all focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50 data-[state=active]:bg-background data-[state=active]:text-foreground data-[state=active]:shadow-sm",
+      className
+    ),
+    ...props
+  }
+));
+TabsTrigger.displayName = TabsPrimitive.Trigger.displayName;
+var TabsContent = React17.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx24(
+  TabsPrimitive.Content,
+  {
+    ref,
+    className: cn23(
+      "mt-2 ring-offset-background focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2",
+      "data-[state=inactive]:hidden",
+      className
+    ),
+    ...props
+  }
+));
+TabsContent.displayName = TabsPrimitive.Content.displayName;
+
+// src/stepper.tsx
+import { Check as Check3 } from "lucide-react";
+import {
+  Direction as DirectionPrimitive,
+  Slot as SlotPrimitive
+} from "radix-ui";
+import * as React21 from "react";
+import { useComposedRefs } from "@petrarca/sonnet-core";
+import { cn as cn24 } from "@petrarca/sonnet-core";
+
+// src/radix/hooks/use-as-ref.ts
+import * as React19 from "react";
+
+// src/radix/hooks/use-isomorphic-layout-effect.ts
+import * as React18 from "react";
+var useIsomorphicLayoutEffect = typeof window !== "undefined" ? React18.useLayoutEffect : React18.useEffect;
+
+// src/radix/hooks/use-as-ref.ts
+function useAsRef(props) {
+  const ref = React19.useRef(props);
+  useIsomorphicLayoutEffect(() => {
+    ref.current = props;
+  });
+  return ref;
+}
+
+// src/radix/hooks/use-lazy-ref.ts
+import * as React20 from "react";
+function useLazyRef(fn) {
+  const ref = React20.useRef(null);
+  if (ref.current === null) {
+    ref.current = fn();
+  }
+  return ref;
+}
+
+// src/stepper.tsx
+import { jsx as jsx25 } from "react/jsx-runtime";
+var ROOT_NAME = "Stepper";
+var LIST_NAME = "StepperList";
+var ITEM_NAME = "StepperItem";
+var TRIGGER_NAME = "StepperTrigger";
+var INDICATOR_NAME = "StepperIndicator";
+var SEPARATOR_NAME = "StepperSeparator";
+var TITLE_NAME = "StepperTitle";
+var DESCRIPTION_NAME = "StepperDescription";
+var CONTENT_NAME = "StepperContent";
+var PREV_NAME = "StepperPrev";
+var NEXT_NAME = "StepperNext";
+var ENTRY_FOCUS = "stepperFocusGroup.onEntryFocus";
+var EVENT_OPTIONS = { bubbles: false, cancelable: true };
+var ARROW_KEYS = ["ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight"];
+function getId(id, variant, value) {
+  return `${id}-${variant}-${value}`;
+}
+var MAP_KEY_TO_FOCUS_INTENT = {
+  ArrowLeft: "prev",
+  ArrowUp: "prev",
+  ArrowRight: "next",
+  ArrowDown: "next",
+  PageUp: "first",
+  Home: "first",
+  PageDown: "last",
+  End: "last"
+};
+function getDirectionAwareKey(key, dir) {
+  if (dir !== "rtl") return key;
+  return key === "ArrowLeft" ? "ArrowRight" : key === "ArrowRight" ? "ArrowLeft" : key;
+}
+function getFocusIntent(event, dir, orientation) {
+  const key = getDirectionAwareKey(event.key, dir);
+  if (orientation === "horizontal" && ["ArrowUp", "ArrowDown"].includes(key))
+    return void 0;
+  if (orientation === "vertical" && ["ArrowLeft", "ArrowRight"].includes(key))
+    return void 0;
+  return MAP_KEY_TO_FOCUS_INTENT[key];
+}
+function focusFirst(candidates, preventScroll = false) {
+  const PREVIOUSLY_FOCUSED_ELEMENT = document.activeElement;
+  for (const candidateRef of candidates) {
+    const candidate = candidateRef.current;
+    if (!candidate) continue;
+    if (candidate === PREVIOUSLY_FOCUSED_ELEMENT) return;
+    candidate.focus({ preventScroll });
+    if (document.activeElement !== PREVIOUSLY_FOCUSED_ELEMENT) return;
+  }
+}
+function wrapArray(array, startIndex) {
+  return array.map(
+    (_, index) => array[(startIndex + index) % array.length]
+  );
+}
+function handleActivationKeys(event, nonInteractive, activationMode, isDisabled, triggerRef) {
+  if (event.key === "Enter" && nonInteractive) {
+    event.preventDefault();
+    return true;
+  }
+  if ((event.key === "Enter" || event.key === " ") && activationMode === "manual" && !nonInteractive) {
+    event.preventDefault();
+    if (!isDisabled && triggerRef.current) {
+      triggerRef.current.click();
+    }
+    return true;
+  }
+  return false;
+}
+function hasModifierKey(event) {
+  return event.metaKey || event.ctrlKey || event.altKey || event.shiftKey;
+}
+function resolveFocusCandidates(items, focusIntent, currentTarget, loop) {
+  let candidateRefs = items.map((item) => item.ref);
+  if (focusIntent === "last") {
+    candidateRefs.reverse();
+  } else if (focusIntent === "prev" || focusIntent === "next") {
+    if (focusIntent === "prev") candidateRefs.reverse();
+    const currentIndex = candidateRefs.findIndex(
+      (ref) => ref.current === currentTarget
+    );
+    candidateRefs = loop ? wrapArray(candidateRefs, currentIndex + 1) : candidateRefs.slice(currentIndex + 1);
+  }
+  return candidateRefs;
+}
+async function handleValidatedNavigation(store, candidateRefs, items, itemValue, value, steps) {
+  if (!store.hasValidation() || candidateRefs.length === 0) return false;
+  const nextRef = candidateRefs[0];
+  const nextElement = nextRef?.current;
+  const nextItem = items.find((item) => item.ref.current === nextElement);
+  if (!nextItem || nextItem.value === itemValue) return false;
+  const currentStepIndex = Array.from(steps.keys()).indexOf(value || "");
+  const targetStepIndex = Array.from(steps.keys()).indexOf(nextItem.value);
+  const direction = targetStepIndex > currentStepIndex ? "next" : "prev";
+  if (direction === "next") {
+    const isValid = await store.setStateWithValidation(
+      nextItem.value,
+      direction
+    );
+    if (!isValid) return true;
+  } else {
+    store.setState("value", nextItem.value);
+  }
+  queueMicrotask(() => nextElement?.focus());
+  return true;
+}
+function getDataState(value, itemValue, stepState, steps, variant = "item") {
+  const stepKeys = Array.from(steps.keys());
+  const currentIndex = stepKeys.indexOf(itemValue);
+  if (stepState?.completed) return "completed";
+  if (value === itemValue) {
+    return variant === "separator" ? "inactive" : "active";
+  }
+  if (value) {
+    const activeIndex = stepKeys.indexOf(value);
+    if (activeIndex > currentIndex) return "completed";
+  }
+  return "inactive";
+}
+var StoreContext = React21.createContext(null);
+function useStoreContext(consumerName) {
+  const context = React21.useContext(StoreContext);
+  if (!context) {
+    throw new Error(`\`${consumerName}\` must be used within \`${ROOT_NAME}\``);
+  }
+  return context;
+}
+function useStore(selector) {
+  const store = useStoreContext("useStore");
+  const getSnapshot = React21.useCallback(
+    () => selector(store.getState()),
+    [store, selector]
+  );
+  return React21.useSyncExternalStore(store.subscribe, getSnapshot, getSnapshot);
+}
+var StepperContext = React21.createContext(null);
+function useStepperContext(consumerName) {
+  const context = React21.useContext(StepperContext);
+  if (!context) {
+    throw new Error(`\`${consumerName}\` must be used within \`${ROOT_NAME}\``);
+  }
+  return context;
+}
+function Stepper(props) {
+  const {
+    value,
+    defaultValue,
+    onValueChange,
+    onValueComplete,
+    onValueAdd,
+    onValueRemove,
+    onValidate,
+    dir: dirProp,
+    orientation = "horizontal",
+    activationMode = "automatic",
+    asChild,
+    disabled = false,
+    nonInteractive = false,
+    loop = false,
+    className,
+    id,
+    ...rootProps
+  } = props;
+  const listenersRef = useLazyRef(() => /* @__PURE__ */ new Set());
+  const stateRef = useLazyRef(() => ({
+    steps: /* @__PURE__ */ new Map(),
+    value: value ?? defaultValue ?? ""
+  }));
+  const propsRef = useAsRef({
+    onValueChange,
+    onValueComplete,
+    onValueAdd,
+    onValueRemove,
+    onValidate
+  });
+  const store = React21.useMemo(() => {
+    return {
+      subscribe: (cb) => {
+        listenersRef.current.add(cb);
+        return () => listenersRef.current.delete(cb);
+      },
+      getState: () => stateRef.current,
+      setState: (key, value2) => {
+        if (Object.is(stateRef.current[key], value2)) return;
+        if (key === "value" && typeof value2 === "string") {
+          stateRef.current.value = value2;
+          propsRef.current.onValueChange?.(value2);
+        } else {
+          stateRef.current[key] = value2;
+        }
+        store.notify();
+      },
+      setStateWithValidation: async (value2, direction) => {
+        if (!propsRef.current.onValidate) {
+          store.setState("value", value2);
+          return true;
+        }
+        try {
+          const isValid = await propsRef.current.onValidate(value2, direction);
+          if (isValid) {
+            store.setState("value", value2);
+          }
+          return isValid;
+        } catch {
+          return false;
+        }
+      },
+      hasValidation: () => !!propsRef.current.onValidate,
+      addStep: (value2, completed, disabled2) => {
+        const newStep = { value: value2, completed, disabled: disabled2 };
+        stateRef.current.steps.set(value2, newStep);
+        propsRef.current.onValueAdd?.(value2);
+        store.notify();
+      },
+      removeStep: (value2) => {
+        stateRef.current.steps.delete(value2);
+        propsRef.current.onValueRemove?.(value2);
+        store.notify();
+      },
+      setStep: (value2, completed, disabled2) => {
+        const step = stateRef.current.steps.get(value2);
+        if (step) {
+          const updatedStep = { ...step, completed, disabled: disabled2 };
+          stateRef.current.steps.set(value2, updatedStep);
+          if (completed !== step.completed) {
+            propsRef.current.onValueComplete?.(value2, completed);
+          }
+          store.notify();
+        }
+      },
+      notify: () => {
+        for (const cb of listenersRef.current) {
+          cb();
+        }
+      }
+    };
+  }, [listenersRef, stateRef, propsRef]);
+  useIsomorphicLayoutEffect(() => {
+    if (value !== void 0) {
+      store.setState("value", value);
+    }
+  }, [value]);
+  const dir = DirectionPrimitive.useDirection(dirProp);
+  const instanceId = React21.useId();
+  const rootId = id ?? instanceId;
+  const contextValue = React21.useMemo(
+    () => ({
+      rootId,
+      dir,
+      orientation,
+      activationMode,
+      disabled,
+      nonInteractive,
+      loop
+    }),
+    [rootId, dir, orientation, activationMode, disabled, nonInteractive, loop]
+  );
+  const RootPrimitive = asChild ? SlotPrimitive.Slot : "div";
+  return /* @__PURE__ */ jsx25(StoreContext.Provider, { value: store, children: /* @__PURE__ */ jsx25(StepperContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsx25(
+    RootPrimitive,
+    {
+      id: rootId,
+      "data-disabled": disabled ? "" : void 0,
+      "data-orientation": orientation,
+      "data-slot": "stepper",
+      dir,
+      ...rootProps,
+      className: cn24(
+        "flex gap-6",
+        orientation === "horizontal" ? "w-full flex-col" : "flex-row",
+        className
+      )
+    }
+  ) }) });
+}
+var FocusContext = React21.createContext(null);
+function useFocusContext(consumerName) {
+  const context = React21.useContext(FocusContext);
+  if (!context) {
+    throw new Error(
+      `\`${consumerName}\` must be used within \`FocusProvider\``
+    );
+  }
+  return context;
+}
+function StepperList(props) {
+  const {
+    asChild,
+    onBlur: onBlurProp,
+    onFocus: onFocusProp,
+    onMouseDown: onMouseDownProp,
+    className,
+    children,
+    ref,
+    ...listProps
+  } = props;
+  const context = useStepperContext(LIST_NAME);
+  const orientation = context.orientation;
+  const currentValue = useStore((state) => state.value);
+  const propsRef = useAsRef({
+    onBlur: onBlurProp,
+    onFocus: onFocusProp,
+    onMouseDown: onMouseDownProp
+  });
+  const [tabStopId, setTabStopId] = React21.useState(null);
+  const [isTabbingBackOut, setIsTabbingBackOut] = React21.useState(false);
+  const [focusableItemCount, setFocusableItemCount] = React21.useState(0);
+  const isClickFocusRef = React21.useRef(false);
+  const itemsRef = React21.useRef(/* @__PURE__ */ new Map());
+  const listRef = React21.useRef(null);
+  const composedRef = useComposedRefs(ref, listRef);
+  const onItemFocus = React21.useCallback((tabStopId2) => {
+    setTabStopId(tabStopId2);
+  }, []);
+  const onItemShiftTab = React21.useCallback(() => {
+    setIsTabbingBackOut(true);
+  }, []);
+  const onFocusableItemAdd = React21.useCallback(() => {
+    setFocusableItemCount((prevCount) => prevCount + 1);
+  }, []);
+  const onFocusableItemRemove = React21.useCallback(() => {
+    setFocusableItemCount((prevCount) => prevCount - 1);
+  }, []);
+  const onItemRegister = React21.useCallback((item) => {
+    itemsRef.current.set(item.id, item);
+  }, []);
+  const onItemUnregister = React21.useCallback((id) => {
+    itemsRef.current.delete(id);
+  }, []);
+  const getItems = React21.useCallback(() => {
+    return Array.from(itemsRef.current.values()).filter((item) => item.ref.current).sort((a, b) => {
+      const elementA = a.ref.current;
+      const elementB = b.ref.current;
+      if (!elementA || !elementB) return 0;
+      const position = elementA.compareDocumentPosition(elementB);
+      if (position & Node.DOCUMENT_POSITION_FOLLOWING) {
+        return -1;
+      }
+      if (position & Node.DOCUMENT_POSITION_PRECEDING) {
+        return 1;
+      }
+      return 0;
+    });
+  }, []);
+  const onBlur = React21.useCallback(
+    (event) => {
+      propsRef.current.onBlur?.(event);
+      if (event.defaultPrevented) return;
+      setIsTabbingBackOut(false);
+    },
+    [propsRef]
+  );
+  const onFocus = React21.useCallback(
+    (event) => {
+      propsRef.current.onFocus?.(event);
+      if (event.defaultPrevented) return;
+      const isKeyboardFocus = !isClickFocusRef.current;
+      if (event.target === event.currentTarget && isKeyboardFocus && !isTabbingBackOut) {
+        const entryFocusEvent = new CustomEvent(ENTRY_FOCUS, EVENT_OPTIONS);
+        event.currentTarget.dispatchEvent(entryFocusEvent);
+        if (!entryFocusEvent.defaultPrevented) {
+          const items = Array.from(itemsRef.current.values()).filter(
+            (item) => !item.disabled
+          );
+          const selectedItem = currentValue ? items.find((item) => item.value === currentValue) : void 0;
+          const activeItem = items.find((item) => item.active);
+          const currentItem = items.find((item) => item.id === tabStopId);
+          const candidateItems = [
+            selectedItem,
+            activeItem,
+            currentItem,
+            ...items
+          ].filter(Boolean);
+          const candidateRefs = candidateItems.map((item) => item.ref);
+          focusFirst(candidateRefs, false);
+        }
+      }
+      isClickFocusRef.current = false;
+    },
+    [propsRef, isTabbingBackOut, currentValue, tabStopId]
+  );
+  const onMouseDown = React21.useCallback(
+    (event) => {
+      propsRef.current.onMouseDown?.(event);
+      if (event.defaultPrevented) return;
+      isClickFocusRef.current = true;
+    },
+    [propsRef]
+  );
+  const focusContextValue = React21.useMemo(
+    () => ({
+      tabStopId,
+      onItemFocus,
+      onItemShiftTab,
+      onFocusableItemAdd,
+      onFocusableItemRemove,
+      onItemRegister,
+      onItemUnregister,
+      getItems
+    }),
+    [
+      tabStopId,
+      onItemFocus,
+      onItemShiftTab,
+      onFocusableItemAdd,
+      onFocusableItemRemove,
+      onItemRegister,
+      onItemUnregister,
+      getItems
+    ]
+  );
+  const ListPrimitive = asChild ? SlotPrimitive.Slot : "div";
+  return /* @__PURE__ */ jsx25(FocusContext.Provider, { value: focusContextValue, children: /* @__PURE__ */ jsx25(
+    ListPrimitive,
+    {
+      role: "tablist",
+      "aria-orientation": orientation,
+      "data-orientation": orientation,
+      "data-slot": "stepper-list",
+      dir: context.dir,
+      tabIndex: isTabbingBackOut || focusableItemCount === 0 ? -1 : 0,
+      ...listProps,
+      ref: composedRef,
+      className: cn24(
+        "flex outline-none",
+        orientation === "horizontal" ? "flex-row items-center" : "flex-col items-start",
+        className
+      ),
+      onBlur,
+      onFocus,
+      onMouseDown,
+      children
+    }
+  ) });
+}
+var StepperItemContext = React21.createContext(
+  null
+);
+function useStepperItemContext(consumerName) {
+  const context = React21.useContext(StepperItemContext);
+  if (!context) {
+    throw new Error(`\`${consumerName}\` must be used within \`${ITEM_NAME}\``);
+  }
+  return context;
+}
+function StepperItem(props) {
+  const {
+    value: itemValue,
+    completed = false,
+    disabled = false,
+    asChild,
+    className,
+    children,
+    ref,
+    ...itemProps
+  } = props;
+  const context = useStepperContext(ITEM_NAME);
+  const store = useStoreContext(ITEM_NAME);
+  const orientation = context.orientation;
+  const value = useStore((state) => state.value);
+  useIsomorphicLayoutEffect(() => {
+    store.addStep(itemValue, completed, disabled);
+    return () => {
+      store.removeStep(itemValue);
+    };
+  }, [itemValue, completed, disabled]);
+  useIsomorphicLayoutEffect(() => {
+    store.setStep(itemValue, completed, disabled);
+  }, [itemValue, completed, disabled]);
+  const stepState = useStore((state) => state.steps.get(itemValue));
+  const steps = useStore((state) => state.steps);
+  const dataState = getDataState(value, itemValue, stepState, steps);
+  const itemContextValue = React21.useMemo(
+    () => ({
+      value: itemValue,
+      stepState
+    }),
+    [itemValue, stepState]
+  );
+  const ItemPrimitive = asChild ? SlotPrimitive.Slot : "div";
+  return /* @__PURE__ */ jsx25(StepperItemContext.Provider, { value: itemContextValue, children: /* @__PURE__ */ jsx25(
+    ItemPrimitive,
+    {
+      "data-disabled": stepState?.disabled ? "" : void 0,
+      "data-orientation": orientation,
+      "data-state": dataState,
+      "data-slot": "stepper-item",
+      dir: context.dir,
+      ...itemProps,
+      ref,
+      className: cn24(
+        "relative flex not-last:flex-1 items-center",
+        orientation === "horizontal" ? "flex-row" : "flex-col",
+        className
+      ),
+      children
+    }
+  ) });
+}
+function StepperTrigger(props) {
+  const {
+    asChild,
+    onClick: onClickProp,
+    onFocus: onFocusProp,
+    onKeyDown: onKeyDownProp,
+    onMouseDown: onMouseDownProp,
+    disabled,
+    className,
+    ref,
+    ...triggerProps
+  } = props;
+  const context = useStepperContext(TRIGGER_NAME);
+  const itemContext = useStepperItemContext(TRIGGER_NAME);
+  const itemValue = itemContext.value;
+  const store = useStoreContext(TRIGGER_NAME);
+  const focusContext = useFocusContext(TRIGGER_NAME);
+  const value = useStore((state) => state.value);
+  const steps = useStore((state) => state.steps);
+  const stepState = useStore((state) => state.steps.get(itemValue));
+  const propsRef = useAsRef({
+    onClick: onClickProp,
+    onFocus: onFocusProp,
+    onKeyDown: onKeyDownProp,
+    onMouseDown: onMouseDownProp
+  });
+  const activationMode = context.activationMode;
+  const orientation = context.orientation;
+  const loop = context.loop;
+  const stepIndex = Array.from(steps.keys()).indexOf(itemValue);
+  const stepPosition = stepIndex + 1;
+  const stepCount = steps.size;
+  const triggerId = getId(context.rootId, "trigger", itemValue);
+  const contentId = getId(context.rootId, "content", itemValue);
+  const titleId = getId(context.rootId, "title", itemValue);
+  const descriptionId = getId(context.rootId, "description", itemValue);
+  const isDisabled = disabled || stepState?.disabled || context.disabled;
+  const isActive = value === itemValue;
+  const isTabStop = focusContext.tabStopId === triggerId;
+  const dataState = getDataState(value, itemValue, stepState, steps);
+  const triggerRef = React21.useRef(null);
+  const composedRef = useComposedRefs(ref, triggerRef);
+  const isArrowKeyPressedRef = React21.useRef(false);
+  const isMouseClickRef = React21.useRef(false);
+  React21.useEffect(() => {
+    function onKeyDown2(event) {
+      if (ARROW_KEYS.includes(event.key)) {
+        isArrowKeyPressedRef.current = true;
+      }
+    }
+    function onKeyUp() {
+      isArrowKeyPressedRef.current = false;
+    }
+    document.addEventListener("keydown", onKeyDown2);
+    document.addEventListener("keyup", onKeyUp);
+    return () => {
+      document.removeEventListener("keydown", onKeyDown2);
+      document.removeEventListener("keyup", onKeyUp);
+    };
+  }, []);
+  useIsomorphicLayoutEffect(() => {
+    focusContext.onItemRegister({
+      id: triggerId,
+      ref: triggerRef,
+      value: itemValue,
+      active: isTabStop,
+      disabled: !!isDisabled
+    });
+    if (!isDisabled) {
+      focusContext.onFocusableItemAdd();
+    }
+    return () => {
+      focusContext.onItemUnregister(triggerId);
+      if (!isDisabled) {
+        focusContext.onFocusableItemRemove();
+      }
+    };
+  }, [focusContext, triggerId, itemValue, isTabStop, isDisabled]);
+  const onClick = React21.useCallback(
+    async (event) => {
+      propsRef.current.onClick?.(event);
+      if (event.defaultPrevented) return;
+      if (!isDisabled && !context.nonInteractive) {
+        const currentStepIndex = Array.from(steps.keys()).indexOf(value ?? "");
+        const targetStepIndex = Array.from(steps.keys()).indexOf(itemValue);
+        const direction = targetStepIndex > currentStepIndex ? "next" : "prev";
+        await store.setStateWithValidation(itemValue, direction);
+      }
+    },
+    [
+      isDisabled,
+      context.nonInteractive,
+      store,
+      itemValue,
+      value,
+      steps,
+      propsRef
+    ]
+  );
+  const onFocus = React21.useCallback(
+    async (event) => {
+      propsRef.current.onFocus?.(event);
+      if (event.defaultPrevented) return;
+      focusContext.onItemFocus(triggerId);
+      const isKeyboardFocus = !isMouseClickRef.current;
+      if (!isActive && !isDisabled && activationMode !== "manual" && !context.nonInteractive && isKeyboardFocus) {
+        const currentStepIndex = Array.from(steps.keys()).indexOf(value || "");
+        const targetStepIndex = Array.from(steps.keys()).indexOf(itemValue);
+        const direction = targetStepIndex > currentStepIndex ? "next" : "prev";
+        await store.setStateWithValidation(itemValue, direction);
+      }
+      isMouseClickRef.current = false;
+    },
+    [
+      focusContext,
+      triggerId,
+      activationMode,
+      isActive,
+      isDisabled,
+      context.nonInteractive,
+      store,
+      itemValue,
+      value,
+      steps,
+      propsRef
+    ]
+  );
+  const onKeyDown = React21.useCallback(
+    async (event) => {
+      propsRef.current.onKeyDown?.(event);
+      if (event.defaultPrevented) return;
+      if (handleActivationKeys(
+        event,
+        context.nonInteractive,
+        activationMode,
+        isDisabled,
+        triggerRef
+      ))
+        return;
+      if (event.key === "Tab" && event.shiftKey) {
+        focusContext.onItemShiftTab();
+        return;
+      }
+      if (event.target !== event.currentTarget) return;
+      const focusIntent = getFocusIntent(event, context.dir, orientation);
+      if (focusIntent !== void 0) {
+        if (hasModifierKey(event)) return;
+        event.preventDefault();
+        const items = focusContext.getItems().filter((item) => !item.disabled);
+        const candidateRefs = resolveFocusCandidates(
+          items,
+          focusIntent,
+          event.currentTarget,
+          loop
+        );
+        const didNavigate = await handleValidatedNavigation(
+          store,
+          candidateRefs,
+          items,
+          itemValue,
+          value,
+          steps
+        );
+        if (didNavigate) return;
+        queueMicrotask(() => focusFirst(candidateRefs));
+      }
+    },
+    [
+      focusContext,
+      context.nonInteractive,
+      context.dir,
+      activationMode,
+      orientation,
+      loop,
+      isDisabled,
+      store,
+      propsRef,
+      itemValue,
+      value,
+      steps
+    ]
+  );
+  const onMouseDown = React21.useCallback(
+    (event) => {
+      propsRef.current.onMouseDown?.(event);
+      if (event.defaultPrevented) return;
+      isMouseClickRef.current = true;
+      if (isDisabled) {
+        event.preventDefault();
+      } else {
+        focusContext.onItemFocus(triggerId);
+      }
+    },
+    [focusContext, triggerId, isDisabled, propsRef]
+  );
+  const TriggerPrimitive = asChild ? SlotPrimitive.Slot : "button";
+  return /* @__PURE__ */ jsx25(
+    TriggerPrimitive,
+    {
+      id: triggerId,
+      role: "tab",
+      type: "button",
+      "aria-controls": contentId,
+      "aria-current": isActive ? "step" : void 0,
+      "aria-describedby": `${titleId} ${descriptionId}`,
+      "aria-posinset": stepPosition,
+      "aria-selected": isActive,
+      "aria-setsize": stepCount,
+      "data-disabled": isDisabled ? "" : void 0,
+      "data-state": dataState,
+      "data-slot": "stepper-trigger",
+      disabled: isDisabled,
+      tabIndex: isTabStop ? 0 : -1,
+      ...triggerProps,
+      ref: composedRef,
+      className: cn24(
+        "inline-flex items-center justify-center gap-3 rounded-md text-left outline-none transition-all focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50 disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 [&_svg:not([class*='size-'])]:size-4 [&_svg]:pointer-events-none [&_svg]:shrink-0",
+        "not-has-data-[slot=description]:rounded-full not-has-data-[slot=title]:rounded-full",
+        className
+      ),
+      onClick,
+      onFocus,
+      onKeyDown,
+      onMouseDown
+    }
+  );
+}
+function StepperIndicator(props) {
+  const { className, children, asChild, ref, ...indicatorProps } = props;
+  const context = useStepperContext(INDICATOR_NAME);
+  const itemContext = useStepperItemContext(INDICATOR_NAME);
+  const value = useStore((state) => state.value);
+  const itemValue = itemContext.value;
+  const stepState = useStore((state) => state.steps.get(itemValue));
+  const steps = useStore((state) => state.steps);
+  const stepPosition = Array.from(steps.keys()).indexOf(itemValue) + 1;
+  const dataState = getDataState(value, itemValue, stepState, steps);
+  const IndicatorPrimitive = asChild ? SlotPrimitive.Slot : "div";
+  return /* @__PURE__ */ jsx25(
+    IndicatorPrimitive,
+    {
+      "data-state": dataState,
+      "data-slot": "stepper-indicator",
+      dir: context.dir,
+      ...indicatorProps,
+      ref,
+      className: cn24(
+        "flex size-7 shrink-0 items-center justify-center rounded-full border-2 border-muted bg-background font-medium text-muted-foreground text-sm transition-colors data-[state=active]:border-primary data-[state=completed]:border-primary data-[state=active]:bg-primary data-[state=completed]:bg-primary data-[state=active]:text-primary-foreground data-[state=completed]:text-primary-foreground",
+        className
+      ),
+      children: typeof children === "function" ? children(dataState) : children ? children : dataState === "completed" ? /* @__PURE__ */ jsx25(Check3, { className: "size-4" }) : stepPosition
+    }
+  );
+}
+function StepperSeparator(props) {
+  const {
+    className,
+    asChild,
+    forceMount = false,
+    ref,
+    ...separatorProps
+  } = props;
+  const context = useStepperContext(SEPARATOR_NAME);
+  const itemContext = useStepperItemContext(SEPARATOR_NAME);
+  const value = useStore((state) => state.value);
+  const steps = useStore((state) => state.steps);
+  const orientation = context.orientation;
+  const stepIndex = Array.from(steps.keys()).indexOf(itemContext.value);
+  const isLastStep = stepIndex === steps.size - 1;
+  if (isLastStep && !forceMount) return null;
+  const dataState = getDataState(
+    value,
+    itemContext.value,
+    itemContext.stepState,
+    steps,
+    "separator"
+  );
+  const SeparatorPrimitive2 = asChild ? SlotPrimitive.Slot : "div";
+  return /* @__PURE__ */ jsx25(
+    SeparatorPrimitive2,
+    {
+      role: "separator",
+      "aria-hidden": "true",
+      "aria-orientation": orientation,
+      "data-orientation": orientation,
+      "data-state": dataState,
+      "data-slot": "stepper-separator",
+      dir: context.dir,
+      ...separatorProps,
+      ref,
+      className: cn24(
+        "bg-border transition-colors data-[state=active]:bg-primary data-[state=completed]:bg-primary",
+        orientation === "horizontal" ? "h-px flex-1" : "h-10 w-px",
+        className
+      )
+    }
+  );
+}
+function StepperTitle(props) {
+  const { className, asChild, ref, ...titleProps } = props;
+  const context = useStepperContext(TITLE_NAME);
+  const itemContext = useStepperItemContext(TITLE_NAME);
+  const titleId = getId(context.rootId, "title", itemContext.value);
+  const TitlePrimitive = asChild ? SlotPrimitive.Slot : "span";
+  return /* @__PURE__ */ jsx25(
+    TitlePrimitive,
+    {
+      id: titleId,
+      "data-slot": "title",
+      dir: context.dir,
+      ...titleProps,
+      ref,
+      className: cn24("font-medium text-sm", className)
+    }
+  );
+}
+function StepperDescription(props) {
+  const { className, asChild, ref, ...descriptionProps } = props;
+  const context = useStepperContext(DESCRIPTION_NAME);
+  const itemContext = useStepperItemContext(DESCRIPTION_NAME);
+  const descriptionId = getId(context.rootId, "description", itemContext.value);
+  const DescriptionPrimitive = asChild ? SlotPrimitive.Slot : "span";
+  return /* @__PURE__ */ jsx25(
+    DescriptionPrimitive,
+    {
+      id: descriptionId,
+      "data-slot": "description",
+      dir: context.dir,
+      ...descriptionProps,
+      ref,
+      className: cn24("text-muted-foreground text-xs", className)
+    }
+  );
+}
+function StepperContent(props) {
+  const {
+    value: valueProp,
+    asChild,
+    forceMount = false,
+    ref,
+    className,
+    ...contentProps
+  } = props;
+  const context = useStepperContext(CONTENT_NAME);
+  const value = useStore((state) => state.value);
+  const contentId = getId(context.rootId, "content", valueProp);
+  const triggerId = getId(context.rootId, "trigger", valueProp);
+  if (valueProp !== value && !forceMount) return null;
+  const ContentPrimitive = asChild ? SlotPrimitive.Slot : "div";
+  return /* @__PURE__ */ jsx25(
+    ContentPrimitive,
+    {
+      id: contentId,
+      role: "tabpanel",
+      "aria-labelledby": triggerId,
+      "data-slot": "stepper-content",
+      dir: context.dir,
+      ...contentProps,
+      ref,
+      className: cn24("flex-1 outline-none", className)
+    }
+  );
+}
+function StepperPrev(props) {
+  const { asChild, onClick: onClickProp, disabled, ...prevProps } = props;
+  const store = useStoreContext(PREV_NAME);
+  const value = useStore((state) => state.value);
+  const steps = useStore((state) => state.steps);
+  const propsRef = useAsRef({
+    onClick: onClickProp
+  });
+  const stepKeys = Array.from(steps.keys());
+  const currentIndex = value ? stepKeys.indexOf(value) : -1;
+  const isDisabled = disabled || currentIndex <= 0;
+  const onClick = React21.useCallback(
+    async (event) => {
+      propsRef.current.onClick?.(event);
+      if (event.defaultPrevented || isDisabled) return;
+      const prevIndex = Math.max(currentIndex - 1, 0);
+      const prevStepValue = stepKeys[prevIndex];
+      if (prevStepValue) {
+        store.setState("value", prevStepValue);
+      }
+    },
+    [propsRef, isDisabled, currentIndex, stepKeys, store]
+  );
+  const PrevPrimitive = asChild ? SlotPrimitive.Slot : "button";
+  return /* @__PURE__ */ jsx25(
+    PrevPrimitive,
+    {
+      type: "button",
+      "data-slot": "stepper-prev",
+      disabled: isDisabled,
+      ...prevProps,
+      onClick
+    }
+  );
+}
+function StepperNext(props) {
+  const { asChild, onClick: onClickProp, disabled, ...nextProps } = props;
+  const store = useStoreContext(NEXT_NAME);
+  const value = useStore((state) => state.value);
+  const steps = useStore((state) => state.steps);
+  const propsRef = useAsRef({
+    onClick: onClickProp
+  });
+  const stepKeys = Array.from(steps.keys());
+  const currentIndex = value ? stepKeys.indexOf(value) : -1;
+  const isDisabled = disabled || currentIndex >= stepKeys.length - 1;
+  const onClick = React21.useCallback(
+    async (event) => {
+      propsRef.current.onClick?.(event);
+      if (event.defaultPrevented || isDisabled) return;
+      const nextIndex = Math.min(currentIndex + 1, stepKeys.length - 1);
+      const nextStepValue = stepKeys[nextIndex];
+      if (nextStepValue) {
+        await store.setStateWithValidation(nextStepValue, "next");
+      }
+    },
+    [propsRef, isDisabled, currentIndex, stepKeys, store]
+  );
+  const NextPrimitive = asChild ? SlotPrimitive.Slot : "button";
+  return /* @__PURE__ */ jsx25(
+    NextPrimitive,
+    {
+      type: "button",
+      "data-slot": "stepper-next",
+      disabled: isDisabled,
+      ...nextProps,
+      onClick
+    }
+  );
+}
+
+// src/EntityTable/EntityTable.tsx
+import {
+  useCallback as useCallback2,
+  useEffect as useEffect3,
+  useMemo as useMemo2,
+  useRef as useRef4,
+  useState as useState2
+} from "react";
+import {
+  flexRender,
+  getCoreRowModel,
+  useReactTable
+} from "@tanstack/react-table";
+import { ChevronRight as ChevronRight2 } from "lucide-react";
+import { cn as cn25 } from "@petrarca/sonnet-core";
+
+// src/EntityTable/tableSchema/mergeUiSchema.ts
+function resolveCellRenderer(property, uiEntry) {
+  return uiEntry?.["x-ui-cell"] ?? property["x-ui-cell"];
+}
+function resolveCellOptions(property, uiEntry) {
+  return {
+    ...property["x-ui-cell-options"] ?? {},
+    ...uiEntry?.["x-ui-cell-options"] ?? {}
+  };
+}
+function mergeColumnConfig(key, property, uiSchema) {
+  const uiEntry = uiSchema?.[key];
+  const merged = {
+    ...property["x-ui-column"] ?? {},
+    ...uiEntry?.["x-ui-column"] ?? {}
+  };
+  return {
+    order: merged.order,
+    hidden: merged.hidden ?? false,
+    width: merged.width,
+    minWidth: merged.minWidth,
+    label: merged.label,
+    cellRenderer: resolveCellRenderer(property, uiEntry),
+    cellOptions: resolveCellOptions(property, uiEntry)
+  };
+}
+
+// src/EntityTable/tableSchema/cellRegistry.ts
+import React22 from "react";
+import { warnLog } from "@petrarca/sonnet-core";
+
+// src/EntityTable/tableSchema/cellRenderers.tsx
+import { formatDate, formatDateTime } from "@petrarca/sonnet-core";
+import { Fragment, jsx as jsx26, jsxs as jsxs7 } from "react/jsx-runtime";
+function resolveValue(value, options) {
+  const key = options.valueKey;
+  if (key && value != null && typeof value === "object") {
+    return value[key];
+  }
+  return value;
+}
+function cx(base, options) {
+  return options.nowrap ? [base, "whitespace-nowrap"].filter(Boolean).join(" ") : base;
+}
+function TextCell({
+  value,
+  options
+}) {
+  const text = resolveValue(value, options);
+  return /* @__PURE__ */ jsx26("span", { className: cx("", options), children: text == null ? "\u2014" : String(text) });
+}
+function MutedCell({
+  value,
+  options
+}) {
+  const text = resolveValue(value, options);
+  return /* @__PURE__ */ jsx26("span", { className: cx("text-muted-foreground", options), children: text == null ? "\u2014" : String(text) });
+}
+function BoldCell({
+  value,
+  options
+}) {
+  const text = resolveValue(value, options);
+  return /* @__PURE__ */ jsx26("span", { className: cx("font-medium", options), children: text == null ? "\u2014" : String(text) });
+}
+function CodeCell({
+  value,
+  options
+}) {
+  const text = resolveValue(value, options);
+  return /* @__PURE__ */ jsx26("span", { className: cx("font-mono text-xs", options), children: text == null ? "\u2014" : String(text) });
+}
+function BadgeCell({
+  value,
+  options
+}) {
+  if (value == null)
+    return /* @__PURE__ */ jsx26("span", { className: "text-muted-foreground", children: "\u2014" });
+  const key = String(value);
+  const colors = options.colors;
+  const labels = options.labels;
+  const color = colors?.[key];
+  const label = labels?.[key] ?? key;
+  return /* @__PURE__ */ jsx26(Badge, { badgeColor: color, children: label });
+}
+function DateCell({
+  value,
+  options
+}) {
+  return /* @__PURE__ */ jsx26("span", { className: cx("text-muted-foreground", options), children: formatDate(value) });
+}
+function DateTimeCell({
+  value,
+  options
+}) {
+  return /* @__PURE__ */ jsx26("span", { className: cx("text-muted-foreground", options), children: formatDateTime(value) });
+}
+function BooleanCell({ value }) {
+  return /* @__PURE__ */ jsx26("span", { className: value ? "text-green-600" : "text-muted-foreground", children: value ? "Yes" : "No" });
+}
+function NumberCell({ value }) {
+  const text = value == null ? "\u2014" : String(value);
+  return /* @__PURE__ */ jsx26("span", { className: "tabular-nums", children: text });
+}
+function TruncateCell({
+  value,
+  options
+}) {
+  const resolved = resolveValue(value, options);
+  const text = resolved == null ? "\u2014" : String(resolved);
+  return /* @__PURE__ */ jsx26("span", { className: "block truncate max-w-xs", title: text, children: text });
+}
+function OverflowListCell({
+  value,
+  options
+}) {
+  const items = Array.isArray(value) ? value : [];
+  if (items.length === 0)
+    return /* @__PURE__ */ jsx26("span", { className: "text-muted-foreground", children: "\u2014" });
+  const displayKey = options.displayKey;
+  const fallbackKey = options.fallbackKey;
+  const prefixKey = options.prefixKey;
+  const first = items[0];
+  const label = displayKey && first[displayKey] || fallbackKey && first[fallbackKey] || "";
+  return /* @__PURE__ */ jsxs7(Fragment, { children: [
+    prefixKey && /* @__PURE__ */ jsxs7("span", { className: "text-muted-foreground", children: [
+      String(first[prefixKey]),
+      ":",
+      " "
+    ] }),
+    label,
+    items.length > 1 && /* @__PURE__ */ jsxs7("span", { className: "text-muted-foreground ml-1", children: [
+      "+",
+      items.length - 1
+    ] })
+  ] });
+}
+function JoinCell({
+  value,
+  options
+}) {
+  const sep = options.separator ?? ", ";
+  if (!Array.isArray(value) || value.length === 0)
+    return /* @__PURE__ */ jsx26("span", { className: "text-muted-foreground", children: "\u2014" });
+  return /* @__PURE__ */ jsx26("span", { className: "text-muted-foreground", children: value.join(sep) });
+}
+
+// src/EntityTable/tableSchema/cellRegistry.ts
+var CELL_RENDERERS = {
+  text: TextCell,
+  muted: MutedCell,
+  bold: BoldCell,
+  code: CodeCell,
+  badge: BadgeCell,
+  date: DateCell,
+  datetime: DateTimeCell,
+  boolean: BooleanCell,
+  number: NumberCell,
+  truncate: TruncateCell,
+  "overflow-list": OverflowListCell,
+  join: JoinCell
+};
+function inferCellRenderer(type, format) {
+  if (type === "boolean") return "boolean";
+  if (type === "number" || type === "integer") return "number";
+  if (type === "string") {
+    if (format === "date-time") return "datetime";
+    if (format === "date") return "date";
+  }
+  return "text";
+}
+function resolveCellRenderer2(name, localRenderers) {
+  return localRenderers?.[name] ?? CELL_RENDERERS[name] ?? TextCell;
+}
+function createRenderer(render) {
+  return ({ row, options }) => React22.createElement(React22.Fragment, null, render(row, options));
+}
+function validateRendererNames(renderers) {
+  for (const name of Object.keys(renderers)) {
+    if (!name.startsWith("x-")) {
+      warnLog(
+        `[EntityTable] Local renderer "${name}" should use the x- prefix (e.g. "x-${name}"). Built-in renderer names are unprefixed.`
+      );
+    }
+  }
+}
+
+// src/EntityTable/tableSchema/columnResolver.ts
+function resolveColumns(schema, uiSchema) {
+  const properties = schema.properties ?? {};
+  const entries = Object.entries(properties).map(([key, property]) => {
+    const config = mergeColumnConfig(key, property, uiSchema);
+    return { key, property, config };
+  }).filter(({ config }) => !config.hidden);
+  const ordered = entries.filter(({ config }) => config.order !== void 0).sort((a, b) => a.config.order - b.config.order);
+  const unordered = entries.filter(({ config }) => config.order === void 0).sort((a, b) => a.key.localeCompare(b.key));
+  const sorted = [...ordered, ...unordered];
+  return sorted.map(({ key, property, config }) => {
+    const cellRenderer = config.cellRenderer ?? inferCellRenderer(property.type, property.format);
+    const label = config.label ?? property.title ?? keyToLabel(key);
+    return {
+      key,
+      label,
+      property,
+      cellRenderer,
+      cellOptions: config.cellOptions,
+      width: config.width,
+      minWidth: config.minWidth
+    };
+  });
+}
+function keyToLabel(key) {
+  return key.replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+
+// src/EntityTable/EntityTable.tsx
+import { jsx as jsx27, jsxs as jsxs8 } from "react/jsx-runtime";
+var coreRowModel = getCoreRowModel();
+function resolveTableDefaults(props) {
+  return {
+    isFiltered: props.isFiltered ?? false,
+    selectionMode: props.selectionMode ?? false
+  };
+}
+function buildColumnDefs(resolved, localRenderers) {
+  return resolved.map((col) => {
+    const Renderer = resolveCellRenderer2(col.cellRenderer, localRenderers);
+    const options = col.cellOptions;
+    const colDef = {
+      id: col.key,
+      accessorKey: col.key,
+      header: col.label,
+      cell: ({
+        getValue,
+        row
+      }) => /* @__PURE__ */ jsx27(
+        Renderer,
+        {
+          value: getValue(),
+          row: row.original,
+          options
+        }
+      )
+    };
+    if (col.width !== void 0) colDef.size = col.width;
+    if (col.minWidth !== void 0) colDef.minSize = col.minWidth;
+    return colDef;
+  });
+}
+function buildSelectColumn() {
+  return {
+    id: "_select",
+    size: 40,
+    header: ({ table: t }) => /* @__PURE__ */ jsx27(
+      Checkbox,
+      {
+        checked: t.getIsAllPageRowsSelected() || (t.getIsSomePageRowsSelected() ? "indeterminate" : false),
+        onCheckedChange: (value) => t.toggleAllPageRowsSelected(!!value),
+        "aria-label": "Select all"
+      }
+    ),
+    cell: ({ row }) => /* @__PURE__ */ jsx27(
+      Checkbox,
+      {
+        checked: row.getIsSelected(),
+        onCheckedChange: (value) => row.toggleSelected(!!value),
+        onClick: (e) => e.stopPropagation(),
+        "aria-label": "Select row"
+      }
+    )
+  };
+}
+function buildTableOptions(opts) {
+  const base = {
+    data: opts.dataRows,
+    columns: opts.columns,
+    getCoreRowModel: coreRowModel,
+    state: opts.tableState
+  };
+  const selectionOpts = opts.selectionMode ? { enableRowSelection: true, onRowSelectionChange: opts.setRowSelection } : {};
+  const paginationOpts = opts.isPaginated ? {
+    manualPagination: true,
+    rowCount: opts.data?.meta.total ?? 0,
+    onPaginationChange: opts.onPaginationChange
+  } : {};
+  return { ...base, ...selectionOpts, ...paginationOpts };
+}
+function useEntityTableState(props, selectionMode) {
+  const {
+    schema,
+    uiSchema,
+    renderers,
+    data,
+    pagination,
+    onPaginationChange,
+    onSelectionChange
+  } = props;
+  const isPaginated = !!(pagination && onPaginationChange);
+  const dataRows = useMemo2(() => data?.data ?? [], [data]);
+  const total = data?.meta.total;
+  const pageIndex = pagination?.pageIndex ?? 0;
+  const pageSize = pagination?.pageSize ?? 1;
+  useEffect3(() => {
+    if (!isPaginated || total == null || !onPaginationChange) return;
+    const maxPage = Math.max(0, Math.ceil(total / pageSize) - 1);
+    if (pageIndex > maxPage) {
+      onPaginationChange((prev) => ({ ...prev, pageIndex: maxPage }));
+    }
+  }, [total, isPaginated, pageIndex, pageSize, onPaginationChange]);
+  const [rowSelection, setRowSelection] = useState2({});
+  useEffect3(() => {
+    setRowSelection({});
+  }, [data]);
+  const [activeRowIndex, setActiveRowIndex] = useState2(-1);
+  const containerRef = useRef4(null);
+  const dataColumns = useMemo2(() => {
+    if (renderers) validateRendererNames(renderers);
+    return buildColumnDefs(resolveColumns(schema, uiSchema), renderers);
+  }, [schema, uiSchema, renderers]);
+  const selectColumn = useMemo2(
+    () => selectionMode ? buildSelectColumn() : null,
+    [selectionMode]
+  );
+  const columns = useMemo2(
+    () => selectColumn ? [selectColumn, ...dataColumns] : dataColumns,
+    [selectColumn, dataColumns]
+  );
+  const onSelectionChangeRef = useRef4(onSelectionChange);
+  onSelectionChangeRef.current = onSelectionChange;
+  useEffect3(() => {
+    if (!selectionMode || !onSelectionChangeRef.current) return;
+    const selected = Object.keys(rowSelection).filter((k) => rowSelection[k]).map(Number).map((i) => dataRows[i]).filter((r) => r !== void 0);
+    onSelectionChangeRef.current(selected);
+  }, [rowSelection, selectionMode, dataRows]);
+  const tableState = useMemo2(
+    () => ({
+      ...isPaginated ? { pagination } : {},
+      ...selectionMode ? { rowSelection } : {}
+    }),
+    [isPaginated, pagination, selectionMode, rowSelection]
+  );
+  const tableOptions = buildTableOptions({
+    dataRows,
+    columns,
+    tableState,
+    selectionMode,
+    setRowSelection,
+    isPaginated,
+    data,
+    onPaginationChange
+  });
+  const table = useReactTable(tableOptions);
+  useEffect3(() => {
+    if (activeRowIndex < 0 || !containerRef.current) return;
+    const rows = containerRef.current.querySelectorAll("tbody tr");
+    rows[activeRowIndex]?.scrollIntoView({ block: "nearest" });
+  }, [activeRowIndex]);
+  return {
+    table,
+    dataRows,
+    isPaginated,
+    rowSelection,
+    setRowSelection,
+    activeRowIndex,
+    setActiveRowIndex,
+    containerRef,
+    columns
+  };
+}
+function useTableKeyboard(table, activeRowIndex, setActiveRowIndex, selectionMode, onRowClick) {
+  return useCallback2(
+    (e) => {
+      const tableRows = table.getRowModel().rows;
+      if (tableRows.length === 0) return;
+      switch (e.key) {
+        case "ArrowDown": {
+          e.preventDefault();
+          setActiveRowIndex((prev) => Math.min(prev + 1, tableRows.length - 1));
+          break;
+        }
+        case "ArrowUp": {
+          e.preventDefault();
+          setActiveRowIndex((prev) => Math.max(prev - 1, 0));
+          break;
+        }
+        case "Enter": {
+          handleEnterKey(
+            e,
+            tableRows,
+            selectionMode,
+            activeRowIndex,
+            onRowClick
+          );
+          break;
+        }
+        case " ": {
+          handleSpaceKey(e, tableRows, selectionMode, activeRowIndex);
+          break;
+        }
+      }
+    },
+    [activeRowIndex, onRowClick, selectionMode, table, setActiveRowIndex]
+  );
+}
+function handleEnterKey(e, tableRows, selectionMode, activeRowIndex, onRowClick) {
+  e.preventDefault();
+  if (selectionMode || activeRowIndex < 0 || !onRowClick) return;
+  const activeRow = tableRows[activeRowIndex];
+  if (activeRow) onRowClick(activeRow.original);
+}
+function handleSpaceKey(e, tableRows, selectionMode, activeRowIndex) {
+  if (!selectionMode || activeRowIndex < 0) return;
+  e.preventDefault();
+  tableRows[activeRowIndex]?.toggleSelected();
+}
+function resolveTrailingCols(rowActions, onRowClick, selectionMode) {
+  const hasRowActions = !!(rowActions && rowActions.length > 0);
+  const hasChevron = !!(onRowClick && !selectionMode && !hasRowActions);
+  return {
+    hasRowActions,
+    hasChevron,
+    hasTrailingCol: hasRowActions || hasChevron
+  };
+}
+function StatusRows({
+  isLoading,
+  isError,
+  errorMessage,
+  entityLabel,
+  isFiltered,
+  emptyMessage,
+  isEmpty,
+  colCount
+}) {
+  if (isLoading) {
+    return /* @__PURE__ */ jsx27("tr", { children: /* @__PURE__ */ jsx27(
+      "td",
+      {
+        colSpan: colCount,
+        className: "px-4 py-8 text-center text-muted-foreground",
+        children: "Loading..."
+      }
+    ) });
+  }
+  if (isError) {
+    return /* @__PURE__ */ jsx27("tr", { children: /* @__PURE__ */ jsx27(
+      "td",
+      {
+        colSpan: colCount,
+        className: "px-4 py-8 text-center text-destructive",
+        children: errorMessage ?? `Failed to load ${entityLabel}.`
+      }
+    ) });
+  }
+  if (isEmpty) {
+    return /* @__PURE__ */ jsx27("tr", { children: /* @__PURE__ */ jsx27(
+      "td",
+      {
+        colSpan: colCount,
+        className: "px-4 py-8 text-center text-muted-foreground",
+        children: resolveEmptyMessage(emptyMessage, isFiltered, entityLabel)
+      }
+    ) });
+  }
+  return null;
+}
+function resolveEmptyMessage(emptyMessage, isFiltered, entityLabel) {
+  if (emptyMessage) return emptyMessage;
+  if (isFiltered) return `No ${entityLabel} match your search.`;
+  return `No ${entityLabel} yet.`;
+}
+function RowActionCell({
+  actions,
+  rowOriginal
+}) {
+  return /* @__PURE__ */ jsx27("td", { className: "px-4 py-3 w-24 text-right", children: /* @__PURE__ */ jsx27("div", { className: "flex items-center justify-end gap-1", children: actions.map((action) => /* @__PURE__ */ jsx27(
+    ActionButton,
+    {
+      action,
+      rowOriginal
+    },
+    action.label
+  )) }) });
+}
+function ActionButton({
+  action,
+  rowOriginal
+}) {
+  const isHidden = action.hidden?.(rowOriginal);
+  if (isHidden) return null;
+  const isDisabled = action.disabled?.(rowOriginal);
+  const Icon = action.icon;
+  return /* @__PURE__ */ jsx27(
+    "button",
+    {
+      title: action.label,
+      disabled: isDisabled,
+      onClick: (e) => {
+        e.stopPropagation();
+        action.onClick(rowOriginal);
+      },
+      className: cn25(
+        "inline-flex items-center justify-center h-7 w-7 rounded-md transition-colors",
+        action.variant === "destructive" ? "text-destructive hover:bg-destructive/10" : "text-muted-foreground hover:bg-accent",
+        isDisabled ? "opacity-30 cursor-not-allowed group-hover/row:opacity-30" : "opacity-0 group-hover/row:opacity-100 focus:opacity-100"
+      ),
+      children: Icon ? /* @__PURE__ */ jsx27(Icon, { className: "h-3.5 w-3.5" }) : /* @__PURE__ */ jsx27("span", { className: "text-xs", children: action.label })
+    },
+    action.label
+  );
+}
+function DataRow({
+  row,
+  index,
+  selectionMode,
+  activeRowIndex,
+  onRowClick,
+  setActiveRowIndex,
+  containerRef,
+  hasRowActions,
+  hasChevron,
+  rowActions
+}) {
+  return /* @__PURE__ */ jsxs8(
+    "tr",
+    {
+      onClick: () => {
+        handleRowClick(
+          row,
+          index,
+          selectionMode,
+          onRowClick,
+          setActiveRowIndex,
+          containerRef
+        );
+      },
+      className: cn25(
+        "border-b last:border-b-0 transition-colors group/row",
+        onRowClick && !selectionMode && "hover:bg-accent/50 cursor-pointer",
+        selectionMode && "cursor-default",
+        row.getIsSelected() && "bg-primary/10",
+        index === activeRowIndex && selectionMode && "bg-accent"
+      ),
+      children: [
+        row.getVisibleCells().map((cell) => /* @__PURE__ */ jsx27("td", { className: "px-4 py-3", children: flexRender(cell.column.columnDef.cell, cell.getContext()) }, cell.id)),
+        hasRowActions && /* @__PURE__ */ jsx27(RowActionCell, { actions: rowActions, rowOriginal: row.original }),
+        hasChevron && /* @__PURE__ */ jsx27("td", { className: "px-4 py-3 w-10", children: /* @__PURE__ */ jsx27(ChevronRight2, { className: "h-4 w-4 text-muted-foreground" }) })
+      ]
+    },
+    row.id
+  );
+}
+function handleRowClick(row, index, selectionMode, onRowClick, setActiveRowIndex, containerRef) {
+  if (selectionMode) {
+    row.toggleSelected();
+    setActiveRowIndex(index);
+    containerRef.current?.focus();
+  } else if (onRowClick) {
+    onRowClick(row.original);
+  }
+}
+function TableFooter({
+  isPaginated,
+  data,
+  dataRows,
+  entityLabel,
+  table
+}) {
+  if (!data?.meta) return null;
+  if (isPaginated) {
+    return /* @__PURE__ */ jsx27(PaginationFooter, { table, entityLabel });
+  }
+  return /* @__PURE__ */ jsxs8("p", { className: "text-xs text-muted-foreground mt-3", children: [
+    "Showing ",
+    dataRows.length,
+    " of ",
+    data.meta.total,
+    " ",
+    entityLabel
+  ] });
+}
+function EntityTable(props) {
+  const {
+    data,
+    isLoading,
+    isError,
+    errorMessage,
+    entityLabel,
+    onRowClick,
+    rowActions
+  } = props;
+  const { isFiltered, selectionMode } = resolveTableDefaults(props);
+  const {
+    table,
+    dataRows,
+    isPaginated,
+    activeRowIndex,
+    setActiveRowIndex,
+    containerRef,
+    columns
+  } = useEntityTableState(props, selectionMode);
+  const handleKeyDown = useTableKeyboard(
+    table,
+    activeRowIndex,
+    setActiveRowIndex,
+    selectionMode,
+    onRowClick
+  );
+  const { hasRowActions, hasChevron, hasTrailingCol } = resolveTrailingCols(
+    rowActions,
+    onRowClick,
+    selectionMode
+  );
+  const colCount = columns.length + (hasTrailingCol ? 1 : 0);
+  return /* @__PURE__ */ jsxs8("div", { children: [
+    /* @__PURE__ */ jsx27(
+      "div",
+      {
+        ref: selectionMode ? containerRef : void 0,
+        tabIndex: selectionMode ? 0 : void 0,
+        onKeyDown: selectionMode ? handleKeyDown : void 0,
+        className: cn25("rounded-lg border", selectionMode && "outline-none"),
+        children: /* @__PURE__ */ jsxs8("table", { className: "w-full text-sm", children: [
+          /* @__PURE__ */ jsx27("thead", { children: /* @__PURE__ */ jsxs8("tr", { className: "border-b bg-muted/40", children: [
+            table.getFlatHeaders().map((header) => /* @__PURE__ */ jsx27(
+              "th",
+              {
+                className: "text-left text-xs font-medium text-muted-foreground px-4 py-2.5",
+                style: header.column.columnDef.size !== void 0 ? { width: header.column.columnDef.size } : void 0,
+                children: header.isPlaceholder ? null : flexRender(
+                  header.column.columnDef.header,
+                  header.getContext()
+                )
+              },
+              header.id
+            )),
+            hasRowActions && /* @__PURE__ */ jsx27(
+              "th",
+              {
+                "aria-label": "Actions",
+                scope: "col",
+                className: "w-24 text-right text-xs font-medium text-muted-foreground px-4 py-2.5"
+              }
+            ),
+            hasChevron && /* @__PURE__ */ jsx27("th", { "aria-label": "Open", scope: "col", className: "w-10" })
+          ] }) }),
+          /* @__PURE__ */ jsxs8("tbody", { children: [
+            /* @__PURE__ */ jsx27(
+              StatusRows,
+              {
+                isLoading,
+                isError,
+                errorMessage,
+                entityLabel,
+                isFiltered,
+                emptyMessage: props.emptyMessage,
+                isEmpty: !isLoading && !isError && dataRows.length === 0,
+                colCount
+              }
+            ),
+            table.getRowModel().rows.map((row, index) => /* @__PURE__ */ jsx27(
+              DataRow,
+              {
+                row,
+                index,
+                selectionMode,
+                activeRowIndex,
+                onRowClick,
+                setActiveRowIndex,
+                containerRef,
+                hasRowActions,
+                hasChevron,
+                rowActions
+              },
+              row.id
+            ))
+          ] })
+        ] })
+      }
+    ),
+    /* @__PURE__ */ jsx27(
+      TableFooter,
+      {
+        isPaginated,
+        data,
+        dataRows,
+        entityLabel,
+        table
+      }
+    )
+  ] });
+}
+function PaginationFooter({
+  table,
+  entityLabel
+}) {
+  const { pageIndex, pageSize } = table.getState().pagination;
+  const rowCount = table.getRowCount();
+  const pageCount = table.getPageCount();
+  const from = rowCount === 0 ? 0 : pageIndex * pageSize + 1;
+  const to = Math.min((pageIndex + 1) * pageSize, rowCount);
+  return /* @__PURE__ */ jsxs8("div", { className: "flex items-center justify-between mt-3", children: [
+    /* @__PURE__ */ jsx27("p", { className: "text-xs text-muted-foreground", children: rowCount === 0 ? `No ${entityLabel}` : `Showing ${from}\u2013${to} of ${rowCount} ${entityLabel}` }),
+    /* @__PURE__ */ jsxs8("div", { className: "flex items-center gap-1", children: [
+      /* @__PURE__ */ jsx27(
+        "button",
+        {
+          type: "button",
+          onClick: () => table.previousPage(),
+          disabled: !table.getCanPreviousPage(),
+          className: "px-2 py-1 text-xs rounded border border-border text-muted-foreground hover:text-foreground hover:bg-accent transition-colors disabled:opacity-40 disabled:pointer-events-none",
+          children: "Previous"
+        }
+      ),
+      /* @__PURE__ */ jsx27("span", { className: "text-xs text-muted-foreground px-2", children: pageCount > 0 ? `${pageIndex + 1} / ${pageCount}` : "--" }),
+      /* @__PURE__ */ jsx27(
+        "button",
+        {
+          type: "button",
+          onClick: () => table.nextPage(),
+          disabled: !table.getCanNextPage(),
+          className: "px-2 py-1 text-xs rounded border border-border text-muted-foreground hover:text-foreground hover:bg-accent transition-colors disabled:opacity-40 disabled:pointer-events-none",
+          children: "Next"
+        }
+      )
+    ] })
+  ] });
+}
+
+// src/EntitySelect/EntitySelect.tsx
+import * as React24 from "react";
+import { Check as Check4, ChevronsUpDown, Loader2 } from "lucide-react";
+import { cn as cn26 } from "@petrarca/sonnet-core";
+import {
+  useEntityOptions
+} from "@petrarca/sonnet-core/hooks";
+import { Fragment as Fragment2, jsx as jsx28, jsxs as jsxs9 } from "react/jsx-runtime";
+function emptyStateMessage({
+  mode,
+  search,
+  minChars,
+  isLoading,
+  hasSearched,
+  emptyMessage
+}) {
+  if (isLoading) return "Loading...";
+  if (mode === "eager") return emptyMessage;
+  if (search.length === 0) return "Start typing to search...";
+  if (mode === "typeahead" && search.length < minChars)
+    return `Type at least ${minChars} character${minChars > 1 ? "s" : ""} to search...`;
+  if (mode === "explicit" && !hasSearched) return "Press Enter to search...";
+  return emptyMessage;
+}
+function useHasSearched(submit) {
+  const [hasSearched, setHasSearched] = React24.useState(false);
+  const wrappedSubmit = React24.useCallback(() => {
+    setHasSearched(true);
+    submit();
+  }, [submit]);
+  return [hasSearched, wrappedSubmit];
+}
+function resolveEntitySelectDefaults(props) {
+  return {
+    mode: props.mode ?? "eager",
+    minChars: props.minChars ?? 1,
+    placeholder: props.placeholder ?? "Select...",
+    searchPlaceholder: props.searchPlaceholder ?? "Search...",
+    emptyMessage: props.emptyMessage ?? "No results found",
+    disabled: props.disabled ?? false
+  };
+}
+function EntitySelectLabel({
+  id,
+  label,
+  required,
+  description
+}) {
+  const hasLabel = label !== void 0 && label !== false;
+  return /* @__PURE__ */ jsxs9(Fragment2, { children: [
+    hasLabel && /* @__PURE__ */ jsxs9(
+      "label",
+      {
+        htmlFor: id,
+        className: "text-sm font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70",
+        children: [
+          label,
+          required && /* @__PURE__ */ jsx28("span", { className: "ml-1 text-destructive", children: "*" })
+        ]
+      }
+    ),
+    description && /* @__PURE__ */ jsx28("p", { className: "text-sm text-muted-foreground", children: description })
+  ] });
+}
+function EntitySelectDropdown({
+  searchPlaceholder,
+  search,
+  setSearch,
+  mode,
+  submit,
+  minChars,
+  isLoading,
+  hasSearched,
+  emptyMessage,
+  options,
+  value,
+  handleSelect
+}) {
+  return /* @__PURE__ */ jsxs9(Command, { shouldFilter: false, children: [
+    /* @__PURE__ */ jsx28(
+      CommandInput,
+      {
+        placeholder: searchPlaceholder,
+        value: search,
+        onValueChange: setSearch,
+        onKeyDown: mode === "explicit" ? (e) => {
+          if (e.key === "Enter") {
+            e.preventDefault();
+            submit();
+          }
+        } : void 0
+      }
+    ),
+    /* @__PURE__ */ jsxs9(CommandList, { children: [
+      /* @__PURE__ */ jsx28(CommandEmpty, { children: emptyStateMessage({
+        mode,
+        search,
+        minChars,
+        isLoading,
+        hasSearched,
+        emptyMessage
+      }) }),
+      /* @__PURE__ */ jsx28(CommandGroup, { children: options.map((option) => /* @__PURE__ */ jsxs9(
+        CommandItem,
+        {
+          value: option.value,
+          onSelect: handleSelect,
+          children: [
+            /* @__PURE__ */ jsx28(
+              Check4,
+              {
+                className: cn26(
+                  "mr-2 h-4 w-4",
+                  value === option.value ? "opacity-100" : "opacity-0"
+                )
+              }
+            ),
+            option.label
+          ]
+        },
+        option.value
+      )) })
+    ] })
+  ] });
+}
+function EntitySelect(props) {
+  const {
+    fetcher,
+    queryKey,
+    value,
+    onChange,
+    onChangeOption,
+    onBlur,
+    label,
+    required,
+    description,
+    error,
+    className,
+    id
+  } = props;
+  const {
+    mode,
+    minChars,
+    placeholder,
+    searchPlaceholder,
+    emptyMessage,
+    disabled
+  } = resolveEntitySelectDefaults(props);
+  const [open, setOpen] = React24.useState(false);
+  const [selectedLabel, setSelectedLabel] = React24.useState(null);
+  const {
+    options,
+    isLoading,
+    search,
+    setSearch,
+    submit: rawSubmit
+  } = useEntityOptions({ fetcher, queryKey, mode, minChars });
+  const [hasSearched, submit] = useHasSearched(rawSubmit);
+  React24.useEffect(() => {
+    if (!value) {
+      setSelectedLabel(null);
+      return;
+    }
+    const found = options.find((opt) => opt.value === value);
+    if (found) {
+      setSelectedLabel(found.label);
+    }
+  }, [value, options]);
+  const handleSelect = React24.useCallback(
+    (selectedValue) => {
+      const opt = options.find((o) => o.value === selectedValue);
+      if (opt) setSelectedLabel(opt.label);
+      const newValue = selectedValue === value ? null : selectedValue;
+      if (newValue === null) setSelectedLabel(null);
+      onChange?.(newValue);
+      onChangeOption?.(newValue === null ? null : opt ?? null);
+      setOpen(false);
+      setSearch("");
+    },
+    [options, value, onChange, onChangeOption, setSearch]
+  );
+  const handleOpenChange = React24.useCallback(
+    (newOpen) => {
+      setOpen(newOpen);
+      if (!newOpen) {
+        setSearch("");
+        onBlur?.();
+      }
+    },
+    [onBlur, setSearch]
+  );
+  return /* @__PURE__ */ jsxs9("div", { className: cn26("space-y-2", className), children: [
+    /* @__PURE__ */ jsx28(
+      EntitySelectLabel,
+      {
+        id,
+        label,
+        required,
+        description
+      }
+    ),
+    /* @__PURE__ */ jsxs9(Popover, { open, onOpenChange: handleOpenChange, children: [
+      /* @__PURE__ */ jsx28(PopoverTrigger, { asChild: true, children: /* @__PURE__ */ jsxs9(
+        Button,
+        {
+          id,
+          variant: "outline",
+          role: "combobox",
+          "aria-expanded": open,
+          className: cn26(
+            "w-full justify-between",
+            !selectedLabel && "text-muted-foreground",
+            error && "border-destructive"
+          ),
+          disabled,
+          children: [
+            /* @__PURE__ */ jsx28("span", { className: "truncate", children: selectedLabel ?? placeholder }),
+            /* @__PURE__ */ jsxs9("div", { className: "flex items-center gap-1", children: [
+              isLoading && /* @__PURE__ */ jsx28(Loader2, { className: "h-4 w-4 animate-spin opacity-50" }),
+              /* @__PURE__ */ jsx28(ChevronsUpDown, { className: "h-4 w-4 shrink-0 opacity-50" })
+            ] })
+          ]
+        }
+      ) }),
+      /* @__PURE__ */ jsx28(
+        PopoverContent,
+        {
+          className: "w-[--radix-popover-trigger-width] p-0",
+          align: "start",
+          children: /* @__PURE__ */ jsx28(
+            EntitySelectDropdown,
+            {
+              searchPlaceholder,
+              search,
+              setSearch,
+              mode,
+              submit,
+              minChars,
+              isLoading,
+              hasSearched,
+              emptyMessage,
+              options,
+              value,
+              handleSelect
+            }
+          )
+        }
+      )
+    ] }),
+    error && /* @__PURE__ */ jsx28("p", { className: "text-sm font-medium text-destructive", children: error })
+  ] });
+}
+
+// src/EntityTree/EntityTree.tsx
+import {
+  forwardRef as forwardRef19,
+  useImperativeHandle as useImperativeHandle2,
+  useMemo as useMemo4,
+  useRef as useRef6
+} from "react";
+import { Pencil } from "lucide-react";
+import { cn as cn28 } from "@petrarca/sonnet-core";
+
+// src/TreeView/TreeView.tsx
+import {
+  forwardRef as forwardRef18,
+  useCallback as useCallback4,
+  useEffect as useEffect5,
+  useId as useId2,
+  useImperativeHandle,
+  useMemo as useMemo3,
+  useRef as useRef5,
+  useState as useState4
+} from "react";
+import { ChevronRight as ChevronRight3 } from "lucide-react";
+import { cn as cn27 } from "@petrarca/sonnet-core";
+import { jsx as jsx29, jsxs as jsxs10 } from "react/jsx-runtime";
+function flatten(nodes, expandedIds, depth = 0, parentId = null, result = []) {
+  for (const node of nodes) {
+    result.push({ node, depth, parentId });
+    if (expandedIds.has(node.id) && node.children) {
+      flatten(node.children, expandedIds, depth + 1, node.id, result);
+    }
+  }
+  return result;
+}
+var UNCONSTRAINED = /* @__PURE__ */ Symbol.for("tree-view:unconstrained");
+function ToggleIcon({
+  hasChildren,
+  isLoading,
+  isExpanded
+}) {
+  if (!hasChildren) {
+    return /* @__PURE__ */ jsx29("span", { className: "block w-1.5 h-1.5 rounded-full bg-border mx-auto" });
+  }
+  if (isLoading) {
+    return /* @__PURE__ */ jsx29("span", { className: "block w-3 h-3 rounded-full border-2 border-muted-foreground/40 border-t-foreground animate-spin" });
+  }
+  return /* @__PURE__ */ jsx29(
+    ChevronRight3,
+    {
+      className: cn27(
+        "h-3.5 w-3.5 text-muted-foreground transition-transform",
+        isExpanded && "rotate-90"
+      )
+    }
+  );
+}
+function NodeRow({
+  flat,
+  expandedIds,
+  selectedIds,
+  isSelectable,
+  isFocused,
+  indentPx,
+  treeId,
+  onExpand,
+  onCollapse,
+  onNodeClick,
+  onSelectionChange,
+  onFocus,
+  renderNode
+}) {
+  const { node, depth } = flat;
+  const isExpanded = expandedIds.has(node.id);
+  const isSelected = selectedIds.has(node.id);
+  const handleToggle = useCallback4(
+    (e) => {
+      e.stopPropagation();
+      if (isExpanded) {
+        onCollapse(node.id);
+      } else if (node.hasChildren) {
+        onExpand(node.id);
+      }
+    },
+    [isExpanded, node.id, node.hasChildren, onExpand, onCollapse]
+  );
+  const handleClick = useCallback4(() => {
+    onFocus(node.id);
+    onNodeClick?.(node);
+  }, [node, onFocus, onNodeClick]);
+  const handleCheckChange = useCallback4(
+    (e) => {
+      onSelectionChange?.(node.id, e.target.checked);
+    },
+    [node.id, onSelectionChange]
+  );
+  return /* @__PURE__ */ jsxs10(
+    "li",
+    {
+      id: `${treeId}-node-${node.id}`,
+      role: "treeitem",
+      "aria-expanded": node.hasChildren ? isExpanded : void 0,
+      "aria-selected": onSelectionChange ? isSelected : void 0,
+      "aria-busy": node.isLoading,
+      tabIndex: isFocused ? 0 : -1,
+      className: cn27(
+        "flex items-center gap-1 px-2 py-1.5 rounded-sm text-sm select-none",
+        "cursor-pointer transition-colors",
+        "hover:bg-accent/60",
+        isFocused && "bg-accent ring-1 ring-ring ring-inset outline-none",
+        isSelected && "bg-primary/10"
+      ),
+      style: { paddingLeft: depth * indentPx + 8 },
+      onClick: handleClick,
+      children: [
+        /* @__PURE__ */ jsx29(
+          "span",
+          {
+            className: "shrink-0 flex items-center justify-center w-4 h-4",
+            onClick: handleToggle,
+            "aria-hidden": true,
+            children: /* @__PURE__ */ jsx29(
+              ToggleIcon,
+              {
+                hasChildren: node.hasChildren,
+                isLoading: node.isLoading,
+                isExpanded
+              }
+            )
+          }
+        ),
+        onSelectionChange && isSelectable && /* @__PURE__ */ jsx29(
+          "input",
+          {
+            type: "checkbox",
+            className: "shrink-0 h-3.5 w-3.5 rounded",
+            checked: isSelected,
+            onChange: handleCheckChange,
+            onClick: (e) => e.stopPropagation(),
+            "aria-label": `Select ${node.id}`,
+            tabIndex: -1
+          }
+        ),
+        /* @__PURE__ */ jsx29("span", { className: "flex-1 min-w-0", children: renderNode(node, depth) }),
+        node.isError && /* @__PURE__ */ jsx29("span", { className: "shrink-0 text-xs text-destructive", "aria-live": "polite", children: "Failed to load" })
+      ]
+    }
+  );
+}
+function TreeViewInner({
+  nodes,
+  expandedIds,
+  onExpand,
+  onCollapse,
+  onNodeClick,
+  onNodeActivate,
+  renderNode,
+  selectedIds,
+  onSelectionChange,
+  constrainSelectionToSiblings,
+  indentPx = 20,
+  className
+}, ref) {
+  const treeId = useId2();
+  const [focusedId, setFocusedId] = useState4(null);
+  const listRef = useRef5(null);
+  const [constrainedParent, setConstrainedParent] = useState4(UNCONSTRAINED);
+  const selectionSize = selectedIds?.size ?? 0;
+  useEffect5(() => {
+    if (selectionSize === 0) setConstrainedParent(UNCONSTRAINED);
+  }, [selectionSize]);
+  useImperativeHandle(
+    ref,
+    () => ({
+      focus() {
+        const ul = listRef.current;
+        if (!ul) return;
+        const target = focusedId ? ul.querySelector(
+          `[id$="-node-${CSS.escape(focusedId)}"]`
+        ) : ul.querySelector('[role="treeitem"]');
+        target?.focus();
+      }
+    }),
+    [focusedId]
+  );
+  const flatNodes = useMemo3(
+    () => flatten(nodes, expandedIds),
+    [nodes, expandedIds]
+  );
+  const parentById = useMemo3(() => {
+    const map = /* @__PURE__ */ new Map();
+    for (const f of flatNodes) map.set(f.node.id, f.parentId);
+    return map;
+  }, [flatNodes]);
+  const selectableSet = useMemo3(() => {
+    if (!constrainSelectionToSiblings || constrainedParent === UNCONSTRAINED) {
+      return void 0;
+    }
+    const ids = /* @__PURE__ */ new Set();
+    for (const f of flatNodes) {
+      if (f.parentId === constrainedParent) ids.add(f.node.id);
+    }
+    return ids;
+  }, [constrainSelectionToSiblings, constrainedParent, flatNodes]);
+  const handleSelectionChange = useCallback4(
+    (nodeId, selected) => {
+      if (constrainSelectionToSiblings && selected && constrainedParent === UNCONSTRAINED) {
+        setConstrainedParent(parentById.get(nodeId) ?? null);
+      }
+      onSelectionChange?.(nodeId, selected);
+    },
+    [
+      constrainSelectionToSiblings,
+      constrainedParent,
+      parentById,
+      onSelectionChange
+    ]
+  );
+  const focusedIndex = flatNodes.findIndex((f) => f.node.id === focusedId);
+  const moveFocus = useCallback4(
+    (delta) => {
+      if (flatNodes.length === 0) return;
+      const next = Math.max(
+        0,
+        Math.min(flatNodes.length - 1, focusedIndex + delta)
+      );
+      const target = flatNodes[next];
+      if (target) {
+        setFocusedId(target.node.id);
+        const el = listRef.current?.querySelector(
+          `#${CSS.escape(`${treeId}-node-${target.node.id}`)}`
+        );
+        el?.scrollIntoView({ block: "nearest" });
+        el?.focus();
+      }
+    },
+    [flatNodes, focusedIndex, treeId]
+  );
+  const handleArrowRight = useCallback4(
+    (current) => {
+      if (current.node.hasChildren && !expandedIds.has(current.node.id)) {
+        onExpand(current.node.id);
+      } else if (current.node.children && current.node.children.length > 0) {
+        moveFocus(1);
+      }
+    },
+    [expandedIds, onExpand, moveFocus]
+  );
+  const handleArrowLeft = useCallback4(
+    (current) => {
+      if (expandedIds.has(current.node.id)) {
+        onCollapse(current.node.id);
+        return;
+      }
+      if (current.parentId === null) return;
+      const parentIdx = flatNodes.findIndex(
+        (f) => f.node.id === current.parentId
+      );
+      if (parentIdx < 0) return;
+      const parentFlat = flatNodes[parentIdx];
+      if (!parentFlat) return;
+      setFocusedId(parentFlat.node.id);
+      const el = listRef.current?.querySelector(
+        `#${CSS.escape(`${treeId}-node-${parentFlat.node.id}`)}`
+      );
+      el?.focus();
+    },
+    [expandedIds, onCollapse, flatNodes, treeId]
+  );
+  const getFocusedNode = useCallback4(() => {
+    if (focusedIndex < 0) return null;
+    return flatNodes[focusedIndex] ?? null;
+  }, [flatNodes, focusedIndex]);
+  const activateNode = useCallback4(
+    (flat) => {
+      if (flat) onNodeActivate?.(flat.node);
+    },
+    [onNodeActivate]
+  );
+  const handleKeyDown = useCallback4(
+    (e) => {
+      switch (e.key) {
+        case "ArrowDown":
+          e.preventDefault();
+          moveFocus(1);
+          break;
+        case "ArrowUp":
+          e.preventDefault();
+          moveFocus(-1);
+          break;
+        case "ArrowRight": {
+          e.preventDefault();
+          const current = getFocusedNode();
+          if (current) handleArrowRight(current);
+          break;
+        }
+        case "ArrowLeft": {
+          e.preventDefault();
+          const current = getFocusedNode();
+          if (current) handleArrowLeft(current);
+          break;
+        }
+        case "Enter":
+        case " ":
+          e.preventDefault();
+          activateNode(getFocusedNode());
+          break;
+        default:
+          break;
+      }
+    },
+    [
+      moveFocus,
+      handleArrowRight,
+      handleArrowLeft,
+      getFocusedNode,
+      activateNode
+    ]
+  );
+  if (nodes.length === 0) {
+    return /* @__PURE__ */ jsx29(
+      "div",
+      {
+        className: cn27(
+          "py-8 text-center text-sm text-muted-foreground",
+          className
+        ),
+        children: "No items."
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx29(
+    "ul",
+    {
+      ref: listRef,
+      role: "tree",
+      "aria-label": "Tree",
+      className: cn27("outline-none", className),
+      onKeyDown: handleKeyDown,
+      children: flatNodes.map((flat) => /* @__PURE__ */ jsx29(
+        NodeRow,
+        {
+          flat,
+          expandedIds,
+          selectedIds: selectedIds ?? /* @__PURE__ */ new Set(),
+          isSelectable: !selectableSet || selectableSet.has(flat.node.id),
+          isFocused: flat.node.id === focusedId,
+          indentPx,
+          treeId,
+          onExpand,
+          onCollapse,
+          onNodeClick,
+          onSelectionChange: onSelectionChange ? handleSelectionChange : void 0,
+          onFocus: setFocusedId,
+          renderNode
+        },
+        flat.node.id
+      ))
+    }
+  );
+}
+var TreeView = forwardRef18(TreeViewInner);
+
+// src/EntityTree/EntityTree.tsx
+import { jsx as jsx30, jsxs as jsxs11 } from "react/jsx-runtime";
+function buildCellRow(resolved, activeNodeIdRef, onNodeEdit, localRenderers) {
+  return function renderCells(node) {
+    const isActive = node.id === activeNodeIdRef.current;
+    return /* @__PURE__ */ jsxs11("span", { className: "flex items-center gap-4 min-w-0 w-full group/row", children: [
+      resolved.map((col) => {
+        const Renderer = resolveCellRenderer2(
+          col.cellRenderer,
+          localRenderers
+        );
+        const value = node.data[col.key];
+        return /* @__PURE__ */ jsx30(
+          "span",
+          {
+            className: "shrink-0",
+            style: col.width !== void 0 ? { width: col.width } : void 0,
+            children: /* @__PURE__ */ jsx30(
+              Renderer,
+              {
+                value,
+                row: node.data,
+                options: col.cellOptions
+              }
+            )
+          },
+          col.key
+        );
+      }),
+      onNodeEdit && /* @__PURE__ */ jsx30("span", { className: "ml-auto shrink-0", children: /* @__PURE__ */ jsx30(
+        "button",
+        {
+          type: "button",
+          onClick: (e) => {
+            e.stopPropagation();
+            onNodeEdit(node);
+          },
+          "aria-label": "Edit",
+          className: cn28(
+            "p-1 rounded hover:bg-background text-muted-foreground hover:text-foreground transition-colors",
+            isActive ? "opacity-100" : "opacity-0 group-hover/row:opacity-100"
+          ),
+          children: /* @__PURE__ */ jsx30(Pencil, { className: "h-3.5 w-3.5" })
+        }
+      ) })
+    ] });
+  };
+}
+function resolveEntityTreeDefaults(props) {
+  return {
+    isLoading: props.isLoading ?? false,
+    isError: props.isError ?? false,
+    entityLabel: props.entityLabel ?? "items",
+    selectionMode: props.selectionMode ?? false
+  };
+}
+function renderTreeStatus({
+  isLoading,
+  isError,
+  errorMessage,
+  entityLabel,
+  nodes,
+  className
+}) {
+  if (isLoading && nodes.length === 0) {
+    return /* @__PURE__ */ jsx30(
+      "div",
+      {
+        className: cn28(
+          "py-8 text-center text-sm text-muted-foreground",
+          className
+        ),
+        children: "Loading\\u2026"
+      }
+    );
+  }
+  if (isError) {
+    return /* @__PURE__ */ jsx30(
+      "div",
+      {
+        className: cn28("py-8 text-center text-sm text-destructive", className),
+        children: errorMessage ?? `Failed to load ${entityLabel}.`
+      }
+    );
+  }
+  if (!isLoading && nodes.length === 0) {
+    return /* @__PURE__ */ jsxs11(
+      "div",
+      {
+        className: cn28(
+          "py-8 text-center text-sm text-muted-foreground",
+          className
+        ),
+        children: [
+          "No ",
+          entityLabel,
+          " yet."
+        ]
+      }
+    );
+  }
+  return null;
+}
+function resolveRenderNode(renderNodeOverride, defaultRenderNode) {
+  if (!renderNodeOverride) return defaultRenderNode;
+  return (node, depth) => {
+    const override = renderNodeOverride(node, depth);
+    if (override !== null) return override;
+    return defaultRenderNode(node);
+  };
+}
+function resolveSelectionProps(selectionMode, props) {
+  return {
+    effectiveOnNodeEdit: selectionMode ? void 0 : props.onNodeEdit,
+    onNodeActivate: selectionMode ? void 0 : props.onNodeEdit,
+    selectedIds: selectionMode ? props.selectedIds : void 0,
+    onSelectionChange: selectionMode ? props.onSelectionChange : void 0,
+    constrainSelectionToSiblings: selectionMode ? props.constrainSelectionToSiblings : void 0
+  };
+}
+function EntityTreeInner(props, ref) {
+  const {
+    schema,
+    uiSchema,
+    renderers,
+    nodes,
+    expandedIds,
+    onExpand,
+    onCollapse,
+    errorMessage,
+    onNodeSelect,
+    onNodeEdit,
+    activeNodeId,
+    selectedIds,
+    onSelectionChange,
+    constrainSelectionToSiblings,
+    renderNodeOverride,
+    indentPx,
+    className
+  } = props;
+  const { isLoading, isError, entityLabel, selectionMode } = resolveEntityTreeDefaults(props);
+  const treeRef = useRef6(null);
+  useImperativeHandle2(ref, () => ({
+    focus() {
+      treeRef.current?.focus();
+    }
+  }));
+  const resolved = useMemo4(() => {
+    if (renderers) validateRendererNames(renderers);
+    return resolveColumns(schema, uiSchema);
+  }, [schema, uiSchema, renderers]);
+  const activeNodeIdRef = useRef6(activeNodeId);
+  activeNodeIdRef.current = activeNodeId;
+  const selection = resolveSelectionProps(selectionMode, {
+    onNodeEdit,
+    selectedIds,
+    onSelectionChange,
+    constrainSelectionToSiblings
+  });
+  const defaultRenderNode = useMemo4(
+    () => buildCellRow(
+      resolved,
+      activeNodeIdRef,
+      selection.effectiveOnNodeEdit,
+      renderers
+    ),
+    [resolved, selection.effectiveOnNodeEdit, renderers]
+  );
+  const renderNode = useMemo4(
+    () => resolveRenderNode(renderNodeOverride, defaultRenderNode),
+    [renderNodeOverride, defaultRenderNode]
+  );
+  const statusView = renderTreeStatus({
+    isLoading,
+    isError,
+    errorMessage,
+    entityLabel,
+    nodes,
+    className
+  });
+  if (statusView) return statusView;
+  return /* @__PURE__ */ jsx30("div", { className: cn28("rounded-lg border", className), children: /* @__PURE__ */ jsx30(
+    TreeView,
+    {
+      ref: treeRef,
+      nodes,
+      expandedIds,
+      onExpand,
+      onCollapse,
+      onNodeClick: onNodeSelect,
+      onNodeActivate: selection.onNodeActivate,
+      renderNode,
+      selectedIds: selection.selectedIds,
+      onSelectionChange: selection.onSelectionChange,
+      constrainSelectionToSiblings: selection.constrainSelectionToSiblings,
+      indentPx,
+      className: "p-1"
+    }
+  ) });
+}
+var EntityTree = forwardRef19(EntityTreeInner);
+
+// src/SearchInput/SearchInput.tsx
+import React29, { useMemo as useMemo6, useRef as useRef9, useState as useState7, useEffect as useEffect9 } from "react";
+import { Search as Search2, X as X3, ChevronDown } from "lucide-react";
+import { cn as cn30 } from "@petrarca/sonnet-core";
+import { getFieldTitle as getFieldTitle2 } from "@petrarca/sonnet-core/schema";
+import { isEmptyFilterExpr } from "@petrarca/sonnet-core/search";
+
+// src/SearchInput/useSearchInput.ts
+import { useCallback as useCallback5, useEffect as useEffect6, useMemo as useMemo5, useRef as useRef7, useState as useState5 } from "react";
+import { collectTerms } from "@petrarca/sonnet-core/search";
+
+// src/SearchInput/schemaAdapter.ts
+import {
+  getFieldTitle,
+  getFieldHelpText,
+  getFieldPlaceholder
+} from "@petrarca/sonnet-core/schema";
+function buildFacetDescriptors(schema) {
+  const properties = schema.properties ?? {};
+  const keys = Object.keys(properties);
+  if (keys.length === 0) return [];
+  const requiredSet = new Set(schema.required ?? []);
+  const order = schema["x-ui-order"];
+  const ordered = applyOrder(keys, order);
+  return ordered.map((key) => {
+    const property = properties[key];
+    return {
+      key,
+      label: getFieldTitle(key, property),
+      required: requiredSet.has(key),
+      description: getFieldHelpText(property),
+      placeholder: getFieldPlaceholder(property),
+      property
+    };
+  });
+}
+function applyOrder(keys, order) {
+  if (!order || order.length === 0) return keys;
+  const keySet = new Set(keys);
+  const ordered = [];
+  for (const key of order) {
+    if (keySet.has(key)) {
+      ordered.push(key);
+      keySet.delete(key);
+    }
+  }
+  for (const key of keys) {
+    if (keySet.has(key)) {
+      ordered.push(key);
+    }
+  }
+  return ordered;
+}
+
+// src/SearchInput/useSearchInput.ts
+function buildSimpleExpr(text, searchFields) {
+  const trimmed = text.trim();
+  if (!trimmed) return { type: "and", children: [] };
+  if (searchFields && searchFields.length > 0) {
+    const terms = searchFields.map((key) => ({
+      type: "term",
+      key,
+      value: trimmed
+    }));
+    if (terms.length === 1) {
+      return { type: "and", children: terms };
+    }
+    return { type: "and", children: [{ type: "or", children: terms }] };
+  }
+  return {
+    type: "and",
+    children: [{ type: "term", key: "search", value: trimmed }]
+  };
+}
+function useSearchInput({
+  value,
+  onChange,
+  mode = "explicit",
+  debounceMs = 300,
+  schema,
+  minChars = 0,
+  searchFields
+}) {
+  const allFacets = useMemo5(
+    () => schema ? buildFacetDescriptors(schema) : [],
+    [schema]
+  );
+  const isFaceted = allFacets.length > 0;
+  const initialInput = !isFaceted ? (() => {
+    const terms = collectTerms(value);
+    return terms.length === 1 && terms[0].key === "search" ? terms[0].value : "";
+  })() : "";
+  const [inputValue, setInputValue] = useState5(initialInput);
+  const [pendingFacet, setPendingFacet] = useState5(
+    null
+  );
+  const [draftTerms, setDraftTerms] = useState5(
+    () => isFaceted ? collectTerms(value) : []
+  );
+  const valueTerms = useMemo5(
+    () => !isFaceted ? collectTerms(value) : [],
+    [value, isFaceted]
+  );
+  const activeTerms = isFaceted ? draftTerms : valueTerms;
+  const activeFieldKeys = useMemo5(
+    () => new Set(activeTerms.map((t) => t.key)),
+    [activeTerms]
+  );
+  const filteredFacets = useMemo5(() => {
+    if (!isFaceted || pendingFacet || inputValue.endsWith(" ")) return [];
+    const available = allFacets.filter((f) => !activeFieldKeys.has(f.key));
+    if (!inputValue.trim()) return available;
+    const lower = inputValue.toLowerCase();
+    return available.filter((f) => f.label.toLowerCase().startsWith(lower));
+  }, [inputValue, pendingFacet, isFaceted, allFacets, activeFieldKeys]);
+  const onChangeRef = useRef7(onChange);
+  onChangeRef.current = onChange;
+  const draftTermsRef = useRef7(draftTerms);
+  draftTermsRef.current = draftTerms;
+  const pendingFacetRef = useRef7(pendingFacet);
+  pendingFacetRef.current = pendingFacet;
+  const inputValueRef = useRef7(inputValue);
+  inputValueRef.current = inputValue;
+  const isFacetedRef = useRef7(isFaceted);
+  isFacetedRef.current = isFaceted;
+  const allFacetsRef = useRef7(allFacets);
+  allFacetsRef.current = allFacets;
+  const filteredFacetsRef = useRef7(filteredFacets);
+  filteredFacetsRef.current = filteredFacets;
+  const minCharsRef = useRef7(minChars);
+  minCharsRef.current = minChars;
+  useEffect6(() => {
+    if (!isFaceted) return;
+    const terms = collectTerms(value);
+    if (terms.length === 0) {
+      setDraftTerms([]);
+      setInputValue("");
+      setPendingFacet(null);
+    }
+  }, [value, isFaceted]);
+  const searchFieldsRef = useRef7(searchFields);
+  searchFieldsRef.current = searchFields;
+  const isMountedRef = useRef7(false);
+  useEffect6(() => {
+    if (!isMountedRef.current) {
+      isMountedRef.current = true;
+      return;
+    }
+    if (mode !== "debounce" || isFaceted) return;
+    if (inputValue.trim().length < minCharsRef.current) return;
+    const timer = setTimeout(() => {
+      onChangeRef.current(buildSimpleExpr(inputValue, searchFieldsRef.current));
+    }, debounceMs);
+    return () => clearTimeout(timer);
+  }, [inputValue, mode, debounceMs, isFaceted]);
+  const submitDraft = useCallback5((terms) => {
+    onChangeRef.current({ type: "and", children: terms });
+  }, []);
+  const allRequiredSatisfied = useCallback5((terms) => {
+    const requiredKeys = allFacetsRef.current.filter((f) => f.required).map((f) => f.key);
+    if (requiredKeys.length === 0) return true;
+    const presentKeys = new Set(terms.map((t) => t.key));
+    return requiredKeys.every((k) => presentKeys.has(k));
+  }, []);
+  const addChip = useCallback5((text) => {
+    const trimmed = text.trim();
+    if (!trimmed) return;
+    const facet = pendingFacetRef.current ?? allFacetsRef.current[0] ?? null;
+    if (!facet) return;
+    const newTerm = {
+      type: "term",
+      key: facet.key,
+      value: trimmed
+    };
+    const nextTerms = [...draftTermsRef.current, newTerm];
+    setDraftTerms(nextTerms);
+    setInputValue("");
+    setPendingFacet(null);
+  }, []);
+  const commitFacetValue = addChip;
+  const cancelPendingFacet = useCallback5(() => {
+    setInputValue("");
+    setPendingFacet(null);
+  }, []);
+  const handleInputChange = useCallback5(
+    (e) => {
+      setInputValue(e.target.value);
+    },
+    []
+  );
+  const tryAcceptSingleMatch = useCallback5(
+    (e) => {
+      if (!isFacetedRef.current || pendingFacetRef.current || filteredFacetsRef.current.length !== 1 || !inputValueRef.current.trim()) {
+        return false;
+      }
+      e.preventDefault();
+      setPendingFacet(filteredFacetsRef.current[0]);
+      setInputValue("");
+      return true;
+    },
+    []
+  );
+  const handleEnterFaceted = useCallback5(() => {
+    const trimmed = inputValueRef.current.trim();
+    if (trimmed) {
+      addChip(trimmed);
+      return false;
+    }
+    if (!pendingFacetRef.current) {
+      if (allRequiredSatisfied(draftTermsRef.current)) {
+        submitDraft(draftTermsRef.current);
+      } else {
+        return true;
+      }
+    }
+    return false;
+  }, [addChip, submitDraft, allRequiredSatisfied]);
+  const handleEnterSimple = useCallback5(() => {
+    if (inputValueRef.current.trim().length >= minCharsRef.current) {
+      onChangeRef.current(
+        buildSimpleExpr(inputValueRef.current, searchFieldsRef.current)
+      );
+    }
+  }, []);
+  const handleBackspaceEmpty = useCallback5(() => {
+    if (isFacetedRef.current) {
+      if (pendingFacetRef.current) {
+        setPendingFacet(null);
+      } else if (draftTermsRef.current.length > 0) {
+        setDraftTerms((prev) => prev.slice(0, -1));
+      }
+    } else {
+      onChangeRef.current({ type: "and", children: [] });
+    }
+  }, []);
+  const handleKeyDown = useCallback5(
+    (e) => {
+      if ((e.key === "Tab" || e.key === "Enter") && tryAcceptSingleMatch(e)) {
+        return false;
+      }
+      if (e.key === "Enter") {
+        e.preventDefault();
+        if (isFacetedRef.current) {
+          return handleEnterFaceted();
+        }
+        handleEnterSimple();
+        return false;
+      }
+      if (e.key === "Backspace" && inputValueRef.current === "") {
+        handleBackspaceEmpty();
+      }
+      return false;
+    },
+    [
+      tryAcceptSingleMatch,
+      handleEnterFaceted,
+      handleEnterSimple,
+      handleBackspaceEmpty
+    ]
+  );
+  const handleCommit = useCallback5(() => {
+    if (isFacetedRef.current) {
+      const trimmed = inputValueRef.current.trim();
+      if (trimmed) {
+        addChip(trimmed);
+      } else if (!pendingFacetRef.current) {
+        if (allRequiredSatisfied(draftTermsRef.current)) {
+          submitDraft(draftTermsRef.current);
+        }
+      }
+    } else if (inputValueRef.current.trim().length >= minCharsRef.current) {
+      onChangeRef.current(
+        buildSimpleExpr(inputValueRef.current, searchFieldsRef.current)
+      );
+    }
+  }, [addChip, submitDraft, allRequiredSatisfied]);
+  const handleRemoveTerm = useCallback5((index) => {
+    const next = draftTermsRef.current.filter((_, i) => i !== index);
+    setDraftTerms(next);
+    onChangeRef.current({ type: "and", children: next });
+  }, []);
+  const handleClear = useCallback5(() => {
+    setInputValue("");
+    setPendingFacet(null);
+    setDraftTerms([]);
+    onChangeRef.current({ type: "and", children: [] });
+  }, []);
+  const selectFacet = useCallback5(
+    (f) => setPendingFacet(f),
+    []
+  );
+  return {
+    inputValue,
+    pendingFacet,
+    isFaceted,
+    filteredFacets,
+    allFacets,
+    selectFacet,
+    handleInputChange,
+    handleKeyDown,
+    handleCommit,
+    handleRemoveTerm,
+    handleClear,
+    activeTerms,
+    commitFacetValue,
+    cancelPendingFacet
+  };
+}
+
+// src/SearchInput/widgets/TextSearchWidget.tsx
+import { useRef as useRef8, useEffect as useEffect7 } from "react";
+import { jsx as jsx31 } from "react/jsx-runtime";
+function TextSearchWidget({
+  value,
+  onChange,
+  onCommit,
+  onCancel,
+  placeholder,
+  autoFocus
+}) {
+  const inputRef = useRef8(null);
+  useEffect7(() => {
+    if (autoFocus) inputRef.current?.focus();
+  }, [autoFocus]);
+  return /* @__PURE__ */ jsx31(
+    Input,
+    {
+      ref: inputRef,
+      value,
+      onChange: (e) => onChange(e.target.value),
+      onKeyDown: (e) => {
+        if (e.key === "Enter") {
+          e.preventDefault();
+          const trimmed = value.trim();
+          if (trimmed) onCommit(trimmed);
+        } else if (e.key === "Escape") {
+          e.preventDefault();
+          onCancel();
+        } else if (e.key === "Backspace" && value === "") {
+          e.preventDefault();
+          onCancel();
+        }
+      },
+      placeholder,
+      className: "border-0 shadow-none focus-visible:ring-0 h-auto p-0 text-sm bg-transparent"
+    }
+  );
+}
+
+// src/SearchInput/widgets/EnumSearchWidget.tsx
+import { useEffect as useEffect8, useState as useState6 } from "react";
+import { cn as cn29 } from "@petrarca/sonnet-core";
+import { jsx as jsx32, jsxs as jsxs12 } from "react/jsx-runtime";
+function EnumSearchWidget({
+  property,
+  options: widgetOptions,
+  onCommit,
+  onCancel,
+  placeholder,
+  autoFocus
+}) {
+  const [open, setOpen] = useState6(false);
+  const [search, setSearch] = useState6("");
+  const [highlightedIndex, setHighlightedIndex] = useState6(0);
+  const enumValues = property.enum ?? [];
+  const enumNames = widgetOptions.enumNames ?? {};
+  const items = enumValues.map((val) => ({
+    value: val,
+    label: enumNames[val] ?? val
+  }));
+  const filtered = search ? items.filter(
+    (item) => item.label.toLowerCase().includes(search.toLowerCase())
+  ) : items;
+  useEffect8(() => {
+    setHighlightedIndex(0);
+  }, [filtered.length, search]);
+  useEffect8(() => {
+    if (autoFocus) {
+      requestAnimationFrame(() => setOpen(true));
+    }
+  }, [autoFocus]);
+  function handleCommit(val) {
+    onCommit(val);
+    setOpen(false);
+    setSearch("");
+  }
+  function handleOpenChange(next) {
+    setOpen(next);
+    if (!next) setSearch("");
+  }
+  function handleKeyDown(e) {
+    if (e.key === "Escape") {
+      e.preventDefault();
+      e.stopPropagation();
+      setOpen(false);
+      onCancel();
+      return;
+    }
+    if (e.key === "ArrowDown") {
+      e.preventDefault();
+      setHighlightedIndex((i) => Math.min(i + 1, filtered.length - 1));
+      return;
+    }
+    if (e.key === "ArrowUp") {
+      e.preventDefault();
+      setHighlightedIndex((i) => Math.max(i - 1, 0));
+      return;
+    }
+    if (e.key === "Enter") {
+      e.preventDefault();
+      e.stopPropagation();
+      const item = filtered[highlightedIndex];
+      if (item) handleCommit(item.value);
+      return;
+    }
+  }
+  return /* @__PURE__ */ jsxs12(Popover, { open, onOpenChange: handleOpenChange, children: [
+    /* @__PURE__ */ jsx32(PopoverTrigger, { asChild: true, children: /* @__PURE__ */ jsx32(
+      "button",
+      {
+        type: "button",
+        className: "text-sm text-muted-foreground hover:text-foreground transition-colors truncate text-left",
+        onClick: () => setOpen(true),
+        children: placeholder ?? "Select..."
+      }
+    ) }),
+    /* @__PURE__ */ jsxs12(
+      PopoverContent,
+      {
+        className: "w-48 p-1",
+        align: "start",
+        onOpenAutoFocus: (e) => e.preventDefault(),
+        children: [
+          /* @__PURE__ */ jsx32(
+            "input",
+            {
+              autoFocus: true,
+              value: search,
+              onChange: (e) => setSearch(e.target.value),
+              onKeyDown: handleKeyDown,
+              placeholder: "Search...",
+              className: "w-full px-2 py-1.5 text-sm bg-transparent outline-none border-b border-border mb-1 placeholder:text-muted-foreground"
+            }
+          ),
+          /* @__PURE__ */ jsxs12("div", { children: [
+            filtered.length === 0 && /* @__PURE__ */ jsx32("p", { className: "px-2 py-1.5 text-sm text-muted-foreground", children: "No matches" }),
+            filtered.map((item, i) => /* @__PURE__ */ jsx32(
+              "button",
+              {
+                type: "button",
+                className: cn29(
+                  "w-full text-left px-2 py-1.5 text-sm rounded transition-colors",
+                  i === highlightedIndex ? "bg-accent text-accent-foreground" : "hover:bg-accent hover:text-accent-foreground"
+                ),
+                onMouseDown: (e) => {
+                  e.preventDefault();
+                  handleCommit(item.value);
+                },
+                onMouseEnter: () => setHighlightedIndex(i),
+                children: item.label
+              },
+              item.value
+            ))
+          ] })
+        ]
+      }
+    )
+  ] });
+}
+
+// src/SearchInput/widgets/resolveSearchWidget.ts
+function resolveSearchWidget(property, registry) {
+  const widgetName = property["x-ui-widget"];
+  if (widgetName && registry[widgetName]) {
+    return registry[widgetName];
+  }
+  if (property.enum && property.enum.length > 0 && registry["enum"]) {
+    return registry["enum"];
+  }
+  return registry["text"];
+}
+
+// src/SearchInput/widgets/index.ts
+var DEFAULT_SEARCH_WIDGETS = {
+  text: TextSearchWidget,
+  enum: EnumSearchWidget
+};
+
+// src/SearchInput/SearchInput.tsx
+import { Fragment as Fragment3, jsx as jsx33, jsxs as jsxs13 } from "react/jsx-runtime";
+function resolveSearchDefaults(props) {
+  return {
+    mode: props.mode ?? "explicit",
+    debounceMs: props.debounceMs ?? 300,
+    minChars: props.minChars ?? 0,
+    showSearchButton: props.showSearchButton ?? false,
+    disabled: props.disabled ?? false
+  };
+}
+function FacetPicker({
+  pickerVisible,
+  hasFacetsToShow,
+  filteredFacets,
+  highlightedIndex,
+  setPickerOpen,
+  setHighlightedIndex,
+  acceptFacet,
+  inputRef
+}) {
+  return /* @__PURE__ */ jsxs13(Popover, { open: pickerVisible, onOpenChange: setPickerOpen, modal: false, children: [
+    /* @__PURE__ */ jsx33(PopoverTrigger, { asChild: true, children: /* @__PURE__ */ jsx33(
+      "button",
+      {
+        type: "button",
+        className: "inline-flex items-center gap-0.5 text-xs text-muted-foreground hover:text-foreground transition-colors shrink-0",
+        tabIndex: -1,
+        onClick: (e) => {
+          e.stopPropagation();
+          setPickerOpen((o) => !o);
+          inputRef.current?.focus();
+        },
+        children: /* @__PURE__ */ jsx33(ChevronDown, { className: "h-3 w-3" })
+      }
+    ) }),
+    /* @__PURE__ */ jsx33(
+      PopoverContent,
+      {
+        className: cn30("w-44 p-1", !hasFacetsToShow && "hidden"),
+        align: "start",
+        onOpenAutoFocus: (e) => e.preventDefault(),
+        onFocusOutside: (e) => e.preventDefault(),
+        children: filteredFacets.map((facet, i) => /* @__PURE__ */ jsx33(
+          "button",
+          {
+            type: "button",
+            className: cn30(
+              "w-full text-left px-2 py-1.5 text-sm rounded transition-colors",
+              i === highlightedIndex ? "bg-accent text-accent-foreground" : "hover:bg-accent hover:text-accent-foreground"
+            ),
+            onMouseDown: (e) => {
+              e.preventDefault();
+              e.stopPropagation();
+              acceptFacet(facet);
+            },
+            onMouseEnter: () => setHighlightedIndex(i),
+            children: facet.label
+          },
+          facet.key
+        ))
+      }
+    )
+  ] });
+}
+function ValueEntry({
+  pendingFacet,
+  PendingWidget,
+  pendingWidgetOptions,
+  inputValue,
+  handleInputChange,
+  commitFacetValue,
+  cancelPendingFacet,
+  resolvedPlaceholder,
+  disabled,
+  inputRef,
+  onInputKeyDown,
+  onInputChange,
+  onInputFocus
+}) {
+  if (pendingFacet && PendingWidget) {
+    return /* @__PURE__ */ jsx33(
+      PendingWidget,
+      {
+        property: pendingFacet.property,
+        options: pendingWidgetOptions,
+        value: inputValue,
+        onChange: (v) => handleInputChange({
+          target: { value: v }
+        }),
+        onCommit: (v) => {
+          commitFacetValue(v);
+          requestAnimationFrame(() => inputRef.current?.focus());
+        },
+        onCancel: () => {
+          cancelPendingFacet();
+          requestAnimationFrame(() => inputRef.current?.focus());
+        },
+        placeholder: pendingFacet.placeholder ?? resolvedPlaceholder,
+        autoFocus: true
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx33(
+    Input,
+    {
+      ref: inputRef,
+      value: inputValue,
+      onChange: onInputChange,
+      onKeyDown: onInputKeyDown,
+      onFocus: onInputFocus,
+      placeholder: resolvedPlaceholder,
+      disabled,
+      autoComplete: "off",
+      className: "border-0 shadow-none focus-visible:ring-0 h-auto p-0 text-sm bg-transparent"
+    }
+  );
+}
+function handlePickerArrowDown(ctx) {
+  if (!ctx.isFaceted || ctx.pendingFacet) return false;
+  ctx.setPickerNavigated(true);
+  if (!ctx.pickerVisible) {
+    ctx.setPickerOpen(true);
+  } else {
+    ctx.setHighlightedIndex(
+      (i) => Math.min(i + 1, ctx.filteredFacets.length - 1)
+    );
+  }
+  return true;
+}
+function handlePickerEnterSelect(ctx) {
+  if (!ctx.hasFacetsToShow) return false;
+  if (!ctx.pickerNavigated && !ctx.inputValue.trim()) return false;
+  const clamped = Math.min(ctx.highlightedIndex, ctx.filteredFacets.length - 1);
+  if (clamped >= 0 && ctx.filteredFacets[clamped]) {
+    ctx.setPickerNavigated(false);
+    ctx.acceptFacet(ctx.filteredFacets[clamped]);
+    return true;
+  }
+  return false;
+}
+function handleInputKeyDown(e, ctx) {
+  if (e.key === "ArrowDown" && handlePickerArrowDown(ctx)) {
+    e.preventDefault();
+    return;
+  }
+  if (e.key === "ArrowUp" && ctx.hasFacetsToShow) {
+    e.preventDefault();
+    ctx.setPickerNavigated(true);
+    ctx.setHighlightedIndex((i) => Math.max(i - 1, 0));
+    return;
+  }
+  if (e.key === "Enter" && handlePickerEnterSelect(ctx)) {
+    e.preventDefault();
+    return;
+  }
+  const reopenPicker = ctx.handleKeyDown(e);
+  if (e.key === "Enter") {
+    ctx.setPickerNavigated(false);
+    ctx.setPickerOpen(!!reopenPicker);
+  }
+}
+function resolvePlaceholder(isFaceted, hasActiveTerms, hasPendingFacet, placeholder) {
+  const defaultPlaceholder = isFaceted ? "Add filter..." : "Search...";
+  if (isFaceted && (hasActiveTerms || hasPendingFacet)) return "Add filter...";
+  return placeholder ?? defaultPlaceholder;
+}
+function ActiveChips({
+  terms,
+  schema,
+  onRemove
+}) {
+  return /* @__PURE__ */ jsx33(Fragment3, { children: terms.map((term, i) => {
+    const property = schema?.properties?.[term.key];
+    const label = property ? getFieldTitle2(term.key, property) : term.key;
+    return /* @__PURE__ */ jsx33(
+      FilterChip,
+      {
+        label: `${label}: ${term.value}`,
+        onRemove: () => onRemove(i)
+      },
+      `${term.key}:${term.value}`
+    );
+  }) });
+}
+function resolveWidgetForFacet(pendingFacet, registry) {
+  if (!pendingFacet) return { Widget: null, options: {} };
+  return {
+    Widget: resolveSearchWidget(pendingFacet.property, registry),
+    options: pendingFacet.property["x-ui-options"] ?? {}
+  };
+}
+function SearchActions({
+  isEmpty,
+  showSearchButton,
+  mode,
+  onClear,
+  onCommit
+}) {
+  return /* @__PURE__ */ jsxs13(Fragment3, { children: [
+    !isEmpty && /* @__PURE__ */ jsx33(
+      "button",
+      {
+        type: "button",
+        onClick: (e) => {
+          e.stopPropagation();
+          onClear();
+        },
+        className: "text-muted-foreground hover:text-foreground transition-colors shrink-0",
+        "aria-label": "Clear search",
+        children: /* @__PURE__ */ jsx33(X3, { className: "h-4 w-4" })
+      }
+    ),
+    showSearchButton && mode === "explicit" && /* @__PURE__ */ jsx33(
+      Button,
+      {
+        type: "button",
+        size: "sm",
+        variant: "ghost",
+        className: "h-6 px-2 shrink-0",
+        onClick: (e) => {
+          e.stopPropagation();
+          onCommit();
+        },
+        children: "Search"
+      }
+    )
+  ] });
+}
+function mergeWidgetRegistry(custom) {
+  return custom ? { ...DEFAULT_SEARCH_WIDGETS, ...custom } : DEFAULT_SEARCH_WIDGETS;
+}
+function SearchInput(props) {
+  const {
+    value,
+    onChange,
+    schema,
+    widgets: customWidgets,
+    searchFields,
+    placeholder,
+    className
+  } = props;
+  const { mode, debounceMs, minChars, showSearchButton, disabled } = resolveSearchDefaults(props);
+  const inputRef = useRef9(null);
+  const containerRef = useRef9(null);
+  const [pickerOpen, setPickerOpen] = useState7(false);
+  const [highlightedIndex, setHighlightedIndex] = useState7(-1);
+  const [pickerNavigated, setPickerNavigated] = useState7(false);
+  useEffect9(() => {
+    if (!pickerOpen) return;
+    function handleMouseDown(e) {
+      if (containerRef.current && !containerRef.current.contains(e.target)) {
+        setPickerOpen(false);
+      }
+    }
+    document.addEventListener("mousedown", handleMouseDown);
+    return () => document.removeEventListener("mousedown", handleMouseDown);
+  }, [pickerOpen]);
+  const widgetRegistry = useMemo6(
+    () => mergeWidgetRegistry(customWidgets),
+    [customWidgets]
+  );
+  const {
+    inputValue,
+    pendingFacet,
+    isFaceted,
+    filteredFacets,
+    selectFacet,
+    handleInputChange,
+    handleKeyDown,
+    handleCommit,
+    handleRemoveTerm,
+    handleClear,
+    activeTerms,
+    commitFacetValue,
+    cancelPendingFacet
+  } = useSearchInput({
+    value,
+    onChange,
+    mode,
+    debounceMs,
+    minChars,
+    schema,
+    searchFields
+  });
+  const isEmpty = isEmptyFilterExpr(value) && inputValue === "";
+  useEffect9(() => {
+    setHighlightedIndex(-1);
+  }, [filteredFacets, pickerOpen]);
+  const resolvedPlaceholder = resolvePlaceholder(
+    isFaceted,
+    activeTerms.length > 0,
+    pendingFacet !== null,
+    placeholder
+  );
+  const showFacetControls = isFaceted && !pendingFacet;
+  const pickerVisible = showFacetControls && pickerOpen;
+  const hasFacetsToShow = pickerVisible && filteredFacets.length > 0;
+  const acceptFacet = React29.useCallback(
+    (facet) => {
+      selectFacet(facet);
+      setPickerOpen(false);
+      inputRef.current?.focus();
+    },
+    [selectFacet]
+  );
+  const { Widget: PendingWidget, options: pendingWidgetOptions } = resolveWidgetForFacet(pendingFacet, widgetRegistry);
+  const keyDownCtx = {
+    isFaceted,
+    pendingFacet,
+    pickerVisible,
+    hasFacetsToShow,
+    filteredFacets,
+    highlightedIndex,
+    inputValue,
+    pickerNavigated,
+    setPickerNavigated,
+    setPickerOpen,
+    setHighlightedIndex,
+    acceptFacet,
+    handleKeyDown
+  };
+  return /* @__PURE__ */ jsxs13(
+    "div",
+    {
+      ref: containerRef,
+      className: cn30(
+        "flex flex-wrap items-center gap-1.5 rounded-md border border-input bg-background px-2 py-1.5 text-sm min-h-9",
+        disabled ? "opacity-50 cursor-not-allowed" : "cursor-text",
+        className
+      ),
+      onClick: () => !disabled && inputRef.current?.focus(),
+      onBlur: (e) => {
+        const relatedTarget = e.relatedTarget;
+        if (relatedTarget && !e.currentTarget.contains(relatedTarget)) {
+          setPickerOpen(false);
+        }
+      },
+      children: [
+        /* @__PURE__ */ jsx33(Search2, { className: "h-4 w-4 text-muted-foreground shrink-0" }),
+        isFaceted && /* @__PURE__ */ jsx33(
+          ActiveChips,
+          {
+            terms: activeTerms,
+            schema,
+            onRemove: handleRemoveTerm
+          }
+        ),
+        pendingFacet && /* @__PURE__ */ jsxs13("span", { className: "inline-flex items-center gap-1 rounded-full bg-muted px-2 py-0.5 text-xs font-medium text-muted-foreground", children: [
+          pendingFacet.label,
+          ":"
+        ] }),
+        /* @__PURE__ */ jsxs13("div", { className: "flex items-center gap-1 flex-1 min-w-[120px]", children: [
+          showFacetControls && /* @__PURE__ */ jsx33(
+            FacetPicker,
+            {
+              pickerVisible,
+              hasFacetsToShow,
+              filteredFacets,
+              highlightedIndex,
+              setPickerOpen,
+              setHighlightedIndex,
+              acceptFacet,
+              inputRef
+            }
+          ),
+          /* @__PURE__ */ jsx33(
+            ValueEntry,
+            {
+              pendingFacet,
+              PendingWidget,
+              pendingWidgetOptions,
+              inputValue,
+              handleInputChange,
+              commitFacetValue,
+              cancelPendingFacet,
+              resolvedPlaceholder,
+              disabled,
+              inputRef,
+              onInputKeyDown: (e) => handleInputKeyDown(e, keyDownCtx),
+              onInputChange: (e) => {
+                handleInputChange(e);
+                setPickerNavigated(false);
+              },
+              onInputFocus: () => {
+                if (isFaceted && !pendingFacet) setPickerNavigated(false);
+              }
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx33(
+          SearchActions,
+          {
+            isEmpty,
+            showSearchButton,
+            mode,
+            onClear: handleClear,
+            onCommit: handleCommit
+          }
+        )
+      ]
+    }
+  );
+}
+function FilterChip({ label, onRemove }) {
+  return /* @__PURE__ */ jsxs13(
+    Badge,
+    {
+      variant: "secondary",
+      className: "inline-flex items-center gap-1 px-2 py-0.5 text-xs font-medium rounded-full",
+      children: [
+        label,
+        /* @__PURE__ */ jsx33(
+          "button",
+          {
+            type: "button",
+            onClick: (e) => {
+              e.stopPropagation();
+              onRemove();
+            },
+            className: "ml-0.5 hover:text-destructive transition-colors",
+            "aria-label": `Remove filter ${label}`,
+            children: /* @__PURE__ */ jsx33(X3, { className: "h-3 w-3" })
+          }
+        )
+      ]
+    }
+  );
+}
+
+// src/Clipboard/ClipboardButton.tsx
+import { Copy } from "lucide-react";
+import { jsx as jsx34 } from "react/jsx-runtime";
+function ClipboardButton({ hasItems, onClick }) {
+  return /* @__PURE__ */ jsx34(
+    Button,
+    {
+      variant: "ghost",
+      size: "icon",
+      onClick,
+      disabled: !hasItems,
+      style: {
+        opacity: hasItems ? 1 : 0.4,
+        cursor: hasItems ? "pointer" : "not-allowed"
+      },
+      children: /* @__PURE__ */ jsx34(Copy, { size: 16 })
+    }
+  );
+}
+var ClipboardButton_default = ClipboardButton;
+
+// src/Clipboard/ClipboardItem.tsx
+import { X as X4, Plus } from "lucide-react";
+import { jsx as jsx35, jsxs as jsxs14 } from "react/jsx-runtime";
+function ClipboardItemComponent({ item, onAddItem, onRemove }) {
+  const handleAddClick = (e) => {
+    const keepInClipboard = e.shiftKey;
+    onAddItem(item, keepInClipboard);
+  };
+  return /* @__PURE__ */ jsx35(
+    "div",
+    {
+      className: "p-3 rounded mb-2",
+      style: {
+        borderLeft: `4px solid ${item.color}`,
+        backgroundColor: "#f8f9fa"
+      },
+      children: /* @__PURE__ */ jsxs14(SimpleGroup, { justify: "space-between", wrap: "nowrap", align: "flex-start", children: [
+        /* @__PURE__ */ jsxs14("div", { className: "flex-1 min-w-0 overflow-hidden", children: [
+          /* @__PURE__ */ jsx35("p", { className: "text-sm font-semibold truncate", children: item.label }),
+          /* @__PURE__ */ jsx35("p", { className: "text-xs text-muted-foreground truncate", children: item.displayName }),
+          /* @__PURE__ */ jsxs14("p", { className: "text-xs text-muted-foreground font-mono", children: [
+            "#",
+            item.entityId
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs14(SimpleGroup, { gap: 4, wrap: "nowrap", style: { flexShrink: 0 }, children: [
+          /* @__PURE__ */ jsxs14(
+            Button,
+            {
+              size: "sm",
+              variant: "secondary",
+              onClick: handleAddClick,
+              title: "Click to add and remove from clipboard, Shift+Click to keep in clipboard",
+              children: [
+                /* @__PURE__ */ jsx35(Plus, { size: 16 }),
+                "Add"
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsx35(
+            Button,
+            {
+              size: "sm",
+              variant: "ghost",
+              onClick: () => onRemove(item.id),
+              title: "Remove from clipboard",
+              children: /* @__PURE__ */ jsx35(X4, { size: 16 })
+            }
+          )
+        ] })
+      ] })
+    }
+  );
+}
+var ClipboardItem_default = ClipboardItemComponent;
+
+// src/Clipboard/ClipboardMenu.tsx
+import { Trash2 } from "lucide-react";
+
+// src/Clipboard/clipboardStore.ts
+import { create } from "zustand";
+import { persist } from "zustand/middleware";
+import { devLog } from "@petrarca/sonnet-core";
+function getItemKey(item) {
+  return `${item.type}:${item.entityId}:${item.label}`;
+}
+function getInputKey(input) {
+  return `${input.type}:${input.entityId}:${input.label}`;
+}
+function uuid() {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+var MAX_CLIPBOARD_SIZE = 100;
+var useClipboard = create()(
+  persist(
+    (set, get) => ({
+      items: [],
+      addItems: (inputs) => {
+        const currentItems = get().items;
+        const existingKeys = new Set(currentItems.map(getItemKey));
+        const newItems = inputs.map(
+          (input) => ({
+            id: uuid(),
+            type: input.type,
+            entityId: input.entityId,
+            label: input.label,
+            displayName: input.displayName,
+            color: input.color
+          })
+        ).filter((item) => !existingKeys.has(getInputKey(item)));
+        if (newItems.length === 0) {
+          devLog(
+            "[ClipboardStore] addItems - all items were duplicates, skipped"
+          );
+          return;
+        }
+        let updatedItems = [...currentItems, ...newItems];
+        if (updatedItems.length > MAX_CLIPBOARD_SIZE) {
+          const overflow = updatedItems.length - MAX_CLIPBOARD_SIZE;
+          updatedItems = updatedItems.slice(overflow);
+          devLog(
+            "[ClipboardStore] addItems - size limit exceeded, removed oldest",
+            { overflow }
+          );
+        }
+        devLog("[ClipboardStore] addItems", {
+          added: newItems.length,
+          total: updatedItems.length,
+          skippedDuplicates: inputs.length - newItems.length
+        });
+        set({ items: updatedItems });
+      },
+      removeItem: (itemId) => {
+        const currentItems = get().items;
+        const updatedItems = currentItems.filter((item) => item.id !== itemId);
+        if (updatedItems.length === currentItems.length) {
+          devLog("[ClipboardStore] removeItem - item not found", { itemId });
+          return;
+        }
+        devLog("[ClipboardStore] removeItem", {
+          itemId,
+          remainingCount: updatedItems.length
+        });
+        set({ items: updatedItems });
+      },
+      clear: () => {
+        const currentCount = get().items.length;
+        devLog("[ClipboardStore] clear", { clearedCount: currentCount });
+        set({ items: [] });
+      }
+    }),
+    {
+      name: "clipboard-items",
+      version: 2
+    }
+  )
+);
+var clipboardStore_default = useClipboard;
+
+// src/Clipboard/ClipboardMenu.tsx
+import { jsx as jsx36, jsxs as jsxs15 } from "react/jsx-runtime";
+function ClipboardMenu({ onAddItem }) {
+  const { items, removeItem, clear } = clipboardStore_default();
+  if (items.length === 0) {
+    return /* @__PURE__ */ jsxs15("div", { style: { padding: "16px", textAlign: "center", width: "300px" }, children: [
+      /* @__PURE__ */ jsx36("p", { className: "text-sm text-muted-foreground", children: "No items in clipboard" }),
+      /* @__PURE__ */ jsx36("p", { className: "text-xs text-muted-foreground mt-1", children: 'Right-click a node and select "Copy"' })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs15(
+    "div",
+    {
+      style: {
+        width: "380px",
+        maxWidth: "90vw",
+        display: "flex",
+        flexDirection: "column",
+        maxHeight: "500px"
+      },
+      children: [
+        /* @__PURE__ */ jsx36(ScrollArea, { className: "flex-1 p-3 min-h-0", children: /* @__PURE__ */ jsx36(SimpleStack, { gap: 0, children: items.map((item) => /* @__PURE__ */ jsx36(
+          ClipboardItem_default,
+          {
+            item,
+            onAddItem,
+            onRemove: removeItem
+          },
+          item.id
+        )) }) }),
+        /* @__PURE__ */ jsx36(Separator2, {}),
+        /* @__PURE__ */ jsx36("div", { style: { padding: "8px 12px", flexShrink: 0 }, children: /* @__PURE__ */ jsxs15(
+          Button,
+          {
+            className: "w-full",
+            variant: "destructive",
+            size: "sm",
+            onClick: clear,
+            children: [
+              /* @__PURE__ */ jsx36(Trash2, { size: 16 }),
+              "Clear All (",
+              items.length,
+              ")"
+            ]
+          }
+        ) })
+      ]
+    }
+  );
+}
+var ClipboardMenu_default = ClipboardMenu;
+export {
+  Alert,
+  AlertDescription,
+  AlertTitle,
+  Avatar,
+  AvatarFallback,
+  AvatarImage,
+  Badge,
+  Button,
+  CELL_RENDERERS,
+  Card,
+  CardContent,
+  CardDescription,
+  CardFooter,
+  CardHeader,
+  CardTitle,
+  Checkbox,
+  ClipboardButton_default as ClipboardButton,
+  ClipboardItem_default as ClipboardItem,
+  ClipboardMenu_default as ClipboardMenu,
+  Collapsible,
+  CollapsibleContent2 as CollapsibleContent,
+  CollapsibleTrigger2 as CollapsibleTrigger,
+  Command,
+  CommandDialog,
+  CommandEmpty,
+  CommandGroup,
+  CommandInput,
+  CommandItem,
+  CommandList,
+  CommandSeparator,
+  CommandShortcut,
+  Dialog,
+  DialogClose,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogOverlay,
+  DialogPortal,
+  DialogTitle,
+  DialogTrigger,
+  DropdownMenu,
+  DropdownMenuCheckboxItem,
+  DropdownMenuContent,
+  DropdownMenuGroup,
+  DropdownMenuItem,
+  DropdownMenuLabel,
+  DropdownMenuPortal,
+  DropdownMenuRadioGroup,
+  DropdownMenuRadioItem,
+  DropdownMenuSeparator,
+  DropdownMenuShortcut,
+  DropdownMenuSub,
+  DropdownMenuSubContent,
+  DropdownMenuSubTrigger,
+  DropdownMenuTrigger,
+  EntitySelect,
+  EntityTable,
+  EntityTree,
+  Input,
+  InputGroup,
+  InputGroupAddon,
+  InputGroupInput,
+  InputGroupText,
+  InputGroupTextarea,
+  Label2 as Label,
+  Popover,
+  PopoverContent,
+  PopoverTrigger,
+  ScrollArea,
+  ScrollBar,
+  SearchInput,
+  Separator2 as Separator,
+  Sheet,
+  SheetBody,
+  SheetClose,
+  SheetContent,
+  SheetDescription,
+  SheetFooter,
+  SheetHeader,
+  SheetOverlay,
+  SheetTitle,
+  SheetTrigger,
+  SimpleGroup,
+  SimpleStack,
+  SimpleTooltip,
+  Skeleton,
+  Spinner,
+  Stepper,
+  StepperContent,
+  StepperDescription,
+  StepperIndicator,
+  StepperItem,
+  StepperList,
+  StepperNext,
+  StepperPrev,
+  StepperSeparator,
+  StepperTitle,
+  StepperTrigger,
+  Tabs,
+  TabsContent,
+  TabsList,
+  TabsTrigger,
+  Textarea,
+  Tooltip,
+  TooltipContent,
+  TooltipProvider,
+  TooltipTrigger,
+  TreeView,
+  badgeVariants,
+  buttonVariants,
+  createRenderer,
+  useStore as useStepper
+};
+//# sourceMappingURL=index.js.map