@danxbot/ui 3.4.3 → 3.5.0

package/dist/types/components/AppShell.d.ts

@@ -1,4 +1,4 @@
-import type { ReactNode } from "react";
+import type { MouseEvent, ReactNode } from "react";
 import { type IconName } from "./Icon";
 export type NavItem = {
     id: string;
@@ -7,7 +7,37 @@ export type NavItem = {
     /** A count or status shown at the trailing edge. */
     badge?: ReactNode;
     href?: string;
-    onClick?: () => void;
+    /**
+     * Receives the click event, which a client-side router NEEDS in order to
+     * suppress the browser's own navigation.
+     *
+     * IT USED TO RECEIVE NOTHING, and that made this component quietly
+     * unusable with a history router. The anchor only calls `preventDefault()`
+     * when `href` is absent, so an item with BOTH `href` and `onClick` did the
+     * client-side navigation AND a full page load — tearing down the app tree
+     * and every live connection it held, on every nav click. The design system's
+     * own demo could not surface it: a hash router's `href="#/x"` never reloads
+     * either way. It showed up the moment a real consumer wired history routing.
+     *
+     * Dropping `href` to force the `preventDefault` branch works and costs too
+     * much — a nav item without an `href` is not a link, so it loses the hover
+     * URL, ctrl/cmd-click-to-new-tab and copy-link-address. Keep the `href`,
+     * take the event:
+     *
+     * ```tsx
+     * onClick: (e) => {
+     *   // Let the browser have the clicks that mean "not here" — a modified
+     *   // click or a middle click is an explicit request for a new tab, and
+     *   // swallowing it is the most-reported bug in hand-rolled SPA links.
+     *   if (e.defaultPrevented || e.metaKey || e.ctrlKey || e.shiftKey || e.altKey) return;
+     *   e.preventDefault();
+     *   navigate(item.href);
+     * }
+     * ```
+     *
+     * Still router-agnostic: the shell hands over the event and decides nothing.
+     */
+    onClick?: (event: MouseEvent<HTMLAnchorElement>) => void;
 };
 export type NavSection = {
     label?: string;

package/dist/types/components/Board.d.ts

@@ -0,0 +1,131 @@
+import { type ReactNode } from "react";
+import type { AutoScrollOptions, DragStrings } from "../lib/dnd";
+import type { BoardColumnModel, BoardItemId, UseBoardOptions, UseBoardResult } from "../lib/board";
+export interface BoardProps<T> extends UseBoardOptions<T> {
+    /** Forwarded to `DragDrop` — announcement grammar, localisation. */
+    strings?: Partial<DragStrings>;
+    /** Forwarded to `DragDrop` — see its own doc; cannot be turned off. */
+    autoScroll?: AutoScrollOptions;
+    className?: string;
+    /**
+     * Applied to the row the columns lay out in, NOT to the board root that
+     * `className` targets.
+     *
+     * Two seams rather than one because the two boxes take genuinely different
+     * decisions: the root is where a consumer sets the board's own size and
+     * chrome, and this row is where the columns' overflow behaviour lives —
+     * horizontal scroll on a wide board, wrapping on a narrow one. The first
+     * real consumer of this component hit the gap immediately and had to reach
+     * `overflow-x-auto` onto the root, which is the wrong box: it scrolls the
+     * live region and the instructions along with the columns.
+     */
+    columnsClassName?: string;
+    /**
+     * The card while it is being carried. Defaults to the card's own children.
+     *
+     * The default is the version that cannot drift from the row it stands for,
+     * which is why it is the default. But a carried card is read at a glance
+     * while it moves, and a dense resting card is the wrong thing to read that
+     * way — the two or three fields that identify the record are all anybody
+     * takes off it mid-drag.
+     *
+     * It changes what the carried card SHOWS and nothing else. Whether a card is
+     * carried, and how, is not a board's decision: the engine lifts every dragged
+     * card into a portalled clone either way.
+     */
+    renderDragging?: (item: T) => ReactNode;
+    /** The rendered board, given the live model to map over — same shape
+     *  `DragDropOverlay`'s own `children` already uses in this package for the
+     *  identical reason: `Board` is generic over the consumer's item type, and
+     *  a render prop is how that generic reaches the consumer's JSX without a
+     *  second, parallel context API duplicating what `useBoard` already
+     *  returns. */
+    children: (board: UseBoardResult<T>) => ReactNode;
+}
+export declare function Board<T>({ items, columns, accessors, validateMove, onMove, selection, strings, autoScroll, className, columnsClassName, renderDragging, children, }: BoardProps<T>): import("react").JSX.Element;
+export interface BoardCardSurfaceProps {
+    className?: string;
+    children?: ReactNode;
+}
+/**
+ * Makes the WHOLE card a drag source, instead of the grip alone.
+ *
+ * RENDERING IT IS WHAT TURNS IT ON — there is no `wholeCardDrag` boolean, the
+ * same rule the rest of this package follows and `drag-drop.test.tsx` enforces
+ * on its own component layer. A board that wants a grip renders no surface; a
+ * board that wants the card to drag wraps its content in one.
+ *
+ * WHY THIS IS SAFE HERE, and it was not safe before. The obvious objection is
+ * that a card usually opens something when clicked, and a card that is entirely
+ * a drag handle swallows that click. True of a source that starts on
+ * `pointerdown`; false of this engine, which holds a press in `pending` until
+ * it passes an activation constraint — 5px of travel for a mouse, a 250ms dwell
+ * for a finger. A press that does not move is still a click. A press that does
+ * becomes a drag, and its trailing click is swallowed. The card can be both,
+ * and `audit:dnd` proves it on every run: a 2px wobble never enters a drag and
+ * still counts as a click.
+ *
+ * THE 2.5.7 CONTROL IS NOT AFFECTED. The menu the card hands out is the
+ * single-pointer, non-dragging route to every move, and it stays exactly where
+ * it was. What the surface removes is the GRIP, which would otherwise be a
+ * second drag source for the same card.
+ *
+ * It also cannot produce a button inside a button: `DragDropSurface` takes a
+ * role only when it owns focus — when it contains no focusable of its own —
+ * and a card carrying the move menu never does.
+ */
+export declare function BoardCardSurface({ className, children }: BoardCardSurfaceProps): import("react").JSX.Element;
+export interface BoardColumnProps<T> {
+    /** `useBoard`'s own computed column — id, label, items, count, wipLimit,
+     *  overWip. Passed straight through; nothing here re-derives it. */
+    column: BoardColumnModel<T>;
+    /**
+     * Rendered in place of `children` when the column has no cards. Content,
+     * not a boolean — supplying THIS is what changes it, matching the
+     * package-wide rule against a `show*`/`with*` switch. Defaults to a
+     * generic message built on `EmptyState` (REUSE: "An empty list, or a
+     * zero-state screen"), sized down for a column rather than a full page.
+     */
+    emptyState?: ReactNode;
+    className?: string;
+    /**
+     * Applied to the droppable list, NOT to the column shell that `className`
+     * targets — this is where a column's own scrolling belongs
+     * (`max-h-… overflow-y-auto`).
+     *
+     * It has to be the inner box: put the scroll on the shell and the header
+     * scrolls away with the cards, so a column whose cards have been scrolled
+     * loses the label and count that say what the column IS. The drag engine
+     * already resolves whichever scroller sits under the pointer, so a column
+     * that scrolls here auto-scrolls during a drag with nothing further wired.
+     */
+    listClassName?: string;
+    /** The column's cards — a `BoardCard` per item, mapped by the consumer
+     *  exactly as `DragDropContainer`'s own children already are. This is the
+     *  virtualization seam — see the file header. */
+    children?: ReactNode;
+}
+export declare function BoardColumn<T>({ column, emptyState, className, listClassName, children, }: BoardColumnProps<T>): import("react").JSX.Element;
+export interface BoardCardProps {
+    id: BoardItemId;
+    /** Position within its OWN column right now — same contract as
+     *  `DragDropItem.index`: the real index in the consumer's data, never a
+     *  filtered render order. */
+    index: number;
+    /** Spoken by the drag engine's announcements and this card's own "Move
+     *  <label>" menu trigger label. Falls back to `id`, which is speakable and
+     *  not great — supply it. */
+    label?: string;
+    className?: string;
+    /**
+     * Card content, 100% consumer-owned — `Board` and `BoardCard` do not know
+     * what is inside. `handle` is the dual-purpose grip-and-menu control (see
+     * the file header); RES-GAME's evidence is that a board renders this
+     * INSIDE its `RecordCardHandle` slot (`RecordCard.tsx` reserves exactly
+     * this region), but nothing here requires that specific composition — it
+     * is a plain `ReactNode`, placeable anywhere the consumer's markup wants a
+     * pointer-operable, non-dragging route to every move this card can make.
+     */
+    children: (handle: ReactNode) => ReactNode;
+}
+export declare function BoardCard({ id, index, label, className, children }: BoardCardProps): import("react").JSX.Element;

package/dist/types/components/Callout.d.ts

@@ -0,0 +1,163 @@
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+import { type VariantProps } from "tailwind-variants";
+declare const callout: import("tailwind-variants").TVReturnType<{
+    tone: {
+        neutral: {
+            root: string;
+            glyph: string;
+            title: string;
+            body: string;
+        };
+        info: {
+            root: string;
+            glyph: string;
+            title: string;
+            body: string;
+        };
+        success: {
+            root: string;
+            glyph: string;
+            title: string;
+            body: string;
+        };
+        warning: {
+            root: string;
+            glyph: string;
+            title: string;
+            body: string;
+        };
+        danger: {
+            root: string;
+            glyph: string;
+            title: string;
+            body: string;
+        };
+    };
+    emphasis: {
+        subtle: {};
+        strong: {
+            root: string;
+        };
+    };
+}, {
+    root: string;
+    glyph: string;
+    content: string;
+    title: string;
+    body: string;
+    actions: string;
+}, undefined, {
+    tone: {
+        neutral: {
+            root: string;
+            glyph: string;
+            title: string;
+            body: string;
+        };
+        info: {
+            root: string;
+            glyph: string;
+            title: string;
+            body: string;
+        };
+        success: {
+            root: string;
+            glyph: string;
+            title: string;
+            body: string;
+        };
+        warning: {
+            root: string;
+            glyph: string;
+            title: string;
+            body: string;
+        };
+        danger: {
+            root: string;
+            glyph: string;
+            title: string;
+            body: string;
+        };
+    };
+    emphasis: {
+        subtle: {};
+        strong: {
+            root: string;
+        };
+    };
+}, {
+    root: string;
+    glyph: string;
+    content: string;
+    title: string;
+    body: string;
+    actions: string;
+}, import("tailwind-variants").TVReturnTypeLike<{
+    tone: {
+        neutral: {
+            root: string;
+            glyph: string;
+            title: string;
+            body: string;
+        };
+        info: {
+            root: string;
+            glyph: string;
+            title: string;
+            body: string;
+        };
+        success: {
+            root: string;
+            glyph: string;
+            title: string;
+            body: string;
+        };
+        warning: {
+            root: string;
+            glyph: string;
+            title: string;
+            body: string;
+        };
+        danger: {
+            root: string;
+            glyph: string;
+            title: string;
+            body: string;
+        };
+    };
+    emphasis: {
+        subtle: {};
+        strong: {
+            root: string;
+        };
+    };
+}, {
+    root: string;
+    glyph: string;
+    content: string;
+    title: string;
+    body: string;
+    actions: string;
+}>>;
+export interface CalloutProps extends Omit<HTMLAttributes<HTMLDivElement>, "title">, VariantProps<typeof callout> {
+    /** The condition, in one line. */
+    title: ReactNode;
+    /**
+     * Override the per-tone default shape. Pass `null` to render no icon at all
+     * — for a tone that is genuinely not a severity.
+     */
+    icon?: ReactNode | null;
+    /** What to do about it. The half that makes a callout useful rather than a complaint. */
+    children?: ReactNode;
+    /** Buttons or links. Rendered under the body, never beside the title. */
+    actions?: ReactNode;
+    /**
+     * Announce assertively via `role="alert"`. Opt-in — see the header. Reserve
+     * for a condition that appears in response to a change, not one present at
+     * load.
+     */
+    live?: boolean;
+    ref?: Ref<HTMLDivElement>;
+}
+export declare function Callout({ tone, emphasis, title, icon, children, actions, live, className, ref, ...props }: CalloutProps): import("react").JSX.Element;
+export { callout as calloutVariants };

package/dist/types/components/RecordCard.d.ts

@@ -116,6 +116,76 @@ declare const record: import("tailwind-variants").TVReturnType<{
     metricValue: string;
     footer: string;
 }>>;
+declare const recordCard: import("tailwind-variants").TVReturnType<{
+    /**
+     * Layout, not content. `corner` is the assignee-avatar shape (small,
+     * square, sits beside the title); `cover` is the banner-image shape (full
+     * width, wide aspect). Same slot, same DOM position — only the geometry
+     * changes, which is the whole argument for not splitting this into two
+     * props.
+     */
+    placement: {
+        corner: {
+            media: string;
+        };
+        cover: {
+            media: string;
+        };
+    };
+}, {
+    handle: string;
+    eyebrow: string;
+    title: string;
+    badges: string;
+    media: string;
+    meta: string;
+}, undefined, {
+    /**
+     * Layout, not content. `corner` is the assignee-avatar shape (small,
+     * square, sits beside the title); `cover` is the banner-image shape (full
+     * width, wide aspect). Same slot, same DOM position — only the geometry
+     * changes, which is the whole argument for not splitting this into two
+     * props.
+     */
+    placement: {
+        corner: {
+            media: string;
+        };
+        cover: {
+            media: string;
+        };
+    };
+}, {
+    handle: string;
+    eyebrow: string;
+    title: string;
+    badges: string;
+    media: string;
+    meta: string;
+}, import("tailwind-variants").TVReturnTypeLike<{
+    /**
+     * Layout, not content. `corner` is the assignee-avatar shape (small,
+     * square, sits beside the title); `cover` is the banner-image shape (full
+     * width, wide aspect). Same slot, same DOM position — only the geometry
+     * changes, which is the whole argument for not splitting this into two
+     * props.
+     */
+    placement: {
+        corner: {
+            media: string;
+        };
+        cover: {
+            media: string;
+        };
+    };
+}, {
+    handle: string;
+    eyebrow: string;
+    title: string;
+    badges: string;
+    media: string;
+    meta: string;
+}>>;
 export interface RecordCardMetric {
     label: ReactNode;
     value: ReactNode;
@@ -123,7 +193,13 @@ export interface RecordCardMetric {
 export interface RecordCardProps extends VariantProps<typeof record> {
     /** The record's own id — rendered mono, above the title. */
     identifier?: ReactNode;
-    title: ReactNode;
+    /**
+     * Optional ONLY so a caller can compose the parts instead (see the header).
+     * For prop-driven use it is effectively required — a record card with no
+     * title is not a record card — and omitting it drops the whole top row
+     * rather than rendering an empty one.
+     */
+    title?: ReactNode;
     /** What kind of record this is, or who it belongs to. One line. */
     subtitle?: ReactNode;
     /** State chips. A slot, so their tones and behaviour stay the consumer's. */
@@ -150,4 +226,72 @@ export interface RecordCardProps extends VariantProps<typeof record> {
     onClick?: (event: React.MouseEvent) => void;
 }
 export declare function RecordCard({ identifier, title, subtitle, badges, metrics, media, action, footer, emphasis, interactive, selected, render, className, children, ref, ...props }: RecordCardProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+export interface RecordCardHandleProps {
+    className?: string;
+    /** Whatever the board wants reachable here — a drag handle, a menu trigger,
+     *  a dual-purpose control combining both. This component owns none of that
+     *  behaviour; it only reserves the shape (shrink-resistant, stretches to
+     *  match a flex-row sibling) so the board's control does not have to fight
+     *  the record's own layout for space. */
+    children: ReactNode;
+    ref?: Ref<HTMLSpanElement>;
+}
+/** The region a board can slot a drag handle into. Absent entirely when a
+ *  card is rendered outside any board — nothing here assumes one exists. */
+export declare function RecordCardHandle({ className, children, ref }: RecordCardHandleProps): import("react").JSX.Element;
+export interface RecordCardEyebrowProps {
+    className?: string;
+    children: ReactNode;
+    ref?: Ref<HTMLSpanElement>;
+}
+/** The identifier line — an id, a code, a short kicker. Answers WHICH record
+ *  this is, which is a different question from the one `Title` answers. */
+export declare function RecordCardEyebrow({ className, children, ref }: RecordCardEyebrowProps): import("react").JSX.Element;
+export interface RecordCardTitleProps {
+    /**
+     * The heading level this title renders as.
+     *
+     * See `CardHeader.titleAs` — the reasoning is identical and does not bear
+     * repeating differently: only the caller knows what sits above this card in
+     * the page outline.
+     *
+     * @default "h3"
+     */
+    as?: "h2" | "h3" | "h4" | "h5" | "h6";
+    className?: string;
+    children: ReactNode;
+    ref?: Ref<HTMLHeadingElement>;
+}
+/** Clamped to two lines by default — a collapsed record has a fixed budget of
+ *  vertical space, and a title that runs on pushes the meta row an
+ *  unpredictable distance down the column instead of wrapping in place. */
+export declare function RecordCardTitle({ as: Title, className, children, ref }: RecordCardTitleProps): import("react").JSX.Element;
+export interface RecordCardBadgesProps {
+    className?: string;
+    children: ReactNode;
+    ref?: Ref<HTMLDivElement>;
+}
+/** A wrapping row for a SMALL set of status/priority badges — `Badge` from
+ *  this same library, composed by the consumer. This component supplies only
+ *  the row layout; it has no opinion on how many badges is too many. */
+export declare function RecordCardBadges({ className, children, ref }: RecordCardBadgesProps): import("react").JSX.Element;
+export interface RecordCardMediaProps extends VariantProps<typeof recordCard> {
+    className?: string;
+    children: ReactNode;
+    ref?: Ref<HTMLDivElement>;
+}
+/** The media/cover region — an assignee avatar (`placement="corner"`, the
+ *  default) or a banner image (`placement="cover"`). See the file header for
+ *  why these are one slot rather than two. */
+export declare function RecordCardMedia({ placement, className, children, ref }: RecordCardMediaProps): import("react").JSX.Element;
+export interface RecordCardMetaProps {
+    className?: string;
+    children: ReactNode;
+    ref?: Ref<HTMLDivElement>;
+}
+/** The one compact secondary-metadata row — comment count, dependency count,
+ *  a due date. Full description, comment threads and history are explicitly
+ *  not this component's problem; they live behind a click, on whatever detail
+ *  surface the consumer opens from here. */
+export declare function RecordCardMeta({ className, children, ref }: RecordCardMetaProps): import("react").JSX.Element;
 export {};

package/dist/types/components/board/context.d.ts

@@ -0,0 +1,60 @@
+import type { BoardColumnId, BoardColumnModel, BoardItemId, BoardMoveRequest, BoardMoveVerdict } from "../../lib/board";
+export declare const BoardCardSurfaceContext: import("react").Context<boolean>;
+/** `true` when an ancestor `BoardCardSurface` makes this whole card draggable. */
+export declare function useBoardCardIsDragSource(): boolean;
+export interface BoardContextValue<T> {
+    /** Every declared column, in order, as `useBoard` last computed it. The
+     *  "Move to…" menu reads `id` / `label` / `count` off this to offer every
+     *  OTHER column as a destination and to compute an append index. */
+    columns: readonly BoardColumnModel<T>[];
+    /**
+     * The single funnel — see `lib/board/use-board.ts`. Every input source
+     * (drag, keyboard, the menu) calls exactly THIS and nothing else.
+     *
+     * This is `Board.tsx`'s own wrapper around `useBoard`'s `requestMove`, not
+     * the raw hook result — it ALSO surfaces a rejected verdict's reason (see
+     * `types.ts`'s own doc on `BoardMoveVerdict`: "written for a person to
+     * read, not logged") before returning it. Routing that through the same
+     * function every caller already has to call — rather than a second
+     * `reportRejection` a caller could forget — is what makes "a rejected move
+     * never fails silently" true of every source by construction, not by
+     * convention.
+     */
+    requestMove: (request: BoardMoveRequest) => BoardMoveVerdict;
+}
+export interface BoardColumnContextValue {
+    columnId: BoardColumnId;
+    label: string;
+}
+export interface BoardCardContextValue {
+    itemId: BoardItemId;
+    /** Position within ITS OWN column right now — the `from.index` half of any
+     *  move this card's handle constructs. */
+    index: number;
+    label: string | undefined;
+    /**
+     * Called by the card's move control on mount, returning its own cleanup.
+     *
+     * WHY A REGISTRATION RATHER THAN TRUST. `BoardCard` hands its control out
+     * through a render prop, which is what keeps card layout entirely
+     * consumer-owned — but a render prop can be received and never placed, and
+     * the thing that would go missing is the WCAG 2.2 SC 2.5.7 pointer
+     * alternative: the one control a touchscreen user with no keyboard has. That
+     * failure has no error, no type error and no visible symptom for anyone
+     * testing with a mouse, which is precisely the class this project keeps
+     * finding.
+     *
+     * So the control announces itself and `BoardCard` checks. React runs child
+     * effects before parent effects, so by the time the card's own effect runs
+     * the answer is already known. This is the same shape `DragDrop` uses to
+     * learn whether an overlay was rendered (`registerOverlay`) — a part reports
+     * its own existence rather than the parent trying to inspect its children.
+     */
+    registerHandle: () => () => void;
+}
+export declare const BoardProvider: import("react").Provider<BoardContextValue<unknown> | null>;
+export declare const BoardColumnProvider: import("react").Provider<BoardColumnContextValue | null>;
+export declare const BoardCardProvider: import("react").Provider<BoardCardContextValue | null>;
+export declare function useBoardContext<T>(component: string): BoardContextValue<T>;
+export declare function useBoardColumnContext(component: string): BoardColumnContextValue;
+export declare function useBoardCardContext(component: string): BoardCardContextValue;

package/dist/types/components/board/recipe.d.ts

@@ -0,0 +1,52 @@
+export declare const board: import("tailwind-variants").TVReturnType<{
+    overWip: {
+        true: {
+            header: string;
+            label: string;
+        };
+        false: {};
+    };
+}, {
+    column: string;
+    header: string[];
+    label: string;
+    list: string;
+    empty: string;
+    handleCluster: string;
+    menuTrigger: string[];
+    rejection: string[];
+}, undefined, {
+    overWip: {
+        true: {
+            header: string;
+            label: string;
+        };
+        false: {};
+    };
+}, {
+    column: string;
+    header: string[];
+    label: string;
+    list: string;
+    empty: string;
+    handleCluster: string;
+    menuTrigger: string[];
+    rejection: string[];
+}, import("tailwind-variants").TVReturnTypeLike<{
+    overWip: {
+        true: {
+            header: string;
+            label: string;
+        };
+        false: {};
+    };
+}, {
+    column: string;
+    header: string[];
+    label: string;
+    list: string;
+    empty: string;
+    handleCluster: string;
+    menuTrigger: string[];
+    rejection: string[];
+}>>;

package/dist/types/components/kanban/KanbanBoard.d.ts

@@ -1,4 +1,4 @@
-import type { ReactNode } from "react";
+import { type ReactNode } from "react";
 import type { DragSessionCallbacks } from "../../lib/dnd";
 import type { KanbanLane, KanbanMove, KanbanRefusal } from "./types";
 export type { KanbanLane, KanbanMove, KanbanRefusal };

package/dist/types/components/kanban/types.d.ts

@@ -16,6 +16,16 @@ export interface KanbanLane<T> {
     limit?: number;
     /** In the order they should appear. Their index is what a move reports. */
     items: readonly T[];
+    /**
+     * Shown in THIS lane when it has no cards, overriding the board's own
+     * `emptyLane`.
+     *
+     * One message for a whole board is right until one lane means something
+     * different from the others — an empty backlog reads "nothing waiting" and an
+     * empty released column reads "nothing shipped yet", and a single string has
+     * to be vague enough to be true of both, which makes it useless for either.
+     */
+    empty?: ReactNode;
     /**
      * Why a card may not be dropped here. Absent means the lane accepts drops.
      *

package/dist/types/index.d.ts

@@ -15,6 +15,7 @@ export { coreIcons, type CoreIconName } from "./icons/data";
 export { Button, buttonVariants, type ButtonProps } from "./components/Button";
 export { IconButton, type IconButtonProps, type IconButtonVariant, type IconButtonTone, } from "./components/IconButton";
 export { Badge, badgeVariants, type BadgeProps } from "./components/Badge";
+export { Callout, calloutVariants, type CalloutProps } from "./components/Callout";
 export { Spinner, type SpinnerProps } from "./components/Spinner";
 export { Skeleton, SkeletonText, LoadingOverlay, type SkeletonProps, type SkeletonTextProps, type LoadingOverlayProps, } from "./components/Loading";
 export { ErrorBoundary } from "./components/ErrorBoundary";
@@ -38,7 +39,7 @@ export { Combobox, ComboboxItem, ComboboxGroup, MultiCombobox, type ComboboxProp
 export { Select, SelectItem, SelectGroup, SelectSeparator, type SelectProps, type SelectItemProps, type SelectGroupProps, } from "./components/Select";
 export { StatusSelect, type StatusSelectProps, type StatusOption } from "./components/StatusSelect";
 export { Card, CardHeader, CardFooter, type CardProps, type CardHeaderProps, } from "./components/Card";
-export { RecordCard, type RecordCardProps, type RecordCardMetric, } from "./components/RecordCard";
+export { RecordCard, RecordCardHandle, RecordCardEyebrow, RecordCardTitle, RecordCardBadges, RecordCardMedia, RecordCardMeta, type RecordCardProps, type RecordCardMetric, type RecordCardHandleProps, type RecordCardEyebrowProps, type RecordCardTitleProps, type RecordCardBadgesProps, type RecordCardMediaProps, type RecordCardMetaProps, } from "./components/RecordCard";
 export { Tabs, TabList, Tab, TabPanel, type TabsProps, type TabListProps, type TabProps, type TabPanelProps, } from "./components/Tabs";
 export { Accordion, AccordionItem, type AccordionProps, type AccordionItemProps, } from "./components/Accordion";
 export { Breadcrumb, Pagination, type BreadcrumbProps, type PaginationProps, type Crumb, } from "./components/Navigation";
@@ -72,6 +73,9 @@ export { parseMarkdown, MarkdownNodes, sanitizeHref, type MdNode, type MdInline,
 export { DragDrop, DragDropContainer, DragDropItem, DragDropHandle, DragDropSurface, type DragDropProps, type DragDropContainerProps, type DragDropItemProps, type DragDropHandleProps, type DragDropSurfaceProps, } from "./components/DragDrop";
 export { KanbanBoard, type KanbanBoardProps, type KanbanLane, type KanbanMove, type KanbanRefusal, } from "./components/kanban/KanbanBoard";
 export { DEFAULT_DRAG_STRINGS, DRAG_INSTRUCTIONS_ID, DragInstructions, DragLiveRegion, DragSession, DragSessionProvider, applyMove, attachAutoScroll, attachKeyboardSensor, attachPointerSensor, attachSessionWindowListeners, isNoOp, resolveTarget, sameTarget, scrollVelocity, useCreateDragSession, useDragAnnouncements, useDragSession, useDragState, useDraggable, useDropContainer, type ContainerId, type DragAxis, type DragCancelEvent, type DragEndEvent, type DragId, type DragMode, type DragPhase, type DragSessionCallbacks, type DragStartEvent, type DragState, type AutoScrollOptions, type DragAnnouncementContext, type DragAnnouncementOptions, type DragAnnouncements, type DragInstructionsProps, type DragLiveRegionProps, type DragStrings, type DropTarget, type KeyboardSensorOptions, type PointerActivation, } from "./lib/dnd";
+export { Board, BoardColumn, BoardCard, BoardCardSurface, type BoardProps, type BoardColumnProps, type BoardCardProps, type BoardCardSurfaceProps, } from "./components/Board";
+export { buildBoardModel, resolveMove, applyBoardMoves, useBoard, type BoardModel, type UseBoardResult, } from "./lib/board";
+export type { BoardAccessors, BoardColumnDef, BoardColumnId, BoardColumnModel, BoardItemId, BoardMove, BoardMoveRequest, BoardMoveSource, BoardMoveVerdict, UseBoardOptions, } from "./lib/board";
 export type { MessageRole, MessagePart, MessagePartType, TextPart, CodePart, ReasoningPart, ToolPart, ToolStatus, FilePart, ComponentPart, ChatFile, ChatMessage, RenderContext, PartRenderer, PartRenderers, ChatComponentRenderer, ChatComponents, } from "./components/chat/types";
 export { Chat, ChatPopover, type ChatProps, type ChatPopoverProps, type ChatSurface, } from "./components/chat/Chat";
 export { Message, MessagePartView, ToolCall, ChatMarker, type MessageProps, type MessageAction, type MessagePartViewProps, type ToolCallProps, type ChatMarkerProps, } from "./components/chat/Message";