@snowcone-app/canvas 0.13.1 → 0.14.0

package/dist/vendor/ui/index.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Vendored @snowcone-app/ui primitives (phase 1 of the CSS-prefix refactor).
+ *
+ * These files are verbatim copies of packages/ui/src/primitives/* (plus
+ * lib/utils.ts) so that @snowcone-app/canvas is self-contained — no runtime
+ * dependency on @snowcone-app/ui. Do not edit logic or class names here in
+ * this phase; phase 2 applies the CSS prefix codemod to this directory.
+ *
+ * Mirrors the `export *` style of packages/ui/src/index.ts for the same files.
+ */
+export * from './primitives/Button';
+export * from './primitives/accordion';
+export * from './primitives/badge';
+export * from './primitives/card';
+export * from './primitives/checkbox';
+export * from './primitives/collapsible';
+export * from './primitives/drawer';
+export * from './primitives/dropdown-menu';
+export * from './primitives/fieldset';
+export * from './primitives/input';
+export * from './primitives/kbd';
+export * from './primitives/label';
+export * from './primitives/link';
+export * from './primitives/popover';
+export * from './primitives/radio-group';
+export * from './primitives/select';
+export * from './primitives/separator';
+export * from './primitives/slider';
+export * from './primitives/spinner';
+export * from './primitives/surface';
+export * from './primitives/switch';
+export * from './primitives/tabs';
+export * from './primitives/text-field';
+export * from './primitives/textarea';
+export * from './primitives/tooltip';

package/dist/vendor/ui/lib/utils.d.ts

@@ -0,0 +1,2 @@
+import { ClassValue } from 'clsx';
+export declare function cn(...inputs: ClassValue[]): string;

package/dist/vendor/ui/primitives/Button.d.ts

@@ -0,0 +1,14 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const buttonVariants: (props?: ({
+    variant?: "default" | "link" | "outline" | "secondary" | "primary" | "tertiary" | "field" | "ghost" | "destructive" | "option-text" | "option-swatch" | "action" | "action-icon" | null | undefined;
+    size?: "default" | "none" | "icon" | "toolbar" | "sm" | "md" | "lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    asChild?: boolean;
+    onPress?: (e?: React.MouseEvent<HTMLButtonElement>) => void;
+    isPending?: boolean;
+    selected?: boolean;
+}
+declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
+export { Button, buttonVariants };

package/dist/vendor/ui/primitives/accordion.d.ts

@@ -0,0 +1,37 @@
+import * as React from 'react';
+interface AccordionSingleProps {
+    type: 'single';
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    collapsible?: boolean;
+    children: React.ReactNode;
+    className?: string;
+}
+interface AccordionMultipleProps {
+    type?: 'multiple';
+    value?: string[];
+    defaultValue?: string[];
+    onValueChange?: (value: string[]) => void;
+    children: React.ReactNode;
+    className?: string;
+}
+type AccordionProps = AccordionSingleProps | AccordionMultipleProps;
+declare const Accordion: React.ForwardRefExoticComponent<AccordionProps & React.RefAttributes<HTMLDivElement>>;
+interface AccordionItemProps {
+    value: string;
+    children: React.ReactNode;
+    className?: string;
+    disabled?: boolean;
+}
+declare const AccordionItem: React.ForwardRefExoticComponent<AccordionItemProps & React.RefAttributes<HTMLDivElement>>;
+interface AccordionTriggerProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    children: React.ReactNode;
+}
+declare const AccordionTrigger: React.ForwardRefExoticComponent<AccordionTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+interface AccordionContentProps {
+    children: React.ReactNode;
+    className?: string;
+}
+declare const AccordionContent: React.ForwardRefExoticComponent<AccordionContentProps & React.RefAttributes<HTMLDivElement>>;
+export { Accordion, AccordionItem, AccordionTrigger, AccordionContent };

package/dist/vendor/ui/primitives/badge.d.ts

@@ -0,0 +1,20 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const badgeVariants: (props?: ({
+    variant?: "default" | "warning" | "gradient" | "outline" | "secondary" | "destructive" | "success" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface BadgeProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {
+    color?: 'default' | 'primary' | 'secondary' | 'success' | 'warning' | 'danger';
+    /** Whether to show a dot indicator */
+    dot?: boolean;
+    /** Content to show on the left */
+    startContent?: React.ReactNode;
+    /** Content to show on the right */
+    endContent?: React.ReactNode;
+    /** Close button click handler (makes badge dismissible) */
+    onClose?: () => void;
+}
+declare function Badge({ className, variant, size, color, dot, startContent, endContent, onClose, children, ...props }: BadgeProps): import("react/jsx-runtime").JSX.Element;
+declare const Chip: typeof Badge;
+export { Badge, Chip, badgeVariants };

package/dist/vendor/ui/primitives/card.d.ts

@@ -0,0 +1,12 @@
+import * as React from 'react';
+interface CardProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Visual variant - 'outlined' adds border and shadow */
+    variant?: 'default' | 'outlined';
+}
+declare const Card: React.ForwardRefExoticComponent<CardProps & React.RefAttributes<HTMLDivElement>>;
+declare const CardHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardTitle: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLHeadingElement> & React.RefAttributes<HTMLParagraphElement>>;
+declare const CardDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
+declare const CardContent: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+export { Card, CardHeader, CardFooter, CardTitle, CardDescription, CardContent };

package/dist/vendor/ui/primitives/checkbox.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
+interface CheckboxProps extends React.ComponentPropsWithoutRef<typeof CheckboxPrimitive.Root> {
+    /** Visual variant - auto-detected from Surface context, or can be set explicitly */
+    variant?: 'default' | 'filled';
+}
+declare const Checkbox: React.ForwardRefExoticComponent<CheckboxProps & React.RefAttributes<HTMLButtonElement>>;
+export { Checkbox };

package/dist/vendor/ui/primitives/collapsible.d.ts

@@ -0,0 +1,10 @@
+import * as React from 'react';
+import * as CollapsiblePrimitive from '@radix-ui/react-collapsible';
+declare const CollapsibleRoot: React.ForwardRefExoticComponent<Omit<CollapsiblePrimitive.CollapsibleProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CollapsibleTrigger: React.ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const CollapsibleContent: React.ForwardRefExoticComponent<Omit<CollapsiblePrimitive.CollapsibleContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const Collapsible: React.ForwardRefExoticComponent<Omit<CollapsiblePrimitive.CollapsibleProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const Disclosure: React.ForwardRefExoticComponent<Omit<CollapsiblePrimitive.CollapsibleProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DisclosureTrigger: React.ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DisclosureContent: React.ForwardRefExoticComponent<Omit<CollapsiblePrimitive.CollapsibleContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Collapsible, CollapsibleTrigger, CollapsibleContent, CollapsibleRoot, Disclosure, DisclosureTrigger, DisclosureContent, };

package/dist/vendor/ui/primitives/drawer.d.ts

@@ -0,0 +1,66 @@
+import * as React from "react";
+interface DrawerProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children: React.ReactNode;
+}
+declare function Drawer({ open: controlledOpen, defaultOpen, onOpenChange, children, }: DrawerProps): import("react/jsx-runtime").JSX.Element;
+declare namespace Drawer {
+    var displayName: string;
+}
+interface DrawerTriggerProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    asChild?: boolean;
+}
+declare const DrawerTrigger: React.ForwardRefExoticComponent<DrawerTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+interface DrawerCloseProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    asChild?: boolean;
+}
+declare const DrawerClose: React.ForwardRefExoticComponent<DrawerCloseProps & React.RefAttributes<HTMLButtonElement>>;
+interface DrawerContentProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Drawer placement. Default: 'bottom' */
+    placement?: "bottom" | "left" | "right";
+    /** Explicit height for bottom drawer. Use this when you want the drawer to always be a specific size. */
+    height?: string;
+    /** Max height for bottom drawer. Default: '80dvh'. Only used if height is not set. */
+    maxHeight?: string;
+    /** Width for side drawers (left/right). Can be CSS value like '400px' or '80vw'. */
+    width?: string;
+    /** Max width for side drawers. Default: '400px' */
+    maxWidth?: string;
+    /** Whether to show the overlay/backdrop. Default: true */
+    showOverlay?: boolean;
+    /** Whether to hide the drag handle. Default: false */
+    hideHandle?: boolean;
+    /** Overlay opacity (0-1). Default: 0.3 */
+    overlayOpacity?: number;
+    /** Whether to lock body scroll when drawer is open. Default: true */
+    lockBodyScroll?: boolean;
+    /** Whether to use dialog ARIA attributes (role="dialog", aria-modal). Default: true */
+    useDialogRole?: boolean;
+    /** Disable swipe gestures for closing the drawer. Default: false. */
+    disableSwipeGestures?: boolean;
+    /** Animation duration in ms. Default: 300 (DEBUG: 2000) */
+    animationDuration?: number;
+    /** Show a gradient fade at the bottom that hides when scrolled to bottom. Default: true */
+    showScrollFade?: boolean;
+    /** Color for the scroll fade gradient. Should match drawer background. Default: uses CSS variable */
+    scrollFadeColor?: string;
+    /** Height ratio for bottom drawer (0-1). Deprecated - use height prop instead. Will set height to heightRatio * 100vh. */
+    heightRatio?: number;
+    /** Whether to add safe area padding at the bottom. Default: false. Deprecated - safe area is handled automatically via CSS. */
+    safeAreaPadding?: boolean;
+}
+declare const DrawerContent: React.ForwardRefExoticComponent<DrawerContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const DrawerHeader: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const DrawerFooter: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const DrawerTitle: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLHeadingElement> & React.RefAttributes<HTMLHeadingElement>>;
+declare const DrawerDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
+export { Drawer, DrawerTrigger, DrawerClose, DrawerContent, DrawerHeader, DrawerFooter, DrawerTitle, DrawerDescription, };
+export { Drawer as IOSDrawer, DrawerTrigger as IOSDrawerTrigger, DrawerClose as IOSDrawerClose, DrawerContent as IOSDrawerContent, DrawerHeader as IOSDrawerHeader, DrawerFooter as IOSDrawerFooter, DrawerTitle as IOSDrawerTitle, DrawerDescription as IOSDrawerDescription, };

package/dist/vendor/ui/primitives/dropdown-menu.d.ts

@@ -0,0 +1,27 @@
+import * as React from 'react';
+import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
+declare const DropdownMenu: React.FC<DropdownMenuPrimitive.DropdownMenuProps>;
+declare const DropdownMenuTrigger: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DropdownMenuGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuPortal: React.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;
+declare const DropdownMenuSub: React.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
+declare const DropdownMenuRadioGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubTrigger: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuCheckboxItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuRadioItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuLabel: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSeparator: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuShortcut: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export { DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuItem, DropdownMenuCheckboxItem, DropdownMenuRadioItem, DropdownMenuLabel, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuGroup, DropdownMenuPortal, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuRadioGroup, };

package/dist/vendor/ui/primitives/fieldset.d.ts

@@ -0,0 +1,35 @@
+import * as React from 'react';
+export interface FieldsetProps extends React.FieldsetHTMLAttributes<HTMLFieldSetElement> {
+}
+/**
+ * Fieldset - A semantic grouping element for form controls.
+ *
+ * Use this to group related form elements together with an optional legend.
+ *
+ * @example
+ * ```tsx
+ * <Fieldset>
+ *   <legend className="text-sm font-medium">Personal Info</legend>
+ *   <TextField>
+ *     <Label>Name</Label>
+ *     <Input placeholder="Enter name..." />
+ *   </TextField>
+ * </Fieldset>
+ * ```
+ */
+declare const Fieldset: React.ForwardRefExoticComponent<FieldsetProps & React.RefAttributes<HTMLFieldSetElement>>;
+export interface LegendProps extends React.HTMLAttributes<HTMLLegendElement> {
+}
+/**
+ * Legend - A caption for a fieldset.
+ *
+ * @example
+ * ```tsx
+ * <Fieldset>
+ *   <Legend>Account Settings</Legend>
+ *   ...
+ * </Fieldset>
+ * ```
+ */
+declare const Legend: React.ForwardRefExoticComponent<LegendProps & React.RefAttributes<HTMLLegendElement>>;
+export { Fieldset, Legend };

package/dist/vendor/ui/primitives/input.d.ts

@@ -0,0 +1,18 @@
+import * as React from 'react';
+export interface InputProps extends React.InputHTMLAttributes<HTMLInputElement> {
+    /** Whether the input is in an invalid state */
+    isInvalid?: boolean;
+    /** Content to display at the start of the input */
+    startContent?: React.ReactNode;
+    /** Content to display at the end of the input */
+    endContent?: React.ReactNode;
+    /**
+     * Visual variant - auto-detected from Surface context, or can be set explicitly
+     * - `default`: Standard field styling for forms (bg-field)
+     * - `filled`: Field on elevated surface (bg-field-on-surface)
+     * - `subtle`: Blends with buttons/tabs in toolbars (bg-default)
+     */
+    variant?: 'default' | 'filled' | 'subtle';
+}
+declare const Input: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<HTMLInputElement>>;
+export { Input };

package/dist/vendor/ui/primitives/kbd.d.ts

@@ -0,0 +1,37 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const kbdVariants: (props?: ({
+    variant?: "default" | "outline" | "minimal" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface KbdProps extends React.HTMLAttributes<HTMLElement>, VariantProps<typeof kbdVariants> {
+    /**
+     * The keyboard key(s) to display.
+     * Can use special values that will be transformed:
+     * - "cmd" or "command" -> displays platform-specific modifier (⌘ on Mac, Ctrl on Windows)
+     * - "ctrl" -> ⌃
+     * - "alt" or "option" -> ⌥
+     * - "shift" -> ⇧
+     * - "enter" or "return" -> ↵
+     * - "backspace" or "delete" -> ⌫
+     * - "escape" or "esc" -> Esc
+     * - "tab" -> ⇥
+     * - "space" -> Space
+     * - "up", "down", "left", "right" -> arrows
+     */
+    keys?: string | string[];
+}
+/**
+ * Kbd - Keyboard key display component.
+ *
+ * Displays keyboard shortcuts in a visually consistent way.
+ *
+ * @example
+ * ```tsx
+ * <Kbd>K</Kbd>
+ * <Kbd keys={['cmd', 'shift', 'P']} />
+ * <Kbd keys="cmd+K" />
+ * ```
+ */
+declare const Kbd: React.ForwardRefExoticComponent<KbdProps & React.RefAttributes<HTMLElement>>;
+export { Kbd, kbdVariants };

package/dist/vendor/ui/primitives/label.d.ts

@@ -0,0 +1,5 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+import * as LabelPrimitive from '@radix-ui/react-label';
+declare const Label: React.ForwardRefExoticComponent<Omit<LabelPrimitive.LabelProps & React.RefAttributes<HTMLLabelElement>, "ref"> & VariantProps<(props?: import('class-variance-authority/types').ClassProp | undefined) => string> & React.RefAttributes<HTMLLabelElement>>;
+export { Label };

package/dist/vendor/ui/primitives/link.d.ts

@@ -0,0 +1,52 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const linkVariants: (props?: ({
+    color?: "default" | "warning" | "secondary" | "primary" | "success" | "danger" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+    underline?: "none" | "always" | "hover" | null | undefined;
+    underlineOffset?: 2 | 1 | 3 | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface LinkProps extends Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, 'color'>, VariantProps<typeof linkVariants> {
+    /**
+     * If true, the link will be rendered as its child element (using Radix Slot).
+     * Useful for integrating with routing libraries like Next.js Link.
+     */
+    asChild?: boolean;
+    /**
+     * If true, adds an external link icon.
+     */
+    isExternal?: boolean;
+    /**
+     * If true, shows a block-style link (full width with padding).
+     */
+    isBlock?: boolean;
+}
+/**
+ * Link - A styled anchor component for navigation.
+ *
+ * Supports animated underlines, external link indicators, and integration
+ * with routing libraries via the asChild prop.
+ *
+ * @example
+ * ```tsx
+ * <Link href="/about">About</Link>
+ * <Link href="https://example.com" isExternal>External Link</Link>
+ * <Link asChild underline="hover">
+ *   <NextLink href="/dashboard">Dashboard</NextLink>
+ * </Link>
+ * ```
+ */
+declare const Link: React.ForwardRefExoticComponent<LinkProps & React.RefAttributes<HTMLAnchorElement>>;
+/**
+ * LinkIcon - External link indicator icon.
+ *
+ * Used automatically when isExternal is true, or can be used manually.
+ */
+interface LinkIconProps extends React.SVGAttributes<SVGElement> {
+    /**
+     * If true, renders as child element using Slot.
+     */
+    asChild?: boolean;
+}
+declare const LinkIcon: React.ForwardRefExoticComponent<LinkIconProps & React.RefAttributes<SVGSVGElement>>;
+export { Link, LinkIcon, linkVariants };

package/dist/vendor/ui/primitives/popover.d.ts

@@ -0,0 +1,26 @@
+import * as React from 'react';
+import * as PopoverPrimitive from '@radix-ui/react-popover';
+declare const PopoverRoot: React.FC<PopoverPrimitive.PopoverProps>;
+declare const PopoverTrigger: React.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const PopoverAnchor: React.ForwardRefExoticComponent<PopoverPrimitive.PopoverAnchorProps & React.RefAttributes<HTMLDivElement>>;
+interface PopoverContentProps extends React.ComponentPropsWithoutRef<typeof PopoverPrimitive.Content> {
+    /** Preserve text selection when popover opens (useful for canvas/editor contexts) */
+    preserveSelection?: boolean;
+    /** Use maximum z-index to appear above fullscreen modals (for canvas/editor contexts) */
+    maxZIndex?: boolean;
+}
+declare const PopoverContent: React.ForwardRefExoticComponent<PopoverContentProps & React.RefAttributes<HTMLDivElement>>;
+interface PopoverProps {
+    children: React.ReactNode;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    defaultOpen?: boolean;
+    modal?: boolean;
+}
+declare const Popover: (({ children, open, onOpenChange, ...props }: PopoverProps) => import("react/jsx-runtime").JSX.Element) & {
+    Trigger: React.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+    Content: React.ForwardRefExoticComponent<PopoverContentProps & React.RefAttributes<HTMLDivElement>>;
+    Anchor: React.ForwardRefExoticComponent<PopoverPrimitive.PopoverAnchorProps & React.RefAttributes<HTMLDivElement>>;
+    Dialog: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+};
+export { Popover, PopoverTrigger, PopoverContent, PopoverAnchor, PopoverRoot };

package/dist/vendor/ui/primitives/radio-group.d.ts

@@ -0,0 +1,15 @@
+import * as React from 'react';
+import * as RadioGroupPrimitive from '@radix-ui/react-radio-group';
+declare const RadioGroup: React.ForwardRefExoticComponent<Omit<RadioGroupPrimitive.RadioGroupProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+interface RadioGroupItemProps extends React.ComponentPropsWithoutRef<typeof RadioGroupPrimitive.Item> {
+    /** Visual variant - auto-detected from Surface context, or can be set explicitly */
+    variant?: 'default' | 'filled';
+}
+declare const RadioGroupItem: React.ForwardRefExoticComponent<RadioGroupItemProps & React.RefAttributes<HTMLButtonElement>>;
+interface RadioProps extends React.ComponentPropsWithoutRef<typeof RadioGroupPrimitive.Item> {
+    children?: React.ReactNode;
+    /** Visual variant - auto-detected from Surface context, or can be set explicitly */
+    variant?: 'default' | 'filled';
+}
+declare const Radio: React.ForwardRefExoticComponent<RadioProps & React.RefAttributes<HTMLButtonElement>>;
+export { RadioGroup, RadioGroupItem, Radio };

package/dist/vendor/ui/primitives/select.d.ts

@@ -0,0 +1,17 @@
+import * as React from 'react';
+import * as SelectPrimitive from '@radix-ui/react-select';
+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>>;
+interface SelectTriggerProps extends React.ComponentPropsWithoutRef<typeof SelectPrimitive.Trigger> {
+    /** Visual variant - auto-detected from Surface context, or can be set explicitly */
+    variant?: 'default' | 'filled';
+}
+declare const SelectTrigger: React.ForwardRefExoticComponent<SelectTriggerProps & 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 SelectLabel: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectItem: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectSeparator: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Select, SelectGroup, SelectValue, SelectTrigger, SelectContent, SelectLabel, SelectItem, SelectSeparator, SelectScrollUpButton, SelectScrollDownButton, };

package/dist/vendor/ui/primitives/separator.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+import * as SeparatorPrimitive from '@radix-ui/react-separator';
+declare const Separator: React.ForwardRefExoticComponent<Omit<SeparatorPrimitive.SeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Separator };

package/dist/vendor/ui/primitives/slider.d.ts

@@ -0,0 +1,26 @@
+import * as React from 'react';
+import * as SliderPrimitive from '@radix-ui/react-slider';
+interface SliderProps extends Omit<React.ComponentPropsWithoutRef<typeof SliderPrimitive.Root>, 'value' | 'onValueChange'> {
+    value?: number | number[];
+    onValueChange?: (value: number[]) => void;
+    onChangeEnd?: (value: number[]) => void;
+    children?: React.ReactNode;
+}
+declare const SliderTrack: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLSpanElement> & React.RefAttributes<HTMLSpanElement>>;
+declare const SliderThumb: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLSpanElement> & React.RefAttributes<HTMLSpanElement>>;
+declare const SliderFill: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLSpanElement> & React.RefAttributes<HTMLSpanElement>>;
+interface SliderOutputProps extends Omit<React.HTMLAttributes<HTMLSpanElement>, 'children'> {
+    children?: React.ReactNode | ((props: {
+        state: {
+            values: number[];
+        };
+    }) => React.ReactNode);
+}
+declare const SliderOutput: React.ForwardRefExoticComponent<SliderOutputProps & React.RefAttributes<HTMLSpanElement>>;
+declare const Slider: React.ForwardRefExoticComponent<SliderProps & React.RefAttributes<HTMLSpanElement>> & {
+    Track: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLSpanElement> & React.RefAttributes<HTMLSpanElement>>;
+    Thumb: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLSpanElement> & React.RefAttributes<HTMLSpanElement>>;
+    Fill: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLSpanElement> & React.RefAttributes<HTMLSpanElement>>;
+    Output: React.ForwardRefExoticComponent<SliderOutputProps & React.RefAttributes<HTMLSpanElement>>;
+};
+export { Slider, SliderTrack, SliderThumb, SliderFill, SliderOutput };

package/dist/vendor/ui/primitives/spinner.d.ts

@@ -0,0 +1,12 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const spinnerVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | "xl" | null | undefined;
+    color?: "warning" | "current" | "secondary" | "primary" | "success" | "danger" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface SpinnerProps extends Omit<React.ComponentProps<'span'>, 'color'>, VariantProps<typeof spinnerVariants> {
+    /** Label for screen readers */
+    label?: string;
+}
+declare function Spinner({ className, size, color, label, ...props }: SpinnerProps): import("react/jsx-runtime").JSX.Element;
+export { Spinner, spinnerVariants };

package/dist/vendor/ui/primitives/surface.d.ts

@@ -0,0 +1,52 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+/**
+ * Surface Context
+ *
+ * Provides information about the current surface variant to child components.
+ * This allows form components (Input, TextArea, etc.) to automatically adapt
+ * their styling based on their container's surface variant.
+ *
+ * Default is 'transparent' so that form fields on the page background
+ * (not inside a Surface/Card) use the white/shadow style.
+ */
+declare const SurfaceContext: React.Context<{
+    variant: "transparent" | "default" | "secondary";
+}>;
+/**
+ * Hook to access the current surface context
+ */
+export declare function useSurface(): {
+    variant: "transparent" | "default" | "secondary";
+};
+declare const surfaceVariants: (props?: ({
+    variant?: "default" | "transparent" | "secondary" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface SurfaceProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof surfaceVariants> {
+    /**
+     * Change the default rendered element for the one passed as a child,
+     * merging their props and behavior.
+     */
+    asChild?: boolean;
+}
+/**
+ * Surface Component
+ *
+ * A semantic container that provides surface-level styling and context for child components.
+ *
+ * ## Variants:
+ * - `transparent` - No background
+ * - `default` - Card/panel surface (bg-card)
+ * - `secondary` - Raised/muted surface (bg-default)
+ *
+ * Form fields automatically adapt their styling based on which surface they're on.
+ *
+ * @example
+ * ```tsx
+ * <Surface variant="default">
+ *   <Input placeholder="On a card surface" />
+ * </Surface>
+ * ```
+ */
+declare const Surface: React.ForwardRefExoticComponent<SurfaceProps & React.RefAttributes<HTMLDivElement>>;
+export { Surface, surfaceVariants, SurfaceContext };

package/dist/vendor/ui/primitives/switch.d.ts

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

package/dist/vendor/ui/primitives/tabs.d.ts

@@ -0,0 +1,28 @@
+import * as React from 'react';
+import * as TabsPrimitive from '@radix-ui/react-tabs';
+interface TabsProps extends Omit<React.ComponentPropsWithoutRef<typeof TabsPrimitive.Root>, 'value' | 'onValueChange'> {
+    value?: string;
+    onValueChange?: (value: string) => void;
+}
+declare const TabsRoot: React.ForwardRefExoticComponent<TabsProps & React.RefAttributes<HTMLDivElement>>;
+declare const TabsList: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsListProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+interface TabsTriggerProps extends Omit<React.ComponentPropsWithoutRef<typeof TabsPrimitive.Trigger>, 'value'> {
+    id?: string;
+    value?: string;
+}
+declare const TabsTrigger: React.ForwardRefExoticComponent<TabsTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+interface TabsContentProps extends Omit<React.ComponentPropsWithoutRef<typeof TabsPrimitive.Content>, 'value'> {
+    id?: string;
+    value?: string;
+}
+declare const TabsContent: React.ForwardRefExoticComponent<TabsContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const Tabs: React.ForwardRefExoticComponent<TabsProps & React.RefAttributes<HTMLDivElement>> & {
+    List: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsListProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    ListContainer: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+    Tab: React.ForwardRefExoticComponent<TabsTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+    Trigger: React.ForwardRefExoticComponent<TabsTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+    Panel: React.ForwardRefExoticComponent<TabsContentProps & React.RefAttributes<HTMLDivElement>>;
+    Content: React.ForwardRefExoticComponent<TabsContentProps & React.RefAttributes<HTMLDivElement>>;
+    Indicator: () => null;
+};
+export { Tabs, TabsList, TabsTrigger, TabsContent, TabsRoot };