@camstack/ui-library 1.2.257 → 1.2.259

package/dist/lib/scrub-controller.d.ts

@@ -1,115 +1,112 @@
-export type ScrubSource = 'timeline' | 'heatmap';
+export type ScrubSource = "timeline" | "heatmap";
 export interface ScrubState {
-    readonly scrubbing: boolean;
-    readonly scrubEpoch: number | null;
-    readonly playheadEpoch: number | null;
-    readonly lastSource: ScrubSource | null;
+	readonly scrubbing: boolean;
+	readonly scrubEpoch: number | null;
+	readonly playheadEpoch: number | null;
+	readonly lastSource: ScrubSource | null;
 }
 export declare const initialScrubState: ScrubState;
 export type ScrubAction = {
-    readonly type: 'begin';
-    readonly source: ScrubSource;
+	readonly type: "begin";
+	readonly source: ScrubSource;
 } | {
-    readonly type: 'update';
-    readonly epoch: number;
-    readonly source: ScrubSource;
+	readonly type: "update";
+	readonly epoch: number;
+	readonly source: ScrubSource;
 } | {
-    readonly type: 'end';
-    readonly epoch: number;
-    readonly source: ScrubSource;
+	readonly type: "end";
+	readonly epoch: number;
+	readonly source: ScrubSource;
 } | {
-    readonly type: 'seek';
-    readonly epoch: number;
-    readonly source: ScrubSource;
+	readonly type: "seek";
+	readonly epoch: number;
+	readonly source: ScrubSource;
 } | {
-    readonly type: 'playhead';
-    readonly epoch: number;
+	readonly type: "playhead";
+	readonly epoch: number;
 } | {
-    readonly type: 'reset';
+	readonly type: "reset";
 };
 export declare function scrubReducer(state: ScrubState, action: ScrubAction): ScrubState;
 /**
- * Throttle decision for continuous `update` emits (default ~70 ms).
- * Returns true when enough time has elapsed since the last emit.
- */
+* Throttle decision for continuous `update` emits (default ~70 ms).
+* Returns true when enough time has elapsed since the last emit.
+*/
 export declare function shouldEmit(lastEmitMs: number, now: number, throttleMs?: number): boolean;
 /** The last committed target (epoch + wall-clock of the commit). */
 export interface LastCommit {
-    readonly epoch: number;
-    readonly at: number;
+	readonly epoch: number;
+	readonly at: number;
 }
 /** Epochs within this many ms of the last commit count as the SAME target. */
 export declare const COMMIT_DEDUPE_TOLERANCE_MS = 750;
 /** Only dedupe against a commit made within this recent window. */
-export declare const COMMIT_DEDUPE_WINDOW_MS = 2000;
+export declare const COMMIT_DEDUPE_WINDOW_MS = 2e3;
 /**
- * Decide whether a `seek`/`scrubCommit` should actually hit the playback sink.
- * Each commit reloads the server feeder (loading→playing) and visibly stutters
- * playback; firing the same (or a near-identical) target twice in quick
- * succession produces a redundant reload. Drop a commit only when it targets
- * essentially the SAME epoch as the last commit AND that commit was recent — a
- * genuinely different target, or a re-seek to the same spot after the window,
- * always commits.
- */
+* Decide whether a `seek`/`scrubCommit` should actually hit the playback sink.
+* Each commit reloads the server feeder (loading→playing) and visibly stutters
+* playback; firing the same (or a near-identical) target twice in quick
+* succession produces a redundant reload. Drop a commit only when it targets
+* essentially the SAME epoch as the last commit AND that commit was recent — a
+* genuinely different target, or a re-seek to the same spot after the window,
+* always commits.
+*/
 export declare function shouldCommit(last: LastCommit | null, epoch: number, now: number, toleranceMs?: number, windowMs?: number): boolean;
 /**
- * The active cursor position (scrub target while scrubbing, else playhead)
- * expressed as a 0..1 fraction across the day window.
- * Returns null when no position is known or the day window is degenerate.
- */
+* The active cursor position (scrub target while scrubbing, else playhead)
+* expressed as a 0..1 fraction across the day window.
+* Returns null when no position is known or the day window is degenerate.
+*/
 export declare function cursorFractionFor(state: ScrubState, day: {
-    readonly from: number;
-    readonly to: number;
+	readonly from: number;
+	readonly to: number;
 }): number | null;
 /**
- * Generic, always-active playback control surface the scrub controller
- * drives. `scrubStart`/`scrubTo` are CLIENT-SIDE hooks (the wire protocol has
- * no per-move scrub message — a future WebCodecs preview consumes them);
- * `scrubCommit`/`seek` reach the server feeder.
- */
+* Generic, always-active playback control surface the scrub controller
+* drives. `scrubStart`/`scrubTo` are CLIENT-SIDE hooks (the wire protocol has
+* no per-move scrub message — a future WebCodecs preview consumes them);
+* `scrubCommit`/`seek` reach the server feeder.
+*/
 export interface PlaybackControlSink {
-    scrubStart(): void;
-    scrubTo(epochMs: number): void;
-    scrubCommit(epochMs: number): void;
-    seek(epochMs: number): void;
+	scrubStart(): void;
+	scrubTo(epochMs: number): void;
+	scrubCommit(epochMs: number): void;
+	seek(epochMs: number): void;
 }
 /** A mutable holder, structurally compatible with React's `MutableRefObject`. */
 export interface MutableRef<T> {
-    current: T;
+	current: T;
 }
 /** The gesture callbacks the hook exposes (everything except `state`). */
-type ScrubBridge = Omit<ScrubController, 'state'>;
+type ScrubBridge = Omit<ScrubController, "state">;
 /**
- * Builds the always-active bridge callbacks from a sink, a dispatch, and the
- * throttle ref. Pure (no React) so it can be unit-tested directly: the hook
- * just wraps the result in `useMemo`.
- *
- * Every gesture drives the sink immediately — there is no VOD-active gate.
- */
-export declare function makeScrubBridge(sink: PlaybackControlSink, dispatch: (action: ScrubAction) => void, lastEmitRef: MutableRef<number>, lastCommitRef?: MutableRef<LastCommit | null>, 
-/** Reports whether the PLAYER is currently on the live edge (not in recorded
- *  mode). Used to bypass commit-dedupe on the live→recorded transition. */
-isPlayerLive?: () => boolean): ScrubBridge;
+* Builds the always-active bridge callbacks from a sink, a dispatch, and the
+* throttle ref. Pure (no React) so it can be unit-tested directly: the hook
+* just wraps the result in `useMemo`.
+*
+* Every gesture drives the sink immediately — there is no VOD-active gate.
+*/
+export declare function makeScrubBridge(sink: PlaybackControlSink, dispatch: (action: ScrubAction) => void, lastEmitRef: MutableRef<number>, lastCommitRef?: MutableRef<LastCommit | null>, isPlayerLive?: () => boolean): ScrubBridge;
 export interface ScrubController {
-    readonly state: ScrubState;
-    readonly beginScrub: (source: ScrubSource) => void;
-    readonly updateScrub: (epoch: number, source: ScrubSource) => void;
-    readonly endScrub: (epoch: number, source: ScrubSource) => void;
-    readonly seek: (epoch: number, source: ScrubSource) => void;
-    readonly setPlayhead: (epoch: number) => void;
-    readonly reset: () => void;
+	readonly state: ScrubState;
+	readonly beginScrub: (source: ScrubSource) => void;
+	readonly updateScrub: (epoch: number, source: ScrubSource) => void;
+	readonly endScrub: (epoch: number, source: ScrubSource) => void;
+	readonly seek: (epoch: number, source: ScrubSource) => void;
+	readonly setPlayhead: (epoch: number) => void;
+	readonly reset: () => void;
 }
 /**
- * Owns the shared scrub position and bridges it to a playback control sink.
- *
- * The bridge is always active: any gesture (drag or tap) drives the sink
- * immediately. There is no VOD-active gate — the timeline always drives
- * playback while frame-push mode is on.
- *
- * @param sink Always-active playback control surface (e.g. the datachannel)
- * @param isPlayerLive Synchronous getter for "is the player on the live
- *   edge?" — lets a live→recorded commit bypass dedupe so the seek always
- *   reaches the server.
- */
+* Owns the shared scrub position and bridges it to a playback control sink.
+*
+* The bridge is always active: any gesture (drag or tap) drives the sink
+* immediately. There is no VOD-active gate — the timeline always drives
+* playback while frame-push mode is on.
+*
+* @param sink Always-active playback control surface (e.g. the datachannel)
+* @param isPlayerLive Synchronous getter for "is the player on the live
+*   edge?" — lets a live→recorded commit bypass dedupe so the seek always
+*   reaches the server.
+*/
 export declare function useScrubController(sink: PlaybackControlSink, isPlayerLive?: () => boolean): ScrubController;
 export {};

package/dist/lib/shared-context.d.ts

@@ -1,5 +1,30 @@
-import { Context } from 'react';
+/**
+* Cross-bundle React Context sharing.
+*
+* Addon page bundles (benchmark, etc.) ship their own bundled copy of
+* `@camstack/ui-library`. Without sharing, each bundle calls
+* `createContext()` and gets a fresh Context instance — so when the
+* bundle's hook reads from this Context, it doesn't match the host
+* admin-ui's <Provider> tree, and `useContext()` returns the default
+* value (typically `null`) which often causes a `must be used within
+* Provider` throw.
+*
+* This helper stashes Context instances on `globalThis` keyed by a
+* unique name, so the SECOND-evaluated copy reuses the host's
+* instance instead of creating a duplicate.
+*
+* Boot order:
+*   1. admin-ui's main.tsx evaluates first → globalThis Map is empty
+*      → creates Context, stores it under `name`.
+*   2. Addon bundle evaluates later → globalThis Map has the entry
+*      → returns the host's Context.
+*
+* Critical: pick UNIQUE `name`s. Two distinct contexts with the same
+* name will silently collide (and TypeScript can't catch it because
+* the Map is typed as `Context<unknown>`).
+*/
+import { type Context } from "react";
 declare global {
-    var __camstackSharedContexts: Map<string, Context<unknown>> | undefined;
+	var __camstackSharedContexts: Map<string, Context<unknown>> | undefined;
 }
 export declare function createSharedContext<T>(name: string, defaultValue: T): Context<T>;

package/dist/lib/tailwind-variants.d.ts

@@ -1,27 +1,27 @@
 /**
- * Predicates over a Tailwind class string, used by layout tests to assert a
- * responsive DECISION rather than a class literal.
- *
- * Why this exists: the two mobile defects fixed in 2026-08 were both "a
- * utility that should have been behind a breakpoint was applied at every
- * width" — a pinned first table column, a truncated settings value. The
- * invariant worth guarding is exactly that: `sticky` must not appear
- * unconditionally on the name column, `truncate` must not appear
- * unconditionally on a settings value. Asserting the whole `className`
- * byte-for-byte would guard something else (churn) and would go stale the
- * first time a padding token moves — see `docs/ui/conventions.md`,
- * "Frozen-string tests have an expiry date".
- *
- * A Tailwind class is `variant:variant:utility`. Everything before the last
- * `:` is a condition (breakpoint, state, container query); a class with no
- * `:` applies at every width and in every state.
- */
+* Predicates over a Tailwind class string, used by layout tests to assert a
+* responsive DECISION rather than a class literal.
+*
+* Why this exists: the two mobile defects fixed in 2026-08 were both "a
+* utility that should have been behind a breakpoint was applied at every
+* width" — a pinned first table column, a truncated settings value. The
+* invariant worth guarding is exactly that: `sticky` must not appear
+* unconditionally on the name column, `truncate` must not appear
+* unconditionally on a settings value. Asserting the whole `className`
+* byte-for-byte would guard something else (churn) and would go stale the
+* first time a padding token moves — see `docs/ui/conventions.md`,
+* "Frozen-string tests have an expiry date".
+*
+* A Tailwind class is `variant:variant:utility`. Everything before the last
+* `:` is a condition (breakpoint, state, container query); a class with no
+* `:` applies at every width and in every state.
+*/
 /** Split a class string into non-empty tokens. `undefined` ⇒ no tokens. */
 export declare function classTokens(className: string | undefined): readonly string[];
 /**
- * True when `utility` is applied with NO condition — i.e. at every width.
- * `hasUnconditionalClass('md:sticky', 'sticky')` is false: that is the point.
- */
+* True when `utility` is applied with NO condition — i.e. at every width.
+* `hasUnconditionalClass('md:sticky', 'sticky')` is false: that is the point.
+*/
 export declare function hasUnconditionalClass(className: string | undefined, utility: string): boolean;
 /** True when `utility` is applied behind the given `variant` (e.g. `md`). */
 export declare function hasVariantClass(className: string | undefined, variant: string, utility: string): boolean;

package/dist/primitives/badge.d.ts

@@ -1,11 +1,6 @@
-import { HTMLAttributes } from 'react';
-import { VariantProps } from 'class-variance-authority';
-declare const badgeVariants: (props?: ({
-    variant?: "info" | "danger" | "default" | "success" | "warning" | null | undefined;
-    styleVariant?: "outline" | "solid" | null | undefined;
-} & import('class-variance-authority/types').ClassProp) | undefined) => string;
-export interface BadgeProps extends Omit<HTMLAttributes<HTMLSpanElement>, 'style'>, VariantProps<typeof badgeVariants> {
-    style?: 'solid' | 'outline';
+import { type HTMLAttributes, type ForwardRefExoticComponent, type RefAttributes } from "react";
+export interface BadgeProps extends Omit<HTMLAttributes<HTMLSpanElement>, "style"> {
+	variant?: "default" | "success" | "warning" | "danger" | "info";
+	style?: "solid" | "outline";
 }
-export declare const Badge: import('react').ForwardRefExoticComponent<BadgeProps & import('react').RefAttributes<HTMLSpanElement>>;
-export {};
+export declare const Badge: ForwardRefExoticComponent<BadgeProps & RefAttributes<HTMLSpanElement>>;

package/dist/primitives/bottom-sheet.d.ts

@@ -1,9 +1,9 @@
-import { ReactNode } from 'react';
+import { type ReactNode, type JSX } from "react";
 export interface BottomSheetProps {
-    open: boolean;
-    onClose: () => void;
-    title?: string;
-    children: ReactNode;
-    className?: string;
+	open: boolean;
+	onClose: () => void;
+	title?: string;
+	children: ReactNode;
+	className?: string;
 }
-export declare function BottomSheet({ open, onClose, title, children, className }: BottomSheetProps): import("react").JSX.Element;
+export declare function BottomSheet({ open, onClose, title, children, className }: BottomSheetProps): JSX.Element;

package/dist/primitives/button.d.ts

@@ -1,10 +1,6 @@
-import { ButtonHTMLAttributes } from 'react';
-import { VariantProps } from 'class-variance-authority';
-declare const buttonVariants: (props?: ({
-    variant?: "primary" | "secondary" | "ghost" | "danger" | "outline" | null | undefined;
-    size?: "sm" | "md" | "lg" | null | undefined;
-} & import('class-variance-authority/types').ClassProp) | undefined) => string;
-export interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+import { type ButtonHTMLAttributes, type ForwardRefExoticComponent, type RefAttributes } from "react";
+export interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+	variant?: "primary" | "secondary" | "ghost" | "danger" | "outline";
+	size?: "sm" | "md" | "lg";
 }
-export declare const Button: import('react').ForwardRefExoticComponent<ButtonProps & import('react').RefAttributes<HTMLButtonElement>>;
-export {};
+export declare const Button: ForwardRefExoticComponent<ButtonProps & RefAttributes<HTMLButtonElement>>;

package/dist/primitives/card.d.ts

@@ -1,9 +1,5 @@
-import { HTMLAttributes } from 'react';
-import { VariantProps } from 'class-variance-authority';
-declare const cardVariants: (props?: ({
-    variant?: "flat" | "bordered" | null | undefined;
-} & import('class-variance-authority/types').ClassProp) | undefined) => string;
-export interface CardProps extends HTMLAttributes<HTMLDivElement>, VariantProps<typeof cardVariants> {
+import { type HTMLAttributes, type ForwardRefExoticComponent, type RefAttributes } from "react";
+export interface CardProps extends HTMLAttributes<HTMLDivElement> {
+	variant?: "flat" | "bordered";
 }
-export declare const Card: import('react').ForwardRefExoticComponent<CardProps & import('react').RefAttributes<HTMLDivElement>>;
-export {};
+export declare const Card: ForwardRefExoticComponent<CardProps & RefAttributes<HTMLDivElement>>;

package/dist/primitives/checkbox.d.ts

@@ -1,4 +1,3 @@
-import { InputHTMLAttributes } from 'react';
-export interface CheckboxProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'type'> {
-}
-export declare const Checkbox: import('react').ForwardRefExoticComponent<CheckboxProps & import('react').RefAttributes<HTMLInputElement>>;
+import { type InputHTMLAttributes, type ForwardRefExoticComponent, type RefAttributes } from "react";
+export interface CheckboxProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "type"> {}
+export declare const Checkbox: ForwardRefExoticComponent<CheckboxProps & RefAttributes<HTMLInputElement>>;

package/dist/primitives/collapsible-card.d.ts

@@ -1,15 +1,25 @@
-import { ReactNode } from 'react';
+/**
+* CollapsibleCard — neutral card with a clickable header + optional
+* expanded body. Same visual language as `FormBuilder` sections so
+* every settings-style container in the app shares one style
+* (`rounded-lg border border-border bg-surface`, no shadow, no
+* coloured left accent).
+*
+* Used by `PipelineStep`; reusable for any "click to expand" settings
+* row where we want FormBuilder-matching chrome.
+*/
+import { type ReactNode, type JSX } from "react";
 export interface CollapsibleCardProps {
-    readonly expanded: boolean;
-    readonly onExpandedChange: (next: boolean) => void;
-    /** Rendered inside the clickable header row, to the right of the chevron. */
-    readonly header: ReactNode;
-    /** Expanded body — rendered below a subtle divider when `expanded === true`. */
-    readonly children?: ReactNode;
-    /** Dims the entire card — for steps flagged as disabled/inactive. */
-    readonly dimmed?: boolean;
-    /** Hide the chevron (header still click-toggles). Useful for always-expanded views. */
-    readonly hideChevron?: boolean;
-    readonly className?: string;
+	readonly expanded: boolean;
+	readonly onExpandedChange: (next: boolean) => void;
+	/** Rendered inside the clickable header row, to the right of the chevron. */
+	readonly header: ReactNode;
+	/** Expanded body — rendered below a subtle divider when `expanded === true`. */
+	readonly children?: ReactNode;
+	/** Dims the entire card — for steps flagged as disabled/inactive. */
+	readonly dimmed?: boolean;
+	/** Hide the chevron (header still click-toggles). Useful for always-expanded views. */
+	readonly hideChevron?: boolean;
+	readonly className?: string;
 }
-export declare function CollapsibleCard({ expanded, onExpandedChange, header, children, dimmed, hideChevron, className, }: CollapsibleCardProps): import("react").JSX.Element;
+export declare function CollapsibleCard({ expanded, onExpandedChange, header, children, dimmed, hideChevron, className }: CollapsibleCardProps): JSX.Element;

package/dist/primitives/dialog.d.ts

@@ -1,65 +1,39 @@
-import { HTMLAttributes, ReactNode } from 'react';
-import { VariantProps } from 'class-variance-authority';
+import { type JSX, type HTMLAttributes, type ReactNode, type ForwardRefExoticComponent, type RefAttributes } from "react";
 interface DialogProps {
-    children: ReactNode;
-    open?: boolean;
-    onOpenChange?: (open: boolean) => void;
+	children: ReactNode;
+	open?: boolean;
+	onOpenChange?: (open: boolean) => void;
 }
-export declare function Dialog({ children, open: controlledOpen, onOpenChange }: DialogProps): import("react").JSX.Element;
-export declare function DialogTrigger({ children, ...props }: HTMLAttributes<HTMLButtonElement>): import("react").JSX.Element;
-/**
- * A native <dialog> opened with showModal() is promoted to the top layer, so
- * ancestor transform/overflow can't clip it — but it relies on the UA
- * stylesheet's `dialog { margin: auto }` for modal centering. Tailwind's
- * preflight resets `margin: 0` on every element, which defeats that centering
- * and pins the modal to the top-left. We therefore center deterministically:
- * a top-layer dialog with `position: fixed` is viewport-relative, and a
- * self-transform is fine, so `fixed left-1/2 top-1/2 -translate-x-1/2
- * -translate-y-1/2 m-0` always centers regardless of any margin reset. Width
- * is capped to the viewport (`w-[calc(100vw-2rem)]`) rather than a bare
- * `w-full` (which would overflow/clip a centered dialog); the per-variant
- * `max-w-*` keeps small dialogs small while the cap prevents overflow.
- *
- * Height is capped against the SAFE viewport, not the raw one. A top-layer
- * `fixed` dialog is viewport-relative, and under `viewport-fit=cover` the
- * viewport extends behind the iOS notch/Dynamic Island and home indicator —
- * so a dialog tall enough to hit its `max-h` put its header under the clock.
- * Because the box is centred on the viewport (not on the safe area), the cap
- * has to subtract TWICE the LARGER of the two insets for the box to clear
- * both edges; using each inset once would still overflow the taller side
- * whenever they are asymmetric (they are: ~59px top vs ~34px bottom). Every
- * term collapses to the previous `100dvh - 2rem` where the insets are 0.
- */
-declare const contentVariants: (props?: ({
-    width?: "sm" | "md" | "lg" | null | undefined;
-    scroll?: "content" | "body" | null | undefined;
-    placement?: "center" | "sheet-on-mobile" | null | undefined;
-} & import('class-variance-authority/types').ClassProp) | undefined) => string;
-export type DialogPlacement = NonNullable<VariantProps<typeof contentVariants>['placement']>;
-export interface DialogContentProps extends HTMLAttributes<HTMLDialogElement>, VariantProps<typeof contentVariants> {
+export declare function Dialog({ children, open: controlledOpen, onOpenChange }: DialogProps): JSX.Element;
+export declare function DialogTrigger({ children, ...props }: HTMLAttributes<HTMLButtonElement>): JSX.Element;
+export interface DialogContentProps extends HTMLAttributes<HTMLDialogElement> {
+	width?: "sm" | "md" | "lg";
+	scroll?: "content" | "body";
+	placement?: "center" | "sheet-on-mobile";
 }
-export declare const DialogContent: import('react').ForwardRefExoticComponent<DialogContentProps & import('react').RefAttributes<HTMLDialogElement>>;
+export type DialogPlacement = NonNullable<DialogContentProps["placement"]>;
+export declare const DialogContent: ForwardRefExoticComponent<DialogContentProps & RefAttributes<HTMLDialogElement>>;
 /** `shrink-0` is inert outside a flex column and load-bearing inside one:
- *  under `scroll="body"` the header must keep its height while the body gives
- *  ground, or a long form squeezes its own title to nothing. */
-export declare function DialogHeader({ className, ...props }: HTMLAttributes<HTMLDivElement>): import("react").JSX.Element;
+*  under `scroll="body"` the header must keep its height while the body gives
+*  ground, or a long form squeezes its own title to nothing. */
+export declare function DialogHeader({ className, ...props }: HTMLAttributes<HTMLDivElement>): JSX.Element;
 /**
- * The scrolling middle of a `scroll="body"` dialog.
- *
- * `min-h-0` is what makes it work: a flex item's default `min-height: auto`
- * refuses to shrink below its content, so without it the body pushes the
- * footer out of the dialog instead of scrolling — the exact failure this
- * variant exists to remove. Anything sticky INSIDE a dialog body pins against
- * this element, since it is the scroll container.
- *
- * It only bounds a scroll area if every ancestor up to the dialog has a
- * resolved height. `DialogContent` supplies the top of that chain (see the
- * `scroll: 'body'` compound variants); an intermediate wrapper between them —
- * a `<Tabs>` that owns the tab strip, say — must carry `flex-1 min-h-0` too,
- * or it collapses and takes the body with it.
- */
-export declare function DialogBody({ className, ...props }: HTMLAttributes<HTMLDivElement>): import("react").JSX.Element;
-export declare function DialogFooter({ className, ...props }: HTMLAttributes<HTMLDivElement>): import("react").JSX.Element;
-export declare function DialogTitle({ className, ...props }: HTMLAttributes<HTMLHeadingElement>): import("react").JSX.Element;
-export declare function DialogDescription({ className, ...props }: HTMLAttributes<HTMLParagraphElement>): import("react").JSX.Element;
+* The scrolling middle of a `scroll="body"` dialog.
+*
+* `min-h-0` is what makes it work: a flex item's default `min-height: auto`
+* refuses to shrink below its content, so without it the body pushes the
+* footer out of the dialog instead of scrolling — the exact failure this
+* variant exists to remove. Anything sticky INSIDE a dialog body pins against
+* this element, since it is the scroll container.
+*
+* It only bounds a scroll area if every ancestor up to the dialog has a
+* resolved height. `DialogContent` supplies the top of that chain (see the
+* `scroll: 'body'` compound variants); an intermediate wrapper between them —
+* a `<Tabs>` that owns the tab strip, say — must carry `flex-1 min-h-0` too,
+* or it collapses and takes the body with it.
+*/
+export declare function DialogBody({ className, ...props }: HTMLAttributes<HTMLDivElement>): JSX.Element;
+export declare function DialogFooter({ className, ...props }: HTMLAttributes<HTMLDivElement>): JSX.Element;
+export declare function DialogTitle({ className, ...props }: HTMLAttributes<HTMLHeadingElement>): JSX.Element;
+export declare function DialogDescription({ className, ...props }: HTMLAttributes<HTMLParagraphElement>): JSX.Element;
 export {};

package/dist/primitives/dropdown.d.ts

@@ -1,19 +1,19 @@
-import { ButtonHTMLAttributes, HTMLAttributes, ReactNode } from 'react';
-import { LucideIcon } from 'lucide-react';
+import { type JSX, type ButtonHTMLAttributes, type HTMLAttributes, type ReactNode } from "react";
+import { type LucideIcon } from "lucide-react";
 export declare function Dropdown({ children }: {
-    children: ReactNode;
-}): import("react").JSX.Element;
-export declare function DropdownTrigger({ children, ...props }: ButtonHTMLAttributes<HTMLButtonElement>): import("react").JSX.Element;
+	children: ReactNode;
+}): JSX.Element | null;
+export declare function DropdownTrigger({ children, ...props }: ButtonHTMLAttributes<HTMLButtonElement>): JSX.Element | null;
 interface DropdownContentProps extends HTMLAttributes<HTMLDivElement> {
-    /** Horizontal alignment relative to the trigger. Default: 'start' (left-aligned). */
-    align?: 'start' | 'end';
-    /** Pixel offset between trigger and content. Default: 4. */
-    offset?: number;
+	/** Horizontal alignment relative to the trigger. Default: 'start' (left-aligned). */
+	align?: "start" | "end";
+	/** Pixel offset between trigger and content. Default: 4. */
+	offset?: number;
 }
-export declare function DropdownContent({ className, children, align, offset, ...props }: DropdownContentProps): import('react').ReactPortal | null;
+export declare function DropdownContent({ className, children, align, offset, ...props }: DropdownContentProps): JSX.Element | null;
 interface DropdownItemProps extends ButtonHTMLAttributes<HTMLButtonElement> {
-    icon?: LucideIcon;
-    variant?: 'default' | 'danger';
+	icon?: LucideIcon;
+	variant?: "default" | "danger";
 }
-export declare function DropdownItem({ className, icon: Icon, variant, children, onClick, ...props }: DropdownItemProps): import("react").JSX.Element;
+export declare function DropdownItem({ className, icon: Icon, variant, children, onClick, ...props }: DropdownItemProps): JSX.Element | null;
 export {};

package/dist/primitives/floating-panel.d.ts

@@ -1,22 +1,43 @@
-import { ReactNode } from 'react';
+import { type ReactNode, type JSX } from "react";
+import { type LucideIcon } from "lucide-react";
+export interface FloatingPanelPosition {
+	readonly x: number;
+	readonly y: number;
+}
+export interface FloatingPanelSize {
+	readonly w: number;
+	readonly h: number;
+}
 export interface FloatingPanelProps {
-    /** Panel title displayed in the title bar */
-    title: string;
-    /** Called when the close button is clicked */
-    onClose: () => void;
-    /** Panel content */
-    children: ReactNode;
-    /** Default width in pixels */
-    defaultWidth?: number;
-    /** Default height in pixels */
-    defaultHeight?: number;
-    /** Minimum width in pixels */
-    minWidth?: number;
-    /** Minimum height in pixels */
-    minHeight?: number;
-    /** Offset index to stagger multiple panels (adds 30px offset per index) */
-    offsetIndex?: number;
-    /** Additional CSS classes for the panel container */
-    className?: string;
+	/** Panel title displayed in the title bar */
+	title: string;
+	/** Optional icon shown before the title */
+	icon?: LucideIcon;
+	/**
+	* Controlled position. When set, the owner holds the position (so it can
+	* survive the panel being unmounted on close) and receives every drag step
+	* through `onPositionChange`. Leave unset for an uncontrolled panel.
+	*/
+	position?: FloatingPanelPosition;
+	onPositionChange?: (position: FloatingPanelPosition) => void;
+	/** Controlled size, same contract as `position` (resize via the corner handle). */
+	size?: FloatingPanelSize;
+	onSizeChange?: (size: FloatingPanelSize) => void;
+	/** Called when the close button is clicked */
+	onClose: () => void;
+	/** Panel content */
+	children: ReactNode;
+	/** Default width in pixels */
+	defaultWidth?: number;
+	/** Default height in pixels */
+	defaultHeight?: number;
+	/** Minimum width in pixels */
+	minWidth?: number;
+	/** Minimum height in pixels */
+	minHeight?: number;
+	/** Offset index to stagger multiple panels (adds 30px offset per index) */
+	offsetIndex?: number;
+	/** Additional CSS classes for the panel container */
+	className?: string;
 }
-export declare function FloatingPanel({ title, onClose, children, defaultWidth, defaultHeight, minWidth, minHeight, offsetIndex, className, }: FloatingPanelProps): import("react").JSX.Element;
+export declare function FloatingPanel({ title, icon: Icon, position, onPositionChange, size: controlledSize, onSizeChange, onClose, children, defaultWidth, defaultHeight, minWidth, minHeight, offsetIndex, className }: FloatingPanelProps): JSX.Element;

package/dist/primitives/icon-button.d.ts

@@ -1,13 +1,9 @@
-import { ButtonHTMLAttributes } from 'react';
-import { VariantProps } from 'class-variance-authority';
-import { LucideIcon } from 'lucide-react';
-declare const iconButtonVariants: (props?: ({
-    variant?: "primary" | "secondary" | "ghost" | "danger" | "outline" | null | undefined;
-    size?: "sm" | "md" | "lg" | null | undefined;
-} & import('class-variance-authority/types').ClassProp) | undefined) => string;
-export interface IconButtonProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'children'>, VariantProps<typeof iconButtonVariants> {
-    icon: LucideIcon;
-    'aria-label': string;
+import { type ButtonHTMLAttributes, type ForwardRefExoticComponent, type RefAttributes } from "react";
+import { type LucideIcon } from "lucide-react";
+export interface IconButtonProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, "children"> {
+	variant?: "primary" | "secondary" | "ghost" | "danger" | "outline";
+	size?: "sm" | "md" | "lg";
+	icon: LucideIcon;
+	"aria-label": string;
 }
-export declare const IconButton: import('react').ForwardRefExoticComponent<IconButtonProps & import('react').RefAttributes<HTMLButtonElement>>;
-export {};
+export declare const IconButton: ForwardRefExoticComponent<IconButtonProps & RefAttributes<HTMLButtonElement>>;