prime-ui-kit 0.9.3 → 0.11.0

package/dist/components/digit-input/DigitInput.d.ts

@@ -1,5 +1,5 @@
-import { type FieldFrameProps, type FieldRootDomProps } from "@/internal/FieldFrame";
-import type { ControlSize } from "@/internal/states";
+import { type FieldFrameProps, type FieldRootDomProps } from "../../internal/FieldFrame";
+import type { ControlSize } from "../../internal/states";
 export type DigitInputLabels = {
     /** Accessible name of the group when there is no visible `label`. */
     group: string;
@@ -7,6 +7,8 @@ export type DigitInputLabels = {
     cell: string;
     /** Muted marker after the label when `optional`. */
     optional: string;
+    /** The error of a code whose `onComplete` promise rejected without a reason. */
+    failed: string;
 };
 export type DigitInputProps = FieldRootDomProps & FieldFrameProps & {
     /** Number of cells. */
@@ -29,8 +31,13 @@ export type DigitInputProps = FieldRootDomProps & FieldFrameProps & {
     value?: string;
     defaultValue?: string;
     onValueChange?: (value: string) => void;
-    /** Called once when the last empty cell is filled. */
-    onComplete?: (value: string) => void;
+    /**
+     * Called once when the last empty cell is filled. Return the check's promise: the cells wait
+     * read-only and quiet (`aria-busy`); resolve — the `success` look; reject — the code clears,
+     * the field shakes in the reason (the rejection's message, else `labels.failed`) as its error,
+     * and the reason is announced. Typing again takes the error away.
+     */
+    onComplete?: (value: string) => void | Promise<void>;
     disabled?: boolean;
     /** Invalid state: danger ring on every cell. A non-empty `error` implies it. */
     invalid?: boolean;
@@ -45,4 +52,4 @@ export type DigitInputProps = FieldRootDomProps & FieldFrameProps & {
     labels?: Partial<DigitInputLabels>;
 };
 /** A one-time code or PIN split into cells, with the field label, hint and error. */
-export declare function DigitInput({ length, size: sizeProp, fullWidth, name, groupSize, mask, autoFocus, value: valueProp, defaultValue, onValueChange, onComplete, disabled, invalid, success, focusRing, label, required, optional, hint, error, id, "aria-describedby": ariaDescribedBy, labels: labelsProp, className, ...rest }: DigitInputProps): import("react/jsx-runtime").JSX.Element;
+export declare function DigitInput({ length, size: sizeProp, fullWidth, name, groupSize, mask, autoFocus, value: valueProp, defaultValue, onValueChange, onComplete, disabled: disabledProp, invalid, success, focusRing, label, required, optional, hint, error, id, "aria-describedby": ariaDescribedBy, labels: labelsProp, className, ...rest }: DigitInputProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/divider/Divider.d.ts

@@ -1,5 +1,5 @@
 import type * as React from "react";
-import type { ControlSize } from "@/internal/states";
+import type { ControlSize } from "../../internal/states";
 export type DividerOrientation = "horizontal" | "vertical";
 export type DividerAlign = "start" | "center" | "end";
 export type DividerProps = React.HTMLAttributes<HTMLDivElement> & {

package/dist/components/dnd/Dnd.d.ts

@@ -2,10 +2,8 @@ import * as React from "react";
 import { type DragItem, type DragOutcome } from "./dragSession";
 import { type Point, type Rect } from "./geometry";
 import { type DndLabels } from "./labels";
-import { type ReorderReturn } from "./useSortableList";
 export type { DragItem, DragOutcome } from "./dragSession";
 export type { DndLabels } from "./labels";
-export type { DndReorderResult } from "./useSortableList";
 export type DndRootProps = {
     /** Built-in strings (live region, handle, role description). Russian defaults. */
     labels?: Partial<DndLabels>;
@@ -24,7 +22,7 @@ export type DndHandleProps = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>,
 };
 /**
  * The grip of a `handle` item: a ghost icon-only Button (`xs`), so it is reachable by keyboard
- * (Alt+arrows reorder).
+ * (Alt+arrows reorder). In a `locked` item it is a lock (`labels.locked`) instead.
  */
 declare function DndHandle({ className, "aria-label": ariaLabel, ref, ...rest }: DndHandleProps): import("react/jsx-runtime").JSX.Element;
 declare namespace DndHandle {
@@ -37,34 +35,56 @@ export type DndSortableProps<T> = Omit<React.HTMLAttributes<HTMLElement>, "child
     getId: (item: T) => string;
     /** Spoken by the live region ("Задача 3: позиция 2 из 5"). Defaults to the id. */
     getLabel?: (item: T) => string;
-    /** Called when an item lands in front of `beforeId` (`null` = last). Return `{ ok: false }` (or reject) to roll the drawn order back. */
-    onReorder: (id: string, beforeId: string | null) => ReorderReturn | Promise<ReorderReturn>;
-    /** Renders one item; return a `Dnd.SortableItem`. */
+    /**
+     * Called when an item lands in front of `beforeId` (`null` = last). A returned promise keeps the
+     * item drawn in its new place until it settles; a rejection glides it back.
+     */
+    onReorder: (id: string, beforeId: string | null) => void | Promise<void>;
+    /**
+     * Renders one item; return a `Dnd.SortableItem`. During a drag `index` is the place the item will
+     * have on release. Parts marked `data-dnd-mirror` stay in step on the carried copy.
+     */
     renderItem: (item: T, index: number) => React.ReactNode;
-    /** Layout direction of the list. */
-    axis?: "x" | "y";
+    /** Layout of the list: a column, a row, or a wrapping grid (reading order, Alt + ← / →). */
+    axis?: "x" | "y" | "grid";
     /** Only `Dnd.Handle` starts a drag; the rest of the item stays free for clicks and text selection. */
     handle?: boolean;
     disabled?: boolean;
     /**
      * Drag kind. Lists sharing a `kind` exchange items: an item dropped from another list arrives in
-     * `onReorder` with an `id` that is not in `items` (move it into this list). Defaults to a unique
-     * value per list, so lists stay separate.
+     * `onReorder` with an `id` that is not in `items` (move it into this list), and Alt + the arrows
+     * across the axis move an item to the neighbouring list of the kind (document order). Defaults to
+     * a unique value per list, so lists stay separate.
      */
     kind?: string;
-    /** Refuses an item (by id) the list would otherwise take; the list turns `danger` before the release. */
-    canDrop?: (id: string) => boolean;
-    /** Root element: `ul` / `ol` turn items into `li`. */
-    as?: "div" | "ul" | "ol";
+    /**
+     * Refuses an item (by id) the list would otherwise take: `false`, or a string that says why — it
+     * is spoken and shown under the carried copy. The list turns `danger` before the release.
+     */
+    canDrop?: (id: string) => boolean | string;
+    /** Shown while the list has no items; a gap opening in the list takes its place. */
+    empty?: React.ReactNode;
+    /**
+     * Root element: `ul` / `ol` turn items into `li`; `tbody` turns them into table rows (`tr`), the
+     * gap into a row across every column, and the carried copy keeps every cell's width.
+     */
+    as?: "div" | "ul" | "ol" | "tbody";
     /** Accessible name of the list. */
     "aria-label"?: string;
+    /**
+     * Content in front of the items that never moves and takes no drop position (the heading row of
+     * a group of table rows).
+     */
+    header?: React.ReactNode;
+    /** Content after the items that never moves and takes no drop position (an add tile). */
+    children?: React.ReactNode;
     ref?: React.Ref<HTMLElement>;
 };
 /**
  * A reorderable list: pointer drag with a gap where the item lands, neighbours that glide aside, an
  * optimistic order, auto-scroll near the edges and an Alt+arrow keyboard path.
  */
-declare function DndSortable<T>({ items, getId, getLabel, onReorder, renderItem, axis, handle, disabled, kind, canDrop, as: Tag, className, ref: forwardedRef, ...rest }: DndSortableProps<T>): import("react/jsx-runtime").JSX.Element;
+declare function DndSortable<T>({ items, getId, getLabel, onReorder, renderItem, axis, handle, disabled, kind, canDrop, empty, as: Tag, header, className, children: trailing, ref: forwardedRef, ...rest }: DndSortableProps<T>): import("react/jsx-runtime").JSX.Element;
 declare namespace DndSortable {
     var displayName: string;
 }
@@ -72,12 +92,17 @@ export type DndSortableItemProps = {
     /** Must match `getId` of the item. */
     id: string;
     disabled?: boolean;
+    /**
+     * Holds its place: it does not drag or move, and nothing is put where it would shift it (a
+     * pinned first row, a system column). Its `Dnd.Handle` shows a lock.
+     */
+    locked?: boolean;
     className?: string;
     children?: React.ReactNode;
     ref?: React.Ref<HTMLElement>;
 } & Omit<React.HTMLAttributes<HTMLElement>, "id">;
-/** One item of a `Dnd.Sortable`. Renders `li` inside `ul` / `ol`, `div` otherwise. */
-declare function DndSortableItem({ id, disabled: itemDisabled, className, children, onPointerDown, onKeyDown, ref, ...rest }: DndSortableItemProps): import("react/jsx-runtime").JSX.Element;
+/** One item of a `Dnd.Sortable`. Renders `li` inside `ul` / `ol`, `tr` inside `tbody`, `div` otherwise. */
+declare function DndSortableItem({ id, disabled: itemDisabled, locked, className, children, onPointerDown, onKeyDown, onDragStart, ref, ...rest }: DndSortableItemProps): import("react/jsx-runtime").JSX.Element;
 declare namespace DndSortableItem {
     var displayName: string;
 }
@@ -100,7 +125,7 @@ export type DndDraggableProps<TData = unknown> = {
     ref?: React.Ref<HTMLElement>;
 } & Omit<React.HTMLAttributes<HTMLElement>, "id">;
 /** Something to carry onto a `Dnd.DropZone`. The source stays in place, faded, until the drop. */
-declare function DndDraggable<TData = unknown>({ kind, id, data, label, disabled, handle, as: Tag, onDragStart, onDragEnd, className, children, onPointerDown, ref, ...rest }: DndDraggableProps<TData>): import("react/jsx-runtime").JSX.Element;
+declare function DndDraggable<TData = unknown>({ kind, id, data, label, disabled, handle, as: Tag, onDragStart, onDragEnd, className, children, onPointerDown, onDragStartCapture, ref, ...rest }: DndDraggableProps<TData>): import("react/jsx-runtime").JSX.Element;
 declare namespace DndDraggable {
     var displayName: string;
 }
@@ -108,8 +133,11 @@ export type DndDropZoneProps<TData = unknown> = {
     /** Drag kinds this zone takes, or a predicate over the dragged item. */
     accepts: string | readonly string[] | ((item: DragItem) => boolean);
     onDrop: (item: DragItem<TData>) => void;
-    /** Refuses an item the zone would otherwise take; the zone turns `danger` before the release. */
-    canDrop?: (item: DragItem<TData>) => boolean;
+    /**
+     * Refuses an item the zone would otherwise take: `false`, or a string that says why (spoken and
+     * shown under the carried copy). The zone turns `danger` before the release.
+     */
+    canDrop?: (item: DragItem<TData>) => boolean | string;
     onEnter?: (item: DragItem<TData>) => void;
     onLeave?: () => void;
     /** Flashes the zone after a drop, so the eye can follow where the item went. */

package/dist/components/dnd/dragSession.d.ts

@@ -26,10 +26,21 @@ export type DragSnapshot = {
      */
     heldId: string | null;
     canDrop: boolean;
+    /** Why the target under the pointer refuses the item (its `canDrop` answered a string), or null. */
+    reason: string | null;
     /** The rect the lifted element occupied when the drag began: the size of the gap a list opens for it. */
     origin: Rect | null;
     /** Where inside that rect the pointer grabbed it. */
     grab: Point | null;
+    /**
+     * The size the carried copy is drawn at when a grid list fits it to the cell it would land in (a
+     * cover carried into a row of tiles shrinks); null — the origin's size. The grab point keeps its
+     * place relative to the copy.
+     */
+    carried: {
+        width: number;
+        height: number;
+    } | null;
     /** The lifted element's `border-radius`, so the gap it leaves is shaped like it. */
     radius: string | null;
     /** The live region text; `sequence` makes a repeated message count as new for assistive technology. */
@@ -39,6 +50,11 @@ export type DragSnapshot = {
     };
 };
 export declare const IDLE_SNAPSHOT: DragSnapshot;
+/**
+ * A target's answer for the item at a spot: `true` takes it; `false` refuses; a string refuses and
+ * says why (spoken by the live region, shown by the carried copy).
+ */
+export type DropVerdict = boolean | string;
 export type DropTargetEntry = {
     id: string;
     element: HTMLElement;
@@ -46,8 +62,8 @@ export type DropTargetEntry = {
     /** Keeps the drop while the pointer crosses empty space (the gutter between two lists). */
     holdsDrop: boolean;
     enter: (item: DragItem) => void;
-    /** Called on every resolved pointer position; returns whether a drop here would be accepted. */
-    over: (point: Point, item: DragItem) => boolean;
+    /** Called on every resolved pointer position; whether a drop here would be accepted, or why not. */
+    over: (point: Point, item: DragItem) => DropVerdict;
     leave: () => void;
     drop: (point: Point, item: DragItem) => void;
     /** Drops where the pointer was last over this target: the release came over empty space. */
@@ -68,6 +84,10 @@ export type DragOverlayEvent = {
 } | {
     type: "move";
     point: Point;
+} | {
+    type: "resize";
+    width: number;
+    height: number;
 } | {
     type: "end";
     item: DragItem;
@@ -97,6 +117,11 @@ export type DragController = {
     labels: () => DndLabels;
     cancel: () => void;
     subscribeOverlay: (listener: (event: DragOverlayEvent) => void) => () => void;
+    /** Fits the carried copy to the cell it would land in (a grid list of mixed cells). */
+    resizeCarried: (size: {
+        width: number;
+        height: number;
+    }) => void;
     destroy: () => void;
 };
 export declare function createDragController(getLabels?: () => DndLabels): DragController;

package/dist/components/dnd/geometry.d.ts

@@ -10,18 +10,26 @@ export type Rect = {
     width: number;
     height: number;
 };
-export type Axis = "x" | "y";
+/** `grid`: items wrap into rows (reading order: row by row, start to end inside a row). */
+export type Axis = "x" | "y" | "grid";
 export declare function rectOf(element: Element): Rect;
 /**
- * Where an element sits in the layout with any animation transform taken back out. Every drop
- * decision is measured against this: reading the drawn position makes each answer depend on the
- * animation the previous answer started, and the gap flickers under a pointer that barely moves.
+ * Where an element sits in the layout with any animation transform taken back out — its glide and
+ * its growth (a tile growing into the cover cell is drawn smaller until it gets there). Every drop
+ * decision is measured against this: reading the drawn box makes each answer depend on the
+ * animation the previous answer started, and the gap swings between cells under a pointer that
+ * barely moves.
  */
 export declare function layoutRect(element: Element): Rect;
 export declare function rectContains(rect: Rect, point: Point): boolean;
 export declare function distanceBetween(a: Point, b: Point): number;
 /** Marks the gap a sortable list opens where the dragged item will land. */
 export declare const DROP_GAP_SELECTOR = "[data-dnd-gap]";
+/**
+ * The nodes matching `selector` that belong to `container` itself: a list nested inside one of its
+ * items (cards inside a column of a board) keeps its own items and gap.
+ */
+export declare function ownNodes(container: Element, selector: string): HTMLElement[];
 /**
  * The item a dragged one would land in front of: the first whose midline is past the pointer, or
  * `null` for "after every item". Measured in the layout the list would have WITHOUT the gap, so the

package/dist/components/dnd/labels.d.ts

@@ -1,7 +1,12 @@
-/** System strings of the drag-and-drop layer. `{label}`, `{position}`, `{total}` are substituted. */
+/**
+ * System strings of the drag-and-drop layer. `{label}`, `{position}`, `{total}`, `{list}`,
+ * `{reason}` are substituted.
+ */
 export type DndLabels = {
     /** `aria-label` of `Dnd.Handle`. */
     handle: string;
+    /** Name of the lock a `Dnd.Handle` shows in a `locked` item. */
+    locked: string;
     /** `aria-roledescription` of every draggable element. */
     roleDescription: string;
     /** Live region: an item was picked up. */
@@ -14,5 +19,11 @@ export type DndLabels = {
     cancelled: string;
     /** Live region: an item was moved with the keyboard. */
     moved: string;
+    /** Live region: an item was moved to a linked list with the keyboard: `{list}` is its name. */
+    movedTo: string;
+    /** Live region: a linked list refused an item moved with the keyboard. */
+    refused: string;
+    /** Live region: a target refused the item and said why (`canDrop` answered a string). */
+    refusedReason: string;
 };
 export declare const defaultDndLabels: DndLabels;

package/dist/components/dnd/useDragSource.d.ts

@@ -9,6 +9,8 @@ export type DragSourceItem<TData> = {
 };
 export type DragSourceProps = {
     "data-dnd-item": string;
+    /** The drag kind: ids are unique only within a kind (two boards may share card ids). */
+    "data-dnd-kind": string;
     "data-dragging"?: true | undefined;
     "aria-roledescription"?: string | undefined;
     onPointerDown: (event: React.PointerEvent<HTMLElement>) => void;

package/dist/components/dnd/useDropTarget.d.ts

@@ -1,13 +1,16 @@
 import * as React from "react";
-import type { DragItem } from "./dragSession";
+import type { DragItem, DropVerdict } from "./dragSession";
 import type { Point } from "./geometry";
 export type DropTargetOptions<TValue, TData = unknown> = {
     /** Which drag kinds this target answers to. */
     accepts: string | readonly string[] | ((item: DragItem) => boolean);
     /** Turns a pointer position into what a drop here would mean (an insertion point, a slot number). `null` means "not over anything droppable". */
     resolve: (point: Point, item: DragItem<TData>, element: HTMLElement) => TValue | null;
-    /** Whether the resolved spot will take this item. Separate from `resolve` so a preview can still be drawn where the refusal is. */
-    canDrop?: ((value: TValue, item: DragItem<TData>) => boolean) | undefined;
+    /**
+     * Whether the resolved spot will take this item; a string refuses and says why. Separate from
+     * `resolve` so a preview can still be drawn where the refusal is.
+     */
+    canDrop?: ((value: TValue, item: DragItem<TData>) => DropVerdict) | undefined;
     onDrop: (value: TValue, item: DragItem<TData>) => void;
     disabled?: boolean | undefined;
     /**

package/dist/components/dnd/useFlipList.d.ts

@@ -1,11 +1,17 @@
 /**
  * WAAPI timing from the motion tokens (`--prime-motion-duration-<token>`,
  * `--prime-motion-easing-<curve>`), read at animation time so theme and app overrides apply;
- * WAAPI cannot take `var()`.
+ * WAAPI cannot take `var()`. Read once per frame: a computed style read of the root forces a style
+ * pass, and each list of a board would otherwise force its own after the previous list's glides.
  */
 export declare function motionTiming(duration: "fast" | "base", curve?: "standard" | "enter" | "exit"): KeyframeAnimationOptions;
 /**
  * Animates layout changes of list items (`data-dnd-item`) and of the gap (`data-dnd-gap`) from the position currently on screen. Hit testing still uses
  * `layoutRect`, so visual easing never changes a drop decision.
  */
-export declare function useFlipList(container: HTMLElement | null, layoutKey: string, selector: string, enabled: boolean): void;
+export declare function useFlipList(container: HTMLElement | null, layoutKey: string, selector: string, enabled: boolean, 
+/**
+ * A new value animates this layout change with no drag in flight: a keyboard move, or a drop the
+ * owner refused gliding back.
+ */
+settle?: number): void;

package/dist/components/dnd/useSortableList.d.ts

@@ -1,4 +1,5 @@
 import * as React from "react";
+import type { DropVerdict } from "./dragSession";
 import { type Axis } from "./geometry";
 import { type DragSourceProps } from "./useDragSource";
 import { type DropTargetProps } from "./useDropTarget";
@@ -11,21 +12,22 @@ export type InsertionPoint = {
     before: string | null;
     moves: boolean;
 };
-/** What a caller's own write may answer. Answering is optional; `{ ok: false }` rolls the drawn order back at once. */
-export type DndReorderResult = {
-    ok: boolean;
-} | undefined;
-export type ReorderReturn = DndReorderResult | void;
 export type SortableListOptions = {
     kind: string;
+    /**
+     * The list shares its `kind` on purpose: Alt + the arrows across the axis move an item to the
+     * neighbouring list of the same kind (a board's columns).
+     */
+    linked?: boolean | undefined;
     /** The ids in the order they are drawn. */
     items: readonly string[];
     labelOf: (id: string) => string;
-    onReorder: (id: string, beforeId: string | null) => ReorderReturn | Promise<ReorderReturn>;
+    /** A returned promise keeps the move drawn until it settles; a rejection glides it back. */
+    onReorder: (id: string, beforeId: string | null) => void | Promise<void>;
     axis?: Axis | undefined;
     disabled?: boolean | undefined;
-    /** Refuses an item of this kind (typically one from another list); the container turns `danger` before the release. */
-    canDrop?: ((id: string) => boolean) | undefined;
+    /** Refuses an item of this kind (typically one from another list); a string says why. */
+    canDrop?: ((id: string) => DropVerdict) | undefined;
     /** Only a press on a `[data-dnd-handle]` element starts a drag. */
     handleOnly?: boolean | undefined;
 };
@@ -56,7 +58,8 @@ export type SortableListHandle = {
 export declare function moveBefore<T>(items: readonly T[], id: string, beforeId: string | null, getId: (item: T) => string): T[];
 /**
  * Reordering, complete: the pointer drag, the gap that opens where the item will land, the settle
- * animation, and an Alt+arrow path for anyone who cannot drag (WCAG 2.2 "Dragging Movements").
- * The list container is the drop target, not each item: items come and go mid-drag.
+ * animation, and an Alt+arrow path for anyone who cannot drag (WCAG 2.2 "Dragging Movements") —
+ * along the list, and across to the neighbouring list of a linked kind. Locked items hold their
+ * places. The list container is the drop target, not each item: items come and go mid-drag.
  */
 export declare function useSortableList(options: SortableListOptions): SortableListHandle;

package/dist/components/drawer/Drawer.d.ts

@@ -1,9 +1,11 @@
 import * as React from "react";
-import { DialogBody, DialogClose, DialogDescription, DialogFooter, DialogHeader, DialogIcon, DialogTitle, DialogTrigger } from "@/components/modal/DialogParts";
-import type { ControlSize } from "@/internal/states";
-export type { DialogBodyProps as DrawerBodyProps, DialogCloseProps as DrawerCloseProps, DialogDescriptionProps as DrawerDescriptionProps, DialogFooterProps as DrawerFooterProps, DialogHeaderProps as DrawerHeaderProps, DialogIconProps as DrawerIconProps, DialogTitleProps as DrawerTitleProps, DialogTriggerProps as DrawerTriggerProps, } from "@/components/modal/DialogParts";
-export type DrawerSide = "left" | "right" | "bottom";
-export type DrawerLabels = {
+import { DialogGuard } from "../modal/DialogGuard";
+import { DialogActions, DialogBody, DialogClose, DialogDescription, type DialogDiscardLabels, DialogFooter, DialogHeader, DialogIcon, DialogMeta, DialogTitle, DialogTrigger } from "../modal/DialogParts";
+import type { ControlSize } from "../../internal/states";
+export type { DialogGuardProps as DrawerGuardProps } from "../modal/DialogGuard";
+export type { DialogActionsProps as DrawerActionsProps, DialogBodyProps as DrawerBodyProps, DialogCloseProps as DrawerCloseProps, DialogDescriptionProps as DrawerDescriptionProps, DialogFooterProps as DrawerFooterProps, DialogHeaderProps as DrawerHeaderProps, DialogIconProps as DrawerIconProps, DialogMetaProps as DrawerMetaProps, DialogTitleProps as DrawerTitleProps, DialogTriggerProps as DrawerTriggerProps, } from "../modal/DialogParts";
+export type DrawerSide = "left" | "right";
+export type DrawerLabels = DialogDiscardLabels & {
     /** `aria-label` of the header close button. */
     close: string;
 };
@@ -13,7 +15,7 @@ export type DrawerRootProps = {
     onOpenChange?: (open: boolean) => void;
     /** Escape closes the drawer. Default `true`. */
     closeOnEscape?: boolean;
-    /** A click on the scrim or a swipe toward the edge closes the drawer. Default `true`. */
+    /** A click on the scrim closes the drawer. Default `true`. */
     closeOnOutsideClick?: boolean;
     labels?: Partial<DrawerLabels>;
     children?: React.ReactNode;
@@ -23,19 +25,16 @@ declare namespace DrawerRoot {
     var displayName: string;
 }
 export type DrawerContentProps = React.HTMLAttributes<HTMLDivElement> & {
-    /** Edge the panel slides from; `bottom` is a sheet with a grab handle. Default `right`. */
+    /** Edge the panel slides from. Default `right`. */
     side?: DrawerSide;
-    /**
-     * Panel width: `s` 360 · `m` 480 · `l` 640 · `xl` 800 (a bottom sheet is centred). Full width
-     * below 640px of viewport.
-     */
+    /** Panel width: `s` 360 · `m` 480 · `l` 640 · `xl` 800. Full width below 640px of viewport. */
     size?: Exclude<ControlSize, "xs">;
     /** Class on the full-screen scrim. */
     overlayClassName?: string;
     /** The `role="dialog"` panel. */
     ref?: React.Ref<HTMLDivElement>;
 };
-declare function DrawerContent(props: DrawerContentProps): import("react/jsx-runtime").JSX.Element | null;
+declare function DrawerContent({ children, ...props }: DrawerContentProps): import("react/jsx-runtime").JSX.Element | null;
 declare namespace DrawerContent {
     var displayName: string;
 }
@@ -47,7 +46,10 @@ export declare const Drawer: {
     Icon: typeof DialogIcon;
     Title: typeof DialogTitle;
     Description: typeof DialogDescription;
+    Actions: typeof DialogActions;
     Body: typeof DialogBody;
     Footer: typeof DialogFooter;
+    Meta: typeof DialogMeta;
     Close: typeof DialogClose;
+    Guard: typeof DialogGuard;
 };

package/dist/components/dropdown/Dropdown.d.ts

@@ -1,7 +1,7 @@
 import * as React from "react";
-import type { PositionAlign, PositionSide } from "@/hooks/usePosition";
-import { type MenuGroupProps } from "@/internal/MenuGroup";
-import type { ControlSize, Tone } from "@/internal/states";
+import { type PositionAlign, type PositionSide } from "../../hooks/usePosition";
+import { type MenuGroupProps } from "../../internal/MenuGroup";
+import type { ControlSize, Tone } from "../../internal/states";
 export type DropdownRootProps = {
     open?: boolean;
     defaultOpen?: boolean;
@@ -45,9 +45,15 @@ export type DropdownItemProps = Omit<React.ButtonHTMLAttributes<HTMLButtonElemen
     disabled?: boolean;
     /** `danger` — destructive action (delete, revoke). */
     tone?: Extract<Tone, "neutral" | "danger">;
+    /**
+     * The item is its single child, a link (`<a href>`, a router `Link`): the item props merge onto
+     * it, so Cmd / Ctrl-click and «open in a new tab» work. Its children are the item content.
+     */
+    asChild?: boolean;
+    /** The item element: `<button>`, or the `asChild` element. */
     ref?: React.Ref<HTMLButtonElement>;
 };
-declare function DropdownItem({ onSelect, disabled, tone, className, onClick, ...rest }: DropdownItemProps): import("react/jsx-runtime").JSX.Element;
+declare function DropdownItem({ onSelect, disabled, tone, asChild, className, onClick, children, ref, ...rest }: DropdownItemProps): import("react/jsx-runtime").JSX.Element;
 declare namespace DropdownItem {
     var displayName: string;
 }
@@ -87,6 +93,18 @@ declare function DropdownItemShortcut({ className, ...rest }: DropdownItemShortc
 declare namespace DropdownItemShortcut {
     var displayName: string;
 }
+export type DropdownItemDescriptionProps = Omit<React.HTMLAttributes<HTMLSpanElement>, "id"> & {
+    children: React.ReactNode;
+    ref?: React.Ref<HTMLSpanElement>;
+};
+/**
+ * Muted second line of an item, under its label: what the action does, or why a disabled item is
+ * unavailable («Доступно владельцу проекта»). Wraps instead of widening the menu past its limit.
+ */
+declare function DropdownItemDescription({ className, ...rest }: DropdownItemDescriptionProps): import("react/jsx-runtime").JSX.Element;
+declare namespace DropdownItemDescription {
+    var displayName: string;
+}
 export type DropdownGroupProps = MenuGroupProps;
 declare function DropdownGroup(props: DropdownGroupProps): import("react/jsx-runtime").JSX.Element;
 declare namespace DropdownGroup {
@@ -131,6 +149,7 @@ export declare const Dropdown: {
     Item: typeof DropdownItem;
     CheckboxItem: typeof DropdownCheckboxItem;
     ItemIcon: typeof DropdownItemIcon;
+    ItemDescription: typeof DropdownItemDescription;
     ItemShortcut: typeof DropdownItemShortcut;
     Separator: typeof DropdownSeparator;
 };

package/dist/components/empty-page/EmptyPage.d.ts

@@ -1,6 +1,12 @@
-import type * as React from "react";
-import type { ControlSize, Tone } from "@/internal/states";
+import * as React from "react";
+import type { ControlSize, Tone } from "../../internal/states";
 type EmptyPageLayout = "default" | "fill" | "compact";
+/** `neutral` — nothing here (yet); `danger` — the region failed to load. */
+export type EmptyPageTone = Extract<Tone, "neutral" | "danger">;
+export type EmptyPageLabels = {
+    /** Text of `EmptyPage.RetryButton`. */
+    retry: string;
+};
 export type EmptyPageRootProps = React.HTMLAttributes<HTMLDivElement> & {
     /** Control height, type and spacing tier. Default `m`. */
     size?: ControlSize;
@@ -11,19 +17,28 @@ export type EmptyPageRootProps = React.HTMLAttributes<HTMLDivElement> & {
      * caption description, a small icon and no entrance motion.
      */
     layout?: EmptyPageLayout;
+    /**
+     * `danger` — the region's load failed: the icon tile turns danger and the root announces itself
+     * (`role="alert"`, unless you pass a `role`). Default `neutral`.
+     */
+    tone?: EmptyPageTone;
+    labels?: Partial<EmptyPageLabels>;
     ref?: React.Ref<HTMLDivElement>;
 };
 /** Parts rise in on first render, except in `compact` (it appears on every keystroke). */
-declare function EmptyPageRoot({ size, layout, className, children, ...rest }: EmptyPageRootProps): import("react/jsx-runtime").JSX.Element;
+declare function EmptyPageRoot({ size, layout, tone, labels, className, children, ...rest }: EmptyPageRootProps): import("react/jsx-runtime").JSX.Element;
 declare namespace EmptyPageRoot {
     var displayName: string;
 }
 export type EmptyPageIconProps = React.HTMLAttributes<HTMLDivElement> & {
-    /** Tile fill: `neutral` (default), `accent` — an invitation to start, `danger` — a failure. */
+    /**
+     * Tile fill: `neutral`, `accent` — an invitation to start, `danger` — a failure. Default: the
+     * root's `tone`.
+     */
     tone?: Extract<Tone, "neutral" | "accent" | "danger">;
     ref?: React.Ref<HTMLDivElement>;
 };
-declare function EmptyPageIcon({ tone, className, ...rest }: EmptyPageIconProps): import("react/jsx-runtime").JSX.Element;
+declare function EmptyPageIcon({ tone: toneProp, className, ...rest }: EmptyPageIconProps): import("react/jsx-runtime").JSX.Element;
 declare namespace EmptyPageIcon {
     var displayName: string;
 }
@@ -54,11 +69,26 @@ declare function EmptyPageActions({ className, ...rest }: EmptyPageActionsProps)
 declare namespace EmptyPageActions {
     var displayName: string;
 }
+export type EmptyPageRetryButtonProps = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "onClick" | "type"> & {
+    /**
+     * Loads the region again. May return a Promise: while it is pending the button shows its loading
+     * state and cannot be pressed twice. Resolve — the owner swaps the region to its data; reject —
+     * the error state stays and the button is ready again.
+     */
+    onRetry: () => void | Promise<void>;
+    ref?: React.Ref<HTMLButtonElement>;
+};
+/** The kit's «Повторить» for an error state: an outline neutral Button with the refresh icon. */
+declare function EmptyPageRetryButton({ onRetry, children, disabled, ...rest }: EmptyPageRetryButtonProps): import("react/jsx-runtime").JSX.Element;
+declare namespace EmptyPageRetryButton {
+    var displayName: string;
+}
 export declare const EmptyPage: {
     Root: typeof EmptyPageRoot;
     Icon: typeof EmptyPageIcon;
     Title: typeof EmptyPageTitle;
     Description: typeof EmptyPageDescription;
     Actions: typeof EmptyPageActions;
+    RetryButton: typeof EmptyPageRetryButton;
 };
 export {};

package/dist/components/fieldset/Fieldset.d.ts

@@ -0,0 +1,24 @@
+import * as React from "react";
+export type FieldsetProps = Omit<React.FieldsetHTMLAttributes<HTMLFieldSetElement>, "children" | "disabled"> & {
+    /** Group heading (`title-s`) in the native `<legend>`; it names the group. */
+    label?: React.ReactNode;
+    /** Secondary text under the heading; linked to the group through `aria-describedby`. */
+    description?: React.ReactNode;
+    /**
+     * Disables every control inside: native `disabled` on the `<fieldset>` (native controls) plus the
+     * kit's disabled context, so kit controls render, announce and behave disabled. Use it while the
+     * form's request runs.
+     */
+    disabled?: boolean;
+    /** The fields; they stack at the form rhythm (field → field 20). */
+    children: React.ReactNode;
+    ref?: React.Ref<HTMLFieldSetElement>;
+};
+/**
+ * A frameless group of fields: native `<fieldset>` + `<legend>` heading, the kit's field rhythm
+ * between the children, one `disabled` for all of them. No border, no padding, no fill.
+ */
+export declare function Fieldset({ label, description, disabled: disabledProp, className, children, "aria-describedby": ariaDescribedBy, ...rest }: FieldsetProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Fieldset {
+    var displayName: string;
+}