@ai-matrx/design-system 0.4.2 → 0.5.1

package/dist/index.d.cts

@@ -2,13 +2,22 @@ import * as class_variance_authority_types from 'class-variance-authority/types'
 import { VariantProps } from 'class-variance-authority';
 import * as React from 'react';
 import React__default, { ReactNode, ComponentType } from 'react';
+import * as AvatarPrimitive from '@radix-ui/react-avatar';
+import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
 import { ClassValue } from 'clsx';
-import * as SheetPrimitive from '@radix-ui/react-dialog';
+import * as CollapsiblePrimitive from '@radix-ui/react-collapsible';
+import * as DialogPrimitive from '@radix-ui/react-dialog';
 import { DialogProps } from '@radix-ui/react-dialog';
+import * as ContextMenuPrimitive from '@radix-ui/react-context-menu';
+import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
 import * as LabelPrimitive from '@radix-ui/react-label';
 import * as PopoverPrimitive from '@radix-ui/react-popover';
+import * as ProgressPrimitive from '@radix-ui/react-progress';
+import * as ScrollAreaPrimitive from '@radix-ui/react-scroll-area';
 import * as SelectPrimitive from '@radix-ui/react-select';
 import * as SeparatorPrimitive from '@radix-ui/react-separator';
+import * as SwitchPrimitives from '@radix-ui/react-switch';
+import * as TabsPrimitive from '@radix-ui/react-tabs';
 
 declare const badgeVariants: (props?: ({
     variant?: "default" | "secondary" | "destructive" | "outline" | "success" | "warning" | "info" | "error" | "neutral" | null | undefined;
@@ -65,8 +74,94 @@ interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, Var
 }
 declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
 
+/**
+ * Avatar — Radix avatar with the package's token vocabulary.
+ *
+ * The forks differed only in the root's fixed size (matrx-frontend `h-10 w-10`,
+ * dashboard `h-9 w-9`) and in whether the fallback carried type styling. Both
+ * are settled here as props rather than copies: `size` picks the box, and the
+ * fallback always carries the muted type treatment (dashboard's version — a
+ * fallback renders initials, and unstyled initials inherit whatever the row
+ * was using, which is how the two hosts' avatars stopped matching).
+ */
+
+type AvatarSize = "sm" | "md" | "lg";
+interface AvatarProps extends React.ComponentPropsWithoutRef<typeof AvatarPrimitive.Root> {
+    /** Box size. Default `lg` (the h-10 box matrx-frontend has always shipped). */
+    size?: AvatarSize;
+}
+declare const Avatar: React.ForwardRefExoticComponent<AvatarProps & React.RefAttributes<HTMLSpanElement>>;
+declare const AvatarImage: React.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarImageProps & React.RefAttributes<HTMLImageElement>, "ref"> & React.RefAttributes<HTMLImageElement>>;
+declare const AvatarFallback: React.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarFallbackProps & React.RefAttributes<HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+
+/**
+ * Card — the surface every host had already forked, four different ways.
+ *
+ * The census that motivated this file (2026-09-07): matrx-frontend padded its
+ * sections `p-2`, matrx-extend `p-4`, aidream/apps/dashboard `p-6`, and
+ * matrx-games ran a Base-UI-generation card of its own. The STRUCTURE was
+ * identical in all of them — a bordered, tokenised surface with header /
+ * title / description / content / footer slots. Only the density differed.
+ *
+ * So density is a PROP, not a fork. `size` is declared once on `<Card>` and
+ * every section reads it from context, which means a host cannot end up with a
+ * `p-6` header above a `p-2` body — the failure mode that made the forks drift
+ * in the first place. A host that wants its historical density binds the size
+ * once at its import site; nothing else moves.
+ *
+ *   sm  → p-2, rounded-xl, `shadow`      (matrx-frontend's density)
+ *   md  → p-4, rounded-lg, `shadow-sm`   (matrx-extend's density; the default)
+ *   lg  → p-6, rounded-lg, `shadow-sm`   (dashboard's density)
+ *
+ * Colour is tokens only (`bg-card` / `text-card-foreground` / `border`), so a
+ * host re-themes cards by redefining tokens, never by editing this file.
+ */
+
+type CardSize = "sm" | "md" | "lg";
+/** The size the nearest enclosing `<Card>` declared. `md` outside one. */
+declare function useCardSize(): CardSize;
+interface CardProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Density for this card and every section inside it. Default `md`. */
+    size?: CardSize;
+}
+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<HTMLHeadingElement>>;
+declare const CardDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
+/**
+ * Trailing control slot for a header (a menu button, a status pill). Absent
+ * from every fork except matrx-games', which is why headers elsewhere grew
+ * one-off absolute wrappers. Positions itself against the header's row.
+ */
+declare const CardAction: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardContent: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+
+/**
+ * Checkbox — Radix checkbox, and the indeterminate ruling that came with it.
+ *
+ * RADIX RENDERS THE INDICATOR FOR BOTH `checked` AND `"indeterminate"`. The
+ * stock shadcn body puts a full check inside it either way, so a half-selected
+ * "select all" tells the user every row is selected — a screen stating
+ * something false. The two states get different glyphs here, always.
+ *
+ * `size` carries the two boxes the hosts had forked into: matrx-frontend's
+ * dense 14px control and the stock 16px one.
+ */
+
+type CheckboxSize = "sm" | "md";
+interface CheckboxProps extends React.ComponentPropsWithoutRef<typeof CheckboxPrimitive.Root> {
+    /** Box size. Default `md` (the stock 16px control); `sm` is the dense 14px one. */
+    size?: CheckboxSize;
+}
+declare const Checkbox: React.ForwardRefExoticComponent<CheckboxProps & React.RefAttributes<HTMLButtonElement>>;
+
 declare function cn(...inputs: ClassValue[]): string;
 
+declare const Collapsible: React.ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleProps & React.RefAttributes<HTMLDivElement>>;
+declare const CollapsibleTrigger: React.ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const CollapsibleContent: React.ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleContentProps & React.RefAttributes<HTMLDivElement>>;
+
 /**
  * Command — ported verbatim from matrx-frontend `components/ui/command.tsx`.
  *
@@ -86,7 +181,9 @@ declare function cn(...inputs: ClassValue[]): string;
  *   `DialogPortal` becomes the package's `PortalContainerProvider` seam
  *   (plus an explicit `container` prop, which keeps top priority).
  * - The host's `useIsMobile` (a plain matchMedia breakpoint hook, not
- *   host-shaped) is inlined privately with the same 768px breakpoint.
+ *   host-shaped) became the package's own `./use-is-mobile`, with the same
+ *   768px breakpoint. It started life inlined here; `Dialog` needed the same
+ *   answer, so it moved to a module both read rather than being copied.
  */
 
 declare const Command: React.ForwardRefExoticComponent<Omit<{
@@ -171,6 +268,61 @@ declare const CommandShortcut: {
     displayName: string;
 };
 
+/**
+ * ContextMenu — the right-click menu primitive.
+ *
+ * THE ROOT RENDERS UNCONDITIONALLY — no hydration mount gate. The gate a
+ * matrx-frontend wrapper once carried ("Radix generates dynamic aria-controls
+ * ids that differ between SSR and client") was false twice over: a CLOSED
+ * `ContextMenuTrigger` renders only `data-state` / `data-disabled` and emits
+ * no id at all, so there was never a mismatch to defend against. And the gate
+ * was actively harmful: the Trigger wraps ALWAYS-VISIBLE content, so `return
+ * null` deleted the wrapped subtree from the server render and the first
+ * client render — around a list row, that means the list paints EMPTY and
+ * fills in after hydration. Gating the Root would additionally orphan any
+ * Trigger rendered beneath it.
+ *
+ * That history is exactly why this belongs in the package: the same repo had
+ * already accumulated two copies of this wrapper, one gated and one not, with
+ * the CORRECT one sitting unused beside the defective one.
+ *
+ * This is the PRIMITIVE only. A host's actual right-click menu SYSTEM — the
+ * sections, the copy/export/convert actions, the surface registry — composes
+ * these parts and stays host-owned; nothing here knows what an action is.
+ *
+ * Portalling goes through the package's `usePortalContainer` seam so a menu
+ * raised inside a Dialog mounts inside it; an explicit `container` wins.
+ */
+
+declare const ContextMenu: React.FC<ContextMenuPrimitive.ContextMenuProps>;
+declare const ContextMenuTrigger: React.ForwardRefExoticComponent<ContextMenuPrimitive.ContextMenuTriggerProps & React.RefAttributes<HTMLSpanElement>>;
+declare const ContextMenuGroup: React.ForwardRefExoticComponent<ContextMenuPrimitive.ContextMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuPortal: React.FC<ContextMenuPrimitive.ContextMenuPortalProps>;
+declare const ContextMenuSub: React.FC<ContextMenuPrimitive.ContextMenuSubProps>;
+declare const ContextMenuRadioGroup: React.ForwardRefExoticComponent<ContextMenuPrimitive.ContextMenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuSubTrigger: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuSubContent: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuSubContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+interface ContextMenuContentProps extends React.ComponentPropsWithoutRef<typeof ContextMenuPrimitive.Content> {
+    /** Explicit portal target; wins over the injected container. */
+    container?: HTMLElement | null;
+}
+declare const ContextMenuContent: React.ForwardRefExoticComponent<ContextMenuContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuItem: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuCheckboxItem: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuRadioItem: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuRadioItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuLabel: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuSeparator: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuShortcut: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): React.JSX.Element;
+    displayName: string;
+};
+
 /** Structural stand-in for the host's `LucideIcon` in `footerActions`. */
 type PickerIcon = ComponentType<{
     className?: string;
@@ -274,6 +426,152 @@ interface CreatablePickerProps {
 }
 declare function CreatablePicker({ value, options, onSelect, placeholder, searchPlaceholder, noun, onCreate, onCreateRequiresMore, disabled, loading, className, triggerClassName, emptyLabel, ariaLabel, lockedNote, lockedAction, createExtra, manageAction, footerActions, renderSelected, size, }: CreatablePickerProps): React.JSX.Element;
 
+/**
+ * Dialog — the modal surface, carrying every ruling the host forks paid for.
+ *
+ * Four hosts shipped four dialogs. Three were the stock shadcn body: a
+ * fixed-size centered card with `overflow: visible`. matrx-frontend's had been
+ * hardened, incident by incident, and those hardenings are the reason this
+ * component belongs in the package rather than being copied a fifth time:
+ *
+ * 1. THE ROOT RENDERS UNCONDITIONALLY — no hydration mount gate. The gate a
+ *    wrapper once carried ("Radix ids differ between SSR and client") was
+ *    false — Radix ids come from React's SSR-stable `useId` — and it deleted
+ *    the always-visible Trigger from SSR and the first client paint.
+ *
+ * 2. THE DIALOG IS CLAMPED TO THE VIEWPORT AND SCROLLS INSIDE ITSELF. Proven
+ *    live: an admin "Create Category" dialog rendered 851px tall in a 657px
+ *    viewport with `overflow-y: visible`, so its Create button sat below the
+ *    fold, unreachable. The only way out was a backdrop click — which
+ *    dismisses WITHOUT writing, and is indistinguishable from a silent save
+ *    failure. `max-h-[85dvh] overflow-y-auto` is the cap.
+ *
+ * 3. THE PRIMARY ACTION IS ALWAYS PRESSABLE. `DialogFooter` is sticky and
+ *    bleeds to the card's edges using `--dialog-pad`, so scrolled content
+ *    never shows through beneath it. Outside a DialogContent the variable is
+ *    unset, the padding falls back to `0px`, and the footer is the plain row
+ *    it always was.
+ *
+ * 4. ON MOBILE THE SAME DIALOG IS A BOTTOM SHEET — full width, bottom
+ *    anchored, height-capped, internally scrollable, safe-area padded. Opt out
+ *    with `mobileSheet={false}` only for the rare surface that must stay
+ *    centered (a tiny spinner). The sheet geometry is re-asserted AFTER the
+ *    caller's className so a desktop `max-w-2xl` cannot un-fullscreen it.
+ *
+ * 5. AN UNTITLED DIALOG IS STILL ACCESSIBLE. Radix warns (correctly) that
+ *    every dialog needs a title; rather than let hosts ship the warning, a
+ *    visually-hidden title is injected when the tree has none, and
+ *    `aria-describedby` is dropped when there is no description rather than
+ *    pointing at nothing.
+ *
+ * SEAM INVERSIONS. The host original resolved its portal target through
+ * app-shaped hooks (a popped-out window-panel body). Here that is the
+ * package's `PortalContainerProvider` seam, with an explicit `container` prop
+ * keeping top priority. And DialogContent PROVIDES that seam to its own
+ * children, so a Popover or menu opened inside a dialog portals INTO the
+ * dialog — staying inside the scroll shard, where its wheel events work.
+ * `useDialogContainer` exposes the same element for host code that needs it.
+ */
+
+declare const Dialog: {
+    ({ children, ...props }: React.ComponentPropsWithoutRef<typeof DialogPrimitive.Root>): React.JSX.Element;
+    displayName: string;
+};
+declare const DialogTrigger: React.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DialogClose: React.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
+/**
+ * Portal-seam-aware DialogPortal. An explicit `container` always wins; with
+ * none, the injected `PortalContainerProvider` value decides; with neither,
+ * Radix's `document.body`.
+ */
+declare const DialogPortal: {
+    ({ container, ...props }: Omit<React.ComponentPropsWithoutRef<typeof DialogPrimitive.Portal>, "container"> & {
+        /** `undefined` → use the injected container; `null` → force document.body. */
+        container?: HTMLElement | null | undefined;
+    }): React.JSX.Element;
+    displayName: string;
+};
+/** The DialogContent element, for host code that portals into the dialog. */
+declare const useDialogContainer: () => HTMLElement | null;
+declare const DialogOverlay: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Unstyled, non-portalling Content for custom dialog layouts. Preserves Radix
+ * focus/background behavior and derives `aria-modal` from the Root.
+ */
+declare const DialogContentPrimitive: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+interface DialogContentProps extends React.ComponentPropsWithoutRef<typeof DialogPrimitive.Content> {
+    /** Render as a bottom sheet below the mobile breakpoint. Default `true`. */
+    mobileSheet?: boolean;
+    /** Render the built-in close control. Default `true`. */
+    showCloseButton?: boolean;
+    /** Explicit portal target; wins over the injected container. */
+    container?: HTMLElement | null;
+}
+declare const DialogContent: React.ForwardRefExoticComponent<DialogContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const DialogHeader: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
+    displayName: string;
+};
+declare const DialogFooter: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
+    displayName: string;
+};
+declare const DialogTitle: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+declare const DialogDescription: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+
+/**
+ * DropdownMenu — Radix dropdown with two behaviours the stock body lacks.
+ *
+ * 1. THE ROOT RENDERS UNCONDITIONALLY — no hydration mount gate. A wrapper in
+ *    matrx-frontend once deferred rendering until after hydration on a false
+ *    premise (Radix ids come from React's SSR-stable `useId`), which deleted
+ *    the always-visible trigger — buttons, `…` menus — from SSR and the first
+ *    client paint.
+ *
+ * 2. A LONG MENU SCROLLS INSTEAD OF GROWING OFF-SCREEN. Content and SubContent
+ *    cap at `--radix-dropdown-menu-content-available-height` — the space Radix
+ *    actually measured between the trigger and the viewport edge — and scroll
+ *    past it. Without the cap a menu longer than the viewport puts its last
+ *    items where no pointer can reach them, and on a short window that can be
+ *    the only exit from the surface.
+ *
+ * Portalling goes through the package's `usePortalContainer` seam, so a menu
+ * opened inside a Dialog mounts INSIDE the dialog (staying in the scroll
+ * shard, where its wheel events work) instead of at `document.body`. An
+ * explicit `container` prop still wins.
+ *
+ * Icons are the package's inlined SVGs (C19) — no icon-library dependency.
+ */
+
+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>>;
+interface DropdownMenuContentProps extends React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Content> {
+    /** Explicit portal target; wins over the injected container. */
+    container?: HTMLElement | null;
+}
+declare const DropdownMenuContent: React.ForwardRefExoticComponent<DropdownMenuContentProps & 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>): React.JSX.Element;
+    displayName: string;
+};
+
 type EditableLabelCommitMode = "optimistic" | "await";
 type EditableLabelActivation = "click" | "doubleClick" | "controlled";
 interface EditableLabelProps {
@@ -451,6 +749,30 @@ declare const PopoverContent: React.ForwardRefExoticComponent<Omit<PopoverPrimit
     container?: HTMLElement | null;
 } & React.RefAttributes<HTMLDivElement>>;
 
+/**
+ * Progress — a determinate bar.
+ *
+ * THE INDETERMINATE CASE IS NOT SILENT. Radix treats `value={null}` (or an
+ * omitted value) as indeterminate, and the shadcn fork every host copied
+ * computed `translateX(-${100 - (value || 0)}%)`, which turns an unknown value
+ * into a confident, wrong "0%" — a bar that says the work has not started when
+ * the truth is that nobody knows. Here an indeterminate bar renders a moving
+ * sweep and carries `data-state="indeterminate"`, so it LOOKS different from
+ * stalled-at-zero.
+ *
+ * `tone` maps the fill onto the semantic status tokens, rather than leaving a
+ * host to reach for a raw palette utility on a failing bar.
+ */
+
+type ProgressTone = "default" | "success" | "warning" | "destructive";
+interface ProgressProps extends React.ComponentPropsWithoutRef<typeof ProgressPrimitive.Root> {
+    /** Fill colour, from the semantic status tokens. Default `default`. */
+    tone?: ProgressTone;
+    /** Classes for the moving fill. */
+    indicatorClassName?: string;
+}
+declare const Progress: React.ForwardRefExoticComponent<ProgressProps & React.RefAttributes<HTMLDivElement>>;
+
 /**
  * Injected portal-container seam.
  *
@@ -494,6 +816,39 @@ declare function RadixDialogModalProvider({ children, modal, }: RadixDialogModal
 /** Returns whether the nearest Radix Dialog-derived root is modal. */
 declare function useRadixDialogModal(): boolean;
 
+/**
+ * ScrollArea — Radix scroll area with a custom, token-coloured scrollbar.
+ *
+ * Every fork was the same component; what they could not share was the
+ * VIEWPORT. Radix renders an internal `display: table` div inside the
+ * viewport, and workflow-studio's fork had to reach through it
+ * (`[&>div]:!block [&>div]:min-w-0`) so long content wraps instead of forcing
+ * the table cell wider than its container. That is the exact reason a host
+ * forks: a class it cannot pass. So the viewport is addressable here —
+ * `viewportClassName` and `viewportRef` — and nobody needs a copy to style it.
+ *
+ * `viewportRef` also unlocks the thing hosts hand-rolled around this
+ * component: programmatic scrolling (scroll-to-bottom on a new message,
+ * restoring a position) needs the scrolling element, and the Root's ref is not
+ * it.
+ *
+ * The thumb reads `bg-border`; a host that wants workflow-studio's dimmer
+ * thumb passes `scrollBarClassName`.
+ */
+
+interface ScrollAreaProps extends React.ComponentPropsWithoutRef<typeof ScrollAreaPrimitive.Root> {
+    /** Classes for the scrolling viewport (not the Root). */
+    viewportClassName?: string;
+    /** Ref to the scrolling element — the one `scrollTop` lives on. */
+    viewportRef?: React.Ref<HTMLDivElement>;
+    /** Classes for the vertical scrollbar this component renders. */
+    scrollBarClassName?: string;
+    /** Scrollbar orientation to render. Default `vertical`. */
+    orientation?: "vertical" | "horizontal";
+}
+declare const ScrollArea: React.ForwardRefExoticComponent<ScrollAreaProps & React.RefAttributes<HTMLDivElement>>;
+declare const ScrollBar: React.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaScrollbarProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+
 interface ScoreThresholds {
     /** Scores at or above this value are green. */
     good: number;
@@ -575,22 +930,22 @@ declare const SelectSeparator: React.ForwardRefExoticComponent<Omit<SelectPrimit
 
 declare const Separator: React.ForwardRefExoticComponent<Omit<SeparatorPrimitive.SeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
 
-declare const Sheet: React.ForwardRefExoticComponent<SheetPrimitive.DialogProps & React.RefAttributes<never>>;
-declare const SheetTrigger: React.ForwardRefExoticComponent<SheetPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
-declare const SheetClose: React.ForwardRefExoticComponent<SheetPrimitive.DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
-declare const SheetPortal: React.FC<SheetPrimitive.DialogPortalProps>;
-declare const SheetOverlay: React.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const Sheet: React.ForwardRefExoticComponent<DialogPrimitive.DialogProps & React.RefAttributes<never>>;
+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 sheetVariants: (props?: ({
     side?: "center" | "bottom" | "left" | "right" | "top" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
-interface SheetContentProps extends React.ComponentPropsWithoutRef<typeof SheetPrimitive.Content>, VariantProps<typeof sheetVariants> {
+interface SheetContentProps extends React.ComponentPropsWithoutRef<typeof DialogPrimitive.Content>, VariantProps<typeof sheetVariants> {
     hideCloseButton?: boolean;
     /** Skip the dimming overlay — for non-modal side panels (e.g. chat canvas). */
     hideOverlay?: boolean;
     /** Optional className for the overlay when shown. */
     overlayClassName?: string;
 }
-declare const SheetDescription: React.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+declare const SheetDescription: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
 declare const SheetContent: React.ForwardRefExoticComponent<SheetContentProps & React.RefAttributes<HTMLDivElement>>;
 declare const SheetHeader: {
     ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
@@ -600,7 +955,7 @@ declare const SheetFooter: {
     ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
     displayName: string;
 };
-declare const SheetTitle: React.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+declare const SheetTitle: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
 
 /**
  * Skeleton — ported verbatim from matrx-frontend `components/ui/skeleton.tsx`.
@@ -609,6 +964,30 @@ declare const SheetTitle: React.ForwardRefExoticComponent<Omit<SheetPrimitive.Di
 
 declare function Skeleton({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
 
+/**
+ * Switch — Radix switch, one implementation, two sizes.
+ *
+ * The four forks were the same control with two different tracks: a 16px track
+ * with a visible border and an overhanging thumb (matrx-frontend) and a 20px
+ * track with a transparent border and an inset thumb (matrx-extend, dashboard,
+ * workflow-studio). Both stay reachable through `size`, so no host has to keep
+ * a copy to keep its look:
+ *
+ *   sm → h-4 track, bordered, thumb sits proud of the rail
+ *   md → h-5 track, transparent border, thumb sits inside (the default)
+ *
+ * The unchecked track reads `bg-input`, the token that exists for exactly this
+ * — workflow-studio's fork used `bg-muted`, which is the surface token and
+ * makes an off switch disappear into a muted panel.
+ */
+
+type SwitchSize = "sm" | "md";
+interface SwitchProps extends React.ComponentPropsWithoutRef<typeof SwitchPrimitives.Root> {
+    /** Track size. Default `md`. */
+    size?: SwitchSize;
+}
+declare const Switch: React.ForwardRefExoticComponent<SwitchProps & React.RefAttributes<HTMLButtonElement>>;
+
 interface TabbedBottomSheetTab {
     id: string;
     label: string;
@@ -627,6 +1006,161 @@ interface TabbedBottomSheetProps {
 }
 declare function TabbedBottomSheet({ open, onOpenChange, title, tabs, }: TabbedBottomSheetProps): React.JSX.Element;
 
+/**
+ * Table — the semantic table shell. No data logic, no sorting, no virtualiser:
+ * those belong to the host's data-table layer, which composes these elements.
+ *
+ * The two forks disagreed on exactly three things, all of them now props:
+ *
+ * 1. matrx-frontend wrapped `<table>` in `relative w-full overflow-auto` so a
+ *    wide table scrolls inside itself instead of pushing the page sideways;
+ *    dashboard emitted a bare `<table>`. The wrapper is the correct default —
+ *    a table that widens its page is a layout bug on every narrow viewport —
+ *    so it stays on, with `wrap={false}` for a host that already owns a
+ *    scroll container (double scrollers are their own defect).
+ * 2. dashboard's header was `sticky top-0 z-10 bg-background`. That is a real
+ *    capability, not a style opinion, so it is `sticky` on `TableHeader` —
+ *    opt-in, because a sticky header inside an unbounded page sticks to
+ *    nothing and only costs a stacking context.
+ * 3. Cell density: `p-2` vs `p-3`. Declared once on `<Table size>` and read
+ *    from context by every cell, so a table cannot mix densities.
+ *
+ * Colour is tokens only.
+ */
+
+type TableSize = "sm" | "md";
+/** The density the nearest enclosing `<Table>` declared. `md` outside one. */
+declare function useTableSize(): TableSize;
+interface TableProps extends React.HTMLAttributes<HTMLTableElement> {
+    /** Cell density for this table. Default `md` (`p-3`); `sm` is `p-2`. */
+    size?: TableSize;
+    /**
+     * Wrap the table in its own horizontal scroll container. Default `true`.
+     * Pass `false` only when an ancestor already scrolls this table.
+     */
+    wrap?: boolean;
+    /** Classes for the scroll wrapper (ignored when `wrap` is false). */
+    wrapperClassName?: string;
+}
+declare const Table: React.ForwardRefExoticComponent<TableProps & React.RefAttributes<HTMLTableElement>>;
+interface TableHeaderProps extends React.HTMLAttributes<HTMLTableSectionElement> {
+    /**
+     * Pin the header to the top of the nearest scroll container. Opt-in: it
+     * needs a bounded scroll ancestor to stick to, and it opens a stacking
+     * context whether or not it sticks.
+     */
+    sticky?: boolean;
+}
+declare const TableHeader: React.ForwardRefExoticComponent<TableHeaderProps & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableBody: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableRow: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableRowElement> & React.RefAttributes<HTMLTableRowElement>>;
+declare const TableHead: React.ForwardRefExoticComponent<React.ThHTMLAttributes<HTMLTableCellElement> & React.RefAttributes<HTMLTableCellElement>>;
+declare const TableCell: React.ForwardRefExoticComponent<React.TdHTMLAttributes<HTMLTableCellElement> & React.RefAttributes<HTMLTableCellElement>>;
+declare const TableCaption: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableCaptionElement> & React.RefAttributes<HTMLTableCaptionElement>>;
+
+/**
+ * Tabs — Radix tabs, carrying two rulings the forks had already paid for.
+ *
+ * 1. THE ROOT RENDERS UNCONDITIONALLY — no mount gate. A wrapper in
+ *    matrx-frontend used to defer rendering until after hydration ("Radix
+ *    generates dynamic aria-controls ids that differ between SSR and client").
+ *    That was false — Radix ids come from React's SSR-stable `useId` — and the
+ *    gate deleted the ENTIRE tab bar and active panel from SSR and the first
+ *    client paint.
+ *
+ * 2. INACTIVE PANELS UNMOUNT — Radix's default, restored in matrx-frontend on
+ *    2026-08-15 after a wrapper hardcoded `forceMount`. Every tab panel in that
+ *    app was live at all times: effects running, fetches firing, subscriptions
+ *    open, registrations registered — while invisible. Not theoretical: on the
+ *    agent-apps executions page both tabs' tables registered a runtime provider
+ *    for the same surface at the same depth, the HIDDEN tab won the tie-break,
+ *    and agents on the VISIBLE tab were handed the other tab's rows.
+ *
+ *    `forceMount` is OPT-IN. Pass it on the panels that genuinely must survive
+ *    a switch — an in-flight editor, a scroll position, a live stream that
+ *    must not be torn down. `data-[state=inactive]:hidden` is applied
+ *    unconditionally (inert when the panel unmounts), so passing the prop is
+ *    the whole opt-in.
+ *
+ *    Do NOT reach for `forceMount` to preserve a form draft. Lift that state to
+ *    the component that owns the `<Tabs>`; the panel is then free to unmount
+ *    and the draft survives a close/reopen too, which force-mounting never gave
+ *    you.
+ *
+ * `TabsTriggerCore` is the trigger WITHOUT the resting muted-foreground
+ * treatment, for hosts that colour their own inactive tabs. Both triggers
+ * otherwise share one class string.
+ */
+
+declare const Tabs: React.ForwardRefExoticComponent<TabsPrimitive.TabsProps & React.RefAttributes<HTMLDivElement>>;
+declare const TabsList: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsListProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const TabsTrigger: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+/** The trigger without the resting muted/hover treatment. */
+declare const TabsTriggerCore: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const TabsContent: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+
+/**
+ * Textarea — the multi-line twin of the Input family, same three shapes:
+ * `Textarea` (elevated), `BasicTextarea` (plain control), and
+ * `TextareaWithPrefix`.
+ *
+ * WHAT THE FORKS PROVED. Three hosts shipped a bare `<textarea>` with a
+ * min-height and nothing else; matrx-frontend shipped auto-grow, min/max
+ * height clamping, and a stretch-detection pass. That last one is the reason
+ * this file is worth having: a `<textarea>` is a REPLACED element, so
+ * `className="h-full"` on it does nothing useful unless its parent is also
+ * told to stretch — which is why every host that wanted a filling textarea
+ * ended up wrapping it by hand at the call site, differently each time.
+ * `getStretchClasses` reads the caller's own fill intent out of the className
+ * and builds the wrapper for them.
+ *
+ * COLOUR IS TOKENS (C26). The ported original pinned its body text to literal
+ * black/white, its placeholder and focus ring to raw palette steps, and its
+ * dark elevation to a custom property no host defined — so that shadow
+ * computed to nothing. All four now resolve from the semantic vocabulary.
+ *
+ * AND `shadow-textarea` NOW EXISTS. The original's resting elevation class was
+ * `shadow-textarea`, and NO host defined `--shadow-textarea` or generated that
+ * utility — 125 call sites asked for an elevation they never got. The package
+ * ships the token (defaulting to the Input family's `--shadow-input`, which is
+ * plainly what the twin class meant) and the rule, so the class finally does
+ * what it says. A host that wants the flat look sets `--shadow-textarea: none`.
+ *
+ * The clipboard/motion variants matrx-frontend layers on top (CopyTextarea,
+ * FancyTextarea) stay host-owned under the C8 split-out law: they drag in
+ * `motion/react`, and plain-textarea consumers must not pay for it.
+ */
+
+interface TextareaProps extends React.TextareaHTMLAttributes<HTMLTextAreaElement> {
+    /** Grow to fit content as the user types (and stop growing at `maxHeight`). */
+    autoGrow?: boolean;
+    /** Minimum height in px. */
+    minHeight?: number;
+    /** Maximum height in px; past it the field scrolls instead of growing. */
+    maxHeight?: number;
+    /** Classes for the wrapper this component adds when one is needed. */
+    wrapperClassName?: string;
+}
+/** The elevated textarea — the Input family's `Input`, in multi-line form. */
+declare const Textarea: React.ForwardRefExoticComponent<TextareaProps & React.RefAttributes<HTMLTextAreaElement>>;
+/**
+ * The plain control — a bordered, transparent field with a 60px floor. This is
+ * what matrx-extend, aidream/apps/dashboard and workflow-studio each called
+ * `Textarea`; the floor is theirs and it is the sensible default (a one-line
+ * box for multi-line content invites a scrollbar on the first Enter).
+ */
+declare const BasicTextarea: React.ForwardRefExoticComponent<TextareaProps & React.RefAttributes<HTMLTextAreaElement>>;
+interface TextareaWithPrefixProps extends Omit<TextareaProps, "prefix"> {
+    /** Leading adornment, absolutely placed at the field's top-left. */
+    prefix?: React.ReactNode;
+}
+declare const TextareaWithPrefix: React.ForwardRefExoticComponent<TextareaWithPrefixProps & React.RefAttributes<HTMLTextAreaElement>>;
+
+/** Viewport width (px) below which the package treats a surface as mobile. */
+declare const MOBILE_BREAKPOINT = 768;
+declare function useIsMobile(): boolean;
+
 interface ScrollFadeState {
     top: boolean;
     bottom: boolean;
@@ -642,4 +1176,4 @@ interface UseScrollFadeResult {
 }
 declare function useScrollFade(): UseScrollFadeResult;
 
-export { Badge, type BadgeProps, BasicInput, BottomSheet, BottomSheetBody, type BottomSheetBodyProps, BottomSheetFooter, type BottomSheetFooterProps, BottomSheetHeader, type BottomSheetHeaderProps, type BottomSheetProps, Button, type ButtonProps, Command, CommandDialog, type CommandDialogProps, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList, CommandSeparator, CommandShortcut, type CreatableOption, CreatablePicker, type CreatablePickerProps, DEFAULT_SCORE_THRESHOLDS, EditableLabel, type EditableLabelActivation, type EditableLabelCommitMode, type EditableLabelProps, EnterInput, type EnterInputProps, Input, type InputProps, type InputVariant, InputWithPrefix, type InputWithPrefixProps, Label, OverflowToolbar, type OverflowToolbarProps, type PickerIcon, Popover, PopoverAnchor, PopoverContent, PopoverTrigger, PortalContainerProvider, type PortalContainerProviderProps, RadixDialogModalProvider, type RadixDialogModalProviderProps, ScoreRing, type ScoreRingProps, type ScoreThresholds, type ScrollFadeState, type SegmentOption, SegmentedControl, type SegmentedControlProps, Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, type SelectTriggerProps, SelectValue, Separator, Sheet, SheetClose, SheetContent, type SheetContentProps, SheetDescription, SheetFooter, SheetHeader, SheetOverlay, SheetPortal, SheetTitle, SheetTrigger, Skeleton, TabbedBottomSheet, type TabbedBottomSheetProps, type TabbedBottomSheetTab, type ToolbarAction, type ToolbarActionTone, type ToolbarIcon, type UseScrollFadeResult, badgeVariants, buttonVariants, cn, scoreAccentBgClasses, scoreRingColorClasses, selectTriggerVariants, sheetVariants, usePortalContainer, useRadixDialogModal, useScrollFade };
+export { Avatar, AvatarFallback, AvatarImage, type AvatarProps, type AvatarSize, Badge, type BadgeProps, BasicInput, BasicTextarea, BottomSheet, BottomSheetBody, type BottomSheetBodyProps, BottomSheetFooter, type BottomSheetFooterProps, BottomSheetHeader, type BottomSheetHeaderProps, type BottomSheetProps, Button, type ButtonProps, Card, CardAction, CardContent, CardDescription, CardFooter, CardHeader, type CardProps, type CardSize, CardTitle, Checkbox, type CheckboxProps, type CheckboxSize, Collapsible, CollapsibleContent, CollapsibleTrigger, Command, CommandDialog, type CommandDialogProps, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList, CommandSeparator, CommandShortcut, ContextMenu, ContextMenuCheckboxItem, ContextMenuContent, type ContextMenuContentProps, ContextMenuGroup, ContextMenuItem, ContextMenuLabel, ContextMenuPortal, ContextMenuRadioGroup, ContextMenuRadioItem, ContextMenuSeparator, ContextMenuShortcut, ContextMenuSub, ContextMenuSubContent, ContextMenuSubTrigger, ContextMenuTrigger, type CreatableOption, CreatablePicker, type CreatablePickerProps, DEFAULT_SCORE_THRESHOLDS, Dialog, DialogClose, DialogContent, DialogContentPrimitive, type DialogContentProps, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, type DropdownMenuContentProps, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, EditableLabel, type EditableLabelActivation, type EditableLabelCommitMode, type EditableLabelProps, EnterInput, type EnterInputProps, Input, type InputProps, type InputVariant, InputWithPrefix, type InputWithPrefixProps, Label, MOBILE_BREAKPOINT, OverflowToolbar, type OverflowToolbarProps, type PickerIcon, Popover, PopoverAnchor, PopoverContent, PopoverTrigger, PortalContainerProvider, type PortalContainerProviderProps, Progress, type ProgressProps, type ProgressTone, RadixDialogModalProvider, type RadixDialogModalProviderProps, ScoreRing, type ScoreRingProps, type ScoreThresholds, ScrollArea, type ScrollAreaProps, ScrollBar, type ScrollFadeState, type SegmentOption, SegmentedControl, type SegmentedControlProps, Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, type SelectTriggerProps, SelectValue, Separator, Sheet, SheetClose, SheetContent, type SheetContentProps, SheetDescription, SheetFooter, SheetHeader, SheetOverlay, SheetPortal, SheetTitle, SheetTrigger, Skeleton, Switch, type SwitchProps, type SwitchSize, TabbedBottomSheet, type TabbedBottomSheetProps, type TabbedBottomSheetTab, Table, TableBody, TableCaption, TableCell, TableFooter, TableHead, TableHeader, type TableHeaderProps, type TableProps, TableRow, type TableSize, Tabs, TabsContent, TabsList, TabsTrigger, TabsTriggerCore, Textarea, type TextareaProps, TextareaWithPrefix, type TextareaWithPrefixProps, type ToolbarAction, type ToolbarActionTone, type ToolbarIcon, type UseScrollFadeResult, badgeVariants, buttonVariants, cn, scoreAccentBgClasses, scoreRingColorClasses, selectTriggerVariants, sheetVariants, useCardSize, useDialogContainer, useIsMobile, usePortalContainer, useRadixDialogModal, useScrollFade, useTableSize };