@acronis-platform/ui-react 0.62.0 → 1.0.0

package/dist/react.js.map

@@ -1 +1 @@
-{"version":3,"file":"react.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"react.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/src/components/ui/alert/alert.d.ts

@@ -1,14 +1,45 @@
 import { VariantProps } from 'class-variance-authority';
+import { ButtonIconProps } from '../button-icon';
 import * as React from 'react';
 declare const alertVariants: (props?: ({
-    variant?: "info" | "success" | "warning" | "critical" | "destructive" | "ai" | "neutral" | null | undefined;
+    variant?: "info" | "success" | "warning" | "critical" | "danger" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export type AlertVariant = NonNullable<VariantProps<typeof alertVariants>['variant']>;
 export interface AlertProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof alertVariants> {
 }
+/**
+ * A status banner: neutral surface, a status-colored border, and a status line
+ * down the leading edge. Compose it from `AlertIcon`, `AlertContent`
+ * (`AlertText` + `AlertTitle` / `AlertDescription`, optionally `AlertActions`)
+ * and `AlertClose`.
+ */
 declare const Alert: React.ForwardRefExoticComponent<AlertProps & React.RefAttributes<HTMLDivElement>>;
+/**
+ * The leading status icon. Renders the variant's own icon when given no
+ * `children`; pass children to substitute a different glyph.
+ */
 declare const AlertIcon: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
 declare const AlertContent: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+/**
+ * The title + description block. Its own vertical padding is what keeps the
+ * text aligned with the icon, so keep the title and description inside it
+ * rather than directly under `AlertContent`.
+ */
+declare const AlertText: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
 declare const AlertTitle: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLHeadingElement> & React.RefAttributes<HTMLHeadingElement>>;
-declare const AlertDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const AlertDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
+/**
+ * Action buttons under the text. Place inside `AlertContent` (after
+ * `AlertText`), as the Figma does — the row wraps when it runs out of width.
+ */
 declare const AlertActions: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
-export { Alert, AlertIcon, AlertContent, AlertTitle, AlertDescription, AlertActions, };
+export interface AlertCloseProps extends Omit<ButtonIconProps, 'children' | 'variant' | 'render' | 'aria-label'> {
+    /** Accessible name for the dismiss control. */
+    ariaLabel?: string;
+}
+/**
+ * The trailing dismiss control. Rendering it is what makes an alert
+ * dismissable — wire `onClick` to remove the alert. Name it with `ariaLabel`.
+ */
+declare const AlertClose: React.ForwardRefExoticComponent<AlertCloseProps & React.RefAttributes<HTMLButtonElement>>;
+export { Alert, AlertIcon, AlertContent, AlertText, AlertTitle, AlertDescription, AlertActions, AlertClose, alertVariants, };

package/dist/src/components/ui/alert/index.d.ts

@@ -1,2 +1,2 @@
-export { Alert, AlertIcon, AlertContent, AlertTitle, AlertDescription, AlertActions, } from './alert';
-export type { AlertProps } from './alert';
+export { Alert, AlertIcon, AlertContent, AlertText, AlertTitle, AlertDescription, AlertActions, AlertClose, alertVariants, } from './alert';
+export type { AlertProps, AlertCloseProps, AlertVariant } from './alert';

package/dist/src/components/ui/button/button.d.ts

@@ -2,7 +2,7 @@ import { useRender } from '@base-ui/react/use-render';
 import { VariantProps } from 'class-variance-authority';
 import * as React from 'react';
 declare const buttonVariants: (props?: ({
-    variant?: "destructive" | "ai" | "secondary" | "default" | "ghost" | null | undefined;
+    variant?: "ghost" | "secondary" | "default" | "destructive" | "ai" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
 export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
     /**

package/dist/src/components/ui/button-group/button-group.d.ts

@@ -0,0 +1,38 @@
+import { ToolbarButtonProps, ToolbarRootProps } from '@base-ui/react/toolbar';
+import { VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const buttonGroupVariants: (props?: ({
+    variant?: "outlined" | "inlined" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare const buttonGroupItemVariants: (props?: import('class-variance-authority/types').ClassProp | undefined) => string;
+export interface ButtonGroupProps extends Omit<ToolbarRootProps, 'className' | 'orientation'>, VariantProps<typeof buttonGroupVariants> {
+    className?: string;
+}
+/**
+ * A cluster of related icon-only actions sharing a single bordered box.
+ *
+ * Renders a `role="toolbar"` container: the group is one Tab stop and the
+ * arrow keys move between items. Give it an accessible name (`aria-label` or
+ * `aria-labelledby`) describing what the actions have in common.
+ */
+declare const ButtonGroup: React.ForwardRefExoticComponent<Omit<ButtonGroupProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+/** Mirrors the Figma `ButtonGroupItem` `order` variant. */
+export type ButtonGroupItemOrder = 'first' | 'middle' | 'last';
+export interface ButtonGroupItemProps extends Omit<ToolbarButtonProps, 'className'> {
+    className?: string;
+    /**
+     * Position within the group, mirroring the Figma `order` variant. Controls
+     * one thing: whether the trailing separator is drawn (`last` omits it).
+     *
+     * Leave it unset — position is derived from the DOM. Only pass it when each
+     * item is wrapped in another element, which defeats that derivation.
+     */
+    order?: ButtonGroupItemOrder;
+}
+/**
+ * A single action inside a `ButtonGroup`. The icon is passed as `children`;
+ * provide an `aria-label` (or `aria-labelledby`) so the control has an
+ * accessible name.
+ */
+declare const ButtonGroupItem: React.ForwardRefExoticComponent<Omit<ButtonGroupItemProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { ButtonGroup, ButtonGroupItem, buttonGroupVariants, buttonGroupItemVariants, };

package/dist/src/components/ui/button-group/index.d.ts

@@ -0,0 +1 @@
+export { ButtonGroup, ButtonGroupItem, buttonGroupVariants, buttonGroupItemVariants, type ButtonGroupProps, type ButtonGroupItemProps, type ButtonGroupItemOrder, } from './button-group';

package/dist/src/components/ui/button-icon/button-icon.d.ts

@@ -2,7 +2,7 @@ import { useRender } from '@base-ui/react/use-render';
 import { VariantProps } from 'class-variance-authority';
 import * as React from 'react';
 declare const buttonIconVariants: (props?: ({
-    variant?: "secondary" | "ghost" | null | undefined;
+    variant?: "ghost" | "secondary" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
 export interface ButtonIconProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonIconVariants> {
     /**

package/dist/src/components/ui/button-icon-menu/button-icon-menu.d.ts

@@ -0,0 +1,28 @@
+import { useRender } from '@base-ui/react/use-render';
+import * as React from 'react';
+export interface ButtonIconMenuProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'children'> {
+    /**
+     * Whether the associated menu is open. Applies the open (`*-active`)
+     * treatment and reflects `aria-expanded`. Control this in sync with the menu
+     * you trigger.
+     */
+    open?: boolean;
+    /**
+     * Accessible name for the trigger. The button is icon-only, so it has no text
+     * to name it — pass a localized string here.
+     */
+    ariaLabel?: string;
+    /**
+     * Replace the rendered `<button>` with another element or component
+     * (Base UI composition). Accepts a React element or a render function —
+     * the component's props and class names are merged onto it.
+     */
+    render?: useRender.RenderProp;
+}
+/**
+ * Icon-only button that opens a menu of actions — the kebab / "more options"
+ * trigger. The glyph is fixed (Ellipsis); for any other icon use `ButtonIcon`.
+ * Pair it with the menu it controls and keep the `open` prop in sync.
+ */
+declare const ButtonIconMenu: React.ForwardRefExoticComponent<ButtonIconMenuProps & React.RefAttributes<HTMLButtonElement>>;
+export { ButtonIconMenu };

package/dist/src/components/ui/button-icon-menu/index.d.ts

@@ -0,0 +1 @@
+export { ButtonIconMenu, type ButtonIconMenuProps } from './button-icon-menu';

package/dist/src/components/ui/button-menu/button-menu.d.ts

@@ -2,7 +2,7 @@ import { useRender } from '@base-ui/react/use-render';
 import { VariantProps } from 'class-variance-authority';
 import * as React from 'react';
 declare const buttonMenuVariants: (props?: ({
-    variant?: "primary" | "secondary" | null | undefined;
+    variant?: "secondary" | "primary" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
 export interface ButtonMenuProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'children'>, VariantProps<typeof buttonMenuVariants> {
     /**

package/dist/src/components/ui/calendar-panel/calendar-panel.d.ts

@@ -36,9 +36,9 @@ interface CalendarPanelSharedProps extends Omit<React.HTMLAttributes<HTMLDivElem
     onMonthChange?: (month: Date) => void;
     /** Days that cannot be selected. */
     disabled?: Matcher | Matcher[];
-    /** Minimum number of selectable days (`multiple` / `range`; ignored for `single`). */
+    /** Minimum count (`multiple` / `range`; ignored for `single`): for `multiple`, the number of selected dates; for `range`, the number of nights between start and end. */
     min?: number;
-    /** Maximum number of selectable days (`multiple` / `range`; ignored for `single`). */
+    /** Maximum count (`multiple` / `range`; ignored for `single`): for `multiple`, the number of selected dates; for `range`, the number of nights between start and end. */
     max?: number;
     /** Render the leading/trailing days of the adjacent months. */
     showOutsideDays?: boolean;

package/dist/src/components/ui/chip/chip.d.ts

@@ -1,7 +1,7 @@
 import { VariantProps } from 'class-variance-authority';
 import * as React from 'react';
 declare const chipVariants: (props?: ({
-    variant?: "removable" | "selectable" | null | undefined;
+    variant?: "removable" | "selectable" | "operational" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
 export interface ChipProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof chipVariants> {
     /** Optional leading icon, rendered at 16px before the label. */

package/dist/src/components/ui/date-range-picker/date-range-picker-utils.d.ts

@@ -1,32 +1,26 @@
+import { DayPickerLocale } from 'react-day-picker';
 /** A start/end date range. Both ends are optional (a partial range while editing). */
 export interface DateRange {
     from?: Date;
     to?: Date;
 }
-/** The date display / parse pattern used by the trigger and the editable fields. */
+/**
+ * The date display pattern used by the trigger. Fixed month-day-year order
+ * regardless of `locale` — only the month/day/era token *names* localize (see
+ * {@link formatDate}); true locale-aware reordering is a separate, bigger
+ * change (tracked, not done here).
+ */
 export declare const DISPLAY_FORMAT = "MMM d, yyyy";
 /**
  * Format a date with {@link DISPLAY_FORMAT}, returning `''` for a missing or
  * invalid `Date`. `date-fns`' `format` throws a `RangeError` on an invalid
  * `Date` (e.g. `new Date('garbage')`), so the `isValid` guard is load-bearing —
  * a truthy-but-invalid `Date` must not reach `format`.
- */
-export declare function formatDate(date: Date | undefined): string;
-/**
- * Parse a {@link DISPLAY_FORMAT} string into a `Date`, or `undefined` when the
- * text is empty, partial (mid-type), or not a real calendar date
- * (e.g. `"Feb 30, 2026"`). The result is normalized to the start of the day so
- * it round-trips with {@link formatDate} — `date-fns`' `parse` fills the unspecified
- * time-of-day from its reference date, which would otherwise leave a "now" time
- * on the value and break equality with the midnight dates the calendar emits.
  *
- * NOTE: the pattern is locale-fixed (US-style `MMM d, yyyy`), matching the
- * `InputDatePicker` trigger. Locale-aware parsing is not yet supported — a
- * known limitation to revisit once the design tier lands.
+ * `locale` only translates the month name via `date-fns`' `format` `options`
+ * — it does not reorder `DISPLAY_FORMAT`'s fixed month-day-year pattern.
  */
-export declare function parseDate(text: string): Date | undefined;
-/** Structural equality of two ranges by their endpoints' timestamps. */
-export declare function rangesEqual(a: DateRange, b: DateRange): boolean;
+export declare function formatDate(date: Date | undefined, locale?: DayPickerLocale): string;
 /**
  * Return a range whose `from` is never after its `to`. When both ends are set
  * and inverted (e.g. the user typed an end date earlier than the start), the two

package/dist/src/components/ui/date-range-picker/date-range-picker.d.ts

@@ -1,10 +1,11 @@
+import { DayPickerLocale, Matcher } from 'react-day-picker';
 import { DateRange } from './date-range-picker-utils';
 import * as React from 'react';
 export type { DateRange };
 export interface DateRangePickerProps {
     /** The applied range (controlled). Omit for uncontrolled use with `defaultValue`. */
     value?: DateRange;
-    /** The initial applied range (uncontrolled) and the target of "Reset to default". */
+    /** The initial applied range (uncontrolled). */
     defaultValue?: DateRange;
     /** Called with the committed range when Apply is pressed. */
     onValueChange?: (range: DateRange) => void;
@@ -20,8 +21,51 @@ export interface DateRangePickerProps {
     disabled?: boolean;
     /** Marks the trigger required. */
     required?: boolean;
-    /** Extra classes merged onto the trigger. */
+    /** Extra classes merged onto the trigger's field wrapper (label + box + message). */
     className?: string;
+    /** Days that cannot be selected in the calendar. */
+    disabledDays?: Matcher | Matcher[];
+    /** Minimum number of nights between the range's start and end (`differenceInCalendarDays(to, from)`) — e.g. `min={7}` requires at least 8 selectable days. */
+    min?: number;
+    /** Maximum number of nights between the range's start and end (`differenceInCalendarDays(to, from)`) — e.g. `max={31}` admits up to 32 selectable days. */
+    max?: number;
+    /** Render the leading/trailing days of the adjacent months. */
+    showOutsideDays?: boolean;
+    /**
+     * First day of the week (0 = Sunday). Defaults to `locale`'s own week
+     * start, falling back to Monday when no `locale` is given.
+     */
+    weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+    /**
+     * First year offered by the year dropdown and the earliest month the grid
+     * can navigate to. Defaults to 50 years back.
+     */
+    fromYear?: number;
+    /**
+     * Last year offered by the year dropdown and the latest month the grid can
+     * navigate to. Defaults to 50 years ahead.
+     */
+    toYear?: number;
+    /**
+     * Localizes weekday names, the calendar's default day-cell/caption
+     * accessible labels, and the trigger's month name (e.g. `import { es }
+     * from 'react-day-picker/locale'`). The trigger's day/year order stays
+     * fixed (`MMM d, yyyy`) — only the month name translates, not the
+     * ordering. Defaults to date-fns `enUS`. Does not translate `monthLabel`/
+     * `yearLabel`/`cancelLabel`/`applyLabel`/`formatMonthLabel` — those are
+     * separate props.
+     */
+    locale?: DayPickerLocale;
+    /** Accessible name of the calendar's month dropdown. */
+    monthLabel?: string;
+    /** Accessible name of the calendar's year dropdown. */
+    yearLabel?: string;
+    /** Formats a month's name for the month dropdown. Defaults to `locale`-aware `date-fns` formatting. */
+    formatMonthLabel?: (date: Date) => string;
+    /** Popup footer's "Cancel" button label. */
+    cancelLabel?: string;
+    /** Popup footer's "Apply" button label. */
+    applyLabel?: string;
 }
 declare const DateRangePicker: React.ForwardRefExoticComponent<DateRangePickerProps & React.RefAttributes<HTMLButtonElement>>;
 export { DateRangePicker };

package/dist/src/components/ui/dropdown-menu/dropdown-menu.d.ts

@@ -29,4 +29,11 @@ declare function DropdownMenuShortcut({ className, ...props }: React.HTMLAttribu
 declare namespace DropdownMenuShortcut {
     var displayName: string;
 }
-export { DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuPortal, };
+declare const DropdownMenuCheckboxItem: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').ContextMenuCheckboxItemProps, "ref"> & React.RefAttributes<HTMLElement>, "ref"> & React.RefAttributes<HTMLElement>>;
+declare const DropdownMenuRadioGroup: React.NamedExoticComponent<Omit<import('@base-ui/react').ContextMenuRadioGroupProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuRadioItem: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').ContextMenuRadioItemProps, "ref"> & React.RefAttributes<HTMLElement>, "ref"> & React.RefAttributes<HTMLElement>>;
+declare const DropdownMenuLabel: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSeparator: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+export { DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuCheckboxItem, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuLabel, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuPortal, };

package/dist/src/components/ui/dropdown-menu/index.d.ts

@@ -1 +1 @@
-export { DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuPortal, type DropdownMenuContentProps, } from './dropdown-menu';
+export { DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuCheckboxItem, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuLabel, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuPortal, type DropdownMenuContentProps, } from './dropdown-menu';

package/dist/src/components/ui/filter-chips/filter-chips.d.ts

@@ -0,0 +1,25 @@
+import { useRender } from '@base-ui/react/use-render';
+import * as React from 'react';
+export interface FilterChipsProps extends React.ComponentPropsWithoutRef<'div'> {
+    /**
+     * Replace the rendered `<div>` with another element or component
+     * (Base UI composition). Accepts a React element or a render function.
+     */
+    render?: useRender.RenderProp;
+    /** Accessible name for the applied-filter region. */
+    ariaLabel?: string;
+}
+declare const FilterChips: React.ForwardRefExoticComponent<FilterChipsProps & React.RefAttributes<HTMLDivElement>>;
+export type FilterChipsListProps = React.ComponentPropsWithoutRef<'div'>;
+declare const FilterChipsList: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export interface FilterChipsResetProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    /**
+     * Replace the rendered `<button>` with another element or component
+     * (Base UI composition). Accepts a React element or a render function.
+     */
+    render?: useRender.RenderProp;
+    /** Label for the reset action. */
+    children?: React.ReactNode;
+}
+declare const FilterChipsReset: React.ForwardRefExoticComponent<FilterChipsResetProps & React.RefAttributes<HTMLButtonElement>>;
+export { FilterChips, FilterChipsList, FilterChipsReset };

package/dist/src/components/ui/filter-chips/index.d.ts

@@ -0,0 +1 @@
+export { FilterChips, FilterChipsList, FilterChipsReset, type FilterChipsProps, type FilterChipsListProps, type FilterChipsResetProps, } from './filter-chips';

package/dist/src/components/ui/filter-search/filter-search.d.ts

@@ -1,3 +1,5 @@
+import { FilterChipsProps } from '../filter-chips';
+import { PopoverContent } from '../popover';
 import * as React from 'react';
 export type FilterSearchProps = React.ComponentPropsWithoutRef<'div'>;
 declare const FilterSearch: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
@@ -25,6 +27,12 @@ export interface FilterSearchFiltersProps extends Omit<React.ComponentPropsWitho
     onApply?: (filters: Record<string, unknown>) => void;
     /** Label for the filter trigger button. */
     label?: React.ReactNode;
+    /** Label for the "Reset filters" action inside the popover. */
+    resetFiltersLabel?: React.ReactNode;
+    /** Label for the "Cancel" action inside the popover. */
+    cancelLabel?: React.ReactNode;
+    /** Label for the "Apply" action inside the popover. */
+    applyLabel?: React.ReactNode;
     /**
      * Filter field children rendered inside the popover form. Plain children —
      * wire each field to the draft via `useFilterSearchFilters`. Group fields with
@@ -33,15 +41,45 @@ export interface FilterSearchFiltersProps extends Omit<React.ComponentPropsWitho
     children?: React.ReactNode;
     /** Additional classes merged onto the trigger button. */
     className?: string;
+    /** Additional classes merged onto the popover content. */
+    contentClassName?: string;
+    /** Which side of the trigger to render the popover on. Defaults to `'bottom'`. */
+    side?: React.ComponentProps<typeof PopoverContent>['side'];
+    /** Alignment of the popover along the chosen side. Defaults to `'start'`. */
+    align?: React.ComponentProps<typeof PopoverContent>['align'];
+    /** Distance in px between the trigger and the popover. */
+    sideOffset?: React.ComponentProps<typeof PopoverContent>['sideOffset'];
+    /**
+     * Portal container the popover mounts into. Defaults to the nearest
+     * `PortalContainerProvider`, or `document.body` if none is set — see
+     * `PopoverContent`'s `portalContainer` prop.
+     */
+    portalContainer?: React.ComponentProps<typeof PopoverContent>['portalContainer'];
+    /**
+     * Element/rect the popover is confined to when avoiding collisions. See
+     * `PopoverContent`'s `collisionBoundary` prop for the default behavior
+     * inside a constrained portal container.
+     */
+    collisionBoundary?: React.ComponentProps<typeof PopoverContent>['collisionBoundary'];
+    /**
+     * Which CSS `position` the popover uses. See `PopoverContent`'s
+     * `positionMethod` prop for the default behavior inside a constrained
+     * portal container.
+     */
+    positionMethod?: React.ComponentProps<typeof PopoverContent>['positionMethod'];
 }
 declare const FilterSearchFilters: React.ForwardRefExoticComponent<FilterSearchFiltersProps & React.RefAttributes<HTMLButtonElement>>;
-export interface FilterSearchAppliedFiltersProps extends Omit<React.ComponentPropsWithoutRef<'div'>, 'children'> {
+export interface FilterSearchAppliedFiltersProps extends Omit<FilterChipsProps, 'children'> {
     /** The currently applied filter values, keyed by an arbitrary consumer-chosen id. */
     filters: Record<string, unknown>;
     /** Called with the remaining filters when a chip is removed or "Reset filters" clears all. */
     onValueChange: (next: Record<string, unknown>) => void;
     /** Format an applied-filter chip's label. Defaults to `"<key>: <value>"`. */
     getFilterChipLabel?: (key: string, value: unknown) => React.ReactNode;
+    /** Format a filter chip's remove-button accessible label. Defaults to `"Remove <key> filter"`. */
+    getRemoveFilterLabel?: (key: string) => string;
+    /** Label for the "Reset filters" action. */
+    resetFiltersLabel?: React.ReactNode;
 }
 /**
  * Renders one removable chip per applied filter plus a "Reset filters" action

package/dist/src/components/ui/fitted-actions/fitted-actions.d.ts

@@ -0,0 +1,50 @@
+import * as React from 'react';
+/**
+ * Pure overflow math (no DOM). Greedily fits leading actions into
+ * `containerWidth - dropdownWidth`, accounting for the inter-item `gap`. Returns
+ * how many render inline; the rest overflow into the menu. Exported for testing.
+ */
+export declare function computeFittedVisibleCount({ containerWidth, itemWidths, dropdownWidth, gap, }: {
+    containerWidth: number;
+    itemWidths: number[];
+    dropdownWidth: number;
+    gap?: number;
+}): number;
+export interface FittedAction {
+    /** Stable identity. */
+    id: string;
+    /** Visible label (also the overflow menu-item label). */
+    label: React.ReactNode;
+    /** Optional leading 16px icon. */
+    icon?: React.ReactNode;
+    /** Set `false` to omit the action entirely. */
+    isDisplayed?: boolean;
+    /** Render a divider above this item when it sits in the overflow menu. */
+    divided?: boolean;
+    disabled?: boolean;
+    /** Invoked when this action is chosen (inline click or menu select). */
+    onSelect?: () => void;
+}
+export interface FittedActionsProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onSelect'> {
+    /** Ordered actions; trailing items overflow into the menu first. Defaults to `[]`. */
+    actions?: FittedAction[];
+    /** Collapse overflow into a "More" menu. Default true. */
+    showDropdown?: boolean;
+    /** Label for the overflow trigger. Default "More". */
+    moreLabel?: React.ReactNode;
+    /** Inter-item gap in px (also reserved when measuring). Default 8. */
+    gap?: number;
+    /** Fired for any chosen action, after its own `onSelect`. */
+    onAction?: (action: FittedAction) => void;
+    /** Customize the inline action element. Default: a ghost `Button`. */
+    renderAction?: (action: FittedAction, api: {
+        onSelect: () => void;
+        disabled?: boolean;
+    }) => React.ReactNode;
+    /** Customize the overflow trigger (used as the menu trigger's `render`). Default: a ghost `Button`. */
+    renderTrigger?: (api: {
+        label: React.ReactNode;
+    }) => React.ReactElement;
+}
+declare const FittedActions: React.ForwardRefExoticComponent<FittedActionsProps & React.RefAttributes<HTMLDivElement>>;
+export { FittedActions };

package/dist/src/components/ui/fitted-actions/fitted-actions.docs.d.ts

@@ -0,0 +1,45 @@
+import type * as React from 'react';
+/**
+ * Props for `FittedActions` — the responsive action row.
+ * Extends `div` props (excluding `onSelect`).
+ */
+export interface FittedActionsProps {
+    /** Ordered actions; trailing items overflow into the menu first. Defaults to `[]`. */
+    actions?: FittedAction[];
+    /** Collapse overflow into a "More" menu. Default `true`. */
+    showDropdown?: boolean;
+    /** Label for the overflow trigger. Default `"More"`. */
+    moreLabel?: React.ReactNode;
+    /** Inter-item gap in px (also reserved when measuring). Default `8`. */
+    gap?: number;
+    /** Fired for any chosen action, after its own `onSelect`. */
+    onAction?: (action: FittedAction) => void;
+    /** Customize the inline action element. Default: a ghost `Button`. */
+    renderAction?: (action: FittedAction, api: {
+        onSelect: () => void;
+        disabled?: boolean;
+    }) => React.ReactNode;
+    /** Customize the overflow trigger (used as the menu trigger's `render`). Default: a ghost `Button`. */
+    renderTrigger?: (api: {
+        label: React.ReactNode;
+    }) => React.ReactElement;
+    /** Extra classes merged onto the root `<div>`. */
+    className?: string;
+}
+/** A single action in the `FittedActions` bar. */
+export interface FittedAction {
+    /** Stable identity — used as React key. */
+    id: string;
+    /** Visible label (also the overflow menu-item label). */
+    label: React.ReactNode;
+    /** Optional leading 16px icon rendered before the label. */
+    icon?: React.ReactNode;
+    /** Set `false` to omit the action entirely without removing it from the array. */
+    isDisplayed?: boolean;
+    /** Render a divider above this item when it appears in the overflow menu. */
+    divided?: boolean;
+    /** Disables the action (inline button and overflow menu item both become inert). */
+    disabled?: boolean;
+    /** Invoked when this action is chosen — inline click or overflow menu select. */
+    onSelect?: () => void;
+}

package/dist/src/components/ui/fitted-actions/index.d.ts

@@ -0,0 +1 @@
+export { FittedActions, computeFittedVisibleCount, type FittedAction, type FittedActionsProps, } from './fitted-actions';

package/dist/src/components/ui/link/index.d.ts

@@ -1 +1 @@
-export { Link, type LinkProps } from './link';
+export { Link, linkVariants, type LinkProps } from './link';

package/dist/src/components/ui/link/link.d.ts

@@ -1,9 +1,27 @@
 import { useRender } from '@base-ui/react/use-render';
+import { VariantProps } from 'class-variance-authority';
 import * as React from 'react';
-export interface LinkProps extends React.AnchorHTMLAttributes<HTMLAnchorElement> {
-    /** Append a trailing external-link icon (e.g. for links that leave the app). */
+declare const linkVariants: (props?: ({
+    variant?: "normal" | "inverse" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface LinkProps extends React.AnchorHTMLAttributes<HTMLAnchorElement>, VariantProps<typeof linkVariants> {
+    /**
+     * Which surface the link sits on (Figma's `background`): `normal` for ordinary
+     * surfaces, `inverse` for a backdrop/scrim or other dark brand surface.
+     */
+    variant?: 'normal' | 'inverse';
+    /**
+     * Append a trailing external-link icon (e.g. for links that leave the app).
+     * Has no effect on `variant="inverse"` — the design defines no external icon for
+     * links on a backdrop.
+     */
     external?: boolean;
-    /** Render the link inert: disabled color, removed from the tab order, no navigation. */
+    /**
+     * Render the link inert: disabled color, removed from the tab order, no navigation.
+     * Ignored entirely on `variant="inverse"` — the design defines no disabled state on
+     * a backdrop, so the link renders exactly as an enabled one (still navigable and
+     * focusable). Omit the link, or use `variant="normal"`, when you need it inert.
+     */
     disabled?: boolean;
     /**
      * Replace the rendered `<a>` with another element or component (Base UI
@@ -12,4 +30,4 @@ export interface LinkProps extends React.AnchorHTMLAttributes<HTMLAnchorElement>
     render?: useRender.RenderProp;
 }
 declare const Link: React.ForwardRefExoticComponent<LinkProps & React.RefAttributes<HTMLAnchorElement>>;
-export { Link };
+export { Link, linkVariants };

package/dist/src/components/ui/metric/metric.d.ts

@@ -2,7 +2,7 @@ import { VariantProps } from 'class-variance-authority';
 import * as React from 'react';
 declare const metricVariants: (props?: ({
     size?: "small" | "medium" | "large" | null | undefined;
-    status?: "info" | "success" | "warning" | "critical" | "neutral" | "danger" | null | undefined;
+    status?: "info" | "success" | "warning" | "critical" | "danger" | "neutral" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
 export interface MetricProps extends React.ComponentProps<'div'>, VariantProps<typeof metricVariants> {
     /** What the value measures — e.g. "Gross margin". Rendered as an uppercase note heading. */

package/dist/src/components/ui/popover/popover.d.ts

@@ -17,11 +17,40 @@ export interface PopoverContentProps extends React.ComponentPropsWithoutRef<type
     portal?: boolean;
     /**
      * Portal container. Pass a shadow-root mount for isolated-style previews
-     * (the docs demos do this via `useShadowMount`).
+     * (the docs demos do this via `useShadowMount`), or a constrained
+     * MFE/Shadow DOM mount point (see `PortalContainerProvider`).
      */
     portalContainer?: PopoverPrimitive.Portal.Props['container'];
     /** Keep the content mounted while closed (Base UI `Portal` prop). */
     keepMounted?: PopoverPrimitive.Portal.Props['keepMounted'];
+    /**
+     * Element/rect the popup is confined to when avoiding collisions. Defaults
+     * to Base UI's own `'clipping-ancestors'` behavior — left alone here,
+     * since pairing it with the `positionMethod` default below already avoids
+     * clipping inside a constrained `portalContainer` (see that prop's doc).
+     * Override explicitly if a different boundary is needed.
+     */
+    collisionBoundary?: PopoverPrimitive.Positioner.Props['collisionBoundary'];
+    /**
+     * Which CSS `position` the popup uses. Defaults to `'fixed'` whenever the
+     * popup is portaled (`portal` is not `false`) into a resolved
+     * `portalContainer` — an `'absolute'`-positioned popup
+     * (Base UI's own default) is still clipped by a `portalContainer` ancestor
+     * that constrains overflow (e.g. a Shadow DOM host with `overflow: hidden`)
+     * no matter how the collision boundary is computed, since it shares that
+     * ancestor's containing block. `'fixed'` escapes a plain overflow-clipping
+     * ancestor — for a `fixed`-positioned popup, the collision-detection
+     * library (floating-ui) drops overflow ancestors that don't establish
+     * their own containing block, so it clips against the real viewport
+     * instead, which is also unaffected by page scroll (unlike measuring
+     * `document.documentElement`'s own bounding rect, which shrinks by the
+     * scroll offset). Note this is not an absolute guarantee: an ancestor with
+     * `transform`, `filter`, `will-change`, `backdrop-filter`, `perspective`,
+     * or `contain: paint`/`layout` *does* establish a containing block, so it
+     * still clips (and repositions relative to) a `fixed` descendant. Override
+     * explicitly if a different strategy is needed.
+     */
+    positionMethod?: PopoverPrimitive.Positioner.Props['positionMethod'];
 }
 declare const PopoverContent: React.ForwardRefExoticComponent<PopoverContentProps & React.RefAttributes<HTMLDivElement>>;
 /**