@imfusion/web-ui 0.6.4-dev.8.g41d03f2f → 0.6.4-dev.84.gbfc0d437

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

@@ -1,277 +1,114 @@
 import { Select as SelectPrimitive } from '@base-ui/react/select';
-type UpstreamRoot = React.ComponentProps<typeof SelectPrimitive.Root>;
-type UpstreamLabel = React.ComponentProps<typeof SelectPrimitive.Label>;
-type UpstreamTrigger = React.ComponentProps<typeof SelectPrimitive.Trigger>;
-type UpstreamValue = React.ComponentProps<typeof SelectPrimitive.Value>;
-type UpstreamIcon = React.ComponentProps<typeof SelectPrimitive.Icon>;
-type UpstreamPortal = React.ComponentProps<typeof SelectPrimitive.Portal>;
-type UpstreamBackdrop = React.ComponentProps<typeof SelectPrimitive.Backdrop>;
-type UpstreamPositioner = React.ComponentProps<typeof SelectPrimitive.Positioner>;
-type UpstreamPopup = React.ComponentProps<typeof SelectPrimitive.Popup>;
-type UpstreamArrow = React.ComponentProps<typeof SelectPrimitive.Arrow>;
-type UpstreamList = React.ComponentProps<typeof SelectPrimitive.List>;
 type UpstreamItem = React.ComponentProps<typeof SelectPrimitive.Item>;
-type UpstreamItemIndicator = React.ComponentProps<typeof SelectPrimitive.ItemIndicator>;
-type UpstreamItemText = React.ComponentProps<typeof SelectPrimitive.ItemText>;
-type UpstreamGroup = React.ComponentProps<typeof SelectPrimitive.Group>;
-type UpstreamGroupLabel = React.ComponentProps<typeof SelectPrimitive.GroupLabel>;
-type UpstreamSeparator = React.ComponentProps<typeof SelectPrimitive.Separator>;
-type UpstreamScrollUpArrow = React.ComponentProps<typeof SelectPrimitive.ScrollUpArrow>;
-type UpstreamScrollDownArrow = React.ComponentProps<typeof SelectPrimitive.ScrollDownArrow>;
-type RootProps = {
-    value?: UpstreamRoot["value"];
-    defaultValue?: UpstreamRoot["defaultValue"];
-    onValueChange?: UpstreamRoot["onValueChange"];
-    /** @default false */
-    defaultOpen?: UpstreamRoot["defaultOpen"];
-    open?: UpstreamRoot["open"];
-    onOpenChange?: UpstreamRoot["onOpenChange"];
-    onOpenChangeComplete?: UpstreamRoot["onOpenChangeComplete"];
-    /** @default false */
-    multiple?: UpstreamRoot["multiple"];
-    /** @default false */
-    disabled?: UpstreamRoot["disabled"];
-    /** @default false */
-    readOnly?: UpstreamRoot["readOnly"];
-    /** @default false */
-    required?: UpstreamRoot["required"];
-    /** @default true */
-    modal?: UpstreamRoot["modal"];
-    /** @default true */
-    highlightItemOnHover?: UpstreamRoot["highlightItemOnHover"];
-    items?: UpstreamRoot["items"];
-    isItemEqualToValue?: UpstreamRoot["isItemEqualToValue"];
-    itemToStringLabel?: UpstreamRoot["itemToStringLabel"];
-    itemToStringValue?: UpstreamRoot["itemToStringValue"];
-    autoComplete?: UpstreamRoot["autoComplete"];
-    form?: UpstreamRoot["form"];
-    inputRef?: UpstreamRoot["inputRef"];
-    actionsRef?: UpstreamRoot["actionsRef"];
-    name?: UpstreamRoot["name"];
-    id?: UpstreamRoot["id"];
-    children?: React.ReactNode;
-};
+interface RootProps<Value = unknown, Multiple extends boolean | undefined = false> extends React.ComponentProps<typeof SelectPrimitive.Root<Value, Multiple>> {
+}
 /**
  * Select.Root — accessible select / listbox primitive.
  *
- * Renders a thin wrapper div so that a sibling Select.Label stacks above the
- * Select.Trigger regardless of the parent's layout. Select.Portal is unaffected
- * (it renders to document.body).
+ * Wraps children in a div so a sibling Select.Label stacks above Select.Trigger
+ * regardless of the parent's layout. Select.Portal is unaffected (it renders to
+ * document.body).
  *
  * @doc https://base-ui.com/react/components/select
  * @llm https://base-ui.com/react/components/select.md
  */
-export declare function Root({ className, style, ...props }: RootProps & {
+export declare function Root<Value = unknown, Multiple extends boolean | undefined = false>({ className, style, ...props }: RootProps<Value, Multiple> & {
     className?: string;
     style?: React.CSSProperties;
 }): import("react/jsx-runtime").JSX.Element;
 export declare namespace Root {
     var displayName: string;
 }
-type LabelProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
-    className?: UpstreamLabel["className"];
-    style?: UpstreamLabel["style"];
-    render?: UpstreamLabel["render"];
-};
 /** Select.Label — visible label for the trigger. */
-export declare function Label({ className, ...props }: LabelProps): import("react/jsx-runtime").JSX.Element;
+export declare function Label(props: React.ComponentProps<typeof SelectPrimitive.Label>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Label {
     var displayName: string;
 }
-type TriggerProps = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "className" | "style"> & {
-    /** @default true */
-    nativeButton?: UpstreamTrigger["nativeButton"];
-    className?: UpstreamTrigger["className"];
-    style?: UpstreamTrigger["style"];
-    render?: UpstreamTrigger["render"];
-};
 /** Select.Trigger — button that opens the popup. */
-export declare function Trigger({ className, ...props }: TriggerProps): import("react/jsx-runtime").JSX.Element;
+export declare function Trigger(props: React.ComponentProps<typeof SelectPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Trigger {
     var displayName: string;
 }
-type ValueProps = Omit<React.HTMLAttributes<HTMLSpanElement>, "children" | "className" | "style"> & {
-    placeholder?: React.ReactNode;
-    children?: UpstreamValue["children"];
-    className?: UpstreamValue["className"];
-    style?: UpstreamValue["style"];
-    render?: UpstreamValue["render"];
-};
 /** Select.Value — renders the currently-selected value (or placeholder). */
-export declare function Value({ className, children, ...props }: ValueProps): import("react/jsx-runtime").JSX.Element;
+export declare function Value({ children, ...props }: React.ComponentProps<typeof SelectPrimitive.Value>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Value {
     var displayName: string;
 }
-type IconProps = Omit<React.HTMLAttributes<HTMLSpanElement>, "className" | "style"> & {
-    className?: UpstreamIcon["className"];
-    style?: UpstreamIcon["style"];
-    render?: UpstreamIcon["render"];
-};
 /** Select.Icon — visual indicator (chevron) next to the value. */
-export declare function Icon({ className, ...props }: IconProps): import("react/jsx-runtime").JSX.Element;
+export declare function Icon(props: React.ComponentProps<typeof SelectPrimitive.Icon>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Icon {
     var displayName: string;
 }
-type PortalProps = {
-    container?: UpstreamPortal["container"];
-    className?: UpstreamPortal["className"];
-    style?: UpstreamPortal["style"];
-    render?: UpstreamPortal["render"];
-    children?: React.ReactNode;
-};
 /** Select.Portal — portals the popup tree to document.body (or a custom container). */
-export declare function Portal(props: PortalProps): import("react/jsx-runtime").JSX.Element;
+export declare function Portal(props: React.ComponentProps<typeof SelectPrimitive.Portal>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Portal {
     var displayName: string;
 }
-type BackdropProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
-    className?: UpstreamBackdrop["className"];
-    style?: UpstreamBackdrop["style"];
-    render?: UpstreamBackdrop["render"];
-};
 /** Select.Backdrop — overlay behind the popup (visible only in modal mode). */
-export declare function Backdrop({ className, ...props }: BackdropProps): import("react/jsx-runtime").JSX.Element;
+export declare function Backdrop(props: React.ComponentProps<typeof SelectPrimitive.Backdrop>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Backdrop {
     var displayName: string;
 }
-type PositionerProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
-    /** @default false */
-    alignItemWithTrigger?: UpstreamPositioner["alignItemWithTrigger"];
-    /** @default false */
-    disableAnchorTracking?: UpstreamPositioner["disableAnchorTracking"];
-    /** @default "start" */
-    align?: UpstreamPositioner["align"];
-    /** @default 0 */
-    alignOffset?: UpstreamPositioner["alignOffset"];
-    /** @default "bottom" */
-    side?: UpstreamPositioner["side"];
-    /** @default 0 */
-    sideOffset?: UpstreamPositioner["sideOffset"];
-    /** @default 'clipping-ancestors' */
-    collisionBoundary?: UpstreamPositioner["collisionBoundary"];
-    /** @default 5 */
-    collisionPadding?: UpstreamPositioner["collisionPadding"];
-    /** @default { fallbackAxisSide: 'none' } */
-    collisionAvoidance?: UpstreamPositioner["collisionAvoidance"];
-    className?: UpstreamPositioner["className"];
-    style?: UpstreamPositioner["style"];
-    render?: UpstreamPositioner["render"];
-};
 /** Select.Positioner — positions the popup relative to the trigger. */
-export declare function Positioner({ className, align, alignItemWithTrigger, ...props }: PositionerProps): import("react/jsx-runtime").JSX.Element;
+export declare function Positioner({ align, alignItemWithTrigger, ...props }: React.ComponentProps<typeof SelectPrimitive.Positioner>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Positioner {
     var displayName: string;
 }
-type PopupProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
-    className?: UpstreamPopup["className"];
-    style?: UpstreamPopup["style"];
-    render?: UpstreamPopup["render"];
-};
 /** Select.Popup — dropdown surface. */
-export declare function Popup({ className, ...props }: PopupProps): import("react/jsx-runtime").JSX.Element;
+export declare function Popup(props: React.ComponentProps<typeof SelectPrimitive.Popup>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Popup {
     var displayName: string;
 }
-type ArrowProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
-    className?: UpstreamArrow["className"];
-    style?: UpstreamArrow["style"];
-    render?: UpstreamArrow["render"];
-};
 /** Select.Arrow — pointer arrow attached to the popup. */
-export declare function Arrow({ className, ...props }: ArrowProps): import("react/jsx-runtime").JSX.Element;
+export declare function Arrow(props: React.ComponentProps<typeof SelectPrimitive.Arrow>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Arrow {
     var displayName: string;
 }
-type ListProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
-    className?: UpstreamList["className"];
-    style?: UpstreamList["style"];
-    render?: UpstreamList["render"];
-};
 /** Select.List — items container. */
-export declare function List({ className, ...props }: ListProps): import("react/jsx-runtime").JSX.Element;
+export declare function List(props: React.ComponentProps<typeof SelectPrimitive.List>): import("react/jsx-runtime").JSX.Element;
 export declare namespace List {
     var displayName: string;
 }
-type ItemProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
+interface ItemProps extends Omit<UpstreamItem, "value"> {
     value: UpstreamItem["value"];
-    /** @default false */
-    disabled?: UpstreamItem["disabled"];
-    className?: UpstreamItem["className"];
-    style?: UpstreamItem["style"];
-    render?: UpstreamItem["render"];
-};
+}
 /** Select.Item — individual selectable option. */
-export declare function Item({ className, ...props }: ItemProps): import("react/jsx-runtime").JSX.Element;
+export declare function Item(props: ItemProps): import("react/jsx-runtime").JSX.Element;
 export declare namespace Item {
     var displayName: string;
 }
-type ItemIndicatorProps = Omit<React.HTMLAttributes<HTMLSpanElement>, "className" | "style"> & {
-    className?: UpstreamItemIndicator["className"];
-    style?: UpstreamItemIndicator["style"];
-    render?: UpstreamItemIndicator["render"];
-};
 /** Select.ItemIndicator — visual marker (e.g. checkmark) inside the selected item. */
-export declare function ItemIndicator({ className, ...props }: ItemIndicatorProps): import("react/jsx-runtime").JSX.Element;
+export declare function ItemIndicator(props: React.ComponentProps<typeof SelectPrimitive.ItemIndicator>): import("react/jsx-runtime").JSX.Element;
 export declare namespace ItemIndicator {
     var displayName: string;
 }
-type ItemTextProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
-    className?: UpstreamItemText["className"];
-    style?: UpstreamItemText["style"];
-    render?: UpstreamItemText["render"];
-};
 /** Select.ItemText — text label for an item. */
-export declare function ItemText({ className, ...props }: ItemTextProps): import("react/jsx-runtime").JSX.Element;
+export declare function ItemText(props: React.ComponentProps<typeof SelectPrimitive.ItemText>): import("react/jsx-runtime").JSX.Element;
 export declare namespace ItemText {
     var displayName: string;
 }
-type GroupProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
-    className?: UpstreamGroup["className"];
-    style?: UpstreamGroup["style"];
-    render?: UpstreamGroup["render"];
-};
 /** Select.Group — wrapper around a grouped set of items. */
-export declare function Group({ className, ...props }: GroupProps): import("react/jsx-runtime").JSX.Element;
+export declare function Group(props: React.ComponentProps<typeof SelectPrimitive.Group>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Group {
     var displayName: string;
 }
-type GroupLabelProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
-    className?: UpstreamGroupLabel["className"];
-    style?: UpstreamGroupLabel["style"];
-    render?: UpstreamGroupLabel["render"];
-};
 /** Select.GroupLabel — heading for a Select.Group. */
-export declare function GroupLabel({ className, ...props }: GroupLabelProps): import("react/jsx-runtime").JSX.Element;
+export declare function GroupLabel(props: React.ComponentProps<typeof SelectPrimitive.GroupLabel>): import("react/jsx-runtime").JSX.Element;
 export declare namespace GroupLabel {
     var displayName: string;
 }
-type SeparatorProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
-    className?: UpstreamSeparator["className"];
-    style?: UpstreamSeparator["style"];
-    render?: UpstreamSeparator["render"];
-};
 /** Select.Separator — thin divider between items. */
-export declare function Separator({ className, ...props }: SeparatorProps): import("react/jsx-runtime").JSX.Element;
+export declare function Separator(props: React.ComponentProps<typeof SelectPrimitive.Separator>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Separator {
     var displayName: string;
 }
-type ScrollUpArrowProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
-    className?: UpstreamScrollUpArrow["className"];
-    style?: UpstreamScrollUpArrow["style"];
-    render?: UpstreamScrollUpArrow["render"];
-};
 /** Select.ScrollUpArrow — indicator that more items exist above. */
-export declare function ScrollUpArrow({ className, ...props }: ScrollUpArrowProps): import("react/jsx-runtime").JSX.Element;
+export declare function ScrollUpArrow(props: React.ComponentProps<typeof SelectPrimitive.ScrollUpArrow>): import("react/jsx-runtime").JSX.Element;
 export declare namespace ScrollUpArrow {
     var displayName: string;
 }
-type ScrollDownArrowProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
-    className?: UpstreamScrollDownArrow["className"];
-    style?: UpstreamScrollDownArrow["style"];
-    render?: UpstreamScrollDownArrow["render"];
-};
 /** Select.ScrollDownArrow — indicator that more items exist below. */
-export declare function ScrollDownArrow({ className, ...props }: ScrollDownArrowProps): import("react/jsx-runtime").JSX.Element;
+export declare function ScrollDownArrow(props: React.ComponentProps<typeof SelectPrimitive.ScrollDownArrow>): import("react/jsx-runtime").JSX.Element;
 export declare namespace ScrollDownArrow {
     var displayName: string;
 }

package/dist/components/separator/separator.d.ts

@@ -1,15 +1,16 @@
+import { Separator as SeparatorPrimitive } from '@base-ui/react/separator';
 import { VariantProps } from 'class-variance-authority';
 declare const separator: (props?: ({
     variant?: "solid" | "dashed" | "dotted" | null | undefined;
+    spacing?: "none" | "small" | "medium" | "large" | "spacious" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
-type Props = React.HTMLAttributes<HTMLDivElement> & VariantProps<typeof separator> & {
-    orientation?: "horizontal" | "vertical";
-};
+interface Props extends React.ComponentProps<typeof SeparatorPrimitive>, VariantProps<typeof separator> {
+}
 /**
  * Separator — visual divider between content sections.
  *
  * @see https://base-ui.com/react/components/separator
  * @llm https://base-ui.com/react/components/separator.md
  */
-export declare function Separator({ orientation, variant, className, ...props }: Props): import("react/jsx-runtime").JSX.Element;
+export declare function Separator({ orientation, variant, spacing, ...props }: Props): import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -1,111 +1,41 @@
 import { Slider as SliderPrimitive } from '@base-ui/react/slider';
-type UpstreamRoot = React.ComponentProps<typeof SliderPrimitive.Root>;
-type UpstreamLabel = React.ComponentProps<typeof SliderPrimitive.Label>;
-type UpstreamValue = React.ComponentProps<typeof SliderPrimitive.Value>;
-type UpstreamControl = React.ComponentProps<typeof SliderPrimitive.Control>;
-type UpstreamTrack = React.ComponentProps<typeof SliderPrimitive.Track>;
-type UpstreamIndicator = React.ComponentProps<typeof SliderPrimitive.Indicator>;
-type UpstreamThumb = React.ComponentProps<typeof SliderPrimitive.Thumb>;
-type RootProps = Omit<React.HTMLAttributes<HTMLDivElement>, "defaultValue" | "className" | "style"> & {
-    value?: number | number[];
-    defaultValue?: number | number[];
-    onValueChange?: UpstreamRoot["onValueChange"];
-    onValueCommitted?: UpstreamRoot["onValueCommitted"];
-    min?: number;
-    max?: number;
-    step?: number;
-    largeStep?: number;
-    minStepsBetweenValues?: number;
-    disabled?: boolean;
-    orientation?: "horizontal" | "vertical";
-    name?: string;
-    form?: string;
-    locale?: UpstreamRoot["locale"];
-    thumbAlignment?: UpstreamRoot["thumbAlignment"];
-    thumbCollisionBehavior?: UpstreamRoot["thumbCollisionBehavior"];
-    format?: Intl.NumberFormatOptions;
-    className?: UpstreamRoot["className"];
-    style?: UpstreamRoot["style"];
-    render?: UpstreamRoot["render"];
-};
 /**
  * Slider.Root — value selector along a continuous or stepped track.
  *
  * @doc https://base-ui.com/react/components/slider
  * @llm https://base-ui.com/react/components/slider.md
  */
-export declare function Root({ value, defaultValue, onValueChange, onValueCommitted, min, max, step, largeStep, minStepsBetweenValues, disabled, orientation, name, form, locale, thumbAlignment, thumbCollisionBehavior, format, className, ...props }: RootProps): import("react/jsx-runtime").JSX.Element;
+export declare function Root({ value, defaultValue, onValueChange, onValueCommitted, min, max, step, largeStep, minStepsBetweenValues, disabled, orientation, name, form, locale, thumbAlignment, thumbCollisionBehavior, format, ...props }: React.ComponentProps<typeof SliderPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Root {
     var displayName: string;
 }
-type LabelProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
-    className?: UpstreamLabel["className"];
-    style?: UpstreamLabel["style"];
-    render?: UpstreamLabel["render"];
-};
 /** Slider.Label — accessible label for the slider. */
-export declare function Label({ className, ...props }: LabelProps): import("react/jsx-runtime").JSX.Element;
+export declare function Label(props: React.ComponentProps<typeof SliderPrimitive.Label>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Label {
     var displayName: string;
 }
-type ValueProps = Omit<React.HTMLAttributes<HTMLOutputElement>, "children" | "className" | "style"> & {
-    children?: UpstreamValue["children"];
-    className?: UpstreamValue["className"];
-    style?: UpstreamValue["style"];
-    render?: UpstreamValue["render"];
-};
 /** Slider.Value — live numeric readout. */
-export declare function Value({ className, children, ...props }: ValueProps): import("react/jsx-runtime").JSX.Element;
+export declare function Value({ children, ...props }: React.ComponentProps<typeof SliderPrimitive.Value>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Value {
     var displayName: string;
 }
-type ControlProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
-    className?: UpstreamControl["className"];
-    style?: UpstreamControl["style"];
-    render?: UpstreamControl["render"];
-};
 /** Slider.Control — interactive container for track + thumb. */
-export declare function Control({ className, ...props }: ControlProps): import("react/jsx-runtime").JSX.Element;
+export declare function Control(props: React.ComponentProps<typeof SliderPrimitive.Control>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Control {
     var displayName: string;
 }
-type TrackProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
-    className?: UpstreamTrack["className"];
-    style?: UpstreamTrack["style"];
-    render?: UpstreamTrack["render"];
-};
 /** Slider.Track — the static rail. */
-export declare function Track({ className, ...props }: TrackProps): import("react/jsx-runtime").JSX.Element;
+export declare function Track(props: React.ComponentProps<typeof SliderPrimitive.Track>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Track {
     var displayName: string;
 }
-type IndicatorProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
-    className?: UpstreamIndicator["className"];
-    style?: UpstreamIndicator["style"];
-    render?: UpstreamIndicator["render"];
-};
 /** Slider.Indicator — filled portion of the track. */
-export declare function Indicator({ className, ...props }: IndicatorProps): import("react/jsx-runtime").JSX.Element;
+export declare function Indicator(props: React.ComponentProps<typeof SliderPrimitive.Indicator>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Indicator {
     var displayName: string;
 }
-type ThumbProps = Omit<React.HTMLAttributes<HTMLDivElement>, "onBlur" | "onFocus" | "className" | "style"> & {
-    index?: number;
-    tabIndex?: number;
-    /** @default false */
-    disabled?: boolean;
-    inputRef?: React.Ref<HTMLInputElement>;
-    getAriaLabel?: UpstreamThumb["getAriaLabel"];
-    getAriaValueText?: UpstreamThumb["getAriaValueText"];
-    onBlur?: UpstreamThumb["onBlur"];
-    onFocus?: UpstreamThumb["onFocus"];
-    className?: UpstreamThumb["className"];
-    style?: UpstreamThumb["style"];
-    render?: UpstreamThumb["render"];
-};
 /** Slider.Thumb — draggable handle. */
-export declare function Thumb({ index, className, ...props }: ThumbProps): import("react/jsx-runtime").JSX.Element;
+export declare function Thumb({ index, ...props }: React.ComponentProps<typeof SliderPrimitive.Thumb>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Thumb {
     var displayName: string;
 }
-export {};

package/dist/components/spinner/spinner.d.ts

@@ -1,19 +1,24 @@
 import { VariantProps } from 'class-variance-authority';
+declare const sources: {
+    blue: string;
+    white: string;
+    black: string;
+};
 declare const spinner: (props?: ({
     size?: "sm" | "md" | "lg" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
 type Props = Omit<React.HTMLAttributes<HTMLSpanElement>, "role"> & VariantProps<typeof spinner> & {
     /** Accessible label announced by assistive tech. */
     label?: string;
+    /**
+     * Which colour of the mark to show. The animation is a pre-rendered image, so
+     * the colour is baked in and does not follow `currentColor` or the scheme —
+     * pick `white` on saturated or dark grounds.
+     */
+    variant?: keyof typeof sources;
 };
 /**
- * Loading indicator built from the animated ImFusion glyph — two filled bands
- * and an empty diagonal channel that continuously rotates, breathes, and sways.
- *
- * The motion is a live per-frame morph of the two paths (the channel geometry is
- * recomputed each frame in {@link frameGeometry}), driven by a single
- * `requestAnimationFrame` loop that rewrites the two `d` attributes directly —
- * no React re-render per frame. The loop pauses while the tab is hidden.
+ * Loading indicator — the ImFusion glyph animation, played as a looping image.
  */
-export declare function Spinner({ size, label, className, ...props }: Props): import("react/jsx-runtime").JSX.Element;
+export declare function Spinner({ size, variant, label, ...props }: Props): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/stack/stack.d.ts

@@ -8,11 +8,10 @@ type Props = React.HTMLAttributes<HTMLDivElement> & VariantProps<typeof stack>;
 /**
  * Stack — vertical layout primitive.
  *
- * Copied and adapted from Mantine's Stack; no upstream runtime
- * dependency. Pure column flex container with token-driven gap and constrained
- * align/justify unions.
+ * Adapted from Mantine's Stack, no upstream runtime dependency: a pure column
+ * flex container with token-driven gap and constrained align/justify unions.
  *
  * @see https://mantine.dev/core/stack/
  */
-export declare function Stack({ gap, align, justify, className, ...props }: Props): import("react/jsx-runtime").JSX.Element;
+export declare function Stack({ gap, align, justify, ...props }: Props): import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -1,45 +1,16 @@
 import { Switch as SwitchPrimitive } from '@base-ui/react/switch';
-type UpstreamRoot = React.ComponentProps<typeof SwitchPrimitive.Root>;
-type UpstreamThumb = React.ComponentProps<typeof SwitchPrimitive.Thumb>;
-type RootProps = Omit<React.HTMLAttributes<HTMLSpanElement>, "className" | "style"> & {
-    checked?: boolean;
-    defaultChecked?: boolean;
-    onCheckedChange?: UpstreamRoot["onCheckedChange"];
-    /** @default false */
-    disabled?: boolean;
-    /** @default false */
-    readOnly?: boolean;
-    /** @default false */
-    required?: boolean;
-    name?: string;
-    value?: string;
-    uncheckedValue?: string;
-    form?: string;
-    inputRef?: React.Ref<HTMLInputElement>;
-    /** @default false */
-    nativeButton?: boolean;
-    className?: UpstreamRoot["className"];
-    style?: UpstreamRoot["style"];
-    render?: UpstreamRoot["render"];
-};
 /**
  * Switch.Root — toggleable on/off control.
  *
  * @doc https://base-ui.com/react/components/switch
  * @llm https://base-ui.com/react/components/switch.md
  */
-export declare function Root({ className, ...props }: RootProps): import("react/jsx-runtime").JSX.Element;
+export declare function Root(props: React.ComponentProps<typeof SwitchPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Root {
     var displayName: string;
 }
-type ThumbProps = Omit<React.HTMLAttributes<HTMLSpanElement>, "className" | "style"> & {
-    className?: UpstreamThumb["className"];
-    style?: UpstreamThumb["style"];
-    render?: UpstreamThumb["render"];
-};
 /** Switch.Thumb — the movable indicator inside the track. */
-export declare function Thumb({ className, ...props }: ThumbProps): import("react/jsx-runtime").JSX.Element;
+export declare function Thumb(props: React.ComponentProps<typeof SwitchPrimitive.Thumb>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Thumb {
     var displayName: string;
 }
-export {};

package/dist/components/table/table.d.ts

@@ -1,37 +1,31 @@
-type RootProps = React.TableHTMLAttributes<HTMLTableElement>;
-type HeaderProps = React.HTMLAttributes<HTMLTableSectionElement>;
-type BodyProps = React.HTMLAttributes<HTMLTableSectionElement>;
-type RowProps = React.HTMLAttributes<HTMLTableRowElement>;
 type HeaderCellProps = React.ThHTMLAttributes<HTMLTableCellElement>;
-type CellProps = React.TdHTMLAttributes<HTMLTableCellElement>;
-type HeaderButtonProps = React.ButtonHTMLAttributes<HTMLButtonElement>;
 /** Table.Root — the `<table>` element. */
-export declare function Root({ className, ...props }: RootProps): import("react/jsx-runtime").JSX.Element;
+export declare function Root(props: React.TableHTMLAttributes<HTMLTableElement>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Root {
     var displayName: string;
 }
 /** Table.Header — the `<thead>` section. */
-export declare function Header({ className, ...props }: HeaderProps): import("react/jsx-runtime").JSX.Element;
+export declare function Header(props: React.HTMLAttributes<HTMLTableSectionElement>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Header {
     var displayName: string;
 }
 /** Table.Body — the `<tbody>` section. */
-export declare function Body({ className, ...props }: BodyProps): import("react/jsx-runtime").JSX.Element;
+export declare function Body(props: React.HTMLAttributes<HTMLTableSectionElement>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Body {
     var displayName: string;
 }
 /** Table.Row — a `<tr>` in header or body. */
-export declare function Row({ className, ...props }: RowProps): import("react/jsx-runtime").JSX.Element;
+export declare function Row(props: React.HTMLAttributes<HTMLTableRowElement>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Row {
     var displayName: string;
 }
 /** Table.HeaderCell — a `<th>` header cell. */
-export declare function HeaderCell({ className, ...props }: HeaderCellProps): import("react/jsx-runtime").JSX.Element;
+export declare function HeaderCell(props: HeaderCellProps): import("react/jsx-runtime").JSX.Element;
 export declare namespace HeaderCell {
     var displayName: string;
 }
 /** Table.Cell — a `<td>` data cell. */
-export declare function Cell({ className, ...props }: CellProps): import("react/jsx-runtime").JSX.Element;
+export declare function Cell(props: React.TdHTMLAttributes<HTMLTableCellElement>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Cell {
     var displayName: string;
 }
@@ -40,7 +34,7 @@ export declare namespace Cell {
  * design: sorting toggles, filter toggles, column menus all render through it
  * rather than each inventing a button. Icon/indicator goes in `children`.
  */
-export declare function HeaderButton({ className, type, ...props }: HeaderButtonProps): import("react/jsx-runtime").JSX.Element;
+export declare function HeaderButton({ type, ...props }: React.ButtonHTMLAttributes<HTMLButtonElement>): import("react/jsx-runtime").JSX.Element;
 export declare namespace HeaderButton {
     var displayName: string;
 }
@@ -53,11 +47,9 @@ type SortableHeaderCellProps = Omit<HeaderCellProps, "aria-sort"> & {
     onToggle?: React.MouseEventHandler<HTMLButtonElement>;
 };
 /**
- * Table.SortableHeaderCell — a partial: a header cell whose label is a sort
- * toggle, pre-composing HeaderCell + HeaderButton so the `aria-sort` state and
- * direction indicator don't get re-derived per consumer app. Headless-upstream-
- * agnostic: feed it `sortDirection` and `onToggle` (e.g. from a TanStack
- * column). Omit `onToggle` and it renders a plain non-sortable header cell.
+ * Table.SortableHeaderCell — a header cell whose label is a sort toggle,
+ * pre-composing HeaderCell + HeaderButton so `aria-sort` and the direction
+ * indicator aren't re-derived per consumer. Omit `onToggle` for a plain cell.
  */
 export declare function SortableHeaderCell({ sortDirection, onToggle, children, ...props }: SortableHeaderCellProps): import("react/jsx-runtime").JSX.Element;
 export declare namespace SortableHeaderCell {