@danxbot/ui 2.2.2 → 2.4.0

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

@@ -8,6 +8,8 @@ declare const button: import("tailwind-variants").TVReturnType<{
         subtle: string[];
         outline: string[];
         ghost: string[];
+        "ghost-danger": string[];
+        "outline-danger": string[];
         danger: string[];
         "danger-subtle": string[];
         link: string[];
@@ -34,6 +36,8 @@ declare const button: import("tailwind-variants").TVReturnType<{
         subtle: string[];
         outline: string[];
         ghost: string[];
+        "ghost-danger": string[];
+        "outline-danger": string[];
         danger: string[];
         "danger-subtle": string[];
         link: string[];
@@ -60,6 +64,8 @@ declare const button: import("tailwind-variants").TVReturnType<{
         subtle: string[];
         outline: string[];
         ghost: string[];
+        "ghost-danger": string[];
+        "outline-danger": string[];
         danger: string[];
         "danger-subtle": string[];
         link: string[];
@@ -99,5 +105,5 @@ export interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement>, Va
     trailingIcon?: ReactNode;
     ref?: Ref<HTMLButtonElement>;
 }
-export declare function Button({ className, variant, size, iconOnly, fullWidth, render, loading, leadingIcon, trailingIcon, disabled, children, onPointerDown, ref, ...props }: ButtonProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+export declare function Button({ className, variant, size, iconOnly, fullWidth, render, loading, leadingIcon, trailingIcon, disabled, children, onPointerDown, ref, "aria-disabled": ariaDisabled, ...props }: ButtonProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
 export { button as buttonVariants };

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

@@ -0,0 +1,56 @@
+import type { ReactNode, Ref } from "react";
+import { type ButtonProps } from "./Button";
+/** Which `Button` variant backs each (variant, tone) pair. */
+declare const VARIANT_FOR: {
+    readonly ghost: {
+        readonly neutral: "ghost";
+        readonly danger: "ghost-danger";
+    };
+    readonly subtle: {
+        readonly neutral: "subtle";
+        readonly danger: "danger-subtle";
+    };
+    readonly outline: {
+        readonly neutral: "outline";
+        readonly danger: "outline-danger";
+    };
+    readonly solid: {
+        readonly neutral: "solid";
+        readonly danger: "danger";
+    };
+};
+export type IconButtonVariant = keyof typeof VARIANT_FOR;
+export type IconButtonTone = "neutral" | "danger";
+export interface IconButtonProps extends Omit<ButtonProps, "children" | "iconOnly" | "leadingIcon" | "trailingIcon" | "variant" | "aria-label" | "disabled" | "aria-disabled"> {
+    /** The glyph. Rendered `aria-hidden` — the name comes from `label`. */
+    icon: ReactNode;
+    /**
+     * The accessible name, and the tooltip text. REQUIRED — an icon carries no
+     * text, so there is no other source for it.
+     *
+     * Name the ACTION and its object ("Delete Phase 2"), not the picture
+     * ("Trash"). It is read aloud in a list of controls where nothing else
+     * distinguishes one row's delete from another's.
+     */
+    label: string;
+    /** Visual weight. Defaults to `ghost` — the right resting state in a row. */
+    variant?: IconButtonVariant;
+    /** `danger` makes the hover destructive. Resting state is unchanged. */
+    tone?: IconButtonTone;
+    /**
+     * Unavailable, AND WHY — there is no boolean form. The string is shown in
+     * the tooltip and announced as the control's description, so the refusal is
+     * never silent.
+     */
+    disabledReason?: string;
+    /**
+     * Suppress the tooltip. For the rare control already named in adjacent
+     * visible text, where a tooltip would only repeat it. The `aria-label` is
+     * unaffected — the name is never optional.
+     */
+    hideTooltip?: boolean;
+    tooltipSide?: "top" | "bottom" | "left" | "right";
+    ref?: Ref<HTMLButtonElement>;
+}
+export declare function IconButton({ icon, label, variant, tone, size, disabledReason, hideTooltip, tooltipSide, className, onClick, ...props }: IconButtonProps): import("react").JSX.Element;
+export {};

package/dist/types/components/checklist/StatusChecklist.d.ts

@@ -0,0 +1,37 @@
+import { type ReactNode } from "react";
+import type { StatusOption } from "../StatusSelect";
+import type { ChecklistItem, ChecklistState, ChecklistTally } from "./types";
+export type { ChecklistItem, ChecklistState, ChecklistTally };
+export interface StatusChecklistProps<Key extends string = string> {
+    /**
+     * What this list IS — "Evidence for the March filing".
+     *
+     * Names the group, so somebody landing on it by keyboard learns what the
+     * counts are counting. Required for the same reason `KanbanBoard.label` is.
+     */
+    label: string;
+    /** The consumer's vocabulary, in the order the summary and groups read. */
+    states: readonly StatusOption<Key>[];
+    items: readonly ChecklistItem<Key>[];
+    /**
+     * `state` groups the rows under their state's heading; `given` renders them
+     * in the order supplied.
+     *
+     * GROUPED IS THE DEFAULT, and that is the opposite of what a checklist
+     * usually wants. A checklist you work down top to bottom should stay in its
+     * given order — but this control's stated job is to make the shape of the gap
+     * legible, and an interleaved list makes the reader do the sorting in their
+     * head while the summary above already claims to have done it for them.
+     * `given` is there for the case where the order is itself meaningful — a
+     * sequence, a priority, a filing order — because then regrouping destroys
+     * information the consumer put in deliberately.
+     */
+    order?: "state" | "given";
+    /** Shown when `items` is empty. `EmptyState` supplies the shape. */
+    emptyTitle?: ReactNode;
+    emptyDescription?: ReactNode;
+    emptyAction?: ReactNode;
+    emptyIcon?: ReactNode;
+    className?: string;
+}
+export declare function StatusChecklist<Key extends string = string>({ label, states, items, order, emptyTitle, emptyDescription, emptyAction, emptyIcon, className, }: StatusChecklistProps<Key>): import("react").JSX.Element;

package/dist/types/components/checklist/index.d.ts

@@ -0,0 +1,3 @@
+export type { ChecklistItem, ChecklistState, ChecklistTally } from "./types";
+export { tallyChecklist } from "./tally";
+export { StatusChecklist, type StatusChecklistProps } from "./StatusChecklist";

package/dist/types/components/checklist/tally.d.ts

@@ -0,0 +1,19 @@
+import type { StatusOption } from "../StatusSelect";
+import type { ChecklistItem, ChecklistTally } from "./types";
+/**
+ * Split `items` across the declared `states`, in the order the states were
+ * given.
+ *
+ * Every state appears in the result, INCLUDING EMPTY ONES. A zero is
+ * information — "nothing is blocking" is the single most useful thing this
+ * control ever says — and a chip that vanishes at zero is invisible at exactly
+ * the moment its emptiness is the news, while also making the summary row
+ * change width every time an item moves. The BODY is the other way round: see
+ * `StatusChecklist`.
+ *
+ * Throws rather than tolerating: an unknown state key, a duplicate state, a
+ * duplicate item id, or no states at all. Each of those renders as something
+ * plausible if allowed through — an item silently dropped from a list whose
+ * whole purpose is to be exhaustive is the worst failure this component has.
+ */
+export declare function tallyChecklist<Key extends string>(states: readonly StatusOption<Key>[], items: readonly ChecklistItem<Key>[]): ChecklistTally<Key>[];

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

@@ -0,0 +1,28 @@
+import type { ReactNode } from "react";
+import type { StatusOption } from "../StatusSelect";
+export type ChecklistState<Key extends string = string> = StatusOption<Key>;
+export interface ChecklistItem<Key extends string = string> {
+    id: string;
+    /** What the item IS. The row's own text — never replaced by an aria-label. */
+    label: ReactNode;
+    /** Must be the `value` of one of the declared states. An unknown key throws. */
+    state: Key;
+    /** A second line: who it is with, when it was asked for, why it is missing. */
+    detail?: ReactNode;
+    /**
+     * A control for this row — "Request it", "Open", "Mark received".
+     *
+     * A slot rather than a `{label, onClick}` prop, for the same reason
+     * `RecordCard.badges` is one: whether the action is a button, a link, a menu
+     * or a spinner belongs to the surface, and every shape this prop could grow
+     * to cover would be a library release for a decision the consumer had
+     * already made.
+     */
+    action?: ReactNode;
+}
+/** One state, its option, and everything in it — in the declared order. */
+export interface ChecklistTally<Key extends string = string> {
+    option: StatusOption<Key>;
+    count: number;
+    items: ChecklistItem<Key>[];
+}

package/dist/types/components/drag-drop/context.d.ts

@@ -14,8 +14,12 @@ export interface DragDropContextValue {
      */
     instructionsId: string;
     /**
-     * True while a `<DragDropOverlay>` is mounted, i.e. while something else is
-     * able to carry the card. It decides whether an item vacates its own slot.
+     * True while a `<DragDropOverlay>` is mounted, i.e. while a portalled clone
+     * is carrying the card and the row itself should render as the hole it left.
+     *
+     * It selects WHICH of the two carries the card, never WHETHER one does: with
+     * no overlay the row follows the pointer under its own transform
+     * (`shift.ts#carriedOffset`). Either way the slot is vacated and closes.
      */
     lifted: boolean;
     registerOverlay: () => () => void;

package/dist/types/components/drag-drop/recipe.d.ts

@@ -21,6 +21,12 @@ export declare const dnd: import("tailwind-variants").TVReturnType<{
         };
         false: {};
     };
+    carried: {
+        true: {
+            shift: string;
+        };
+        false: {};
+    };
     mode: {
         pointer: {
             overlay: string;
@@ -61,6 +67,12 @@ export declare const dnd: import("tailwind-variants").TVReturnType<{
         };
         false: {};
     };
+    carried: {
+        true: {
+            shift: string;
+        };
+        false: {};
+    };
     mode: {
         pointer: {
             overlay: string;
@@ -101,6 +113,12 @@ export declare const dnd: import("tailwind-variants").TVReturnType<{
         };
         false: {};
     };
+    carried: {
+        true: {
+            shift: string;
+        };
+        false: {};
+    };
     mode: {
         pointer: {
             overlay: string;

package/dist/types/components/drag-drop/shift.d.ts

@@ -1,4 +1,4 @@
-import type { ContainerId, DragAxis, DragState, LayoutSnapshot } from "../../lib/dnd";
+import type { ContainerId, DragAxis, DragState, LayoutSnapshot, Point } from "../../lib/dnd";
 export interface ContainerShift {
     axis: DragAxis;
     /** Items in this container with the carried one removed. */
@@ -26,14 +26,54 @@ export interface ContainerShift {
      */
     markerShift: (restIndex: number) => number;
 }
+/**
+ * The carried item's own displacement from its resting box, in px — what makes
+ * the thing under the cursor BE the thing you picked up.
+ *
+ * WHY THIS EXISTS AT ALL. A `<DragDropOverlay>` is optional, and for a long
+ * while a board without one dragged nothing: the sibling gap opened correctly,
+ * the marker drew in the right place, and the row itself sat exactly where it
+ * had always been. Every automated check passed, because every one of them
+ * asserts against the ORDER a drop writes and the order was right — the defect
+ * was that there was no visual connection between the pointer and the thing it
+ * was moving, which is a fact about pixels and nothing but a browser can see
+ * it. So following the pointer is now what the engine does by DEFAULT, and an
+ * overlay is what a consumer adds when the card must escape its container
+ * rather than what it adds to make the card move at all.
+ *
+ * `grab` is where inside the box the press landed, so the card tracks the point
+ * that was actually pressed rather than snapping a corner to the cursor. The
+ * rest box comes from the same snapshot the shift is computed from — re-taken
+ * on scroll, resize and every auto-scroll frame — so the card stays under the
+ * cursor while the list scrolls beneath it.
+ *
+ * Null in keyboard mode: there is no pointer to follow, and a keyboard drag
+ * moves slot to slot with the marker saying where. That is not a fallback — it
+ * is a different question with a different honest answer.
+ */
+export declare function carriedOffset(layout: LayoutSnapshot | null, state: DragState): Point | null;
+/**
+ * The carried item's follow offset as an inline style.
+ *
+ * A 2D `translate`, unlike `shiftStyle`'s axis-constrained one: the card is a
+ * held object rather than a row sliding along a list, and constraining it to
+ * the container's axis makes it slide off the cursor the moment the hand moves
+ * the other way.
+ */
+export declare function followStyle(offset: Point | null): {
+    translate: string;
+};
 /**
  * Everything one container needs to render the shift, or null when no drag is
  * in flight and nothing should move.
  *
- * `lifted` says whether something else is carrying the card — a
- * `<DragDropOverlay>` is mounted. It decides ONLY whether the home slot closes,
- * and the reason is not cosmetic: with no overlay the card is still sitting in
- * its own slot, so closing that slot slides a neighbour underneath it.
+ * WHETHER THE HOME SLOT CLOSES ASKS ONE QUESTION: has the card actually left
+ * it? Two different things can carry it away — a mounted `<DragDropOverlay>`
+ * (`lifted`), or the card following the pointer under its own transform
+ * (`carriedOffset`) — and either one empties the slot, so either one closes it.
+ * The reason this is not cosmetic runs the other way too: a KEYBOARD drag with
+ * no overlay has nothing carrying the card, so the card is still sitting in its
+ * own slot, and closing it there would slide a neighbour underneath it.
  */
 export declare function containerShift(layout: LayoutSnapshot | null, state: DragState, container: ContainerId, lifted: boolean): ContainerShift | null;
 /** A rect in viewport coordinates. */

package/dist/types/components/provenance/ProvenanceBadge.d.ts

@@ -1,12 +1,22 @@
 import type { ProvenanceState } from "./types";
+/** How much of the state the badge draws. The accessible name is the same either way. */
+export type ProvenanceBadgeAppearance = "word" | "icon";
 export interface ProvenanceBadgeProps {
     state: ProvenanceState;
     /** Render the badge even for states that are quiet by default. */
     alwaysShow?: boolean;
+    /**
+     * `"word"` (default) draws the icon and the word. `"icon"` draws the glyph in
+     * the same coloured box and keeps the word as visually-hidden text, so the
+     * announced name does not change.
+     *
+     * `"icon"` also lifts the quiet rule — see the note at the top of this file.
+     */
+    appearance?: ProvenanceBadgeAppearance;
     size?: "sm" | "md";
     className?: string;
 }
-export declare function ProvenanceBadge({ state, alwaysShow, size, className, }: ProvenanceBadgeProps): import("react").JSX.Element | null;
+export declare function ProvenanceBadge({ state, alwaysShow, appearance, size, className, }: ProvenanceBadgeProps): import("react").JSX.Element | null;
 /** The words this library uses for each state. Exported so a consumer's own
     filters and legends read the same as its badges. */
 export declare function provenanceStateLabel(state: ProvenanceState): string;

package/dist/types/components/provenance/ProvenanceDisclosure.d.ts

@@ -1,5 +1,7 @@
 import { type ReactNode } from "react";
 import type { ProvenanceRecord } from "./types";
+/** How much of the verification state the trigger draws. */
+export type ProvenanceTriggerBadge = "icon" | "word" | "none";
 export interface ProvenanceDisclosureProps {
     record: ProvenanceRecord;
     /**
@@ -14,6 +16,49 @@ export interface ProvenanceDisclosureProps {
     emptyLabel?: string;
     /** Shown in place of the value when the viewer may not see it. */
     redactedLabel?: string;
+    /**
+     * How the state reads ON THE TRIGGER. The panel always shows icon + word.
+     *
+     * - `"word"` (default) — today's behaviour exactly, quiet rule included: the
+     *   exceptions wear a worded badge and `verified` wears nothing.
+     * - `"icon"` — the glyph alone, in the same coloured box, for ALL FOUR states
+     *   including `verified`. A dense table of values wants a legend, not four
+     *   hundred sentences; the word is still announced (see below).
+     * - `"none"` — no badge at all, for a consumer drawing the state itself in an
+     *   adjacent column. The state then leaves the accessible name too, because
+     *   the name says what the trigger says and nothing more.
+     */
+    triggerBadge?: ProvenanceTriggerBadge;
+    /**
+     * Let a long value wrap onto more lines instead of truncating.
+     *
+     * Off by default because the component's home is a dense table where a
+     * ragged row height is worse than an ellipsis. On by default would be wrong;
+     * unavailable was also wrong — a value clipped at `No — typed notes only, at
+     * gu…` in a 900px column is not a value, and there was no way in.
+     */
+    valueWrap?: boolean;
+    /**
+     * Draw something else in place of the value — an id chip, an avatar, a
+     * sparkline — and anchor the panel to THAT.
+     *
+     * NOT a whole-trigger slot, and the difference matters. This node becomes the
+     * CONTENT of the disclosure's own button; the button, its focus ring, its tap
+     * target and its accessible name stay with the component. A prop that took
+     * the control itself would hand a consumer all four obligations at once, and
+     * the observed result of consumers owning this one is a chip that announces a
+     * bare id ("FM-002") with no field, no value and no state — which is the
+     * exact defect this library has now shipped three times.
+     *
+     * Pass presentational markup. An interactive element here nests a control
+     * inside a control, which is invalid and unfocusable.
+     *
+     * The field, the state and the "show where this came from" affordance are
+     * still composed around it, so the announced name is the same as any other
+     * disclosure's. The dotted underline is dropped — a chip carries its own
+     * edges and does not want a second one.
+     */
+    triggerContent?: ReactNode;
     className?: string;
 }
-export declare function ProvenanceDisclosure({ record, actions, emptyLabel, redactedLabel, className, }: ProvenanceDisclosureProps): import("react").JSX.Element;
+export declare function ProvenanceDisclosure({ record, actions, emptyLabel, redactedLabel, triggerBadge, valueWrap, triggerContent, className, }: ProvenanceDisclosureProps): import("react").JSX.Element;

package/dist/types/components/stepper/Stepper.d.ts

@@ -0,0 +1,44 @@
+import { type ReactNode } from "react";
+import type { Step, StepStatus, StepperProgress } from "./types";
+export type { Step, StepStatus, StepperProgress };
+export interface StepperProps {
+    /**
+     * What this flow IS — "Case intake", "Deployment".
+     *
+     * It names the ordered list, which is how somebody arriving at the rail
+     * learns what the sequence is for. Required rather than optional for the same
+     * reason `KanbanBoard.label` is: an unnamed list announces as "list" and
+     * gives nobody a reason to be in it.
+     */
+    label: string;
+    steps: readonly Step[];
+    /** 0-based. Out of range throws — see `assertSteps`. */
+    current: number;
+    /**
+     * Move the cursor.
+     *
+     * ABSENT MAKES THE WHOLE RAIL A READ-OUT: no step is clickable and no
+     * forward/back control is drawn. The configuration is the switch, the same
+     * way `UseCaseCard` only becomes editable when handed `onStatusChange`. A
+     * consumer driving its own buttons omits this and keeps the rail.
+     */
+    onCurrentChange?: (index: number) => void;
+    /**
+     * What the last step's forward control does. Absent means no control is drawn
+     * on the last step — a wizard whose final action lives in its own form.
+     */
+    onFinish?: () => void;
+    backLabel?: string;
+    nextLabel?: string;
+    finishLabel?: string;
+    /**
+     * `vertical` stacks the rail beside long-form content. `horizontal` is the
+     * default because a sequence reads left to right, which is also the only
+     * layout in which the connector between two steps means anything.
+     */
+    orientation?: "horizontal" | "vertical";
+    /** The CURRENT step's content. */
+    children?: ReactNode;
+    className?: string;
+}
+export declare function Stepper({ label, steps, current, onCurrentChange, onFinish, backLabel, nextLabel, finishLabel, orientation, children, className, }: StepperProps): import("react").JSX.Element;

package/dist/types/components/stepper/derive.d.ts

@@ -0,0 +1,48 @@
+import type { Step, StepStatus, StepperProgress } from "./types";
+/**
+ * Reject a flow that cannot be rendered honestly, loudly.
+ *
+ * Every one of these is unreachable through the component's own UI and silent
+ * if allowed through: an empty rail renders as a blank strip, an out-of-range
+ * cursor renders no current step at all, duplicate ids give React two elements
+ * with one key (which reconciles them into each other on the next change), and
+ * an empty `blocked` string disables the forward button while printing nothing
+ * beside it.
+ */
+export declare function assertSteps(steps: readonly Step[], current: number): void;
+/**
+ * What one step IS, given where the cursor is.
+ *
+ * PRECEDENCE, and the first rule is the interesting one. `blocked` outranks
+ * everything, including `complete`, wherever the step sits. Data saying both
+ * is contradictory, and when a record contradicts itself the exception is what
+ * the reader needs — the same call `ProvenanceBadge` makes when it stays quiet
+ * on the ordinary case and loud on every other one. An affirmative that hides
+ * an obstruction is the worse of the two possible mistakes.
+ *
+ * Note that a `blocked` reason on a step OTHER than the current one still
+ * renders as blocked but gates nothing: only the current step's reason can stop
+ * forward movement (see `advanceBlockReason`). That is deliberate — a flow can
+ * legitimately want to say "and this one ahead needs a signature" without
+ * claiming that is why you are stuck right now.
+ */
+export declare function stepStatus(steps: readonly Step[], current: number, index: number): StepStatus;
+/**
+ * Why forward movement is refused, or `null` when it is not.
+ *
+ * ONLY THE CURRENT STEP GATES. A reason on a step you are not standing on is
+ * information about that step, not a claim about this one.
+ *
+ * `null` is the only "not blocked" value — an empty string is rejected at
+ * `assertSteps` rather than treated as absent, so a falsy check here cannot
+ * turn a reason that failed to load into permission to proceed.
+ */
+export declare function advanceBlockReason(steps: readonly Step[], current: number): string | null;
+/**
+ * Position and completion, as two numbers that are allowed to disagree.
+ *
+ * This exists so a consumer that genuinely wants a bar builds it from a named
+ * number instead of guessing which one a bar meant. The component itself draws
+ * no percentage — see the note on `Stepper`.
+ */
+export declare function stepperProgress(steps: readonly Step[], current: number): StepperProgress;

package/dist/types/components/stepper/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./types";
+export * from "./derive";
+export { Stepper, type StepperProps } from "./Stepper";

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

@@ -0,0 +1,70 @@
+import type { ReactNode } from "react";
+export interface Step {
+    id: string;
+    /** Shown on the rail and spoken as the step's name. */
+    label: string;
+    /** What this step is for. One line, under the label. */
+    hint?: ReactNode;
+    /**
+     * Finished.
+     *
+     * ABSENT MEANS NOT COMPLETE. There is no third state, and none is invented:
+     * nobody has ever needed to record that they do not know whether a step was
+     * finished. This is the same call `RoadmapItem.built` makes about an absent
+     * track key, and it is what keeps `!step.complete` from having two readings.
+     */
+    complete?: boolean;
+    /**
+     * Why the flow cannot move on from here. Absent means it can.
+     *
+     * Written for the person who would have pressed the button — "two documents
+     * are still missing", not "invalid". It is rendered beside the forward
+     * control rather than only disabling it, because a dead button with no
+     * sentence next to it is indistinguishable from a broken one.
+     *
+     * AN EMPTY STRING THROWS, and that is a deliberate divergence from
+     * `KanbanLane.refusal`, which accepts one. There the reason is supporting
+     * detail on a lane that is already visibly refusing; here the sentence IS the
+     * mechanism — an empty one produces exactly the mute disabled button this
+     * prop exists to prevent, so it is rejected loudly instead of rendered as
+     * nothing.
+     */
+    blocked?: string;
+}
+/**
+ * What a step IS right now — derived from the steps and the cursor, never
+ * stored.
+ *
+ * Five, not two, because "finished", "you are here", "you skipped it", "not
+ * reached yet" and "this is what is stopping you" call for four different
+ * next actions and one absence of action. Collapsing them to a boolean is what
+ * produces a rail where a skipped step and an untouched one look identical.
+ */
+export type StepStatus = 
+/** `complete: true`. */
+"complete"
+/** Carries a `blocked` reason. Beats every other reading — see `stepStatus`. */
+ | "blocked"
+/** The cursor is on it. */
+ | "current"
+/** Behind the cursor and not complete: passed over. */
+ | "incomplete"
+/** Ahead of the cursor. Not a fault — simply not reached. */
+ | "upcoming";
+/**
+ * The two numbers a stepper header is tempted to average into one bar.
+ *
+ * `position` is where the cursor is; `complete` is how many are finished. They
+ * disagree the moment anybody moves past a step without finishing it, and
+ * `skipped` is that disagreement stated as a number rather than hidden inside
+ * a percentage.
+ */
+export interface StepperProgress {
+    /** 1-based, for reading: "Step 3 of 5". */
+    position: number;
+    total: number;
+    /** How many steps are `complete`, anywhere in the flow. */
+    complete: number;
+    /** Behind the cursor and not complete. */
+    skipped: number;
+}

package/dist/types/index.d.ts

@@ -13,6 +13,7 @@ export { Icon, type IconProps, type IconSize, type IconName } from "./components
 export { registerIcon, registerIcons, getIcon, hasIcon, iconNames, type IconNode, type IconNodeChild, } from "./lib/icons";
 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 { Spinner, type SpinnerProps } from "./components/Spinner";
 export { Skeleton, SkeletonText, LoadingOverlay, type SkeletonProps, type SkeletonTextProps, type LoadingOverlayProps, } from "./components/Loading";
@@ -41,6 +42,8 @@ export { RecordCard, type RecordCardProps, type RecordCardMetric, } from "./comp
 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";
+export { Stepper, stepStatus, stepperProgress, advanceBlockReason, assertSteps, type StepperProps, type Step, type StepStatus, type StepperProgress, } from "./components/stepper";
+export { StatusChecklist, tallyChecklist, type StatusChecklistProps, type ChecklistItem, type ChecklistState, type ChecklistTally, } from "./components/checklist";
 export { Toggle, ToggleGroup, Toolbar, ToolbarSeparator, type ToggleProps, type ToggleGroupProps, type ToolbarProps, } from "./components/Toggle";
 export { Separator, ScrollArea, Collapsible, EmptyState, Timeline, type SeparatorProps, type ScrollAreaProps, type CollapsibleProps, type EmptyStateProps, type TimelineProps, type TimelineItem, } from "./components/Surface";
 export { PanelGroup, Panel, PanelResizer, type PanelGroupProps, type PanelProps, type PanelResizerProps, type PanelDirection, type PanelNarrowMode, } from "./components/Panel";
@@ -96,5 +99,5 @@ export { AmbiguousTimeError, addDays, addDuration, addMonths, atMidnight, atTime
 export { allDayBandSegment, dayKey, daySlots, isAllDay, packBand, packLanes, snapFractionToInstant, timeSegments, timedBandSegment, type AllDayEvent, type BandInput, type BandOptions, type BandPlacement, type BandResult, type BandSegment, type CalendarEvent, type CalendarEventId, type CalendarView, type DaySlot, type DragKind, type EventDraft, type EventPalette, type LaneInput, type LaneOptions, type LanePlacement, type PaletteEntry, type TimeSegment, type TimedEvent, type VisibleRange, } from "./lib/calendar";
 export { RBACProvider, useRBAC, AccountMenu, DevToolsPopover, RolePermissionMatrix, ProfilePage, RolesPermissionsPage, type RBACProviderProps, type RBACHookResult, type AccountMenuProps, type DevToolsPopoverProps, type RolePermissionMatrixProps, type Permission, type Role, type User, type Team, type TeamMembership, } from "./components/rbac";
 export { UseCaseCard, RoadmapItemCard, RoadmapSwimlaneBoard, UseCaseLedgerPage, RoadmapPage, PhaseManager, TrackManager, deriveRoadmapItemStatus, isFullyBuilt, isUnbuilt, trackIds, trackProgress, toneForIndex, CATEGORY_TONES, type Domain, type Phase, type Track, type RoadmapItem, type RoadmapItemStatus, type UseCase, type UseCaseStatus, type UseCaseDecision, type UseCaseCardProps, type RoadmapItemCardProps, type RoadmapSwimlaneBoardProps, type UseCaseLedgerPageProps, type RoadmapPageProps, type PhaseManagerProps, type TrackManagerProps, } from "./components/roadmap";
-export { ProvenanceDisclosure, ProvenanceBadge, ConfidenceMeter, provenanceStateLabel, confidenceBand, type ProvenanceRecord, type ProvenanceState, type ProvenanceSource, type ProvenanceCheck, type ProvenanceCall, type ProvenanceSignoff, type ConfidenceBand, type ProvenanceDisclosureProps, type ProvenanceBadgeProps, type ConfidenceMeterProps, } from "./components/provenance";
+export { ProvenanceDisclosure, ProvenanceBadge, ConfidenceMeter, provenanceStateLabel, confidenceBand, type ProvenanceRecord, type ProvenanceState, type ProvenanceSource, type ProvenanceCheck, type ProvenanceCall, type ProvenanceSignoff, type ConfidenceBand, type ProvenanceDisclosureProps, type ProvenanceTriggerBadge, type ProvenanceBadgeProps, type ProvenanceBadgeAppearance, type ConfidenceMeterProps, } from "./components/provenance";
 export { createSimStore, resetSimStores, useSimSettings, setSimSettings, getNetworkSpeed, getDataSource, simulateLatency, SimNetworkError, type SimStore, type SimStoreOptions, type SimSettings, type NetworkSpeed, type DataSource, type SimNamespace, } from "./lib/sim";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danxbot/ui",
-  "version": "2.2.2",
+  "version": "2.4.0",
   "type": "module",
   "description": "Danxbot — a domain-agnostic React design system with motion as a first-class primitive.",
   "license": "MIT",
@@ -78,7 +78,7 @@
     "audit:arrows": "node scripts/audit-arrows.mjs",
     "audit:motion": "node scripts/audit-motion.mjs",
     "audit:responsive": "node scripts/audit-responsive.mjs",
-    "audit:dnd": "node scripts/audit-dnd.mjs && node scripts/probe-dnd-sensors.mjs && node scripts/probe-dnd-a11y.mjs",
+    "audit:dnd": "node scripts/audit-dnd.mjs && node scripts/probe-dnd-sensors.mjs && node scripts/probe-dnd-a11y.mjs && node scripts/probe-drag-follow.mjs",
     "audit:axtree": "node scripts/audit-axtree.mjs",
     "audit:mutations": "node scripts/audit-mutations.mjs",
     "audit:palette": "node scripts/audit-palette.mjs",