@marktiderman/genesis-ui 1.2.0 → 2.0.0

package/dist/components/ui/scroll-area.d.ts

@@ -1,9 +1,66 @@
-import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as React from 'react';
+import { ScrollArea as ScrollArea$1 } from 'radix-ui';
 
-interface ScrollAreaProps extends React.HTMLAttributes<HTMLDivElement> {
+interface ScrollAreaProps extends React.ComponentPropsWithoutRef<typeof ScrollArea$1.Root> {
+    /**
+     * Which axes get a scrollbar. `"vertical"` (the default) also clips
+     * horizontal overflow, `"horizontal"` clips vertical overflow, `"both"`
+     * scrolls either way — the same meaning the `overflow-*` utilities this
+     * replaced had, because Radix's viewport derives `overflow-x`/`overflow-y`
+     * from which scrollbars are mounted.
+     */
     orientation?: "vertical" | "horizontal" | "both";
+    /**
+     * Props for the inner viewport — the element that actually scrolls.
+     *
+     * The root that this component's `ref`, `className` and remaining props land
+     * on is `overflow: hidden`; scrolling happens one level in. `onScroll`,
+     * `onScrollCapture` and `nonce` are routed to the viewport automatically
+     * because they have no other correct destination. Anything else that must
+     * address the scroller specifically — a `ref` for programmatic `scrollTop`, a
+     * `tabIndex`, an `id`, `aria-*` — goes here. Values passed here win over the
+     * automatically routed ones.
+     */
+    viewportProps?: React.ComponentPropsWithRef<typeof ScrollArea$1.Viewport>;
 }
-declare function ScrollArea({ className, orientation, children, ...props }: ScrollAreaProps): react_jsx_runtime.JSX.Element;
+/**
+ * ScrollArea — a scroll container with a consistent, styled scrollbar.
+ *
+ * Backed by Radix `ScrollArea`. The hand-rolled version was a single
+ * `overflow-auto` div plus a stack of `::-webkit-scrollbar` pseudo-element
+ * rules, which is a WebKit-only vocabulary: Firefox ignored every one of them
+ * and rendered the OS scrollbar instead, so the "design system scrollbar" was
+ * a Chrome/Safari-only promise. Radix hides the native scrollbar and renders a
+ * real element in its place, so the same thumb appears in every browser, can
+ * be dragged, and participates in the same hover/transition styling as the
+ * rest of the system.
+ *
+ * `type` defaults to `"auto"` — scrollbar present exactly while the content
+ * overflows — because that is what `overflow-auto` did. Radix's own default is
+ * `"hover"`; pass `type` explicitly for `"hover"`, `"always"` or `"scroll"`.
+ *
+ * NOTE ON PROP DESTINATIONS. This used to be one element; it is now a root plus
+ * an inner viewport, and the root does not scroll. Three props therefore have to
+ * be routed inward rather than spread onto the root with the rest, because for
+ * them the root is not merely a different element — it is an element on which
+ * they do nothing at all, silently:
+ *
+ *   - `onScroll` / `onScrollCapture` — `scroll` events do not bubble, so a
+ *     handler on the root would never fire once. Infinite-loading and
+ *     scroll-position UI would break with no error.
+ *   - `nonce` — Radix injects its scrollbar-hiding `<style>` from the viewport
+ *     and only reads a nonce given to that component. Under a strict
+ *     `style-src 'nonce-…'` policy the rule is blocked and the native scrollbar
+ *     shows up alongside the custom one.
+ *
+ * Everything else keeps landing on the root, which is the component's box and
+ * the right owner for `className`, `style`, `id`, `role`, `aria-*`, `data-*`
+ * and bubbling handlers. `viewportProps` is the escape hatch for the remainder
+ * — most importantly a `ref`, since `ref` on this component addresses the root
+ * and setting `scrollTop` there does nothing.
+ *
+ * @stability Stable
+ */
+declare const ScrollArea: React.ForwardRefExoticComponent<ScrollAreaProps & React.RefAttributes<HTMLDivElement>>;
 
 export { ScrollArea };

package/dist/components/ui/scroll-area.js

@@ -1,4 +1,4 @@
-export { ScrollArea } from '../../chunk-OCTV3S4I.js';
+export { ScrollArea } from '../../chunk-6KHY647C.js';
 import '../../chunk-NZ5WBA4R.js';
 //# sourceMappingURL=scroll-area.js.map
 //# sourceMappingURL=scroll-area.js.map

package/dist/components/ui/select.d.ts

@@ -1,13 +1,13 @@
 import * as React from 'react';
-import * as SelectPrimitive from '@radix-ui/react-select';
+import { Select as Select$1 } from 'radix-ui';
 
-declare const Select: React.FC<SelectPrimitive.SelectProps>;
-declare const SelectGroup: React.ForwardRefExoticComponent<SelectPrimitive.SelectGroupProps & React.RefAttributes<HTMLDivElement>>;
-declare const SelectValue: React.ForwardRefExoticComponent<SelectPrimitive.SelectValueProps & React.RefAttributes<HTMLSpanElement>>;
-declare const SelectTrigger: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
-declare const SelectScrollUpButton: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollUpButtonProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
-declare const SelectScrollDownButton: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollDownButtonProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
-declare const SelectContent: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
-declare const SelectItem: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const Select: React.FC<Select$1.SelectProps>;
+declare const SelectGroup: React.ForwardRefExoticComponent<Select$1.SelectGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const SelectValue: React.ForwardRefExoticComponent<Select$1.SelectValueProps & React.RefAttributes<HTMLSpanElement>>;
+declare const SelectTrigger: React.ForwardRefExoticComponent<Omit<Select$1.SelectTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const SelectScrollUpButton: React.ForwardRefExoticComponent<Omit<Select$1.SelectScrollUpButtonProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectScrollDownButton: React.ForwardRefExoticComponent<Omit<Select$1.SelectScrollDownButtonProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectContent: React.ForwardRefExoticComponent<Omit<Select$1.SelectContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectItem: React.ForwardRefExoticComponent<Omit<Select$1.SelectItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
 
 export { Select, SelectContent, SelectGroup, SelectItem, SelectScrollDownButton, SelectScrollUpButton, SelectTrigger, SelectValue };

package/dist/components/ui/select.js

@@ -1,4 +1,4 @@
-export { Select, SelectContent, SelectGroup, SelectItem, SelectScrollDownButton, SelectScrollUpButton, SelectTrigger, SelectValue } from '../../chunk-2B3MFHBQ.js';
+export { Select, SelectContent, SelectGroup, SelectItem, SelectScrollDownButton, SelectScrollUpButton, SelectTrigger, SelectValue } from '../../chunk-FK42ZGGV.js';
 import '../../chunk-NZ5WBA4R.js';
 //# sourceMappingURL=select.js.map
 //# sourceMappingURL=select.js.map

package/dist/components/ui/sheet.d.ts

@@ -1,18 +1,20 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as class_variance_authority_types from 'class-variance-authority/types';
 import * as React from 'react';
-import * as DialogPrimitive from '@radix-ui/react-dialog';
+import { Dialog } from 'radix-ui';
 import { VariantProps } from 'class-variance-authority';
 
-declare const Sheet: React.FC<DialogPrimitive.DialogProps>;
-declare const SheetTrigger: React.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
-declare const SheetClose: React.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
-declare const SheetPortal: React.FC<DialogPrimitive.DialogPortalProps>;
-declare const SheetOverlay: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const Sheet: React.FC<Dialog.DialogProps>;
+declare const SheetTrigger: React.ForwardRefExoticComponent<Dialog.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const SheetClose: React.ForwardRefExoticComponent<Dialog.DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
+declare const SheetPortal: React.FC<Dialog.DialogPortalProps>;
+declare const SheetOverlay: React.ForwardRefExoticComponent<Omit<Dialog.DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
 declare const sheetVariants: (props?: ({
     side?: "top" | "right" | "bottom" | "left" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
-interface SheetContentProps extends React.ComponentPropsWithoutRef<typeof DialogPrimitive.Content>, VariantProps<typeof sheetVariants> {
+interface SheetContentProps extends React.ComponentPropsWithoutRef<typeof Dialog.Content>, VariantProps<typeof sheetVariants> {
+    /** Show the built-in top-right close affordance. Default true. Mirrors `DialogContent`'s `showCloseButton` — set false when a composing consumer (e.g. `DetailPanel`) renders its own close control. */
+    showCloseButton?: boolean;
 }
 declare const SheetContent: React.ForwardRefExoticComponent<SheetContentProps & React.RefAttributes<HTMLDivElement>>;
 declare const SheetHeader: {
@@ -23,7 +25,7 @@ declare const SheetFooter: {
     ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
     displayName: string;
 };
-declare const SheetTitle: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
-declare const SheetDescription: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+declare const SheetTitle: React.ForwardRefExoticComponent<Omit<Dialog.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+declare const SheetDescription: React.ForwardRefExoticComponent<Omit<Dialog.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
 
 export { Sheet, SheetClose, SheetContent, SheetDescription, SheetFooter, SheetHeader, SheetOverlay, SheetPortal, SheetTitle, SheetTrigger };

package/dist/components/ui/sheet.js

@@ -1,4 +1,4 @@
-export { Sheet, SheetClose, SheetContent, SheetDescription, SheetFooter, SheetHeader, SheetOverlay, SheetPortal, SheetTitle, SheetTrigger } from '../../chunk-SCUT2ZCD.js';
+export { Sheet, SheetClose, SheetContent, SheetDescription, SheetFooter, SheetHeader, SheetOverlay, SheetPortal, SheetTitle, SheetTrigger } from '../../chunk-XCGZPFT7.js';
 import '../../chunk-NZ5WBA4R.js';
 //# sourceMappingURL=sheet.js.map
 //# sourceMappingURL=sheet.js.map

package/dist/components/ui/slider.d.ts

@@ -1,6 +1,6 @@
 import * as React from 'react';
-import * as SliderPrimitive from '@radix-ui/react-slider';
+import { Slider as Slider$1 } from 'radix-ui';
 
-declare const Slider: React.ForwardRefExoticComponent<Omit<SliderPrimitive.SliderProps & React.RefAttributes<HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+declare const Slider: React.ForwardRefExoticComponent<Omit<Slider$1.SliderProps & React.RefAttributes<HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
 
 export { Slider };

package/dist/components/ui/slider.js

@@ -1,4 +1,4 @@
-export { Slider } from '../../chunk-LRXDZBV2.js';
+export { Slider } from '../../chunk-PSR47JRA.js';
 import '../../chunk-NZ5WBA4R.js';
 //# sourceMappingURL=slider.js.map
 //# sourceMappingURL=slider.js.map

package/dist/components/ui/switch.d.ts

@@ -1,6 +1,6 @@
 import * as React from 'react';
-import * as SwitchPrimitive from '@radix-ui/react-switch';
+import { Switch as Switch$1 } from 'radix-ui';
 
-declare const Switch: React.ForwardRefExoticComponent<Omit<SwitchPrimitive.SwitchProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const Switch: React.ForwardRefExoticComponent<Omit<Switch$1.SwitchProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
 
 export { Switch };

package/dist/components/ui/switch.js

@@ -1,4 +1,4 @@
-export { Switch } from '../../chunk-2MXMWBDV.js';
+export { Switch } from '../../chunk-27ELYTGE.js';
 import '../../chunk-NZ5WBA4R.js';
 //# sourceMappingURL=switch.js.map
 //# sourceMappingURL=switch.js.map

package/dist/components/ui/tabs.d.ts

@@ -1,20 +1,35 @@
-import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as React from 'react';
+import { Tabs as Tabs$1 } from 'radix-ui';
 
-interface TabsProps extends React.HTMLAttributes<HTMLDivElement> {
+interface TabsProps extends React.ComponentPropsWithoutRef<typeof Tabs$1.Root> {
+    /**
+     * Required here even though Radix's own `defaultValue` is optional — that is
+     * the existing contract, and loosening it is a separate decision.
+     */
     defaultValue: string;
-    value?: string;
-    onValueChange?: (value: string) => void;
 }
-declare function Tabs({ defaultValue, value: controlledValue, onValueChange: controlledOnValueChange, className, ...props }: TabsProps): react_jsx_runtime.JSX.Element;
-declare function TabsList({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
-interface TabsTriggerProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
-    value: string;
-}
-declare function TabsTrigger({ className, value, ...props }: TabsTriggerProps): react_jsx_runtime.JSX.Element;
-interface TabsContentProps extends React.HTMLAttributes<HTMLDivElement> {
-    value: string;
-}
-declare function TabsContent({ className, value, ...props }: TabsContentProps): react_jsx_runtime.JSX.Element | null;
+/**
+ * Tabs — a tablist and its panels.
+ *
+ * Backed by Radix `Tabs`. The hand-rolled version was a React context plus a
+ * row of plain `<button>`s: it tracked the selected value correctly and
+ * nothing else. Every keyboard and screen-reader affordance the WAI-ARIA tabs
+ * pattern asks for was missing — `role="tablist"`/`"tab"`/`"tabpanel"`, the
+ * `aria-selected` state, the `aria-controls`/`aria-labelledby` link between a
+ * tab and its panel, the roving `tabindex` that makes the whole tablist ONE
+ * tab stop instead of N, and Arrow/Home/End navigation between tabs. Radix
+ * supplies all of it, plus the selection state the old version already
+ * handled.
+ *
+ * One behavioural note worth knowing: Radix selects on `mousedown` rather than
+ * `click`. Pointer users see no difference, but a synthetic `fireEvent.click`
+ * on a trigger no longer changes tabs.
+ *
+ * @stability Stable
+ */
+declare const Tabs: React.ForwardRefExoticComponent<TabsProps & React.RefAttributes<HTMLDivElement>>;
+declare const TabsList: React.ForwardRefExoticComponent<Omit<Tabs$1.TabsListProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const TabsTrigger: React.ForwardRefExoticComponent<Omit<Tabs$1.TabsTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const TabsContent: React.ForwardRefExoticComponent<Omit<Tabs$1.TabsContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
 
 export { Tabs, TabsContent, TabsList, TabsTrigger };

package/dist/components/ui/tabs.js

@@ -1,4 +1,4 @@
-export { Tabs, TabsContent, TabsList, TabsTrigger } from '../../chunk-JJ4NOMMI.js';
+export { Tabs, TabsContent, TabsList, TabsTrigger } from '../../chunk-VXFYETRK.js';
 import '../../chunk-NZ5WBA4R.js';
 //# sourceMappingURL=tabs.js.map
 //# sourceMappingURL=tabs.js.map

package/dist/components/ui/toggle-group.d.ts

@@ -1,13 +1,13 @@
 import * as class_variance_authority_types from 'class-variance-authority/types';
 import * as React from 'react';
-import * as ToggleGroupPrimitive from '@radix-ui/react-toggle-group';
+import { ToggleGroup as ToggleGroup$1 } from 'radix-ui';
 import { VariantProps } from 'class-variance-authority';
 
-declare const ToggleGroup: React.ForwardRefExoticComponent<((Omit<ToggleGroupPrimitive.ToggleGroupSingleProps & React.RefAttributes<HTMLDivElement>, "ref"> | Omit<ToggleGroupPrimitive.ToggleGroupMultipleProps & React.RefAttributes<HTMLDivElement>, "ref">) & VariantProps<(props?: ({
+declare const ToggleGroup: React.ForwardRefExoticComponent<((Omit<ToggleGroup$1.ToggleGroupSingleProps & React.RefAttributes<HTMLDivElement>, "ref"> | Omit<ToggleGroup$1.ToggleGroupMultipleProps & React.RefAttributes<HTMLDivElement>, "ref">) & VariantProps<(props?: ({
     variant?: "default" | "outline" | null | undefined;
     size?: "default" | "sm" | "lg" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string>) & React.RefAttributes<HTMLDivElement>>;
-declare const ToggleGroupItem: React.ForwardRefExoticComponent<Omit<ToggleGroupPrimitive.ToggleGroupItemProps & React.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: ({
+declare const ToggleGroupItem: React.ForwardRefExoticComponent<Omit<ToggleGroup$1.ToggleGroupItemProps & React.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: ({
     variant?: "default" | "outline" | null | undefined;
     size?: "default" | "sm" | "lg" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string> & React.RefAttributes<HTMLButtonElement>>;

package/dist/components/ui/toggle-group.js

@@ -1,5 +1,5 @@
-export { ToggleGroup, ToggleGroupItem } from '../../chunk-5Q4FABZQ.js';
-import '../../chunk-JXI2MYL3.js';
+export { ToggleGroup, ToggleGroupItem } from '../../chunk-NUXW6NPP.js';
+import '../../chunk-C46ITXE4.js';
 import '../../chunk-NZ5WBA4R.js';
 //# sourceMappingURL=toggle-group.js.map
 //# sourceMappingURL=toggle-group.js.map

package/dist/components/ui/toggle.d.ts

@@ -1,13 +1,13 @@
 import * as class_variance_authority_types from 'class-variance-authority/types';
 import * as React from 'react';
-import * as TogglePrimitive from '@radix-ui/react-toggle';
+import { Toggle as Toggle$1 } from 'radix-ui';
 import { VariantProps } from 'class-variance-authority';
 
 declare const toggleVariants: (props?: ({
     variant?: "default" | "outline" | null | undefined;
     size?: "default" | "sm" | "lg" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
-declare const Toggle: React.ForwardRefExoticComponent<Omit<TogglePrimitive.ToggleProps & React.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: ({
+declare const Toggle: React.ForwardRefExoticComponent<Omit<Toggle$1.ToggleProps & React.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: ({
     variant?: "default" | "outline" | null | undefined;
     size?: "default" | "sm" | "lg" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string> & React.RefAttributes<HTMLButtonElement>>;

package/dist/components/ui/toggle.js

@@ -1,4 +1,4 @@
-export { Toggle, toggleVariants } from '../../chunk-JXI2MYL3.js';
+export { Toggle, toggleVariants } from '../../chunk-C46ITXE4.js';
 import '../../chunk-NZ5WBA4R.js';
 //# sourceMappingURL=toggle.js.map
 //# sourceMappingURL=toggle.js.map

package/dist/components/ui/toolbar.d.ts

@@ -0,0 +1,104 @@
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import * as React from 'react';
+import { Toolbar as Toolbar$1 } from 'radix-ui';
+import { VariantProps } from 'class-variance-authority';
+import { buttonVariants } from './button.js';
+import { toggleVariants } from './toggle.js';
+
+declare const toolbarVariants: (props?: ({
+    orientation?: "horizontal" | "vertical" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface ToolbarProps extends React.ComponentPropsWithoutRef<typeof Toolbar$1.Root> {
+    /** Stable test/automation selector (emitted as `data-testid`). */
+    testID?: string;
+}
+/**
+ * Toolbar — a grouped set of controls that behaves as ONE tab stop.
+ *
+ * This is a primitive, not a layout, and the distinction is the whole reason
+ * it wraps Radix instead of a `<div className="flex gap-1">`. Radix's Toolbar
+ * owns a roving tabindex: Tab moves into and out of the whole group, and
+ * Arrow/Home/End move between the items inside it. A layout, by the framework's
+ * own definition, "positions things without knowing what they are" — this one
+ * knows its children are focusable controls and manages their focus, so it
+ * fails that test and passes the primitive one.
+ *
+ * `orientation` is passed to BOTH Radix (which uses it to decide whether
+ * Left/Right or Up/Down are the navigation keys) and the CVA class (which uses
+ * it to decide the flex direction). Splitting those would let the visual axis
+ * and the keyboard axis disagree — arrows moving "down" a row of buttons.
+ *
+ * @stability Beta
+ */
+declare const Toolbar: React.ForwardRefExoticComponent<ToolbarProps & React.RefAttributes<HTMLDivElement>>;
+interface ToolbarButtonProps extends React.ComponentPropsWithoutRef<typeof Toolbar$1.Button>, VariantProps<typeof buttonVariants> {
+    /** Stable test/automation selector (emitted as `data-testid`). */
+    testID?: string;
+}
+/**
+ * ToolbarButton — a button that participates in the toolbar's roving tabindex.
+ *
+ * Styling reuses `buttonVariants` rather than declaring a second button look:
+ * per the framework's "one home per concept", the question "what does a button
+ * look like?" already has an answer. Only the DEFAULTS differ — `ghost`/`sm`,
+ * because a toolbar is a dense strip of controls, not a page's primary action —
+ * and both remain overridable.
+ *
+ * @stability Beta
+ */
+declare const ToolbarButton: React.ForwardRefExoticComponent<ToolbarButtonProps & React.RefAttributes<HTMLButtonElement>>;
+interface ToolbarLinkProps extends React.ComponentPropsWithoutRef<typeof Toolbar$1.Link> {
+    /** Stable test/automation selector (emitted as `data-testid`). */
+    testID?: string;
+}
+/**
+ * ToolbarLink — an anchor inside the toolbar's roving tabindex.
+ *
+ * Kept distinct from `ToolbarButton` because the element matters: a link
+ * navigates and must stay an `<a>` for middle-click, "open in new tab" and the
+ * screen-reader link rotor. Radix also gives it the toolbar's Enter/Space
+ * handling without turning it into a button.
+ *
+ * @stability Beta
+ */
+declare const ToolbarLink: React.ForwardRefExoticComponent<ToolbarLinkProps & React.RefAttributes<HTMLAnchorElement>>;
+interface ToolbarSeparatorProps extends React.ComponentPropsWithoutRef<typeof Toolbar$1.Separator> {
+}
+/**
+ * ToolbarSeparator — a decorative divider between toolbar groups.
+ *
+ * Radix excludes it from the roving tabindex, so arrow keys skip straight over
+ * it instead of landing on a 1px line.
+ *
+ * Note the inverted axis, which is easy to get backwards: Radix gives the
+ * separator the orientation PERPENDICULAR to the toolbar's, so a horizontal
+ * toolbar contains separators with `data-orientation="vertical"`. The classes
+ * below are keyed on the separator's own orientation accordingly — a vertical
+ * separator is the tall thin rule.
+ *
+ * @stability Beta
+ */
+declare const ToolbarSeparator: React.ForwardRefExoticComponent<ToolbarSeparatorProps & React.RefAttributes<HTMLDivElement>>;
+/**
+ * ToolbarToggleGroup — a set of pressed/unpressed controls inside a toolbar
+ * (the classic bold / italic / underline cluster).
+ *
+ * @stability Beta
+ */
+declare const ToolbarToggleGroup: React.ForwardRefExoticComponent<(Omit<Toolbar$1.ToolbarToggleGroupSingleProps & React.RefAttributes<HTMLDivElement>, "ref"> | Omit<Toolbar$1.ToolbarToggleGroupMultipleProps & React.RefAttributes<HTMLDivElement>, "ref">) & React.RefAttributes<HTMLDivElement>>;
+interface ToolbarToggleItemProps extends React.ComponentPropsWithoutRef<typeof Toolbar$1.ToggleItem>, VariantProps<typeof toggleVariants> {
+    /** Stable test/automation selector (emitted as `data-testid`). */
+    testID?: string;
+}
+/**
+ * ToolbarToggleItem — one member of a `ToolbarToggleGroup`.
+ *
+ * Reuses `toggleVariants` for the same reason `ToolbarButton` reuses
+ * `buttonVariants`: `Toggle` already answers "what does a pressed control look
+ * like?", and a second answer is how two implementations get born.
+ *
+ * @stability Beta
+ */
+declare const ToolbarToggleItem: React.ForwardRefExoticComponent<ToolbarToggleItemProps & React.RefAttributes<HTMLButtonElement>>;
+
+export { Toolbar, ToolbarButton, type ToolbarButtonProps, ToolbarLink, type ToolbarLinkProps, type ToolbarProps, ToolbarSeparator, type ToolbarSeparatorProps, ToolbarToggleGroup, ToolbarToggleItem, type ToolbarToggleItemProps, toolbarVariants };

package/dist/components/ui/toolbar.js

@@ -0,0 +1,6 @@
+export { Toolbar, ToolbarButton, ToolbarLink, ToolbarSeparator, ToolbarToggleGroup, ToolbarToggleItem, toolbarVariants } from '../../chunk-YYEGAFUE.js';
+import '../../chunk-C46ITXE4.js';
+import '../../chunk-NWSCYLPT.js';
+import '../../chunk-NZ5WBA4R.js';
+//# sourceMappingURL=toolbar.js.map
+//# sourceMappingURL=toolbar.js.map

package/dist/components/ui/toolbar.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"toolbar.js"}

package/dist/components/ui/tooltip.d.ts

@@ -1,10 +1,52 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as React from 'react';
 
-interface TooltipProps extends React.HTMLAttributes<HTMLDivElement> {
-    content: string;
+interface TooltipProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "content"> {
+    /**
+     * Tooltip body. Accepts any `ReactNode` — icons, formatted or multi-line
+     * content — not just a plain string.
+     */
+    content: React.ReactNode;
     side?: "top" | "bottom" | "left" | "right";
+    /**
+     * Milliseconds a POINTER must rest on the trigger before the tooltip
+     * opens. Keyboard focus is never delayed — Radix opens instantly on focus
+     * regardless of this value.
+     *
+     * Defaults to `0` rather than Radix's own `700`: the CSS-only
+     * implementation this replaced revealed the bubble the instant the pointer
+     * entered, and inheriting a 700ms delay on upgrade would read as the
+     * tooltip having broken. Raise it to get the "don't fire while the cursor
+     * sweeps across the UI" behaviour the hand-rolled version could not offer.
+     */
+    delayDuration?: number;
 }
-declare function Tooltip({ content, side, className, children, ...props }: TooltipProps): react_jsx_runtime.JSX.Element;
+/**
+ * Tooltip — hover/focus hint anchored to its trigger child.
+ *
+ * Backed by Radix `Tooltip`, which owns the parts a design system should not
+ * be maintaining itself: open/close state, the pointer delay, opening on
+ * keyboard focus and closing on blur/Escape/scroll, the portal, collision
+ * detection against the viewport, and the `aria-describedby` ↔ `role="tooltip"`
+ * association. The previous implementation was CSS-only — a `group` wrapper
+ * plus `group-hover:block` / `group-focus-within:block` — which meant no
+ * portal (so the bubble was clipped by any `overflow:hidden` ancestor), no
+ * collision handling (so it ran off-screen at the edges), no dismissal, and no
+ * delay.
+ *
+ * The wrapper `<div>` stays, and keeps `group relative inline-flex`: it is
+ * where `className` and the rest of `HTMLAttributes<HTMLDivElement>` land, so
+ * removing it would silently drop props callers already pass. Positioning no
+ * longer depends on it.
+ *
+ * The bubble keeps `whitespace-nowrap`, so rich `content` does not soft wrap
+ * by itself — long multi-line content needs an explicit `<br />`, or a
+ * `whitespace-normal` + width class on the node you pass in. Dropping
+ * `whitespace-nowrap` here would re-wrap every existing single-line string
+ * tooltip, so it stays opt-out rather than opt-in.
+ *
+ * @stability Stable
+ */
+declare function Tooltip({ content, side, delayDuration, className, children, ...props }: TooltipProps): react_jsx_runtime.JSX.Element;
 
-export { Tooltip };
+export { Tooltip, type TooltipProps };

package/dist/components/ui/tooltip.js

@@ -1,4 +1,4 @@
-export { Tooltip } from '../../chunk-EI5EGKHL.js';
+export { Tooltip } from '../../chunk-G5YKBPBF.js';
 import '../../chunk-NZ5WBA4R.js';
 //# sourceMappingURL=tooltip.js.map
 //# sourceMappingURL=tooltip.js.map

package/dist/components/ui/visually-hidden.d.ts

@@ -0,0 +1,48 @@
+import * as React from 'react';
+import { VisuallyHidden as VisuallyHidden$1 } from 'radix-ui';
+
+interface VisuallyHiddenProps extends React.ComponentPropsWithoutRef<typeof VisuallyHidden$1.Root> {
+    /** Stable test/automation selector (emitted as `data-testid`). */
+    testID?: string;
+}
+/**
+ * VisuallyHidden — content removed from the visual layout but kept in the
+ * accessibility tree.
+ *
+ * This is the correct tool for the label an icon-only control needs, for the
+ * `DialogTitle` a dialog must have even when the design shows none, and for
+ * live-region status text. It is NOT `display: none` and it is NOT
+ * `visibility: hidden` — both of those remove the node from the a11y tree too,
+ * which is the exact opposite of the intent.
+ *
+ * Why Radix rather than Tailwind's `sr-only`: the two produce the same result,
+ * but `sr-only` is a class a consumer's `@apply`, a purge misconfiguration, or
+ * a competing utility can quietly defeat, and the failure is silent — the text
+ * simply becomes visible, or the layout shifts, and nothing in a build catches
+ * it. Radix applies the clip rectangle as inline styles on the element itself,
+ * so there is no stylesheet for the consumer's build to lose.
+ *
+ * **That robustness cuts both ways, and it is the one thing to know before
+ * reaching for this.** An inline style beats any ordinary class declaration, so
+ * a `className` cannot override the clipping either — not accidentally, and
+ * not on purpose. `className` is merged for non-visual concerns (a test hook, a
+ * data attribute target); it is NOT a way to reveal the content.
+ *
+ * The escape hatch is the `style` prop, which Radix spreads *after* its own
+ * (`{...VISUALLY_HIDDEN_STYLES, ...props.style}`) and which therefore wins.
+ * Both behaviours are pinned in this component's tests, because the docs above
+ * depend on them.
+ *
+ * **This is therefore the wrong primitive for a skip link.** A skip link is
+ * hidden until focused, and "until focused" is state, not a class — a static
+ * `style` prop cannot express it and `focus-within:` utilities cannot win
+ * against the inline rule. Give a skip link its own element with real CSS, or
+ * drive the `style` prop from `onFocus`/`onBlur`. Use `VisuallyHidden` for text
+ * that stays hidden: control labels, dialog titles a design omits, live-region
+ * status text.
+ *
+ * @stability Beta
+ */
+declare const VisuallyHidden: React.ForwardRefExoticComponent<VisuallyHiddenProps & React.RefAttributes<HTMLSpanElement>>;
+
+export { VisuallyHidden, type VisuallyHiddenProps };

package/dist/components/ui/visually-hidden.js

@@ -0,0 +1,4 @@
+export { VisuallyHidden } from '../../chunk-SY62XJFA.js';
+import '../../chunk-NZ5WBA4R.js';
+//# sourceMappingURL=visually-hidden.js.map
+//# sourceMappingURL=visually-hidden.js.map

package/dist/components/ui/visually-hidden.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"visually-hidden.js"}