@danxbot/ui 2.3.0 → 2.5.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/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/node-canvas/NodeCanvas.d.ts

@@ -0,0 +1,58 @@
+import type { CanvasNode, CanvasOrientation, NodeRenderer } from "./types";
+export interface NodeCanvasProps<Extra = unknown> {
+    /** The whole tree. The canvas walks into it; it never mutates it. */
+    root: CanvasNode<Extra>;
+    /**
+     * What this canvas IS — "Org chart", "Dependency graph for the March build".
+     *
+     * Required for the same reason `StatusChecklist.label` and
+     * `KanbanBoard.label` are: it is the accessible name of the whole structure,
+     * and somebody landing on it by keyboard has nothing else to tell them what
+     * they are inside.
+     */
+    label: string;
+    /**
+     * The node body. Receives the consumer's own node type and a context of
+     * purely structural facts.
+     *
+     * A RENDER PROP RATHER THAN CHILDREN-AS-A-FUNCTION, because a canvas draws
+     * MANY nodes and `children` reads as one. `<NodeCanvas>{(node) => …}` looks
+     * like a single child and is really a template invoked N times, which is the
+     * ambiguity this library already avoids elsewhere (`ProvenanceDisclosure`
+     * takes `actions`, `Chat` takes a `components` map). It is optional: the
+     * default draws the `label` the node already declares and nothing else, so
+     * the component is usable with no wiring and the default introduces no
+     * vocabulary of its own.
+     */
+    renderNode?: NodeRenderer<Extra>;
+    /** Which way the chart grows. See `CanvasOrientation`. */
+    orientation?: CanvasOrientation;
+    /** Levels below the current root to draw. `1` is the root and its children. */
+    depth?: number;
+    /** Along-axis extent of a node that does not declare its own, in px. */
+    nodeWidth?: number;
+    /** Cross-axis extent of a node that does not declare its own, in px. */
+    nodeHeight?: number;
+    /** Height of the scrolling viewport. Any CSS length. */
+    height?: string;
+    /**
+     * Fired after the canvas re-roots, with the trail from the ORIGINAL root.
+     *
+     * Observation, not control: the canvas owns where it is. A consumer that
+     * needs to restore a position across a reload stores this and remounts with
+     * a different `root`.
+     */
+    onRootChange?: (node: CanvasNode<Extra>, path: CanvasNode<Extra>[]) => void;
+    /** Fired when a node drag commits. The offset is from its laid-out position. */
+    onNodeDragEnd?: (event: {
+        id: string;
+        offset: {
+            x: number;
+            y: number;
+        };
+    }) => void;
+    /** Nothing pans, drags or descends. Reading still works, including by keyboard. */
+    disabled?: boolean;
+    className?: string;
+}
+export declare function NodeCanvas<Extra = unknown>({ root, label, renderNode, orientation, depth, nodeWidth, nodeHeight, height, onRootChange, onNodeDragEnd, disabled, className, }: NodeCanvasProps<Extra>): import("react").JSX.Element;

package/dist/types/components/node-canvas/index.d.ts

@@ -0,0 +1,3 @@
+export { NodeCanvas, type NodeCanvasProps } from "./NodeCanvas";
+export { LAYOUT_DEFAULTS, layoutTree, pathToNode } from "./layout";
+export type { CanvasEdge, CanvasLayout, CanvasNode, CanvasOrientation, LayoutOptions, NodeRenderContext, NodeRenderer, PlacedNode, } from "./types";

package/dist/types/components/node-canvas/layout.d.ts

@@ -0,0 +1,17 @@
+import type { CanvasLayout, CanvasNode, LayoutOptions } from "./types";
+export declare const LAYOUT_DEFAULTS: Required<LayoutOptions>;
+/**
+ * Lay a tree out.
+ *
+ * Coordinates are plane-local and start at 0 on both axes: the caller decides
+ * where the plane sits and how much padding surrounds it.
+ */
+export declare function layoutTree<Extra>(root: CanvasNode<Extra>, options?: LayoutOptions): CanvasLayout<Extra>;
+/**
+ * The ids from the ORIGINAL root down to `targetId`, inclusive.
+ *
+ * `null` when the id is not in the tree, which the canvas treats as a
+ * programming error rather than as an empty trail — a breadcrumb that silently
+ * renders nothing is how a broken `rootId` looks like a styling bug.
+ */
+export declare function pathToNode<Extra>(root: CanvasNode<Extra>, targetId: string): CanvasNode<Extra>[] | null;

package/dist/types/components/node-canvas/types.d.ts

@@ -0,0 +1,113 @@
+import type { ReactNode } from "react";
+/**
+ * One node of the tree.
+ *
+ * `Extra` carries the consumer's own fields DOWN THE WHOLE TREE, so
+ * `renderNode` receives their type rather than ours plus a cast:
+ *
+ * ```ts
+ * type Task = { owner: string; done: boolean };
+ * const root: CanvasNode<Task> = { id: "r", label: "Release", owner: "ada", done: false, children: [...] };
+ * <NodeCanvas root={root} renderNode={(node) => <span>{node.owner}</span>} />
+ * ```
+ *
+ * Written as an intersection rather than an interface with a type parameter
+ * because the recursion has to carry `Extra` into `children` — an interface
+ * cannot refer to its own instantiation that way without a self-referencing
+ * constraint that every consumer then has to spell out.
+ */
+export type CanvasNode<Extra = unknown> = Extra & {
+    /** Stable across renders. Node positions, focus and drag offsets are keyed on it. */
+    id: string;
+    /**
+     * The accessible name, the breadcrumb text, and the default body.
+     *
+     * A plain string, not a `ReactNode`, and that is deliberate: it is read
+     * aloud and printed into a trail, and neither of those can do anything with
+     * an element tree. Rich content belongs in `renderNode`.
+     */
+    label: string;
+    children?: readonly CanvasNode<Extra>[];
+    /** Along-axis extent for this node only, when it differs from the canvas default. */
+    width?: number;
+    /** Cross-axis extent for this node only, when it differs from the canvas default. */
+    height?: number;
+};
+/**
+ * Which way the chart grows.
+ *
+ * `vertical` puts the root at the top with children below it — the shape most
+ * people picture. `horizontal` puts the root at the left with children to the
+ * right, which is what deep trees with long labels actually want: label text
+ * runs along the level axis in one and across it in the other, so a horizontal
+ * chart of the same tree is narrower and reads without truncation.
+ */
+export type CanvasOrientation = "vertical" | "horizontal";
+/** A node with its box resolved, in plane coordinates. `x`/`y` are its TOP-LEFT. */
+export interface PlacedNode<Extra = unknown> {
+    id: string;
+    node: CanvasNode<Extra>;
+    /** 0 for the node the canvas is currently rooted on. */
+    depth: number;
+    /** Null for the current root. Ids of nodes outside this view never appear. */
+    parentId: string | null;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** How many children it has, whether or not this view is showing them. */
+    childCount: number;
+    /**
+     * It has children and this view is not drawing them — the node sits on the
+     * bottom row of the visible depth. The affordance to descend belongs here.
+     */
+    hasHiddenChildren: boolean;
+}
+/** Parent → child, by id. Both ends are always present in `nodes`. */
+export interface CanvasEdge {
+    from: string;
+    to: string;
+}
+export interface CanvasLayout<Extra = unknown> {
+    nodes: PlacedNode<Extra>[];
+    edges: CanvasEdge[];
+    /** Extent of the laid-out nodes. The plane is this plus padding on each side. */
+    width: number;
+    height: number;
+}
+export interface LayoutOptions {
+    /** Along-axis extent of a node that does not declare its own. */
+    nodeWidth?: number;
+    /** Cross-axis extent of a node that does not declare its own. */
+    nodeHeight?: number;
+    /** Clear space between two adjacent nodes on the same level. */
+    siblingGap?: number;
+    /** Clear space between one level and the next. */
+    levelGap?: number;
+    orientation?: CanvasOrientation;
+    /**
+     * How many levels BELOW the root to draw. `1` shows the root and its
+     * children; `0` shows the root alone.
+     */
+    depth?: number;
+}
+/**
+ * What `renderNode` is told about the node it is drawing.
+ *
+ * Every field is structural — a fact about the node's place in the tree or in
+ * the current interaction. None of them is a fact about what the node is.
+ */
+export interface NodeRenderContext {
+    /** 0 for the node the canvas is rooted on. */
+    depth: number;
+    isRoot: boolean;
+    childCount: number;
+    hasChildren: boolean;
+    /** Children exist and this view stops short of them — clicking descends. */
+    hasHiddenChildren: boolean;
+    /** This node carries the canvas's single tab stop. */
+    isFocused: boolean;
+    /** A pointer is carrying this node right now. */
+    isDragging: boolean;
+}
+export type NodeRenderer<Extra = unknown> = (node: CanvasNode<Extra>, context: NodeRenderContext) => ReactNode;

package/dist/types/components/node-canvas/use-canvas-gestures.d.ts

@@ -0,0 +1,39 @@
+import type { Point } from "@/lib/dnd/types";
+/** Plane-local box of a node, as the layout placed it. */
+export interface NodeBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface CanvasGestureOptions {
+    /** Where a node sits before any drag offset. Null for an id not on screen. */
+    layoutBoxOf: (id: string) => NodeBox | null;
+    /** Extent of the scrolled plane. Node positions are clamped inside it. */
+    planeSize: {
+        width: number;
+        height: number;
+    };
+    /** A press that released without activating — the click that descends. */
+    onNodeClick: (id: string) => void;
+    /** A drag that committed. Offsets stay owned here either way. */
+    onNodeDragEnd?: (event: {
+        id: string;
+        offset: Point;
+    }) => void;
+    disabled?: boolean;
+}
+export interface CanvasGestures {
+    /** Drag offsets from the layout position, by node id. */
+    offsets: Readonly<Record<string, Point>>;
+    /** The node a pointer is currently carrying, or null. */
+    draggingId: string | null;
+    panning: boolean;
+    /** Ref callback for the scroll viewport. Stable — see the note at its use. */
+    bindViewport: (node: HTMLDivElement | null) => void;
+    /** Ref callback for one node's element. Stable per id. */
+    bindNode: (id: string) => (node: HTMLElement | null) => void;
+    /** Drop every offset — called when the layout underneath them changes. */
+    clearOffsets: () => void;
+}
+export declare function useCanvasGestures(options: CanvasGestureOptions): CanvasGestures;

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/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";
@@ -98,5 +99,6 @@ 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";
+export { NodeCanvas, LAYOUT_DEFAULTS, layoutTree, pathToNode, type NodeCanvasProps, type CanvasEdge, type CanvasLayout, type CanvasNode, type CanvasOrientation, type LayoutOptions, type NodeRenderContext, type NodeRenderer, type PlacedNode, } from "./components/node-canvas";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danxbot/ui",
-  "version": "2.3.0",
+  "version": "2.5.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 && node scripts/probe-drag-overflow.mjs && node scripts/probe-node-canvas.mjs",
     "audit:axtree": "node scripts/audit-axtree.mjs",
     "audit:mutations": "node scripts/audit-mutations.mjs",
     "audit:palette": "node scripts/audit-palette.mjs",